package com.huimv.sjlr;

import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.GregorianCalendar;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

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

import org.springframework.util.StringUtils;
import org.springframework.web.servlet.ModelAndView;

import com.huimv.busi.xt.constant.XtAppConstant;
import com.huimv.busi.xt.model.CommonService;
import com.huimv.busi.xt.utils.DateUtil;
import com.huimv.dto.SjlrFzmyDTO;
import com.huimv.dto.SjlrFzswDTO;
import com.huimv.dto.SjlrFzttDTO;
import com.huimv.dto.SjlrFzxsDTO;
import com.huimv.dto.SjlrFzzqDTO;
import com.huimv.dto.SjlrPtmyDTO;
import com.huimv.dto.SjlrZzmyDTO;
import com.huimv.dto.SjlrZzswDTO;
import com.huimv.dto.SjlrZzttDTO;
import com.huimv.dto.SjlrZzxsDTO;
import com.huimv.dto.SjlrZzzqDTO;
import com.huimv.dto.hpSjlrSlwlDTO;
import com.huimv.sjlr.dao.SjlrFzswDAO;
import com.huimv.sjlr.dao.SjlrFzttDAO;
import com.huimv.sjlr.dao.SjlrFzxsDAO;
import com.huimv.sjlr.dao.SjlrFzzqDAO;
import com.huimv.sjlr.dao.SjlrGzdaDAO;
import com.huimv.sjlr.dao.SjlrMyjlDAO;
import com.huimv.sjlr.dao.SjlrMzdaDAO;
import com.huimv.sjlr.dao.SjlrSlwlDAO;
import com.huimv.sjlr.dao.SjlrZzswDAO;
import com.huimv.sjlr.dao.SjlrZzttDAO;
import com.huimv.sjlr.dao.SjlrZzxsDAO;
import com.huimv.sjlr.dao.SjlrZzzqDAO;
import com.huimv.sjlr.dataobject.SjlrFzsw;
import com.huimv.sjlr.dataobject.SjlrFzswExample;
import com.huimv.sjlr.dataobject.SjlrFztt;
import com.huimv.sjlr.dataobject.SjlrFzttExample;
import com.huimv.sjlr.dataobject.SjlrFzxs;
import com.huimv.sjlr.dataobject.SjlrFzzq;
import com.huimv.sjlr.dataobject.SjlrFzzqExample;
import com.huimv.sjlr.dataobject.SjlrGzda;
import com.huimv.sjlr.dataobject.SjlrGzdaExample;
import com.huimv.sjlr.dataobject.SjlrMyjl;
import com.huimv.sjlr.dataobject.SjlrMzda;
import com.huimv.sjlr.dataobject.SjlrMzdaExample;
import com.huimv.sjlr.dataobject.SjlrSlwl;
import com.huimv.sjlr.dataobject.SjlrSlwlExample;
import com.huimv.sjlr.dataobject.SjlrZzsw;
import com.huimv.sjlr.dataobject.SjlrZztt;
import com.huimv.sjlr.dataobject.SjlrZzxs;
import com.huimv.sjlr.dataobject.SjlrZzxsExample;
import com.huimv.sjlr.dataobject.SjlrZzzq;
import com.huimv.web.base.BaseController;
import com.huimv.xt.dao.XtGydmDAO;
import com.huimv.xt.dataobject.XtGydm;

public class SjlrScHpController extends BaseController {
	
	private CommonService commonService;
	
	private XtGydmDAO xtGydmDAO;
	
	private SjlrZzzqDAO sjlrZzzqDAO;
	
	private SjlrFzzqDAO sjlrFzzqDAO;
	
	private SjlrZzswDAO sjlrZzswDAO;
	
	private SjlrFzswDAO sjlrFzswDAO;
	
	private SjlrZzttDAO sjlrZzttDAO;
	
	private SjlrFzttDAO sjlrFzttDAO;
	
	private SjlrGzdaDAO sjlrGzdaDAO;
	
	private SjlrMzdaDAO sjlrMzdaDAO;
	
	private SjlrMyjlDAO sjlrMyjlDAO;
	
	private SjlrZzxsDAO sjlrZzxsDAO;
	
	private SjlrFzxsDAO sjlrFzxsDAO;
	
	private SjlrSlwlDAO sjlrSlwlDAO;
	
	/**
	 * 加载生产
	 * @param request
	 * @param response
	 * @return
	 * @throws Exception
	 */
	public ModelAndView hpSjlrScIndex(HttpServletRequest request,
			HttpServletResponse response) throws Exception {
		ModelAndView mv = new ModelAndView("haifmp/sjlr/scgl/hpSjlrScglIndex.htm");
		return mv;
	}
	
	/**
	 * 种猪转群
	 * @param request
	 * @param response
	 * @return
	 * @throws Exception
	 */
	public ModelAndView hpSjlrZzzqIndex(HttpServletRequest request,
			HttpServletResponse response) throws Exception {
		ModelAndView mv = new ModelAndView("haifmp/sjlr/scgl/zzzq/hpSjlrZzzqIndex.htm");
		String mcid = request.getParameter("mcid");
		if (StringUtils.hasText(mcid)) {
			Map<String, Object> paramMap = new HashMap<String, Object>();
			Map<String, Object> paramMap1 = new HashMap<String, Object>();
			paramMap.put("mcid", mcid);
			String ksrq = request.getParameter("ksrq");
			String jsrq = request.getParameter("jsrq");
			String dweb = request.getParameter("dweb");
			String cxeph = request.getParameter("cxeph");
			if (!StringUtils.hasText(jsrq)) {
				jsrq = DateUtil.parserDateToDefaultString(commonService.getCurrentDate());
			}
			paramMap.put("jsrq", jsrq);
			mv.addObject("jsrq", jsrq);
			if (!StringUtils.hasText(ksrq)) {
				Calendar calendar = new GregorianCalendar();
				calendar.setTime(commonService.getCurrentDate());
				calendar.add(Calendar.DATE, -7);
				ksrq = DateUtil.parserDateToDefaultString(calendar.getTime());
			}
			paramMap.put("ksrq", ksrq);
			mv.addObject("ksrq", ksrq);
			if (StringUtils.hasText(dweb)) {
				paramMap1.put("dweb", dweb);
				List<SjlrMzda> daList = sjlrMzdaDAO.getDaListByZzds(paramMap1);
				paramMap.put("dweb", daList.get(0).getEph());
			}else if (StringUtils.hasText(cxeph)) {
				paramMap.put("dweb", "%" + cxeph + "%");
				mv.addObject("dweb", cxeph);
			}
			List<XtGydm> zqlcList = getGydm(XtAppConstant.CODE_SJLR_ZZZQLC);
			List<XtGydm> slList = getGydm(XtAppConstant.CODE_SJLR_SL);
			List<SjlrZzzq> zzzqList = sjlrZzzqDAO.selectZzzqListByParam(paramMap);
			List<SjlrZzzqDTO> zzzqDTOList = new ArrayList<SjlrZzzqDTO>();
			SjlrZzzqDTO sjlrZzzqDTO = null;
			String date = "";
			int count = 0;
			List<SjlrZzzq> zqList = null;
			if (zzzqList != null && zzzqList.size() > 0) {
				for (int i = 0; i < zzzqList.size(); i++) {
					SjlrZzzq sjlrZzzq = zzzqList.get(i);
					//转群流程
					if (StringUtils.hasText(sjlrZzzq.getZqlc())) {
						for (XtGydm xtGydm : zqlcList) {
							if (xtGydm.getDmid().equals(sjlrZzzq.getZqlc())) {
								sjlrZzzq.setZqlcStr(xtGydm.getDmmc());
							}
						}
					}
					//转入舍栏
					if (StringUtils.hasText(sjlrZzzq.getZrsl())) {
						for (XtGydm xtGydm : slList) {
							if (xtGydm.getDmid().equals(sjlrZzzq.getZrsl())) {
								sjlrZzzq.setZrslStr(xtGydm.getDmmc());
							}
						}
					}
					//转出舍栏
					if (StringUtils.hasText(sjlrZzzq.getZcsl())) {
						for (XtGydm xtGydm : slList) {
							if (xtGydm.getDmid().equals(sjlrZzzq.getZcsl())) {
								sjlrZzzq.setZcslStr(xtGydm.getDmmc());
							}
						}
					}
					//业务逻辑
					if (i == 0) {
						sjlrZzzqDTO = new SjlrZzzqDTO();
						zqList = new ArrayList<SjlrZzzq>();
						date = DateUtil.parserDateToDefaultString(sjlrZzzq.getZqsj());
						sjlrZzzqDTO.setZqrq(date);
						zqList.add(sjlrZzzq);
						count ++;
					} else {
						if (DateUtil.parserDateToDefaultString(sjlrZzzq.getZqsj()).equals(date)) {
							count ++;
							zqList.add(sjlrZzzq);
						} else {
							sjlrZzzqDTO.setZzzqList(zqList);
							sjlrZzzqDTO.setCount(count);
							zzzqDTOList.add(sjlrZzzqDTO);
							sjlrZzzqDTO = new SjlrZzzqDTO();
							zqList = new ArrayList<SjlrZzzq>();
							date = DateUtil.parserDateToDefaultString(sjlrZzzq.getZqsj());
							sjlrZzzqDTO.setZqrq(date);
							zqList.add(sjlrZzzq);
							count = 1;
						}
					}
				}
				if (count > 0) {
					sjlrZzzqDTO.setZzzqList(zqList);
					sjlrZzzqDTO.setCount(count);
					zzzqDTOList.add(sjlrZzzqDTO);
				}
				mv.addObject("zzzqDTOList", zzzqDTOList);
			}
		}
		return mv;
	}
	
	/**
	 * 种猪新增、修改
	 * @param request
	 * @param response
	 * @return
	 * @throws Exception
	 */
	public ModelAndView hpSjlrZzzqEdit(HttpServletRequest request,
			HttpServletResponse response) throws Exception {
		ModelAndView mv = new ModelAndView("haifmp/sjlr/scgl/zzzq/hpSjlrZzzqEdit.htm");
		String mcid = request.getParameter("mcid");
		String id = request.getParameter("id");
		String dweb = request.getParameter("dweb");
		String date = request.getParameter("date");
		//String eph = request.getParameter("eph");
		SjlrZzzq sjlrZzzq = new SjlrZzzq();
		if ("undefined".equals(dweb)) {
			dweb = "";
		}
		if (StringUtils.hasText(mcid)) {
			if (StringUtils.hasText(dweb)) {
				sjlrZzzq.setDweb(dweb);
			} else {
				if (StringUtils.hasText(id)) {
					sjlrZzzq = sjlrZzzqDAO.selectByPrimaryKey(Integer.parseInt(id));
					date = sjlrZzzq.getZqsj().toString();
					dweb = sjlrZzzq.getDweb();
				}
			}
			if (date != null) {
				if (!StringUtils.hasText(id)) {
					SimpleDateFormat sdf=new SimpleDateFormat(XtAppConstant.TIME_FORMAT);
					java.util.Date newdate=sdf.parse(date.toString());
					sjlrZzzq.setZqsj(newdate);
				}
			}else {
				sjlrZzzq.setZqsj(commonService.getCurrentDate());
			}
		}
		List<XtGydm> zqlcList = getGydm(XtAppConstant.CODE_SJLR_ZZZQLC);
		List<XtGydm> slList = getGydm(XtAppConstant.CODE_SJLR_SL);
		mv.addObject("zqlcList", zqlcList);
		mv.addObject("slList", slList);
		mv.addObject("sjlrZzzq", sjlrZzzq);
		mv.addObject("dweb",dweb);
		return mv;
	}
	
	/**
	 * 种猪转群
	 * @param request
	 * @throws Exception 
	 */
	public void saveSjlrZzzq(HttpServletRequest request,
			HttpServletResponse response) throws Exception {
		response.setContentType("text/json; charset=UTF-8");
		response.addHeader("Cache-Control", "no-cache,must-revalidate");
		response.addHeader("Pragma", "no-cache");
		
		String dweb = request.getParameter("dweb");

		SjlrZzzq sjlrZzzq = new SjlrZzzq();
		sjlrZzzq = (SjlrZzzq) parseObjectFromRequest(request, sjlrZzzq);
		if (dweb == "") {
			dweb = sjlrZzzqDAO.selectByPrimaryKey(sjlrZzzq.getId()).getDweb();
			sjlrZzzq.setDweb(dweb);
		}
		sjlrZzzq.setXgr(getLoginSessionBean(request).getYhid().toString());
		sjlrZzzq.setXgsj(commonService.getCurrentDate());
		sjlrZzzq.setZfbz(XtAppConstant.ZFBZ_VALID);
		
		//转出舍栏
		if (sjlrZzzq.getId() == 0 || sjlrZzzq.getId() == null) {
			//没有ID 转出舍栏去档案中找
			Map<String,Object> paramMap = new HashMap<String,Object>();
			paramMap.put("eph",dweb);
			List<SjlrMzda> mzList = sjlrMzdaDAO.getDaListByZzds(paramMap);
			sjlrZzzq.setZcsl(mzList.get(0).getSl());
		}else {
			//有ID ，转出舍栏去ZZZQ表中找
			String zcsl = sjlrZzzqDAO.selectByPrimaryKey(sjlrZzzq.getId()).getZcsl();
			sjlrZzzq.setZcsl(zcsl);
		}
		if (sjlrZzzq.getId() == 0) {
			sjlrZzzq.setId(null);
		}
		if (sjlrZzzq.getId() != null) {
			sjlrZzzqDAO.updateByPrimaryKeySelective(sjlrZzzq);
		} else {
			sjlrZzzqDAO.insertSelective(sjlrZzzq);
		}
		
		String zrsl = sjlrZzzq.getZrsl();
		if (StringUtils.hasText(zrsl)) {
			SjlrGzdaExample gzdaEx = new SjlrGzdaExample();
			SjlrGzdaExample.Criteria gzdaCr = gzdaEx.createCriteria(); 
			gzdaCr.andDwebEqualTo(sjlrZzzq.getDweb()).andZfbzEqualTo(XtAppConstant.ZFBZ_VALID);
			String mcid = request.getParameter("mcid");
			if (StringUtils.hasText(mcid)) {
				gzdaCr.andMcidEqualTo(Integer.parseInt(mcid));
			}
			SjlrGzda sjlrGzda = new SjlrGzda();
			sjlrGzda.setSl(zrsl);
			sjlrGzda.setXgr(getLoginSessionBean(request).getYhid().toString());
			sjlrGzda.setXgsj(commonService.getCurrentDate());
			sjlrGzdaDAO.updateByExampleSelective(sjlrGzda, gzdaEx);
			
			SjlrMzdaExample mzdaEx = new SjlrMzdaExample();
			SjlrMzdaExample.Criteria mzdaCr = mzdaEx.createCriteria(); 
			mzdaCr.andDwebEqualTo(sjlrZzzq.getDweb()).andZfbzEqualTo(XtAppConstant.ZFBZ_VALID);
			if (StringUtils.hasText(mcid)) {
				mzdaCr.andMcidEqualTo(Integer.parseInt(mcid));
			}
			SjlrMzda sjlrMzda = new SjlrMzda();
			sjlrMzda.setSl(zrsl);
			sjlrMzda.setXgr(getLoginSessionBean(request).getYhid().toString());
			sjlrMzda.setXgsj(commonService.getCurrentDate());
			sjlrMzdaDAO.updateByExampleSelective(sjlrMzda, mzdaEx);
		}
		
		String jsonStr = "{\"count\" : \"1\"}";
		response.getWriter().write(jsonStr);
	}
	
	/**
	 * 删除种猪转群
	 * @param request
	 * @throws Exception 
	 */
	public void disableZzzq(HttpServletRequest request,
			HttpServletResponse response) throws Exception {
		response.setContentType("text/json; charset=UTF-8");
		response.addHeader("Cache-Control", "no-cache,must-revalidate");
		response.addHeader("Pragma", "no-cache");
		
		String xgr = getLoginSessionBean(request).getYhid().toString();
		String id = request.getParameter("id");
		String jsonStr = "";
		int count = 0;
		if (StringUtils.hasText(id)) {
			SjlrZzzq sjlrZzzq = sjlrZzzqDAO.selectByPrimaryKey(Integer.parseInt(id));
			sjlrZzzq.setId(Integer.parseInt(id));
			sjlrZzzq.setZfbz(XtAppConstant.ZFBZ_INVALID);
			sjlrZzzq.setXgr(xgr);
			sjlrZzzq.setXgsj(commonService.getCurrentDate());
			sjlrZzzqDAO.updateByPrimaryKeySelective(sjlrZzzq);
			
			String dweb = sjlrZzzqDAO.selectByPrimaryKey(Integer.parseInt(id)).getDweb();
			SjlrGzdaExample gzEx = new SjlrGzdaExample();
			SjlrGzdaExample.Criteria gzCr = gzEx.createCriteria();
			gzCr.andDwebEqualTo(dweb).andZfbzEqualTo(XtAppConstant.ZFBZ_VALID);
			count = sjlrGzdaDAO.countByExample(gzEx);
			if (count > 0) {
				SjlrGzda sjlrGzda = new SjlrGzda();
				sjlrGzda.setSl(sjlrZzzq.getZcsl());
				sjlrGzda.setXgr(getLoginSessionBean(request).getYhid().toString());
				sjlrGzda.setXgsj(commonService.getCurrentDate());
				sjlrGzdaDAO.updateByExampleSelective(sjlrGzda, gzEx);
			}else {
				SjlrMzdaExample mzdaEx = new SjlrMzdaExample();
				SjlrMzdaExample.Criteria mzdaCr = mzdaEx.createCriteria(); 
				mzdaCr.andDwebEqualTo(sjlrZzzq.getDweb()).andZfbzEqualTo(XtAppConstant.ZFBZ_VALID);
				
				SjlrMzda sjlrMzda = new SjlrMzda();
				sjlrMzda.setSl(sjlrZzzq.getZcsl());
				sjlrMzda.setXgr(getLoginSessionBean(request).getYhid().toString());
				sjlrMzda.setXgsj(commonService.getCurrentDate());
				sjlrMzdaDAO.updateByExampleSelective(sjlrMzda, mzdaEx);
			}
			jsonStr = "{\"count\" : \"1\"}";
		} else {
			jsonStr = "{\"count\" : \"0\"}";
		}
		response.getWriter().write(jsonStr);
	}
	/**
	 * 种猪耳标公共查询页面
	 * @param request
	 * @param response
	 * @return
	 * @throws Exception
	 */
	public ModelAndView getZzmySearchDweb(HttpServletRequest request,
			HttpServletResponse response) throws Exception {
		ModelAndView mv = new ModelAndView("haifmp/sjlr/scgl/zzmy/zzmySearchModel.htm");
		String dweb = request.getParameter("dweb");
		String mcid = request.getParameter("mcid");
		String date = request.getParameter("date");
		String id = request.getParameter("id");
		String cxeph = request.getParameter("cxeph");
		if (StringUtils.hasText(id)) {
			mv.addObject("id", id);
		}
		if (StringUtils.hasText(mcid)) {
			Map<String, Object> paramMap = new HashMap<String, Object>();
			paramMap.put("mcid", mcid);
			if (StringUtils.hasText(dweb)) {
				paramMap.put("dweb", "%" + dweb + "%");
				mv.addObject("dweb", dweb);
			} else if (StringUtils.hasText(cxeph)) {
				paramMap.put("eph", "%" + cxeph + "%");
				mv.addObject("dweb", cxeph);
			}
			List<SjlrMzda> daList = sjlrMyjlDAO.selectZzmyDaListByParam(paramMap);
			List<XtGydm> slList = getGydm(XtAppConstant.CODE_SJLR_SL);
			List<XtGydm> dqztList = getGydm(XtAppConstant.CODE_SJLR_DQZT);
			if (daList != null && daList.size() > 0) {
				for (SjlrMzda sjlrMzda : daList) {
					//舍栏
					if (StringUtils.hasText(sjlrMzda.getSl())) {
						for (XtGydm xtGydm : slList) {
							if (sjlrMzda.getSl().equals(xtGydm.getDmid())) {
								sjlrMzda.setSlStr(xtGydm.getDmmc());
							}
						}
					}
					//当前状态
					if (StringUtils.hasText(sjlrMzda.getDqzt())) {
						for (XtGydm xtGydm : dqztList) {
							if (sjlrMzda.getDqzt().equals(xtGydm.getDmid())) {
								sjlrMzda.setDqztStr(xtGydm.getDmmc());
							}
						}
					}
				}
			}
			mv.addObject("daList", daList);
			mv.addObject("date",date);
		}
		return mv;
	}
	/**
	 * 耳标公共查询页面
	 * @param request
	 * @param response
	 * @return
	 * @throws Exception
	 */
	public ModelAndView getZzzqSearchDweb(HttpServletRequest request,
			HttpServletResponse response) throws Exception {
		ModelAndView mv = new ModelAndView("haifmp/sjlr/scgl/zzzq/zzzqSearchModel.htm");
		Map<String, Object> paramMap = new HashMap<String, Object>();
		Map<String, Object> paramMap1 = new HashMap<String, Object>();
		String dweb = request.getParameter("dweb");
		String mcid = request.getParameter("mcid");
		String date = request.getParameter("date");
		String id = request.getParameter("id");
		String cxeph = request.getParameter("cxeph");
		if (StringUtils.hasText(id)) {
			mv.addObject("id", id);
		}
		if (StringUtils.hasText(mcid)) {
			
			paramMap.put("mcid", mcid);
			if (StringUtils.hasText(dweb)) {
				paramMap1.put("dweb", dweb);
				List<SjlrMzda> daList = sjlrMzdaDAO.getDaListByZzds(paramMap1);
				paramMap.put("dweb", daList.get(0).getEph());
			}else if (StringUtils.hasText(cxeph)) {
				paramMap.put("dweb", "%" + cxeph + "%");
				mv.addObject("dweb", cxeph);
			}
			paramMap.put("dqzt", "6,7,10");
			List<SjlrMzda> daList = sjlrZzzqDAO.selectZzzqDaListByParam(paramMap);
			List<XtGydm> slList = getGydm(XtAppConstant.CODE_SJLR_SL);
			List<XtGydm> dqztList = getGydm(XtAppConstant.CODE_SJLR_DQZT);
			if (daList != null && daList.size() > 0) {
				for (SjlrMzda sjlrMzda : daList) {
					//舍栏
					if (StringUtils.hasText(sjlrMzda.getSl())) {
						for (XtGydm xtGydm : slList) {
							if (sjlrMzda.getSl().equals(xtGydm.getDmid())) {
								sjlrMzda.setSlStr(xtGydm.getDmmc());
							}
						}
					}
					//当前状态
					if (StringUtils.hasText(sjlrMzda.getDqzt())) {
						for (XtGydm xtGydm : dqztList) {
							if (sjlrMzda.getDqzt().equals(xtGydm.getDmid())) {
								sjlrMzda.setDqztStr(xtGydm.getDmmc());
							}
						}
					}
				}
			}
			mv.addObject("daList", daList);
			mv.addObject("date",date);
		}
		return mv;
	}
	
	/**
	 * 肥猪转群
	 * @param request
	 * @param response
	 * @return
	 * @throws Exception
	 */
	public ModelAndView hpSjlrFzzqIndex(HttpServletRequest request,
			HttpServletResponse response) throws Exception {
		ModelAndView mv = new ModelAndView("haifmp/sjlr/scgl/fzzq/hpSjlrFzzqIndex.htm");
		String mcid = request.getParameter("mcid");
		if (StringUtils.hasText(mcid)) {
			SjlrFzzqExample fzzqEx = new SjlrFzzqExample();
			fzzqEx.setOrderByClause("zqsj desc");
			SjlrFzzqExample.Criteria fzzqCr = fzzqEx.createCriteria();
			fzzqCr.andMcidEqualTo(Integer.parseInt(mcid)).andZfbzEqualTo(XtAppConstant.ZFBZ_VALID);
			String ksrq = request.getParameter("ksrq");
			String jsrq = request.getParameter("jsrq");
			if (!StringUtils.hasText(jsrq)) {
				jsrq = DateUtil.parserDateToDefaultString(commonService.getCurrentDate());
			}
			mv.addObject("jsrq", jsrq);
			fzzqCr.andZqsjLessThanOrEqualTo(DateUtil.parser(jsrq + XtAppConstant.TIME_FORMAT3));
			if (!StringUtils.hasText(ksrq)) {
				Calendar calendar = new GregorianCalendar();
				calendar.setTime(commonService.getCurrentDate());
				calendar.add(Calendar.DATE, -7);
				ksrq = DateUtil.parserDateToDefaultString(calendar.getTime());
			}
			mv.addObject("ksrq", ksrq);
			fzzqCr.andZqsjGreaterThanOrEqualTo(DateUtil.parser(ksrq + XtAppConstant.TIME_FORMAT2));
			List<XtGydm> zqlcList = getGydm(XtAppConstant.CODE_SJLR_FZZQLC);
			List<XtGydm> slList = getGydm(XtAppConstant.CODE_SJLR_SL);
			List<SjlrFzzq> fzzqList = sjlrFzzqDAO.selectByExample(fzzqEx);
			List<SjlrFzzqDTO> fzzqDTOList = new ArrayList<SjlrFzzqDTO>();
			SjlrFzzqDTO sjlrFzzqDTO = null;
			String date = "";
			int count = 0;
			List<SjlrFzzq> zqList = null;
			if (fzzqList != null && fzzqList.size() > 0) {
				for (int i = 0; i < fzzqList.size(); i++) {
					SjlrFzzq sjlrFzzq = fzzqList.get(i);
					//转群流程
					if (StringUtils.hasText(sjlrFzzq.getZqlc())) {
						for (XtGydm xtGydm : zqlcList) {
							if (xtGydm.getDmid().equals(sjlrFzzq.getZqlc())) {
								sjlrFzzq.setZqlcStr(xtGydm.getDmmc());
							}
						}
					}
					//转入舍栏
					if (StringUtils.hasText(sjlrFzzq.getZrsl())) {
						for (XtGydm xtGydm : slList) {
							if (xtGydm.getDmid().equals(sjlrFzzq.getZrsl())) {
								sjlrFzzq.setZrslStr(xtGydm.getDmmc());
							}
						}
					}
					//转出舍栏
					if (StringUtils.hasText(sjlrFzzq.getZcsl())) {
						for (XtGydm xtGydm : slList) {
							if (xtGydm.getDmid().equals(sjlrFzzq.getZcsl())) {
								sjlrFzzq.setZcslStr(xtGydm.getDmmc());
							}
						}
					}
					//业务逻辑
					if (i == 0) {
						sjlrFzzqDTO = new SjlrFzzqDTO();
						zqList = new ArrayList<SjlrFzzq>();
						date = DateUtil.parserDateToDefaultString(sjlrFzzq.getZqsj());
						sjlrFzzqDTO.setZqrq(date);
						zqList.add(sjlrFzzq);
						count = count + sjlrFzzq.getZcts();
					} else {
						if (DateUtil.parserDateToDefaultString(sjlrFzzq.getZqsj()).equals(date)) {
							count = count + sjlrFzzq.getZcts();
							zqList.add(sjlrFzzq);
						} else {
							sjlrFzzqDTO.setFzzqList(zqList);
							sjlrFzzqDTO.setCount(count);
							fzzqDTOList.add(sjlrFzzqDTO);
							sjlrFzzqDTO = new SjlrFzzqDTO();
							zqList = new ArrayList<SjlrFzzq>();
							date = DateUtil.parserDateToDefaultString(sjlrFzzq.getZqsj());
							sjlrFzzqDTO.setZqrq(date);
							zqList.add(sjlrFzzq);
							count = count + sjlrFzzq.getZcts();;
						}
					}
				}
				if (count > 0) {
					sjlrFzzqDTO.setFzzqList(zqList);
					sjlrFzzqDTO.setCount(count);
					fzzqDTOList.add(sjlrFzzqDTO);
				}
				mv.addObject("fzzqDTOList", fzzqDTOList);
			}
		}
		return mv;
	}
	
	/**
	 * 肥猪转群新增、修改
	 * @param request
	 * @param response
	 * @return
	 * @throws Exception
	 */
	public ModelAndView hpSjlrFzzqEdit(HttpServletRequest request,
			HttpServletResponse response) throws Exception {
		ModelAndView mv = new ModelAndView("haifmp/sjlr/scgl/fzzq/hpSjlrFzzqEdit.htm");
		String mcid = request.getParameter("mcid");
		String id = request.getParameter("id");
		SjlrFzzq sjlrFzzq = new SjlrFzzq();
		if (StringUtils.hasText(mcid)) {
			if (StringUtils.hasText(id)) {
				sjlrFzzq = sjlrFzzqDAO.selectByPrimaryKey(Integer.parseInt(id));
			}
			if (sjlrFzzq.getZqsj() == null) {
				sjlrFzzq.setZqsj(commonService.getCurrentDate());
			}
			sjlrFzzq.setMcid(Integer.parseInt(mcid));
			
		}
		List<XtGydm> zqlcList = getGydm(XtAppConstant.CODE_SJLR_FZZQLC);
		List<XtGydm> slList = getGydm(XtAppConstant.CODE_SJLR_SL);
		mv.addObject("zqlcList", zqlcList);
		mv.addObject("slList", slList);
		mv.addObject("sjlrFzzq", sjlrFzzq);
		return mv;
	}
	
	/**
	 * 肥猪转群
	 * @param request
	 * @throws Exception 
	 */
	public void saveSjlrFzzq(HttpServletRequest request,
			HttpServletResponse response) throws Exception {
		response.setContentType("text/json; charset=UTF-8");
		response.addHeader("Cache-Control", "no-cache,must-revalidate");
		response.addHeader("Pragma", "no-cache");
		
		SjlrFzzq sjlrFzzq = new SjlrFzzq();
		sjlrFzzq = (SjlrFzzq) parseObjectFromRequest(request, sjlrFzzq);
		sjlrFzzq.setXgr(getLoginSessionBean(request).getYhid().toString());
		sjlrFzzq.setXgsj(commonService.getCurrentDate());
		sjlrFzzq.setZfbz(XtAppConstant.ZFBZ_VALID);
		if (sjlrFzzq.getId() == 0) {
			sjlrFzzq.setId(null);
		}
		if (sjlrFzzq.getId() != null) {
			sjlrFzzqDAO.updateByPrimaryKeySelective(sjlrFzzq);
		} else {
			sjlrFzzqDAO.insertSelective(sjlrFzzq);
		}
		String jsonStr = "{\"count\" : \"1\"}";
		response.getWriter().write(jsonStr);
	}
	
	/**
	 * 删除肥猪转群
	 * @param request
	 * @throws Exception 
	 */
	public void disableFzzq(HttpServletRequest request,
			HttpServletResponse response) throws Exception {
		response.setContentType("text/json; charset=UTF-8");
		response.addHeader("Cache-Control", "no-cache,must-revalidate");
		response.addHeader("Pragma", "no-cache");
		String id = request.getParameter("id");
		String jsonStr = "";
		if (StringUtils.hasText(id)) {
			SjlrFzzq sjlrFzzq = new SjlrFzzq();
			sjlrFzzq.setId(Integer.parseInt(id));
			sjlrFzzq.setZfbz(XtAppConstant.ZFBZ_INVALID);
			sjlrFzzq.setXgr(getLoginSessionBean(request).getYhid().toString());
			sjlrFzzq.setXgsj(commonService.getCurrentDate());
			sjlrFzzqDAO.updateByPrimaryKeySelective(sjlrFzzq);
			jsonStr = "{\"count\" : \"1\"}";
		} else {
			jsonStr = "{\"count\" : \"0\"}";
		}
		response.getWriter().write(jsonStr);
	}
	
	/**
	 * 种猪死亡
	 * @param request
	 * @param response
	 * @return
	 * @throws Exception
	 */
	public ModelAndView hpSjlrZzswIndex(HttpServletRequest request,
			HttpServletResponse response) throws Exception {
		ModelAndView mv = new ModelAndView("haifmp/sjlr/scgl/zzsw/hpSjlrZzswIndex.htm");
		String mcid = request.getParameter("mcid");
		if (StringUtils.hasText(mcid)) {
			Map<String, Object> paramMap = new HashMap<String, Object>();
			paramMap.put("mcid", mcid);
			String ksrq = request.getParameter("ksrq");
			String jsrq = request.getParameter("jsrq");
			String dweb = request.getParameter("dweb");
			String cxeph = request.getParameter("cxeph");
			if (!StringUtils.hasText(jsrq)) {
				jsrq = DateUtil.parserDateToDefaultString(commonService.getCurrentDate());
			}
			paramMap.put("jsrq", jsrq);
			mv.addObject("jsrq", jsrq);
			if (!StringUtils.hasText(ksrq)) {
				Calendar calendar = new GregorianCalendar();
				calendar.setTime(commonService.getCurrentDate());
				calendar.add(Calendar.DATE, -7);
				ksrq = DateUtil.parserDateToDefaultString(calendar.getTime());
			}
			paramMap.put("ksrq", ksrq);
			mv.addObject("ksrq", ksrq);
			if (StringUtils.hasText(dweb)) {
				paramMap.put("dweb", "%" + dweb + "%");
				mv.addObject("dweb", dweb);
			}if (StringUtils.hasText(cxeph)) {
				paramMap.put("cxeph", "%" + cxeph + "%");
				mv.addObject("dweb", cxeph);
			}
			List<XtGydm> swlxList = getGydm(XtAppConstant.CODE_SJLR_SWLX);
			List<XtGydm> slList = getGydm(XtAppConstant.CODE_SJLR_SL);
			List<SjlrZzsw> zzswList = sjlrZzswDAO.selectZzswListByParam(paramMap);
			List<SjlrZzswDTO> zzswDTOList = new ArrayList<SjlrZzswDTO>();
			SjlrZzswDTO sjlrZzswDTO = null;
			String date = "";
			int count = 0;
			List<SjlrZzsw> swList = null;
			if (zzswList != null && zzswList.size() > 0) {
				for (int i = 0; i < zzswList.size(); i++) {
					SjlrZzsw sjlrZzsw = zzswList.get(i);
					//死亡类型
					if (StringUtils.hasText(sjlrZzsw.getSwlx())) {
						for (XtGydm xtGydm : swlxList) {
							if (xtGydm.getDmid().equals(sjlrZzsw.getSwlx())) {
								sjlrZzsw.setSwlxStr(xtGydm.getDmmc());
							}
						}
					}
					//死亡舍栏
					if (StringUtils.hasText(sjlrZzsw.getSwsl())) {
						for (XtGydm xtGydm : slList) {
							if (xtGydm.getDmid().equals(sjlrZzsw.getSwsl())) {
								sjlrZzsw.setSwslStr(xtGydm.getDmmc());
							}
						}
					}
					//业务逻辑
					if (i == 0) {
						sjlrZzswDTO = new SjlrZzswDTO();
						swList = new ArrayList<SjlrZzsw>();
						date = DateUtil.parserDateToDefaultString(sjlrZzsw.getSwsj());
						sjlrZzswDTO.setSwrq(date);
						swList.add(sjlrZzsw);
						count ++;
					} else {
						if (DateUtil.parserDateToDefaultString(sjlrZzsw.getSwsj()).equals(date)) {
							count ++;
							swList.add(sjlrZzsw);
						} else {
							sjlrZzswDTO.setZzswList(swList);
							sjlrZzswDTO.setCount(count);
							zzswDTOList.add(sjlrZzswDTO);
							sjlrZzswDTO = new SjlrZzswDTO();
							swList = new ArrayList<SjlrZzsw>();
							date = DateUtil.parserDateToDefaultString(sjlrZzsw.getSwsj());
							sjlrZzswDTO.setSwrq(date);
							swList.add(sjlrZzsw);
							count = 1;
						}
					}
				}
				if (count > 0) {
					sjlrZzswDTO.setZzswList(swList);
					sjlrZzswDTO.setCount(count);
					zzswDTOList.add(sjlrZzswDTO);
				}
				mv.addObject("zzswDTOList", zzswDTOList);
			}
		}
		return mv;
	}
	
	/**
	 * 种猪新增、修改
	 * @param request
	 * @param response
	 * @return
	 * @throws Exception
	 */
	public ModelAndView hpSjlrZzswEdit(HttpServletRequest request,
			HttpServletResponse response) throws Exception {
		ModelAndView mv = new ModelAndView("haifmp/sjlr/scgl/zzsw/hpSjlrZzswEdit.htm");
		String mcid = request.getParameter("mcid");
		String id = request.getParameter("id");
		String dweb = request.getParameter("dweb");
		String date = request.getParameter("date");
		SjlrZzsw sjlrZzsw = new SjlrZzsw();
		
		if ("undefined".equals(dweb)) {
			dweb = "";
		}
		if (StringUtils.hasText(mcid)) {
			if (StringUtils.hasText(dweb)) {
				sjlrZzsw.setDweb(dweb);
			} else {
				if (StringUtils.hasText(id)) {
					sjlrZzsw = sjlrZzswDAO.selectByPrimaryKey(Integer.parseInt(id));
					dweb = sjlrZzsw.getDweb();
					date = sjlrZzsw.getSwsj().toString();
				}
			}
			if (date != null) {
				if(!StringUtils.hasText(id)) {
					SimpleDateFormat sdf=new SimpleDateFormat(XtAppConstant.TIME_FORMAT);
					java.util.Date newdate=sdf.parse(date.toString());
					sjlrZzsw.setSwsj(newdate);
				}
			}else {
				sjlrZzsw.setSwsj(commonService.getCurrentDate());
			}
		}
		List<XtGydm> swlxList = getGydm(XtAppConstant.CODE_SJLR_SWLX);
		List<XtGydm> slList = getGydm(XtAppConstant.CODE_SJLR_SL);
		mv.addObject("swlxList", swlxList);
		mv.addObject("slList", slList);
		mv.addObject("sjlrZzsw", sjlrZzsw);
		mv.addObject("dweb",dweb);
		return mv;
	}
	
	/**
	 * 种猪死亡
	 * @param request
	 * @throws Exception 
	 */
	public void saveSjlrZzsw(HttpServletRequest request,
			HttpServletResponse response) throws Exception {
		response.setContentType("text/json; charset=UTF-8");
		response.addHeader("Cache-Control", "no-cache,must-revalidate");
		response.addHeader("Pragma", "no-cache");
		

		String dweb = request.getParameter("dweb");
		SjlrZzsw sjlrZzsw = new SjlrZzsw();
		String xgr = getLoginSessionBean(request).getYhid().toString();
		sjlrZzsw = (SjlrZzsw) parseObjectFromRequest(request, sjlrZzsw);
		sjlrZzsw.setXgr(xgr);
		sjlrZzsw.setXgsj(commonService.getCurrentDate());
		sjlrZzsw.setZfbz(XtAppConstant.ZFBZ_VALID);
		sjlrZzsw.setDweb(dweb);
		if (sjlrZzsw.getId() == 0) {
			sjlrZzsw.setId(null);
		}
		if (sjlrZzsw.getId() != null) {
			sjlrZzswDAO.updateByPrimaryKeySelective(sjlrZzsw);
		} else {
			sjlrZzswDAO.insertSelective(sjlrZzsw);
		}
		
		dweb = sjlrZzsw.getDweb();
		if (dweb == "") {
			dweb = sjlrZzttDAO.selectByPrimaryKey(sjlrZzsw.getId()).getDweb();
		}
		//档案中设置上次状态
		this.setDazt(dweb, xgr);
		
		String jsonStr = "{\"count\" : \"1\"}";
		response.getWriter().write(jsonStr);
	}
	
	/**
	 * 删除种猪死亡
	 * @param request
	 * @throws Exception 
	 */
	public void disableZzsw(HttpServletRequest request,
			HttpServletResponse response) throws Exception {
		response.setContentType("text/json; charset=UTF-8");
		response.addHeader("Cache-Control", "no-cache,must-revalidate");
		response.addHeader("Pragma", "no-cache");
		
		String xgr = getLoginSessionBean(request).getYhid().toString();
		String id = request.getParameter("id");
		String jsonStr = "";
		if (StringUtils.hasText(id)) {
			SjlrZzsw sjlrZzsw = new SjlrZzsw();
			sjlrZzsw.setId(Integer.parseInt(id));
			sjlrZzsw.setZfbz(XtAppConstant.ZFBZ_INVALID);
			sjlrZzsw.setXgr(xgr);
			sjlrZzsw.setXgsj(commonService.getCurrentDate());
			sjlrZzswDAO.updateByPrimaryKeySelective(sjlrZzsw);
			
			//修改档案中猪只状态
			String dweb = sjlrZzswDAO.selectByPrimaryKey(Integer.parseInt(id)).getDweb();
			setDazt(dweb, xgr);
			jsonStr = "{\"count\" : \"1\"}";
		} else {
			jsonStr = "{\"count\" : \"0\"}";
		}
		response.getWriter().write(jsonStr);
	}
	
	/**
	 * 耳标公共查询页面
	 * @param request
	 * @param response
	 * @return
	 * @throws Exception
	 */
	public ModelAndView getZzswSearchDweb(HttpServletRequest request,
			HttpServletResponse response) throws Exception {
		ModelAndView mv = new ModelAndView("haifmp/sjlr/scgl/zzsw/zzswSearchModel.htm");
		String dweb = request.getParameter("dweb");
		String mcid = request.getParameter("mcid");
		String date = request.getParameter("date");
		String id = request.getParameter("id");
		String cxeph = request.getParameter("cxeph");
		if (StringUtils.hasText(id)) {
			mv.addObject("id", id);
		}
		if (StringUtils.hasText(mcid)) {
			Map<String, Object> paramMap = new HashMap<String, Object>();
			Map<String, Object> paramMap1 = new HashMap<String, Object>();
			paramMap.put("mcid", mcid);
			if (StringUtils.hasText(dweb)) {
				paramMap1.put("dweb", dweb);
				List<SjlrMzda> daList = sjlrMzdaDAO.getDaListByZzds(paramMap1);
				String eph = daList.get(0).getEph();
				paramMap.put("dweb", "%" + eph + "%");
				mv.addObject("dweb", dweb);
			} else if (StringUtils.hasText(cxeph)) {
				paramMap.put("dweb", "%" + cxeph + "%");
				mv.addObject("dweb", cxeph);
			}
			paramMap.put("dqzt", "7,10");
			List<SjlrMzda> daList = sjlrZzzqDAO.selectZzzqDaListByParam(paramMap);
			List<XtGydm> slList = getGydm(XtAppConstant.CODE_SJLR_SL);
			List<XtGydm> dqztList = getGydm(XtAppConstant.CODE_SJLR_DQZT);
			if (daList != null && daList.size() > 0) {
				for (SjlrMzda sjlrMzda : daList) {
					//舍栏
					if (StringUtils.hasText(sjlrMzda.getSl())) {
						for (XtGydm xtGydm : slList) {
							if (sjlrMzda.getSl().equals(xtGydm.getDmid())) {
								sjlrMzda.setSlStr(xtGydm.getDmmc());
							}
						}
					}
					//当前状态
					if (StringUtils.hasText(sjlrMzda.getDqzt())) {
						for (XtGydm xtGydm : dqztList) {
							if (sjlrMzda.getDqzt().equals(xtGydm.getDmid())) {
								sjlrMzda.setDqztStr(xtGydm.getDmmc());
							}
						}
					}
				}
			}
			mv.addObject("daList", daList);
			mv.addObject("date",date);
		}
		return mv;
	}
	
	/**
	 * 肥猪死亡
	 * @param request
	 * @param response
	 * @return
	 * @throws Exception
	 */
	public ModelAndView hpSjlrFzswIndex(HttpServletRequest request,
			HttpServletResponse response) throws Exception {
		ModelAndView mv = new ModelAndView("haifmp/sjlr/scgl/fzsw/hpSjlrFzswIndex.htm");
		String mcid = request.getParameter("mcid");
		if (StringUtils.hasText(mcid)) {
			SjlrFzswExample fzswEx = new SjlrFzswExample();
			fzswEx.setOrderByClause("swsj desc");
			SjlrFzswExample.Criteria fzswCr = fzswEx.createCriteria();
			fzswCr.andMcidEqualTo(Integer.parseInt(mcid)).andZfbzEqualTo(XtAppConstant.ZFBZ_VALID);
			String ksrq = request.getParameter("ksrq");
			String jsrq = request.getParameter("jsrq");
			if (!StringUtils.hasText(jsrq)) {
				jsrq = DateUtil.parserDateToDefaultString(commonService.getCurrentDate());
			}
			mv.addObject("jsrq", jsrq);
			fzswCr.andSwsjLessThanOrEqualTo(DateUtil.parser(jsrq + XtAppConstant.TIME_FORMAT3));
			if (!StringUtils.hasText(ksrq)) {
				Calendar calendar = new GregorianCalendar();
				calendar.setTime(commonService.getCurrentDate());
				calendar.add(Calendar.DATE, -7);
				ksrq = DateUtil.parserDateToDefaultString(calendar.getTime());
			}
			mv.addObject("ksrq", ksrq);
			fzswCr.andSwsjGreaterThanOrEqualTo(DateUtil.parser(ksrq + XtAppConstant.TIME_FORMAT2));
			List<XtGydm> swlxList = getGydm(XtAppConstant.CODE_SJLR_SWLX);
			List<XtGydm> slList = getGydm(XtAppConstant.CODE_SJLR_SL);
			List<XtGydm> zzlxList = getGydm(XtAppConstant.CODE_SJLR_ZZLX);
			List<SjlrFzsw> fzswList = sjlrFzswDAO.selectByExample(fzswEx);
			List<SjlrFzswDTO> fzswDTOList = new ArrayList<SjlrFzswDTO>();
			SjlrFzswDTO sjlrFzswDTO = null;
			String date = "";
			int count = 0;
			List<SjlrFzsw> zqList = null;
			if (fzswList != null && fzswList.size() > 0) {
				for (int i = 0; i < fzswList.size(); i++) {
					SjlrFzsw sjlrFzsw = fzswList.get(i);
					//死亡类型
					if (StringUtils.hasText(sjlrFzsw.getSwlx())) {
						for (XtGydm xtGydm : swlxList) {
							if (xtGydm.getDmid().equals(sjlrFzsw.getSwlx())) {
								sjlrFzsw.setSwlxStr(xtGydm.getDmmc());
							}
						}
					}
					//舍栏
					if (StringUtils.hasText(sjlrFzsw.getSwsl())) {
						for (XtGydm xtGydm : slList) {
							if (xtGydm.getDmid().equals(sjlrFzsw.getSwsl())) {
								sjlrFzsw.setSwslStr(xtGydm.getDmmc());
							}
						}
					}
					//转出舍栏
					if (StringUtils.hasText(sjlrFzsw.getZzlx())) {
						for (XtGydm xtGydm : zzlxList) {
							if (xtGydm.getDmid().equals(sjlrFzsw.getZzlx())) {
								sjlrFzsw.setZzlxStr(xtGydm.getDmmc());
							}
						}
					}
					//业务逻辑
					if (i == 0) {
						sjlrFzswDTO = new SjlrFzswDTO();
						zqList = new ArrayList<SjlrFzsw>();
						date = DateUtil.parserDateToDefaultString(sjlrFzsw.getSwsj());
						sjlrFzswDTO.setSwrq(date);
						zqList.add(sjlrFzsw);
						count = sjlrFzsw.getSwts();
					} else {
						if (DateUtil.parserDateToDefaultString(sjlrFzsw.getSwsj()).equals(date)) {
							count = count + sjlrFzsw.getSwts();
							zqList.add(sjlrFzsw);
						} else {
							sjlrFzswDTO.setFzswList(zqList);
							sjlrFzswDTO.setCount(count);
							fzswDTOList.add(sjlrFzswDTO);
							sjlrFzswDTO = new SjlrFzswDTO();
							zqList = new ArrayList<SjlrFzsw>();
							date = DateUtil.parserDateToDefaultString(sjlrFzsw.getSwsj());
							sjlrFzswDTO.setSwrq(date);
							zqList.add(sjlrFzsw);
							count = sjlrFzsw.getSwts();;
						}
					}
				}
				if (count > 0) {
					sjlrFzswDTO.setFzswList(zqList);
					sjlrFzswDTO.setCount(count);
					fzswDTOList.add(sjlrFzswDTO);
				}
				mv.addObject("fzswDTOList", fzswDTOList);
			}
		}
		return mv;
	}
	
	/**
	 * 肥猪死亡新增、修改
	 * @param request
	 * @param response
	 * @return
	 * @throws Exception
	 */
	public ModelAndView hpSjlrFzswEdit(HttpServletRequest request,
			HttpServletResponse response) throws Exception {
		ModelAndView mv = new ModelAndView("haifmp/sjlr/scgl/fzsw/hpSjlrFzswEdit.htm");
		String mcid = request.getParameter("mcid");
		String id = request.getParameter("id");
		SjlrFzsw sjlrFzsw = new SjlrFzsw();
		if (StringUtils.hasText(mcid)) {
			if (StringUtils.hasText(id)) {
				sjlrFzsw = sjlrFzswDAO.selectByPrimaryKey(Integer.parseInt(id));
			}
			if (sjlrFzsw.getSwsj() == null) {
				sjlrFzsw.setSwsj(commonService.getCurrentDate());
			}
			sjlrFzsw.setMcid(Integer.parseInt(mcid));
		}
		List<XtGydm> swlxList = getGydm(XtAppConstant.CODE_SJLR_SWLX);
		List<XtGydm> slList = getGydm(XtAppConstant.CODE_SJLR_SL);
		List<XtGydm> zzlxList = getGydm(XtAppConstant.CODE_SJLR_ZZLX);
		mv.addObject("swlxList", swlxList);
		mv.addObject("zzlxList", zzlxList);
		mv.addObject("slList", slList);
		mv.addObject("sjlrFzsw", sjlrFzsw);
		return mv;
	}
	
	/**
	 * 肥猪死亡
	 * @param request
	 * @throws Exception 
	 */
	public void saveSjlrFzsw(HttpServletRequest request,
			HttpServletResponse response) throws Exception {
		response.setContentType("text/json; charset=UTF-8");
		response.addHeader("Cache-Control", "no-cache,must-revalidate");
		response.addHeader("Pragma", "no-cache");
		
		SjlrFzsw sjlrFzsw = new SjlrFzsw();
		sjlrFzsw = (SjlrFzsw) parseObjectFromRequest(request, sjlrFzsw);
		sjlrFzsw.setXgr(getLoginSessionBean(request).getYhid().toString());
		sjlrFzsw.setXgsj(commonService.getCurrentDate());
		sjlrFzsw.setZfbz(XtAppConstant.ZFBZ_VALID);
		if (sjlrFzsw.getId() == 0) {
			sjlrFzsw.setId(null);
		}
		if (sjlrFzsw.getId() != null) {
			sjlrFzswDAO.updateByPrimaryKeySelective(sjlrFzsw);
		} else {
			sjlrFzswDAO.insertSelective(sjlrFzsw);
		}
		String jsonStr = "{\"count\" : \"1\"}";
		response.getWriter().write(jsonStr);
	}
	
	/**
	 * 删除肥猪死亡
	 * @param request
	 * @throws Exception 
	 */
	public void disableFzsw(HttpServletRequest request,
			HttpServletResponse response) throws Exception {
		response.setContentType("text/json; charset=UTF-8");
		response.addHeader("Cache-Control", "no-cache,must-revalidate");
		response.addHeader("Pragma", "no-cache");
		
		String id = request.getParameter("id");
		String jsonStr = "";
		if (StringUtils.hasText(id)) {
			SjlrFzsw sjlrFzsw = new SjlrFzsw();
			sjlrFzsw.setId(Integer.parseInt(id));
			sjlrFzsw.setZfbz(XtAppConstant.ZFBZ_INVALID);
			sjlrFzsw.setXgr(getLoginSessionBean(request).getYhid().toString());
			sjlrFzsw.setXgsj(commonService.getCurrentDate());
			sjlrFzswDAO.updateByPrimaryKeySelective(sjlrFzsw);
			jsonStr = "{\"count\" : \"1\"}";
		} else {
			jsonStr = "{\"count\" : \"0\"}";
		}
		response.getWriter().write(jsonStr);
	}
	
	/**
	 * 种猪淘汰
	 * @param request
	 * @param response
	 * @return
	 * @throws Exception
	 */
	public ModelAndView hpSjlrZzttIndex(HttpServletRequest request,
			HttpServletResponse response) throws Exception {
 		ModelAndView mv = new ModelAndView("haifmp/sjlr/scgl/zztt/hpSjlrZzttIndex.htm");
		String mcid = request.getParameter("mcid");
		if (StringUtils.hasText(mcid)) {
			Map<String, Object> paramMap = new HashMap<String, Object>();
			paramMap.put("mcid", mcid);
			String ksrq = request.getParameter("ksrq");
			String jsrq = request.getParameter("jsrq");
			String dweb = request.getParameter("dweb");
			String cxeph = request.getParameter("cxeph");
			if (!StringUtils.hasText(jsrq)) {
				jsrq = DateUtil.parserDateToDefaultString(commonService.getCurrentDate());
				
			}
			paramMap.put("jsrq", jsrq);
			mv.addObject("jsrq", jsrq);
			if (!StringUtils.hasText(ksrq)) {
				Calendar calendar = new GregorianCalendar();
				calendar.setTime(commonService.getCurrentDate());
				calendar.add(Calendar.DATE, -7);
				ksrq = DateUtil.parserDateToDefaultString(calendar.getTime());
			}
			paramMap.put("ksrq", ksrq);
			mv.addObject("ksrq", ksrq);
			if (StringUtils.hasText(dweb)) {
				paramMap.put("dweb", "%" + dweb + "%");
				mv.addObject("dweb", dweb);
			}else if (StringUtils.hasText(cxeph)) {
				paramMap.put("cxeph", "%" + cxeph + "%");
				mv.addObject("dweb", cxeph);
			}
			List<XtGydm> ttlxList = getGydm(XtAppConstant.CODE_SJLR_TTLX);
			List<XtGydm> slList = getGydm(XtAppConstant.CODE_SJLR_SL);
			paramMap.put("order", "order by tt.id desc");
			List<SjlrZztt> zzttList = sjlrZzttDAO.selectZzttListByParam(paramMap);
			
			
			List<SjlrZzttDTO> zzttDTOList = new ArrayList<SjlrZzttDTO>();
			SjlrZzttDTO sjlrZzttDTO = null;
			String date = "";
			int count = 0;
			List<SjlrZztt> ttList = null;
			if (zzttList != null && zzttList.size() > 0) {
				for (int i = 0; i < zzttList.size(); i++) {
					SjlrZztt sjlrZztt = zzttList.get(i);
					if (sjlrZztt.getSh().equals("1")) {
						sjlrZztt.setShStr("已审核");
					} else if(sjlrZztt.getSh().equals("2")){
						sjlrZztt.setShStr("已驳回");
					} else {
						sjlrZztt.setShStr("未审核");
					}
					//淘汰类型
					if (StringUtils.hasText(sjlrZztt.getTtlx())) {
						for (XtGydm xtGydm : ttlxList) {
							if (xtGydm.getDmid().equals(sjlrZztt.getTtlx())) {
								sjlrZztt.setTtlxStr(xtGydm.getDmmc());
							}
						}
					}
					//转入舍栏
					if (StringUtils.hasText(sjlrZztt.getZrsl())) {
						for (XtGydm xtGydm : slList) {
							if (xtGydm.getDmid().equals(sjlrZztt.getZrsl())) {
								sjlrZztt.setZrslStr(xtGydm.getDmmc());
							}
						}
					}
					//淘汰舍栏
					if (StringUtils.hasText(sjlrZztt.getTtsl())) {
						for (XtGydm xtGydm : slList) {
							if (xtGydm.getDmid().equals(sjlrZztt.getTtsl())) {
								sjlrZztt.setTtslStr(xtGydm.getDmmc());
							}
						}
					}
					//业务逻辑
					if (i == 0) {
						sjlrZzttDTO = new SjlrZzttDTO();
						ttList = new ArrayList<SjlrZztt>();
						date = DateUtil.parserDateToDefaultString(sjlrZztt.getTtsj());
						sjlrZzttDTO.setTtrq(date);
						ttList.add(sjlrZztt);
						count ++;
					} else {
						if (DateUtil.parserDateToDefaultString(sjlrZztt.getTtsj()).equals(date)) {
							count ++;
							ttList.add(sjlrZztt);
						} else {
							sjlrZzttDTO.setZzttList(ttList);
							sjlrZzttDTO.setCount(count);
							zzttDTOList.add(sjlrZzttDTO);
							sjlrZzttDTO = new SjlrZzttDTO();
							ttList = new ArrayList<SjlrZztt>();
							date = DateUtil.parserDateToDefaultString(sjlrZztt.getTtsj());
							sjlrZzttDTO.setTtrq(date);
							ttList.add(sjlrZztt);
							count = 1;
						}
					}
				}
				if (count > 0) {
					sjlrZzttDTO.setZzttList(ttList);
					sjlrZzttDTO.setCount(count);
					zzttDTOList.add(sjlrZzttDTO);
				}
				mv.addObject("zzttDTOList", zzttDTOList);
			}
		}
		return mv;
	}
	
	/**
	 * 种猪淘汰新增、修改
	 * @param request
	 * @param response
	 * @return
	 * @throws Exception
	 */
	public ModelAndView hpSjlrZzttEdit(HttpServletRequest request,
			HttpServletResponse response) throws Exception {
		ModelAndView mv = new ModelAndView("haifmp/sjlr/scgl/zztt/hpSjlrZzttEdit.htm");
		String mcid = request.getParameter("mcid");
		String id = request.getParameter("id");
		String dweb = request.getParameter("dweb");
		String date = request.getParameter("date");
		String eph = request.getParameter("eph");
		SjlrZztt sjlrZztt = new SjlrZztt();
		if (StringUtils.hasText(mcid)) {
			if (StringUtils.hasText(dweb)) {
				sjlrZztt.setDweb(dweb);
			}
			if (StringUtils.hasText(id)) {
				sjlrZztt = sjlrZzttDAO.selectByPrimaryKey(Integer.parseInt(id));
				dweb = sjlrZztt.getDweb();
				date = sjlrZztt.getTtsj().toString();
			}
			if (StringUtils.hasText(eph)) {
				sjlrZztt.setEph(eph);
			}
			if (date != null) {
				if (!StringUtils.hasText(id)) {
					SimpleDateFormat sdf=new SimpleDateFormat(XtAppConstant.TIME_FORMAT);
					java.util.Date newdate=sdf.parse(date.toString());
					sjlrZztt.setTtsj(newdate);
				}
			}else {
				sjlrZztt.setTtsj(commonService.getCurrentDate());
			}
		}
		List<XtGydm> ttlxList = getGydm(XtAppConstant.CODE_SJLR_TTLX);
		List<XtGydm> slList = getGydm(XtAppConstant.CODE_SJLR_SL);
		mv.addObject("ttlxList", ttlxList);
		mv.addObject("slList", slList);
		mv.addObject("sjlrZztt", sjlrZztt);
		mv.addObject("dweb",dweb);
		return mv;
	}
	
	/**
	 * 保存种猪淘汰
	 * @param request
	 * @throws Exception 
	 */
	public void saveSjlrZztt(HttpServletRequest request,
			HttpServletResponse response) throws Exception {
		response.setContentType("text/json; charset=UTF-8");
		response.addHeader("Cache-Control", "no-cache,must-revalidate");
		response.addHeader("Pragma", "no-cache");
		String dweb = request.getParameter("dweb");
		SjlrZztt sjlrZztt = new SjlrZztt();
		sjlrZztt = (SjlrZztt) parseObjectFromRequest(request, sjlrZztt);
		sjlrZztt.setXgr(getLoginSessionBean(request).getYhid().toString());
		sjlrZztt.setXgsj(commonService.getCurrentDate());
		sjlrZztt.setSh("0");//未审核
		sjlrZztt.setZfbz(XtAppConstant.ZFBZ_VALID);
		if (sjlrZztt.getId() == 0) {
			sjlrZztt.setId(null);
		}
		if (dweb == "") {
			dweb = sjlrZzttDAO.selectByPrimaryKey(sjlrZztt.getId()).getDweb();
			sjlrZztt.setDweb(dweb);
		}else {
			sjlrZztt.setDweb(dweb);
		}
		Map<String, Object> paramMap = new HashMap<String, Object>();
		paramMap.put("dweb", dweb);
		List<SjlrZztt> zzttList = sjlrZzttDAO.selectZzttSLByParam(paramMap);
		if(zzttList.size()>0) {
			SjlrZztt sjlrZztt1 = new SjlrZztt();
			for(int i=0 ; i<zzttList.size() ; i++) {
				sjlrZztt1=zzttList.get(i);
				if(sjlrZztt1.getEph().equals(sjlrZztt.getEph())) {
					sjlrZztt.setTtsl(sjlrZztt1.getTtsl());	
					break;
				}
			}
		}
		//种猪淘汰时间不能小于入栏日期
		Map<String, Object> paramMap1 = new HashMap<String, Object>();
		paramMap1.put("dweb", dweb);
		List<SjlrMzda> daList = sjlrMzdaDAO.getDaListByZzds(paramMap1);
		if (daList.size() > 0 ) {
			Date rlrq = daList.get(0).getRlrq();
			if (sjlrZztt.getTtsj().getTime() < rlrq.getTime()) {
				String jsonStr = "{\"count\" : \"2\"}";
				response.getWriter().write(jsonStr);
				return;
			}
		}
		
		if (sjlrZztt.getId() != null) {
			sjlrZzttDAO.updateByPrimaryKeySelective(sjlrZztt);
		} else {
			sjlrZzttDAO.insertSelective(sjlrZztt);
		}
		
/*		//修改档案中的当前舍栏和状态
		String zrsl = sjlrZztt.getZrsl();
		if (StringUtils.hasText(zrsl)) {
			SjlrGzda sjlrGzda = new SjlrGzda();
			SjlrGzdaExample gzdaEx = new SjlrGzdaExample();
			SjlrGzdaExample.Criteria gzdaCr = gzdaEx.createCriteria(); 
			gzdaCr.andDwebEqualTo(sjlrZztt.getDweb()).andZfbzEqualTo(XtAppConstant.ZFBZ_VALID);
			String mcid = request.getParameter("mcid");
			if (StringUtils.hasText(mcid)) {
				gzdaCr.andMcidEqualTo(Integer.parseInt(mcid));
			}
			List<SjlrGzda> daList = sjlrGzdaDAO.selectByExample(gzdaEx);
			if (daList.size() > 0) {
				sczt = daList.get(0).getDqzt();
				sjlrGzda.setSczt(sczt);
				sjlrGzda.setSl(zrsl);
				sjlrGzda.setDqzt(XtAppConstant.CODE_SJLR_DQZT_TT);
				sjlrGzda.setXgr(getLoginSessionBean(request).getYhid().toString());
				sjlrGzda.setXgsj(commonService.getCurrentDate());
				sjlrGzdaDAO.updateByExampleSelective(sjlrGzda, gzdaEx);
			}

			SjlrMzdaExample mzdaEx = new SjlrMzdaExample();
			SjlrMzdaExample.Criteria mzdaCr = mzdaEx.createCriteria(); 
			mzdaCr.andDwebEqualTo(sjlrZztt.getDweb()).andZfbzEqualTo(XtAppConstant.ZFBZ_VALID);
			if (StringUtils.hasText(mcid)) {
				mzdaCr.andMcidEqualTo(Integer.parseInt(mcid));
			}
			List<SjlrMzda> mzList = sjlrMzdaDAO.selectByExample(mzdaEx);
			if (mzList.size() > 0) {
				scztMz = mzList.get(0).getSczt();
				SjlrMzda sjlrMzda = new SjlrMzda();
				sjlrMzda.setSl(zrsl);
				sjlrMzda.setDqzt(XtAppConstant.CODE_SJLR_DQZT_TT);
				sjlrMzda.setXgr(getLoginSessionBean(request).getYhid().toString());
				sjlrMzda.setXgsj(commonService.getCurrentDate());
				sjlrMzda.setSczt(scztMz);
				sjlrMzdaDAO.updateByExampleSelective(sjlrMzda, mzdaEx);
			}
			
		}*/
		String jsonStr = "{\"count\" : \"1\"}";
		response.getWriter().write(jsonStr);
	}
	
	/**
	 * 删除种猪淘汰
	 * @param request
	 * @throws Exception 
	 */
	public void disableZztt(HttpServletRequest request,
			HttpServletResponse response) throws Exception {
		response.setContentType("text/json; charset=UTF-8");
		response.addHeader("Cache-Control", "no-cache,must-revalidate");
		response.addHeader("Pragma", "no-cache");
		String xgr = getLoginSessionBean(request).getYhid().toString();
		String id = request.getParameter("id");
		String jsonStr = "";
		if (StringUtils.hasText(id)) {
			SjlrZztt sjlrZztt = new SjlrZztt();
			sjlrZztt.setId(Integer.parseInt(id));
			sjlrZztt.setZfbz(XtAppConstant.ZFBZ_INVALID);
			sjlrZztt.setXgr(xgr);
			sjlrZztt.setXgsj(commonService.getCurrentDate());
			sjlrZzttDAO.updateByPrimaryKeySelective(sjlrZztt);
			
			//修改档案中的当前状态
			String dweb = sjlrZzttDAO.selectByPrimaryKey(Integer.parseInt(id)).getDweb();
			this.setDazt(dweb, xgr);
			jsonStr = "{\"count\" : \"1\"}";
		} else {
			jsonStr = "{\"count\" : \"0\"}";
		}
		response.getWriter().write(jsonStr);
	}
	
	
	/**
	 * 确定种猪淘汰
	 * 淘汰审核标志改为1
	 * 档案表里状态改为淘汰
	 * @param request
	 * @throws Exception 
	 */
	public void zzttConfirmTt(HttpServletRequest request,
			HttpServletResponse response) throws Exception {
		response.setContentType("text/json; charset=UTF-8");
		response.addHeader("Cache-Control", "no-cache,must-revalidate");
		response.addHeader("Pragma", "no-cache");
		String id = request.getParameter("id");
		String xgr = getLoginSessionBean(request).getYhid().toString();
		String jsonStr = "";
		if (StringUtils.hasText(id)) {
			SjlrZztt sjlrZztt = new SjlrZztt();
			sjlrZztt.setId(Integer.parseInt(id));
			sjlrZztt.setZfbz(XtAppConstant.ZFBZ_VALID);
			sjlrZztt.setXgr(xgr);
			sjlrZztt.setXgsj(commonService.getCurrentDate());
			sjlrZztt.setSh("1");
			sjlrZzttDAO.updateByPrimaryKeySelective(sjlrZztt);
			//修改档案中的当前状态
			String dweb = sjlrZzttDAO.selectByPrimaryKey(Integer.parseInt(id)).getDweb();
			this.modify(dweb, xgr);
			jsonStr = "{\"data\" : \"1\"}";
		} else {
			jsonStr = "{\"data\" : \"0\"}";
		}
		response.getWriter().write(jsonStr);
	}
	/**
	 * 驳回种猪淘汰
	 * 作废标志之置1
	 * @param request
	 * @throws Exception 
	 */
	public void zzttRejectedTt(HttpServletRequest request,
			HttpServletResponse response) throws Exception {
		response.setContentType("text/json; charset=UTF-8");
		response.addHeader("Cache-Control", "no-cache,must-revalidate");
		response.addHeader("Pragma", "no-cache");
		String id = request.getParameter("id");
		String xgr = getLoginSessionBean(request).getYhid().toString();
		String jsonStr = "";
		if (StringUtils.hasText(id)) {
			SjlrZztt sjlrZztt = new SjlrZztt();
			sjlrZztt.setId(Integer.parseInt(id));
			sjlrZztt.setXgr(xgr);
			sjlrZztt.setXgsj(commonService.getCurrentDate());
			sjlrZztt.setSh("2");//已驳回
			sjlrZzttDAO.updateByPrimaryKeySelective(sjlrZztt);
			jsonStr = "{\"data\" : \"1\"}";
		} else {
			jsonStr = "{\"data\" : \"0\"}";
		}
		response.getWriter().write(jsonStr);
	}
	
	/**
	 * 查询猪只生平
	 * @param request
	 * @throws Exception 
	 */
	public void selectPigRerecord(HttpServletRequest request,
			HttpServletResponse response) throws Exception {
		response.setContentType("text/json; charset=UTF-8");
		response.addHeader("Cache-Control", "no-cache,must-revalidate");
		response.addHeader("Pragma", "no-cache");
		String id = request.getParameter("id");
		String jsonStr = "";
		List<SjlrMzda> mzdaList = null;
		List<SjlrGzda> gzdaList = null;
		if (StringUtils.hasText(id)) {
			//先查动物Eb,再去档案里查是公猪还是母猪
			SjlrZztt zztt = sjlrZzttDAO.selectByPrimaryKey(Integer.parseInt(id));
			String dweb = zztt.getDweb();
			if (StringUtils.hasText(dweb)) {
				//母猪档案
				SjlrMzdaExample mzdaEx = new SjlrMzdaExample();
				SjlrMzdaExample.Criteria mzddCr = mzdaEx.createCriteria();
				mzddCr.andDwebEqualTo(zztt.getDweb()).andZfbzEqualTo(XtAppConstant.ZFBZ_VALID);
				mzdaList = sjlrMzdaDAO.selectByExample(mzdaEx);
				//公猪档案
				SjlrGzdaExample gzdaEx = new SjlrGzdaExample();
				SjlrGzdaExample.Criteria gzddCr = gzdaEx.createCriteria();
				gzddCr.andDwebEqualTo(zztt.getDweb()).andZfbzEqualTo(XtAppConstant.ZFBZ_VALID);
				gzdaList = sjlrGzdaDAO.selectByExample(gzdaEx);
				
			}
			if (mzdaList.size() > 0 && gzdaList.size() <= 0) {//如果母猪档案里有这个动物耳标
				jsonStr = "{\"data\" : \"2\",\"id\" : \"" +  mzdaList.get(0).getId() + "\"}";
			} else if (gzdaList.size() > 0 && mzdaList.size() <= 0) {//如果公猪档案里有这个动物耳标
				jsonStr = "{\"data\" : \"1\",\"id\" : \"" +  gzdaList.get(0).getId() + "\"}";
			} else {
				jsonStr = "{\"data\" : \"0\"}";
			}
		} else {
			jsonStr = "{\"data\" : \"0\"}";
		}
		response.getWriter().write(jsonStr);
	}
	
	/**
	 * 耳标公共查询页面
	 * @param request
	 * @param response
	 * @return
	 * @throws Exception
	 */
	public ModelAndView getZzttSearchDweb(HttpServletRequest request,
			HttpServletResponse response) throws Exception {
		ModelAndView mv = new ModelAndView("haifmp/sjlr/scgl/zztt/zzttSearchModel.htm");
		String dweb = request.getParameter("dweb");
		String mcid = request.getParameter("mcid");
		String date = request.getParameter("date");
		String id = request.getParameter("id");
		String cxeph = request.getParameter("cxeph");
		Map<String, Object> paramMap = new HashMap<String, Object>();
		if (StringUtils.hasText(id)) {
			mv.addObject("id", id);
		}
		if (StringUtils.hasText(mcid)) {
			paramMap.put("mcid", mcid);
			if (StringUtils.hasText(dweb)) {
				paramMap.put("dweb", "%" + dweb + "%");
				mv.addObject("dweb", dweb);
			}else if (StringUtils.hasText(cxeph)) {
				paramMap.put("cxeph", "%" + cxeph + "%");
				mv.addObject("dweb", cxeph);
			}
			paramMap.put("dqzt", "6,7,10");
			List<SjlrMzda> daList = sjlrZzzqDAO.selectZzzqDaListByParam(paramMap);
			List<XtGydm> slList = getGydm(XtAppConstant.CODE_SJLR_SL);
			List<XtGydm> dqztList = getGydm(XtAppConstant.CODE_SJLR_DQZT);
			if (daList != null && daList.size() > 0) {
				for (SjlrMzda sjlrMzda : daList) {
					//舍栏
					if (StringUtils.hasText(sjlrMzda.getSl())) {
						for (XtGydm xtGydm : slList) {
							if (sjlrMzda.getSl().equals(xtGydm.getDmid())) {
								sjlrMzda.setSlStr(xtGydm.getDmmc());
							}
						}
					}
					//当前状态
					if (StringUtils.hasText(sjlrMzda.getDqzt())) {
						for (XtGydm xtGydm : dqztList) {
							if (sjlrMzda.getDqzt().equals(xtGydm.getDmid())) {
								sjlrMzda.setDqztStr(xtGydm.getDmmc());
							}
						}
					}
				}
			}
			mv.addObject("daList", daList);
			mv.addObject("date",date);
		}
		return mv;
	}
	
	/**
	 * 肥猪淘汰
	 * @param request
	 * @param response
	 * @return
	 * @throws Exception
	 */
	public ModelAndView hpSjlrFzttIndex(HttpServletRequest request,
			HttpServletResponse response) throws Exception {
		ModelAndView mv = new ModelAndView("haifmp/sjlr/scgl/fztt/hpSjlrFzttIndex.htm");
		String mcid = request.getParameter("mcid");
		if (StringUtils.hasText(mcid)) {
			SjlrFzttExample fzttEx = new SjlrFzttExample();
			fzttEx.setOrderByClause("ttsj desc");
			SjlrFzttExample.Criteria fzttCr = fzttEx.createCriteria();
			fzttCr.andMcidEqualTo(Integer.parseInt(mcid)).andZfbzEqualTo(XtAppConstant.ZFBZ_VALID);
			String ksrq = request.getParameter("ksrq");
			String jsrq = request.getParameter("jsrq");
			if (!StringUtils.hasText(jsrq)) {
				jsrq = DateUtil.parserDateToDefaultString(commonService.getCurrentDate());
				
			}
			mv.addObject("jsrq", jsrq);
			fzttCr.andTtsjLessThanOrEqualTo(DateUtil.parser(jsrq + XtAppConstant.TIME_FORMAT3));
			if (!StringUtils.hasText(ksrq)) {
				Calendar calendar = new GregorianCalendar();
				calendar.setTime(commonService.getCurrentDate());
				calendar.add(Calendar.DATE, -7);
				ksrq = DateUtil.parserDateToDefaultString(calendar.getTime());
			}
			mv.addObject("ksrq", ksrq);
			fzttCr.andTtsjGreaterThanOrEqualTo(DateUtil.parser(ksrq + XtAppConstant.TIME_FORMAT2));
			List<XtGydm> ttlxList = getGydm(XtAppConstant.CODE_SJLR_TTLX);
			List<XtGydm> slList = getGydm(XtAppConstant.CODE_SJLR_SL);
			List<SjlrFztt> fzttList = sjlrFzttDAO.selectByExample(fzttEx);
			List<SjlrFzttDTO> fzttDTOList = new ArrayList<SjlrFzttDTO>();
			SjlrFzttDTO sjlrFzttDTO = null;
			String date = "";
			int count = 0;
			List<SjlrFztt> zqList = null;
			if (fzttList != null && fzttList.size() > 0) {
				for (int i = 0; i < fzttList.size(); i++) {
					SjlrFztt sjlrFztt = fzttList.get(i);
					//淘汰类型
					if (StringUtils.hasText(sjlrFztt.getTtlx())) {
						for (XtGydm xtGydm : ttlxList) {
							if (xtGydm.getDmid().equals(sjlrFztt.getTtlx())) {
								sjlrFztt.setTtlxStr(xtGydm.getDmmc());
							}
						}
					}
					//转入舍栏
					if (StringUtils.hasText(sjlrFztt.getZrsl())) {
						for (XtGydm xtGydm : slList) {
							if (xtGydm.getDmid().equals(sjlrFztt.getZrsl())) {
								sjlrFztt.setZrslStr(xtGydm.getDmmc());
							}
						}
					}
					//淘汰舍栏
					if (StringUtils.hasText(sjlrFztt.getTtsl())) {
						for (XtGydm xtGydm : slList) {
							if (xtGydm.getDmid().equals(sjlrFztt.getTtsl())) {
								sjlrFztt.setTtslStr(xtGydm.getDmmc());
							}
						}
					}
					//业务逻辑
					if (i == 0) {
						sjlrFzttDTO = new SjlrFzttDTO();
						zqList = new ArrayList<SjlrFztt>();
						date = DateUtil.parserDateToDefaultString(sjlrFztt.getTtsj());
						sjlrFzttDTO.setTtrq(date);
						zqList.add(sjlrFztt);
						count = sjlrFztt.getTtts();
					} else {
						if (DateUtil.parserDateToDefaultString(sjlrFztt.getTtsj()).equals(date)) {
							count = count + sjlrFztt.getTtts();
							zqList.add(sjlrFztt);
						} else {
							sjlrFzttDTO.setFzttList(zqList);
							sjlrFzttDTO.setCount(count);
							fzttDTOList.add(sjlrFzttDTO);
							sjlrFzttDTO = new SjlrFzttDTO();
							zqList = new ArrayList<SjlrFztt>();
							date = DateUtil.parserDateToDefaultString(sjlrFztt.getTtsj());
							sjlrFzttDTO.setTtrq(date);
							zqList.add(sjlrFztt);
							count = sjlrFztt.getTtts();
						}
					}
				}
				if (count > 0) {
					sjlrFzttDTO.setFzttList(zqList);
					sjlrFzttDTO.setCount(count);
					fzttDTOList.add(sjlrFzttDTO);
				}
				mv.addObject("fzttDTOList", fzttDTOList);
			}
		}
		return mv;
	}
	
	/**
	 * 肥猪新增、修改
	 * @param request
	 * @param response
	 * @return
	 * @throws Exception
	 */
	public ModelAndView hpSjlrFzttEdit(HttpServletRequest request,
			HttpServletResponse response) throws Exception {
		ModelAndView mv = new ModelAndView("haifmp/sjlr/scgl/fztt/hpSjlrFzttEdit.htm");
		String mcid = request.getParameter("mcid");
		String id = request.getParameter("id");
		SjlrFztt sjlrFztt = new SjlrFztt();
		if (StringUtils.hasText(mcid)) {
			if (StringUtils.hasText(id)) {
				sjlrFztt = sjlrFzttDAO.selectByPrimaryKey(Integer.parseInt(id));
			}
			if (sjlrFztt.getTtsj() == null) {
				sjlrFztt.setTtsj(commonService.getCurrentDate());
			}
			sjlrFztt.setMcid(Integer.parseInt(mcid));
		}
		List<XtGydm> ttlxList = getGydm(XtAppConstant.CODE_SJLR_TTLX);
		List<XtGydm> ttfsList = getGydm(XtAppConstant.CODE_SJLR_TTFS);
		List<XtGydm> zzlxList = getGydm(XtAppConstant.CODE_SJLR_ZZLX);
		List<XtGydm> slList = getGydm(XtAppConstant.CODE_SJLR_SL);
		mv.addObject("ttlxList", ttlxList);
		mv.addObject("ttfsList", ttfsList);
		mv.addObject("zzlxList", zzlxList);
		mv.addObject("slList", slList);
		mv.addObject("sjlrFztt", sjlrFztt);
		return mv;
	}
	
	/**
	 * 肥猪淘汰
	 * @param request
	 * @throws Exception 
	 */
	public void saveSjlrFztt(HttpServletRequest request,
			HttpServletResponse response) throws Exception {
		response.setContentType("text/json; charset=UTF-8");
		response.addHeader("Cache-Control", "no-cache,must-revalidate");
		response.addHeader("Pragma", "no-cache");
		
		SjlrFztt sjlrFztt = new SjlrFztt();
		sjlrFztt = (SjlrFztt) parseObjectFromRequest(request, sjlrFztt);
		sjlrFztt.setXgr(getLoginSessionBean(request).getYhid().toString());
		sjlrFztt.setXgsj(commonService.getCurrentDate());
		sjlrFztt.setZfbz(XtAppConstant.ZFBZ_VALID);
		if (sjlrFztt.getId() == 0) {
			sjlrFztt.setId(null);
		}
		if (sjlrFztt.getId() != null) {
			sjlrFzttDAO.updateByPrimaryKeySelective(sjlrFztt);
		} else {
			sjlrFzttDAO.insertSelective(sjlrFztt);
		}
		String jsonStr = "{\"count\" : \"1\"}";
		response.getWriter().write(jsonStr);
	}
	
	/**
	 * 删除肥猪淘汰
	 * @param request
	 * @throws Exception 
	 */
	public void disableFztt(HttpServletRequest request,
			HttpServletResponse response) throws Exception {
		response.setContentType("text/json; charset=UTF-8");
		response.addHeader("Cache-Control", "no-cache,must-revalidate");
		response.addHeader("Pragma", "no-cache");
		
		String id = request.getParameter("id");
		String jsonStr = "";
		if (StringUtils.hasText(id)) {
			SjlrFztt sjlrFztt = new SjlrFztt();
			sjlrFztt.setId(Integer.parseInt(id));
			sjlrFztt.setZfbz(XtAppConstant.ZFBZ_INVALID);
			sjlrFztt.setXgr(getLoginSessionBean(request).getYhid().toString());
			sjlrFztt.setXgsj(commonService.getCurrentDate());
			sjlrFzttDAO.updateByPrimaryKeySelective(sjlrFztt);
			jsonStr = "{\"count\" : \"1\"}";
		} else {
			jsonStr = "{\"count\" : \"0\"}";
		}
		response.getWriter().write(jsonStr);
	}
	
	/**
	 * 普通免疫
	 * @param request
	 * @param response
	 * @return
	 * @throws Exception
	 */
	public ModelAndView hpSjlrPtmyIndex(HttpServletRequest request,
			HttpServletResponse response) throws Exception {
		ModelAndView mv = new ModelAndView("haifmp/sjlr/scgl/ptmy/hpSjlrPtmyIndex.htm");
		String mcid = request.getParameter("mcid");
		if (StringUtils.hasText(mcid)) {
			Map<String, Object> paramMap = new HashMap<String, Object>();
			paramMap.put("mcid", mcid);
			String ksrq = request.getParameter("ksrq");
			String jsrq = request.getParameter("jsrq");
			String dweb = request.getParameter("dweb");
			if (!StringUtils.hasText(jsrq)) {
				jsrq = DateUtil.parserDateToDefaultString(commonService.getCurrentDate());
			}
			paramMap.put("jsrq", jsrq);
			mv.addObject("jsrq", jsrq);
			if (!StringUtils.hasText(ksrq)) {
				Calendar calendar = new GregorianCalendar();
				calendar.setTime(commonService.getCurrentDate());
				calendar.add(Calendar.DATE, -7);
				ksrq = DateUtil.parserDateToDefaultString(calendar.getTime());
			}
			paramMap.put("ksrq", ksrq);
			mv.addObject("ksrq", ksrq);
			if (StringUtils.hasText(dweb)) {
				paramMap.put("dweb", "%" + dweb + "%");
				mv.addObject("dweb", dweb);
			}
			paramMap.put("mylx", XtAppConstant.SJLR_MYLX_PTMY);
			List<XtGydm> slList = getGydm(XtAppConstant.CODE_SJLR_SL);
			List<XtGydm> ymmcList = getGydm(XtAppConstant.CODE_SJLR_YMMC);
			List<XtGydm> zzlxList = getGydm(XtAppConstant.CODE_SJLR_ZZLX);
			List<SjlrMyjl> ptmyList = sjlrMyjlDAO.selectPtmyListByParam(paramMap);
					
			List<SjlrPtmyDTO> ptmyDTOList = new ArrayList<SjlrPtmyDTO>();
			SjlrPtmyDTO sjlrPtmyDTO = null;
			String date = "";
			int count = 0;
			List<SjlrMyjl> ptmyLists = null;
			if (ptmyList != null && ptmyList.size() > 0) {
				for (int i = 0; i < ptmyList.size(); i++) {
					SjlrMyjl sjlrPtmy = ptmyList.get(i);
					//免疫舍栏
					if (StringUtils.hasText(sjlrPtmy.getMysl())) {
						for (XtGydm xtGydm : slList) {
							if (xtGydm.getDmid().equals(sjlrPtmy.getMysl())) {
								sjlrPtmy.setMyslStr(xtGydm.getDmmc());
							}
						}
					}
					//疫苗名称
					if (StringUtils.hasText(sjlrPtmy.getYmmc())) {
						for (XtGydm xtGydm : ymmcList) {
							if (xtGydm.getDmid().equals(sjlrPtmy.getYmmc())) {
								sjlrPtmy.setYmmcStr(xtGydm.getDmmc());
							}
						}
					}
					//猪只类型
					if (StringUtils.hasText(sjlrPtmy.getZzlx())) {
						for (XtGydm xtGydm : zzlxList) {
							if (xtGydm.getDmid().equals(sjlrPtmy.getZzlx())) {
								sjlrPtmy.setZzlxStr(xtGydm.getDmmc());
							}
						}
					}
					//业务逻辑
					if (i == 0) {
						sjlrPtmyDTO = new SjlrPtmyDTO();
						ptmyLists = new ArrayList<SjlrMyjl>();
						date = DateUtil.parserDateToDefaultString(sjlrPtmy.getMysj());
						sjlrPtmyDTO.setMyrq(date);
						ptmyLists.add(sjlrPtmy);
						count ++;
					} else {
						if (DateUtil.parserDateToDefaultString(sjlrPtmy.getMysj()).equals(date)) {
							count ++;
							ptmyLists.add(sjlrPtmy);
						} else {
							sjlrPtmyDTO.setPtmyList(ptmyLists);
							sjlrPtmyDTO.setCount(count);
							ptmyDTOList.add(sjlrPtmyDTO);
							sjlrPtmyDTO = new SjlrPtmyDTO();
							ptmyLists = new ArrayList<SjlrMyjl>();
							date = DateUtil.parserDateToDefaultString(sjlrPtmy.getMysj());
							sjlrPtmyDTO.setMyrq(date);
							ptmyLists.add(sjlrPtmy);
							count = 1;
						}
					}
				}
				if (count > 0) {
					sjlrPtmyDTO.setPtmyList(ptmyLists);
					sjlrPtmyDTO.setCount(count);
					ptmyDTOList.add(sjlrPtmyDTO);
				}
				mv.addObject("ptmyDTOList", ptmyDTOList);
			}
		}
		return mv;
	}
	/**
	 * 普通免疫新增、修改
	 * @param request
	 * @param response
	 * @return
	 * @throws Exception
	 */
	public ModelAndView hpSjlrPtmyEdit(HttpServletRequest request,
			HttpServletResponse response) throws Exception {
		ModelAndView mv = new ModelAndView("haifmp/sjlr/scgl/ptmy/hpSjlrPtmyEdit.htm");
		String mcid = request.getParameter("mcid");
		String id = request.getParameter("id");
		
		SjlrMyjl sjlrPtmy = new SjlrMyjl();
		if (StringUtils.hasText(mcid)) {
			if (StringUtils.hasText(id)) {
				sjlrPtmy = sjlrMyjlDAO.selectByPrimaryKey(Integer.parseInt(id));
			}
			if (sjlrPtmy.getMysj() == null) {
				sjlrPtmy.setMysj(commonService.getCurrentDate());
			}
			sjlrPtmy.setMcid(Integer.parseInt(mcid));
		}
		List<XtGydm> zzlxList = getGydm(XtAppConstant.CODE_SJLR_ZZLX);
		List<XtGydm> slList = getGydm(XtAppConstant.CODE_SJLR_SL);
		List<XtGydm> ymmcList = getGydm(XtAppConstant.CODE_SJLR_YMMC);
		mv.addObject("ymmcList", ymmcList);
		mv.addObject("zzlxList", zzlxList);
		mv.addObject("slList", slList);
		mv.addObject("sjlrPtmy", sjlrPtmy);
		return mv;
	}
	
	/**
	 * 保存普通免疫
	 * @param request
	 * @throws Exception 
	 */
	public void saveSjlrPtmy(HttpServletRequest request,
			HttpServletResponse response) throws Exception {
		response.setContentType("text/json; charset=UTF-8");
		response.addHeader("Cache-Control", "no-cache,must-revalidate");
		response.addHeader("Pragma", "no-cache");
		
		SjlrMyjl sjlrPtmy = new SjlrMyjl();
		sjlrPtmy = (SjlrMyjl) parseObjectFromRequest(request, sjlrPtmy);
		sjlrPtmy.setXgr(getLoginSessionBean(request).getYhid().toString());
		sjlrPtmy.setXgsj(commonService.getCurrentDate());
		sjlrPtmy.setZfbz(XtAppConstant.ZFBZ_VALID);
		sjlrPtmy.setLx(XtAppConstant.SJLR_MYLX_PTMY);
		//
		if (!StringUtils.hasText(String.valueOf(sjlrPtmy.getYmts()))) {
			sjlrPtmy.setYmts(0);
		}
		if (!StringUtils.hasText(String.valueOf(sjlrPtmy.getSjyl()))) {
			sjlrPtmy.setSjyl("0");
		}
		if (sjlrPtmy.getId() == 0) {
			sjlrPtmy.setId(null);
		}
		if (sjlrPtmy.getId() != null) {
			sjlrMyjlDAO.updateByPrimaryKeySelective(sjlrPtmy);
		} else {
			sjlrMyjlDAO.insertSelective(sjlrPtmy);
		}
		String jsonStr = "{\"count\" : \"1\"}";
		response.getWriter().write(jsonStr);
	}
	
	/**
	 * 删除普通免疫
	 * @param request
	 * @throws Exception 
	 */
	public void disablePtmy(HttpServletRequest request,
			HttpServletResponse response) throws Exception {
		response.setContentType("text/json; charset=UTF-8");
		response.addHeader("Cache-Control", "no-cache,must-revalidate");
		response.addHeader("Pragma", "no-cache");
		
		String id = request.getParameter("id");
		String jsonStr = "";
		if (StringUtils.hasText(id)) {
			SjlrMyjl sjlrPtmy = new SjlrMyjl();
			sjlrPtmy.setId(Integer.parseInt(id));
			sjlrPtmy.setZfbz(XtAppConstant.ZFBZ_INVALID);
			sjlrPtmy.setXgr(getLoginSessionBean(request).getYhid().toString());
			sjlrPtmy.setXgsj(commonService.getCurrentDate());
			sjlrMyjlDAO.updateByPrimaryKeySelective(sjlrPtmy);
			jsonStr = "{\"count\" : \"1\"}";
		} else {
			jsonStr = "{\"count\" : \"0\"}";
		}
		response.getWriter().write(jsonStr);
	}
	/**
	 * 种猪免疫
	 * @param request
	 * @param response
	 * @return
	 * @throws Exception
	 */
	public ModelAndView hpSjlrZzmyIndex(HttpServletRequest request,
			HttpServletResponse response) throws Exception {
		ModelAndView mv = new ModelAndView("haifmp/sjlr/scgl/zzmy/hpSjlrZzmyIndex.htm");
		String mcid = request.getParameter("mcid");
		if (StringUtils.hasText(mcid)) {
			Map<String, Object> paramMap = new HashMap<String, Object>();
			Map<String, Object> paramMap2 = new HashMap<String, Object>();
			paramMap.put("mcid", mcid);
			String ksrq = request.getParameter("ksrq");
			String jsrq = request.getParameter("jsrq");
			String dweb = request.getParameter("dweb");
			String cxeph = request.getParameter("cxeph");
			if (!StringUtils.hasText(jsrq)) {
				jsrq = DateUtil.parserDateToDefaultString(commonService.getCurrentDate());
				
			}
			paramMap.put("jsrq", jsrq);
			mv.addObject("jsrq", jsrq);
			if (!StringUtils.hasText(ksrq)) {
				Calendar calendar = new GregorianCalendar();
				calendar.setTime(commonService.getCurrentDate());
				calendar.add(Calendar.DATE, -7);
				ksrq = DateUtil.parserDateToDefaultString(calendar.getTime());
			}
			paramMap.put("ksrq", ksrq);
			mv.addObject("ksrq", ksrq);
			if (StringUtils.hasText(dweb)) {
				paramMap2.put("dweb", dweb);
				List<SjlrMzda> daList = sjlrMzdaDAO.getDaListByZzds(paramMap2);
				paramMap.put("dweb","%" + daList.get(0).getEph() + "%");
			}else if (StringUtils.hasText(cxeph)) {
				paramMap.put("dweb", "%" + cxeph + "%");
				mv.addObject("dweb", cxeph);
			}
			paramMap.put("mylx", XtAppConstant.SJLR_MYLX_ZZMY);
			List<XtGydm> slList = getGydm(XtAppConstant.CODE_SJLR_SL);
			List<XtGydm> ymmcList = getGydm(XtAppConstant.CODE_SJLR_YMMC);
			List<XtGydm> zzlxList = getGydm(XtAppConstant.CODE_SJLR_ZZLX);
			List<SjlrMyjl> zzmyList = sjlrMyjlDAO.selectZzmyListByParam(paramMap);
					
			List<SjlrZzmyDTO> zzmyDTOList = new ArrayList<SjlrZzmyDTO>();
			SjlrZzmyDTO sjlrZzmyDTO = null;
			String date = "";
			int count = 0;
			List<SjlrMyjl> zzmyLists = null;
			if (zzmyList != null && zzmyList.size() > 0) {
				for (int i = 0; i < zzmyList.size(); i++) {
					SjlrMyjl sjlrZzmy = zzmyList.get(i);
					//免疫舍栏
					if (StringUtils.hasText(sjlrZzmy.getMysl())) {
						for (XtGydm xtGydm : slList) {
							if (xtGydm.getDmid().equals(sjlrZzmy.getMysl())) {
								sjlrZzmy.setMyslStr(xtGydm.getDmmc());
							}
						}
					}
					//疫苗名称
					if (StringUtils.hasText(sjlrZzmy.getYmmc())) {
						for (XtGydm xtGydm : ymmcList) {
							if (xtGydm.getDmid().equals(sjlrZzmy.getYmmc())) {
								sjlrZzmy.setYmmcStr(xtGydm.getDmmc());
							}
						}
					}
					//猪只类型
					if (StringUtils.hasText(sjlrZzmy.getZzlx())) {
						for (XtGydm xtGydm : zzlxList) {
							if (xtGydm.getDmid().equals(sjlrZzmy.getZzlx())) {
								sjlrZzmy.setZzlxStr(xtGydm.getDmmc());
							}
						}
					}
					//业务逻辑
					if (i == 0) {
						sjlrZzmyDTO = new SjlrZzmyDTO();
						zzmyLists = new ArrayList<SjlrMyjl>();
						date = DateUtil.parserDateToDefaultString(sjlrZzmy.getMysj());
						sjlrZzmyDTO.setMyrq(date);
						zzmyLists.add(sjlrZzmy);
						count ++;
					} else {
						if (DateUtil.parserDateToDefaultString(sjlrZzmy.getMysj()).equals(date)) {
							count ++;
							zzmyLists.add(sjlrZzmy);
						} else {
							sjlrZzmyDTO.setZzmyList(zzmyLists);
							sjlrZzmyDTO.setCount(count);
							zzmyDTOList.add(sjlrZzmyDTO);
							sjlrZzmyDTO = new SjlrZzmyDTO();
							zzmyLists = new ArrayList<SjlrMyjl>();
							date = DateUtil.parserDateToDefaultString(sjlrZzmy.getMysj());
							sjlrZzmyDTO.setMyrq(date);
							zzmyLists.add(sjlrZzmy);
							count = 1;
						}
					}
				}
				if (count > 0) {
					sjlrZzmyDTO.setZzmyList(zzmyLists);
					sjlrZzmyDTO.setCount(count);
					zzmyDTOList.add(sjlrZzmyDTO);
				}
				mv.addObject("zzmyDTOList", zzmyDTOList);
			}
			}
		return mv;
	}
	/**
	 * 种猪免疫新增、修改
	 * @param request
	 * @param response
	 * @return
	 * @throws Exception
	 */
	public ModelAndView hpSjlrZzmyEdit(HttpServletRequest request,
			HttpServletResponse response) throws Exception {
		ModelAndView mv = new ModelAndView("haifmp/sjlr/scgl/zzmy/hpSjlrZzmyEdit.htm");
		String mcid = request.getParameter("mcid");
		String id = request.getParameter("id");
		String dweb = request.getParameter("dweb");
		String date = request.getParameter("date");
		SjlrMyjl sjlrZzmy = new SjlrMyjl();
		if ("undefined".equals(dweb)) {
			dweb = "";
		}
		if (StringUtils.hasText(mcid)) {
			if (StringUtils.hasText(dweb)) {
				sjlrZzmy.setDweb(dweb);
			} else {
				if (StringUtils.hasText(id)) {
					sjlrZzmy = sjlrMyjlDAO.selectByPrimaryKey(Integer.parseInt(id));
					dweb = sjlrZzmy.getDweb();
				}
			}
			if (date != null) {
				SimpleDateFormat sdf=new SimpleDateFormat(XtAppConstant.TIME_FORMAT);
				java.util.Date newdate=sdf.parse(date.toString());
				sjlrZzmy.setMysj(newdate);
			}else {
				sjlrZzmy.setMysj(commonService.getCurrentDate());
			}
			if (StringUtils.hasText(id)) {
				sjlrZzmy.setId(Integer.parseInt(id));
			}
			sjlrZzmy.setMcid(Integer.parseInt(mcid));
		}
		List<XtGydm> ymmcList = getGydm(XtAppConstant.CODE_SJLR_YMMC);
		List<XtGydm> slList = getGydm(XtAppConstant.CODE_SJLR_SL);
		List<XtGydm> zzlxList = getGydm(XtAppConstant.CODE_SJLR_ZZLX);
		mv.addObject("ymmcList", ymmcList);
		mv.addObject("myslList", slList);
		mv.addObject("sjlrZzmy", sjlrZzmy);
		mv.addObject("zzlxList", zzlxList);
		mv.addObject("dweb",dweb);
		return mv;
	}
	
	/**
	 * 保存种猪免疫
	 * @param request
	 * @throws Exception 
	 */
	public void saveSjlrZzmy(HttpServletRequest request,
			HttpServletResponse response) throws Exception {
		response.setContentType("text/json; charset=UTF-8");
		response.addHeader("Cache-Control", "no-cache,must-revalidate");
		response.addHeader("Pragma", "no-cache");
		String dweb = request.getParameter("dweb");
		SjlrMyjl sjlrZzmy = new SjlrMyjl();
		sjlrZzmy = (SjlrMyjl) parseObjectFromRequest(request, sjlrZzmy);
		if (dweb == "") {
			dweb = sjlrMyjlDAO.selectByPrimaryKey(sjlrZzmy.getId()).getDweb();
			sjlrZzmy.setDweb(dweb);
		}
		sjlrZzmy.setXgr(getLoginSessionBean(request).getYhid().toString());
		sjlrZzmy.setXgsj(commonService.getCurrentDate());
		sjlrZzmy.setZfbz(XtAppConstant.ZFBZ_VALID);
		sjlrZzmy.setLx(XtAppConstant.SJLR_MYLX_ZZMY);
		
		if (!StringUtils.hasText(String.valueOf(sjlrZzmy.getSjyl()))) {
			sjlrZzmy.setSjyl("0");
		}
		if (sjlrZzmy.getId() == 0) {
			sjlrZzmy.setId(null);
		}
		if (sjlrZzmy.getId() != null) {
			sjlrMyjlDAO.updateByPrimaryKeySelective(sjlrZzmy);
		} else {
			sjlrMyjlDAO.insertSelective(sjlrZzmy);
		}
		String zrsl = sjlrZzmy.getMysl();
		if (StringUtils.hasText(zrsl)) {
			SjlrGzdaExample gzdaEx = new SjlrGzdaExample();
			SjlrGzdaExample.Criteria gzdaCr = gzdaEx.createCriteria(); 
			gzdaCr.andDwebEqualTo(sjlrZzmy.getDweb()).andZfbzEqualTo(XtAppConstant.ZFBZ_VALID);
			String mcid = request.getParameter("mcid");
			if (StringUtils.hasText(mcid)) {
				gzdaCr.andMcidEqualTo(Integer.parseInt(mcid));
			}
			SjlrGzda sjlrGzda = new SjlrGzda();
			sjlrGzda.setSl(zrsl);
			sjlrGzda.setXgr(getLoginSessionBean(request).getYhid().toString());
			sjlrGzda.setXgsj(commonService.getCurrentDate());
			sjlrGzdaDAO.updateByExampleSelective(sjlrGzda, gzdaEx);
			
			SjlrMzdaExample mzdaEx = new SjlrMzdaExample();
			SjlrMzdaExample.Criteria mzdaCr = mzdaEx.createCriteria(); 
			mzdaCr.andDwebEqualTo(sjlrZzmy.getDweb()).andZfbzEqualTo(XtAppConstant.ZFBZ_VALID);
			if (StringUtils.hasText(mcid)) {
				mzdaCr.andMcidEqualTo(Integer.parseInt(mcid));
			}
			SjlrMzda sjlrMzda = new SjlrMzda();
			sjlrMzda.setSl(zrsl);
			sjlrMzda.setXgr(getLoginSessionBean(request).getYhid().toString());
			sjlrMzda.setXgsj(commonService.getCurrentDate());
			sjlrMzdaDAO.updateByExampleSelective(sjlrMzda, mzdaEx);
		}
		String jsonStr = "{\"count\" : \"1\"}";
		response.getWriter().write(jsonStr);
	}
	
	/**
	 * 删除种猪免疫
	 * @param request
	 * @throws Exception 
	 */
	public void disableZzmy(HttpServletRequest request,
			HttpServletResponse response) throws Exception {
		response.setContentType("text/json; charset=UTF-8");
		response.addHeader("Cache-Control", "no-cache,must-revalidate");
		response.addHeader("Pragma", "no-cache");
		String id = request.getParameter("id");
		String jsonStr = "";
		if (StringUtils.hasText(id)) {
			SjlrMyjl sjlrZzmy = new SjlrMyjl();
			sjlrZzmy.setId(Integer.parseInt(id));
			sjlrZzmy.setZfbz(XtAppConstant.ZFBZ_INVALID);
			sjlrZzmy.setXgr(getLoginSessionBean(request).getYhid().toString());
			sjlrZzmy.setXgsj(commonService.getCurrentDate());
			sjlrMyjlDAO.updateByPrimaryKeySelective(sjlrZzmy);
			jsonStr = "{\"count\" : \"1\"}";
		} else {
			jsonStr = "{\"count\" : \"0\"}";
		}
		response.getWriter().write(jsonStr);
	}
	
	/**
	 * 加载舍栏喂料
	 * @param request
	 * @param response
	 * @return
	 * @throws Exception
	 */
	public ModelAndView hpSjlrSlwlIndex(HttpServletRequest request,
			HttpServletResponse response) throws Exception {
		ModelAndView mv = new ModelAndView("haifmp/sjlr/scgl/slwl/hpSjlrSlwlIndex.htm");
		String mcid = request.getParameter("mcid");
		List<XtGydm> slList = getGydm(XtAppConstant.CODE_SJLR_SL);
		List<XtGydm> pzList = getGydm(XtAppConstant.CODE_SJLR_ZZPZ);
		List<XtGydm> slpzList = getGydm(XtAppConstant.CODE_SJLR_SLPZ);
		if (StringUtils.hasText(mcid)) {
			SjlrSlwlExample slwlEx = new SjlrSlwlExample();
			slwlEx.setOrderByClause("wysj desc");
			SjlrSlwlExample.Criteria slwlCr = slwlEx.createCriteria();
			slwlCr.andMcidEqualTo(Integer.parseInt(mcid)).andZfbzEqualTo(XtAppConstant.ZFBZ_VALID);
			String ksrq = request.getParameter("ksrq");
			String jsrq = request.getParameter("jsrq");
			if (!StringUtils.hasText(jsrq)) {
				jsrq = DateUtil.parserDateToDefaultString(commonService.getCurrentDate());
			}
			mv.addObject("jsrq", jsrq);
			slwlCr.andWysjLessThanOrEqualTo(DateUtil.parser(jsrq + XtAppConstant.TIME_FORMAT3));
			if (!StringUtils.hasText(ksrq)) {
				Calendar calendar = new GregorianCalendar();
				calendar.setTime(commonService.getCurrentDate());
				calendar.add(Calendar.DATE, -7);
				ksrq = DateUtil.parserDateToDefaultString(calendar.getTime());
			}
			mv.addObject("ksrq", ksrq);
			slwlCr.andWysjGreaterThanOrEqualTo(DateUtil.parser(ksrq + XtAppConstant.TIME_FORMAT2));
			List<SjlrSlwl> slwlList = sjlrSlwlDAO.selectByExample(slwlEx);//按照日期倒叙查找列入slwlList
			List<hpSjlrSlwlDTO> slwlDTOList = new ArrayList<hpSjlrSlwlDTO>();
			hpSjlrSlwlDTO sjlrSlwlDTO = null;  //实例化一个对象
			SjlrSlwl sjlrSlwl=null;
			String date = "";
			List<SjlrSlwl> wlList = null;
			int count = 0;
			if (slwlList != null && slwlList.size() > 0) {
				for(int i = 0 ; i < slwlList.size() ; i++) {
					sjlrSlwl = slwlList.get(i);
					//舍栏
					if (StringUtils.hasText(sjlrSlwl.getWlsl())) {
						for (XtGydm xtGydm : slList) {
							if (sjlrSlwl.getWlsl().equals(xtGydm.getDmid())) { 
								sjlrSlwl.setSlStr(xtGydm.getDmmc());;
							}
						}
					}
						//品种
					if (StringUtils.hasText(sjlrSlwl.getPz())) {
						for (XtGydm xtGydm : pzList) {
							if(sjlrSlwl.getPz().equals(xtGydm.getDmid())) {
								sjlrSlwl.setPzStr(xtGydm.getDmmc());
							}
						}
					}
						//饲料品种
					if (StringUtils.hasText(sjlrSlwl.getSlpz())) {
						for (XtGydm xtGydm : slpzList) {
							if(sjlrSlwl.getSlpz().equals(xtGydm.getDmid())) {
								sjlrSlwl.setSlpzStr(xtGydm.getDmmc());
							}
						}
					}
						//喂养头数
					if (!StringUtils.hasText(sjlrSlwl.getWygs().toString())) {
						sjlrSlwl.setWygs(0);
					}
						//喂养量
					if (!StringUtils.hasText(sjlrSlwl.getZwyl().toString())) {
						sjlrSlwl.setZwyl(0);
					}
						//业务逻辑
					if (i == 0) {//第一条记录
						sjlrSlwlDTO = new hpSjlrSlwlDTO();
						wlList = new ArrayList<SjlrSlwl>();
						date = DateUtil.parserDateToDefaultString(sjlrSlwl.getWysj());
						sjlrSlwlDTO.setWlrq(date);
						wlList.add(sjlrSlwl);
						count = count + sjlrSlwl.getWygs();
					} else {
						if (DateUtil.parserDateToDefaultString(sjlrSlwl.getWysj()).equals(date)) {//如果第二条记录i=1的喂料日期等于前一条的日期
							count = count + sjlrSlwl.getWygs();//喂养个数+1，WlList 加一个实例
							wlList.add(sjlrSlwl);
						} else {
							sjlrSlwlDTO.setSlwlList(wlList);//记录进DTO	
							sjlrSlwlDTO.setCount(count);
							slwlDTOList.add(sjlrSlwlDTO);//如果不等于前一条的时间  WlList填满 重新new
							sjlrSlwlDTO = new hpSjlrSlwlDTO();
							wlList = new ArrayList<SjlrSlwl>();
							count=0;
							date = DateUtil.parserDateToDefaultString(sjlrSlwl.getWysj());//date 为最新日期
							sjlrSlwlDTO.setWlrq(date);
							wlList.add(sjlrSlwl);
							count = count + sjlrSlwl.getWygs();
						}
					}
				}
				if (count > 0) {//最后一条记录
					sjlrSlwlDTO.setSlwlList(wlList);
					sjlrSlwlDTO.setCount(count);
					slwlDTOList.add(sjlrSlwlDTO);
				}
			mv.addObject("slwlDTOList", slwlDTOList);
			}
		}
		return mv;
	}
	/**
	 * 加载舍栏喂料新增/修改页面
	 * @param request
	 * @param response
	 * @return
	 * @throws Exception
	 */
	public ModelAndView hpSjlrSlwlAdd( HttpServletRequest request,
			HttpServletResponse response ) throws Exception {
		 	ModelAndView mv=new ModelAndView("haifmp/sjlr/scgl/slwl/hpSjlrSlwlAdd.htm");
		 	String mcid = request.getParameter("mcid");
			String id = request.getParameter("id");
			SjlrSlwl sjlrSlwl = new SjlrSlwl();
			if (StringUtils.hasText(mcid)) {
				if (StringUtils.hasText(id)) {
					sjlrSlwl = sjlrSlwlDAO.selectByPrimaryKey(Integer.parseInt(id));//如果是新增，sjlrSlwl.id 是空的，如果不是新增的就按照ID查询
				}
				if (sjlrSlwl.getWysj() == null) {
					sjlrSlwl.setWysj(commonService.getCurrentDate());
				}
				sjlrSlwl.setMcid(Integer.parseInt(mcid));
			}					
			
			List<XtGydm> slList = getGydm(XtAppConstant.CODE_SJLR_SL);
			List<XtGydm> pzList = getGydm(XtAppConstant.CODE_SJLR_ZZPZ);
			List<XtGydm> slpzList = getGydm(XtAppConstant.CODE_SJLR_SLPZ);
	
			mv.addObject("slList" , slList);
			mv.addObject("sjlrSlwl" , sjlrSlwl);
			mv.addObject("pzList" , pzList);
			mv.addObject("slpzList" , slpzList);
		 	return mv;
	}
	/**
	 * 喂料舍栏保存
	 * @param request
	 * @throws Exception 
	 */
	public void saveSjlrSlwl(HttpServletRequest request,
			HttpServletResponse response) throws Exception {
		response.setContentType("text/json; charset=UTF-8");
		response.addHeader("Cache-Control", "no-cache,must-revalidate");
		response.addHeader("Pragma", "no-cache");
		
		SjlrSlwl sjlrSlwl = new SjlrSlwl();
		sjlrSlwl = (SjlrSlwl) parseObjectFromRequest(request, sjlrSlwl);    //从Request中获取请求对象
		sjlrSlwl.setXgr(getLoginSessionBean(request).getYhid().toString()); //修改人
		sjlrSlwl.setXgsj(commonService.getCurrentDate());					//修改时间	
		sjlrSlwl.setZfbz(XtAppConstant.ZFBZ_VALID);							//作废标志
		if (!StringUtils.hasText(sjlrSlwl.getWygs().toString())) {
			sjlrSlwl.setWygs(0);   //喂养个数
		}
		if (!StringUtils.hasText(sjlrSlwl.getZwyl().toString())) {
			sjlrSlwl.setZwyl(0);//总喂养量
		}
		if (sjlrSlwl.getId() == 0) {
			sjlrSlwl.setId(null);
		}
		if (sjlrSlwl.getId() != null) {
			sjlrSlwlDAO.updateByPrimaryKeySelective(sjlrSlwl);
		} else {
			sjlrSlwlDAO.insertSelective(sjlrSlwl);
		}
	
		String jsonStr = "{\"count\" : \"1\"}";
		response.getWriter().write(jsonStr);
	}
	
	/**
	 * 删除舍栏喂料
	 * @param request
	 * @throws Exception 
	 */
	public void disableSlwl(HttpServletRequest request,
			HttpServletResponse response) throws Exception {
		response.setContentType("text/json; charset=UTF-8");
		response.addHeader("Cache-Control", "no-cache,must-revalidate");
		response.addHeader("Pragma", "no-cache");
		
		String id = request.getParameter("id");
		String jsonStr = "";
		if (StringUtils.hasText(id)) {
			SjlrSlwl sjlrSlwl = new SjlrSlwl();
			sjlrSlwl.setId(Integer.parseInt(id));
			sjlrSlwl.setZfbz(XtAppConstant.ZFBZ_INVALID);
			sjlrSlwl.setXgr(getLoginSessionBean(request).getYhid().toString());
			sjlrSlwl.setXgsj(commonService.getCurrentDate());
			sjlrSlwlDAO.updateByPrimaryKeySelective(sjlrSlwl);
			jsonStr = "{\"count\" : \"1\"}";
		} else {
			jsonStr = "{\"count\" : \"0\"}";
		}
		response.getWriter().write(jsonStr);
	}
	
	/**
	 * 肥猪免疫
	 * @param request
	 * @param response
	 * @return
	 * @throws Exception
	 */
	public ModelAndView hpSjlrFzmyIndex(HttpServletRequest request,
			HttpServletResponse response) throws Exception {
		ModelAndView mv = new ModelAndView("haifmp/sjlr/scgl/fzmy/hpSjlrFzmyIndex.htm");
		String mcid = request.getParameter("mcid");
		if (StringUtils.hasText(mcid)) {
			Map<String, Object> paramMap = new HashMap<String, Object>();
			paramMap.put("mcid", mcid);
			String ksrq = request.getParameter("ksrq");
			String jsrq = request.getParameter("jsrq");
			String dweb = request.getParameter("dweb");
			if (!StringUtils.hasText(jsrq)) {
				jsrq = DateUtil.parserDateToDefaultString(commonService.getCurrentDate());
			}
			paramMap.put("jsrq", jsrq);
			mv.addObject("jsrq", jsrq);
			if (!StringUtils.hasText(ksrq)) {
				Calendar calendar = new GregorianCalendar();
				calendar.setTime(commonService.getCurrentDate());
				calendar.add(Calendar.DATE, -7);
				ksrq = DateUtil.parserDateToDefaultString(calendar.getTime());
			}
			paramMap.put("ksrq", ksrq);
			mv.addObject("ksrq", ksrq);
			if (StringUtils.hasText(dweb)) {
				paramMap.put("dweb", "%" + dweb + "%");
				mv.addObject("dweb", dweb);
			}
			paramMap.put("mylx", XtAppConstant.SJLR_MYLX_FZMY);
			List<XtGydm> slList = getGydm(XtAppConstant.CODE_SJLR_SL);
			List<XtGydm> ymmcList = getGydm(XtAppConstant.CODE_SJLR_YMMC);
			List<XtGydm> zzlxList = getGydm(XtAppConstant.CODE_SJLR_ZZLX);
			List<SjlrMyjl> fzmyList = sjlrMyjlDAO.selectFzmyListByParam(paramMap);
					
			List<SjlrFzmyDTO> fzmyDTOList = new ArrayList<SjlrFzmyDTO>();
			SjlrFzmyDTO sjlrFzmyDTO = null;
			String date = "";
			int count = 0;
			List<SjlrMyjl> fzmyLists = null;
			if (fzmyList != null && fzmyList.size() > 0) {
				for (int i = 0; i < fzmyList.size(); i++) {
					SjlrMyjl sjlrFzmy = fzmyList.get(i);
					//免疫舍栏
					if (StringUtils.hasText(sjlrFzmy.getMysl())) {
						for (XtGydm xtGydm : slList) {
							if (xtGydm.getDmid().equals(sjlrFzmy.getMysl())) {
								sjlrFzmy.setMyslStr(xtGydm.getDmmc());
							}
						}
					}
					//疫苗名称
					if (StringUtils.hasText(sjlrFzmy.getYmmc())) {
						for (XtGydm xtGydm : ymmcList) {
							if (xtGydm.getDmid().equals(sjlrFzmy.getYmmc())) {
								sjlrFzmy.setYmmcStr(xtGydm.getDmmc());
							}
						}
					}
					//猪只类型
					if (StringUtils.hasText(sjlrFzmy.getZzlx())) {
						for (XtGydm xtGydm : zzlxList) {
							if (xtGydm.getDmid().equals(sjlrFzmy.getZzlx())) {
								sjlrFzmy.setZzlxStr(xtGydm.getDmmc());
							}
						}
					}
					//业务逻辑
					if (i == 0) {
						sjlrFzmyDTO = new SjlrFzmyDTO();
						fzmyLists = new ArrayList<SjlrMyjl>();
						date = DateUtil.parserDateToDefaultString(sjlrFzmy.getMysj());
						sjlrFzmyDTO.setMyrq(date);
						fzmyLists.add(sjlrFzmy);
						count ++;
					} else {
						if (DateUtil.parserDateToDefaultString(sjlrFzmy.getMysj()).equals(date)) {
							count ++;
							fzmyLists.add(sjlrFzmy);
						} else {
							sjlrFzmyDTO.setFzmyList(fzmyLists);
							sjlrFzmyDTO.setCount(count);
							fzmyDTOList.add(sjlrFzmyDTO);
							sjlrFzmyDTO = new SjlrFzmyDTO();
							fzmyLists = new ArrayList<SjlrMyjl>();
							date = DateUtil.parserDateToDefaultString(sjlrFzmy.getMysj());
							sjlrFzmyDTO.setMyrq(date);
							fzmyLists.add(sjlrFzmy);
							count = 1;
						}
					}
				}
				if (count > 0) {
					sjlrFzmyDTO.setFzmyList(fzmyLists);
					sjlrFzmyDTO.setCount(count);
					fzmyDTOList.add(sjlrFzmyDTO);
				}
				mv.addObject("fzmyDTOList", fzmyDTOList);
			}
			}
		return mv;
	}
	/**
	 * 肥猪免疫新增、修改
	 * @param request
	 * @param response
	 * @return
	 * @throws Exception
	 */
	public ModelAndView hpSjlrFzmyEdit(HttpServletRequest request,
			HttpServletResponse response) throws Exception {
		ModelAndView mv = new ModelAndView("haifmp/sjlr/scgl/fzmy/hpSjlrFzmyEdit.htm");
		String mcid = request.getParameter("mcid");
		String id = request.getParameter("id");
		SjlrMyjl sjlrFzmy = new SjlrMyjl();
		if (StringUtils.hasText(mcid)) {
			if (StringUtils.hasText(id)) {
				sjlrFzmy = sjlrMyjlDAO.selectByPrimaryKey(Integer.parseInt(id));
			}
			if (sjlrFzmy.getMysj() == null) {
				sjlrFzmy.setMysj(commonService.getCurrentDate());
			}
			sjlrFzmy.setMcid(Integer.parseInt(mcid));
		}
		List<XtGydm> zzlxList = getGydm(XtAppConstant.CODE_SJLR_ZZLX);
		List<XtGydm> slList = getGydm(XtAppConstant.CODE_SJLR_SL);
		List<XtGydm> ymmcList = getGydm(XtAppConstant.CODE_SJLR_YMMC);
		mv.addObject("ymmcList", ymmcList);
		mv.addObject("zzlxList", zzlxList);
		mv.addObject("slList", slList);
		mv.addObject("sjlrFzmy", sjlrFzmy);
		return mv;
	}
	
	/**
	 * 保存肥猪免疫
	 * @param request
	 * @throws Exception 
	 */
	public void saveSjlrFzmy(HttpServletRequest request,
			HttpServletResponse response) throws Exception {
		response.setContentType("text/json; charset=UTF-8");
		response.addHeader("Cache-Control", "no-cache,must-revalidate");
		response.addHeader("Pragma", "no-cache");
		
		SjlrMyjl sjlrFzmy = new SjlrMyjl();
		sjlrFzmy = (SjlrMyjl) parseObjectFromRequest(request, sjlrFzmy);
		sjlrFzmy.setXgr(getLoginSessionBean(request).getYhid().toString());
		sjlrFzmy.setXgsj(commonService.getCurrentDate());
		sjlrFzmy.setZfbz(XtAppConstant.ZFBZ_VALID);
		sjlrFzmy.setLx(XtAppConstant.SJLR_MYLX_FZMY);
		if (StringUtils.hasText(String.valueOf(sjlrFzmy.getYmts()))) {
			sjlrFzmy.setYmts(0);
		}
		if (StringUtils.hasText(String.valueOf(sjlrFzmy.getSjyl()))) {
			sjlrFzmy.setSjyl("0");
		}
		if (sjlrFzmy.getId() == 0) {
			sjlrFzmy.setId(null);
		}
		if (sjlrFzmy.getId() != null) {
			sjlrMyjlDAO.updateByPrimaryKeySelective(sjlrFzmy);
		} else {
			sjlrMyjlDAO.insertSelective(sjlrFzmy);
		}
		String jsonStr = "{\"count\" : \"1\"}";
		response.getWriter().write(jsonStr);
	}
	
	/**
	 * 删除肥猪免疫
	 * @param request
	 * @throws Exception 
	 */
	public void disableFzmy(HttpServletRequest request,
			HttpServletResponse response) throws Exception {
		response.setContentType("text/json; charset=UTF-8");
		response.addHeader("Cache-Control", "no-cache,must-revalidate");
		response.addHeader("Pragma", "no-cache");
		String id = request.getParameter("id");
		String jsonStr = "";
		if (StringUtils.hasText(id)) {
			SjlrMyjl sjlrFzmy = new SjlrMyjl();
			sjlrFzmy.setId(Integer.parseInt(id));
			sjlrFzmy.setZfbz(XtAppConstant.ZFBZ_INVALID);
			sjlrFzmy.setXgr(getLoginSessionBean(request).getYhid().toString());
			sjlrFzmy.setXgsj(commonService.getCurrentDate());
			sjlrMyjlDAO.updateByPrimaryKeySelective(sjlrFzmy);
			jsonStr = "{\"count\" : \"1\"}";
		} else {
			jsonStr = "{\"count\" : \"0\"}";
		}
		response.getWriter().write(jsonStr);
	}
	
	
	/**
	 * 肥猪销售Index
	 * @param request
	 * @param response
	 * @return
	 * @throws Exception
	 */
	public ModelAndView hpSjlrFzxsIndex(HttpServletRequest request,
			HttpServletResponse response) throws Exception {
		ModelAndView mv = new ModelAndView("haifmp/sjlr/scgl/fzxs/hpSjlrFzxsIndex.htm");
		String mcid = request.getParameter("mcid");
		if (StringUtils.hasText(mcid)) {
			Map<String, Object> paramMap = new HashMap<String, Object>();
			paramMap.put("mcid", mcid);
			String ksrq = request.getParameter("ksrq");
			String jsrq = request.getParameter("jsrq");
			String djh = request.getParameter("djh");
			if (!StringUtils.hasText(jsrq)) {
				jsrq = DateUtil.parserDateToDefaultString(commonService.getCurrentDate());
				
			}
			paramMap.put("jsrq", jsrq);
			mv.addObject("jsrq", jsrq);
			if (!StringUtils.hasText(ksrq)) {
				Calendar calendar = new GregorianCalendar();
				calendar.setTime(commonService.getCurrentDate());
				calendar.add(Calendar.DATE, -7);
				ksrq = DateUtil.parserDateToDefaultString(calendar.getTime());
			}
			paramMap.put("ksrq", ksrq);
			mv.addObject("ksrq", ksrq);
			if (StringUtils.hasText(djh)) {
				paramMap.put("djh", "%" + djh + "%");
				mv.addObject("djh", djh);
			}
			
			List<SjlrFzxs> fzxsList = sjlrFzxsDAO.selectFzxsListByParam(paramMap);
			List<SjlrFzxsDTO> fzxsDTOList = new ArrayList<SjlrFzxsDTO>();
			SjlrFzxsDTO sjlrFzxsDTO = null;
			String date = "";
			int count = 0;
			List<SjlrFzxs> fzxsLists = null;
			if (fzxsList != null && fzxsList.size() > 0) {
				for (int i = 0; i < fzxsList.size(); i++) {
					SjlrFzxs sjlrFzxs = fzxsList.get(i);
					String [] kemcList = XtAppConstant.SJRL_XS_KEMC;
					
					//客户名称
					if (StringUtils.hasText(sjlrFzxs.getKhmc())) {
						for (int j = 0; j < kemcList.length; j++) {
							if (sjlrFzxs.getKhmc().equals(String.valueOf(j))) {
								sjlrFzxs.setKhmc(kemcList [j]);
							}
						}
					}
					
					//业务逻辑
					if (i == 0) {
						sjlrFzxsDTO = new SjlrFzxsDTO();
						fzxsLists = new ArrayList<SjlrFzxs>();
						date = DateUtil.parserDateToDefaultString(sjlrFzxs.getXssj());
						sjlrFzxsDTO.setXsrq(date);
						fzxsLists.add(sjlrFzxs);
						count ++;
					} else {
						if (DateUtil.parserDateToDefaultString(sjlrFzxs.getXssj()).equals(date)) {
							count ++;
							fzxsLists.add(sjlrFzxs);
						} else {
							sjlrFzxsDTO.setFzxsList(fzxsLists);
							sjlrFzxsDTO.setCount(count);
							fzxsDTOList.add(sjlrFzxsDTO);
							sjlrFzxsDTO = new SjlrFzxsDTO();
							fzxsLists = new ArrayList<SjlrFzxs>();
							date = DateUtil.parserDateToDefaultString(sjlrFzxs.getXssj());
							sjlrFzxsDTO.setXsrq(date);
							fzxsLists.add(sjlrFzxs);
							count = 1;
						}
					}
				}
				if (count > 0) {
					sjlrFzxsDTO.setFzxsList(fzxsLists);
					sjlrFzxsDTO.setCount(count);
					fzxsDTOList.add(sjlrFzxsDTO);
				}
				mv.addObject("fzxsDTOList", fzxsDTOList);
			}
		}
		return mv;
	}
	
	/**
	 * 肥猪销售新增、修改
	 * @param request
	 * @param response
	 * @return
	 * @throws Exception
	 */
	public ModelAndView hpSjlrFzxsEdit(HttpServletRequest request,
			HttpServletResponse response) throws Exception {
		ModelAndView mv = new ModelAndView("haifmp/sjlr/scgl/fzxs/hpSjlrFzxsEdit.htm");
		String mcid = request.getParameter("mcid");
		String id = request.getParameter("id");
		SjlrFzxs sjlrFzxs = new SjlrFzxs();
		if (StringUtils.hasText(String.valueOf(sjlrFzxs.getXsje()))) {
			sjlrFzxs.setXsje("0");
		}
		if (StringUtils.hasText(mcid)) {
			if (StringUtils.hasText(id)) {
				sjlrFzxs = sjlrFzxsDAO.selectByPrimaryKey(Integer.parseInt(id));
			}
			if (sjlrFzxs.getXssj() == null) {
				sjlrFzxs.setXssj(commonService.getCurrentDate());
			}
			sjlrFzxs.setMcid(Integer.valueOf(mcid));
		}
		List<XtGydm> slList = getGydm(XtAppConstant.CODE_SJLR_SL);
		List<XtGydm> xslxList = getGydm(XtAppConstant.CODE_SJLR_SLLX);
		mv.addObject("xslxList", xslxList);
		mv.addObject("id", id);
		mv.addObject("slList", slList);
		mv.addObject("sjlrFzxs", sjlrFzxs);
		mv.addObject("khmc", XtAppConstant.SJRL_XS_KEMC);
		return mv;
	}
	
	/**
	 * 保存肥猪销售
	 * @param request
	 * @throws Exception 
	 */
	public void saveSjlrFzxs(HttpServletRequest request,
			HttpServletResponse response) throws Exception {
		response.setContentType("text/json; charset=UTF-8");
		response.addHeader("Cache-Control", "no-cache,must-revalidate");
		response.addHeader("Pragma", "no-cache");
		
		SjlrFzxs sjlrFzxs = new SjlrFzxs();
		sjlrFzxs = (SjlrFzxs) parseObjectFromRequest(request, sjlrFzxs);
		sjlrFzxs.setXgr(getLoginSessionBean(request).getYhid().toString());
		sjlrFzxs.setXgsj(commonService.getCurrentDate());
		sjlrFzxs.setZfbz(XtAppConstant.ZFBZ_VALID);
		if (sjlrFzxs.getId() == 0) {
			sjlrFzxs.setId(null);
		}
		if (!StringUtils.hasText(String.valueOf(sjlrFzxs.getXsje()))) {
			sjlrFzxs.setXsje("0");
		}
		if (!StringUtils.hasText(String.valueOf(sjlrFzxs.getSl()))) {
			sjlrFzxs.setSl(0);
		}
		if (!StringUtils.hasText(String.valueOf(sjlrFzxs.getZl()))) {
			sjlrFzxs.setZl("0");
		}
		if (sjlrFzxs.getDjh() == null) {
			Calendar calendar = new GregorianCalendar();
			calendar.setTime(commonService.getCurrentDate());
			sjlrFzxs.setDjh(DateUtil.parser3(calendar.getTime().getTime()));
		}
		if (sjlrFzxs.getId() != null) {
			sjlrFzxsDAO.updateByPrimaryKeySelective(sjlrFzxs);
		} else {
			sjlrFzxsDAO.insertSelective(sjlrFzxs);
		}
		String jsonStr = "{\"count\" : \"1\"}";
		response.getWriter().write(jsonStr);
	}
	
	/**
	 * 删除肥猪转群
	 * @param request
	 * @throws Exception 
	 */
	public void disableFzxs(HttpServletRequest request,
			HttpServletResponse response) throws Exception {
		response.setContentType("text/json; charset=UTF-8");
		response.addHeader("Cache-Control", "no-cache,must-revalidate");
		response.addHeader("Pragma", "no-cache");
		String id = request.getParameter("id");
		String jsonStr = "";
		if (StringUtils.hasText(id)) {
			SjlrFzxs sjlrFzxs = new SjlrFzxs();
			sjlrFzxs.setId(Integer.parseInt(id));
			sjlrFzxs.setZfbz(XtAppConstant.ZFBZ_INVALID);
			sjlrFzxs.setXgr(getLoginSessionBean(request).getYhid().toString());
			sjlrFzxs.setXgsj(commonService.getCurrentDate());
			sjlrFzxsDAO.updateByPrimaryKeySelective(sjlrFzxs);
			jsonStr = "{\"count\" : \"1\"}";
		} else {
			jsonStr = "{\"count\" : \"0\"}";
		}
		response.getWriter().write(jsonStr);
	}
	
	/**
	 * 肥猪猪销售单据号公共查询页面
	 * @param request
	 * @param response
	 * @return
	 * @throws Exception
	 */
	public ModelAndView getFzxsSearchDjh(HttpServletRequest request,
			HttpServletResponse response) throws Exception {
		ModelAndView mv = new ModelAndView("haifmp/sjlr/scgl/zzxs/fzxsSearchModel.htm");
		String dweb = request.getParameter("dweb");
		String mcid = request.getParameter("mcid");
		String id = request.getParameter("id");
		if (StringUtils.hasText(id)) {
			mv.addObject("id", id);
		}
		if (StringUtils.hasText(mcid)) {
			Map<String, Object> paramMap = new HashMap<String, Object>();
			paramMap.put("mcid", mcid);
			if (StringUtils.hasText(dweb)) {
				paramMap.put("dweb", "%" + dweb + "%");
				mv.addObject("dweb", dweb);
			}
			List<SjlrMzda> daList = sjlrMyjlDAO.selectZzmyDaListByParam(paramMap);
			List<XtGydm> slList = getGydm(XtAppConstant.CODE_SJLR_SL);
			List<XtGydm> dqztList = getGydm(XtAppConstant.CODE_SJLR_DQZT);
			if (daList != null && daList.size() > 0) {
				for (SjlrMzda sjlrMzda : daList) {
					//舍栏
					if (StringUtils.hasText(sjlrMzda.getSl())) {
						for (XtGydm xtGydm : slList) {
							if (sjlrMzda.getSl().equals(xtGydm.getDmid())) {
								sjlrMzda.setSlStr(xtGydm.getDmmc());
							}
						}
					}
					//当前状态
					if (StringUtils.hasText(sjlrMzda.getDqzt())) {
						for (XtGydm xtGydm : dqztList) {
							if (sjlrMzda.getDqzt().equals(xtGydm.getDmid())) {
								sjlrMzda.setDqztStr(xtGydm.getDmmc());
							}
						}
					}
				}
			}
			mv.addObject("daList", daList);
		}
		return mv;
	}
	/**
	 * 种猪销售Index
	 * @param request
	 * @param response
	 * @return
	 * @throws Exception
	 */
	public ModelAndView hpSjlrZzxsIndex(HttpServletRequest request,
			HttpServletResponse response) throws Exception {
		ModelAndView mv = new ModelAndView("haifmp/sjlr/scgl/zzxs/hpSjlrZzxsIndex.htm");
		String mcid = request.getParameter("mcid");
		Map<String, Object> paramMap2 = new HashMap<String, Object>();
		if (StringUtils.hasText(mcid)) {
			Map<String, Object> paramMap = new HashMap<String, Object>();
			paramMap.put("mcid", mcid);
			String ksrq = request.getParameter("ksrq");
			String jsrq = request.getParameter("jsrq");
			String dweb = request.getParameter("dweb");
			String cxeph = request.getParameter("cxeph");
			if (!StringUtils.hasText(jsrq)) {
				jsrq = DateUtil.parserDateToDefaultString(commonService.getCurrentDate());
				
			}
			paramMap.put("jsrq", jsrq);
			mv.addObject("jsrq", jsrq);
			if (!StringUtils.hasText(ksrq)) {
				Calendar calendar = new GregorianCalendar();
				calendar.setTime(commonService.getCurrentDate());
				calendar.add(Calendar.DATE, -7);
				ksrq = DateUtil.parserDateToDefaultString(calendar.getTime());
			}
			paramMap.put("ksrq", ksrq);
			mv.addObject("ksrq", ksrq);
			if (StringUtils.hasText(dweb)) {
				paramMap2.put("dweb", dweb);
				List<SjlrMzda> daList = sjlrMzdaDAO.getDaListByZzds(paramMap2);
				paramMap.put("dweb","%" + daList.get(0).getEph() + "%");
				mv.addObject("dweb", dweb);
			}else if (StringUtils.hasText(cxeph)) {
				paramMap.put("dweb", "%" + cxeph + "%");
				mv.addObject("dweb", cxeph);
			}
			List<SjlrZzxs> zzxsList = sjlrZzxsDAO.selectZzxsAllListByParam(paramMap);
			List<SjlrZzxsDTO> zzxsDTOList = new ArrayList<SjlrZzxsDTO>();
			SjlrZzxsDTO sjlrZzxsDTO = null;
			String date = "";
			int count = 0;
			List<SjlrZzxs> zzxsLists = null;
			if (zzxsList != null && zzxsList.size() > 0) {
				for (int i = 0; i < zzxsList.size(); i++) {
					SjlrZzxs sjlrZzxs = zzxsList.get(i);
					String [] kemcList = XtAppConstant.SJRL_XS_KEMC;
					//客户名称
					if (StringUtils.hasText(sjlrZzxs.getKhmc())) {
						for (int j = 0; j < kemcList.length; j++) {
							if (sjlrZzxs.getKhmc().equals(String.valueOf(j))) {
								sjlrZzxs.setKhmc(kemcList [j]);
							}
						}
					}
					
					//业务逻辑
					if (i == 0) {
						sjlrZzxsDTO = new SjlrZzxsDTO();
						zzxsLists = new ArrayList<SjlrZzxs>();
						date = DateUtil.parserDateToDefaultString(sjlrZzxs.getXssj());
						sjlrZzxsDTO.setXsrq(date);
						zzxsLists.add(sjlrZzxs);
						count ++;
					} else {
						if (DateUtil.parserDateToDefaultString(sjlrZzxs.getXssj()).equals(date)) {
							count ++;
							zzxsLists.add(sjlrZzxs);
						} else {
							sjlrZzxsDTO.setZzxsList(zzxsLists);
							sjlrZzxsDTO.setCount(count);
							zzxsDTOList.add(sjlrZzxsDTO);
							sjlrZzxsDTO = new SjlrZzxsDTO();
							zzxsLists = new ArrayList<SjlrZzxs>();
							date = DateUtil.parserDateToDefaultString(sjlrZzxs.getXssj());
							sjlrZzxsDTO.setXsrq(date);
							zzxsLists.add(sjlrZzxs);
							count = 1;
						}
					}
				}
				if (count > 0) {
					sjlrZzxsDTO.setZzxsList(zzxsLists);
					sjlrZzxsDTO.setCount(count);
					zzxsDTOList.add(sjlrZzxsDTO);
				}
				mv.addObject("zzxsDTOList", zzxsDTOList);
			}
		}
		return mv;
	}
	
	/**
	 * 种猪销售新增、修改
	 * @param request
	 * @param response
	 * @return
	 * @throws Exception
	 */
	public ModelAndView hpSjlrZzxsEdit(HttpServletRequest request,
			HttpServletResponse response) throws Exception {
		ModelAndView mv = new ModelAndView("haifmp/sjlr/scgl/zzxs/hpSjlrZzxsEdit.htm");
		String mcid = request.getParameter("mcid");
		String id = request.getParameter("id");
		String dweb = request.getParameter("dweb");
		String date = request.getParameter("date");
		SjlrZzxs sjlrZzxs = new SjlrZzxs();
		if ("undefined".equals(dweb)) {
			dweb = "";
		}
		if (!StringUtils.hasText(String.valueOf(sjlrZzxs.getXsje()))) {
			sjlrZzxs.setXsje("0");
		}
		if (StringUtils.hasText(mcid)) {
			if (StringUtils.hasText(dweb)) {
				sjlrZzxs.setDweb(dweb);
			} else {
				if (StringUtils.hasText(id)) {
					sjlrZzxs = sjlrZzxsDAO.selectByPrimaryKey(Integer.parseInt(id));
					dweb = sjlrZzxs.getDweb();
					date = sjlrZzxs.getXssj().toString();
				}
			}
			if (date != null) {
				if (!StringUtils.hasText(id)) {
					SimpleDateFormat sdf=new SimpleDateFormat(XtAppConstant.TIME_FORMAT);
					java.util.Date newdate=sdf.parse(date.toString());
					sjlrZzxs.setXssj(newdate);
				}
			}else {
				sjlrZzxs.setXssj(commonService.getCurrentDate());
			}
		}
		List<XtGydm> slList = getGydm(XtAppConstant.CODE_SJLR_SL);
		mv.addObject("id", id);
		mv.addObject("slList", slList);
		mv.addObject("sjlrZzxs", sjlrZzxs);
		mv.addObject("khmc", XtAppConstant.SJRL_XS_KEMC);
		mv.addObject("dweb",dweb);
		return mv;
	}
	
	/**
	 * 保存种猪销售
	 * @param request
	 * @throws Exception 
	 */
	public void saveSjlrZzxs(HttpServletRequest request,
			HttpServletResponse response) throws Exception {
		response.setContentType("text/json; charset=UTF-8");
		response.addHeader("Cache-Control", "no-cache,must-revalidate");
		response.addHeader("Pragma", "no-cache");
		
		String dweb = request.getParameter("dweb");
		String mcid = request.getParameter("mcid");
		Map<String, Object> paramMap = new HashMap<String, Object>();
		SjlrZzxs sjlrZzxs = new SjlrZzxs();
		
		sjlrZzxs = (SjlrZzxs) parseObjectFromRequest(request, sjlrZzxs);
		if (dweb == "") {
			dweb = sjlrZzxsDAO.selectByPrimaryKey(sjlrZzxs.getId()).getDweb();
		}
		sjlrZzxs.setDweb(dweb);
		SjlrZzxsExample xsEx = new SjlrZzxsExample();
		SjlrZzxsExample.Criteria xsCr = xsEx.createCriteria();
		xsCr.andDwebEqualTo(sjlrZzxs.getDweb()).andZfbzEqualTo(XtAppConstant.ZFBZ_VALID);
		paramMap.put("eph", sjlrZzxs.getDweb());
		String xb = sjlrMzdaDAO.getDaListByZzds(paramMap).get(0).getXb();
		
		sjlrZzxs.setXgr(getLoginSessionBean(request).getYhid().toString());
		sjlrZzxs.setZt(10);//添加状态已售
		sjlrZzxs.setXgsj(commonService.getCurrentDate());
		sjlrZzxs.setZfbz(XtAppConstant.ZFBZ_VALID);
		sjlrZzxs.setXb(Integer.parseInt(xb));
		if (sjlrZzxs.getId() == 0) {
			sjlrZzxs.setId(null);
		}
		sjlrZzxsDAO.updateByExampleSelective(sjlrZzxs, xsEx);
		
		dweb = sjlrZzxs.getDweb();
		if (StringUtils.hasText(dweb)) {
			if ("1".equals(xb)) {
				SjlrGzdaExample gzdaEx = new SjlrGzdaExample();
				SjlrGzdaExample.Criteria gzdaCr = gzdaEx.createCriteria(); 
				gzdaCr.andDwebEqualTo(sjlrZzxs.getDweb()).andZfbzEqualTo(XtAppConstant.ZFBZ_VALID);
				
				if (StringUtils.hasText(mcid)) {
					gzdaCr.andMcidEqualTo(Integer.parseInt(mcid));
				}
				String sczt = sjlrGzdaDAO.selectByExample(gzdaEx).get(0).getDqzt();
				
				SjlrGzda sjlrGzda = new SjlrGzda();
				sjlrGzda.setDqzt("10");//10是已售的标志,后期修改
				sjlrGzda.setXgr(getLoginSessionBean(request).getYhid().toString());
				sjlrGzda.setXgsj(commonService.getCurrentDate());
				sjlrGzda.setSczt(sczt);
				sjlrGzdaDAO.updateByExampleSelective(sjlrGzda, gzdaEx);
			}
			if("2".equals(xb)) {
				SjlrMzdaExample mzdaEx = new SjlrMzdaExample();
				SjlrMzdaExample.Criteria mzdaCr = mzdaEx.createCriteria(); 
				mzdaCr.andDwebEqualTo(sjlrZzxs.getDweb()).andZfbzEqualTo(XtAppConstant.ZFBZ_VALID);
				if (StringUtils.hasText(mcid)) {
					mzdaCr.andMcidEqualTo(Integer.parseInt(mcid));
				}
				String scztMz = sjlrMzdaDAO.selectByExample(mzdaEx).get(0).getDqzt();
				SjlrMzda sjlrMzda = new SjlrMzda();
				sjlrMzda.setDqzt("10");//10是已售的标志,后期修改
				sjlrMzda.setXgr(getLoginSessionBean(request).getYhid().toString());
				sjlrMzda.setXgsj(commonService.getCurrentDate());
				sjlrMzda.setSczt(scztMz);
				sjlrMzdaDAO.updateByExampleSelective(sjlrMzda, mzdaEx);
			}
		}
		
		String jsonStr = "{\"count\" : \"1\"}";
		response.getWriter().write(jsonStr);
	}
	
	/**
	 * 删除种猪销售
	 * @param request
	 * @throws Exception 
	 */
	public void disableZzxs(HttpServletRequest request,
			HttpServletResponse response) throws Exception {
		response.setContentType("text/json; charset=UTF-8");
		response.addHeader("Cache-Control", "no-cache,must-revalidate");
		response.addHeader("Pragma", "no-cache");
		String xgr = getLoginSessionBean(request).getYhid().toString();
		String id = request.getParameter("id");
		String jsonStr = "";
		if (StringUtils.hasText(id)) {
			SjlrZzxs sjlrZzxs = sjlrZzxsDAO.selectByPrimaryKey(Integer.parseInt(id));
			sjlrZzxs.setId(Integer.parseInt(id));
			sjlrZzxs.setZfbz(XtAppConstant.ZFBZ_INVALID);
			sjlrZzxs.setXgr(xgr);
			sjlrZzxs.setXgsj(commonService.getCurrentDate());
			sjlrZzxsDAO.updateByPrimaryKeySelective(sjlrZzxs);
			//还原档案中的猪只状态
			this.setDazt(sjlrZzxs.getDweb(),xgr);
			jsonStr = "{\"count\" : \"1\"}";
		} else {
			jsonStr = "{\"count\" : \"0\"}";
		}
		response.getWriter().write(jsonStr);
	}
	
	/**
	 * 种猪销售耳标公共查询页面
	 * @param request
	 * @param response
	 * @return
	 * @throws Exception
	 */
	public ModelAndView getZzxsSearchDweb(HttpServletRequest request,
			HttpServletResponse response) throws Exception {
		ModelAndView mv = new ModelAndView("haifmp/sjlr/scgl/zzxs/zzxsSearchModel.htm");
		String dweb = request.getParameter("dweb");
		String mcid = request.getParameter("mcid");
		String date = request.getParameter("date");
		String id = request.getParameter("id");
		String cxeph = request.getParameter("cxeph");
		Map<String, Object> paramMapda = new HashMap<String, Object>();
		Map<String, Object> paramMap1 = new HashMap<String, Object>();
		if (StringUtils.hasText(id)) {
			mv.addObject("id", id);
		}
		if (StringUtils.hasText(mcid)) {
			SjlrZzxsExample zzxsEx = new SjlrZzxsExample();
			SjlrZzxsExample.Criteria xsCr = zzxsEx.createCriteria();
			xsCr.andZtEqualTo(12).andZfbzEqualTo(XtAppConstant.ZFBZ_VALID).andMcidEqualTo(Integer.parseInt(mcid));
			if (StringUtils.hasText(dweb)) {
				paramMap1.put("dweb", dweb);
				List<SjlrMzda> daList = sjlrMzdaDAO.getDaListByZzds(paramMap1);
				xsCr.andDwebLike("%" + daList.get(0).getEph() + "%");
				mv.addObject("dweb", dweb);
			}else if (StringUtils.hasText(cxeph)) {
				xsCr.andDwebLike("%" + cxeph + "%");
				mv.addObject("dweb", cxeph);
			}
			xsCr.andZtEqualTo(12);
			List<SjlrZzxs> daList = sjlrZzxsDAO.selectByExample(zzxsEx);
			List<XtGydm> slList = getGydm(XtAppConstant.CODE_SJLR_SL);
			List<XtGydm> xbList = getGydm(XtAppConstant.CODE_DWXB);
			List<XtGydm> ztList = getGydm(XtAppConstant.CODE_SJLR_DQZT);
			if (daList != null && daList.size() > 0) {
				for (SjlrZzxs sjlrZzxs : daList) {
					//舍栏
					paramMapda.put("mcid", mcid);
					paramMapda.put("eph", sjlrZzxs.getDweb());
					String sl = sjlrMzdaDAO.getDaListByZzds(paramMapda).get(0).getSl();
					if (StringUtils.hasText(sl)) {
						for (XtGydm xtGydm : slList) {
							if (sl.equals(xtGydm.getDmid())) {
								sjlrZzxs.setSlStr(xtGydm.getDmmc());
							}
						}
					}
					//当前状态
					if (StringUtils.hasText(sjlrZzxs.getZt().toString())) {
						for (XtGydm xtGydm : ztList) {
							if (sjlrZzxs.getZt().equals(xtGydm.getDmid())) {
								sjlrZzxs.setDqztStr(xtGydm.getDmmc());
							}
						}
					}
					sjlrZzxs.setDqztStr("待售");

					if (StringUtils.hasText(sjlrZzxs.getXb().toString())) {
						for (XtGydm xtGydm : xbList) {
							if (sjlrZzxs.getXb().equals(xtGydm.getDmid())) {
								sjlrZzxs.setXbStr((xtGydm.getDmmc()));
							}
						}
					}
				}
			}
			mv.addObject("daList", daList);
			mv.addObject("date",date);
		}
		return mv;
	}
	
	
	/**
	 * 种猪待售Index
	 * @param request
	 * @param response
	 * @return
	 * @throws Exception
	 */
	
	public ModelAndView hpSjlrZzdsIndex(HttpServletRequest request,
			HttpServletResponse response) throws Exception {
		ModelAndView mv = new ModelAndView("haifmp/sjlr/scgl/zzds/hpSjlrZzdsIndex.htm");
		String mcid = request.getParameter("mcid");
		String cxeph = request.getParameter("cxeph");
		SjlrZzxs sjlrZzds = null;
		Map<String, Object> paramMapda = new HashMap<String, Object>();
		Map<String, Object> paramMap1 = new HashMap<String, Object>();
		if (StringUtils.hasText(mcid)) {
			Map<String, Object> paramMap = new HashMap<String, Object>();
			paramMap.put("mcid", mcid);
			String ksrq = request.getParameter("ksrq");
			String jsrq = request.getParameter("jsrq");
			String dweb = request.getParameter("dweb");
			if (!StringUtils.hasText(jsrq)) {
				jsrq = DateUtil.parserDateToDefaultString(commonService.getCurrentDate());
				
			}
			paramMap.put("jsrq", jsrq);
			mv.addObject("jsrq", jsrq);
			if (!StringUtils.hasText(ksrq)) {
				Calendar calendar = new GregorianCalendar();
				calendar.setTime(commonService.getCurrentDate());
				calendar.add(Calendar.DATE, -7);
				ksrq = DateUtil.parserDateToDefaultString(calendar.getTime());
			}
			paramMap.put("ksrq", ksrq);
			mv.addObject("ksrq", ksrq);
			if (StringUtils.hasText(dweb)) {
				paramMap1.put("dweb", dweb);
				mv.addObject("dweb", dweb);
			}else if (StringUtils.hasText(cxeph)) {
				paramMap.put("cxeph", "%" + cxeph + "%");
				mv.addObject("dweb", cxeph);
			}
			List<XtGydm> slList = getGydm(XtAppConstant.CODE_SJLR_SL);
			List<XtGydm> pzList = getGydm(XtAppConstant.CODE_SJLR_ZZPZ);
			List<XtGydm> dwxbList = getGydm(XtAppConstant.CODE_DWXB);
			
			//从种猪销售表中选择当前状态为待售的数据。
			List<SjlrZzxs> zzdsList = sjlrZzxsDAO.selectZzdsAlltByParam(paramMap);
			List<SjlrZzxsDTO> zzdsDTOList = new ArrayList<SjlrZzxsDTO>();
			SjlrZzxsDTO sjlrZzdsDTO = null;
			String date = "";
			int count = 0;
			List<SjlrZzxs> zzdsLists = null;
			if (zzdsList != null && zzdsList.size() > 0) {
				for (int i = 0; i < zzdsList.size(); i++) {
					sjlrZzds = zzdsList.get(i);
					String eb = sjlrZzds.getDweb();
					paramMapda.put("eph", eb);
					paramMapda.put("mcid", mcid);
					SjlrMzda mz = sjlrMzdaDAO.getDaListByZzds(paramMapda).get(0);

					//舍栏
					if (StringUtils.hasText(mz.getSl())) {
						for (XtGydm xtGydm : slList) {
							if (xtGydm.getDmid().equals(mz.getSl())) {
								sjlrZzds.setSlStr(xtGydm.getDmmc());
							}
						}
					}
					//当前状态
					sjlrZzds.setDqztStr("待售");
					//猪只品种
					if (StringUtils.hasText(mz.getPz())) {
						for (XtGydm xtGydm : pzList) {
							if (xtGydm.getDmid().equals(mz.getPz())) {
								sjlrZzds.setPzStr(xtGydm.getDmmc());
							}
						}
					}
					//猪只性别
					if (StringUtils.hasText(mz.getXb())) {
						for (XtGydm xtGydm : dwxbList) {
							if (xtGydm.getDmid().equals(mz.getXb())) {
								sjlrZzds.setXbStr(xtGydm.getDmmc());
							}
						}
					}
					//业务逻辑
					if (i == 0) {
						sjlrZzdsDTO = new SjlrZzxsDTO();
						zzdsLists = new ArrayList<SjlrZzxs>();
						date = DateUtil.parserDateToDefaultString(sjlrZzds.getDssj());
						sjlrZzdsDTO.setXsrq(date);
						zzdsLists.add(sjlrZzds);
						count ++;
					} else {
						if (DateUtil.parserDateToDefaultString(sjlrZzds.getDssj()).equals(date)) {
							count ++;
							zzdsLists.add(sjlrZzds);
						} else {
							sjlrZzdsDTO.setZzxsList(zzdsLists);
							sjlrZzdsDTO.setCount(count);
							zzdsDTOList.add(sjlrZzdsDTO);
							sjlrZzdsDTO = new SjlrZzxsDTO();
							zzdsLists = new ArrayList<SjlrZzxs>();
							date = DateUtil.parserDateToDefaultString(sjlrZzds.getDssj());
							sjlrZzdsDTO.setXsrq(date);
							zzdsLists.add(sjlrZzds);
							count = 1;
						}
					}
				}
				if (count > 0) {
					sjlrZzdsDTO.setZzxsList(zzdsLists);
					sjlrZzdsDTO.setCount(count);
					zzdsDTOList.add(sjlrZzdsDTO);
				}
				mv.addObject("zzdsDTOList", zzdsDTOList);
			}
		}
		return mv;
	}
		
	///**
//	 * 种猪待售新增、修改
//	 * @param request
//	 * @param response
//	 * @return
//	 * @throws Exception
//	 */
//	public ModelAndView hpSjlrZzdsEdit1(HttpServletRequest request,
//			HttpServletResponse response) throws Exception {
//		ModelAndView mv = new ModelAndView("haifmp/sjlr/scgl/zzds/hpSjlrZzdsEdit.htm");
//		String mcid = request.getParameter("mcid");
//		String id = request.getParameter("id");
//		String dweb = request.getParameter("dweb");
//		SjlrZzxs sjlrZzds = new SjlrZzxs();
//		if (StringUtils.hasText(mcid)) {
//			if (StringUtils.hasText(dweb)) {
//				sjlrZzds.setDweb(dweb);
//			} else {
//				if (StringUtils.hasText(id)) {
//					sjlrZzds = sjlrZzxsDAO.selectByPrimaryKey(Integer.parseInt(id));
//				}
//			}
//			if (sjlrZzds.getXssj() == null) {
//				sjlrZzds.setXssj(commonService.getCurrentDate());
//			}
//		}
//		List<XtGydm> slList = getGydm(XtAppConstant.CODE_SJLR_SL);
//		mv.addObject("id", id);
//		mv.addObject("slList", slList);
//		mv.addObject("sjlrZzds", sjlrZzds);
//		return mv;
//	}

///**
//	 * 种猪待售新增、修改
//	 * @param request
//	 * @param response
//	 * @return
//	 * @throws Exception
//	 */
//	public ModelAndView hpSjlrZzdsEdit1(HttpServletRequest request,
//			HttpServletResponse response) throws Exception {
//		ModelAndView mv = new ModelAndView("haifmp/sjlr/scgl/zzds/hpSjlrZzdsEdit.htm");
//		String mcid = request.getParameter("mcid");
//		String id = request.getParameter("id");
//		String dweb = request.getParameter("dweb");
//		SjlrZzxs sjlrZzds = new SjlrZzxs();
//		if (StringUtils.hasText(mcid)) {
//			if (StringUtils.hasText(dweb)) {
//				sjlrZzds.setDweb(dweb);
//			} else {
//				if (StringUtils.hasText(id)) {
//					sjlrZzds = sjlrZzxsDAO.selectByPrimaryKey(Integer.parseInt(id));
//				}
//			}
//			if (sjlrZzds.getXssj() == null) {
//				sjlrZzds.setXssj(commonService.getCurrentDate());
//			}
//		}
//		List<XtGydm> slList = getGydm(XtAppConstant.CODE_SJLR_SL);
//		mv.addObject("id", id);
//		mv.addObject("slList", slList);
//		mv.addObject("sjlrZzds", sjlrZzds);
//		return mv;
//	}
	
	/**
	 * 保存种猪待售
	 * @param request
	 * @throws Exception 
	 */
	public void saveSjlrZzds(HttpServletRequest request,
			HttpServletResponse response) throws Exception {
		response.setContentType("text/json; charset=UTF-8");
		response.addHeader("Cache-Control", "no-cache,must-revalidate");
		response.addHeader("Pragma", "no-cache");
		List<SjlrGzda> gzdaList = new ArrayList<SjlrGzda>();
		List<SjlrMzda> mzdaList = new ArrayList<SjlrMzda>();
		List<SjlrZzxs> zzxsList = new ArrayList<SjlrZzxs>();
		List<SjlrGzdaExample> gzdaExList = new ArrayList<SjlrGzdaExample>();
		List<SjlrMzdaExample> mzdaExList = new ArrayList<SjlrMzdaExample>();
		String dweb = request.getParameter("dweb");
		String mcid = request.getParameter("mcid");
		
		if (StringUtils.hasText(dweb)) {//修改档案中的当前状态
			String ndweb[] = dweb.split(",");
			//写入种猪销售表
			for (int i = 0 ; i < ndweb.length ; i++) {
				String dwebxb[] = ndweb[i].split("@");
				SjlrZzxs sjlrzzds = new SjlrZzxs();
				sjlrzzds.setDweb(dwebxb[0]);
				sjlrzzds.setDssj(commonService.getCurrentDate());
				sjlrzzds.setZt(12);
				sjlrzzds.setXgr(getLoginSessionBean(request).getYhid().toString());
				sjlrzzds.setXgsj(commonService.getCurrentDate());
				sjlrzzds.setZfbz(XtAppConstant.ZFBZ_VALID);
				sjlrzzds.setXb(Integer.parseInt(dwebxb[1]));
				sjlrzzds.setMcid(Integer.parseInt(mcid));
				zzxsList.add(sjlrzzds);
				
				//修改档案中的公猪档案记录	
				if ("1".equals(dwebxb[1])) {
					SjlrGzdaExample gzdaEx = new SjlrGzdaExample();
					SjlrGzdaExample.Criteria gzdaCr = gzdaEx.createCriteria(); 
						gzdaCr.andEphEqualTo(dwebxb[0]).andZfbzEqualTo(XtAppConstant.ZFBZ_VALID);
						if (StringUtils.hasText(mcid)) {
								gzdaCr.andMcidEqualTo(Integer.parseInt(mcid));
							}
						String sczt = sjlrGzdaDAO.selectByExample(gzdaEx).get(0).getDqzt();
						//更新公猪档案记录
						SjlrGzda sjlrGzda = new SjlrGzda();
						sjlrGzda.setXgr(getLoginSessionBean(request).getYhid().toString());
						sjlrGzda.setXgsj(commonService.getCurrentDate());
						sjlrGzda.setZfbz(XtAppConstant.ZFBZ_VALID);
						sjlrGzda.setDqzt("12");
						sjlrGzda.setSczt(sczt);
						gzdaList.add(sjlrGzda);
						gzdaExList.add(gzdaEx);
				}else {
					//修改档案中的母猪档案记录
					SjlrMzdaExample mzdaExample = new SjlrMzdaExample();
					SjlrMzdaExample.Criteria mzdaCr = mzdaExample.createCriteria();
						mzdaCr.andEphEqualTo(dwebxb[0]).andZfbzEqualTo(XtAppConstant.ZFBZ_VALID);
						if (StringUtils.hasText(mcid)) {
							mzdaCr.andMcidEqualTo(Integer.parseInt(mcid));
						}
						String scztMz = sjlrMzdaDAO.selectByExample(mzdaExample).get(0).getDqzt();
						//更新母猪档案记录
						SjlrMzda sjlrMzda = new SjlrMzda();
						sjlrMzda.setXgr(getLoginSessionBean(request).getYhid().toString());
						sjlrMzda.setXgsj(commonService.getCurrentDate());
						sjlrMzda.setZfbz(XtAppConstant.ZFBZ_VALID);
						sjlrMzda.setDqzt("12");
						sjlrMzda.setSczt(scztMz);
						mzdaList.add(sjlrMzda);
						mzdaExList.add(mzdaExample);
				}
			}
			


			//批量插入更新
				sjlrGzdaDAO.updatGzdaByParam(gzdaList, gzdaExList);
				sjlrMzdaDAO.updatMzdaByParam(mzdaList, mzdaExList);
				sjlrZzxsDAO.insertZzdsByParam(zzxsList);
		}
		
		String jsonStr = "{\"count\" : \"1\"}";
		response.getWriter().write(jsonStr);
	}
	
	/**
	 * 删除种猪待售
	 * @param request
	 * @throws Exception 
	 */
	public void disableZzds(HttpServletRequest request,
			HttpServletResponse response) throws Exception {
		response.setContentType("text/json; charset=UTF-8");
		response.addHeader("Cache-Control", "no-cache,must-revalidate");
		response.addHeader("Pragma", "no-cache");
		
		String xgr = getLoginSessionBean(request).getYhid().toString();
		String id = request.getParameter("id");
		String jsonStr = "";
		if (StringUtils.hasText(id)) {
			SjlrZzxs sjlrZzxs = sjlrZzxsDAO.selectByPrimaryKey(Integer.parseInt(id));
			sjlrZzxs.setId(Integer.parseInt(id));
			sjlrZzxs.setZfbz(XtAppConstant.ZFBZ_INVALID);
			sjlrZzxs.setXgr(xgr);
			sjlrZzxs.setXgsj(commonService.getCurrentDate());
			sjlrZzxsDAO.updateByPrimaryKeySelective(sjlrZzxs);
			//还原档案中的猪只状态
			setDazt(sjlrZzxs.getDweb(),xgr);
			jsonStr = "{\"count\" : \"1\"}";
		} else {
			jsonStr = "{\"count\" : \"0\"}";
		}
		response.getWriter().write(jsonStr);
	}
	
	/**
	 * 种猪待售耳标公共查询页面
	 * @param request
	 * @param response
	 * @return
	 * @throws Exception
	 */
	public ModelAndView getZzdsSearchDweb(HttpServletRequest request,
			HttpServletResponse response) throws Exception {
		ModelAndView mv = new ModelAndView("haifmp/sjlr/scgl/zzds/zzdsSearchModel.htm");
		String dweb = request.getParameter("dweb");
		String mcid = request.getParameter("mcid");
		String id = request.getParameter("id");
		String cxeph = request.getParameter("cxeph");
		if (StringUtils.hasText(id)) {
			mv.addObject("id", id);
		}
		if (StringUtils.hasText(mcid)) {
			Map<String, Object> paramMap = new HashMap<String, Object>();
			paramMap.put("mcid", mcid);
			if (StringUtils.hasText(dweb)) {
				paramMap.put("dweb", "%" + dweb + "%");
				mv.addObject("dweb", dweb);
			}else if (StringUtils.hasText(cxeph)) {
				paramMap.put("cxeph", "%" + cxeph + "%");
				mv.addObject("dweb", cxeph);
			}
			List<SjlrMzda> daList = sjlrZzxsDAO.selectZzxsDaListByParam(paramMap);
			List<XtGydm> slList = getGydm(XtAppConstant.CODE_SJLR_SL);
			List<XtGydm> dqztList = getGydm(XtAppConstant.CODE_SJLR_DQZT);
			if (daList != null && daList.size() > 0) {
				for (SjlrMzda sjlrMzda : daList) {
					//舍栏
					if (StringUtils.hasText(sjlrMzda.getSl())) {
						for (XtGydm xtGydm : slList) {
							if (sjlrMzda.getSl().equals(xtGydm.getDmid())) {
								sjlrMzda.setSlStr(xtGydm.getDmmc());
							}
						}
					}
					//当前状态
					if (StringUtils.hasText(sjlrMzda.getDqzt())) {
						for (XtGydm xtGydm : dqztList) {
							if (sjlrMzda.getDqzt().equals(xtGydm.getDmid())) {
								sjlrMzda.setDqztStr(xtGydm.getDmmc());
							}
						}
					}
/*					if (StringUtils.hasText(sjlrMzda.getXb())) {
						for (XtGydm xtGydm : xbList) {
							if (sjlrMzda.getXb().equals(xtGydm.getDmid())) {
								sjlrMzda.setXb((xtGydm.getDmmc()));
							}
						}
					}*/
				}
			}
			mv.addObject("daList", daList);
		}
		return mv;
	}
	
	
	/**
	 * 修改档案的状态
	 * @param lbmc
	 * @return 
	 * @return
	 * @throws Exception
	 */ 
	private void modify(String dweb , String xgr) throws Exception {
		if (StringUtils.hasText(dweb)) {
			SjlrGzdaExample gzdaEx = new SjlrGzdaExample();
			SjlrGzdaExample.Criteria gzdaCr = gzdaEx.createCriteria(); 
			gzdaCr.andDwebEqualTo(dweb).andZfbzEqualTo(XtAppConstant.ZFBZ_VALID);
			List<SjlrGzda> daList = sjlrGzdaDAO.selectByExample(gzdaEx);
			if (daList.size() > 0){
				SjlrGzda sjlrGzda = new SjlrGzda();
				sjlrGzda.setXgr(xgr);
				sjlrGzda.setXgsj(commonService.getCurrentDate());
				sjlrGzda.setLcrq(commonService.getCurrentDate());
				sjlrGzda.setDqzt(XtAppConstant.CODE_SJLR_DQZT_TT);
				sjlrGzdaDAO.updateByExampleSelective(sjlrGzda, gzdaEx);
			}
			
			SjlrMzdaExample mzdaEx = new SjlrMzdaExample();
			SjlrMzdaExample.Criteria mzdaCr = mzdaEx.createCriteria(); 
			mzdaCr.andDwebEqualTo(dweb).andZfbzEqualTo(XtAppConstant.ZFBZ_VALID);
			List<SjlrMzda> mzList = sjlrMzdaDAO.selectByExample(mzdaEx);
			if (mzList.size() > 0) {
				SjlrMzda sjlrMzda = new SjlrMzda();
				sjlrMzda.setXgr(xgr);
				sjlrMzda.setXgsj(commonService.getCurrentDate());
				sjlrMzda.setLcrq(commonService.getCurrentDate());
				sjlrMzda.setDqzt(XtAppConstant.CODE_SJLR_DQZT_TT);
				sjlrMzdaDAO.updateByExampleSelective(sjlrMzda, mzdaEx);
			}
		}
	}
	/**
	 * 还原档案中的当前状态为sczt中存储的状态
	 * @param lbmc
	 * @return 
	 * @return
	 * @throws Exception
	 */ 
	

	private void setDazt(String dweb , String xgr) throws Exception {
		String sczt = "";
		String scztMz = "";
		if (StringUtils.hasText(dweb)) {
			SjlrGzdaExample gzdaEx = new SjlrGzdaExample();
			SjlrGzdaExample.Criteria gzdaCr = gzdaEx.createCriteria(); 
			gzdaCr.andDwebEqualTo(dweb).andZfbzEqualTo(XtAppConstant.ZFBZ_VALID);
			
			List<SjlrGzda> daList = sjlrGzdaDAO.selectByExample(gzdaEx);
			if (daList.size() > 0){
				sczt = daList.get(0).getDqzt();
				SjlrGzda sjlrGzda = new SjlrGzda();
				sjlrGzda.setDqzt(daList.get(0).getSczt());
				sjlrGzda.setXgr(xgr);
				sjlrGzda.setXgsj(commonService.getCurrentDate());
				sjlrGzda.setSczt(sczt);
				sjlrGzdaDAO.updateByExampleSelective(sjlrGzda, gzdaEx);
			}
			
			SjlrMzdaExample mzdaEx = new SjlrMzdaExample();
			SjlrMzdaExample.Criteria mzdaCr = mzdaEx.createCriteria(); 
			mzdaCr.andDwebEqualTo(dweb).andZfbzEqualTo(XtAppConstant.ZFBZ_VALID);
			List<SjlrMzda> mzList = sjlrMzdaDAO.selectByExample(mzdaEx);
			if (mzList.size() > 0) {
				scztMz = mzList.get(0).getDqzt();
				SjlrMzda sjlrMzda = new SjlrMzda();
				sjlrMzda.setDqzt(daList.get(0).getSczt());
				sjlrMzda.setXgr(xgr);
				sjlrMzda.setXgsj(commonService.getCurrentDate());
				sjlrMzda.setSczt(scztMz);
				sjlrMzdaDAO.updateByExampleSelective(sjlrMzda, mzdaEx);
			}
		}
	}
	/**
	 * 获取公用代码
	 * @param lbmc
	 * @return 
	 * @return
	 * @throws Exception
	 */ 
	private List<XtGydm> getGydm(String lbmc) {
		return xtGydmDAO.selectGydmByLbmc(lbmc);
	}

	public void setCommonService(CommonService commonService) {
		this.commonService = commonService;
	}

	public void setXtGydmDAO(XtGydmDAO xtGydmDAO) {
		this.xtGydmDAO = xtGydmDAO;
	}

	public void setSjlrZzzqDAO(SjlrZzzqDAO sjlrZzzqDAO) {
		this.sjlrZzzqDAO = sjlrZzzqDAO;
	}

	public void setSjlrFzzqDAO(SjlrFzzqDAO sjlrFzzqDAO) {
		this.sjlrFzzqDAO = sjlrFzzqDAO;
	}

	public void setSjlrZzswDAO(SjlrZzswDAO sjlrZzswDAO) {
		this.sjlrZzswDAO = sjlrZzswDAO;
	}

	public void setSjlrFzswDAO(SjlrFzswDAO sjlrFzswDAO) {
		this.sjlrFzswDAO = sjlrFzswDAO;
	}

	public void setSjlrZzttDAO(SjlrZzttDAO sjlrZzttDAO) {
		this.sjlrZzttDAO = sjlrZzttDAO;
	}

	public void setSjlrFzttDAO(SjlrFzttDAO sjlrFzttDAO) {
		this.sjlrFzttDAO = sjlrFzttDAO;
	}

	public void setSjlrGzdaDAO(SjlrGzdaDAO sjlrGzdaDAO) {
		this.sjlrGzdaDAO = sjlrGzdaDAO;
	}

	public void setSjlrMzdaDAO(SjlrMzdaDAO sjlrMzdaDAO) {
		this.sjlrMzdaDAO = sjlrMzdaDAO;
	}

	public void setSjlrMyjlDAO(SjlrMyjlDAO sjlrMyjlDAO) {
		this.sjlrMyjlDAO = sjlrMyjlDAO;
	}

	public void setSjlrZzxsDAO(SjlrZzxsDAO sjlrZzxsDAO) {
		this.sjlrZzxsDAO = sjlrZzxsDAO;
	}

	public void setSjlrFzxsDAO(SjlrFzxsDAO sjlrFzxsDAO) {
		this.sjlrFzxsDAO = sjlrFzxsDAO;
	}

	public void setSjlrSlwlDAO(SjlrSlwlDAO sjlrSlwlDAO) {
		this.sjlrSlwlDAO = sjlrSlwlDAO;
	}
	
}