package com.fgkj.services;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.List;

import com.fgkj.actions.ActionUtil;
import com.fgkj.dao.BaseDAO;
import com.fgkj.dao.BaseDAOFactory;
import com.fgkj.dao.BattCapFactory;
import com.fgkj.dao.DAOHelper;
import com.fgkj.dao.impl.BattInfImpl;
import com.fgkj.dao.impl.Batt_param_lowImpl;
import com.fgkj.dao.impl.Batttestdata_infDAOImpl;
import com.fgkj.dto.BattInf;
import com.fgkj.dto.Batt_Maint_Dealarm;
import com.fgkj.dto.Batt_param_low;
import com.fgkj.dto.Batttestdata_inf;
import com.fgkj.dto.ServiceModel;
import com.sun.net.httpserver.Authenticator.Success;

public class Batttestdata_infService {
	private ServiceModel model;
	private BaseDAO dao;
	private BaseDAO daoB;
	public Batttestdata_infService() {
		model=new ServiceModel();
		dao=BaseDAOFactory.getBaseDAO(BaseDAO.BATTTESTDATA_INF);
		daoB=BaseDAOFactory.getBaseDAO(BaseDAO.BATTINF);
		model=new ServiceModel();
	}
	/**
	 * 根据电池组id查询电池组的inf表中的放电信息
	 */
	public ServiceModel serchByCondition(Object obj){
		List<Batttestdata_inf> list=dao.serchByCondition(obj);		
		if(list!=null && list.size()>0){
			model=judge(obj);			
			if(model.getCode()!=0){
				model.setCode(1);
				model.setData(list);
			}
		}
		return model;
	}

	/**
	 * 根据电池组id查询电池组的inf表中的放电信息<-------跨域----------->
	 */
	public ServiceModel serchByCondition_ky(Object obj){
		List<Batttestdata_inf> list=((Batttestdata_infDAOImpl)dao).serchByCondition_ky(obj);		
		if(list!=null && list.size()>0){
			model=judge(obj);			
			if(model.getCode()!=0){
				model.setCode(1);
				model.setData(list);
			}
		}
		return model;
	}
   //测试battgroupid在batttestdata_inf中是否存在
	public ServiceModel judge(Object obj){
		Batttestdata_inf bti=(Batttestdata_inf)obj;
		if(bti.getBattGroupId()!=null){		
			//System.out.println(bti.getBattGroupId());
			List list=((Batttestdata_infDAOImpl)dao).judge(obj);
			//System.out.println(list.size()+"**********");
			if(list!=null && list.size()>0){
				model.setCode(1);
				model.setData(list);
			}else{
				model.setCode(0);
			}		
		}
		return model;
	}
	//1.2/1.3电池组统计分析查询
	public ServiceModel serchByTestType1(Object obj){
		Batttestdata_inf binf=(Batttestdata_inf) obj;
		if(binf.getTest_type()==2){
			List<Batttestdata_inf> list2=((Batttestdata_infDAOImpl)dao).serchByTestType2(binf);
			List<Batttestdata_inf> list3=((Batttestdata_infDAOImpl)dao).serchByTestType3(binf);
			List<Batttestdata_inf> listd=((Batttestdata_infDAOImpl)dao).serchByDataNew(binf);
			List<Batttestdata_inf> l=new ArrayList<Batttestdata_inf>();
			if(list2!=null && list2.size()>0){
				model.setCode(1);
				l.add(list2.get(list2.size()-1));
				model.setData(l);     //充电时数据
				model.setSum(list3.size());//放电次数
				model.setNewsum(listd.size());//新增放电测试次数
			}else{
				model.setCode(0);
				model.setData(l);
				model.setSum(0);//放电总次数
				model.setNewsum(0);//新增放电测试次数
			}
		}
		else if(binf.getTest_type()==3){
			List<Batttestdata_inf> list3=((Batttestdata_infDAOImpl)dao).serchByTestType3(binf);
			List<Batttestdata_inf> listd=((Batttestdata_infDAOImpl)dao).serchByDataNew(binf);
			List<Batttestdata_inf> l=new ArrayList<Batttestdata_inf>();
			if(list3!=null && list3.size()>0){
				model.setCode(1);
				l.add(list3.get(list3.size()-1));
				model.setData(l);
				model.setSum(list3.size());//放电总次数
				model.setNewsum(listd.size());//新增放电测试次数
			}else{
				model.setCode(0);
				model.setData(l);
				model.setSum(0);//放电总次数
				model.setNewsum(0);//新增放电测试次数
			}
		}else if(binf.getTest_type()==3000){
			List<Batttestdata_inf> list2=((Batttestdata_infDAOImpl)dao).serchByTestType2(binf);
			List<Batttestdata_inf> list3=((Batttestdata_infDAOImpl)dao).serchByTestType3(binf);
			List<Batttestdata_inf> listd=((Batttestdata_infDAOImpl)dao).serchByDataNew(binf);
			List<Batttestdata_inf> l=new ArrayList<Batttestdata_inf>();
			if(list2!=null && list2.size()>0){
					model.setCode(1);
					l.add(list2.get(list2.size()-1));
					model.setData(l);     //充电时数据
					model.setSum(list3.size());//放电次数
					model.setNewsum(listd.size());//新增放电测试次数
				}else{
					model.setCode(0);
					model.setData(l);
					model.setSum(0);//放电总次数
					model.setNewsum(0);//新增放电测试次数
				}
				if(list3!=null && list3.size()>0){
					model.setCode(1);
					l.add(list3.get(list3.size()-1));
					model.setData(l);
					model.setSum(list3.size());//放电总次数
					model.setNewsum(listd.size());//新增放电测试次数
				}else{
					model.setData(l);
					model.setCode(0);
					model.setSum(0);//放电总次数
					model.setNewsum(0);//新增放电测试次数xxxxxl
			}	
		}else if(binf.getTest_type()==5){
			List<Batttestdata_inf> list3=((Batttestdata_infDAOImpl)dao).serchByTestType3(binf);
			List<Batttestdata_inf> listd=((Batttestdata_infDAOImpl)dao).serchByDataNew(binf);
			List<Batttestdata_inf> l=new ArrayList<Batttestdata_inf>();
			if(list3!=null && list3.size()>0){
				model.setCode(1);
				l.add(list3.get(list3.size()-1));
				model.setData(l);
				model.setSum(list3.size());//放电总次数
				model.setNewsum(listd.size());//新增放电测试次数
			}else{
				model.setCode(0);
				model.setData(l);
				model.setSum(0);//放电总次数
				model.setNewsum(0);//新增放电测试次数
			}
		}else if(binf.getTest_type()==9){
			List<Batttestdata_inf> list3=((Batttestdata_infDAOImpl)dao).serchByTestType3(binf);
			List<Batttestdata_inf> listd=((Batttestdata_infDAOImpl)dao).serchByDataNew(binf);
			List<Batttestdata_inf> l=new ArrayList<Batttestdata_inf>();
			if(list3!=null && list3.size()>0){
				model.setCode(1);
				l.add(list3.get(list3.size()-1));
				model.setData(l);
				model.setSum(list3.size());//放电总次数
				model.setNewsum(listd.size());//新增放电测试次数
			}else{
				model.setCode(0);
				model.setData(l);
				model.setSum(0);//放电总次数
				model.setNewsum(0);//新增放电测试次数
			}
		}else if(binf.getTest_type()==4000){
			List<Batttestdata_inf> list2=((Batttestdata_infDAOImpl)dao).serchByTestType2(binf);
			List<Batttestdata_inf> list3=((Batttestdata_infDAOImpl)dao).serchByTestType3(binf);
			if(list2!=null&&list2.size()>0||list3!=null&&list3.size()>0){
				model.setCode(1);
				model.setMsg("该battgroupid有记录");
				
			}else{
				model.setCode(0);
				model.setMsg("该battgroupid无记录");
			}
			model.setSum(0);//放电总次数
			model.setNewsum(0);//新增放电测试次数
		}
		else if(binf.getTest_type()==0){
			List<Batttestdata_inf> list2=((Batttestdata_infDAOImpl)dao).serchByTestType2(binf);
			List<Batttestdata_inf> list3=((Batttestdata_infDAOImpl)dao).serchByTestType3(binf);
			List<Batttestdata_inf> listd=((Batttestdata_infDAOImpl)dao).serchByDataNew(binf);
			List<Batttestdata_inf> l=new ArrayList<Batttestdata_inf>();
			if(list2!=null&&list2.size()>0 || list3!=null&&list3.size()>0){
				if(list3!=null&&list3.size()>0){
					l.add(list3.get(list3.size()-1));
				}
				model.setCode(1);
				model.setMsg("该battgroupid有记录");
				model.setData(l);
				model.setSum(list3.size());
				model.setNewsum(listd.size());
				//System.out.println(1111111+"   "+model);
			}else{
				model.setCode(0);
				model.setMsg("该battgroupid无记录");
				model.setSum(0);//放电总次数
				model.setNewsum(0);//新增放电测试次数
			}
		}
		//System.out.println(model);
		return model;
	}
	//0.7电测放电测试比例
	public ServiceModel serchByInfo(Object obj) throws ParseException{
		Batt_Maint_Dealarm bmd=(Batt_Maint_Dealarm) obj;
		Batttestdata_inf tdata=bmd.getTdata();
		BattInf binf=bmd.getBinf();
		Date Ndate=new Date();
		int year=Ndate.getYear() + 1900;
		int monthfirst=0;
		int monthlast=11;
		Calendar ca = Calendar.getInstance();//得到一个Calendar的实例 
		ca.setTime(new Date()); //设置时间为当前时间
		
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
		Date date1 = sdf.parse("1000-01-01");
		Date date2 = sdf.parse("3000-01-01");
		if(tdata.getNum()==100){								//全部
			tdata.setTest_starttime(ActionUtil.getSimpDate(date1));
			tdata.setTest_starttime_ex(ActionUtil.getSimpDate(date2));
		}else if(tdata.getNum()==0){ 							//今年要测
		    ca.clear();  
	        ca.set(Calendar.YEAR, year);  
	        Date lastDate = ca.getTime();						//当前年份第一天		        
	        ca.clear();  
	        ca.set(Calendar.YEAR, year);  
	        ca.roll(Calendar.DAY_OF_YEAR, -1);  
	        Date nextDate = ca.getTime();  //当前年份最后一天
	        tdata.setTest_starttime(ActionUtil.getSimpDate(lastDate));
			tdata.setTest_starttime_ex(ActionUtil.getSimpDate(nextDate));
		}else if(tdata.getNum()==1){ 							//一年未测
			ca.add(Calendar.YEAR, tdata.getNum()*(-1)); //年份减1 
			Date lastDate = ca.getTime(); //结果
			ca.add(Calendar.YEAR, tdata.getNum()); //年份减1
			Date nextDate = ca.getTime();
			//System.out.println(lastDate+"  "+nextDate);
			tdata.setTest_starttime(ActionUtil.getSimpDate(lastDate));
			tdata.setTest_starttime_ex(ActionUtil.getSimpDate(nextDate));
		}else if(tdata.getNum()==3){							//3年
			ca.add(Calendar.YEAR, tdata.getNum()*(-1)); //年份减3 
			Date lastDate = ca.getTime(); //结果
			ca.add(Calendar.YEAR, tdata.getNum()); //年份减1
			Date nextDate = ca.getTime();
			//System.out.println(lastDate+"  "+nextDate);
			tdata.setTest_starttime(ActionUtil.getSimpDate(lastDate));
			tdata.setTest_starttime_ex(ActionUtil.getSimpDate(nextDate));
		}
		//System.out.println(tdata);
		List list=dao.serchByInfo(bmd);
		//System.out.println(list);
		List listA=new BattInfImpl().serchByStationName1(binf);
		if(listA!=null && listA.size()>0){
			model.setSum(listA.size());
		}
		if(list!=null && list.size()>0){
			model.setCode(1);			
			model.setData(list);
		}else{
			model.setCode(0);
			model.setMsg("查询失败!");
		}
		//System.out.println(model);
		return model;
	}

	//0.9电池健康率
	public ServiceModel serchGood(){
		List<Batttestdata_inf> list=((Batttestdata_infDAOImpl)dao).serchGood();//不健康
		List listB=(new BattInfImpl()).searchAll();//所有的电池组
		int battgroupid=0;
		float test_cap=0f;
		int number=0;
		int judge=0;//标识
		if(list!=null&&list.size()>0){
			for(int i=0;i<list.size();i++){
				if(battgroupid!=list.get(i).getBattGroupId()){
					battgroupid=list.get(i).getBattGroupId();
					test_cap=Math.abs(list.get(i).getTest_cap());
					judge=0;
				}else{
					if(judge==0&&test_cap>Math.abs(list.get(i).getTest_cap())){
						judge=1;
						number++;
					}
				}
			}
		}
		//System.out.println(number);
		model.setCode(1);
		model.setSum(listB.size());
		model.setNewsum(number);
		//System.out.println(model);
		return model;	
	}
    
	//6.4.2根据条件查询符合条件的测试完成的电池组(蓄电池放电测试完成率)
	/*
	 * mon_num中存放层次
	 * test_record_count 中存放统计方式：年度统计为0 季度统计为1
	 * test_record_count_ex中存放统计季度：一季度为1 以此类推
	 * record_num 中存放年份*/
	public ServiceModel serchComplete(Object obj){
		Batttestdata_inf tdata=(Batttestdata_inf) obj;
		int level=tdata.getMon_num();//tdata的mon_num中存放层次
		int year=tdata.getRecord_num();//获取年份
		int firstMonth=0;//获取起始月份
		int lastMonth=0;//获取结束月份
		String dateFirst=""; //起始时间
		String dateLast="";  //结束时间
		//做时间判断
		if(tdata.getTest_record_count()==0){
			 firstMonth=0;//获取起始月份
			 lastMonth=11;//获取结束月份
		}else if(tdata.getTest_record_count()==1){
			 if(tdata.getTest_record_count_ex()==1){
				 firstMonth=0;//获取起始月份
				 lastMonth=2;//获取结束月份
			 }else if(tdata.getTest_record_count_ex()==2){
				 firstMonth=3;//获取起始月份
				 lastMonth=5;//获取结束月份
			 }else if(tdata.getTest_record_count_ex()==3){
				 firstMonth=6;//获取起始月份
				 lastMonth=8;//获取结束月份
			 }else if(tdata.getTest_record_count_ex()==4){
				 firstMonth=9;//获取起始月份
				 lastMonth=11;//获取结束月份
			 }
		}
		dateFirst=ActionUtil.getFirstDayOfMonth(year,firstMonth);//起始时间
		try {
			tdata.setTest_starttime(DAOHelper.sdf.parse(dateFirst));
			//System.out.println(dateFirst.substring(0,10));
			dateLast=ActionUtil.getLastDayOfMonth(year,lastMonth);//结束时间
			tdata.setTest_starttime_ex(DAOHelper.sdf.parse(dateLast));
		} catch (ParseException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		//System.out.println(dateLast.substring(0,10));
		//System.out.println(dateFirst.substring(0,11).concat(dateLast.substring(0,10)));
		
		List<BattInf> listB=((BattInfImpl)daoB).serchBylevel(level);
		if(listB!=null&&listB.size()>0){
			  for(int i=0;i<listB.size();i++){
			 	if(level==1){
			 		tdata.setStationname1(listB.get(i).getStationName1());
			 		tdata.setStationname2("");
			 		tdata.setStationname3("");
			 		tdata.setStationname4("");
				}else if(level==2){
					tdata.setStationname1(listB.get(i).getStationName1());
					tdata.setStationname2(listB.get(i).getStationName2());
					tdata.setStationname3("");
					tdata.setStationname4("");
				}else if(level==3){
					tdata.setStationname1(listB.get(i).getStationName1());
					tdata.setStationname2(listB.get(i).getStationName2());
					tdata.setStationname3(listB.get(i).getStationName3());
					tdata.setStationname4("");
				}else if(level==4){
					tdata.setStationname1(listB.get(i).getStationName1());
					tdata.setStationname2(listB.get(i).getStationName2());
					tdata.setStationname3(listB.get(i).getStationName3());
					tdata.setStationname4(listB.get(i).getStationName4());
			    }

			List<Batttestdata_inf> list=((Batttestdata_infDAOImpl)(dao)).serchComplete(tdata);   
		    listB.get(i).setMonCount(list.size());//完成数
		    listB.get(i).setStationName9(dateFirst.substring(0,11).concat(dateLast.substring(0,10)));
		    if(listB.get(i).getMonNum()!=0){
		    	int numC=listB.get(i).getMonCount();
		    	int numM=listB.get(i).getMonNum();
		    	Float percent=(float) (((numC*1.0)/numM)*100);
		    	//System.out.println(percent);
		    	listB.get(i).setMonVolLowToAvg(percent);//完成率
		    }
		    }
//		  for (BattInf binf : listB) {
//			System.out.println(binf);
//		}
		  model.setCode(1);
		  model.setData(listB);
		}else{
			model.setCode(0);
			model.setMsg("查询失败!");
		}
		return model;
	}

	//电池组历史放电数据续航能力查询(历史)
    public ServiceModel serchBattLife(Object obj){
    	List<Batt_Maint_Dealarm> list=((Batttestdata_infDAOImpl)dao).serchBattLife(obj);
    	float param = 0;//容量有效参数
    	double STDAH = 0;//标存容量
    	Batt_param_low capLow=new Batt_param_low();
    	capLow.setLow_type(BattCapFactory.CapType_type);;
    	capLow.setLow_nametype(BattCapFactory.CapType_name);
    	capLow.setLow_method(BattCapFactory.CapType_method);
    	List<Batt_param_low> listC=(new Batt_param_lowImpl().serchByLow(capLow));
    	if(listC!=null&&listC.size()>0){
    		param=listC.get(listC.size()-1).getLow_value();
    	}
		int flag=0;//该次放电是否有效判断
		List<Batt_Maint_Dealarm> listE=new ArrayList();//存放放电有效的测试
    	if(list!=null&&list.size()>0){
    		for(int i=0;i<list.size();i++){
    			STDAH=list.get(i).getBinf().getMonCapStd();
    			float testCap=list.get(i).getTdata().getTest_cap();//此次放电量统计
    			//System.out.println(list.get(i).getTdata().getBattGroupId()+"  "+list.get(i).getTdata().getTest_record_count()+"   "+testCap+"  "+param+"  "+STDAH);
    			flag=BattCapFactory.Judge(testCap, param, STDAH);
    		    if(flag==1){
    		    	if(listE.size()>0){
    		    		int tdata_battgroupid=list.get(i).getTdata().getBattGroupId();
    		    		int e_battgroupid=listE.get(listE.size()-1).getTdata().getBattGroupId();
    		    		if(tdata_battgroupid!=e_battgroupid){
    		    			listE.add(list.get(i));
    		    		}else{
    		    			continue;
    		    		}
    		    	}else{
    		    		listE.add(list.get(i));
    		    	}
    		    flag=0;
    		    }
    		}
    		/*for (Batt_Maint_Dealarm b : listE) {
				System.out.println(b.getTdata());
			}*/
    		model.setCode(1);
    		model.setData(listE);
    		model.setMsg("查询成功!");
    	}else{
    		model.setCode(0);
    		model.setData("查询失败!");
    	}
		return model;
    }

    //机房历史放电数据续航能力查询(实时)
    public ServiceModel serchBattLifeNow(Object obj){
       	List list=((Batttestdata_infDAOImpl)dao).serchBattLifeNow(obj);		
   		if(list!=null && list.size()>0){
   			model.setCode(1);
   			model.setData(list);
   			model.setMsg("查询成功!");
   		}else{
   			model.setCode(0);
   			model.setMsg("查询失败!");
   		}
   		return model;
       	
    }
	//6.4.4根据条件查询符合条件的测试完成的电池组(蓄电池容量预警)
	/*
		 * data_available中存放层次
		 * test_record_count 中存放统计方式：年度统计为0 季度统计为1
		 * test_record_count_ex中存放统计季度：一季度为1 以此类推
		 * test_type 中存放年份*/
	public ServiceModel serchCap(Object obj){
		Batttestdata_inf tdata=(Batttestdata_inf) obj;
		int level=tdata.getData_available();
		int year=tdata.getTest_type();//获取年份
		int firstMonth=0;//获取起始月份
		int lastMonth=0;//获取结束月份
		String dateFirst=""; //起始时间
		String dateLast="";  //结束时间
		//做时间判断
		if(tdata.getTest_record_count()==0){
			 firstMonth=0;//获取起始月份
			 lastMonth=11;//获取结束月份
		}else if(tdata.getTest_record_count()==1){
			 if(tdata.getTest_record_count_ex()==1){
				 firstMonth=0;//获取起始月份
				 lastMonth=2;//获取结束月份
			 }else if(tdata.getTest_record_count_ex()==2){
				 firstMonth=3;//获取起始月份
				 lastMonth=5;//获取结束月份
			 }else if(tdata.getTest_record_count_ex()==3){
				 firstMonth=6;//获取起始月份
				 lastMonth=8;//获取结束月份
			 }else if(tdata.getTest_record_count_ex()==4){
				 firstMonth=9;//获取起始月份
				 lastMonth=11;//获取结束月份
			 }
		}
		dateFirst=ActionUtil.getFirstDayOfMonth(year,firstMonth);//起始时间
		try {
			tdata.setTest_starttime(DAOHelper.sdf.parse(dateFirst));
			//System.out.println(dateFirst.substring(0,10));
			dateLast=ActionUtil.getLastDayOfMonth(year,lastMonth);//结束时间
			tdata.setTest_starttime_ex(DAOHelper.sdf.parse(dateLast));
		} catch (ParseException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		//System.out.println(dateLast.substring(0,10));
		//System.out.println(dateFirst.substring(0,11).concat(dateLast.substring(0,10)));
		
		List<BattInf> listB=((BattInfImpl)daoB).serchBylevel(level);
		if(listB!=null&&listB.size()>0){
			  for(int i=0;i<listB.size();i++){
			 	if(level==1){
			 		tdata.setStationname1(listB.get(i).getStationName1());
			 		tdata.setStationname2("");
			 		tdata.setStationname3("");
			 		tdata.setStationname4("");
				}else if(level==2){
					tdata.setStationname1(listB.get(i).getStationName1());
					tdata.setStationname2(listB.get(i).getStationName2());
					tdata.setStationname3("");
					tdata.setStationname4("");
				}else if(level==3){
					tdata.setStationname1(listB.get(i).getStationName1());
					tdata.setStationname2(listB.get(i).getStationName2());
					tdata.setStationname3(listB.get(i).getStationName3());
					tdata.setStationname4("");
				}else if(level==4){
					tdata.setStationname1(listB.get(i).getStationName1());
					tdata.setStationname2(listB.get(i).getStationName2());
					tdata.setStationname3(listB.get(i).getStationName3());
					tdata.setStationname4(listB.get(i).getStationName4());
			    }
			 	listB.get(i).setStationName9(dateFirst.substring(0,11).concat(dateLast.substring(0,10)));
			 	Float monCapStd=0f;//标存电容
			 	List<Batttestdata_inf> list=((Batttestdata_infDAOImpl)(dao)).serchCap(tdata); 
				int YelNum=0;//记录黄色预警
				int OraNum=0;//记录橙色预警
			 	int RedNum=0;//记录红色预警
			 	if(list!=null&&list.size()>0){
			 	  for(int j=0;j<list.size();j++){
			 		  BattInf binf=new BattInf();
			 		  binf.setBattGroupId(list.get(j).getBattGroupId());
			 		  List<BattInf> listS=(new BattInfImpl()).serchByCondition(binf);
			 		  if(listS!=null&&listS.size()>0){
			 			 monCapStd=listS.get(listS.size()-1).getMonCapStd();//求标存电容
			 		  }
			 		  Float test_cap=list.get(j).getTest_cap();
			 		  if(test_cap>=(0.85*monCapStd)&&test_cap<(0.9*monCapStd)){
			 			 YelNum++;
			 		  }else if(test_cap>=(0.8*monCapStd)&&test_cap<(0.85*monCapStd)){
			 			 OraNum++;
			 		  }else if(test_cap<(0.8*monCapStd)){
			 			 RedNum++;
			 		  }
			 	    }
			 	}
			 	listB.get(i).setStationId(list.size()+"");//已经测试电池组数
			 	listB.get(i).setNum(YelNum);//记录黄色预警
				listB.get(i).setGroupIndexInFBSDevice(OraNum);//记录橙色预警
				listB.get(i).setBattGroupNum(RedNum);//记录红色预警
			 }
			  model.setCode(1);
			  model.setData(listB);
			}else{
				model.setCode(0);
				model.setMsg("查询失败!");
			}
			return model;
	}
	//1.4电池组性能评估(根据电池组id查询所有的放电记录求出放电总次数，最高历史容量,最低历史容量，平均容量，最新测试容量)
	public ServiceModel serchDischargeTest(Object obj){
		model=new ServiceModel();
		List list=((Batttestdata_infDAOImpl)dao).serchDischargeTest(obj);
   		if(list!=null && list.size()>0){
   			model.setCode(1);
   			model.setData(list);
   			model.setMsg("查询成功!");
   		}else{
   			model.setCode(0);
   			model.setMsg("查询失败!");
   		}
   		return model;
	}

	//1.2电池组统计分析查询
    public ServiceModel serchByTestType(Object obj){
    	model=new ServiceModel();
		List list=((Batttestdata_infDAOImpl)dao).serchByTestType(obj);
   		if(list!=null && list.size()>0){
   			model.setCode(1);
   			model.setData(list);
   			model.setMsg("查询成功!");
   		}else{
   			model.setCode(0);
   			model.setMsg("查询失败!");
   		}
   		return model;
    }

	
	public static void main(String[] args) throws ParseException {
		Batttestdata_infService bs=new Batttestdata_infService();
		Batttestdata_inf b=new Batttestdata_inf();
		b.setBattGroupId(0);
		b.setTest_type(0);
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
		Date date1 = sdf.parse("2000-01-01");
		Date date2 = sdf.parse("2017-01-01");
		b.setRecord_time(date1);
		b.setRecord_time1(date2);
		//bs.serchByCondition(b);
		//bs.searchAll();
		//bs.serchByTestType(b);
		
		Batt_Maint_Dealarm bmd=new Batt_Maint_Dealarm();
		Batttestdata_inf tdata=new Batttestdata_inf();
		tdata.setNum(0);
		tdata.setTest_starttype(0);		
		BattInf binf=new BattInf();
		binf.setStationName1("");
		bmd.setTdata(tdata);
		bmd.setBinf(binf);
		
		bs.serchByInfo(bmd);
	}
}