k18-ntcs-web-ntc/src/main/java/com/nis/web/controller/BaseController.java

package com.nis.web.controller;

import java.beans.PropertyEditorSupport;
import java.io.IOException;
import java.net.URLEncoder;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Properties;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.apache.commons.lang3.StringEscapeUtils;
import org.apache.commons.lang3.StringUtils;
import org.apache.log4j.Logger;
import org.jets3t.service.ServiceException;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.i18n.LocaleContextHolder;
import org.springframework.ui.Model;
import org.springframework.web.bind.WebDataBinder;
import org.springframework.web.bind.annotation.InitBinder;
import org.springframework.web.multipart.MultipartFile;
import org.springframework.web.servlet.mvc.support.RedirectAttributes;

import com.beust.jcommander.internal.Lists;
import com.nis.domain.FunctionRegionDict;
import com.nis.domain.FunctionServiceDict;
import com.nis.domain.Page;
import com.nis.domain.SysDataDictionaryItem;
import com.nis.domain.basics.AsnGroupInfo;
import com.nis.domain.basics.AsnIpCfg;
import com.nis.domain.basics.ServiceDictInfo;
import com.nis.domain.basics.SysDictInfo;
import com.nis.domain.configuration.AppComplexFeatureCfg;
import com.nis.domain.configuration.AppDomainCfg;
import com.nis.domain.configuration.AppFeatureIndex;
import com.nis.domain.configuration.AppHttpCfg;
import com.nis.domain.configuration.AppIpCfg;
import com.nis.domain.configuration.AppPolicyCfg;
import com.nis.domain.configuration.AppSslCertCfg;
import com.nis.domain.configuration.AppTopicDomainCfg;
import com.nis.domain.configuration.AreaBean;
import com.nis.domain.configuration.AreaIpCfg;
import com.nis.domain.configuration.AvFileSampleCfg;
import com.nis.domain.configuration.AvSignSampleCfg;
import com.nis.domain.configuration.BaseCfg;
import com.nis.domain.configuration.BaseIpCfg;
import com.nis.domain.configuration.BaseStringCfg;
import com.nis.domain.configuration.CfgIndexInfo;
import com.nis.domain.configuration.ComplexkeywordCfg;
import com.nis.domain.configuration.DdosIpCfg;
import com.nis.domain.configuration.DnsIpCfg;
import com.nis.domain.configuration.DnsResStrategy;
import com.nis.domain.configuration.FileDigestCfg;
import com.nis.domain.configuration.IpPortCfg;
import com.nis.domain.configuration.PxyObjKeyring;
import com.nis.domain.configuration.PxyObjTrustedCaCert;
import com.nis.domain.configuration.PxyObjTrustedCaCrl;
import com.nis.domain.configuration.RequestInfo;
import com.nis.domain.configuration.template.AppDomainTemplate;
import com.nis.domain.configuration.template.AppPayloadTemplate;
import com.nis.domain.configuration.template.AsnIpTemplate;
import com.nis.domain.configuration.template.ComplexStringAllNotDoLogTemplate;
import com.nis.domain.configuration.template.ComplexStringAllTemplate;
import com.nis.domain.configuration.template.DdosIpTemplate;
import com.nis.domain.configuration.template.DnsComplexStringTemplate;
import com.nis.domain.configuration.template.DnsFakeIpTemplate;
import com.nis.domain.configuration.template.DnsIpTemplate;
import com.nis.domain.configuration.template.DnsResStrategyTemplate;
import com.nis.domain.configuration.template.DomainInterceptMonitTemplate;
import com.nis.domain.configuration.template.DomainInterceptRateLimitTemplate;
import com.nis.domain.configuration.template.DomainInterceptTemplate;
import com.nis.domain.configuration.template.HttpsRedirectComplexTemplate;
import com.nis.domain.configuration.template.HttpsRedirectIpTemplate;
import com.nis.domain.configuration.template.HttpsRedirectTemplate;
import com.nis.domain.configuration.template.HttpsRejectComplexTemplate;
import com.nis.domain.configuration.template.HttpsRejectIpTemplate;
import com.nis.domain.configuration.template.HttpsRejectTemplate;
import com.nis.domain.configuration.template.HttpsReplaceComplexTemplate;
import com.nis.domain.configuration.template.HttpsReplaceIpTemplate;
import com.nis.domain.configuration.template.HttpsReplaceTemplate;
import com.nis.domain.configuration.template.IpAllNotDoLogTemplate;
import com.nis.domain.configuration.template.IpAllTemplate;
import com.nis.domain.configuration.template.IpPayloadTemplate;
import com.nis.domain.configuration.template.IpRateLimitTemplate;
import com.nis.domain.configuration.template.IpSpoofingTemplate;
import com.nis.domain.configuration.template.IpWhitelistTemplate;
import com.nis.domain.configuration.template.P2pHashStringTemplate;
import com.nis.domain.configuration.template.P2pIpTemplate;
import com.nis.domain.configuration.template.StringAllNotDoLogTemplate;
import com.nis.domain.configuration.template.StringAllTemplate;
import com.nis.domain.configuration.template.TopicWebsiteTemplate;
import com.nis.domain.log.BaseLogEntity;
import com.nis.domain.log.SearchReport;
import com.nis.domain.maat.MaatCfg;
import com.nis.domain.maat.MaatCfg.DigestCfg;
import com.nis.domain.maat.MaatCfg.GroupCfg;
import com.nis.domain.maat.MaatCfg.IpCfg;
import com.nis.domain.maat.MaatCfg.NumBoundaryCfg;
import com.nis.domain.maat.MaatCfg.StringCfg;
import com.nis.domain.maat.ToMaatBean;
import com.nis.domain.report.NtcPzReport;
import com.nis.domain.specific.ConfigGroupInfo;
import com.nis.domain.specific.SpecificServiceCfg;
import com.nis.exceptions.MaatConvertException;
//import com.nis.util.AsnCacheUtils;
import com.nis.util.ConfigServiceUtil;
import com.nis.util.Configurations;
//import com.nis.main.ConvertTool;
import com.nis.util.Constants;
import com.nis.util.DateUtils;
import com.nis.util.DictUtils;
import com.nis.util.JsonMapper;
import com.nis.util.Reflections;
import com.nis.util.ServiceConfigTemplateUtil;
import com.nis.util.StringUtil;
import com.nis.util.excel.ExcelCsv;
import com.nis.util.excel.ExportExcel;
import com.nis.util.excel.ImportBigExcel;
import com.nis.util.excel.thread.CheckAppFeatureComplexStringFormatThread;
import com.nis.util.excel.thread.CheckComplexStringFormatThread;
import com.nis.util.excel.thread.CheckDnsResStrategyFormatThread;
import com.nis.util.excel.thread.CheckIpFormatThread;
import com.nis.util.excel.thread.CheckStringFormatThread;
import com.nis.util.excel.thread.CheckTopicWebsiteFormatThread;
import com.nis.web.security.UserUtils;
import com.nis.web.service.ArchiveServcie;
import com.nis.web.service.AreaService;
import com.nis.web.service.BaseService;
import com.nis.web.service.DictService;
import com.nis.web.service.LogService;
import com.nis.web.service.MenuService;
import com.nis.web.service.OfficeService;
import com.nis.web.service.RoleService;
import com.nis.web.service.SystemService;
import com.nis.web.service.UserService;
import com.nis.web.service.basics.AsnGroupInfoService;
import com.nis.web.service.basics.AsnIpCfgService;
import com.nis.web.service.basics.InnerProtectionListService;
import com.nis.web.service.basics.IpReuseIpCfgService;
import com.nis.web.service.basics.PolicyGroupInfoService;
import com.nis.web.service.basics.ServiceDictInfoService;
import com.nis.web.service.basics.SysDictInfoService;
import com.nis.web.service.configuration.AppBuiltInFeatureService;
import com.nis.web.service.configuration.AppCfgService;
import com.nis.web.service.configuration.AppMultiFeatureCfgService;
import com.nis.web.service.configuration.AsnPolicyCfgService;
import com.nis.web.service.configuration.AvCfgService;
import com.nis.web.service.configuration.AvContentCfgService;
import com.nis.web.service.configuration.BgpCfgService;
import com.nis.web.service.configuration.CachePolicyService;
import com.nis.web.service.configuration.CommonPolicyService;
import com.nis.web.service.configuration.ComplexStringCfgService;
import com.nis.web.service.configuration.ConfigSynchronizationService;
import com.nis.web.service.configuration.ControlPolicyService;
import com.nis.web.service.configuration.DdosCfgService;
import com.nis.web.service.configuration.DnsIpCfgService;
import com.nis.web.service.configuration.DnsResStrategyService;
import com.nis.web.service.configuration.DomainService;
import com.nis.web.service.configuration.FileTransferCfgService;
import com.nis.web.service.configuration.GroupAreaService;
import com.nis.web.service.configuration.HttpRedirectCfgService;
import com.nis.web.service.configuration.InterceptCfgService;
import com.nis.web.service.configuration.IpAddrPoolCfgService;
import com.nis.web.service.configuration.IpCfgService;
import com.nis.web.service.configuration.IpMultiplexPoolCfgService;
import com.nis.web.service.configuration.MailCfgService;
import com.nis.web.service.configuration.NumCfgService;
import com.nis.web.service.configuration.ProxyFileStrategyService;
import com.nis.web.service.configuration.PxyObjKeyringService;
import com.nis.web.service.configuration.PxyObjSpoofingIpPoolService;
import com.nis.web.service.configuration.RequestInfoService;
import com.nis.web.service.configuration.UserManageService;
import com.nis.web.service.configuration.WebsiteCfgService;
import com.nis.web.service.configuration.XmppCfgService;
import com.nis.web.service.configuration.statistics.ConfigureStatisticsService;
import com.nis.web.service.specific.ConfigGroupInfoService;
import com.nis.web.service.specific.SpecificServiceCfgService;
import com.nis.web.service.specific.SpecificServiceHostCfgService;
import com.nis.web.service.systemService.ServiceConfigInfoService;

import jersey.repackaged.com.google.common.collect.Maps;
import net.sf.json.JSONArray;
import net.sf.json.JSONObject;
import net.sf.json.JsonConfig;

public class BaseController {

	@Autowired
	protected UserService userService;

	@Autowired
	protected SystemService systemService;

	@Autowired
	protected OfficeService officeService;

	@Autowired
	protected AreaService areaService;

	@Autowired
	protected RoleService roleService;

	@Autowired
	protected MenuService menuService;

	@Autowired
	protected LogService logService;

	@Autowired
	protected ArchiveServcie archiveServcie;

	@Autowired
	protected DictService dictService;

	@Autowired
	protected IpCfgService ipCfgService;

	@Autowired
	protected DnsIpCfgService dnsIpCfgService;

	@Autowired
	protected MailCfgService mailCfgService;

	@Autowired
	protected FileTransferCfgService fileTransferCfgService;

	@Autowired
	protected AppCfgService appCfgService;
	@Autowired
	protected ControlPolicyService controlPolicyService;

	@Autowired
	protected ServiceDictInfoService serviceDictInfoService;

	@Autowired
	protected SysDictInfoService sysDictInfoService;

	protected final Logger logger = Logger.getLogger(this.getClass());

	@Autowired
	protected ServiceConfigInfoService serviceConfigInfoService;

	@Autowired
	protected RequestInfoService requestInfoService;
	@Autowired
	protected DomainService domainService;
	@Autowired
	protected NumCfgService numCfgService;
	@Autowired
	protected ComplexStringCfgService complexStringCfgService;
	@Autowired
	protected SpecificServiceCfgService specificServiceCfgService;
	@Autowired
	protected SpecificServiceHostCfgService specificServiceHostCfgService;
	@Autowired
	protected AvCfgService avCfgService;
	@Autowired
	protected AvContentCfgService avContentCfgService;
	@Autowired
	protected WebsiteCfgService websiteCfgService;
	@Autowired
	protected BgpCfgService bgpCfgService;
	@Autowired
	protected XmppCfgService xmppCfgService;
	@Autowired
	protected PolicyGroupInfoService policyGroupInfoService;
	@Autowired
	protected DnsResStrategyService dnsResStrategyService;
	@Autowired
	protected HttpRedirectCfgService httpRedirectCfgService;
	@Autowired
	protected DdosCfgService ddosCfgService;
	@Autowired
	protected IpMultiplexPoolCfgService ipMultiplexPoolCfgService;
	@Autowired
	protected ConfigureStatisticsService configureStatisticsService;
	@Autowired
	protected InterceptCfgService interceptCfgService;
	@Autowired
	protected ProxyFileStrategyService proxyFileStrategyService;// 代理文件策略service
	@Autowired
	protected PxyObjKeyringService pxyObjKeyringService;// 拦截策略service
	@Autowired
	protected AppBuiltInFeatureService appBuiltInFeatureService;// 拦截策略service
	@Autowired
	protected AsnIpCfgService asnIpCfgService;// asn ip service
	@Autowired
	protected AsnPolicyCfgService asnPolicyCfgService;// asn 策略 service
	@Autowired
	protected AppMultiFeatureCfgService appMultiFeatureCfgService;
	@Autowired
	protected GroupAreaService groupAreaService;// 分组区域管理 service
	//@Autowired
	//protected ConfigGroupInfoService configGroupInfoService;
	@Autowired
	protected ConfigSynchronizationService configSynchronizationService;
	@Autowired
	protected CachePolicyService cachePolicyService;
	@Autowired
	protected CommonPolicyService commonPolicyService;
	
	@Autowired
	protected UserManageService userManageService;
	@Autowired
	protected IpReuseIpCfgService ipReuseIpCfgService;
	@Autowired
	protected IpAddrPoolCfgService ipAddrPoolCfgService;// 地址池管理service
	@Autowired
	protected ConfigGroupInfoService configGroupInfoService;// 分组复用

	@Autowired
	protected PxyObjSpoofingIpPoolService pxyObjSpoofingIpPoolService;// 欺骗IP池
	@Autowired
	protected AsnGroupInfoService asnGroupInfoService;// asn组
	@Autowired
	protected InnerProtectionListService innerProtectionListService;
	/**
	 * 管理基础路径
	 */
	@Value("${adminPath}")
	protected String adminPath;

	/**
	 * 前端基础路径
	 */
	@Value("${frontPath}")
	protected String frontPath;
	/**
	 * 前端URL后缀
	 */
	@Value("${urlSuffix}")
	protected String urlSuffix;

	/**
	 * 客户端返回JSON字符串
	 * 
	 * @param response
	 * @param object
	 * @return
	 */
	protected String renderString(HttpServletResponse response, Object object) {
		return renderString(response, JsonMapper.toJsonString(object), "application/json");
	}

	/**
	 * 客户端返回字符串
	 * 
	 * @param response
	 * @param string
	 * @return
	 */
	protected String renderString(HttpServletResponse response, String string, String type) {
		try {
			response.reset();
			response.setContentType(type);
			response.setCharacterEncoding("utf-8");
			response.getWriter().print(string);
			return null;
		} catch (IOException e) {
			return null;
		}
	}

	/**
	 * 添加Model消息
	 * 
	 * @param message
	 */
	protected void addMessage(Model model, String... messages) {
		StringBuilder sb = new StringBuilder();
		for (String message : messages) {
			sb.append(message).append(messages.length > 1 ? "<br/>" : "");
		}
		model.addAttribute("message", sb.toString());
	}

	/**
	 * 添加Model消息
	 * 
	 * @param message
	 * @param messageType 消息类型：info、success、warning、error、loading
	 */
	protected void addMessage(String messageType,Model model,String... messages) {
		StringBuilder sb = new StringBuilder();
		for (String message : messages) {
			sb.append(message).append(messages.length > 1 ? "<br/>" : "");
		}
		model.addAttribute("message", sb.toString());
		model.addAttribute("messageType", messageType);
	}
	/**
	 * 添加Model消息 日志用
	 * 
	 * @param message
	 */
	protected void addMessageLog(Model model, String status) {
		// status 接口状态码
		String messages = "search_error";
		if (null != status) {
			if ("400".equals(status)) {
				messages = "data_format_error";
			} else if ("500".equals(status)) {
				messages = "server_internal_error";
			} else if (status.indexOf("request_service_failed") != -1) {
				messages = "server_internal_error";
			}
		}
		model.addAttribute("message", messages);
	}

	/**
	 * 添加Flash消息
	 * 
	 * @param message
	 * @param messageType 消息类型：info、success、warning、error、loading
	 */
	protected void addMessage(RedirectAttributes redirectAttributes,String messageType, String... messages) {
		StringBuilder sb = new StringBuilder();
		for (String message : messages) {
			sb.append(message).append(messages.length > 1 ? "<br/>" : "");
		}
		redirectAttributes.addFlashAttribute("message", sb.toString());
		redirectAttributes.addFlashAttribute("messageType", messageType);
	}

	/**
	 * 初始化数据绑定 1. 将所有传递进来的String进行HTML编码，防止XSS攻击 2. 将字段中Date类型转换为String类型
	 */
	@InitBinder
	protected void initBinder(WebDataBinder binder) {
		// String类型转换，将所有传递进来的String进行HTML编码，防止XSS攻击
		binder.registerCustomEditor(String.class, new PropertyEditorSupport() {
			@Override
			public void setAsText(String text) {
				setValue(text == null ? null : StringEscapeUtils.escapeHtml4(text.trim()));
			}

			@Override
			public String getAsText() {
				Object value = getValue();
				return value != null ? value.toString() : "";
			}
		});
		// Date 类型转换
		binder.registerCustomEditor(Date.class, new PropertyEditorSupport() {
			@Override
			public void setAsText(String text) {
				setValue(DateUtils.parseDate(text));
			}
		});
	}

	protected void initPageCondition(Model model) {
		List<RequestInfo> requestInfos = requestInfoService.getAllRequestInfo();
		model.addAttribute("requestInfos", requestInfos);
		List<ServiceDictInfo> fls = serviceDictInfoService.findAllFlDict();
		String pNames = "";
		for (ServiceDictInfo serviceDictInfo : fls) {
			pNames = "";
			pNames = serviceDictInfo.getPNames(fls, serviceDictInfo.getParent().getServiceDictId(), pNames);
			serviceDictInfo.setpNames(pNames);
		}
		model.addAttribute("fls", fls);
		List<ServiceDictInfo> xzs = serviceDictInfoService.findAllXzDict();
		for (ServiceDictInfo serviceDictInfo : xzs) {
			pNames = "";
			pNames = serviceDictInfo.getPNames(xzs, serviceDictInfo.getParent().getServiceDictId(), pNames);
			serviceDictInfo.setpNames(pNames);
		}
		model.addAttribute("xzs", xzs);
		List<ServiceDictInfo> lables = serviceDictInfoService.findAllLableDict();
		for (ServiceDictInfo serviceDictInfo : lables) {
			pNames = "";
			pNames = serviceDictInfo.getPNames(lables, serviceDictInfo.getParent().getServiceDictId(), pNames);
			serviceDictInfo.setpNames(pNames);
		}
		model.addAttribute("lables", lables);
	}

	protected void initPageCondition(Model model, BaseCfg cfg) {
		List<RequestInfo> requestInfos = requestInfoService.getAllRequestInfo();
		model.addAttribute("requestInfos", requestInfos);
		List<ServiceDictInfo> fls = serviceDictInfoService.findAllFlDict();
		String pNames = "";
		/*
		 * for (ServiceDictInfo serviceDictInfo : fls) { pNames = ""; pNames =
		 * serviceDictInfo.getPNames(fls,
		 * serviceDictInfo.getParent().getServiceDictId(), pNames);
		 * serviceDictInfo.setpNames(pNames); }
		 */
		model.addAttribute("fls", fls);
		List<ServiceDictInfo> xzs = serviceDictInfoService.findAllXzDict();
		/*
		 * for (ServiceDictInfo serviceDictInfo : xzs) { pNames = ""; pNames =
		 * serviceDictInfo.getPNames(xzs,
		 * serviceDictInfo.getParent().getServiceDictId(), pNames);
		 * serviceDictInfo.setpNames(pNames); }
		 */
		model.addAttribute("xzs", xzs);
		List<ServiceDictInfo> lables = serviceDictInfoService.findAllLableDict();
		/*
		 * for (ServiceDictInfo serviceDictInfo : lables) { pNames = ""; pNames =
		 * serviceDictInfo.getPNames(lables,
		 * serviceDictInfo.getParent().getServiceDictId(), pNames);
		 * serviceDictInfo.setpNames(pNames); }
		 */
		model.addAttribute("lables", lables);
		List<FunctionRegionDict> regionList = DictUtils.getFunctionRegionDictList(cfg.getFunctionId());
		model.addAttribute("regionList", regionList);
		List<FunctionServiceDict> serviceList = DictUtils.getFunctionServiceDictList(cfg.getFunctionId());
		model.addAttribute("serviceList", serviceList);
	}

	protected void initReportCondition(Model model, SearchReport report) {
		List<FunctionServiceDict> serviceList = DictUtils.getFunctionServiceDictList(report.getFunctionId());
		// HTTP +keyword
		if(report.getFunctionId() == 8){
			serviceList.addAll(DictUtils.getFunctionServiceDictList(635));
		}
		model.addAttribute("serviceList", serviceList);
		
		if (StringUtils.isBlank(report.getReportTime())) {
			report.setReportTime(DateUtils.formatDate(new Date(), "yyyy-MM-dd"));
		}
		if (report.getReportType() == null) {
			report.setReportType(1);
		}
	}

	protected void initFormCondition(Model model) {
		List<RequestInfo> requestInfos = requestInfoService.getValidRequestInfo();
		model.addAttribute("requestInfos", requestInfos);
		List<ServiceDictInfo> fls = serviceDictInfoService.findFlDict();
		String pNames = "";
		/*
		 * for (ServiceDictInfo serviceDictInfo : fls) { pNames = ""; pNames =
		 * serviceDictInfo.getPNames(fls,
		 * serviceDictInfo.getParent().getServiceDictId(), pNames);
		 * serviceDictInfo.setpNames(pNames); }
		 */
		model.addAttribute("fls", fls);
		List<ServiceDictInfo> xzs = serviceDictInfoService.findXzDict();
		/*
		 * for (ServiceDictInfo serviceDictInfo : xzs) { pNames = ""; pNames =
		 * serviceDictInfo.getPNames(xzs,
		 * serviceDictInfo.getParent().getServiceDictId(), pNames);
		 * serviceDictInfo.setpNames(pNames); }
		 */
		model.addAttribute("xzs", xzs);
		List<ServiceDictInfo> lables = serviceDictInfoService.findLableDict();
		/*
		 * for (ServiceDictInfo serviceDictInfo : lables) { pNames = ""; pNames =
		 * serviceDictInfo.getPNames(lables,
		 * serviceDictInfo.getParent().getServiceDictId(), pNames);
		 * serviceDictInfo.setpNames(pNames); }
		 */
		model.addAttribute("lables", lables);
		List<Integer> itTypeList = new ArrayList<Integer>();
		itTypeList.add(Constants.ITEM_TYPE_AREA);
		List<SysDictInfo> areas = sysDictInfoService.findAllSysDictInfo(new SysDictInfo(), itTypeList, null);
		model.addAttribute("areas", areas);
		itTypeList.clear();
		itTypeList.add(Constants.ITEM_TYPE_ISP);
		List<SysDictInfo> isps = sysDictInfoService.findAllSysDictInfo(new SysDictInfo(), itTypeList, null);
		model.addAttribute("isps", isps);
		// 初始化一个默认的地域ip给界面
		AreaIpCfg areaIpCfg = new AreaIpCfg();
		areaIpCfg.initDefaultValue();
		model.addAttribute("_areaCfg", areaIpCfg);
	}

	protected void initFormCondition(Model model, BaseCfg cfg) {
		List<RequestInfo> requestInfos = requestInfoService.getValidRequestInfo();
		model.addAttribute("requestInfos", requestInfos);
		List<ServiceDictInfo> fls = serviceDictInfoService.findFlDict();
		String pNames = "";
		/*
		 * for (ServiceDictInfo serviceDictInfo : fls) { pNames = ""; pNames =
		 * serviceDictInfo.getPNames(fls,
		 * serviceDictInfo.getParent().getServiceDictId(), pNames);
		 * serviceDictInfo.setpNames(pNames); }
		 */
		model.addAttribute("fls", fls);
		List<ServiceDictInfo> xzs = serviceDictInfoService.findXzDict();
		/*
		 * for (ServiceDictInfo serviceDictInfo : xzs) { pNames = ""; pNames =
		 * serviceDictInfo.getPNames(xzs,
		 * serviceDictInfo.getParent().getServiceDictId(), pNames);
		 * serviceDictInfo.setpNames(pNames); }
		 */
		model.addAttribute("xzs", xzs);
		List<ServiceDictInfo> lables = serviceDictInfoService.findLableDict();
		/*
		 * for (ServiceDictInfo serviceDictInfo : lables) { pNames = ""; pNames =
		 * serviceDictInfo.getPNames(lables,
		 * serviceDictInfo.getParent().getServiceDictId(), pNames);
		 * serviceDictInfo.setpNames(pNames); }
		 */
		model.addAttribute("lables", lables);
		List<Integer> itTypeList = new ArrayList<Integer>();
		itTypeList.add(Constants.ITEM_TYPE_AREA);
		List<SysDictInfo> areas = sysDictInfoService.findAllSysDictInfo(new SysDictInfo(), itTypeList, null);
		model.addAttribute("areas", areas);
		itTypeList.clear();
		itTypeList.add(Constants.ITEM_TYPE_ISP);
		List<SysDictInfo> isps = sysDictInfoService.findAllSysDictInfo(new SysDictInfo(), itTypeList, null);
		model.addAttribute("isps", isps);
		// 初始化一个默认的地域ip给界面
		AreaIpCfg areaIpCfg = new AreaIpCfg();
		areaIpCfg.initDefaultValue();
		model.addAttribute("_areaCfg", areaIpCfg);
		List<FunctionRegionDict> regionList = DictUtils.getFunctionRegionDictList(cfg.getFunctionId());
		model.addAttribute("regionList", regionList);
		List<FunctionServiceDict> serviceList = DictUtils.getFunctionServiceDictList(cfg.getFunctionId());
		model.addAttribute("serviceList", serviceList);
		// ip配置设置protocolId
		if (cfg instanceof BaseIpCfg) {
			for (FunctionServiceDict dict : serviceList) {
				if (cfg.getFunctionId().intValue() == dict.getFunctionId().intValue()) {
					((BaseIpCfg) cfg).setProtocolId(dict.getProtocolId().intValue());
					break;
				}
			}
		}
	}

	protected void initUpdateFormCondition(Model model, BaseCfg cfg) {
		List<Integer> itTypeList = new ArrayList<Integer>();
		itTypeList.add(Constants.ITEM_TYPE_AREA);
		List<SysDictInfo> areas = sysDictInfoService.findAllSysDictInfo(new SysDictInfo(), itTypeList, null);
		model.addAttribute("areas", areas);
		itTypeList.clear();
		itTypeList.add(Constants.ITEM_TYPE_ISP);
		List<SysDictInfo> isps = sysDictInfoService.findAllSysDictInfo(new SysDictInfo(), itTypeList, null);
		model.addAttribute("isps", isps);

		// 查询配置对应的地域ip
		if (cfg.getCompileId() != null) {
			List<AreaIpCfg> areaCfgs = ipCfgService.getAreaCfgByCompileId(cfg.getCompileId());
			model.addAttribute("areaCfgs", areaCfgs);

			StringBuffer areaCfgIds = new StringBuffer();
			for (AreaIpCfg areaCfg : areaCfgs) {
				areaCfgIds.append(areaCfg.getCfgId() + ",");
			}
			// update时判断是否有删除地域ip
			model.addAttribute("areaCfgIds", areaCfgIds.toString());
		}
		// 初始化一个默认的地域ip给界面
		AreaIpCfg areaIpCfg = new AreaIpCfg();
		areaIpCfg.initDefaultValue();
		model.addAttribute("_areaCfg", areaIpCfg);
		// 从区域生效ID中获取区域与运营商
		String areaEffectiveIds = cfg.getAreaEffectiveIds();
		List<AreaBean> areaIspList = new ArrayList<AreaBean>();
		getAreaIsps(areaEffectiveIds, areaIspList, isps, areas);
		model.addAttribute("_areaIsps", areaIspList);
		List<RequestInfo> requestInfos = requestInfoService.getValidRequestInfo();// 只查询有效的
		model.addAttribute("requestInfos", requestInfos);
		List<ServiceDictInfo> fls = serviceDictInfoService.findFlDict();// 只查询有效分类字典
		String pNames = "";
		/*
		 * for (ServiceDictInfo serviceDictInfo : fls) { pNames = ""; pNames =
		 * serviceDictInfo.getPNames(fls,
		 * serviceDictInfo.getParent().getServiceDictId(), pNames);
		 * serviceDictInfo.setpNames(pNames); }
		 */
		model.addAttribute("fls", fls);
		List<ServiceDictInfo> xzs = serviceDictInfoService.findXzDict();// 只查询有效性质字典
		/*
		 * for (ServiceDictInfo serviceDictInfo : xzs) { pNames = ""; pNames =
		 * serviceDictInfo.getPNames(xzs,
		 * serviceDictInfo.getParent().getServiceDictId(), pNames);
		 * serviceDictInfo.setpNames(pNames); }
		 */
		model.addAttribute("xzs", xzs);
		List<ServiceDictInfo> lables = serviceDictInfoService.findLableDict();// 只查询有效标签字典
		/*
		 * for (ServiceDictInfo serviceDictInfo : lables) { pNames = ""; pNames =
		 * serviceDictInfo.getPNames(lables,
		 * serviceDictInfo.getParent().getServiceDictId(), pNames);
		 * serviceDictInfo.setpNames(pNames); }
		 */
		model.addAttribute("lables", lables);
		List<FunctionRegionDict> regionList = DictUtils.getFunctionRegionDictList(cfg.getFunctionId());
		model.addAttribute("regionList", regionList);
		List<FunctionServiceDict> serviceList = DictUtils.getFunctionServiceDictList(cfg.getFunctionId());
		model.addAttribute("serviceList", serviceList);
	}

	public List<AreaBean> getAreaIsps(String areaEffectiveIds, List<AreaBean> areaIspList, List<SysDictInfo> isps,
			List<SysDictInfo> areas) {
		Map<String, SysDictInfo> areaMap = new HashMap<String, SysDictInfo>();
		for (SysDictInfo areaDict : areas) {
			areaMap.put(areaDict.getItemCode(), areaDict);
		}
		Map<String, SysDictInfo> ispMap = new HashMap<String, SysDictInfo>();
		for (SysDictInfo ispDict : isps) {
			ispMap.put(ispDict.getItemCode(), ispDict);
		}

		// ： 存在冒号，则冒号前为area后为isp；不存在冒号，判断id是否为isp，否则为area
		if (StringUtils.isNotBlank(areaEffectiveIds)) {
			String[] areaIsps = areaEffectiveIds.split(",");
			for (String areaIsp : areaIsps) {
				AreaBean area = new AreaBean();
				if (areaIsp.contains(":")) {
					area.setArea(areaIsp.split(":")[0]);
					area.setIsp(areaIsp.split(":")[1]);
					area.setAreaName(areaMap.get(areaIsp.split(":")[0]).getItemValue());
					area.setIspName(ispMap.get(areaIsp.split(":")[1]).getItemValue());
				} else {
					if (ispMap.keySet().contains(areaIsp)) {
						area.setIsp(areaIsp);
						area.setIspName(ispMap.get(areaIsp).getItemValue());
						area.setAreaName("");
					} else {
						area.setArea(areaIsp);
						area.setIspName("");
						area.setAreaName(areaMap.get(areaIsp).getItemValue());
					}

				}
				areaIspList.add(area);
			}
		}
		return areaIspList;
	}

	/**
	 * 获取国际化配置文件
	 * 
	 * @return
	 */
	public Properties getMsgProp() {
		Properties msgProp = new Properties();
		try {
			String language = LocaleContextHolder.getLocale().getLanguage();
			if (language.equals("zh_cn") || language.equals("zh")) {
				msgProp=Configurations.getMsgPropZh();
			} else if (language.equals("ru")) {
				msgProp=Configurations.getMsgPropRu();
			} else {
				msgProp=Configurations.getMsgPropEn();
			}

		} catch (Exception e) {
			//msgProp = null;
			logger.error("未知i18n消息配置文件,请确定文件是否存在!", e);
		}
		return msgProp;
	}

	public void setLogAction(BaseLogEntity log, List<FunctionServiceDict> serviceList) {
		if (!StringUtil.isEmpty(serviceList)) {
			for (FunctionServiceDict dict : serviceList) {
				if (dict.getServiceId().intValue() == log.getService()) {
					log.setAction(dict.getAction());
				}
			}
		}
	}

	// 初始化查询值判断
	public void initLogSearchValue(BaseLogEntity entry, Map<String, Object> params) {

		if (StringUtils.isNotBlank(entry.getSearchFoundStartTime())
				&& StringUtils.isNotBlank(entry.getSearchFoundEndTime())) {
			params.put("searchFoundStartTime", entry.getSearchFoundStartTime());
			params.put("searchFoundEndTime", entry.getSearchFoundEndTime());
		} else {
			// 判断是否是从配置界面过来的日志查询
			if (StringUtils.isNotBlank(entry.getIsLogTotalSearch())) {
				Calendar time = Calendar.getInstance();
				String searchEndTime = DateUtils.formatDateTime(time.getTime());
				time.add(Calendar.MINUTE, -(Constants.LOG_TIME_RANGE/1000/60));
				String searchStartTime = DateUtils.formatDateTime(time.getTime());
				
				params.put("searchFoundStartTime", searchStartTime);
				params.put("searchFoundEndTime", searchEndTime);
				entry.setSearchFoundStartTime(searchStartTime);
				entry.setSearchFoundEndTime(searchEndTime);

				// 判断startTime是否有值
				/*
				 * if(StringUtils.isNotBlank(Constants.LOG_TIME_START)) { String endTime =
				 * Constants.LOG_TIME_END; if(StringUtils.isBlank(endTime)) { endTime =
				 * DateUtils.getDateTime(); } params.put("searchFoundStartTime",
				 * Constants.LOG_TIME_START); params.put("searchFoundEndTime",endTime );
				 * entry.setSearchFoundStartTime(Constants.LOG_TIME_START);
				 * entry.setSearchFoundEndTime(endTime); }else { Calendar startTimeCal =
				 * Calendar.getInstance(); if(StringUtils.isNotEmpty(entry.getDate())) {
				 * startTimeCal.setTimeInMillis(Long.parseLong(entry.getDate()));// 同步日志总量查询时间 }
				 * // 时间间隔 int interval = Constants.LOG_TIME_RANGE/1000/60; if(interval < 60) {
				 * // 查询上一个5分钟 startTimeCal.set(Calendar.SECOND, 0); int minute =
				 * startTimeCal.get(Calendar.MINUTE); startTimeCal.set(Calendar.MINUTE,
				 * minute/interval*interval); }else { // 查询上一个1小时
				 * startTimeCal.set(Calendar.SECOND, 0); startTimeCal.set(Calendar.MINUTE, 0); }
				 * Calendar endTimeCal = Calendar.getInstance();
				 * endTimeCal.setTimeInMillis(startTimeCal.getTimeInMillis());
				 * //endTimeCal.add(Calendar.SECOND, -1);
				 * 
				 * startTimeCal.add(Calendar.MINUTE, -interval); //开始时间减去时间间隔
				 * 
				 * String searchStartTime = DateUtils.formatDateTime(startTimeCal.getTime());
				 * String searchEndTime = DateUtils.formatDateTime(endTimeCal.getTime());
				 * params.put("searchFoundStartTime", searchStartTime);
				 * params.put("searchFoundEndTime",searchEndTime);
				 * entry.setSearchFoundStartTime(searchStartTime);
				 * entry.setSearchFoundEndTime(searchEndTime); }
				 */

			} else {
				// 设置默认查询当前时间及前五分钟
				String endTime = DateUtils.getDateTime();
				Date dateStart = new Date(new Date().getTime() - Constants.LOG_TIME_INTERVAL);
				String startTime = DateUtils.formatDateTime(dateStart);
				params.put("searchFoundStartTime", startTime);
				params.put("searchFoundEndTime", endTime);
				entry.setSearchFoundStartTime(startTime);
				entry.setSearchFoundEndTime(endTime);
			}
			logger.info("searchFoundStartTime：" + params.get("searchFoundStartTime"));
			logger.info("searchFoundEndTime：" + params.get("searchFoundEndTime"));
		}

		if (StringUtils.isNotBlank(entry.getTransProto())) {
			params.put("searchTransProto", entry.getTransProto());
		}
		if (entry.getService() != null) {
			params.put("searchService", entry.getService());
		} else if (entry.getAction() != null) {
			List<FunctionServiceDict> serviceList = DictUtils.getFunctionServiceDictList(entry.getFunctionId());
			for (FunctionServiceDict dict : serviceList) {
				if (dict.getAction().intValue() == entry.getAction().intValue()
						&& dict.getFunctionId().intValue() == entry.getFunctionId().intValue()) {
					entry.setService(dict.getServiceId());
					params.put("searchService", dict.getServiceId());
				}
			}
		}
		if (StringUtils.isNotBlank(entry.getdIp())) {
			params.put("searchDIp", entry.getdIp());
		}
		if (StringUtils.isNotBlank(entry.getsIp())) {
			params.put("searchSIp", entry.getsIp());
		}
		if (StringUtils.isNotBlank(entry.getCapIp())) {
			params.put("searchCapIp", entry.getCapIp());
		}
		if (entry.getDirection() != null) {
			params.put("searchDirection", entry.getDirection());
		}
		if (entry.getEntranceId() != null) {
			params.put("searchEntranceId", entry.getEntranceId());
		}
		if (entry.getCfgId() != null) {
			params.put("searchCfgId", entry.getCfgId());
		}
		if (StringUtils.isNotBlank(entry.getOrderBy())) {
			params.put("orderBy", entry.getOrderBy());
		}
	}
	/**
	 * 多线程验证
	 * @param serviceDict
	 * @param regionDict
	 * @param asnNos
	 * @param list
	 * @return
	 * @throws ServiceException
	 * @throws InterruptedException
	 * @throws ExecutionException
	 */
	public BlockingQueue<BaseIpCfg> checkIpCfgMulity(StringBuffer _msg,FunctionServiceDict serviceDict, FunctionRegionDict regionDict,List<Map<Long,AsnGroupInfo>> asnNos,Map<Long,AsnGroupInfo> asnGroupInfos, BlockingQueue<? extends Object> list) throws ServiceException, InterruptedException, ExecutionException{
		logger.warn("start checkIpCfgMulity ,size "+list.size());
		long start=System.currentTimeMillis();
		BlockingQueue<BaseIpCfg> queue=new ArrayBlockingQueue<>(list.size());
		ExecutorService service=Executors.newFixedThreadPool(Constants.MULITY_THREAD_SIZE);
		List<Future<String>> futures=new ArrayList<>();
		
		Properties props=this.getMsgProp();
		for(int i=0;i<Constants.MULITY_THREAD_SIZE;i++) {
			CheckIpFormatThread t=new CheckIpFormatThread(serviceDict,regionDict, props, list, queue);
			t.setAsnNoMaps(asnNos);
			t.setAsnGroupInfos(asnGroupInfos);
			futures.add(service.submit(t));
		}
		service.shutdown();
		while(!service.isTerminated()) {
			try {
				Thread.sleep(10);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
		boolean valideteError=false;
		for(Future<String> future:futures) {
			String msg = future.get();
			if(StringUtils.isNotBlank(msg)) {
				if(msg.equals("validate_error")) {
					valideteError=true;
				}else if(msg.endsWith("validate_error")) {
					_msg.append(msg.substring(0, msg.length()-1-"validate_error".length()));
					valideteError=true;
				}else {
					_msg.append(msg);
				}
				//throw new ServiceException(msg);
				
			}
		}
		if(valideteError) {
			_msg.append(props.getProperty("validate_error", "Unexpected error occurred while validating"));
		}
		
		long end=System.currentTimeMillis();
		logger.warn("checkIpCfgMulity finish,cost:"+(end-start)+",size:"+queue.size());
		return queue;
	}
	/**
	 * 多线程验证
	 * @param serviceDict
	 * @param regionDict
	 * @param list
	 * @return
	 * @throws InterruptedException
	 * @throws ExecutionException
	 * @throws ServiceException
	 */
	public BlockingQueue<BaseStringCfg<?>> checkStringCfgMulity(StringBuffer _msg,FunctionServiceDict serviceDict, FunctionRegionDict regionDict, BlockingQueue<? extends Object> list) throws InterruptedException, ExecutionException, ServiceException{
		logger.warn("start checkStringCfgMulity ,size "+list.size());
		long start=System.currentTimeMillis();
		BlockingQueue<BaseStringCfg<?>> queue=new ArrayBlockingQueue<>(list.size());
		ExecutorService service=Executors.newFixedThreadPool(Constants.MULITY_THREAD_SIZE);
		List<Future<String>> futures=new ArrayList<>();
		
		Properties props=this.getMsgProp();
		for(int i=0;i<Constants.MULITY_THREAD_SIZE;i++) {
			CheckStringFormatThread t=new CheckStringFormatThread(serviceDict,regionDict, props, list, queue);
			futures.add(service.submit(t));
		}
		service.shutdown();
		while(!service.isTerminated()) {
			try {
				Thread.sleep(10);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
		boolean valideteError=false;
		for(Future<String> future:futures) {
			String msg = future.get();
			if(StringUtils.isNotBlank(msg)) {
				if(msg.equals("validate_error")) {
					valideteError=true;
				}else if(msg.endsWith("validate_error")) {
					_msg.append(msg.substring(0, msg.length()-1-"validate_error".length()));
					valideteError=true;
				}else {
					_msg.append(msg);
				}
				//throw new ServiceException(msg);
				
			}
		}
		if(valideteError) {
			_msg.append(props.getProperty("validate_error", "Unexpected error occurred while validating"));
		}
		
		long end=System.currentTimeMillis();
		logger.warn("checkStringCfgMulity finish,cost:"+(end-start)+",size:"+queue.size());
		return queue;
	}
	/**
	 * 多线程验证
	 * @param serviceDict
	 * @param regionDict
	 * @param list
	 * @return
	 * @throws InterruptedException
	 * @throws ExecutionException
	 * @throws ServiceException
	 */
	public BlockingQueue<ComplexkeywordCfg> checkComplexStringCfgMulity(StringBuffer _msg,FunctionServiceDict serviceDict, FunctionRegionDict regionDict,BlockingQueue<? extends Object> list) throws InterruptedException, ExecutionException, ServiceException{
		logger.warn("start checkComplexStringCfgMulity ,size "+list.size());
		long start=System.currentTimeMillis();
		BlockingQueue<ComplexkeywordCfg> queue=new ArrayBlockingQueue<>(list.size());
		ExecutorService service=Executors.newFixedThreadPool(Constants.MULITY_THREAD_SIZE);
		List<Future<String>> futures=new ArrayList<>();
		
		Properties props=this.getMsgProp();
		for(int i=0;i<Constants.MULITY_THREAD_SIZE;i++) {
			CheckComplexStringFormatThread t=new CheckComplexStringFormatThread(serviceDict,regionDict, props, list, queue);
			futures.add(service.submit(t));
		}
		service.shutdown();
		while(!service.isTerminated()) {
			try {
				Thread.sleep(10);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
		boolean valideteError=false;
		for(Future<String> future:futures) {
			String msg = future.get();
			if(StringUtils.isNotBlank(msg)) {
				if(msg.equals("validate_error")) {
					valideteError=true;
				}else if(msg.endsWith("validate_error")) {
					_msg.append(msg.substring(0, msg.length()-1-"validate_error".length()));
					valideteError=true;
				}else {
					_msg.append(msg);
				}
				//throw new ServiceException(msg);
				
			}
		}
		if(valideteError) {
			_msg.append(props.getProperty("validate_error", "Unexpected error occurred while validating"));
		}
		
		long end=System.currentTimeMillis();
		logger.warn("checkComplexStringCfgMulity finish,cost:"+(end-start)+",size:"+queue.size());
		return queue;
	}
	/**
	 * 多线程验证
	 * @param serviceDict
	 * @param regionDict
	 * @param list
	 * @return
	 * @throws InterruptedException
	 * @throws ExecutionException
	 * @throws ServiceException
	 */
	public BlockingQueue<DnsResStrategy> checkDnsResStrategyCfgMulity(StringBuffer _msg,FunctionServiceDict serviceDict, FunctionRegionDict regionDict,BlockingQueue<? extends Object> list) throws InterruptedException, ExecutionException, ServiceException{
		logger.warn("start checkDnsResStrategyCfgMulity ,size "+list.size());
		long start=System.currentTimeMillis();
		BlockingQueue<DnsResStrategy> queue=new ArrayBlockingQueue<>(list.size());
		ExecutorService service=Executors.newFixedThreadPool(Constants.MULITY_THREAD_SIZE);
		List<Future<String>> futures=new ArrayList<>();
		
		Properties props=this.getMsgProp();
		for(int i=0;i<Constants.MULITY_THREAD_SIZE;i++) {
			CheckDnsResStrategyFormatThread t=new CheckDnsResStrategyFormatThread(serviceDict,regionDict, props, list, queue);
			futures.add(service.submit(t));
		}
		service.shutdown();
		while(!service.isTerminated()) {
			try {
				Thread.sleep(10);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
		boolean valideteError=false;
		for(Future<String> future:futures) {
			String msg = future.get();
			if(StringUtils.isNotBlank(msg)) {
				if(msg.equals("validate_error")) {
					valideteError=true;
				}else if(msg.endsWith("validate_error")) {
					_msg.append(msg.substring(0, msg.length()-1-"validate_error".length()));
					valideteError=true;
				}else {
					_msg.append(msg);
				}
				//throw new ServiceException(msg);
				
			}
		}
		if(valideteError) {
			_msg.append(props.getProperty("validate_error", "Unexpected error occurred while validating"));
		}
		
		long end=System.currentTimeMillis();
		logger.warn("checkDnsResStrategyCfgMulity finish,cost:"+(end-start)+",size:"+queue.size());
		return queue;
	}
	
	/**
	 * 多线程验证
	 * @param _msg
	 * @param serviceDict
	 * @param regionDict
	 * @param list
	 * @return
	 * @throws InterruptedException
	 * @throws ExecutionException
	 * @throws ServiceException
	 */
	public BlockingQueue<AppComplexFeatureCfg> checkAppComplexFeatureStringCfgMulity(StringBuffer _msg,FunctionServiceDict serviceDict, FunctionRegionDict regionDict,BlockingQueue<? extends Object> list) throws InterruptedException, ExecutionException, ServiceException{
		logger.warn("start checkAppComplexFeatureStringCfgMulity ,size "+list.size());
		long start=System.currentTimeMillis();
		BlockingQueue<AppComplexFeatureCfg> queue=new ArrayBlockingQueue<>(list.size());
		ExecutorService service=Executors.newFixedThreadPool(Constants.MULITY_THREAD_SIZE);
		List<Future<String>> futures=new ArrayList<>();
		
		Properties props=this.getMsgProp();
		for(int i=0;i<Constants.MULITY_THREAD_SIZE;i++) {
			CheckAppFeatureComplexStringFormatThread t=new CheckAppFeatureComplexStringFormatThread(serviceDict,regionDict, props, list, queue);
			futures.add(service.submit(t));
		}
		service.shutdown();
		while(!service.isTerminated()) {
			try {
				Thread.sleep(10);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
		boolean valideteError=false;
		for(Future<String> future:futures) {
			String msg = future.get();
			if(StringUtils.isNotBlank(msg)) {
				if(msg.equals("validate_error")) {
					valideteError=true;
				}else if(msg.endsWith("validate_error")) {
					_msg.append(msg.substring(0, msg.length()-1-"validate_error".length()));
					valideteError=true;
				}else {
					_msg.append(msg);
				}
				//throw new ServiceException(msg);
				
			}
		}
		if(valideteError) {
			_msg.append(props.getProperty("validate_error", "Unexpected error occurred while validating"));
		}
		
		long end=System.currentTimeMillis();
		logger.warn("checkAppComplexFeatureStringCfgMulity finish,cost:"+(end-start)+",size:"+queue.size());
		return queue;
	}
	
	/**
	 * 多线程验证
	 * @param serviceDict
	 * @param regionDict
	 * @param list
	 * @return
	 * @throws InterruptedException
	 * @throws ExecutionException
	 * @throws ServiceException
	 */
	public BlockingQueue<AppTopicDomainCfg> checkTopicWebsiteCfgMulity(StringBuffer _msg,FunctionServiceDict serviceDict, FunctionRegionDict regionDict, BlockingQueue<? extends Object> list) throws InterruptedException, ExecutionException, ServiceException{
		logger.warn("start checkTopicWebsiteCfgMulity ,size "+list.size());
		long start=System.currentTimeMillis();
		BlockingQueue<AppTopicDomainCfg> queue=new ArrayBlockingQueue<>(list.size());
		ExecutorService service=Executors.newFixedThreadPool(Constants.MULITY_THREAD_SIZE);
		List<Future<String>> futures=new ArrayList<>();
		
		Properties props=this.getMsgProp();
		for(int i=0;i<Constants.MULITY_THREAD_SIZE;i++) {
			CheckTopicWebsiteFormatThread t=new CheckTopicWebsiteFormatThread(serviceDict,regionDict, props, list, queue);
			futures.add(service.submit(t));
		}
		service.shutdown();
		while(!service.isTerminated()) {
			try {
				Thread.sleep(10);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
		boolean valideteError=false;
		for(Future<String> future:futures) {
			String msg = future.get();
			if(StringUtils.isNotBlank(msg)) {
				if(msg.equals("validate_error")) {
					valideteError=true;
				}else if(msg.endsWith("validate_error")) {
					_msg.append(msg.substring(0, msg.length()-1-"validate_error".length()));
					valideteError=true;
				}else {
					_msg.append(msg);
				}
				//throw new ServiceException(msg);
				
			}
		}
		if(valideteError) {
			_msg.append(props.getProperty("validate_error", "Unexpected error occurred while validating"));
		}
		
		long end=System.currentTimeMillis();
		logger.warn("checkTopicWebsiteCfgMulity finish,cost:"+(end-start)+",size:"+queue.size());
		return queue;
	}
	
	/**
	 * 
	 * setReportSearchTime(报表查询设置开始时间与结束时间) (这里描述这个方法适用条件 – 可选)
	 * 
	 * @param bean
	 * @throws ParseException
	 *             void
	 * @exception @since
	 *                1.0.0
	 */
	public void setReportSearchTime(SearchReport bean) throws ParseException {
		SimpleDateFormat sdf = new SimpleDateFormat(Constants.SEARCH_DATEFORMAT);
		String reportTime = bean.getReportTime();
		if (StringUtils.isNotBlank(reportTime)) {
			Calendar startCal = Calendar.getInstance();
			startCal.setTime(getReportTime(reportTime));
			startCal.set(Calendar.MINUTE, 0);
			startCal.set(Calendar.SECOND, 0);
			startCal.set(Calendar.MILLISECOND, 0);
			Calendar endCal = Calendar.getInstance();
			endCal.setTime(getReportTime(reportTime));
			endCal.set(Calendar.MINUTE, 59);
			endCal.set(Calendar.SECOND, 59);
			endCal.set(Calendar.MILLISECOND, 0);
			if (bean.getReportType() == Constants.REPORT_TYPE_HOUR) {
				startCal.set(Calendar.HOUR_OF_DAY, 0);
				endCal.set(Calendar.HOUR_OF_DAY, 23);
			} else if (bean.getReportType() == Constants.REPORT_TYPE_DAY) {
				startCal.set(Calendar.HOUR_OF_DAY, 0);
				startCal.set(Calendar.DAY_OF_MONTH, 1);
				endCal.set(Calendar.HOUR_OF_DAY, 23);
				DateUtils.setLastDayOfMonth(endCal);
			} else if (bean.getReportType() == Constants.REPORT_TYPE_MONTH) {
				startCal.set(Calendar.HOUR_OF_DAY, 0);
				startCal.set(Calendar.DAY_OF_MONTH, 1);
				startCal.set(Calendar.MONTH, 0);
				endCal.set(Calendar.HOUR_OF_DAY, 23);
				DateUtils.setLastDayOfMonth(endCal);
				endCal.set(Calendar.MONTH, 11);
			}
			bean.setReportStartTime(startCal.getTime());
			bean.setReportEndTime(endCal.getTime());
			bean.setSearchReportStartTime(sdf.format(startCal.getTime()));
			bean.setSearchReportEndTime(sdf.format(endCal.getTime()));
		} else {
			Date date = new Date();
			bean.setReportEndTime(date);
			bean.setSearchReportEndTime(sdf.format(date));
			Calendar startCal = Calendar.getInstance();
			startCal.setTime(date);
			startCal.set(Calendar.MINUTE, 0);
			startCal.set(Calendar.SECOND, 0);
			startCal.set(Calendar.MILLISECOND, 0);
			if (bean.getReportType() == Constants.REPORT_TYPE_HOUR) {
				startCal.set(Calendar.HOUR_OF_DAY, 0);
			} else if (bean.getReportType() == Constants.REPORT_TYPE_DAY) {
				startCal.set(Calendar.HOUR_OF_DAY, 0);
				startCal.set(Calendar.DAY_OF_MONTH, 1);
			} else if (bean.getReportType() == Constants.REPORT_TYPE_MONTH) {
				startCal.set(Calendar.HOUR_OF_DAY, 0);
				startCal.set(Calendar.DAY_OF_MONTH, 1);
				startCal.set(Calendar.MONTH, 0);
			}
			bean.setReportStartTime(startCal.getTime());
			bean.setSearchReportStartTime(sdf.format(startCal.getTime()));

		}
		logger.info("search start time " + bean.getSearchReportStartTime());
		logger.info("search end time " + bean.getSearchReportEndTime());
	}

	public List<String> getDateTitiles(SearchReport bean) {
		SimpleDateFormat sdf = new SimpleDateFormat(Constants.SEARCH_DATEFORMAT);
		List<String> titles = new ArrayList<String>();
		Calendar cal = Calendar.getInstance();
		cal.setTime(bean.getReportStartTime());
		while (cal.getTimeInMillis() < bean.getReportEndTime().getTime()) {// 构造标题
			// 报表时间单位加一
			if (bean.getReportType() == Constants.REPORT_TYPE_HOUR) {
				titles.add(sdf.format(cal.getTime()).substring(0, 13));
				cal.add(Calendar.HOUR_OF_DAY, 1);
			} else if (bean.getReportType() == Constants.REPORT_TYPE_DAY) {
				titles.add(sdf.format(cal.getTime()).substring(0, 10));
				cal.add(Calendar.DAY_OF_MONTH, 1);
			} else if (bean.getReportType() == Constants.REPORT_TYPE_MONTH) {
				titles.add(sdf.format(cal.getTime()).substring(0, 7));
				cal.add(Calendar.MONTH, 1);
			}
		}
		return titles;
	}

	public Date getReportTime(String reportTime) throws ParseException {
		Pattern datePattern = Pattern.compile("^[0-9]{4}-[0-9]{2}-[0-9]{2}$");
		Pattern monthPattern = Pattern.compile("^[0-9]{4}-[0-9]{2}$");
		Pattern yearPattern = Pattern.compile("^[0-9]{4}$");
		Matcher matcher = datePattern.matcher(reportTime);
		if (matcher.matches()) {
			return new SimpleDateFormat("yyyy-MM-dd").parse(reportTime);
		} else {
			matcher = monthPattern.matcher(reportTime);
			if (matcher.matches()) {
				return new SimpleDateFormat("yyyy-MM").parse(reportTime);
			} else {
				matcher = yearPattern.matcher(reportTime);
				if (matcher.matches()) {
					return new SimpleDateFormat("yyyy").parse(reportTime);
				}
			}
		}
		return null;
	}

	/**
	 * 多域导入
	 * 
	 * @param redirectAttributes
	 * @param files
	 * @param serviceDictId
	 * @param regionDictIds
	 * @param requestId
	 * @param classify 
	 * @param attribute 
	 */
	public void _import(HttpServletRequest request, HttpServletResponse response, RedirectAttributes redirectAttributes,
			MultipartFile[] files, Integer serviceDictId, String regionDictIds, Integer requestId, String attribute, String classify) {
		logger.warn("import start...");
		long start=System.currentTimeMillis();
		ImportBigExcel ei=null;
		try {
			FunctionServiceDict serviceDict = DictUtils.getFunctionServiceDict(serviceDictId);
			StringBuffer errTip=new StringBuffer();
				BlockingQueue<BaseIpCfg> ipPortCfgs =null;
				BlockingQueue<BaseStringCfg<?>> stringCfgs =null;
				BlockingQueue<ComplexkeywordCfg> complexkeywordCfgs =null;
				BlockingQueue<DnsResStrategy> dnsResStrategies=null;
				BlockingQueue<AppComplexFeatureCfg> appComplexFeatureCfgs=null;
				BlockingQueue<AppTopicDomainCfg> appTopicDomainCfgs=null;// 主题网站
				List<CfgIndexInfo> cfgIndexInfos = new ArrayList<CfgIndexInfo>();
				List<AppPolicyCfg> appPolicyCfgs = new ArrayList<AppPolicyCfg>();
				List<AppFeatureIndex> appFeatureIndexs= new ArrayList<AppFeatureIndex>();
				List<Map<Long,AsnGroupInfo>> asnNoMaps=Lists.newArrayList();
				Map<Long,AsnGroupInfo> newAsnNoMap=Maps.newConcurrentMap();
				Map<Long,AsnGroupInfo> OldAsnNoMap=Maps.newConcurrentMap();
				Map<Long,AsnGroupInfo> asnGroupInfos=null;
				asnNoMaps.add(newAsnNoMap);
				asnNoMaps.add(OldAsnNoMap);
				FunctionRegionDict appRegion = null;
				FunctionRegionDict appFeatureRegion = null;
				if(serviceDict!=null) {
					String regionCode = serviceDict.getRegionCode();
					for (String code : regionCode.split(",")) {
						if (StringUtils.isNotBlank(code)) {
							FunctionRegionDict d = DictUtils.getFunctionRegionDictByRegionCode(serviceDict.getFunctionId(),
									Integer.parseInt(code));
							if (d != null && d.getConfigServiceType() != null
									&& d.getConfigServiceType().equals("app_policy")) {
								appRegion = d;
								break;
							}
							
							if (d != null && d.getFunctionId() != null
									&& (d.getFunctionId().intValue()==565 || d.getFunctionId().intValue()==564 || d.getFunctionId().intValue()==566 || d.getFunctionId().intValue()==563)) {
								appFeatureRegion = d;
								break;
							}
						}
	
					}
				}
				for (int i = 0; i < files.length; i++) {
					MultipartFile file = files[i];
					ei = new ImportBigExcel(file, 0, 1);
					FunctionRegionDict regionDict = DictUtils
							.getFunctionRegionDict(Integer.parseInt(regionDictIds.split(",")[i]));
					//加载模板
					loadTemplate(ei,regionDict, serviceDict);
					//------------------------------------check format start----------------------------
					if (regionDict.getRegionType().equals(1)) {// IP
						if (regionDict.getFunctionId().equals(5)) {
							if (serviceDict!=null&&serviceDict.getAction().equals(64)) {
								BlockingQueue<IpRateLimitTemplate> list = ei.getDataList(IpRateLimitTemplate.class
										);
								ipPortCfgs=this.checkIpCfgMulity(errTip,serviceDict, regionDict,null,asnGroupInfos, list);
							} else if(serviceDict!=null&&serviceDict.getAction().equals(32)) {
								BlockingQueue<IpAllNotDoLogTemplate> list = ei.getDataList(IpAllNotDoLogTemplate.class );
								ipPortCfgs=this.checkIpCfgMulity(errTip,serviceDict, regionDict, null,asnGroupInfos, list);
							} else {
								BlockingQueue<IpAllTemplate> list = ei.getDataList(IpAllTemplate.class );
								ipPortCfgs=this.checkIpCfgMulity(errTip,serviceDict, regionDict, null,asnGroupInfos, list);
							}
						} else if (regionDict.getFunctionId().equals(7)&&serviceDict!=null&&serviceDict.getAction().intValue()==16) {
							BlockingQueue<DnsIpTemplate> list = ei.getDataList(DnsIpTemplate.class );
							ipPortCfgs=this.checkIpCfgMulity(errTip,serviceDict, regionDict, null,asnGroupInfos, list);
						}else if(regionDict.getFunctionId().equals(401)) {
							BlockingQueue<DnsFakeIpTemplate> list = ei.getDataList(DnsFakeIpTemplate.class );
							ipPortCfgs=this.checkIpCfgMulity(errTip,serviceDict, regionDict, null,asnGroupInfos, list);
						}else if (regionDict.getFunctionId().equals(212)) {
							BlockingQueue<IpPayloadTemplate> list = ei.getDataList(IpPayloadTemplate.class );
							ipPortCfgs=this.checkIpCfgMulity(errTip,serviceDict, regionDict, null,asnGroupInfos, list);
						} else if (regionDict.getFunctionId().equals(510)
								&& "p2p_ip".equals(regionDict.getConfigServiceType())) { // P2p IP
							BlockingQueue<P2pIpTemplate> list = ei.getDataList(P2pIpTemplate.class );
							ipPortCfgs=this.checkIpCfgMulity(errTip,serviceDict, regionDict, null,asnGroupInfos, list);
						} else if (regionDict.getFunctionId().equals(600)) {// ASN IP
							ei.setHasImportLimit(false);
							//加载asn缓存
							//AsnCacheUtils.init(true);
							//从数据库中读取
							asnGroupInfos=asnGroupInfoService.getGroupList();
							//OldAsnNoMap.putAll(asnGroupInfoService.getGroupList());
							BlockingQueue<AsnIpTemplate> list = ei.getDataList(AsnIpTemplate.class );
							ipPortCfgs=this.checkIpCfgMulity(errTip,serviceDict, regionDict, asnNoMaps,asnGroupInfos, list);
							
						}else if (regionDict.getFunctionId().equals(301)) {// DDOS IP
							BlockingQueue<DdosIpTemplate> list = ei.getDataList(DdosIpTemplate.class );
							ipPortCfgs=this.checkIpCfgMulity(errTip,serviceDict, regionDict, null,asnGroupInfos, list);
						}else if(regionDict.getFunctionId().equals(207)){// HTTP(s)阻断
							BlockingQueue<HttpsRejectIpTemplate> list = ei.getDataList(HttpsRejectIpTemplate.class );
							ipPortCfgs=this.checkIpCfgMulity(errTip,serviceDict, regionDict, null,asnGroupInfos, list);
						}else if(regionDict.getFunctionId().equals(208)){// HTTP(s)重定向
							BlockingQueue<HttpsRedirectIpTemplate> list = ei.getDataList(HttpsRedirectIpTemplate.class );
							ipPortCfgs=this.checkIpCfgMulity(errTip,serviceDict, regionDict, null,asnGroupInfos, list);
						}else if(regionDict.getFunctionId().equals(209)){// HTTP(s)替换
							BlockingQueue<HttpsReplaceIpTemplate> list = ei.getDataList(HttpsReplaceIpTemplate.class );
							ipPortCfgs=this.checkIpCfgMulity(errTip,serviceDict, regionDict, null,asnGroupInfos, list);
						}else if(regionDict.getFunctionId().equals(211)){// HTTP(s)白名单
							BlockingQueue<IpAllNotDoLogTemplate> list = ei.getDataList(IpAllNotDoLogTemplate.class );
							ipPortCfgs=this.checkIpCfgMulity(errTip,serviceDict, regionDict, null,asnGroupInfos, list);
						}else if(regionDict.getFunctionId().equals(200)) {// 拦截策略
							if(serviceDict.getAction().equals(64)) {
								BlockingQueue<IpRateLimitTemplate> list = ei.getDataList(IpRateLimitTemplate.class );
								ipPortCfgs=this.checkIpCfgMulity(errTip,serviceDict, regionDict,null,asnGroupInfos, list);
							}else {
								BlockingQueue<IpAllNotDoLogTemplate> list = ei.getDataList(IpAllNotDoLogTemplate.class );
								ipPortCfgs=this.checkIpCfgMulity(errTip,serviceDict, regionDict,null,asnGroupInfos, list);
							}
						}else if(regionDict.getFunctionId().equals(3)) { // IP白名单
							BlockingQueue<IpWhitelistTemplate> list = ei.getDataList(IpWhitelistTemplate.class );
							ipPortCfgs=this.checkIpCfgMulity(errTip,serviceDict, regionDict,null,asnGroupInfos, list);
						}else if(regionDict.getFunctionId().equals(214)) { // IpSpoofing
							BlockingQueue<IpSpoofingTemplate> list = ei.getDataList(IpSpoofingTemplate.class );
							ipPortCfgs=this.checkIpCfgMulity(errTip,serviceDict, regionDict,null,asnGroupInfos, list);
						}else if(regionDict.getFunctionId().equals(405) || regionDict.getFunctionId().equals(563) || regionDict.getFunctionId().equals(565)
								|| regionDict.getFunctionId().equals(566)) { // APP Feature IP
							BlockingQueue<IpAllNotDoLogTemplate> list = ei.getDataList(IpAllNotDoLogTemplate.class );
							ipPortCfgs=this.checkIpCfgMulity(errTip,serviceDict, regionDict,null,asnGroupInfos, list);
						}else if((regionDict.getFunctionId().equals(63) || regionDict.getFunctionId().equals(407) || regionDict.getFunctionId().equals(408)) && serviceDict!=null && serviceDict.getAction().equals(64)) { // Policies -> Stream
							BlockingQueue<IpRateLimitTemplate> list = ei.getDataList(IpRateLimitTemplate.class);
							ipPortCfgs=this.checkIpCfgMulity(errTip,serviceDict, regionDict,null,asnGroupInfos, list);
						}else {
							BlockingQueue<IpAllTemplate> list = ei.getDataList(IpAllTemplate.class );
							ipPortCfgs=this.checkIpCfgMulity(errTip,serviceDict, regionDict, null,asnGroupInfos, list);
						}
					} else if (regionDict.getRegionType().equals(2)) {// 字符串类
						if (regionDict.getFunctionId().equals(510)
								&& "p2p_hash".equals(regionDict.getConfigServiceType())) { // P2p hash
							BlockingQueue<P2pHashStringTemplate> list = ei.getDataList(P2pHashStringTemplate.class
									);
							stringCfgs=this.checkStringCfgMulity(errTip,serviceDict, regionDict, list);
						}else if (regionDict.getFunctionId().equals(403)) {
							BlockingQueue<AppDomainTemplate> list = ei.getDataList(AppDomainTemplate.class
									);
							stringCfgs=this.checkStringCfgMulity(errTip,serviceDict, regionDict, list);
						}else if (regionDict.getFunctionId().equals(200)){// 拦截策略
							if(serviceDict.getAction().equals(1)){// 监测
								BlockingQueue<DomainInterceptMonitTemplate> list = ei.getDataList(DomainInterceptMonitTemplate.class);
								stringCfgs=this.checkStringCfgMulity(errTip,serviceDict, regionDict, list);
							}else if(serviceDict.getAction().equals(64)){// 限速
								BlockingQueue<DomainInterceptRateLimitTemplate> list = ei.getDataList(DomainInterceptRateLimitTemplate.class);
								stringCfgs=this.checkStringCfgMulity(errTip,serviceDict, regionDict, list);
							}else{// 白名单
								BlockingQueue<DomainInterceptTemplate> list = ei.getDataList(DomainInterceptTemplate.class);
								stringCfgs=this.checkStringCfgMulity(errTip,serviceDict, regionDict, list);
							}
						}else if(regionDict.getFunctionId().equals(207)){// HTTP(s)阻断
							BlockingQueue<HttpsRejectTemplate> list = ei.getDataList(HttpsRejectTemplate.class);
							stringCfgs=this.checkStringCfgMulity(errTip,serviceDict, regionDict, list);
						}else if(regionDict.getFunctionId().equals(208)){// HTTP(s)重定向
							BlockingQueue<HttpsRedirectTemplate> list = ei.getDataList(HttpsRedirectTemplate.class);
							stringCfgs=this.checkStringCfgMulity(errTip,serviceDict, regionDict, list);
						}else if(regionDict.getFunctionId().equals(209)){// HTTP(s)替换
							BlockingQueue<HttpsReplaceTemplate> list = ei.getDataList(HttpsReplaceTemplate.class);
							stringCfgs=this.checkStringCfgMulity(errTip,serviceDict, regionDict, list);
						}else if(regionDict.getFunctionId().equals(211)){// HTTP(s)白名单
							BlockingQueue<StringAllNotDoLogTemplate> list = ei.getDataList(StringAllNotDoLogTemplate.class);
							stringCfgs=this.checkStringCfgMulity(errTip,serviceDict, regionDict, list);
						}else if(regionDict.getFunctionId().equals(560)){// 主题网站
							BlockingQueue<TopicWebsiteTemplate> list = ei.getDataList(TopicWebsiteTemplate.class);
							appTopicDomainCfgs=this.checkTopicWebsiteCfgMulity(errTip,serviceDict, regionDict, list);
						}else {
							BlockingQueue<StringAllTemplate> list = ei.getDataList(StringAllTemplate.class );
							stringCfgs=this.checkStringCfgMulity(errTip,serviceDict, regionDict, list);
						}

					} else if (regionDict.getRegionType().equals(3)) {// 增强字符串类
						if (regionDict.getFunctionId().equals(7)&&serviceDict!=null&&serviceDict.getAction().intValue()==16) {
							BlockingQueue<DnsComplexStringTemplate> list = ei.getDataList(DnsComplexStringTemplate.class
									);
							complexkeywordCfgs = this.checkComplexStringCfgMulity(errTip,serviceDict, regionDict, list);
						} else if(regionDict.getFunctionId().equals(207)){// HTTP(s)阻断
							BlockingQueue<HttpsRejectComplexTemplate> list = ei.getDataList(HttpsRejectComplexTemplate.class);
							complexkeywordCfgs = this.checkComplexStringCfgMulity(errTip,serviceDict, regionDict, list);
						} else if(regionDict.getFunctionId().equals(208)){// HTTP(s)重定向
							BlockingQueue<HttpsRedirectComplexTemplate> list = ei.getDataList(HttpsRedirectComplexTemplate.class);
							complexkeywordCfgs = this.checkComplexStringCfgMulity(errTip,serviceDict, regionDict, list);
						} else if(regionDict.getFunctionId().equals(209)){// HTTP(s)替换
							BlockingQueue<HttpsReplaceComplexTemplate> list = ei.getDataList(HttpsReplaceComplexTemplate.class);
							complexkeywordCfgs = this.checkComplexStringCfgMulity(errTip,serviceDict, regionDict, list);
						} else if(regionDict.getFunctionId().equals(211)){// HTTP(s)白名单
							BlockingQueue<ComplexStringAllNotDoLogTemplate> list = ei.getDataList(ComplexStringAllNotDoLogTemplate.class);
							complexkeywordCfgs = this.checkComplexStringCfgMulity(errTip,serviceDict, regionDict, list);
						} else if(regionDict.getFunctionId().equals(563)){// APP Payload
							BlockingQueue<AppPayloadTemplate> list = ei.getDataList(AppPayloadTemplate.class);
							appComplexFeatureCfgs = this.checkAppComplexFeatureStringCfgMulity(errTip,serviceDict, regionDict, list);
						} else if(regionDict.getFunctionId().equals(565) || regionDict.getFunctionId().equals(564) || regionDict.getFunctionId().equals(566)){// APP Feature StrPlus
							BlockingQueue<ComplexStringAllNotDoLogTemplate> list = ei.getDataList(ComplexStringAllNotDoLogTemplate.class);
							complexkeywordCfgs = this.checkComplexStringCfgMulity(errTip,serviceDict, regionDict, list);
						} else {
							BlockingQueue<ComplexStringAllTemplate> list = ei.getDataList(ComplexStringAllTemplate.class
									);
							complexkeywordCfgs = this.checkComplexStringCfgMulity(errTip,serviceDict, regionDict, list);
						}

					}else if (regionDict.getRegionType().equals(6)) {// 回调类
						if (regionDict.getFunctionId().equals(400)) {
							BlockingQueue<DnsResStrategyTemplate> list = ei.getDataList(DnsResStrategyTemplate.class
									);
							dnsResStrategies=this.checkDnsResStrategyCfgMulity(errTip,serviceDict, regionDict, list);
						} 
					}
					//删除文件
					if(ei.getUploadFile()!=null&&ei.getUploadFile().exists()) {
						ei.getUploadFile().delete();
					}
					//------------------------------------check format end----------------------------
					Date date = new Date();
					String specServiceId = request.getParameter("appId");
					String behaviorId = request.getParameter("behaviorId");
					String asnIpGroup = request.getParameter("asnGroupId");
					
					String isSend = request.getParameter("isSend")==null?"":request.getParameter("isSend");
					SpecificServiceCfg specificServiceCfg = null;
					if (serviceDict!=null&&(serviceDict.getServiceId().intValue() == 33 || serviceDict.getServiceId().intValue() == 145
							|| serviceDict.getServiceId().intValue() == 1056
							|| serviceDict.getServiceId().intValue() == 1059
							|| serviceDict.getServiceId().intValue() == 1060
							|| serviceDict.getServiceId().intValue() == 35
							|| serviceDict.getServiceId().intValue() == 147
							|| serviceDict.getServiceId().intValue() == 36
							|| serviceDict.getServiceId().intValue() == 148
							|| serviceDict.getServiceId().intValue() == 1028// app ip
							|| serviceDict.getServiceId().intValue() == 1024//app http
							|| serviceDict.getServiceId().intValue() == 1026//app domain
							|| serviceDict.getServiceId().intValue() == 1027//app dns
							|| serviceDict.getServiceId().intValue() == 1029//app ssl
							|| serviceDict.getServiceId().intValue() == 1025//app PAYLOAD
							)) {
						if (StringUtils.isNotBlank(specServiceId)) {
							specificServiceCfg = specificServiceCfgService
									.getBySpecServiceId(Integer.parseInt(specServiceId));
						}
					}
					if (regionDict.getRegionType().equals(1)) {// IP
						if(regionDict.getFunctionId().intValue()==600) {//ans ip
							
							List<SysDataDictionaryItem> isImportAll=DictUtils.getDictList("IS_ASN_IP_IMPORT_ALL");
							//处理组,新的组会在这里保存
							if(!asnNoMaps.get(0).isEmpty()) {
								asnIpCfgService.processGroup(asnNoMaps.get(0));
							}
							//全量下发，删除asnNo对应的已有的IP
							if(isImportAll.get(0).getItemCode().equals("1")) {
								Integer ipType=null;
								if((!ipPortCfgs.isEmpty())){
									BaseIpCfg baseIpCfg=ipPortCfgs.take();
									ipPortCfgs.put(baseIpCfg);
									if(!StringUtil.isEmpty(baseIpCfg)){
										ipType=baseIpCfg.getIpType();
									}
								}
								logger.warn("Delete and send ip reuse regions start");
								long _start=System.currentTimeMillis();
								deleteIps(asnNoMaps.get(1),ipType);
								long _end=System.currentTimeMillis();
								logger.warn("Delete and send ip reuse regions end,cost:"+(_end-_start));
							}
							List<AsnIpCfg> asnIpCfgs=Lists.newArrayList(Constants.MAAT_JSON_SEND_SIZE);
							List<BaseIpCfg> _ipPortCfgs=Lists.newArrayList(Constants.MAAT_JSON_SEND_SIZE);
							while(!ipPortCfgs.isEmpty()) {
								ipPortCfgs.drainTo(_ipPortCfgs, Constants.MAAT_JSON_SEND_SIZE);
								List<Integer> regionIds=Lists.newArrayList();
								try {
									regionIds = ConfigServiceUtil.getId(3,_ipPortCfgs.size());
								} catch (Exception e) {
									e.printStackTrace();
									logger.info("获取域ID出错");
									throw new MaatConvertException("<spring:message code=\"request_service_failed\"/>:"+e.getMessage());
								}
								int ind=0;
								for (BaseIpCfg cfg : _ipPortCfgs) {
									AsnIpCfg _cfg=new AsnIpCfg();
									BeanUtils.copyProperties(cfg, _cfg,new String[] {"cfgId"});
									_cfg.setTableName(AsnIpCfg.getTablename());
									_cfg.setAction(serviceDict==null?0:serviceDict.getAction());
									_cfg.setCfgRegionCode(regionDict.getConfigRegionCode());
									_cfg.setCfgType(regionDict.getConfigRegionValue());
									_cfg.setCreateTime(date);
									_cfg.setCreatorId(UserUtils.getUser().getId());
									_cfg.setDoLog(2);
									_cfg.setFunctionId(regionDict.getFunctionId());
									if(isSend.equals("1")) {
										_cfg.setIsAudit(Constants.AUDIT_YES);
										_cfg.setIsValid(Constants.VALID_YES);
										_cfg.setAuditorId(UserUtils.getUser().getId());
										_cfg.setAuditTime(date);
										
									}else {
										_cfg.setIsAudit(Constants.AUDIT_NOT_YET);
										_cfg.setIsValid(Constants.VALID_NO);
									}
									_cfg.setIsAreaEffective(0);
									_cfg.setLable("0");
									_cfg.setRequestId(StringUtil.isEmpty(requestId) ? 0 : requestId);
									_cfg.setAttribute(attribute);
									_cfg.setClassify(classify);
//									_cfg.setServiceId(0);
									_cfg.setServiceId(serviceDict==null?0:serviceDict.getServiceId());
									//设置region id
									if(regionIds!=null&&regionIds.size()==_ipPortCfgs.size()) {
										_cfg.setRegionId(regionIds.get(ind));
									}
									//设置group id,compileId
									if(asnNoMaps.get(0).containsKey(Long.parseLong(_cfg.getUserRegion1()))) {
										_cfg.setAsnIpGroup(asnNoMaps.get(0).get(Long.parseLong(_cfg.getUserRegion1())).getGroupId());
										_cfg.setCompileId(asnNoMaps.get(0).get(Long.parseLong(_cfg.getUserRegion1())).getCompileId());
									}else if(asnNoMaps.get(1).containsKey(Long.parseLong(_cfg.getUserRegion1()))) {
										_cfg.setAsnIpGroup(asnNoMaps.get(1).get(Long.parseLong(_cfg.getUserRegion1())).getGroupId());
										_cfg.setCompileId(asnNoMaps.get(1).get(Long.parseLong(_cfg.getUserRegion1())).getCompileId());
									}else {
										//AsnGroupInfo info=AsnCacheUtils.get(Long.parseLong(_cfg.getUserRegion1()));
										AsnGroupInfo info=asnGroupInfos.get(Long.parseLong(_cfg.getUserRegion1()));
										if(info!=null) {
											_cfg.setAsnIpGroup(info.getGroupId());
											_cfg.setCompileId(info.getCompileId());
										}
									}
									asnIpCfgs.add(_cfg);
									ind++;
								}
								ipCfgService.saveAndSend(regionDict, serviceDict, specificServiceCfg, asnIpCfgs, cfgIndexInfos, appPolicyCfgs,appFeatureIndexs,asnNoMaps,isSend.equals("1"));
								cfgIndexInfos.clear();
								appPolicyCfgs.clear();
								_ipPortCfgs.clear();
								asnIpCfgs.clear();
							}
						}else if(regionDict.getFunctionId().intValue()==214) { // IpSpoofing
							List<BaseIpCfg> _ipPortCfgs=Lists.newArrayList(Constants.MAAT_JSON_SEND_SIZE);
							while(!ipPortCfgs.isEmpty()) {
								ipPortCfgs.drainTo(_ipPortCfgs, Constants.MAAT_JSON_SEND_SIZE);
								List<Integer> compileIds=Lists.newArrayList();
								List<Integer> regionIds=Lists.newArrayList();
								List<Integer> groupIds=Lists.newArrayList();
								List<Integer> numRegionGroupIds=Lists.newArrayList();
								List<Integer> numRegionRegionIds=Lists.newArrayList();
								try {
									 compileIds = ConfigServiceUtil.getId(1,_ipPortCfgs.size());
									 if(isSend.equals("1")) {
										 groupIds = ConfigServiceUtil.getId(2,_ipPortCfgs.size());
										 regionIds = ConfigServiceUtil.getId(3,_ipPortCfgs.size());
										 //需要获取数值域的id
										 if(serviceDict!=null&&serviceDict.getProtocolId()!=null&&serviceDict.getProtocolId()>0) {
											 numRegionGroupIds = ConfigServiceUtil.getId(2,_ipPortCfgs.size());
											 numRegionRegionIds = ConfigServiceUtil.getId(3,_ipPortCfgs.size());
										 }
									 }
								} catch (Exception e) {
									e.printStackTrace();
									logger.info("获取编译ID出错");
									throw new MaatConvertException("<spring:message code=\"request_service_failed\"/>:"+e.getMessage());
								}
								
								int ind=0;
								for (BaseIpCfg cfg : _ipPortCfgs) {
									cfg.setAction(serviceDict==null?null:serviceDict.getAction());
									cfg.setCfgRegionCode(regionDict.getConfigRegionCode());
									cfg.setCfgType(regionDict.getConfigRegionValue());
									cfg.setCreateTime(date);
									cfg.setCreatorId(UserUtils.getUser().getId());
									cfg.setFunctionId(regionDict.getFunctionId());
									if(isSend.equals("1")) {
										cfg.setIsAudit(Constants.AUDIT_YES);
										cfg.setIsValid(Constants.VALID_YES);
										cfg.setAuditorId(UserUtils.getUser().getId());
										cfg.setAuditTime(date);
										if(groupIds!=null&&groupIds.size()==_ipPortCfgs.size()) {
											cfg.setGroupId(groupIds.get(ind));
										}
										if(regionIds!=null&&regionIds.size()==_ipPortCfgs.size()) {
											cfg.setRegionId(regionIds.get(ind));
										}
										if(serviceDict!=null&&serviceDict.getProtocolId()!=null) {
											if(numRegionGroupIds!=null&&numRegionGroupIds.size()==_ipPortCfgs.size()) {
												cfg.setNumberRegionGroupId(numRegionGroupIds.get(ind));
											}
											if(numRegionRegionIds!=null&&numRegionRegionIds.size()==_ipPortCfgs.size()) {
												cfg.setNumberRegionRegionId(numRegionRegionIds.get(ind));
											}
										}
									}else {
										cfg.setIsAudit(Constants.AUDIT_NOT_YET);
										cfg.setIsValid(Constants.VALID_NO);
									}
									cfg.setIsAreaEffective(0);
									cfg.setLable("0");
									cfg.setRequestId(StringUtil.isEmpty(requestId) ? 0 : requestId);
									cfg.setAttribute(attribute);
									cfg.setClassify(classify);
									cfg.setServiceId(serviceDict==null?null:serviceDict.getServiceId());
									cfg.setTableName("ip_port_cfg");
									if(compileIds.size()==_ipPortCfgs.size()) {
										cfg.setCompileId(compileIds.get(ind));
									}
									ind++;
									
								}
								ipCfgService.saveAndSend(regionDict, serviceDict, specificServiceCfg, _ipPortCfgs, cfgIndexInfos, appPolicyCfgs,appFeatureIndexs,asnNoMaps,isSend.equals("1"));
								cfgIndexInfos.clear();
								appPolicyCfgs.clear();
								_ipPortCfgs.clear();
							}
						}else {
							List<BaseIpCfg> _ipPortCfgs=Lists.newArrayList(Constants.MAAT_JSON_SEND_SIZE);
							while(!ipPortCfgs.isEmpty()) {
								ipPortCfgs.drainTo(_ipPortCfgs, Constants.MAAT_JSON_SEND_SIZE);
								List<Integer> compileIds=Lists.newArrayList();
								List<Integer> regionIds=Lists.newArrayList();
								List<Integer> groupIds=Lists.newArrayList();
								List<Integer> numRegionGroupIds=Lists.newArrayList();
								List<Integer> numRegionRegionIds=Lists.newArrayList();
								if(!regionDict.getFunctionId().equals(405)) {//app ip compileId 从config_group_info中取
									try {
										 compileIds = ConfigServiceUtil.getId(1,_ipPortCfgs.size());
										 if(isSend.equals("1")) {
											 groupIds = ConfigServiceUtil.getId(2,_ipPortCfgs.size());
											 regionIds = ConfigServiceUtil.getId(3,_ipPortCfgs.size());
											 //需要获取数值域的id
											 if(serviceDict!=null&&serviceDict.getProtocolId()!=null&&serviceDict.getProtocolId()>0) {
												 numRegionGroupIds = ConfigServiceUtil.getId(2,_ipPortCfgs.size());
												 numRegionRegionIds = ConfigServiceUtil.getId(3,_ipPortCfgs.size());
											 }
										 }
									} catch (Exception e) {
										e.printStackTrace();
										logger.info("获取编译ID出错");
										throw new MaatConvertException("<spring:message code=\"request_service_failed\"/>:"+e.getMessage());
									}
								}else {
									try {
										regionIds = ConfigServiceUtil.getId(3,_ipPortCfgs.size());
									} catch (Exception e) {
										e.printStackTrace();
										logger.info("获取域ID出错");
										throw new MaatConvertException("<spring:message code=\"request_service_failed\"/>:"+e.getMessage());
									}
								}
								int ind=0;
								for (BaseIpCfg cfg : _ipPortCfgs) {
									cfg.setAction(serviceDict==null?null:serviceDict.getAction());
									/*cfg.setAuditorId(UserUtils.getUser().getId());
									cfg.setAuditTime(date);*/
									cfg.setCfgRegionCode(regionDict.getConfigRegionCode());
									cfg.setCfgType(regionDict.getConfigRegionValue());
									cfg.setCreateTime(date);
									cfg.setCreatorId(UserUtils.getUser().getId());
									//cfg.setDoLog(2);
									cfg.setFunctionId(regionDict.getFunctionId());
									if(isSend.equals("1")) {
										cfg.setIsAudit(Constants.AUDIT_YES);
										cfg.setIsValid(Constants.VALID_YES);
										cfg.setAuditorId(UserUtils.getUser().getId());
										cfg.setAuditTime(date);
										if(groupIds!=null&&groupIds.size()==_ipPortCfgs.size()) {
										cfg.setGroupId(groupIds.get(ind));
										}
										if(regionIds!=null&&regionIds.size()==_ipPortCfgs.size()) {
										cfg.setRegionId(regionIds.get(ind));
										}
										if(serviceDict!=null&&serviceDict.getProtocolId()!=null) {
											if(numRegionGroupIds!=null&&numRegionGroupIds.size()==_ipPortCfgs.size()) {
												cfg.setNumberRegionGroupId(numRegionGroupIds.get(ind));
											}
											if(numRegionRegionIds!=null&&numRegionRegionIds.size()==_ipPortCfgs.size()) {
												cfg.setNumberRegionRegionId(numRegionRegionIds.get(ind));
											}
										 }
									}else {
										cfg.setIsAudit(Constants.AUDIT_NOT_YET);
										cfg.setIsValid(Constants.VALID_NO);
									}
									cfg.setIsAreaEffective(0);
									cfg.setLable("0");
									cfg.setRequestId(StringUtil.isEmpty(requestId) ? 0 : requestId);
									cfg.setAttribute(attribute);
									cfg.setClassify(classify);
									cfg.setServiceId(serviceDict==null?null:serviceDict.getServiceId());
									cfg.setTableName("ip_port_cfg");
									if(compileIds.size()==_ipPortCfgs.size()) {
										cfg.setCompileId(compileIds.get(ind));
									}
									if(regionDict.getFunctionId().equals(405)&&regionIds.size()==_ipPortCfgs.size()) {
										cfg.setUserRegion1(regionIds.get(ind).toString());
									}
									if(specificServiceCfg!=null) {
										cfg.setAppCode(specificServiceCfg.getSpecServiceCode());
										cfg.setSpecServiceId(specificServiceCfg.getSpecServiceId());
										if(StringUtils.isNotBlank(behaviorId))
										cfg.setBehavCode(Integer.parseInt(behaviorId));
									}
									if (serviceDict!=null&&(serviceDict.getServiceId().intValue() == 33
											|| serviceDict.getServiceId().intValue() == 145
											|| serviceDict.getServiceId().intValue() == 1056
											|| serviceDict.getServiceId().intValue() == 1059
											|| serviceDict.getServiceId().intValue() == 1060
											|| serviceDict.getServiceId().intValue() == 35
											|| serviceDict.getServiceId().intValue() == 147
											|| serviceDict.getServiceId().intValue() == 36
											|| serviceDict.getServiceId().intValue() == 148)) {
										if (appRegion != null) {
											AppPolicyCfg appPolicyCfg = new AppPolicyCfg();
											BeanUtils.copyProperties(cfg, appPolicyCfg,new String[] {"cfgId"});
											//appPolicyCfg.setSpecServiceId(specificServiceCfg.getSpecServiceId());
											//appPolicyCfg.setAppCode(specificServiceCfg.getSpecServiceCode());
											appPolicyCfg.setMatchMethod(0);
											appPolicyCfg.setIsHexbin(0);
											appPolicyCfg.setCfgType(appRegion.getConfigRegionValue());
											appPolicyCfg.setCfgRegionCode(appRegion.getConfigRegionCode());
											if (StringUtils.isNotBlank(behaviorId)) {
												//appPolicyCfg.setBehavCode(Integer.parseInt(behaviorId));
												appPolicyCfg.setExprType(1);
											} else {
												appPolicyCfg.setExprType(0);
											}
											appPolicyCfgs.add(appPolicyCfg);
										}
									} else {
										if(regionDict.getFunctionId().intValue()!=600
										&&regionDict.getFunctionId().intValue()!=301
										&&regionDict.getFunctionId().intValue()!=401
										&&regionDict.getFunctionId().intValue()!=405
										&&regionDict.getFunctionId().intValue()!=565
										&&regionDict.getFunctionId().intValue()!=566
										&&regionDict.getFunctionId().intValue()!=563) {
											CfgIndexInfo cfgIndexInfo = new CfgIndexInfo();
											BeanUtils.copyProperties(cfg, cfgIndexInfo,new String[] {"cfgId"});
											cfgIndexInfos.add(cfgIndexInfo);
										}
										if(regionDict.getFunctionId().intValue()==565 || regionDict.getFunctionId().intValue()==566 || regionDict.getFunctionId().intValue()==563){
											AppFeatureIndex  appfeature = new AppFeatureIndex();
											if(regionDict!=null){
												appfeature.setCfgRegionCode1(String.valueOf(regionDict.getConfigRegionCode()));
												appfeature.setCfgRegionValue(regionDict.getConfigRegionValue());
												appfeature.setCfgRegionType(String.valueOf(regionDict.getRegionType()));
											}
											BeanUtils.copyProperties(cfg, appfeature,new String[] {"cfgId"});
											appFeatureIndexs.add(appfeature);
										}
										
									}
									ind++;
								}
								ipCfgService.saveAndSend(regionDict, serviceDict, specificServiceCfg, _ipPortCfgs, cfgIndexInfos, appPolicyCfgs,appFeatureIndexs,asnNoMaps,isSend.equals("1"));
								cfgIndexInfos.clear();
								appPolicyCfgs.clear();
								_ipPortCfgs.clear();
							}
						}
						
					} else if (regionDict.getRegionType().equals(2)) {
//						List<Future<Throwable>> list=Lists.newArrayList();
//						ExecutorService service=Executors.newFixedThreadPool(Constants.SAVE_AND_DEL_THREAD_SIZE);
//						for(int j=0;j<Constants.SAVE_AND_DEL_THREAD_SIZE;j++) {
//							SaveStringCfgThread t=new SaveStringCfgThread(serviceDict, regionDict, requestId, stringCfgs,isSend.equals("1"));
//							t.setSpecificServiceCfg(specificServiceCfg);
//							t.setAsnIpGroup(asnIpGroup);
//							t.setBehaviorId(behaviorId);
//							t.setSpecServiceId(specServiceId);
//							list.add(service.submit(t));
//						}
//						service.shutdown();
//						while(!service.isTerminated()) {
//							Thread.sleep(10);
//						}
//						for(Future<Throwable> e:list) {
//							if(e.get()!=null) {
//								try {
//									throw e.get();
//								} catch (Throwable e1) {
//									// TODO Auto-generated catch block
//									e1.printStackTrace();
//								}
//							}
//						}
						if(!regionDict.getFunctionId().equals(560)) {
							List<BaseStringCfg> _stringCfgs=Lists.newArrayList(Constants.MAAT_JSON_SEND_SIZE);
							while(!stringCfgs.isEmpty()) {
								stringCfgs.drainTo(_stringCfgs, Constants.MAAT_JSON_SEND_SIZE);
								List<Integer> compileIds=Lists.newArrayList();
								List<Integer> groupIds=Lists.newArrayList();
								List<Integer> regionIds=Lists.newArrayList();
								try {
									 compileIds = ConfigServiceUtil.getId(1,_stringCfgs.size());
									 if(isSend.equals("1")) {
										 groupIds = ConfigServiceUtil.getId(2,_stringCfgs.size());
										 regionIds = ConfigServiceUtil.getId(3,_stringCfgs.size());
									 }
								} catch (Exception e) {
									e.printStackTrace();
									logger.info("获取编译ID出错");
									throw new MaatConvertException("<spring:message code=\"request_service_failed\"/>:"+e.getMessage());
								}
								int ind=0;
								for (BaseStringCfg cfg : _stringCfgs) {
									cfg.setAction(serviceDict.getAction());
									cfg.setCfgRegionCode(regionDict.getConfigRegionCode());
									cfg.setCfgType(regionDict.getConfigRegionValue());
									cfg.setCreateTime(date);
									cfg.setCreatorId(UserUtils.getUser().getId());
									//cfg.setDoLog(2);
									cfg.setFunctionId(regionDict.getFunctionId());
									if(isSend.equals("1")) {
										cfg.setIsAudit(Constants.AUDIT_YES);
										cfg.setIsValid(Constants.VALID_YES);
										cfg.setAuditorId(UserUtils.getUser().getId());
										cfg.setAuditTime(date);
										if(groupIds!=null&&groupIds.size()==_stringCfgs.size()) {
										cfg.setGroupId(groupIds.get(ind));
										}
										if(regionIds!=null&&regionIds.size()==_stringCfgs.size()) {
										cfg.setRegionId(regionIds.get(ind));
										}
									}else {
										cfg.setIsAudit(Constants.AUDIT_NOT_YET);
										cfg.setIsValid(Constants.VALID_NO);
									}
									cfg.setIsAreaEffective(0);
									cfg.setLable("0");
									cfg.setRequestId(StringUtil.isEmpty(requestId) ? 0 : requestId);
									cfg.setAttribute(attribute);
									cfg.setClassify(classify);
									cfg.setServiceId(serviceDict.getServiceId());
									if(compileIds!=null&&compileIds.size()==_stringCfgs.size()) {
										cfg.setCompileId(compileIds.get(ind));
									}
									if(specificServiceCfg!=null) {
										cfg.setAppCode(specificServiceCfg.getSpecServiceCode());
										cfg.setSpecServiceId(specificServiceCfg.getSpecServiceId());
										if(StringUtils.isNotBlank(behaviorId))
										cfg.setBehavCode(Integer.parseInt(behaviorId));
									}
									if (serviceDict.getServiceId().intValue() == 33
											|| serviceDict.getServiceId().intValue() == 145
											|| serviceDict.getServiceId().intValue() == 35
											|| serviceDict.getServiceId().intValue() == 147
											|| serviceDict.getServiceId().intValue() == 36
											|| serviceDict.getServiceId().intValue() == 148) {
										if (appRegion != null) {
											AppPolicyCfg appPolicyCfg = new AppPolicyCfg();
											BeanUtils.copyProperties(cfg, appPolicyCfg,new String[] {"cfgId"});
											//appPolicyCfg.setSpecServiceId(specificServiceCfg.getSpecServiceId());
											//appPolicyCfg.setAppCode(specificServiceCfg.getSpecServiceCode());
											appPolicyCfg.setMatchMethod(0);
											appPolicyCfg.setIsHexbin(0);
											appPolicyCfg.setCfgType(appRegion.getConfigRegionValue());
											appPolicyCfg.setCfgRegionCode(appRegion.getConfigRegionCode());
											if (StringUtils.isNotBlank(behaviorId)) {
												//appPolicyCfg.setBehavCode(Integer.parseInt(behaviorId));
												appPolicyCfg.setExprType(1);
											} else {
												appPolicyCfg.setExprType(0);
											}
											appPolicyCfgs.add(appPolicyCfg);
										}
									} else {
										if(!regionDict.getFunctionId().equals(403)) {
											CfgIndexInfo cfgIndexInfo = new CfgIndexInfo();
											BeanUtils.copyProperties(cfg, cfgIndexInfo, new String[] {"cfgId"});
											cfgIndexInfos.add(cfgIndexInfo);
										}
										
									}
									ind++;
								}
								ipCfgService.saveAndSend(regionDict, serviceDict, specificServiceCfg, _stringCfgs, cfgIndexInfos, appPolicyCfgs,appFeatureIndexs,asnNoMaps,isSend.equals("1"));
								cfgIndexInfos.clear();
								appPolicyCfgs.clear();
								_stringCfgs.clear();
							}
						}else {
							// 主题网站
							List<AppTopicDomainCfg> _topicDomainCfgs=Lists.newArrayList(Constants.MAAT_JSON_SEND_SIZE);
							while(!appTopicDomainCfgs.isEmpty()) {
								appTopicDomainCfgs.drainTo(_topicDomainCfgs, Constants.MAAT_JSON_SEND_SIZE);
								List<Integer> compileIds=Lists.newArrayList();
								List<Integer> groupIds=Lists.newArrayList();
								List<Integer> regionIds=Lists.newArrayList();
								try {
									 compileIds = ConfigServiceUtil.getId(1,_topicDomainCfgs.size());
									 if(isSend.equals("1")) {
										 groupIds = ConfigServiceUtil.getId(2,_topicDomainCfgs.size());
										 regionIds = ConfigServiceUtil.getId(3,_topicDomainCfgs.size());
									 }
								} catch (Exception e) {
									e.printStackTrace();
									logger.info("获取编译ID出错");
									throw new MaatConvertException("<spring:message code=\"request_service_failed\"/>:"+e.getMessage());
								}
								int ind=0;
								for (AppTopicDomainCfg cfg : _topicDomainCfgs) {
									cfg.setAction(serviceDict.getAction());
									cfg.setCfgRegionCode(regionDict.getConfigRegionCode());
									cfg.setCfgType(regionDict.getConfigRegionValue());
									cfg.setCreateTime(date);
									cfg.setCreatorId(UserUtils.getUser().getId());
									//cfg.setDoLog(2);
									cfg.setFunctionId(regionDict.getFunctionId());
									if(isSend.equals("1")) {
										cfg.setIsAudit(Constants.AUDIT_YES);
										cfg.setIsValid(Constants.VALID_YES);
										cfg.setAuditorId(UserUtils.getUser().getId());
										cfg.setAuditTime(date);
										if(groupIds!=null&&groupIds.size()==_topicDomainCfgs.size()) {
										cfg.setGroupId(groupIds.get(ind));
										}
										if(regionIds!=null&&regionIds.size()==_topicDomainCfgs.size()) {
										cfg.setRegionId(regionIds.get(ind));
										}
									}else {
										cfg.setIsAudit(Constants.AUDIT_NOT_YET);
										cfg.setIsValid(Constants.VALID_NO);
									}
									cfg.setIsAreaEffective(0);
									cfg.setLable("0");
									cfg.setRequestId(StringUtil.isEmpty(requestId) ? 0 : requestId);
									cfg.setAttribute(attribute);
									cfg.setClassify(classify);
									cfg.setServiceId(serviceDict.getServiceId());
									if(compileIds!=null&&compileIds.size()==_topicDomainCfgs.size()) {
										cfg.setCompileId(compileIds.get(ind));
									}
									ind++;
								}
								ipCfgService.saveAndSend(regionDict, serviceDict, specificServiceCfg, _topicDomainCfgs, cfgIndexInfos, appPolicyCfgs,appFeatureIndexs,asnNoMaps,isSend.equals("1"));
								cfgIndexInfos.clear();
								_topicDomainCfgs.clear();
							}
						}
					} else if (regionDict.getRegionType().equals(3)) {
						if(!regionDict.getFunctionId().equals(563)) {
							List<ComplexkeywordCfg> _complexkeywordCfgs=Lists.newArrayList(Constants.MAAT_JSON_SEND_SIZE);
							while(!complexkeywordCfgs.isEmpty()) {
								complexkeywordCfgs.drainTo(_complexkeywordCfgs, Constants.MAAT_JSON_SEND_SIZE);
								List<Integer> compileIds=Lists.newArrayList();
								List<Integer> groupIds=Lists.newArrayList();
								List<Integer> regionIds=Lists.newArrayList();
								try {
									compileIds = ConfigServiceUtil.getId(1,_complexkeywordCfgs.size());
									if(isSend.equals("1")) {
										groupIds = ConfigServiceUtil.getId(2,_complexkeywordCfgs.size());
										regionIds = ConfigServiceUtil.getId(3,_complexkeywordCfgs.size());
									}
								} catch (Exception e) {
									e.printStackTrace();
									logger.info("获取编译ID出错");
									throw new MaatConvertException("<spring:message code=\"request_service_failed\"/>:"+e.getMessage());
								}
								int ind=0;
								for (ComplexkeywordCfg cfg : _complexkeywordCfgs) {
									cfg.setAction(serviceDict.getAction());
									/*cfg.setAuditorId(UserUtils.getUser().getId());
									cfg.setAuditTime(date);*/
									cfg.setCfgRegionCode(regionDict.getConfigRegionCode());
									cfg.setCfgType(regionDict.getConfigRegionValue());
									cfg.setCreateTime(date);
									cfg.setCreatorId(UserUtils.getUser().getId());
									//cfg.setDoLog(2);
									cfg.setFunctionId(regionDict.getFunctionId());
									if(isSend.equals("1")) {
										cfg.setIsAudit(Constants.AUDIT_YES);
										cfg.setIsValid(Constants.VALID_YES);
										cfg.setAuditorId(UserUtils.getUser().getId());
										cfg.setAuditTime(date);
										if(groupIds!=null&&groupIds.size()==_complexkeywordCfgs.size()) {
											cfg.setGroupId(groupIds.get(ind));
										}
										if(regionIds!=null&&regionIds.size()==_complexkeywordCfgs.size()) {
											cfg.setRegionId(regionIds.get(ind));
										}
									}else {
										cfg.setIsAudit(Constants.AUDIT_NOT_YET);
										cfg.setIsValid(Constants.VALID_NO);
									}
									//cfg.setIsAudit(0);
									//cfg.setIsValid(0);
									cfg.setIsAreaEffective(0);
									cfg.setLable("0");
									cfg.setRequestId(StringUtil.isEmpty(requestId) ? 0 : requestId);
									cfg.setAttribute(attribute);
									cfg.setClassify(classify);
									cfg.setServiceId(serviceDict.getServiceId());
									if(compileIds!=null&&compileIds.size()==_complexkeywordCfgs.size()) {
										cfg.setCompileId(compileIds.get(ind));
									}
									if(specificServiceCfg!=null) {
										cfg.setAppCode(specificServiceCfg.getSpecServiceCode());
										cfg.setSpecServiceId(specificServiceCfg.getSpecServiceId());
										if(StringUtils.isNotBlank(behaviorId))
											cfg.setBehavCode(Integer.parseInt(behaviorId));
									}
									if (serviceDict.getServiceId().intValue() == 33
											|| serviceDict.getServiceId().intValue() == 145
											|| serviceDict.getServiceId().intValue() == 35
											|| serviceDict.getServiceId().intValue() == 147
											|| serviceDict.getServiceId().intValue() == 36
											|| serviceDict.getServiceId().intValue() == 148) {
										if (appRegion != null) {
											AppPolicyCfg appPolicyCfg = new AppPolicyCfg();
											BeanUtils.copyProperties(cfg, appPolicyCfg,new String[] {"cfgId"});
											//appPolicyCfg.setSpecServiceId(specificServiceCfg.getSpecServiceId());
											//appPolicyCfg.setAppCode(specificServiceCfg.getSpecServiceCode());
											appPolicyCfg.setMatchMethod(0);
											appPolicyCfg.setIsHexbin(0);
											appPolicyCfg.setCfgType(appRegion.getConfigRegionValue());
											appPolicyCfg.setCfgRegionCode(appRegion.getConfigRegionCode());
											if (StringUtils.isNotBlank(behaviorId)) {
												//appPolicyCfg.setBehavCode(Integer.parseInt(behaviorId));
												appPolicyCfg.setExprType(1);
											} else {
												appPolicyCfg.setExprType(0);
											}
											appPolicyCfgs.add(appPolicyCfg);
										}
									} else {
										if(!regionDict.getFunctionId().equals(402) && !regionDict.getFunctionId().equals(565)
												&& !regionDict.getFunctionId().equals(566) && !regionDict.getFunctionId().equals(564)) {
											CfgIndexInfo cfgIndexInfo = new CfgIndexInfo();
											BeanUtils.copyProperties(cfg, cfgIndexInfo,new String[] {"cfgId"});
											cfgIndexInfos.add(cfgIndexInfo);
										}
										if(regionDict.getFunctionId().intValue()==565 || regionDict.getFunctionId().intValue()==566 
												|| regionDict.getFunctionId().intValue()==564){
											AppFeatureIndex  appfeature = new AppFeatureIndex();
											BeanUtils.copyProperties(cfg, appfeature,new String[] {"cfgId"});
											if(regionDict!=null){
												appfeature.setCfgRegionCode1(String.valueOf(regionDict.getConfigRegionCode()));
												appfeature.setCfgRegionValue(regionDict.getConfigRegionValue());
												appfeature.setCfgRegionType(String.valueOf(regionDict.getRegionType()));
											}
											appFeatureIndexs.add(appfeature);
										}
									}
									ind++;
								}
								ipCfgService.saveAndSend(regionDict, serviceDict, specificServiceCfg, _complexkeywordCfgs, cfgIndexInfos, appPolicyCfgs,appFeatureIndexs,asnNoMaps,isSend.equals("1"));
								cfgIndexInfos.clear();
								appPolicyCfgs.clear();
								_complexkeywordCfgs.clear();
								appFeatureIndexs.clear();
							}
							
						}else {
							// APP Payload处理
							List<AppComplexFeatureCfg> _complexkeywordCfgs=Lists.newArrayList(Constants.MAAT_JSON_SEND_SIZE);
							while(!appComplexFeatureCfgs.isEmpty()) {
								appComplexFeatureCfgs.drainTo(_complexkeywordCfgs, Constants.MAAT_JSON_SEND_SIZE);
								List<Integer> compileIds=Lists.newArrayList();
								List<Integer> groupIds=Lists.newArrayList();
								List<Integer> regionIds=Lists.newArrayList();
								try {
									 compileIds = ConfigServiceUtil.getId(1,_complexkeywordCfgs.size());
									 if(isSend.equals("1")) {
										 groupIds = ConfigServiceUtil.getId(2,_complexkeywordCfgs.size());
										 regionIds = ConfigServiceUtil.getId(3,_complexkeywordCfgs.size());
									 }
								} catch (Exception e) {
									e.printStackTrace();
									logger.info("获取编译ID出错");
									throw new MaatConvertException("<spring:message code=\"request_service_failed\"/>:"+e.getMessage());
								}
								int ind=0;
								for (AppComplexFeatureCfg cfg : _complexkeywordCfgs) {
									cfg.setAction(serviceDict.getAction());
									/*cfg.setAuditorId(UserUtils.getUser().getId());
									cfg.setAuditTime(date);*/
									cfg.setCfgRegionCode(regionDict.getConfigRegionCode());
									cfg.setCfgType(regionDict.getConfigRegionValue());
									cfg.setCreateTime(date);
									cfg.setCreatorId(UserUtils.getUser().getId());
									cfg.setDoLog(2);
									cfg.setFunctionId(regionDict.getFunctionId());
									if(isSend.equals("1")) {
										cfg.setIsAudit(Constants.AUDIT_YES);
										cfg.setIsValid(Constants.VALID_YES);
										cfg.setAuditorId(UserUtils.getUser().getId());
										cfg.setAuditTime(date);
										if(groupIds!=null&&groupIds.size()==_complexkeywordCfgs.size()) {
										cfg.setGroupId(groupIds.get(ind));
										}
										if(regionIds!=null&&regionIds.size()==_complexkeywordCfgs.size()) {
										cfg.setRegionId(regionIds.get(ind));
										}
									}else {
										cfg.setIsAudit(Constants.AUDIT_NOT_YET);
										cfg.setIsValid(Constants.VALID_NO);
									}
									//cfg.setIsAudit(0);
									//cfg.setIsValid(0);
									cfg.setIsAreaEffective(0);
									cfg.setLable("0");
									cfg.setRequestId(StringUtil.isEmpty(requestId) ? 0 : requestId);
									cfg.setAttribute(attribute);
									cfg.setClassify(classify);
									cfg.setServiceId(serviceDict.getServiceId());
									if(compileIds!=null&&compileIds.size()==_complexkeywordCfgs.size()) {
										cfg.setCompileId(compileIds.get(ind));
									}
									if(specificServiceCfg!=null) {
										cfg.setAppCode(specificServiceCfg.getSpecServiceCode());
										cfg.setSpecServiceId(specificServiceCfg.getSpecServiceId());
										if(StringUtils.isNotBlank(behaviorId))
										cfg.setBehavCode(Integer.parseInt(behaviorId));
									}
									
									AppFeatureIndex  appfeature = new AppFeatureIndex();
									BeanUtils.copyProperties(cfg, appfeature,new String[] {"cfgId"});
									if(regionDict!=null){
										appfeature.setCfgRegionCode1(String.valueOf(regionDict.getConfigRegionCode()));
										appfeature.setCfgRegionValue(regionDict.getConfigRegionValue());
										appfeature.setCfgRegionType(String.valueOf(regionDict.getRegionType()));
									}
									appFeatureIndexs.add(appfeature);
									ind++;
								}
								ipCfgService.saveAndSend(regionDict, serviceDict, specificServiceCfg, _complexkeywordCfgs, cfgIndexInfos, appPolicyCfgs,appFeatureIndexs,asnNoMaps,isSend.equals("1"));
								cfgIndexInfos.clear();
								appPolicyCfgs.clear();
								_complexkeywordCfgs.clear();
								appFeatureIndexs.clear();
							}
						}
					}else if(regionDict.getRegionType().equals(6)) {
						if(regionDict.getFunctionId().equals(400)) {
							List<DnsResStrategy> _dnsResStrategies=Lists.newArrayList(Constants.MAAT_JSON_SEND_SIZE);
							while(!dnsResStrategies.isEmpty()) {
								dnsResStrategies.drainTo(_dnsResStrategies, Constants.MAAT_JSON_SEND_SIZE);
								List<Integer> compileIds=Lists.newArrayList();
								try {
									 compileIds = ConfigServiceUtil.getId(1,_dnsResStrategies.size());
								} catch (Exception e) {
									e.printStackTrace();
									logger.info("获取编译ID出错");
									throw new MaatConvertException("<spring:message code=\"request_service_failed\"/>:"+e.getMessage());
								}
								int ind=0;
								for(DnsResStrategy cfg:_dnsResStrategies) {
									cfg.setAction(serviceDict.getAction());
									/*cfg.setAuditorId(UserUtils.getUser().getId());
									cfg.setAuditTime(date);*/
									cfg.setCfgRegionCode(regionDict.getConfigRegionCode());
									cfg.setCfgType(regionDict.getConfigRegionValue());
									cfg.setCreateTime(date);
									cfg.setCreatorId(UserUtils.getUser().getId());
									cfg.setDoLog(2);
									cfg.setFunctionId(regionDict.getFunctionId());
									cfg.setIsAudit(0);
									cfg.setIsValid(0);
									cfg.setIsAreaEffective(0);
									cfg.setLable("0");
									cfg.setRequestId(StringUtil.isEmpty(requestId) ? 0 : requestId);
									cfg.setAttribute(attribute);
									cfg.setClassify(classify);
									cfg.setServiceId(serviceDict.getServiceId());
									cfg.setCompileId(compileIds.get(ind));
									ind++;
								}
								ipCfgService.saveAndSend(regionDict, serviceDict, specificServiceCfg, _dnsResStrategies, cfgIndexInfos, appPolicyCfgs,appFeatureIndexs,asnNoMaps,isSend.equals("1"));
								_dnsResStrategies.clear();
								cfgIndexInfos.clear();
								appPolicyCfgs.clear();
							}
						}
					}
				}
				if(errTip.toString().length()>0) {
					addMessage(redirectAttributes,"error", errTip.toString());
				}
		} catch (Exception e) {
			if(ei!=null) {
				if(ei.getUploadFile().exists()) {
					ei.getUploadFile().delete();
				}
			}
			if(e instanceof MaatConvertException) {
				addMessage(redirectAttributes,"error", "request_service_failed");
			}else if(e instanceof ServiceException) {
				addMessage(redirectAttributes,"error", e.getMessage());
			}else if(e instanceof IndexOutOfBoundsException){
				addMessage(redirectAttributes,"error", "template_error");
			}else {
				addMessage(redirectAttributes,"error",  "import_failed");
			}
			e.printStackTrace();
		}
		long end=System.currentTimeMillis();
		logger.warn("import finish,cost:"+(end-start));
	}
	
	public void deleteIps(Map<Long,AsnGroupInfo> asnNoMap,Integer ipType){
		List<AsnIpCfg> toDelAndSendAsnIpCfgs=Lists.newArrayList();
		List<Long> asnIds=Lists.newArrayList(asnNoMap.size());
		for(Entry<Long, AsnGroupInfo> e:asnNoMap.entrySet()) {
			AsnGroupInfo asnGroupInfo=e.getValue();
			if(asnGroupInfo==null) {
				asnGroupInfo=asnIpCfgService.getAsnGroupInfoByAsnNo(e.getKey());
			}
			if(asnGroupInfo.getIsValid()==1) {//已下发
				List<AsnIpCfg> _toDelAsnIpCfgs=asnIpCfgService.getByAsnNo(asnGroupInfo.getAsnId());
				toDelAndSendAsnIpCfgs.addAll(_toDelAsnIpCfgs);
			}else {
				asnIds.add(e.getKey());
			}
		}
		if(asnIds.size()>0) {
			asnIpCfgService.deleteByAsnNo(asnIds,ipType);
		}
		if(toDelAndSendAsnIpCfgs.size()>0) {
			int pointsDataLimit = Constants.MAAT_JSON_SEND_SIZE;//限制条数
			Integer size = toDelAndSendAsnIpCfgs.size();
			//判断是否有必要分批
			if(pointsDataLimit<size){
				int part = size/pointsDataLimit;//分批数
				for (int i = 0; i < part; i++) {
					//pointsDataLimit条
					List<AsnIpCfg> listPage = toDelAndSendAsnIpCfgs.subList(0, pointsDataLimit);
					asnIpCfgService.delAndSend(listPage);
					//剔除
					toDelAndSendAsnIpCfgs.subList(0, pointsDataLimit).clear();
				}
				//最后剩下的
				if(!toDelAndSendAsnIpCfgs.isEmpty()){
					asnIpCfgService.delAndSend(toDelAndSendAsnIpCfgs);
					
				}
			}else {
				asnIpCfgService.delAndSend(toDelAndSendAsnIpCfgs);
			}
		}
	}
	/**
	 * 加载模板
	 * @param ei
	 * @param regionDict
	 * @param serviceDict
	 */
	public void loadTemplate(ImportBigExcel ei,FunctionRegionDict regionDict,FunctionServiceDict serviceDict) {
		Properties msgProp = this.getMsgProp();
		if (regionDict.getRegionType().equals(1)) {// IP
			if (regionDict.getFunctionId().equals(5)) {
				if (serviceDict!=null&&serviceDict.getAction().equals(64)) {
					ei.loadInitParams(IpRateLimitTemplate.class, msgProp, regionDict, serviceDict);
				} else if(serviceDict!=null&&serviceDict.getAction().equals(32)) {
					ei.loadInitParams(IpAllNotDoLogTemplate.class, msgProp, regionDict, serviceDict);
				} else {
					ei.loadInitParams(IpAllTemplate.class, msgProp, regionDict, serviceDict);
				}
			} else if (regionDict.getFunctionId().equals(7)&&serviceDict!=null&&serviceDict.getAction().intValue()==16) {
				ei.loadInitParams(DnsIpTemplate.class, msgProp, regionDict, serviceDict);
			}else if(regionDict.getFunctionId().equals(401)) {
				ei.loadInitParams(DnsFakeIpTemplate.class, msgProp, regionDict, serviceDict);
			}else if (regionDict.getFunctionId().equals(212)) {
				ei.loadInitParams(IpPayloadTemplate.class, msgProp, regionDict, serviceDict);
			} else if (regionDict.getFunctionId().equals(510)
					&& "p2p_ip".equals(regionDict.getConfigServiceType())) { // P2p IP
				ei.loadInitParams(P2pIpTemplate.class, msgProp, regionDict, serviceDict);
			} else if (regionDict.getFunctionId().equals(600)) {// ASN IP
				ei.loadInitParams(AsnIpTemplate.class, msgProp, regionDict, serviceDict);
			} else if (regionDict.getFunctionId().equals(301)) {// DDOS IP
				ei.loadInitParams(DdosIpTemplate.class, msgProp, regionDict, serviceDict);
			} else if(regionDict.getFunctionId().equals(207)){// HTTP(s)阻断
				ei.loadInitParams(HttpsRejectIpTemplate.class, this.getMsgProp(), regionDict, serviceDict);
			} else if(regionDict.getFunctionId().equals(208)){// HTTP(s)重定向
				ei.loadInitParams(HttpsRedirectIpTemplate.class, this.getMsgProp(), regionDict, serviceDict);
			} else if(regionDict.getFunctionId().equals(209)){// HTTP(s)替换
				ei.loadInitParams(HttpsReplaceIpTemplate.class, this.getMsgProp(), regionDict, serviceDict);
			} else if(regionDict.getFunctionId().equals(211)){// HTTP(s)白名单
				ei.loadInitParams(IpAllNotDoLogTemplate.class, this.getMsgProp(), regionDict, serviceDict);
			} else if(regionDict.getFunctionId().equals(200)){// 拦截策略
				if(serviceDict.getAction().intValue()==64) {
					ei.loadInitParams(IpRateLimitTemplate.class, msgProp, regionDict, serviceDict);
				}else {
					ei.loadInitParams(IpAllNotDoLogTemplate.class, msgProp, regionDict, serviceDict);
				}
			} else if(regionDict.getFunctionId().equals(3)) { // IP白名单
				ei.loadInitParams(IpWhitelistTemplate.class, msgProp, regionDict, serviceDict);
			} else if(regionDict.getFunctionId().equals(214)) { // IpSpoofing
				ei.loadInitParams(IpSpoofingTemplate.class, msgProp, regionDict, serviceDict);
			} else if(regionDict.getFunctionId().equals(405) || regionDict.getFunctionId().equals(563) || regionDict.getFunctionId().equals(565)
					|| regionDict.getFunctionId().equals(566)) { // APP Feature IP
					ei.loadInitParams(IpAllNotDoLogTemplate.class, msgProp, regionDict, serviceDict);
			} else if((regionDict.getFunctionId().equals(63) || regionDict.getFunctionId().equals(407) || regionDict.getFunctionId().equals(408)) && serviceDict.getAction().equals(64)){ // Policies -> Stream
				ei.loadInitParams(IpRateLimitTemplate.class, msgProp, regionDict, serviceDict);
			}else {
				ei.loadInitParams(IpAllTemplate.class, msgProp, regionDict, serviceDict);
			}
		} else if (regionDict.getRegionType().equals(2)) {// 字符串类
			if (regionDict.getFunctionId().equals(510)
					&& "p2p_hash".equals(regionDict.getConfigServiceType())) { // P2p hash
				ei.loadInitParams(P2pHashStringTemplate.class, msgProp, regionDict, serviceDict);
			}else if (regionDict.getFunctionId().equals(403)) {
				ei.loadInitParams(AppDomainTemplate.class, msgProp, regionDict, serviceDict);
			} else if(regionDict.getFunctionId().equals(200)){// 拦截策略 domain
				if(serviceDict.getAction().equals(1)){// 监测
					ei.loadInitParams(DomainInterceptMonitTemplate.class, msgProp, regionDict, serviceDict);
				}else if(serviceDict.getAction().equals(64)){// 限速
					ei.loadInitParams(DomainInterceptRateLimitTemplate.class, msgProp, regionDict, serviceDict);
				}else{// 白名单
					ei.loadInitParams(DomainInterceptTemplate.class, msgProp, regionDict, serviceDict);
				}
			}else if(regionDict.getFunctionId().equals(207)){// HTTP(s)阻断
				ei.loadInitParams(HttpsRejectTemplate.class, this.getMsgProp(), regionDict, serviceDict);
			}else if(regionDict.getFunctionId().equals(208)){// HTTP(s)重定向
				ei.loadInitParams(HttpsRedirectTemplate.class, this.getMsgProp(), regionDict, serviceDict);
			}else if(regionDict.getFunctionId().equals(209)){// HTTP(s)替换
				ei.loadInitParams(HttpsReplaceTemplate.class, this.getMsgProp(), regionDict, serviceDict);
			}else if(regionDict.getFunctionId().equals(211)){// HTTP(s)白名单
				ei.loadInitParams(StringAllNotDoLogTemplate.class, this.getMsgProp(), regionDict, serviceDict);
			}else if(regionDict.getFunctionId().equals(560)){// 主题网站
				ei.loadInitParams(TopicWebsiteTemplate.class, this.getMsgProp(), regionDict, serviceDict);
			}else {
				ei.loadInitParams(StringAllTemplate.class, msgProp, regionDict, serviceDict);
			}

		} else if (regionDict.getRegionType().equals(3)) {// 增强字符串类
			if (regionDict.getFunctionId().equals(7)&&serviceDict!=null&&serviceDict.getAction().intValue()==16) {
				ei.loadInitParams(DnsComplexStringTemplate.class, msgProp, regionDict, serviceDict);
			}else if(regionDict.getFunctionId().equals(207)){// HTTP(s)阻断
				ei.loadInitParams(HttpsRejectComplexTemplate.class, this.getMsgProp(), regionDict, serviceDict);
			}else if(regionDict.getFunctionId().equals(208)){// HTTP(s)重定向
				ei.loadInitParams(HttpsRedirectComplexTemplate.class, this.getMsgProp(), regionDict, serviceDict);
			}else if(regionDict.getFunctionId().equals(209)){// HTTP(s)替换
				ei.loadInitParams(HttpsReplaceComplexTemplate.class, this.getMsgProp(), regionDict, serviceDict);
			}else if(regionDict.getFunctionId().equals(211)){// HTTP(s)白名单
				ei.loadInitParams(ComplexStringAllNotDoLogTemplate.class, this.getMsgProp(), regionDict, serviceDict);
			}else if(regionDict.getFunctionId().equals(563)) {// APP Payload
				ei.loadInitParams(AppPayloadTemplate.class, this.getMsgProp(), regionDict, serviceDict);
			}else if(regionDict.getFunctionId().equals(565) || regionDict.getFunctionId().equals(564) || regionDict.getFunctionId().equals(566)){// APP Feature StrPlus
				ei.loadInitParams(ComplexStringAllNotDoLogTemplate.class, this.getMsgProp(), regionDict, serviceDict);
			} else {
				ei.loadInitParams(ComplexStringAllTemplate.class, msgProp, regionDict, serviceDict);
			}

		}else if (regionDict.getRegionType().equals(6)) {// 回调类
			if (regionDict.getFunctionId().equals(400)) {
				ei.loadInitParams(DnsResStrategyTemplate.class, msgProp, regionDict, serviceDict);
			} 
		}
		
	}
	/**
	 * 多域配置导出
	 * 
	 * @param columns
	 * @param model
	 * @param request
	 * @param response
	 * @param entity
	 * @param ids
	 * @param redirectAttributes
	 */
	public void _export(Model model, HttpServletRequest request, HttpServletResponse response,
			RedirectAttributes redirectAttributes, String functionName, List<String> titleList,
			Map<String, Class<?>> classMap, Map<String, List> dataMap, Map<String, String> noExportMap)
			throws Exception {
		// 获取国际化配置
		Properties msgProp = getMsgProp();
		// 获取分类、性质、标签
		List<ServiceDictInfo> fls = serviceDictInfoService.findAllFlDict();
		List<ServiceDictInfo> xzs = serviceDictInfoService.findAllXzDict();
		List<ServiceDictInfo> labels = serviceDictInfoService.findAllLableDict();
		Map<Object, Object> map = new HashMap<Object, Object>();
		map.put("fls", fls);
		map.put("xzs", xzs);
		map.put("labels", labels);

		String fileName = msgProp.getProperty(functionName, functionName) + "_" + DateUtils.getDate("yyyyMMddHHmmss")
				+ ".xlsx";

		fileName = fileName.replaceAll(" ", "_");
		if (request.getHeader("User-Agent").toUpperCase().indexOf("MSIE") > 0) {
			fileName = URLEncoder.encode(fileName, "UTF-8");
		} else {
			fileName = new String(fileName.getBytes("UTF-8"), "ISO8859-1");
		}
		String titleTime=noExportMap.get("timeRange");
		new ExportExcel(msgProp, titleList, noExportMap, classMap, 1,titleTime).setDataList(msgProp, dataMap, map)
				.write(response, fileName).dispose();
	}
	
	
	public void _exportCsv(Model model, HttpServletRequest request, HttpServletResponse response,
			RedirectAttributes redirectAttributes, String functionName, List<String> titleList,
			Map<String, Class<?>> classMap, Map<String, List> dataMap, Map<String, String> noExportMap)
			throws Exception {
		// 获取国际化配置
		Properties msgProp = getMsgProp();
		// 获取分类、性质、标签
		List<ServiceDictInfo> fls = serviceDictInfoService.findAllFlDict();
		List<ServiceDictInfo> xzs = serviceDictInfoService.findAllXzDict();
		List<ServiceDictInfo> labels = serviceDictInfoService.findAllLableDict();
		Map<Object, Object> map = new HashMap<Object, Object>();
		map.put("fls", fls);
		map.put("xzs", xzs);
		map.put("labels", labels);

		String fileName = msgProp.getProperty(functionName, functionName) + "_" + DateUtils.getDate("yyyyMMddHHmmss")
				+ ".csv";

		fileName = fileName.replaceAll(" ", "_");
		if (request.getHeader("User-Agent").toUpperCase().indexOf("MSIE") > 0) {
			fileName = URLEncoder.encode(fileName, "UTF-8");
		} else {
			fileName = new String(fileName.getBytes("UTF-8"), "ISO8859-1");
		}
		String titleTime=noExportMap.get("timeRange");
		Map<String, List<String>> headMap=ExcelCsv.ExcelCsvHeader(msgProp, titleList, noExportMap, classMap, 1);
		Map<String,List<List<String>>> dataList=ExcelCsv.setDataList(msgProp, dataMap, map);
		ExcelCsv.writeCSVFile(response,titleList,headMap,dataList,fileName,titleTime,msgProp);
	}
	
	
	public void _ajaxExport(HttpServletRequest request, HttpServletResponse response,
			String code,String titleTime,List<String> headerList, List<List<Object>> dataList)
					throws Exception{
		Properties msgProp = getMsgProp();
		String fileName = msgProp.getProperty(code, code) + "_" + DateUtils.getDate("yyyyMMddHHmmss")
		+ ".xlsx";
		fileName = fileName.replaceAll(" ", "_");
		if (request.getHeader("User-Agent").toUpperCase().indexOf("MSIE") > 0) {
			fileName = URLEncoder.encode(fileName, "UTF-8");
		} else {
			fileName = new String(fileName.getBytes("UTF-8"), "ISO8859-1");
		}		
		new ExportExcel(msgProp.getProperty(code, code),code,titleTime, headerList).ajaxDataList(dataList, code).write(response, fileName).dispose();
	}
	
	
	public void _ajaxCsv(HttpServletRequest request, HttpServletResponse response,
			String code,String titleTime,List<String> headerList, List<List<String>> dataList)
					throws Exception{
		Properties msgProp = getMsgProp();
		String fileName = msgProp.getProperty(code, code) + "_" + DateUtils.getDate("yyyyMMddHHmmss")
		+ ".csv";
		fileName = fileName.replaceAll(" ", "_");
		if (request.getHeader("User-Agent").toUpperCase().indexOf("MSIE") > 0) {
			fileName = URLEncoder.encode(fileName, "UTF-8");
		} else {
			fileName = new String(fileName.getBytes("UTF-8"), "ISO8859-1");
		}				
		ExcelCsv.ajaxCSVFile(response,headerList,dataList,fileName,titleTime,msgProp);
	}
	
	public String initLogMap(BaseLogEntity log,String title){
		Properties msgProp = getMsgProp();
		String logTime=msgProp.getProperty(title,title);;
		 if(log.getSearchFoundStartTime()!=null){
			 logTime+="  "+msgProp.getProperty("begin_date")+"："+log.getSearchFoundStartTime();
		 }
		 if(log.getSearchFoundEndTime()!=null){
			 logTime+="  "+msgProp.getProperty("end_date")+"："+log.getSearchFoundEndTime();
		 }
		return logTime;		
	}
	
	public String initTimeMap(BaseCfg cfg){
		Properties msgProp = getMsgProp();
		String titleTime=msgProp.getProperty(cfg.getMenuNameCode(),cfg.getMenuNameCode());
		if(cfg.getSearch_create_time_start()!=null){
			titleTime+="  "+msgProp.getProperty("config_time")+"："+DateUtils.formatDateTime(cfg.getSearch_create_time_start());
			if(cfg.getSearch_create_time_end()!=null){
				titleTime+="—"+DateUtils.formatDateTime(cfg.getSearch_create_time_end());
			}else{
				titleTime+="—"+DateUtils.getDateTime();
				
			}
		}
		if(cfg.getSearch_edit_time_start()!=null){
			titleTime+=" "+msgProp.getProperty("edit_time")+"："+DateUtils.formatDateTime(cfg.getSearch_edit_time_start());
			if(cfg.getSearch_edit_time_end()!=null){
				titleTime+="—"+DateUtils.formatDateTime(cfg.getSearch_edit_time_end());
			}else{
				titleTime+="—"+DateUtils.getDateTime();
			}
		}
		if(cfg.getSearch_audit_time_start()!=null){
			titleTime+=" "+msgProp.getProperty("audit_time")+"："+DateUtils.formatDateTime(cfg.getSearch_audit_time_start());
			if(cfg.getSearch_audit_time_end()!=null){
				titleTime+="—"+DateUtils.formatDateTime(cfg.getSearch_audit_time_end());
			}else{
				titleTime+="—"+DateUtils.getDateTime();
			}
		}
		return titleTime;
	}
	
	/**
	 * 批量审核
	 * @param isAudit
	 * @param isValid
	 * @param ids
	 * @param functionId
	 * @param redirectAttributes
	 * @return
	 */
	public void auditAll(Page page,Integer auditType,Object entity)throws Exception {
		long start=System.currentTimeMillis();
		page.setOrderBy("");
		page.setPageSize(Constants.MAAT_JSON_SEND_SIZE);
		page.setPageNo(1);
		page.setLastPage(false);
		//携带审核状态信息的BaseCfg
		BaseCfg auditBatchCfg=new BaseCfg();
		//携带审核条件的BaseCfg
		CfgIndexInfo searchCfg=new CfgIndexInfo();
		AppPolicyCfg searchAppCfg=new AppPolicyCfg();
		FileDigestCfg searchDigestCfg=new FileDigestCfg();
		AvFileSampleCfg searchFileSampleCfg=new AvFileSampleCfg();
		PxyObjKeyring searchObjKeyringCfg=new PxyObjKeyring();
		PxyObjTrustedCaCert searchTrustedCaCertCfg=new PxyObjTrustedCaCert();
		PxyObjTrustedCaCrl searchTrustedCaCrlCfg=new PxyObjTrustedCaCrl();
		DnsResStrategy searchDnsResStrategy=new DnsResStrategy();
		DnsIpCfg searchDnsIpCfg=new DnsIpCfg();
		IpPortCfg searchIpPortCfg=new IpPortCfg();
		AvSignSampleCfg searchSignSampleCfg=new AvSignSampleCfg();
		DdosIpCfg searchDdosIpCfg=new DdosIpCfg();
		AppIpCfg searchAppIpCfg=new AppIpCfg();
		AppHttpCfg searchAppHttpCfg=new AppHttpCfg();
		AppDomainCfg searchAppDomainCfg=new AppDomainCfg();
		AppTopicDomainCfg searchAppTopicCfg=new AppTopicDomainCfg();
		AppFeatureIndex searchAppFeatureIndex=new AppFeatureIndex();
		AppSslCertCfg searchAppSslCertCfg=new AppSslCertCfg();
		AsnIpCfg searchAsnIpCfg=new AsnIpCfg();
		if(entity != null  && (entity instanceof CfgIndexInfo)) {
			BeanUtils.copyProperties(entity, auditBatchCfg);
			BeanUtils.copyProperties(entity, searchCfg);
		}
		if(entity != null && (entity instanceof AppPolicyCfg)) {
			BeanUtils.copyProperties(entity, auditBatchCfg);
			BeanUtils.copyProperties(entity, searchAppCfg);
		}
		if(entity != null && (entity instanceof FileDigestCfg)) {
			BeanUtils.copyProperties(entity, auditBatchCfg);
			BeanUtils.copyProperties(entity, searchDigestCfg);
		}
		if(entity != null && (entity instanceof AvFileSampleCfg)) {
			BeanUtils.copyProperties(entity, auditBatchCfg);
			BeanUtils.copyProperties(entity, searchFileSampleCfg);
		}
		if(entity != null && (entity instanceof PxyObjKeyring)) {
			BeanUtils.copyProperties(entity, auditBatchCfg);
			BeanUtils.copyProperties(entity, searchObjKeyringCfg);
		}
		if(entity != null && (entity instanceof PxyObjTrustedCaCert)) {
			BeanUtils.copyProperties(entity, auditBatchCfg);
			BeanUtils.copyProperties(entity, searchTrustedCaCertCfg);
		}
		if(entity != null && (entity instanceof PxyObjTrustedCaCrl)) {
			BeanUtils.copyProperties(entity, auditBatchCfg);
			BeanUtils.copyProperties(entity, searchTrustedCaCrlCfg);
		}
		if(entity != null && (entity instanceof DnsResStrategy)) {
			BeanUtils.copyProperties(entity, auditBatchCfg);
			BeanUtils.copyProperties(entity, searchDnsResStrategy);
		}
		if(entity != null && (entity instanceof DnsIpCfg)) {
			BeanUtils.copyProperties(entity, auditBatchCfg);
			BeanUtils.copyProperties(entity, searchDnsIpCfg);
		}
		if(entity != null && (entity instanceof IpPortCfg)) {
			BeanUtils.copyProperties(entity, auditBatchCfg);
			BeanUtils.copyProperties(entity, searchIpPortCfg);
		}
		
		if(entity != null && (entity instanceof AvSignSampleCfg)) {
			BeanUtils.copyProperties(entity, auditBatchCfg);
			BeanUtils.copyProperties(entity, searchSignSampleCfg);
		}
		if(entity != null && (entity instanceof DdosIpCfg)) {
			BeanUtils.copyProperties(entity, auditBatchCfg);
			BeanUtils.copyProperties(entity, searchDdosIpCfg);
		}
		if(entity != null && (entity instanceof AppIpCfg)) {
			BeanUtils.copyProperties(entity, auditBatchCfg);
			BeanUtils.copyProperties(entity, searchAppIpCfg);
		}
		if(entity != null && (entity instanceof AppHttpCfg)) {
			BeanUtils.copyProperties(entity, auditBatchCfg);
			BeanUtils.copyProperties(entity, searchAppHttpCfg);
		}
		if(entity != null && (entity instanceof AppDomainCfg)) {
			BeanUtils.copyProperties(entity, auditBatchCfg);
			BeanUtils.copyProperties(entity, searchAppDomainCfg);
		}
		if(entity != null && (entity instanceof AppTopicDomainCfg)) {
			BeanUtils.copyProperties(entity, auditBatchCfg);
			BeanUtils.copyProperties(entity, searchAppTopicCfg);
		}
		if(entity != null && (entity instanceof AppFeatureIndex)) {
			BeanUtils.copyProperties(entity, auditBatchCfg);
			BeanUtils.copyProperties(entity, searchAppFeatureIndex);
		}
		if(entity != null && (entity instanceof AppSslCertCfg)) {
			BeanUtils.copyProperties(entity, auditBatchCfg);
			BeanUtils.copyProperties(entity, searchAppSslCertCfg);
		}
		if(entity != null && (entity instanceof AsnIpCfg)) {
			BeanUtils.copyProperties(entity, auditBatchCfg);
			BeanUtils.copyProperties(entity, searchAsnIpCfg);
		}
		
		auditType = (Integer)Reflections.invokeGetter(entity, "isAudit");
		
		//全部审核通过，只查询当前条件下的所有未审核的配置 -批量审核通过/不通过
		if(auditType.equals(1) || auditType.equals(2)) {
			searchCfg.setIsValid(0);
			searchCfg.setIsAudit(0);
			searchAppCfg.setIsValid(0);
			searchAppCfg.setIsAudit(0);
			searchDigestCfg.setIsValid(0);
			searchDigestCfg.setIsAudit(0);
			searchFileSampleCfg.setIsValid(0);
			searchFileSampleCfg.setIsAudit(0);
			searchObjKeyringCfg.setIsValid(0);
			searchObjKeyringCfg.setIsAudit(0);
			searchTrustedCaCertCfg.setIsValid(0);
			searchTrustedCaCertCfg.setIsAudit(0);
			searchTrustedCaCrlCfg.setIsValid(0);
			searchTrustedCaCrlCfg.setIsAudit(0);
			searchDnsResStrategy.setIsValid(0);
			searchDnsResStrategy.setIsAudit(0);
			searchDnsIpCfg.setIsValid(0);
			searchDnsIpCfg.setIsAudit(0);
			searchIpPortCfg.setIsValid(0);
			searchIpPortCfg.setIsAudit(0);
			searchSignSampleCfg.setIsValid(0);
			searchSignSampleCfg.setIsAudit(0);
			searchDdosIpCfg.setIsValid(0);
			searchDdosIpCfg.setIsAudit(0);
			searchAppIpCfg.setIsValid(0);
			searchAppIpCfg.setIsAudit(0);
			searchAppHttpCfg.setIsValid(0);
			searchAppHttpCfg.setIsAudit(0);
			searchAppDomainCfg.setIsValid(0);
			searchAppDomainCfg.setIsAudit(0);
			searchAppTopicCfg.setIsValid(0);
			searchAppTopicCfg.setIsAudit(0);
			searchAppFeatureIndex.setIsValid(0);
			searchAppFeatureIndex.setIsAudit(0);
			searchAppSslCertCfg.setIsValid(0);
			searchAppSslCertCfg.setIsAudit(0);
			searchAsnIpCfg.setIsValid(0);
			searchAsnIpCfg.setIsAudit(0);
			
			if(auditType.equals(1)) {
				auditBatchCfg.setIsAudit(1);
				auditBatchCfg.setIsValid(1);
			}else {
				auditBatchCfg.setIsAudit(2);
				auditBatchCfg.setIsValid(0);
			}
			auditBatchCfg.setAuditTime(new Date());
			auditBatchCfg.setAuditorId(UserUtils.getUser().getId());
		}else {
		//全部取消通过，只查询当前条件下的所有审核通过的配置
			searchCfg.setIsValid(1);
			searchCfg.setIsAudit(1);
			searchAppCfg.setIsValid(1);
			searchAppCfg.setIsAudit(1);
			searchDigestCfg.setIsValid(1);
			searchDigestCfg.setIsAudit(1);
			searchFileSampleCfg.setIsValid(1);
			searchFileSampleCfg.setIsAudit(1);
			searchObjKeyringCfg.setIsValid(1);
			searchObjKeyringCfg.setIsAudit(1);
			searchTrustedCaCertCfg.setIsValid(1);
			searchTrustedCaCertCfg.setIsAudit(1);
			searchTrustedCaCrlCfg.setIsValid(1);
			searchTrustedCaCrlCfg.setIsAudit(1);
			searchDnsResStrategy.setIsValid(1);
			searchDnsResStrategy.setIsAudit(1);
			searchDnsIpCfg.setIsValid(1);
			searchDnsIpCfg.setIsAudit(1);
			searchIpPortCfg.setIsValid(1);
			searchIpPortCfg.setIsAudit(1);
			searchSignSampleCfg.setIsValid(1);
			searchSignSampleCfg.setIsAudit(1);
			searchDdosIpCfg.setIsValid(1);
			searchDdosIpCfg.setIsAudit(1);
			searchAppIpCfg.setIsValid(1);
			searchAppIpCfg.setIsAudit(1);
			searchAppHttpCfg.setIsValid(1);
			searchAppHttpCfg.setIsAudit(1);
			searchAppDomainCfg.setIsValid(1);
			searchAppDomainCfg.setIsAudit(1);
			searchAppTopicCfg.setIsValid(1);
			searchAppTopicCfg.setIsAudit(1);
			searchAppFeatureIndex.setIsValid(1);
			searchAppFeatureIndex.setIsAudit(1);
			searchAppSslCertCfg.setIsValid(1);
			searchAppSslCertCfg.setIsAudit(1);
			searchAsnIpCfg.setIsValid(1);
			searchAsnIpCfg.setIsAudit(1);
			
			auditBatchCfg.setIsAudit(3);
			auditBatchCfg.setIsValid(0);
			auditBatchCfg.setAuditTime(new Date());
			auditBatchCfg.setAuditorId(UserUtils.getUser().getId());
		}
		
		ServiceConfigTemplateUtil serviceTemplate = new ServiceConfigTemplateUtil();
		Integer functionId=0;
		if(auditBatchCfg != null && !StringUtil.isEmpty(auditBatchCfg.getFunctionId())) {
			functionId=auditBatchCfg.getFunctionId();
		}
 		List<Map<String,Object>> serviceList = serviceTemplate.getServiceListByFunctionId(functionId);
 		for(Map<String,Object> service:serviceList){
  			String tableNameXml = service.get("tableName").toString(); 		// 获取业务主配置表
  			String serviceTypeXml = service.get("serviceType").toString(); 	// 业务类型 1maat 2callback
			String classNameXml = service.get("className").toString(); 		// 主配置Java类
			String serviceIdXml = service.get("id").toString(); 			// service字典表 service_id字段
 			auditBatchCfg.setServiceId(Integer.valueOf(serviceIdXml));
 			auditBatchCfg.setTableName(tableNameXml);
 			searchCfg.setServiceId(Integer.valueOf(serviceIdXml));
 			searchCfg.setTableName(tableNameXml);
			searchAppCfg.setServiceId(Integer.valueOf(serviceIdXml));
			searchAppCfg.setTableName(tableNameXml);
			searchDigestCfg.setServiceId(Integer.valueOf(serviceIdXml));
			searchDigestCfg.setTableName(tableNameXml);
			searchFileSampleCfg.setServiceId(Integer.valueOf(serviceIdXml));
			searchFileSampleCfg.setTableName(tableNameXml);
			searchObjKeyringCfg.setServiceId(Integer.valueOf(serviceIdXml));
			searchObjKeyringCfg.setTableName(tableNameXml);
			searchTrustedCaCertCfg.setServiceId(Integer.valueOf(serviceIdXml));
			searchTrustedCaCertCfg.setTableName(tableNameXml);
			searchTrustedCaCrlCfg.setServiceId(Integer.valueOf(serviceIdXml));
			searchTrustedCaCrlCfg.setTableName(tableNameXml);
			searchDnsResStrategy.setServiceId(Integer.valueOf(serviceIdXml));
			searchDnsResStrategy.setTableName(tableNameXml);
			searchDnsIpCfg.setServiceId(Integer.valueOf(serviceIdXml));
			searchDnsIpCfg.setTableName(tableNameXml);
			searchIpPortCfg.setServiceId(Integer.valueOf(serviceIdXml));
			searchIpPortCfg.setTableName(tableNameXml);
			searchSignSampleCfg.setServiceId(Integer.valueOf(serviceIdXml));
			searchSignSampleCfg.setTableName(tableNameXml);
			searchDdosIpCfg.setServiceId(Integer.valueOf(serviceIdXml));
			searchDdosIpCfg.setTableName(tableNameXml);
			searchAppIpCfg.setServiceId(Integer.valueOf(serviceIdXml));
			searchAppIpCfg.setTableName(tableNameXml);
			searchAppHttpCfg.setServiceId(Integer.valueOf(serviceIdXml));
			searchAppHttpCfg.setTableName(tableNameXml);
			searchAppDomainCfg.setServiceId(Integer.valueOf(serviceIdXml));
			searchAppDomainCfg.setTableName(tableNameXml);
			searchAppTopicCfg.setServiceId(Integer.valueOf(serviceIdXml));
			searchAppTopicCfg.setTableName(tableNameXml);
			searchAppFeatureIndex.setServiceId(Integer.valueOf(serviceIdXml));
			searchAppFeatureIndex.setTableName(tableNameXml);
			searchAppSslCertCfg.setServiceId(Integer.valueOf(serviceIdXml));
			searchAppSslCertCfg.setTableName(tableNameXml);
			
			if("1".equals(serviceTypeXml)){//maat类配置
				// 存放域配置类型 及 对应表名
 				List<Map<String,Object>> cfgList = (List<Map<String, Object>>) service.get("cfgList");
				List<Map<String,Object>> userRegionList = (List<Map<String, Object>>) service.get("userRegionList");
				if(!StringUtil.isEmpty(cfgList)) {
					if("cfg_index_info".equals(tableNameXml)){
						/************************多域maat cfg_index_info 处理****************************************/
	 					boolean hasData = true;
						while(hasData){
							page.setPageNo(1);
							page.setLastPage(false);
	 						List<CfgIndexInfo> list = getDataList(page,searchCfg,null,null,null); // 通过ServiceId获取cfg_index_info主配置表数据
							if(!StringUtil.isEmpty(list)){
								//配置生效处理 复用全量下发
								if(auditBatchCfg.getIsAudit().equals(1)) {
									hasData = configSynchronizationService.auditNtcMaatData(cfgList,userRegionList,page,auditBatchCfg,list,hasData,true);
								}else {
									List<BaseCfg> BaseCfgList=new ArrayList<>();
									if(!StringUtil.isEmpty(list)) {
										for (CfgIndexInfo cfg : list) {
											BaseCfg baseCfg=new BaseCfg();
											BeanUtils.copyProperties(cfg, baseCfg);
											BaseCfgList.add(baseCfg);
										}
									}
									if(auditBatchCfg.getIsAudit().equals(2)) {// 配置批量审核不通过
										hasData = commonPolicyService.batchUnApproveMaatData(cfgList, page, auditBatchCfg, BaseCfgList, hasData);
									}else {// 配置失效处理 批量处理
										hasData = commonPolicyService.auditNtcMaatData(cfgList, page, auditBatchCfg, BaseCfgList, hasData);
									}
								}
							}else{
								hasData = false;
							}
						}
					}else if("file_digest_cfg".equals(tableNameXml)){
						/************************多域 maat 摘要处理****************************************/
						boolean hasData = true;
						while(hasData){
							
							page.setPageNo(1);
							page.setLastPage(false);
							List<FileDigestCfg> list=getDataList(page,null,null,searchDigestCfg,null);
							if(!StringUtil.isEmpty(list)){
								//配置生效处理 复用全量下发
								if(auditBatchCfg.getIsAudit().equals(1)) {
									hasData=configSynchronizationService.auditFileDigestData(cfgList, userRegionList, page, auditBatchCfg, list, hasData, true);
								}else {
									List<BaseCfg> baseCfgList=new ArrayList<>();
									if(!StringUtil.isEmpty(list)) {
										for (FileDigestCfg cfg : list) {
											BaseCfg baseCfg=new BaseCfg();
											BeanUtils.copyProperties(cfg, baseCfg);
											baseCfgList.add(baseCfg);
										}
									}
									if(auditBatchCfg.getIsAudit().equals(2)) {// 配置批量审核不通过
										hasData = commonPolicyService.batchUnApproveMaatData(cfgList, page, auditBatchCfg, baseCfgList, hasData);
									}else {// 配置失效处理 批量处理
										hasData=commonPolicyService.auditNtcMaatData(cfgList, page, auditBatchCfg,baseCfgList, hasData);
									}
								}
							}else{
								hasData = false;
							}
						}
					}else if("app_policy_cfg".equals(tableNameXml)){
						/************************多域 maat app策略处理****************************************/
						boolean hasData = true;
						while(hasData){
							page.setPageNo(1);
							page.setLastPage(false);
							List<AppPolicyCfg> list=getDataList(page,null,searchAppCfg,null,null);
							if(!StringUtil.isEmpty(list)){
								//配置生效处理 复用全量下发
								if(auditBatchCfg.getIsAudit().equals(1)) {
									hasData=configSynchronizationService.auditAppPolicyData(cfgList,userRegionList,page,auditBatchCfg,list,hasData,true);
								}else {
									List<BaseCfg> cfgAppList=new ArrayList<>();
									if(!StringUtil.isEmpty(list)) {
										for (AppPolicyCfg cfg : list) {
											BaseCfg baseCfg=new BaseCfg();
											BeanUtils.copyProperties(cfg, baseCfg);
											cfgAppList.add(baseCfg);
										}
									}
									if(auditBatchCfg.getIsAudit().equals(2)) {// 配置批量审核不通过
										hasData = commonPolicyService.batchUnApproveMaatData(cfgList, page, auditBatchCfg, cfgAppList, hasData);
									}else {// 配置失效处理 批量处理
										hasData=commonPolicyService.auditNtcMaatData(cfgList, page, auditBatchCfg,cfgAppList, hasData);
									}
								}
							}else{
								hasData = false;
							}
						}
					}else if("app_feature_index".equals(tableNameXml)){
						/************************多域 maat app特征处理****************************************/
						boolean hasData = true;
						while(hasData){
							page.setPageNo(1);
							page.setLastPage(false);
							
							List<AppFeatureIndex> list=getDataList(page,null,null,null,searchAppFeatureIndex);
							if(!StringUtil.isEmpty(list)){
								//配置生效处理 复用全量下发
								if(auditBatchCfg.getIsAudit().equals(1)) {
									hasData=configSynchronizationService.auditAppFeatureData(cfgList,userRegionList,page,auditBatchCfg,list,hasData,true);
								}else {
									List<BaseCfg> cfgFeatrureList=new ArrayList<>();
									if(!StringUtil.isEmpty(list)) {
										for (AppFeatureIndex cfg : list) {
											BaseCfg baseCfg=new BaseCfg();
											BeanUtils.copyProperties(cfg, baseCfg);
											cfgFeatrureList.add(baseCfg);
										}
									}
									if(auditBatchCfg.getIsAudit().equals(2)) {// 配置批量审核不通过
										hasData = commonPolicyService.batchUnApproveMaatData(cfgList, page, auditBatchCfg, cfgFeatrureList, hasData);
									}else {// 配置失效处理 批量处理
										hasData=commonPolicyService.auditNtcMaatData(cfgList, page, auditBatchCfg,cfgFeatrureList, hasData);
									}
								}
							}else{
								hasData = false;
							}
						}
					}else{
						logger.info("未知业务");
					}
				}else {
					/************************单域maat处理****************************************/
					int cfgType = Integer.parseInt(service.get("cfgType").toString());
					if("ddos_ip_cfg".equals(tableNameXml)){
						 boolean hasData = true;
							while(hasData){
								page.setPageNo(1);
								page.setLastPage(false);
								
								List<DdosIpCfg> list=ddosCfgService.findPage(page, searchDdosIpCfg).getList();
								if(!StringUtil.isEmpty(list)){
									// 配置生效处理
									if(auditBatchCfg.getIsAudit().equals(1)) {
										hasData=configSynchronizationService.auditDdosMaatData(cfgList,userRegionList,
												page,auditBatchCfg,list,hasData,true);
									}else {
										List<BaseCfg> newList=new ArrayList<>();
										if(!StringUtil.isEmpty(list)) {
											for (Object obj : list) {
												BaseCfg cfg=(BaseCfg)obj;
												newList.add(cfg);
											}
										}
										if(auditBatchCfg.getIsAudit().equals(2)) {// 配置批量审核不通过
											hasData = commonPolicyService.batchUnApproveMaatData(cfgList, page, auditBatchCfg, newList, hasData);
										}else {// 配置失效处理 批量处理
											hasData=commonPolicyService.auditNtcMaatData(cfgList, page, auditBatchCfg,newList, hasData);
										}
									}
									if(hasData) {
										page.setPageNo(1);
										page.setLastPage(false);
									}
								}else{
									hasData = false;
								}
							}
					}else{
						//400 ASN IP
						if(auditBatchCfg.getServiceId().equals(400)) {
							if(auditBatchCfg.getIsAudit() == 1) {
								boolean hasData = true;
								//批量生效[按每组每批次下发一次]
								AsnGroupInfo groupInfo=new AsnGroupInfo();
								if(!StringUtil.isEmpty(searchAsnIpCfg.getUserRegion1())) {
									groupInfo.setAsnId(Long.valueOf(searchAsnIpCfg.getUserRegion1()));
								}
								List<AsnGroupInfo> asnGroupInfos=asnGroupInfoService.findAsnGroupInfoList(groupInfo);
								if(StringUtil.isEmpty(asnGroupInfos)){
									hasData=false;
								}
								while(hasData){
									page.setPageNo(1);
									page.setLastPage(true);
									page.setPageSize(-1);
									auditBatchCfg.setCompileIsIssued(asnGroupInfos.get(0).getIsValid());
									auditBatchCfg.setCompileId(asnGroupInfos.get(0).getCompileId());
									auditBatchCfg.setGroupId(asnGroupInfos.get(0).getGroupId());
									searchAsnIpCfg.setAsnIpGroup(asnGroupInfos.get(0).getGroupId());
									List list=asnIpCfgService.findPage(page, searchAsnIpCfg).getList();
									if(!StringUtil.isEmpty(list)) {
										configSynchronizationService.auditAsnIpData(null, page, auditBatchCfg, list, hasData,true);
									}
									if(!StringUtil.isEmpty(asnGroupInfos)) {
										asnGroupInfos.remove(0);
									}
									if(asnGroupInfos.size() > 0) {
										hasData=true;
									}else {
										hasData=false;
									}
								}
							}else {
								//所有已下发的ASN IP组
								boolean hasData = true;
								while(hasData){
									page.setPageNo(1);
									page.setLastPage(false);
									//已下发的ASN IP
									List<AsnIpCfg> list=asnIpCfgService.findPage(page, searchAsnIpCfg).getList();
									
									if(!StringUtil.isEmpty(list)){
										if(auditBatchCfg.getIsAudit() == 2) {
											List<BaseCfg> BaseCfgList=new ArrayList<>();
											for (AsnIpCfg cfg : list) {
												BaseCfg baseCfg=new BaseCfg();
												BeanUtils.copyProperties(cfg, baseCfg);
												BaseCfgList.add(baseCfg);
											}
											hasData = commonPolicyService.batchUnApproveMaatData(cfgList, page, auditBatchCfg, BaseCfgList, hasData);
										}else {
											Map<Integer,List> asnIpMap=new HashMap();
											if(!StringUtil.isEmpty(list)) {
												for (AsnIpCfg obj : list) {
													BaseCfg baseCfg=(BaseCfg)obj;
													if(!StringUtil.isEmpty(asnIpMap.get(obj.getAsnIpGroup()))) {
														asnIpMap.get(obj.getAsnIpGroup()).add(baseCfg);
														asnIpMap.put(obj.getAsnIpGroup(), asnIpMap.get(obj.getAsnIpGroup()));
													}else {
														List newList=new ArrayList<>();
														newList.add(baseCfg);
														asnIpMap.put(obj.getAsnIpGroup(),newList);
													}
												}
											}
											hasData=commonPolicyService.auditReuseConfigData(page, auditBatchCfg,asnIpMap,hasData);
										}
										
									}else{
										hasData = false;
									}
								}
							}
						}else if(auditBatchCfg.getServiceId().equals(1028)) {
							if(auditBatchCfg.getIsAudit() == 1) {
								boolean hasData = true;
								//批量生效[按每组每批次下发一次]
								ConfigGroupInfo groupInfo=new ConfigGroupInfo();
								groupInfo.setGroupType(1);//1:app ip
								List<ConfigGroupInfo> groupInfos=configGroupInfoService.findAllList(groupInfo);
								if(StringUtil.isEmpty(groupInfos)){
									hasData=false;
								}
								while(hasData){
									page.setPageNo(1);
									page.setLastPage(true);
									page.setPageSize(-1);
									auditBatchCfg.setCompileIsIssued(groupInfos.get(0).getIsIssued());
									auditBatchCfg.setCompileId(groupInfos.get(0).getCompileId());
									auditBatchCfg.setGroupId(groupInfos.get(0).getGroupId());
									searchAppIpCfg.setCompileId(groupInfos.get(0).getCompileId());;
									List list=appCfgService.findAppIpList(searchAppIpCfg);
									if(!StringUtil.isEmpty(list)) {
										configSynchronizationService.auditAppIpData(null, page, auditBatchCfg, list, hasData,true);
									}
									if(!StringUtil.isEmpty(groupInfos)) {
										groupInfos.remove(0);
									}
									if(groupInfos.size() > 0) {
										hasData=true;
									}else {
										hasData=false;
									}
								}
							}else {
								//所有已下发的app IP组
								ConfigGroupInfo groupInfo=new ConfigGroupInfo();
								groupInfo.setIsIssued(1);
								groupInfo.setGroupType(1);//1:app ip
								List<ConfigGroupInfo> groupInfos=configGroupInfoService.findAllList(groupInfo);
								Map<Integer,Integer> groupMap=new HashMap<>();
								for (ConfigGroupInfo configGroupInfo : groupInfos) {
									groupMap.put(configGroupInfo.getCompileId(), configGroupInfo.getGroupId());
								}
								
								boolean hasData = true;
								while(hasData){
									page.setPageNo(1);
									page.setLastPage(false);
									
									//已下发的APP IP
									List<AppIpCfg> list=appCfgService.findAppIpList(page, searchAppIpCfg).getList();
									
									if(!StringUtil.isEmpty(list)){
										if(auditBatchCfg.getIsAudit() == 2) { // 配置批量审核不通过
											List<BaseCfg> BaseCfgList=new ArrayList<>();
											for (AppIpCfg cfg : list) {
												BaseCfg baseCfg=new BaseCfg();
												BeanUtils.copyProperties(cfg, baseCfg);
												BaseCfgList.add(baseCfg);
											}
											hasData = commonPolicyService.batchUnApproveMaatData(cfgList, page, auditBatchCfg, BaseCfgList, hasData);
											
										}else {
											Map<Integer,List> appIpMap=new HashMap();
											if(!StringUtil.isEmpty(list)) {
												for (AppIpCfg obj : list) {
													BaseCfg baseCfg=(BaseCfg)obj;
													if(!StringUtil.isEmpty(appIpMap.get((groupMap.get(obj.getCompileId()))))) {
														appIpMap.get(groupMap.get(obj.getCompileId())).add(baseCfg);
														appIpMap.put(groupMap.get(obj.getCompileId()), appIpMap.get(groupMap.get(obj.getCompileId())));
													}else {
														List newList=new ArrayList<>();
														newList.add(baseCfg);
														appIpMap.put(groupMap.get(obj.getCompileId()),newList);
													}
												}
											}
											hasData=commonPolicyService.auditReuseConfigData(page, auditBatchCfg,appIpMap,hasData);
										}
									}else{
										hasData = false;
									}
								}
							}	
						}else {
							boolean hasData = true;
							while(hasData){
								page.setPageNo(1);
								page.setLastPage(false);
								List list = Lists.newArrayList();
								/*
								1026 app_domain_cfg
								1028 app_ip_cfg
								1029 app_ssl_cert_cfg
								1152 app_topic_domain_cfg
								1024 app_http_cfg
								1026 app_domain_cfg
								*/
								if(auditBatchCfg.getServiceId().equals(1026)) {
									list=appCfgService.findAppDomainList(page, searchAppDomainCfg).getList();
								}
								if(auditBatchCfg.getServiceId().equals(1029)) {
									list=appCfgService.findAppSslList(page, searchAppSslCertCfg).getList();
								}
								if(auditBatchCfg.getServiceId().equals(1152)) {
									list=appCfgService.findAppTopicDomainList(page, searchAppTopicCfg).getList();
								}
								if(auditBatchCfg.getServiceId().equals(1024)) {
									list=appCfgService.findAppHttpList(page, searchAppHttpCfg).getList();
								}
								if(!StringUtil.isEmpty(list)){
									if(auditBatchCfg.getIsAudit().equals(1)) {
										hasData=configSynchronizationService.auditSingleMaatData(cfgType,userRegionList,
												page,auditBatchCfg,list,hasData,true);
									}else {
										List<BaseCfg> newList=new ArrayList<>();
										if(!StringUtil.isEmpty(list)) {
											for (Object obj : list) {
												BaseCfg cfg=(BaseCfg)obj;
												newList.add(cfg);
											}
										}
										if(auditBatchCfg.getIsAudit().equals(2)) { // 配置批量审核不通过
											hasData = commonPolicyService.batchUnApproveMaatData(cfgList, page, auditBatchCfg, newList, hasData);
										}else {
											hasData=commonPolicyService.auditNtcMaatData(cfgList, page, auditBatchCfg,newList, hasData);
										}
									}
								}else{
									hasData = false;
								}
							}
						}
						
					}
				}
			}else if("2".equals(serviceTypeXml)){
				/********************回调类处理生效和失效一个方法【由于每个表检索条件不一样，需要自己处理，无法复用全量下发】*********/
				boolean hasData = true;
				while(hasData){
					page.setPageNo(1);
					page.setLastPage(false);
					hasData=handelCallbackData(classNameXml, page, hasData, auditBatchCfg
												, searchCfg
												, searchAppCfg
												, searchDigestCfg
												, searchFileSampleCfg
												, searchObjKeyringCfg
												, searchTrustedCaCertCfg
												, searchTrustedCaCrlCfg
												, searchDnsResStrategy
												, searchDnsIpCfg
												, searchIpPortCfg
												, searchSignSampleCfg);
				}
			}
		}
 		
 		//批量审核通过时，如果没有携带isValid检索条件，返回界面需要将isValid置为null
		if(!StringUtil.isEmpty(entity)) {
			BaseCfg base=(BaseCfg)entity ;
			if(!StringUtil.isEmpty(base.getSeltype()) && !base.getSeltype().equals("isValid")) {
				base.setIsValid(null);
				BeanUtils.copyProperties(base, entity);
			}
		}
		long end=System.currentTimeMillis();
		logger.warn("配置批量生效/失效耗时："+(end-start));
	}
	
	/**
	 * 界面批量删除当前检索条件下的配置
	 * @param page
	 * @param functionId
	 * @param entity 
	 * @throws Exception
	 */
	public void deleteAll(Page page,Integer functionId, Object entity)throws Exception {
		long start=System.currentTimeMillis();
		page.setOrderBy("");
		page.setPageSize(Constants.MAAT_JSON_SEND_SIZE);
		page.setPageNo(1);
		page.setLastPage(false);
		
		CfgIndexInfo searchCfg = new CfgIndexInfo();
		AppPolicyCfg searchAppCfg=new AppPolicyCfg();
		FileDigestCfg searchDigestCfg=new FileDigestCfg();
		AvFileSampleCfg searchFileSampleCfg=new AvFileSampleCfg();
		DdosIpCfg searchDdosIpCfg=new DdosIpCfg();
		
		AppIpCfg searchAppIpCfg=new AppIpCfg();
		AppHttpCfg searchAppHttpCfg=new AppHttpCfg();
		AppDomainCfg searchAppDomainCfg=new AppDomainCfg();
		AppTopicDomainCfg searchAppTopicCfg=new AppTopicDomainCfg();
		AppSslCertCfg searchAppSslCertCfg=new AppSslCertCfg();
		AppFeatureIndex searchAppFeatureIndex=new AppFeatureIndex();
		
		DnsResStrategy searchDnsResStrategy=new DnsResStrategy();
		DnsIpCfg searchDnsIpCfg=new DnsIpCfg();
		PxyObjKeyring searchObjKeyringCfg=new PxyObjKeyring();
		PxyObjTrustedCaCert searchTrustedCaCertCfg=new PxyObjTrustedCaCert();
		AsnIpCfg searchAsnIpCfg=new AsnIpCfg();
		
		// 未审核或取消审核通过的配置可删除
		Integer searchAuditValue = (Integer)Reflections.invokeGetter(entity, "isAudit");
		if(searchAuditValue != null) {
			if(searchAuditValue != 3 && searchAuditValue != 0) {
				searchAuditValue = 30;
			}
		}else {
			searchAuditValue = 30;
		}
		
		// 传递检索条件
		if(entity != null  && (entity instanceof CfgIndexInfo)) {
			BeanUtils.copyProperties(entity, searchCfg);
			searchCfg.setIsValid(0);
			searchCfg.setIsAudit(searchAuditValue); // 检索isValid = 0 AND (isAudit = 0 OR 3)
			searchCfg.setFunctionId(functionId);
		}
		if(entity != null  && (entity instanceof AppPolicyCfg)) {
			BeanUtils.copyProperties(entity, searchAppCfg);
			searchAppCfg.setIsValid(0);
			searchAppCfg.setIsAudit(searchAuditValue);
			searchAppCfg.setFunctionId(functionId);
		}
		if(entity != null  && (entity instanceof FileDigestCfg)) {
			BeanUtils.copyProperties(entity, searchDigestCfg);
			searchDigestCfg.setIsValid(0);
			searchDigestCfg.setIsAudit(searchAuditValue);
			searchDigestCfg.setFunctionId(functionId);
		}
		if(entity != null  && (entity instanceof AvFileSampleCfg)) {
			BeanUtils.copyProperties(entity, searchFileSampleCfg);
			searchFileSampleCfg.setIsValid(0);
			searchFileSampleCfg.setIsAudit(searchAuditValue);
			searchFileSampleCfg.setFunctionId(functionId);
		}
		if(entity != null  && (entity instanceof DdosIpCfg)) {
			BeanUtils.copyProperties(entity, searchDdosIpCfg);
			searchDdosIpCfg.setIsValid(0);
			searchDdosIpCfg.setIsAudit(searchAuditValue);
			searchDdosIpCfg.setFunctionId(functionId);
		}
		if(entity != null  && (entity instanceof AppHttpCfg)) {
			BeanUtils.copyProperties(entity, searchAppHttpCfg);
			searchAppHttpCfg.setIsValid(0);
			searchAppHttpCfg.setIsAudit(searchAuditValue);
			searchAppHttpCfg.setFunctionId(functionId);
		}
		if(entity != null  && (entity instanceof AppHttpCfg)) {
			BeanUtils.copyProperties(entity, searchAppHttpCfg);
			searchAppHttpCfg.setIsValid(0);
			searchAppHttpCfg.setIsAudit(searchAuditValue);
			searchAppHttpCfg.setFunctionId(functionId);
		}
		if(entity != null  && (entity instanceof AppDomainCfg)) {
			BeanUtils.copyProperties(entity, searchAppDomainCfg);
			searchAppDomainCfg.setIsValid(0);
			searchAppDomainCfg.setIsAudit(searchAuditValue);
			searchAppDomainCfg.setFunctionId(functionId);
		}
		if(entity != null  && (entity instanceof AppTopicDomainCfg)) {
			BeanUtils.copyProperties(entity, searchAppTopicCfg);
			searchAppTopicCfg.setIsValid(0);
			searchAppTopicCfg.setIsAudit(searchAuditValue);
			searchAppTopicCfg.setFunctionId(functionId);
		}
		if(entity != null  && (entity instanceof AppSslCertCfg)) {
			BeanUtils.copyProperties(entity, searchAppSslCertCfg);
			searchAppSslCertCfg.setIsValid(0);
			searchAppSslCertCfg.setIsAudit(searchAuditValue);
			searchAppSslCertCfg.setFunctionId(functionId);
		}
		if(entity != null  && (entity instanceof AppIpCfg)) {
			BeanUtils.copyProperties(entity, searchAppIpCfg);
			searchAppIpCfg.setIsValid(0);
			searchAppIpCfg.setIsAudit(searchAuditValue);
			searchAppIpCfg.setFunctionId(functionId);
		}
		if(entity != null  && (entity instanceof AppFeatureIndex)) {
			BeanUtils.copyProperties(entity, searchAppFeatureIndex);
			searchAppFeatureIndex.setIsValid(0);
			searchAppFeatureIndex.setIsAudit(searchAuditValue);
			searchAppFeatureIndex.setFunctionId(functionId);
		}
		if(entity != null  && (entity instanceof DnsResStrategy)) {
			BeanUtils.copyProperties(entity, searchDnsResStrategy);
			searchDnsResStrategy.setIsValid(0);
			searchDnsResStrategy.setIsAudit(searchAuditValue);
			searchDnsResStrategy.setFunctionId(functionId);
		}
		if(entity != null  && (entity instanceof DnsIpCfg)) {
			BeanUtils.copyProperties(entity, searchDnsIpCfg);
			searchDnsIpCfg.setIsValid(0);
			searchDnsIpCfg.setIsAudit(searchAuditValue);
			searchDnsIpCfg.setFunctionId(functionId);
		}
		if(entity != null  && (entity instanceof PxyObjKeyring)) {
			BeanUtils.copyProperties(entity, searchObjKeyringCfg);
			searchObjKeyringCfg.setIsValid(0);
			searchObjKeyringCfg.setIsAudit(searchAuditValue);
			searchObjKeyringCfg.setFunctionId(functionId);
		}
		if(entity != null  && (entity instanceof PxyObjTrustedCaCert)) {
			BeanUtils.copyProperties(entity, searchTrustedCaCertCfg);
			searchTrustedCaCertCfg.setIsValid(0);
			searchTrustedCaCertCfg.setIsAudit(searchAuditValue);
			searchTrustedCaCertCfg.setFunctionId(functionId);
		}
		if(entity != null  && (entity instanceof AsnIpCfg)) {
			BeanUtils.copyProperties(entity, searchAsnIpCfg);
			searchAsnIpCfg.setIsValid(0);
			searchAsnIpCfg.setIsAudit(searchAuditValue);
			searchAsnIpCfg.setFunctionId(functionId);
		}
		
		BaseCfg batchCfg = new BaseCfg();
		batchCfg.setIsValid(-1);
		batchCfg.setIsAudit(0);
		batchCfg.setEditTime(new Date());
		batchCfg.setEditorId(UserUtils.getUser().getId());
		
		ServiceConfigTemplateUtil serviceTemplate = new ServiceConfigTemplateUtil();
		List<Map<String,Object>> serviceList = serviceTemplate.getServiceListByFunctionId(functionId);
 		for(Map<String,Object> service:serviceList){
  			String tableNameXml = service.get("tableName").toString(); 		// 获取业务主配置表
  			String serviceTypeXml = service.get("serviceType").toString(); 	// 业务类型 1maat 2callback
			String classNameXml = service.get("className").toString(); 		// 主配置Java类
			String serviceIdXml = service.get("id").toString(); 			// service字典表 service_id字段
			
			searchCfg.setServiceId(Integer.valueOf(serviceIdXml));
			searchCfg.setTableName(tableNameXml);
			searchAppCfg.setServiceId(Integer.valueOf(serviceIdXml));
			searchAppCfg.setTableName(tableNameXml);
			searchDigestCfg.setServiceId(Integer.valueOf(serviceIdXml));
			searchDigestCfg.setTableName(tableNameXml);
			batchCfg.setServiceId(Integer.valueOf(serviceIdXml));
 			batchCfg.setTableName(tableNameXml);
			
			// 存放域配置类型 及 对应表名
			List<Map<String,Object>> cfgList = (List<Map<String, Object>>) service.get("cfgList");
			if(!StringUtil.isEmpty(cfgList)) {
				/** -- 多域maat -- **/
				if("cfg_index_info".equals(tableNameXml)){
 					boolean hasData = true;
					while(hasData){
						page.setPageNo(1);
						page.setLastPage(false);
 						List<CfgIndexInfo> list = getDataList(page,searchCfg,null,null,null); // 通过serviceId获取主配置表数据
						if(!StringUtil.isEmpty(list)){
							List<BaseCfg> baseCfgList=new ArrayList<>();
							for (CfgIndexInfo cfg : list) {
								BaseCfg baseCfg=new BaseCfg();
								BeanUtils.copyProperties(cfg, baseCfg);
								baseCfgList.add(baseCfg);
							}
							hasData = commonPolicyService.batchDeleteMaatData(cfgList, page, batchCfg, baseCfgList, hasData);
						}else{
							hasData = false;
						}
					}
				}else if("file_digest_cfg".equals(tableNameXml)) {
					boolean hasData = true;
					while(hasData){
						page.setPageNo(1);
						page.setLastPage(false);
 						List<FileDigestCfg> list = getDataList(page,null,null,searchDigestCfg,null); // 通过serviceId获取主配置表数据
						if(!StringUtil.isEmpty(list)){
							List<BaseCfg> baseCfgList=new ArrayList<>();
							for (FileDigestCfg cfg : list) {
								BaseCfg baseCfg=new BaseCfg();
								BeanUtils.copyProperties(cfg, baseCfg);
								baseCfgList.add(baseCfg);
							}
							hasData = commonPolicyService.batchDeleteMaatData(cfgList, page, batchCfg, baseCfgList, hasData);
						}else{
							hasData = false;
						}
					}
				}else if("app_policy_cfg".equals(tableNameXml)) {
					boolean hasData = true;
					while(hasData){
						page.setPageNo(1);
						page.setLastPage(false);
 						List<AppPolicyCfg> list = getDataList(page,null,searchAppCfg,null,null); // 通过serviceId获取主配置表数据
						if(!StringUtil.isEmpty(list)){
							List<BaseCfg> baseCfgList=new ArrayList<>();
							for (AppPolicyCfg cfg : list) {
								BaseCfg baseCfg=new BaseCfg();
								BeanUtils.copyProperties(cfg, baseCfg);
								baseCfgList.add(baseCfg);
							}
							hasData = commonPolicyService.batchDeleteMaatData(cfgList, page, batchCfg, baseCfgList, hasData);
						}else{
							hasData = false;
						}
					}
				}else if("app_feature_index".equals(tableNameXml)) {
					boolean hasData = true;
					while(hasData){
						page.setPageNo(1);
						page.setLastPage(false);
 						List<AppFeatureIndex> list = getDataList(page,null,null,null,searchAppFeatureIndex); // 通过serviceId获取主配置表数据
						if(!StringUtil.isEmpty(list)){
							List<BaseCfg> baseCfgList=new ArrayList<>();
							for (AppFeatureIndex cfg : list) {
								BaseCfg baseCfg=new BaseCfg();
								BeanUtils.copyProperties(cfg, baseCfg);
								baseCfgList.add(baseCfg);
							}
							hasData = commonPolicyService.batchDeleteMaatData(cfgList, page, batchCfg, baseCfgList, hasData);
						}else{
							hasData = false;
						}
					}
					
				}else{
					logger.info("未知业务");
				}
			}else {
				/** -- 单域maat -- **/
				if("ddos_ip_cfg".equals(tableNameXml)) {
					boolean hasData = true;
					while(hasData){
						page.setPageNo(1);
						page.setLastPage(false);
						List<DdosIpCfg> list=ddosCfgService.findPage(page, searchDdosIpCfg).getList();
						if(!StringUtil.isEmpty(list)){
							List<BaseCfg> baseCfgList=new ArrayList<>();
							for (DdosIpCfg cfg : list) {
								BaseCfg baseCfg=new BaseCfg();
								BeanUtils.copyProperties(cfg, baseCfg);
								baseCfgList.add(baseCfg);
							}
							hasData = commonPolicyService.batchDeleteMaatData(cfgList, page, batchCfg, baseCfgList, hasData);
						}else{
							hasData = false;
						}
					}
					
				}else if("av_file_sample_cfg".equals(tableNameXml)) {
					boolean hasData = true;
					while(hasData){
						page.setPageNo(1);
						page.setLastPage(false);
						List<BaseCfg> list = avCfgService.getAvFileSampleList(page,searchFileSampleCfg).getList();
						if(!StringUtil.isEmpty(list)){
							hasData = commonPolicyService.batchDeleteMaatData(cfgList, page, batchCfg, list, hasData);
						}else{
							hasData = false;
						}
					}
					
				}else if("dns_res_strategy".equals(tableNameXml)) {
					boolean hasData = true;
					while(hasData){
						page.setPageNo(1);
						page.setLastPage(false);
						List<BaseCfg> list = dnsResStrategyService.findPage(page,searchDnsResStrategy).getList();
						if(!StringUtil.isEmpty(list)){
							hasData = commonPolicyService.batchDeleteMaatData(cfgList, page, batchCfg, list, hasData);
						}else{
							hasData = false;
						}
					}
					
				}else if("dns_ip_cfg".equals(tableNameXml)) {
					boolean hasData = true;
					while(hasData){
						page.setPageNo(1);
						page.setLastPage(false);
						List<DnsIpCfg> list = dnsIpCfgService.findPage(page,searchDnsIpCfg).getList();
						if(!StringUtil.isEmpty(list)){
							List<BaseCfg> baseCfgList=new ArrayList<>();
							for (DnsIpCfg cfg : list) {
								BaseCfg baseCfg=new BaseCfg();
								BeanUtils.copyProperties(cfg, baseCfg);
								baseCfgList.add(baseCfg);
							}
							hasData = commonPolicyService.batchDeleteMaatData(cfgList, page, batchCfg, baseCfgList, hasData);
						}else{
							hasData = false;
						}
					}
					
				}else if("pxy_obj_keyring".equals(tableNameXml)) {
					boolean hasData = true;
					while(hasData){
						page.setPageNo(1);
						page.setLastPage(false);
						List<BaseCfg> list = pxyObjKeyringService.findPage(page,searchObjKeyringCfg).getList();
						if(!StringUtil.isEmpty(list)){
							hasData = commonPolicyService.batchDeleteMaatData(cfgList, page, batchCfg, list, hasData);
						}else{
							hasData = false;
						}
					}
					
				}else if("pxy_obj_trusted_ca_cert".equals(tableNameXml)) {
					boolean hasData = true;
					while(hasData){
						page.setPageNo(1);
						page.setLastPage(false);
						List<BaseCfg> list = pxyObjKeyringService.findTrustedCertPage(page,searchTrustedCaCertCfg).getList();
						if(!StringUtil.isEmpty(list)){
							hasData = commonPolicyService.batchDeleteMaatData(cfgList, page, batchCfg, list, hasData);
						}else{
							hasData = false;
						}
					}
					
				}else if("asn_ip_cfg".equals(tableNameXml)) { // ASN IP
					boolean hasData = true;
					while(hasData){
						page.setPageNo(1);
						page.setLastPage(false);
						List<BaseCfg> list=asnIpCfgService.findPage(page, searchAsnIpCfg).getList();
						if(!StringUtil.isEmpty(list)){
							hasData = commonPolicyService.batchDeleteMaatData(cfgList, page, batchCfg, list, hasData);
						}else{
							hasData = false;
						}
					}
					
				}else {
					boolean hasData = true;
					while(hasData){
						page.setPageNo(1);
						page.setLastPage(false);
						List list = Lists.newArrayList();
						/*
						1026 app_domain_cfg
						1028 app_ip_cfg
						1029 app_ssl_cert_cfg
						1152 app_topic_domain_cfg
						1024 app_http_cfg
						1026 app_domain_cfg
						*/
						if(batchCfg.getServiceId().equals(1028)) {
							list = appCfgService.findAppIpList(page, searchAppIpCfg).getList();
						}
						if(batchCfg.getServiceId().equals(1026)) {
							list = appCfgService.findAppDomainList(page, searchAppDomainCfg).getList();
						}
						if(batchCfg.getServiceId().equals(1029)) {
							list = appCfgService.findAppSslList(page, searchAppSslCertCfg).getList();
						}
						if(batchCfg.getServiceId().equals(1152)) {
							list = appCfgService.findAppTopicDomainList(page, searchAppTopicCfg).getList();
						}
						if(batchCfg.getServiceId().equals(1024)) {
							list = appCfgService.findAppHttpList(page, searchAppHttpCfg).getList();
						}
						if(!StringUtil.isEmpty(list)){
							List<BaseCfg> baseCfgList = new ArrayList<>();
							if(!StringUtil.isEmpty(list)) {
								for (Object obj : list) {
									BaseCfg cfg = (BaseCfg)obj;
									baseCfgList.add(cfg);
								}
							}
							hasData = commonPolicyService.batchDeleteMaatData(cfgList, page, batchCfg, baseCfgList, hasData);
						}else{
							hasData = false;
						}
					}
						
				}
				
			}
			
		}
		long end=System.currentTimeMillis();
		logger.warn("配置批量删除耗时："+(end-start));
		
	}
	
	public List getDataList(Page searchPage
							,CfgIndexInfo searchCfg
							,AppPolicyCfg searchAppCfg
							,FileDigestCfg searchDigestCfg
							,AppFeatureIndex searchAppFeatureIndex){
		BaseCfg baseCfg=new BaseCfg<>();
		if(!StringUtil.isEmpty(searchCfg)) {
			BeanUtils.copyProperties(searchCfg, baseCfg);
		}
		if(!StringUtil.isEmpty(searchAppCfg)) {
			BeanUtils.copyProperties(searchAppCfg, baseCfg);
		}
		if(!StringUtil.isEmpty(searchDigestCfg)) {
			BeanUtils.copyProperties(searchDigestCfg, baseCfg);
		}
		if(!StringUtil.isEmpty(searchAppFeatureIndex)) {
			BeanUtils.copyProperties(searchAppFeatureIndex, baseCfg);
		}
		Page pageResult=new Page();
		if(baseCfg.getFunctionId().equals(5)//IP
				|| baseCfg.getFunctionId().equals(3)) { //IP WHITELIST
			pageResult=ipCfgService.getIpCfgList(searchPage,searchCfg);
		}else if(baseCfg.getFunctionId().equals(212) //IP Payload
				|| baseCfg.getFunctionId().equals(214) //IP Replace
				|| baseCfg.getFunctionId().equals(7) //DNS
				|| baseCfg.getFunctionId().equals(8)//HTTP ADVANCED
				|| baseCfg.getFunctionId().equals(635) //HTTP 关键字
				|| baseCfg.getFunctionId().equals(37) //MAIL ADDRESS
				|| baseCfg.getFunctionId().equals(35) //MAIL ADVANCED
				|| baseCfg.getFunctionId().equals(34)) {//SSL
			pageResult=websiteCfgService.getWebsiteList(searchPage, searchCfg);
		}else if(baseCfg.getFunctionId().equals(6)) {//HTTP URL
			pageResult=domainService.getDomainList(searchPage, searchCfg);
		}else if(baseCfg.getFunctionId().equals(63)//Stream basic 
				|| baseCfg.getFunctionId().equals(407)//Stream app 
				|| baseCfg.getFunctionId().equals(408)) {//Stream behavior 
			pageResult=appCfgService.findAppPolicyList(searchPage, searchAppCfg);
		}else if(baseCfg.getFunctionId().equals(61)) {//BGP
			pageResult=bgpCfgService.getBgpList(searchPage, searchCfg);
		}else if(baseCfg.getFunctionId().equals(51)) {//FTP
			pageResult=fileTransferCfgService.getFtpList(searchPage, searchCfg);
		}else if(baseCfg.getFunctionId().equals(510)) {//P2P
			pageResult=fileTransferCfgService.getFtpList(searchPage, searchCfg);
		}else if(baseCfg.getFunctionId().equals(22)) {//Stream Media
			pageResult=avContentCfgService.findPage(searchPage, searchCfg);
		}else if(baseCfg.getFunctionId().equals(24)) {//VOIP
			pageResult=avContentCfgService.findPage(searchPage, searchCfg);
		}else if(baseCfg.getFunctionId().equals(52)) {//Digest
			pageResult=fileTransferCfgService.getFileDigestList(searchPage, searchDigestCfg);
		}else if(baseCfg.getFunctionId().equals(200)//intercept ip
				||baseCfg.getFunctionId().equals(201)) {//intercept domain
			pageResult=interceptCfgService.getWebsiteList(searchPage, searchCfg);
		}else if(baseCfg.getFunctionId().equals(207) //control
				||baseCfg.getFunctionId().equals(208)
				||baseCfg.getFunctionId().equals(209)
				||baseCfg.getFunctionId().equals(210)
				||baseCfg.getFunctionId().equals(211)) {
			pageResult=httpRedirectCfgService.getHttpRedirectList(searchPage, searchCfg);
		}else if(baseCfg.getFunctionId().equals(213)) {// cache
			pageResult=cachePolicyService.getCachePolicyList(searchPage, searchCfg);
		}else if(baseCfg.getFunctionId().equals(563) //app payload
				||baseCfg.getFunctionId().equals(564)//app dns
				||baseCfg.getFunctionId().equals(565)//app http
				||baseCfg.getFunctionId().equals(566)//app ssl
				||baseCfg.getFunctionId().equals(567)) {//dk_gl
			pageResult=appMultiFeatureCfgService.findAppFeatureIndexList(searchPage,searchAppFeatureIndex);
		}
		return pageResult.getList();
	}
	
	private boolean handelCallbackData(String className,Page page,boolean hasData,BaseCfg entity
								,CfgIndexInfo searchCfg
								,AppPolicyCfg searchAppCfg
								,FileDigestCfg searchDigestCfg
								,AvFileSampleCfg searchFileSampleCfg
								,PxyObjKeyring searchObjKeyringCfg
								,PxyObjTrustedCaCert searchTrustedCaCertCfg
								,PxyObjTrustedCaCrl searchTrustedCaCrlCfg
								,DnsResStrategy searchDnsResStrategy
								,DnsIpCfg searchDnsIpCfg
								,IpPortCfg searchIpPortCfg
								,AvSignSampleCfg searchSignSampleCfg) {	
		ToMaatBean maatBean;		
		MaatCfg maatCfg;
		List<MaatCfg> configCompileList;
		List<GroupCfg> groupRelationList;
		List<IpCfg> ipRegionList;
		List<StringCfg> strRegionList;
		List<NumBoundaryCfg> numRegionList;
		List<DigestCfg> digestRegionList;
		List<IpCfg> areaIpRegionList;
		
		maatBean = new ToMaatBean();		
		configCompileList = new ArrayList();
		List list = new ArrayList();
		List notAuditList = new ArrayList();
		List auditList = new ArrayList();
		List ids = new ArrayList();
		List<Integer> compileIds = Lists.newArrayList();
		if(entity.getServiceId().equals(3)){//ip drop回调类配置用了主表和子表关系
			list = getDataList(page, searchCfg, null, null,null);
			if(!StringUtil.isEmpty(list)){
				for(int i=0;i<list.size();i++){
					CfgIndexInfo cfg = (CfgIndexInfo) list.get(i);
					compileIds.add(cfg.getCompileId());
				}
				List subList = commonPolicyService.getIpDropList("ip_port_cfg", compileIds);
				for(int i=0;i<subList.size();i++){
					IpPortCfg cfg = (IpPortCfg) subList.get(i);
					if(cfg.getIsValid()==1) {
						cfg.setIsValid(entity.getIsValid());
						cfg.setIsAudit(entity.getIsAudit());
						cfg.setAuditTime(entity.getAuditTime());
						cfg.setAuditorId(entity.getAuditorId());
						//auditList.add(BaseService.convertCallBackIp(cfg,cfg.getGroupId())); // 移至下发前处理
						auditList.add(cfg);
					}else {
						//定时任务审核通过，配置已经失效，则
						cfg.setIsValid(entity.getIsValid());
						cfg.setIsAudit(entity.getIsAudit());
						cfg.setAuditTime(entity.getAuditTime());
						cfg.setAuditorId(entity.getAuditorId());
						//notAuditList.add(BaseService.convertCallBackIp(cfg,cfg.getGroupId())); // 移至下发前处理
						notAuditList.add(cfg);
					}
				}
				
			}
		}else{
			if(className.equals("AvFileSampleCfg")){
				list = avCfgService.getAvFileSampleList(page,searchFileSampleCfg).getList();
				for(int i=0;i<list.size();i++){
					BaseCfg cfg = (BaseCfg) list.get(i);
					ids.add(cfg.getCompileId());
					if(cfg.getIsValid()==1) {
						cfg.setIsValid(entity.getIsValid());
						cfg.setIsAudit(entity.getIsAudit());
						cfg.setAuditTime(entity.getAuditTime());
						cfg.setAuditorId(entity.getAuditorId());
						auditList.add(cfg);
					}else {
						//定时任务审核通过，配置已经失效，则
						cfg.setIsValid(entity.getIsValid());
						cfg.setIsAudit(entity.getIsAudit());
						cfg.setAuditTime(entity.getAuditTime());
						cfg.setAuditorId(entity.getAuditorId());
						notAuditList.add(cfg);
					}
					
				}
			}else if(className.equals("AvSignSampleCfg")){
				list = avCfgService.getSignSampleList(searchSignSampleCfg);
				for(int i=0;i<list.size();i++){
					BaseCfg cfg = (BaseCfg) list.get(i);
					ids.add(cfg.getCompileId());
					if(cfg.getIsValid()==1) {
						cfg.setIsValid(entity.getIsValid());
						cfg.setIsAudit(entity.getIsAudit());
						cfg.setAuditTime(entity.getAuditTime());
						cfg.setAuditorId(entity.getAuditorId());
						auditList.add(cfg);
					}else {
						//定时任务审核通过，配置已经失效，则
						cfg.setIsValid(entity.getIsValid());
						cfg.setIsAudit(entity.getIsAudit());
						cfg.setAuditTime(entity.getAuditTime());
						cfg.setAuditorId(entity.getAuditorId());
						notAuditList.add(cfg);
					}
				}
			}else if(className.equals("PxyObjKeyring")){
				list = pxyObjKeyringService.findPage(page, searchObjKeyringCfg).getList();
				for(int i=0;i<list.size();i++){
					PxyObjKeyring cfg = (PxyObjKeyring) list.get(i);
					ids.add(cfg.getCompileId());
					if(cfg.getIsValid()==1) {
						cfg.setIsValid(entity.getIsValid());
						cfg.setIsAudit(entity.getIsAudit());
						cfg.setAuditTime(entity.getAuditTime());
						cfg.setAuditorId(entity.getAuditorId());
						//auditList.add(BaseService.convertCallBackProxyObjKeyring(cfg)); // 移至下发前处理
						auditList.add(cfg);
					}else {
						//定时任务审核通过，配置已经失效，则
						cfg.setIsValid(entity.getIsValid());
						cfg.setIsAudit(entity.getIsAudit());
						cfg.setAuditTime(entity.getAuditTime());
						cfg.setAuditorId(entity.getAuditorId());
						//notAuditList.add(BaseService.convertCallBackProxyObjKeyring(cfg)); // 移至下发前处理
						notAuditList.add(cfg);
					}
				}
			}else if(className.equals("PxyObjTrustedCaCert")){
				list = pxyObjKeyringService.findTrustedCertPage(page,searchTrustedCaCertCfg).getList();
				for(int i=0;i<list.size();i++){
					PxyObjTrustedCaCert cfg = (PxyObjTrustedCaCert) list.get(i);
					ids.add(cfg.getCompileId());
					if(cfg.getIsValid()==1) {
						cfg.setIsValid(entity.getIsValid());
						cfg.setIsAudit(entity.getIsAudit());
						cfg.setAuditTime(entity.getAuditTime());
						cfg.setAuditorId(entity.getAuditorId());
						//auditList.addAll(BaseService.convertCallBackProxyObjTrustedCa(cfg,null)); // 移至下发前处理
						auditList.add(cfg);
					}else {
						//定时任务审核通过，配置已经失效，则
						cfg.setIsValid(entity.getIsValid());
						cfg.setIsAudit(entity.getIsAudit());
						cfg.setAuditTime(entity.getAuditTime());
						cfg.setAuditorId(entity.getAuditorId());
						//notAuditList.addAll(BaseService.convertCallBackProxyObjTrustedCa(cfg,null)); // 移至下发前处理
						notAuditList.add(cfg);
					}
				}
				if(!StringUtil.isEmpty(ids)) {
					list=new ArrayList<>();
					list=commonPolicyService.getPxyObjTrustedCrlCfgListByCertId(ids);
					for(int i=0;i<list.size();i++){
						PxyObjTrustedCaCrl cfg = (PxyObjTrustedCaCrl) list.get(i);
						if(cfg.getIsValid()==1) {
							cfg.setIsValid(entity.getIsValid());
							cfg.setIsAudit(entity.getIsAudit());
							cfg.setAuditTime(entity.getAuditTime());
							cfg.setAuditorId(entity.getAuditorId());
							//auditList.addAll(BaseService.convertCallBackProxyObjTrustedCa(null,cfg)); // 移至下发前处理
							auditList.add(cfg);
						}else {
							//定时任务审核通过，配置已经失效，则
							cfg.setIsValid(entity.getIsValid());
							cfg.setIsAudit(entity.getIsAudit());
							cfg.setAuditTime(entity.getAuditTime());
							cfg.setAuditorId(entity.getAuditorId());
							//notAuditList.addAll(BaseService.convertCallBackProxyObjTrustedCa(null,cfg)); // 移至下发前处理
							notAuditList.add(cfg);
						}
					}
				}
			}/*//批量下发时不需要单独下发CRL
				else if(className.equals("PxyObjTrustedCaCrl")){ 
				list = pxyObjKeyringService;
				for(int i=0;i<list.size();i++){
					PxyObjTrustedCaCrl cfg = (PxyObjTrustedCaCrl) list.get(i);
					newList.add(BaseService.convertCallBackProxyObjTrustedCa(null,cfg));
					ids.add(cfg.getCompileId());
				}
			}*/else if(className.equals("DnsResStrategy")){
				list = dnsResStrategyService.findPage(page,searchDnsResStrategy).getList();
				for(int i=0;i<list.size();i++){
					DnsResStrategy cfg = (DnsResStrategy) list.get(i);
					ids.add(cfg.getCompileId());
					if(cfg.getIsValid()==1) {
						cfg.setIsValid(entity.getIsValid());
						cfg.setIsAudit(entity.getIsAudit());
						cfg.setAuditTime(entity.getAuditTime());
						cfg.setAuditorId(entity.getAuditorId());
						//auditList.add(BaseService.convertCallBackDnsResStrategy(cfg)); // 移至下发前处理
						auditList.add(cfg);
					}else {
						//定时任务审核通过，配置已经失效，则
						cfg.setIsValid(entity.getIsValid());
						cfg.setIsAudit(entity.getIsAudit());
						cfg.setAuditTime(entity.getAuditTime());
						cfg.setAuditorId(entity.getAuditorId());
						//notAuditList.add(BaseService.convertCallBackDnsResStrategy(cfg)); // 移至下发前处理
						notAuditList.add(cfg);
					}
				}
			}else if(className.equals("DnsIpCfg")){
				list = dnsIpCfgService.findPage(page,searchDnsIpCfg).getList();
				for(int i=0;i<list.size();i++){
					DnsIpCfg cfg = (DnsIpCfg) list.get(i);
					ids.add(cfg.getCompileId());
					if(cfg.getIsValid()==1) {
						cfg.setIsValid(entity.getIsValid());
						cfg.setIsAudit(entity.getIsAudit());
						cfg.setAuditTime(entity.getAuditTime());
						cfg.setAuditorId(entity.getAuditorId());
						//auditList.add(BaseService.convertCallBackIp(cfg,cfg.getDnsStrategyId())); // 移至下发前处理
						auditList.add(cfg);
					}else {
						//定时任务审核通过，配置已经失效，则
						cfg.setIsValid(entity.getIsValid());
						cfg.setIsAudit(entity.getIsAudit());
						cfg.setAuditTime(entity.getAuditTime());
						cfg.setAuditorId(entity.getAuditorId());
						//notAuditList.add(BaseService.convertCallBackIp(cfg,cfg.getDnsStrategyId()));
						notAuditList.add(cfg);
					}
				}
			}else if(className.equals("IpPortCfg")){
				list = commonPolicyService.getIpPortList(searchIpPortCfg);
				for(int i=0;i<list.size();i++){
					IpPortCfg cfg = (IpPortCfg) list.get(i);
					ids.add(cfg.getCompileId());
					if(cfg.getIsValid()==1) {
						cfg.setIsValid(entity.getIsValid());
						cfg.setIsAudit(entity.getIsAudit());
						cfg.setAuditTime(entity.getAuditTime());
						cfg.setAuditorId(entity.getAuditorId());
						auditList.add(BaseService.convertCallBackIp(cfg,cfg.getGroupId()));
					}else {
						//定时任务审核通过，配置已经失效，则
						cfg.setIsValid(entity.getIsValid());
						cfg.setIsAudit(entity.getIsAudit());
						cfg.setAuditTime(entity.getAuditTime());
						cfg.setAuditorId(entity.getAuditorId());
						notAuditList.add(BaseService.convertCallBackIp(cfg,cfg.getGroupId()));
					}
				}
			}
		}
		page.setList(list);
		if(page.isLastPage()){
			hasData = false;
		}
		
		if(!StringUtil.isEmpty(auditList) || !StringUtil.isEmpty(notAuditList)) {
			//批量修改和下发回调配置
			commonPolicyService.auditCallBackData(auditList,notAuditList, compileIds, ids, entity);
		}else {
			hasData = false;
		}
		
		return hasData;
	}
	/**
	 * 通过serviceIds 和 compileIds获取日志总量
	 * */
	public List<Map<String, Object>> getLogTotal(Long endTime,String serviceIds,String compileIds){
		List<Map<String, Object>> dataList=new ArrayList<>();
		SimpleDateFormat sdf=new SimpleDateFormat(Constants.SEARCH_DATEFORMAT);
		Date endDate=null;
		Date startDate=null;
		if(endTime!=null) {
			if(StringUtils.isNotBlank(Constants.LOG_TIME_START)) {
				try {
					startDate=sdf.parse(Constants.LOG_TIME_START);
					if(StringUtils.isNotBlank(Constants.LOG_TIME_END)) {
						endDate=sdf.parse(Constants.LOG_TIME_END);
					}else {
						endDate=new Date(endTime);
					}
				} catch (ParseException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
				
			}else {
				Calendar cal=Calendar.getInstance();
				//分钟间隔
				int interval=Constants.LOG_TIME_RANGE/1000/60;
				cal.setTimeInMillis(endTime);
				if(interval<60) {//5分钟
					cal.set(Calendar.SECOND, 0);
					int minute=cal.get(Calendar.MINUTE);
					cal.set(Calendar.MINUTE,minute/interval*interval);
				}else {//1小时
					cal.set(Calendar.SECOND, 0);
					cal.set(Calendar.MINUTE, 0);
				}
				Calendar endTimeCal=Calendar.getInstance();
				endTimeCal.setTimeInMillis(cal.getTimeInMillis());
				//endTimeCal.add(Calendar.SECOND, -1);
				endDate=endTimeCal.getTime();
				cal.add(Calendar.MINUTE, -interval);
				startDate=cal.getTime();
			}
			logger.info("log search end time:"+sdf.format(endDate));
			logger.info("log search start time:"+sdf.format(startDate));
		}
		List<NtcPzReport> list=null;
		try {
			//调用带有超时时间的方法，设置与页面ajax获取total log 超时时间保持一致 页面设置在pzlog.js
			String json=ConfigServiceUtil.getReport(Constants.BUSINESSTYPE_CONFIG, compileIds, serviceIds, startDate==null?null:sdf.format(startDate), endDate==null?null:sdf.format(endDate),Constants.CLIENT_CONNECT_TIMEOUT,10000);
			list=getList(json);
		} catch (Exception e) {
			logger.error("获取日志总量失败！",e);
			
		}
		
		String[] idArr=compileIds.split(",");
		for(String id:idArr) {
			Map<String, Object> data=new HashMap<String, Object>();
			data.put("compileId", id);
			Long sum=(long) 0;
			if(list!=null&&(list.size()>0)){
				for(NtcPzReport report:list) {
					if(Long.valueOf(id).longValue() == report.getCfgId().longValue()){
						sum=report.getSum().longValue();
						break;
					}
				}
			}
			data.put("sum",sum);
			dataList.add(data);
		}
		return dataList;
	}
	public <E> List<E> getList(String json){
		JSONObject obj=JSONObject.fromObject(json);
		if(obj.containsKey("data")) {
			JSONObject data= obj.getJSONObject("data");
			if(data.containsKey("list")) {
				Object list=data.get("list");
				JSONArray array=JSONArray.fromObject(list);
				List<E> result=JSONArray.toList(array, new NtcPzReport(),new JsonConfig());
				return result;
			}
			
		}
		return new ArrayList<E>();
	}
}