meidu2021/daju/target/classes/cn/com/lzt/userattendancedetail/service/impl/UserAttendanceDetailQueryServiceImpl.java

package cn.com.lzt.userattendancedetail.service.impl;

import java.math.BigDecimal;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Collections;
import java.util.Date;
import java.util.HashMap;
import java.util.List;

import org.jeecgframework.core.common.hibernate.qbc.CriteriaQuery;
import org.jeecgframework.core.common.service.impl.CommonServiceImpl;
import org.jeecgframework.core.constant.Globals;
import org.jeecgframework.core.util.DataUtils;
import org.jeecgframework.core.util.ListUtils;
import org.jeecgframework.core.util.oConvertUtils;
import org.jeecgframework.tag.vo.datatable.SortDirection;
import org.jeecgframework.web.system.pojo.base.TSDepart;
import org.jeecgframework.workflow.common.WorkFlowGlobals;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import com.alibaba.fastjson.JSONObject;

import cn.com.lzt.attendance.entity.TBusSpecialAttendEntity;
import cn.com.lzt.attendance.service.TBusSpecialAttendServiceI;
import cn.com.lzt.calendar.entity.CalendarEntity;
import cn.com.lzt.calendar.service.CalendarServiceI;
import cn.com.lzt.dingattendanceinfo.entity.DingAttendanceinfoEntity;
import cn.com.lzt.dingattendanceinfo.service.DingAttendanceinfoServiceI;
import cn.com.lzt.holiday.entity.HolidayEntity;
import cn.com.lzt.holiday.service.HolidayServiceI;
import cn.com.lzt.mealsdeduct.entity.MealsDeductEntity;
import cn.com.lzt.mealssubsidy.entity.MealsSubsidyEntity;
import cn.com.lzt.overtimerecord.entity.OvertimeRecordEntity;
import cn.com.lzt.overtimerecord.service.OvertimeRecordServiceI;
import cn.com.lzt.projarrangedetail.entity.ProjarrangeDetailEntity;
import cn.com.lzt.snapregularborrow.entity.SnapRegularborrowEntity;
import cn.com.lzt.snapregularborrow.service.SnapRegularborrowServiceI;
import cn.com.lzt.snapsingleborrow.entity.SnapSingleborrowEntity;
import cn.com.lzt.snapsingleborrow.service.SnapSingleborrowServiceI;
import cn.com.lzt.userattendancedetail.dao.UserAttendanceDetailDao;
import cn.com.lzt.userattendancedetail.dto.AttendanceDetailJsonObj;
import cn.com.lzt.userattendancedetail.dto.AttendanceTotalJsonObj;
import cn.com.lzt.userattendancedetail.dto.UserAttendanceDetailDto;
import cn.com.lzt.userattendancedetail.entity.UserAttendanceDetailAdjustedEntity;
import cn.com.lzt.userattendancedetail.entity.UserAttendanceDetailEntity;
import cn.com.lzt.userattendancedetail.service.UserAttendanceDetailQueryServiceI;
import cn.com.lzt.userattendancetotal.entity.UserAttendanceTotalEntity;
import cn.com.lzt.userwagestrategy.entity.UserWagestrategyEntity;
import cn.com.lzt.userwagestrategy.service.UserWagestrategyServiceI;

@Service("userAttendanceDetailQueryService")
public class UserAttendanceDetailQueryServiceImpl extends CommonServiceImpl
		implements UserAttendanceDetailQueryServiceI {
	@Autowired
	private UserAttendanceDetailDao userAttendanceDetailDao;
	// 员工工资策略表
	@Autowired
	private UserWagestrategyServiceI userWagestrategyService;
	// 休假申请表
	@Autowired
	private HolidayServiceI holidayService;
	// 加班备案表
	@Autowired
	private OvertimeRecordServiceI overtimeRecordService;
	// 临时借调（单次）申请表
	@Autowired
	private SnapSingleborrowServiceI snapSingleborrowService;
	// 临时固定周期申请表
	@Autowired
	private SnapRegularborrowServiceI snapRegularborrowService;
	// 钉钉考勤原始信息表
	@Autowired
	private DingAttendanceinfoServiceI dingAttendanceinfoService;
	@Autowired
	private CalendarServiceI calendarService;
	@Autowired
	private TBusSpecialAttendServiceI specialAttendService;
	
/**
 * 通过月度考勤计算更新月度每日的考勤信息
 * @author hualong.zhao
 * @date 2017-11-30
 * @param userAttendanceTotalEntity
 * @param hm_cache 
 * @throws Exception
 */
	private void updateDetailinfoBytotalEntity(
			UserAttendanceTotalEntity userAttendanceTotalEntity, HashMap<String, HashMap<String, Object>> hm_cache) throws Exception {
		List<UserAttendanceDetailDto>  uatdlist = null;
		if(hm_cache == null) {
			uatdlist = getallUsefulField(userAttendanceTotalEntity, null, null);
		}else {
			uatdlist = getallUsefulFieldWithCache(hm_cache,userAttendanceTotalEntity);
		}
				
		List<UserAttendanceDetailEntity> detailEntities = new ArrayList<>();
		
		for (UserAttendanceDetailDto dto : uatdlist) {
//			
//			if("ff808081657e96b10165848ae5d61df2".equals(dto.getUserid())) {
//				System.out.println("张义华日夜");
//			}else {
//				continue;
//			}
			
			UserAttendanceDetailEntity userAttendanceDetailEntity = new UserAttendanceDetailEntity();
			//时间微调 默认为零
			userAttendanceDetailEntity.setTimeFineTuning(BigDecimal.ZERO);
			//设置当前时间
			userAttendanceDetailEntity.setYmdDate(dto.getYmdDate());
			// 设置考勤id; ok
			userAttendanceDetailEntity.setAttendanceId(dto.getAttendanceId());
			// 设置实际出勤时间
			userAttendanceDetailEntity.setAttendanceDate(dto.getActattendanceDate());
			// 设置实际退勤时间
			if (oConvertUtils.isNotEmpty(dto.getActattendanceDate())&&
					oConvertUtils.isNotEmpty(dto.getActretreatDate())&&
					dto.getActattendanceDate().equals(dto.getActretreatDate())) {
				userAttendanceDetailEntity.setRetreatDate(null);
			}else {
				userAttendanceDetailEntity.setRetreatDate(dto.getActretreatDate());
			}
			// 设置班次id 如果排班类型为休息  则此处不存储班次id 
			 if (Globals.DUTYTYPE_xiuxi.equals(oConvertUtils.getString(dto.getDutyType()))) {
				 userAttendanceDetailEntity.setDutyId(null);
			 }else {
				 userAttendanceDetailEntity.setDutyId(dto.getShiftid());
			}
			// 设置基准时间
			userAttendanceDetailEntity.setDatumDate(dto.getDatumDate());
			// 設置时间差值
			if (null==dto.getTimeDifference()) {
				userAttendanceDetailEntity.setTimeDifference(BigDecimal.ZERO);
			}else {
				userAttendanceDetailEntity.setTimeDifference(dto.getTimeDifference());
			}
			//设置超时加班时长
			userAttendanceDetailEntity.setTimeoutOvertimeDuration(dto.getTimeoutOvertimeDuration());
			//设置  国定加班时长
			userAttendanceDetailEntity.setNationalOvertimeDuration(dto.getNationalOvertimeDuration());
			//设置  特殊加班时长
			userAttendanceDetailEntity.setSpecialOvertime(dto.getSpecialOvertime());
			// 获取当前状态
			userAttendanceDetailEntity.setStatus(dto.getCurdateStatus());
			// 获取借调信息-==start
			userAttendanceDetailEntity.setBorrowstatus(dto.getBorrowstatus());
			userAttendanceDetailEntity.setBorrowspid(dto.getBorrowspid());
			userAttendanceDetailEntity.setBorrowsdepartid(dto.getBorrowsdepartid());
			userAttendanceDetailEntity.setDayPay(dto.getDayPay());
			// 获取借调信息-==end
			// 设置实际出勤时间
			if (null==dto.getActualAttendanceDate()) {
				userAttendanceDetailEntity.setAttendanceMins(BigDecimal.ZERO);
				userAttendanceDetailEntity.setActualAttendanceDate(BigDecimal.ZERO);
			}else{
				userAttendanceDetailEntity.setAttendanceMins(dto.getActualAttendanceDate());
				userAttendanceDetailEntity.setActualAttendanceDate(dto.getActualAttendanceDate());
			}
			
			AttendanceDetailJsonObj jsonobj = getjsonObjfromDto(dto);
			if(hm_cache != null) {
				// 单个考勤核算不覆盖调整记录
				// 恢复调整记录， 主要是针对重复生成考勤的调整记录被覆盖的问题
				List<UserAttendanceDetailAdjustedEntity> adjustedEntities = getAdjustedAttendEntitiesWithCache(hm_cache, dto);
				UserAttendanceDetailAdjustedEntity currDateAdjustEntity = getCurrDateAdjustEntity(adjustedEntities, dto);
				if(currDateAdjustEntity != null) {
					userAttendanceDetailEntity.setStatus(currDateAdjustEntity.getStatus());
					userAttendanceDetailEntity.setFineTuningType(currDateAdjustEntity.getFineTuningType());
					userAttendanceDetailEntity.setAdjustReason(currDateAdjustEntity.getAdjustReason());
					userAttendanceDetailEntity.setTimeFineTuning(currDateAdjustEntity.getTimeFineTuning());
					
					jsonobj.setPrimevalAttendanceDate(dto.getPrimevalAttendanceDate());
					jsonobj.setPrimevalRetreatDate(dto.getPrimevalRetreatDate());
					jsonobj.setAdjustRecord(1);
					userAttendanceTotalEntity.setAdjustRecord("1");
				}
			}
			
			//设置其他参数 
			userAttendanceDetailEntity.setJsonObj(JSONObject.toJSONString(jsonobj));
			saveOrUpdate(userAttendanceDetailEntity);
			detailEntities.add(userAttendanceDetailEntity);
		}											 
		//设置固定固定餐费补贴
		/**固定餐费补贴*/
		UserWagestrategyEntity userWagestrategy = userWagestrategyService.getUserWagestrategyEntityByUserId(userAttendanceTotalEntity.getUserId());
		Integer fixedValue = null;
		if (null!=userWagestrategy) {
			/**餐补类型*/
			String strategyType=oConvertUtils.getString(userWagestrategy.getStrategyType());
			 if (strategyType.equals("0")) {
				// 0按固定餐补；1按班次餐补
				String temp  =  userWagestrategy.getNofixedmealsSubsidyid();
				 try {
					 fixedValue  = Integer.valueOf(oConvertUtils.getString(temp));
				} catch (Exception e) {
				}
			}
			
		}
		if (null==fixedValue) {
			fixedValue = 0;
		}
		userAttendanceTotalEntity.setFixedValue(fixedValue);
		//更新月度汇总信息
		updateMonthlyInfo(userAttendanceTotalEntity,detailEntities);
	}
	/**
 * @param adjustedEntities
 * @param dto
 * @return
 */
private UserAttendanceDetailAdjustedEntity getCurrDateAdjustEntity(
		List<UserAttendanceDetailAdjustedEntity> adjustedEntities, UserAttendanceDetailDto dto) {
	if(adjustedEntities != null && adjustedEntities.size()>0 && dto != null) {
		for(UserAttendanceDetailAdjustedEntity ae : adjustedEntities) {
			if(dto.getYmdDate().compareTo(ae.getYmdDate()) == 0) {
				return ae;
			}
		}
	}
	return null;
}
	//将dto 中的其他字段信息 转化成jsonString  用于数据库保存
	private AttendanceDetailJsonObj getjsonObjfromDto(UserAttendanceDetailDto dto) {
		AttendanceDetailJsonObj  jsonobj = new AttendanceDetailJsonObj();
		jsonobj.setNoPunchCard(0);
		jsonobj.setAdjustRecord(0);
		jsonobj.setMoneyLeave(false);
		jsonobj.setWorktype(dto.getDtype());
		BigDecimal actDatumDate = dto.getDatumDate();
		if (null==actDatumDate) {
			actDatumDate = BigDecimal.ZERO;
		}
		//设置 早退 状态
		jsonobj.setLeaveEarly(dto.isLeaveEarly());
		//设置 迟到 状态
		jsonobj.setBelate(dto.isBelate());
		//设置 旷工 状态
		jsonobj.setAbsenteeism(dto.getAbsenteeism());
		//设置事假请假的分钟数
		jsonobj.setThingLeaveMins(dto.getThingLeaveMins());
		//设置病假请假的分钟数
		jsonobj.setSickLeaveMins(dto.getSickLeaveMins());
		//设置这一天加过班
		jsonobj.setIhadDuty(dto.isIhadDuty());
		//设置这一天未打卡
		if (oConvertUtils.isNotEmpty(dto.getActattendanceDate())&&
				oConvertUtils.isNotEmpty(dto.getActretreatDate())&&
				dto.getActattendanceDate().equals(dto.getActretreatDate())) {
			//如果上班时间和下班时间相等  则认定为 一次漏打卡
			if (Globals.DUTYTYPE_xiuxi.equals(oConvertUtils.getString(dto.getDutyType()))) {
				//休息的时候 不记录漏打卡
				jsonobj.setNoPunchCard(0);
			 }else {
				 jsonobj.setNoPunchCard(1);
			}
		} 
		jsonobj.setExtraOvertime(dto.getExtraOvertime());
		//如果既没有开始时间 也没有结束时间  切 当前状态为正常的时候记录 漏打卡两次
		if (oConvertUtils.isEmpty(dto.getActattendanceDate())&&
				oConvertUtils.isEmpty(dto.getActretreatDate()) ) {
			if (Globals.DUTYTYPE_xiuxi.equals(oConvertUtils.getString(dto.getDutyType()))) {
				//休息的时候 不记录漏打卡
				jsonobj.setNoPunchCard(0);
			 }else {
				 //正常的需要工作的时候
				 // 判断当天有没有长假期  
				 Boolean longHoliday = dto.getLongHoliday();
				 //没有请长假  切当天没有打卡记录  则记录两次漏打卡
				 if (!longHoliday) {
					 //  如果当天请了事假或者是病假，不记录未打卡  事假和病假 也按照480计算
					if ((!dto.getSickLeaveMins().equals(BigDecimal.ZERO))||
							(!dto.getThingLeaveMins().equals(BigDecimal.ZERO)) ) {
						actDatumDate = new BigDecimal(480);
						jsonobj.setNoPunchCard(0);
					}else {
					//当该员工在没有情况在前提下  没有打卡记录的时候， 实际出勤时间记作480分，避免超时加班时长） 
					actDatumDate = new BigDecimal(480);
					 jsonobj.setMoneyLeave(true);
					 jsonobj.setNoPunchCard(2);
					}
				}
			}
		} 
		//如果这一天又带薪假  将工作状态记录为已请假 
		Boolean longHoliday = dto.getLongHoliday();
		if (longHoliday) {
			 actDatumDate = new BigDecimal(480);
		}
		jsonobj.setActDatumDate(actDatumDate );
		jsonobj.setDayShiftSubsidy(dto.getDayShiftSubsidy());
		jsonobj.setNightShiftSubsidy(dto.getNightShiftSubsidy());
		jsonobj.setDayShift(dto.getDayShift());
		jsonobj.setRegularShift(dto.getRegularShift());
		jsonobj.setDayShiftId(dto.getDayShiftId());
		jsonobj.setNightShiftSubsidyId(dto.getNightShiftSubsidyId());
		jsonobj.setDayShiftSubsidyId(dto.getDayShiftSubsidyId());
		jsonobj.setRegularShiftId(dto.getRegularShiftId());
		return jsonobj;
	}

	//更新月度请假信息
	private void updateMonthlyInfo(
			UserAttendanceTotalEntity userAttendanceTotalEntity,List<UserAttendanceDetailEntity> detailEntities) throws Exception {
		
		/**调整时间*/
		 BigDecimal adjustTime = BigDecimal.ZERO;
		/**总时间差*/
		BigDecimal timeDifferenceTotal= BigDecimal.ZERO;
		/**总加班时间*/
	    BigDecimal overtimeTotalTime= BigDecimal.ZERO;
		/**超时加班时长*/
	    BigDecimal timeoutOvertimeDuration= BigDecimal.ZERO;
		/**国定加班时长*/
	    BigDecimal nationalOvertimeDuration= BigDecimal.ZERO;
		/**特殊加班费*/
	    BigDecimal specialOvertime= BigDecimal.ZERO;
		/**夜班白班津贴*/
	    Integer dayShiftSubsidy= 0;
		/**夜班夜班津贴*/
	    Integer nightShiftSubsidy= 0;
		/**日班*/
	    Integer dayShift= 0;
		/**常班*/
	     Integer regularShift= 0;
		/**额外加班*/
	     Integer extraOvertime= 0;
		/**基准出勤时间*/
	    BigDecimal datumAttendanceDate = BigDecimal.ZERO;
	    /**实际出勤时间*/
	    BigDecimal actualAttendanceDate= BigDecimal.ZERO;
		/** 早退次数 */
		Integer earlyLeaveAmount = 0;
		/** 迟到次数 */
		Integer lateAmount = 0;
		/** 旷工次数 */
		BigDecimal absenteeismAmount = BigDecimal.ZERO;
		/** 未打卡次 */
		Integer noPunchCardAmount = 0;
		/** 带薪假 */
		BigDecimal paidLeave = BigDecimal.ZERO;
		/** 事假 */
		BigDecimal thingLeave = BigDecimal.ZERO;
		/** 病假 */
		BigDecimal sickLeave = BigDecimal.ZERO;
		/** 病假分钟数 */
		BigDecimal sickLeavetotalmins = BigDecimal.ZERO;
		/** 婚假 */
		BigDecimal marriageLeave = BigDecimal.ZERO;
		/** 丧假 */
		BigDecimal funeralLeave = BigDecimal.ZERO;
		/** 产假 */
		BigDecimal maternityLeave = BigDecimal.ZERO;
		/** 陪产假 */
		BigDecimal accompanyMaternityLeave = BigDecimal.ZERO;
		/**请假总时间*/
		BigDecimal leaveTotalTime= BigDecimal.ZERO;
		/**普通值班时长*/
		BigDecimal dutyDuration = BigDecimal.ZERO;
		/**国定值班天数*/
		BigDecimal nationalDutyDuration = BigDecimal.ZERO;
		/**
		 * 月度基准时间合计
		 */
		BigDecimal monthlyActDatumsum = BigDecimal.ZERO;;
		/**
		 * 国定假日排班时长
		 */
		BigDecimal monthlyLegalholidaysum = BigDecimal.ZERO;;
		/**
		 * 月度法定工时天数
		 */
		Integer monthlyLegalworktime = 0;
		 /**
	     * 是否单次临时调动过 0没有调动过；1调动过
	     */
	   String ifmoved = Globals.SHIFOU_01_0;
	   		/**夜班白班津贴主键*/
	 		  String dayShiftSubsidyId = "";
	 		/**夜班夜班津贴主键*/
	 		  String nightShiftSubsidyId= "";
	 		/**日班津贴主键*/
	 		  String dayShiftId= "";
	 		/**常班津贴主键*/
	 		  String regularShiftId= "";
	 	//缓存出勤日期和出勤实体，用于解决请病假却出勤的病假扣除问题
	   HashMap<String, UserAttendanceDetailEntity> hm_Date2AttendanceDetail = new HashMap<String, UserAttendanceDetailEntity>();
	   
		for (UserAttendanceDetailEntity entity:detailEntities) {
			//读取其他字段信息， 变转化成实体类 对其进行相关逻辑判断
			AttendanceDetailJsonObj jsonObj = getJsonObjFromString(oConvertUtils
					.getString(entity.getJsonObj()));
			if (jsonObj.getIhadDuty()) {
				// 把国定值班从值班天数中分离出去 zy 20180416
				if(jsonObj.getWorktype().equals(Globals.dtype_2)) {
					//国定值班
					nationalDutyDuration = nationalDutyDuration.add(BigDecimal.ONE);
				}else {
					//非国定普通加班
					//如果这一天加班了     月度加班总和+1
					dutyDuration = dutyDuration.add(BigDecimal.ONE);
				}
			}
			
			hm_Date2AttendanceDetail.put(DataUtils.date2Str(entity.getYmdDate(), DataUtils.date_sdf), entity);
			//查看当天是否有迟到
			if (jsonObj.getBelate()) {
				lateAmount = lateAmount +1 ;
			}
			//查看当天是否有早退
			if (jsonObj.getLeaveEarly()) {
				earlyLeaveAmount = earlyLeaveAmount +1 ;
			}
			//查看当天是否有旷工
			if (null!=jsonObj.getAbsenteeism() && !jsonObj.getWorktype().equals(Globals.dtype_2)) {
				absenteeismAmount = absenteeismAmount.add(jsonObj.getAbsenteeism());
			}
			//查看月度基准时间
			if (null!=jsonObj.getActDatumDate() /*&& !jsonObj.getWorktype().equals(Globals.dtype_2)*/) {
				monthlyActDatumsum = monthlyActDatumsum.add(jsonObj.getActDatumDate());
			}
			//查看 月度额外加班
			if (null!=jsonObj.getExtraOvertime()) {
				extraOvertime = extraOvertime+jsonObj.getExtraOvertime();
			}
		    
			String  worktype = jsonObj.getWorktype();
			//查看月度国定假日时长
			
			if (null!=worktype) {
				if (worktype.equals(Globals.dtype_2)) {
					//国定休日
					monthlyLegalholidaysum = monthlyLegalholidaysum.add(jsonObj.getActDatumDate());
				}
				if (worktype.equals(Globals.dtype_0)) {
					//工作日
					monthlyLegalworktime++;
				}
			}
			//查看 夜班白班津贴
			if (null!=jsonObj.getDayShiftSubsidy()) {
				dayShiftSubsidy = dayShiftSubsidy+jsonObj.getDayShiftSubsidy();
			}
			//查看夜班夜班津贴
			if (null!=jsonObj.getNightShiftSubsidy()) {
				nightShiftSubsidy = nightShiftSubsidy+jsonObj.getNightShiftSubsidy();
			}
			//查看日班
			if (null!=jsonObj.getDayShift()) {
				dayShift = dayShift+jsonObj.getDayShift();
			}
			//查看 常班 
			if (null!=jsonObj.getRegularShift()) {
				regularShift = regularShift+jsonObj.getRegularShift();
			}
			if(isPayLeave(entity)) {
				//年假等带薪假+8小时
				datumAttendanceDate = datumAttendanceDate.add(new BigDecimal(8*60));
			}else if (null!=entity.getDatumDate()) {
		        // add by zy 20180413
				// 刨除国定假
				// 在计算应出勤时间是已经处理过国定时间 -zy 20180513
				if(null!=worktype /*&& !worktype.equals(Globals.dtype_2)*/) {
					datumAttendanceDate = datumAttendanceDate.add(entity.getDatumDate());
				}
			}
			//查看员工的  实际出勤时间
			if(isPayLeave(entity)) {
				//年假等带薪假+8小时
				actualAttendanceDate = actualAttendanceDate.add(new BigDecimal(8*60));
			}else if (null!=entity.getActualAttendanceDate()) {
				 // add by zy 20180413
				// 刨除国定假
				// 直接减掉国定加班时长
				if(null!=worktype /*&& !worktype.equals(Globals.dtype_2))*/) {
					actualAttendanceDate = actualAttendanceDate.add(entity.getActualAttendanceDate());
					if(entity.getNationalOvertimeDuration() != null && entity.getNationalOvertimeDuration().compareTo(BigDecimal.ZERO)>0) {
						actualAttendanceDate =actualAttendanceDate.subtract(entity.getNationalOvertimeDuration());
					}
				}
			}
			//查看员工的 国定加班时长
			if (null!=entity.getNationalOvertimeDuration()) {
				nationalOvertimeDuration = nationalOvertimeDuration.add(entity.getNationalOvertimeDuration());
			}
			//查看员工的 临时借调状态
			if (null!=entity.getBorrowstatus()&&"1".equals(entity.getBorrowstatus())) {
				ifmoved =Globals.SHIFOU_01_1;
			}
			//查看员工的 时间差值
			if (null!=entity.getTimeDifference()) {
				timeDifferenceTotal = timeDifferenceTotal.add(entity.getTimeDifference());
			}
			//查看员工的 特殊加班费
			if (null!=entity.getSpecialOvertime()) {
				specialOvertime = specialOvertime.add(entity.getSpecialOvertime());
			}
			//查看员工的 时间微调
			if (null!=entity.getTimeFineTuning()) {
				adjustTime = adjustTime.add(entity.getTimeFineTuning());
			}
			//查看当天是否有未打卡
			if (null!=jsonObj.getNoPunchCard()) {
				noPunchCardAmount = noPunchCardAmount +jsonObj.getNoPunchCard() ;
			}
			/*//这一天状态是事假   事假统计分钟数
			if (entity.getStatus().equals(Globals.ATTENDANCE_STATUS_EDIT_0)) {
				BigDecimal thingLeaveMins =jsonObj.getThingLeaveMins();
				if (null==thingLeaveMins) {
					thingLeaveMins = BigDecimal.ZERO;
				}
				thingLeave = thingLeave.add(thingLeaveMins);
			}*/
			 //这一天状态是病假   月度病假数+1
			if (entity.getStatus().equals(Globals.ATTENDANCE_STATUS_EDIT_1)) {
				/*BigDecimal sickLeaveMins =jsonObj.getSickLeaveMins();
				if (null==sickLeaveMins) {
					sickLeaveMins = BigDecimal.ZERO;
				}*/
				sickLeave = sickLeave.add( BigDecimal.ONE);
				//sickLeavetotalmins = sickLeavetotalmins.add(sickLeaveMins);
			} 
			//这一天状态是年假？ 年假就是带薪假
			if (entity.getStatus().equals(Globals.ATTENDANCE_STATUS_EDIT_2)) {
				paidLeave = paidLeave.add(BigDecimal.ONE);
			}
			//这一天状态是丧假 月度丧假数+1
			if (entity.getStatus().equals(Globals.ATTENDANCE_STATUS_EDIT_3)) {
				funeralLeave = funeralLeave.add(BigDecimal.ONE);
			}
			//这一天状态是婚假 月度婚假数+1
			if (entity.getStatus().equals(Globals.ATTENDANCE_STATUS_EDIT_4)) {
				marriageLeave = marriageLeave.add(BigDecimal.ONE);
			}
			//这一天状态是产假 月度产假数+1
			if (entity.getStatus().equals(Globals.ATTENDANCE_STATUS_EDIT_5)) {
				maternityLeave = maternityLeave.add(BigDecimal.ONE);
			}
			//这一天状态是陪产假  月度陪产假数+1
			if (entity.getStatus().equals(Globals.ATTENDANCE_STATUS_EDIT_6)) {
				accompanyMaternityLeave = accompanyMaternityLeave.add(BigDecimal.ONE);
			}
			//这一天状态是法定假日   法定假日也归属于带薪假
			if (entity.getStatus().equals(Globals.ATTENDANCE_STATUS_EDIT_11)) {
				paidLeave = paidLeave.add(BigDecimal.ONE);
			}
		}
		
		// =====查询请假情况
		String yearmonth=userAttendanceTotalEntity.getYearmonth();
		String userid = userAttendanceTotalEntity.getUserId();
		String ymdDate = yearmonth+"-01";
		Calendar calendar = Calendar.getInstance();
		Date endDate = DataUtils.str2Date(ymdDate, DataUtils.date_sdf);
		calendar.setTime(endDate);
		calendar.add(Calendar.DATE, -1);
		// 上个月的最后一天
		String lastmonthlatestday = DataUtils.date2Str(endDate,  DataUtils.date_sdf);
		calendar.add(Calendar.DATE, 1);
		//这个月的第一天
		String monthfirstday = DataUtils.date2Str(endDate,  DataUtils.date_sdf);
		calendar.add(Calendar.MONTH, 1);
		endDate = calendar.getTime();
		//下个月的第一天
		String nextmonthfirstday = DataUtils.date2Str(endDate,  DataUtils.date_sdf);
		calendar.add(Calendar.DATE, -1);
		endDate = calendar.getTime();
		//这个月的最后一天
		String monthlatestday = DataUtils.date2Str(endDate,  DataUtils.date_sdf);
		
		List<HolidayEntity> userHolidayEntities = holidayService
				.getUserHolidayEntities(userid, yearmonth);
		if (null==userHolidayEntities) {
			userHolidayEntities = new ArrayList<HolidayEntity>();
		}
		for (HolidayEntity  holiday:userHolidayEntities) {
			String hilidaytype =oConvertUtils.getString( holiday.getHolidayType());
			BigDecimal holidayDuration= holiday.getHolidayDuration();
			Date holidayStime=	holiday.getHolidayStime();
			Date holidayEtime=	holiday.getHolidayEtime();
			//如果开始时间 和结束时间为空// 跳过
			if (null==holidayStime||null==holidayEtime) {
				continue;
			}
			//请假类型不是事假  也不是病假  跳过  不做处理
			if (!(Globals.REST_TYPE_1.equals(hilidaytype)|| Globals.REST_TYPE_0.equals(hilidaytype))) { 
				continue;
			}
			String  holidaySdate = DataUtils.date2Str(holidayStime, DataUtils.date_sdf);
			String  holidayEdate = DataUtils.date2Str(holidayEtime, DataUtils.date_sdf);
			//如果结束日期晚于下月一号    跳过
			if (holidayEdate.compareTo(nextmonthfirstday)>0) {
				continue;
			}
			/* 此处处理逻辑混乱, 注释不知所云. 暂且去掉. 20180702 xzx
			// 如果请假开始日期 等于本月的一号  切请假结束日期也是本月的一号  
			if (holidaySdate.equals(monthfirstday)&&holidayEdate.equals(monthfirstday)) {
				//判断上月的最后一天 是否为夜班
				List<UserAttendanceDetailDto>   yestoryday = userAttendanceDetailDao.
						getlistbyProjarrangeDetailid(null,userid,lastmonthlatestday);
					if (!ListUtils.isNullOrEmpty(yestoryday)) {
						UserAttendanceDetailDto ydto =  yestoryday.get(0);
						if (Globals.DUTYTYPE_yeban115.equals(oConvertUtils.getString(ydto.getDutyType()))) {
						//如果上月的最后一天是夜班， 则将该事假/病假  记录
						}else {
							//如果上月的最后一天不是夜班， 则将该事假/病假  记录
							continue;
						}
					} 
			 }
			// 如果请假开始日期 等于下个月的一号  切请假结束日期也是下个月的一号  
			if (holidaySdate.equals(nextmonthfirstday)&&holidayEdate.equals(nextmonthfirstday)) {
				//判断本月的最后一天 是否为夜班
				List<UserAttendanceDetailDto>   yestoryday = userAttendanceDetailDao.
						getlistbyProjarrangeDetailid(null,userid,monthlatestday);
					if (!ListUtils.isNullOrEmpty(yestoryday)) {
						UserAttendanceDetailDto ydto =  yestoryday.get(0);
						if (Globals.DUTYTYPE_yeban115.equals(oConvertUtils.getString(ydto.getDutyType()))) {
						//如果本月的最后一天是夜班， 则将该事假/病假  记录
						}else {
							//如果本月的最后一天不是夜班， 则将该事假/病假  记录
							continue;
						}
					}
			}
			*/
			//对  每天请假时长 非空处理
			if (oConvertUtils.isEmpty(holidayDuration)) {
				holidayDuration = BigDecimal.ZERO;
			}
			//对  每天请假时长 进行单位转换： 小时--> 分钟
			holidayDuration = holidayDuration.multiply(new BigDecimal(60));
			Calendar dd = Calendar.getInstance();
			dd.setTime(holidayStime);
			while(dd.getTime().compareTo(holidayEtime)<=0) {
				UserAttendanceDetailEntity temp_entity = hm_Date2AttendanceDetail.get(DataUtils.date2Str(dd.getTime(), DataUtils.date_sdf));
				if(temp_entity != null && temp_entity.getActualAttendanceDate() != null && temp_entity.getActualAttendanceDate().compareTo(BigDecimal.ZERO)>0) {
					if (temp_entity.getStatus().equals(Globals.ATTENDANCE_STATUS_EDIT_10)) {
						holidayDuration = holidayDuration.subtract(temp_entity.getActualAttendanceDate());
						if(holidayDuration.compareTo(BigDecimal.ZERO)<0) {
							holidayDuration = BigDecimal.ZERO;
						}
					}
				}
				dd.add(Calendar.DATE, 1);
			}
			
			if (Globals.REST_TYPE_1.equals(hilidaytype) ) {
				sickLeavetotalmins =	sickLeavetotalmins.add(holidayDuration);
			}else if (  Globals.REST_TYPE_0.equals(hilidaytype)) { 
				thingLeave = thingLeave.add(holidayDuration);
			}
		}
		//超时加班时长计算  月度基准时间-国定假日排班时长 -带薪休假时长-法定工时   ---原算法，新算法是月基准时间-法定工时然后抵扣旷工时长  zy20180416
		//月度法定工时=（当月天数-休假天数-国定休假天数）*8；datumAttendanceDate 
//		timeoutOvertimeDuration=  monthlyActDatumsum.subtract(monthlyLegalholidaysum)
//				.subtract(new BigDecimal(monthlyLegalworktime*8*60));
//      2018年11月15日前的算法是169应出勤时间-月度法定工时		
//		timeoutOvertimeDuration=  datumAttendanceDate.subtract(new BigDecimal(monthlyLegalworktime*8*60));//xzx
		
		//2018年11月15日后的算法是实际出勤时间-法定工时，这里面实际出勤时间包含漏打卡时间 //xzx
		timeoutOvertimeDuration=  actualAttendanceDate.subtract(new BigDecimal(monthlyLegalworktime*8*60));
		// 记录抵扣前的原始的超时加班时长和旷工时长
		if(timeoutOvertimeDuration == null) {
			userAttendanceTotalEntity.setTimeoutOvertimeDuration_orig(BigDecimal.ZERO);
		}else {
			userAttendanceTotalEntity.setTimeoutOvertimeDuration_orig(timeoutOvertimeDuration);
		}
		if(absenteeismAmount == null) {
			absenteeismAmount = BigDecimal.ZERO; 
			userAttendanceTotalEntity.setAbsenteeismAmount_orig(BigDecimal.ZERO);
		}else {
			userAttendanceTotalEntity.setAbsenteeismAmount_orig(absenteeismAmount);
		}
		// 负数归零
		// 2019/2/11 超时加班时长负数代表没有做满法定工时
//		if(timeoutOvertimeDuration.compareTo(BigDecimal.ZERO) < 0) {
//			timeoutOvertimeDuration = BigDecimal.ZERO; 
//		}
		
		if(absenteeismAmount.compareTo(BigDecimal.ZERO) < 0) {
			absenteeismAmount = BigDecimal.ZERO; 
		}
		
		//旷工工时和超时加班工时进行相互抵扣 zy20180415 
		// 2019/2/11由于超时加班采用实际出勤时间来计算，故不存在抵扣
//		if(timeoutOvertimeDuration.compareTo(absenteeismAmount) == 0) {
//		//旷工工时等于超时加班工时	
//			timeoutOvertimeDuration = BigDecimal.ZERO;
//			absenteeismAmount = BigDecimal.ZERO;
//		}else if(timeoutOvertimeDuration.compareTo(absenteeismAmount) > 0) {
//		//超时加班工时多
//			timeoutOvertimeDuration = timeoutOvertimeDuration.subtract(absenteeismAmount);
//			absenteeismAmount = BigDecimal.ZERO;
//		}else {
//		//旷工工时多
//			absenteeismAmount = absenteeismAmount.subtract(timeoutOvertimeDuration);
//			timeoutOvertimeDuration = BigDecimal.ZERO; 
//		}
			
		
//		/**
//		 * 超时加班时长  当小于零的时候， 按 零存储
//		 */
//		if (timeoutOvertimeDuration.compareTo(BigDecimal.ZERO)<0) {
//			timeoutOvertimeDuration = BigDecimal.ZERO;
//		}
		userAttendanceTotalEntity.setPaidLeave(paidLeave);
		userAttendanceTotalEntity.setThingLeave(thingLeave);
		userAttendanceTotalEntity.setSickLeave(sickLeave);
		userAttendanceTotalEntity.setMarriageLeave(marriageLeave);
		userAttendanceTotalEntity.setFuneralLeave(funeralLeave);
		userAttendanceTotalEntity.setMaternityLeave(maternityLeave);
		 
		leaveTotalTime = thingLeave.add(sickLeavetotalmins)
				.add((paidLeave
				.add(marriageLeave)
				.add(funeralLeave)
				.add(maternityLeave)
				.add(accompanyMaternityLeave)).multiply(new BigDecimal(8*60)));

		userAttendanceTotalEntity.setLeaveTotalTime(leaveTotalTime);
		userAttendanceTotalEntity.setAccompanyMaternityLeave(accompanyMaternityLeave);
		userAttendanceTotalEntity.setDutyDuration(dutyDuration);
		userAttendanceTotalEntity.setNationalDutyDuration(nationalDutyDuration);
		userAttendanceTotalEntity.setEarlyLeaveAmount(earlyLeaveAmount);
		userAttendanceTotalEntity.setLateAmount(lateAmount);
		userAttendanceTotalEntity.setAbsenteeismAmount(absenteeismAmount);
		userAttendanceTotalEntity.setNoPunchCardAmount(noPunchCardAmount);
		userAttendanceTotalEntity.setDatumAttendanceDate(datumAttendanceDate);
		userAttendanceTotalEntity.setActualAttendanceDate(actualAttendanceDate);
		/**调整时间*/
		userAttendanceTotalEntity.setAdjustTime(adjustTime);
		/**超时加班时长*/
	    userAttendanceTotalEntity.setTimeoutOvertimeDuration(timeoutOvertimeDuration);
		/**国定加班时长*/
	    userAttendanceTotalEntity.setNationalOvertimeDuration(nationalOvertimeDuration);
	    /**总时间差*/
	    userAttendanceTotalEntity.setTimeDifferenceTotal(timeDifferenceTotal);
		/**特殊加班费*/
	    userAttendanceTotalEntity.setSpecialOvertime(specialOvertime);
	    /**总加班时间*/
	    overtimeTotalTime = timeoutOvertimeDuration.add(nationalOvertimeDuration).add(specialOvertime);
	    // 当总加班时间小于零的时候  以零处理
	 		if (overtimeTotalTime.compareTo(BigDecimal.ZERO)<0) {
	 			overtimeTotalTime = BigDecimal.ZERO;
	 		}
	    userAttendanceTotalEntity.setOvertimeTotalTime(overtimeTotalTime);
	    /**夜班白班津贴*/
	    userAttendanceTotalEntity.setDayShiftSubsidy(dayShiftSubsidy);
		/**夜班夜班津贴*/
	    userAttendanceTotalEntity.setNightShiftSubsidy(nightShiftSubsidy);
		/**日班*/
	    userAttendanceTotalEntity.setDayShift(dayShift);
		/**常班*/
	    userAttendanceTotalEntity.setRegularShift(regularShift);
		/** 额外加班 */
		userAttendanceTotalEntity.setExtraOvertime(extraOvertime);
		/** 是否单次临时调动过 */
		userAttendanceTotalEntity.setIfmoved(ifmoved);
		AttendanceTotalJsonObj json = new AttendanceTotalJsonObj();
		json.setSickLeavetotalmins(sickLeavetotalmins);
		userAttendanceTotalEntity.setJsonObj(JSONObject.toJSONString(json));
	   saveOrUpdate(userAttendanceTotalEntity);
	}
	
/**
 * 判断是否是带薪假
 * @param entity
 * @return
 */
private boolean isPayLeave(UserAttendanceDetailEntity entity) {
	if (entity.getStatus().equals(Globals.ATTENDANCE_STATUS_EDIT_2)) {
		return true;
	}
	if (entity.getStatus().equals(Globals.ATTENDANCE_STATUS_EDIT_3)) {
		return true;
	}
	if (entity.getStatus().equals(Globals.ATTENDANCE_STATUS_EDIT_4)) {
		return true;
	}
	if (entity.getStatus().equals(Globals.ATTENDANCE_STATUS_EDIT_5)) {
		return true;
	}
	if (entity.getStatus().equals(Globals.ATTENDANCE_STATUS_EDIT_6)) {
		return true;
	}
	return false;
}
/**
 * 将从数据库中读取的字符串信息转化成实体类
 * 需求變更： 2018年1月12日17:30:17
 *  当员工两次都没打卡的时候， 默认界定为该员工旷工， 此时不提供餐补
 * @author hualong.zhao
 * @date 2017-11-29
 * 
 * @param jsonobjString
 * @return
 */
	@Override
	public AttendanceDetailJsonObj getJsonObjFromString(String jsonobjString) {
		AttendanceDetailJsonObj jsonObj  = new AttendanceDetailJsonObj();
		if (oConvertUtils.isNotEmpty(jsonobjString)) {
			try {
				jsonObj = (JSONObject.parseObject(jsonobjString)).toJavaObject(AttendanceDetailJsonObj.class);
			} catch (Exception e) {
			}
			
			}
		return jsonObj;
	}

	/*记一次迟到情况：
	出勤时间>排班工作开始时间；并且10分钟＜两者之差≤30分钟；*/
	/*当月的迟到次数累计	迟到：10min之内不算迟到，10＜min≤30  算迟到，min＞30 算旷工半天；
	当天请事假,也得考察迟到；*/
	private void calculateBelateAndLeaveEarlyAndabsenteeism(
			UserAttendanceDetailDto dto) {
		//判断当天是否请了长假期
		boolean longHoliday = dto.getLongHoliday();
		//实际上班时间
		Date   actattendanceDate = dto.getActattendanceDate();;
		//实际下班时间
		Date   actretreatDate= dto.getActretreatDate();
		String dutyType = oConvertUtils.getString(dto.getDutyType());
		//前提条件：  如果排班为休息时 ， 不考虑  迟到 / 早退 / 旷工 
		if (!Globals.DUTYTYPE_xiuxi.equals(dutyType)) {
			//当班次为加班  或者是值班时  不考虑 迟到 / 早退
			if (oConvertUtils.isNotEmpty(dto.getNormalworkStime())&&oConvertUtils.isNotEmpty(dto.getNormalworkEtime())) {
				 /**理应工作开始时间*/
				 Date workStarttime =getexactDate(dto.getYmdDate(), dto.getNormalworkStime(), 0, 0);
				 /**理应工作结束时间*/
				 Integer t1flag = 0;
				boolean hassickorthingLeave = false;
				 if (Globals.DUTYTYPE_yeban115.equals(dutyType)) {
					 t1flag = 1;
				 }
				 Date workendtime =  getexactDate(dto.getYmdDate(), dto.getNormalworkEtime(), t1flag, 0);
				// =====查询请假情况, 去掉事假的加班申请时长，计算理应的开始和结束工作时间  如果员工在这一天请了非事假意外的假  不认为该员工旷工 /迟到/早退
				List<HolidayEntity> userHolidayEntities = dto.getUserHolidayEntities();
				if (!ListUtils.isNullOrEmpty(userHolidayEntities)) {
					for (HolidayEntity holiday:userHolidayEntities) {
						String hilidaytype =oConvertUtils.getString( holiday.getHolidayType());
						if (Globals.REST_TYPE_1.equals(hilidaytype)||Globals.REST_TYPE_0.equals(hilidaytype)) {
							BigDecimal holidayDuration= calculateHolidayDuration(holiday,workStarttime,workendtime,dto);
							/**休假开始时间*/
							 Date holidayStime = holiday.getHolidayStime();
							 /**休假结束时间*/
							 Date holidayEtime = holiday.getHolidayEtime();
								if (holidayStime.compareTo(workStarttime)<=0&&holidayEtime.compareTo(workStarttime)>=0) {
									 workStarttime = holidayEtime;
								}
								if (holidayStime.compareTo(workendtime)<=0&&holidayEtime.compareTo(workendtime)>=0) {
									workendtime = holidayStime;
								}
							BigDecimal datumDate = dto.getDatumDate();
							//如果休假表中填写的申请假期时长 大于当天的基准时间  是按照基准时间处理
							holidayDuration = holidayDuration.compareTo(datumDate)>0?datumDate:holidayDuration;
							if(dto.getActualAttendanceDate() != null && dto.getActualAttendanceDate().compareTo(BigDecimal.ZERO)>0) {
								// 如果当天有实际出勤时间，那么从请假中扣除
								holidayDuration = holidayDuration.subtract(dto.getActualAttendanceDate());
							}
							if (Globals.REST_TYPE_1.equals(hilidaytype)) {
								dto.setSickLeaveMins(holidayDuration);
							}else {
								// 修改为  改天请假的 小时数 这算的分钟数
								dto.setThingLeaveMins(holidayDuration);
							}
							hassickorthingLeave = true;
						}else {
							dto.setLeaveEarly(false);
							dto.setBelate(false);
							dto.setAbsenteeism(BigDecimal.ZERO);
							longHoliday = true;
							break;
						}
					}
				}
				//如果请了事假之外的假期， 则认为该员工没有迟到  没有早退 没有旷工
				//如果是国定假出现缺勤，不算旷工
				if (!longHoliday && !Globals.dtype_2.equals(oConvertUtils.getString(dto.getDtype()))) {
					//如果两个打卡时间均为空， 则该员工旷工（前提条件是该员工没有请事假或者是病假）
					if (!hassickorthingLeave) {
						if (oConvertUtils.isEmpty(actattendanceDate)&&oConvertUtils.isEmpty(actretreatDate)) {
							// 当员工两次都没打卡的时候， 界定为该员工旷工， 此时不提供餐补
							dto.setAbsenteeism(dto.getDatumDate());
						} 
					}
					//计算是否为迟到   或者是早旷工
					if (oConvertUtils.isNotEmpty(actattendanceDate)&&actattendanceDate.after(workStarttime)) {
						// 实际上班时间
						Calendar actattendanceCalendar = Calendar.getInstance();
						actattendanceCalendar.setTime(actattendanceDate);
						// 理论应该工作时间
						Calendar workStartCalendar = Calendar.getInstance();
						workStartCalendar.setTime(workStarttime);
						int dateDiffint = DataUtils.dateDiff('m', actattendanceCalendar,workStartCalendar);
						if (actattendanceDate.equals(actretreatDate)) {
							// 如果開始時間等於结束时间  则定义为该员工漏打卡  ， 此时 不计算欠勤时间
							dateDiffint = 0;
						}
						dto.setBelatemins(dateDiffint);
						//出勤时间>排班工作开始时间；并且10分钟＜两者之差≤30分钟；
						if (dateDiffint>10&&dateDiffint<=30) {
							dto.setBelate(true);
						}
						//迟到，min＞30 切小于240分钟 算旷工4小时
						if (dateDiffint>30&&dateDiffint<240) {
							BigDecimal  absenteeism = dto.getAbsenteeism().add(new BigDecimal(240));
							dto.setAbsenteeism(absenteeism);
						}
						//迟到，min>=240&&dateDiffint<480 算旷工8小时
						if(dateDiffint>=240&&dateDiffint<480) {
							BigDecimal  absenteeism = dto.getAbsenteeism().add(new BigDecimal(480));
							dto.setAbsenteeism(absenteeism);
						}
						//迟到，min＞=480 算旷工实际班次工时
						if (dateDiffint>=480) {
							BigDecimal  absenteeism = dto.getAbsenteeism().add(new BigDecimal(dateDiffint));
							dto.setAbsenteeism(absenteeism);
						}
						
					}
					if (oConvertUtils.isNotEmpty(actretreatDate)
							&& oConvertUtils.isNotEmpty(actattendanceDate)
							&& actretreatDate.after(actattendanceDate)
							&& actretreatDate.before(workendtime)) {
						// 实际下班时间
						Calendar actretreatCalendar = Calendar.getInstance();
						actretreatCalendar.setTime(actretreatDate);
						// 理论应该下班时间
						Calendar workendCalendar = Calendar.getInstance();
						workendCalendar.setTime(workendtime);
						int dateDiffint = DataUtils.dateDiff('m',workendCalendar, actretreatCalendar);
						if (actattendanceDate.equals(actretreatDate)) {
							// 如果開始時間等於结束时间  则定义为该员工漏打卡  ， 此时 不计算欠勤时间
							dateDiffint = 0;
						}
						dto.setLeaveEarlymins(dateDiffint);
						//出勤时间>排班工作开始时间；并且10分钟＜两者之差≤30分钟；
						if (dateDiffint>10&&dateDiffint<=30) {
							dto.setLeaveEarly(true);
						}
						//迟到，min＞30 切小于240分钟 算旷工4小时
						if (dateDiffint>30&&dateDiffint<240) {
							BigDecimal  absenteeism = dto.getAbsenteeism().add(new BigDecimal(240));
							dto.setAbsenteeism(absenteeism);
						}
						//迟到，min>=240&&dateDiffint<480 算旷工8小时
						if(dateDiffint>=240&&dateDiffint<480) {
							BigDecimal  absenteeism = dto.getAbsenteeism().add(new BigDecimal(480));
							dto.setAbsenteeism(absenteeism);
						}
						//迟到，min＞=480 算旷工实际班次工时
						if (dateDiffint>=480) {
							BigDecimal  absenteeism = dto.getAbsenteeism().add(new BigDecimal(dateDiffint));
							dto.setAbsenteeism(absenteeism);
						}
					}
					
//					BigDecimal  absenteeism = dto.getAbsenteeism();
//					if (absenteeism.compareTo(new BigDecimal(8))>=0) {
//						dto.setLeaveEarly(false);
//						dto.setBelate(false);
//						dto.setAbsenteeism(new BigDecimal(8));
//					}
					// 如果漏打卡： 打卡开始时间等于打卡结束时间  这个时候 只计算迟到和早退   旷工按零计算
					if (oConvertUtils.isNotEmpty(actattendanceDate)
							&& oConvertUtils.isNotEmpty(actretreatDate)
							&& actattendanceDate.equals(actretreatDate)) {
						dto.setAbsenteeism(BigDecimal.ZERO);
					}
				}
			}else {
				// 当加班/值班 的时候      不迟到  也不早退   也不认为该员工旷工
 			}
		}
		dto.setLongHoliday(longHoliday);
	}
/**FIXME 有待校验
 * 动态计算  事假/病假的分钟数
 * @author hualong.zhao
 * @date 2018-1-10
 * @param holiday
 * @param workStarttime
 * @param workendtime
 * @param dto 
 * @param dto
 * @return
 */
	private BigDecimal calculateHolidayDuration(HolidayEntity holiday,
			Date workStarttime, Date workendtime, UserAttendanceDetailDto dto) {
		BigDecimal holidayDuration=BigDecimal.ZERO;
		/**休假开始时间*/
		 Date holidayStime = holiday.getHolidayStime();
		 /**休假结束时间*/
		 Date holidayEtime = holiday.getHolidayEtime();
		 Date startmax =workStarttime;
		 Date endmin =workendtime;
		 if (workStarttime.compareTo(holidayStime) <= 0
					&& holidayStime.compareTo(workendtime) <= 0){
			 startmax = holidayStime;
		 }
		 if (workStarttime.compareTo(holidayEtime) <= 0
					&& holidayEtime.compareTo(workendtime) <= 0){
			 endmin =holidayEtime;
		 }
		String  durationCode = "0";
		 //如果请假开始时间小于等于上班开始时间 且请假结束时间早于下班时间  则认为该员工请的假期为前半夜假期
		 if (holidayStime.compareTo(workStarttime) <= 0
			&& holidayEtime.compareTo(workendtime) <0){
			 durationCode = "1";
		 }
		 //如果请假开始时间大于上班开始时间  且请假结束时间等于或者是晚于下班时间  则认为该员工请的假期为后半夜假期
		 if (workStarttime.compareTo(holidayStime ) < 0
			&&workendtime.compareTo(holidayEtime) <=0) {
			 durationCode = "2";
		}
		dto.setDurationCode(durationCode);
		// 时间段开始时间
			Calendar startCalendar = Calendar.getInstance();
			startCalendar.setTime(startmax);
			// 时间段结束时间
			Calendar endCalendar = Calendar.getInstance();
			endCalendar.setTime(endmin);
			int startDiffint = DataUtils.dateDiff('m', endCalendar,startCalendar);
			holidayDuration = new BigDecimal(Math.abs(startDiffint));
		return holidayDuration;
	}
	/**设置基准时间
	 * 排班计划中的： 正常工作基准工时 每日的排班的基准时间 排班信息：获取员工当日的排班基准时间；
	 * 根据“月度员工排班”中的员工排班情况，获取每日的班次； 根据“班次设定”中的“基准时间”获取每日的基准时长；
	 * 
	 * 
	 * 
	 * 请婚假、丧假、带薪假、陪产假情况下，计算超时加班时长=月度基准时长-法定工时，其中请假当天的月度基准时长要按照8小时累计
	 * @param hm_cache 
	 */
	private void calculateDatumDate(HashMap<String, HashMap<String, Object>> hm_cache, UserAttendanceDetailDto dto) {
		// 基准时间 
		BigDecimal datumDate = BigDecimal.ZERO;
		
		if (Globals.DUTYTYPE_yeban115.equals(dto.getDutyType())) {
			//如果是跨日期夜班，需要判断是否有国定时间，有的话要刨除 -zy 20180513
			BigDecimal yebanNationalDuration = calculateHalfNationalOvertime(hm_cache, dto,false);
			if(yebanNationalDuration.compareTo(BigDecimal.ZERO) >= 0) {
				datumDate = new BigDecimal(11.5*60).subtract(yebanNationalDuration);
			}
		}else if(Globals.dtype_2.equals(oConvertUtils.getString(dto.getDtype()))) {
			//如果是国定排班，且不跨夜
			datumDate = BigDecimal.ZERO;
		}else {
			BigDecimal datumWorkhours = dto.getDatumWorkhours();
			
			if (null != datumWorkhours) {
				datumDate = datumWorkhours.multiply(new BigDecimal(60));
			}
		}
		
		dto.setDatumDate(datumDate);
	}

	/**
	 * 获取借调信息 疑问点： 1 当某人处于周期临时借调中时， 刚好这一天又有单次临时借调， 这个怎么处置？ （目前在临时借调处没有限制） 2 同一天，
	 * 某人即被A部门临时借调， 又被B部门临时借调， 算哪一天
	 * 
	 * 
	 * 
	 * @author hualong.zhao
	 * @date 2017-11-25
	 * @param dto
	 */
	private void calculateBorrowsInfo(UserAttendanceDetailDto dto) {
		// 借调状态；0未借调，1单次借调 2 周期性临时借调
		String borrowstatus = "0";
		// 借调项目id
		String borrowspid = null;
		// 借调部门id 对应的是临时借调表中的调入单位id
		String borrowsdepartid = null;
		// 单次借调日薪
		BigDecimal dayPay = null;
		// 01 临时借调（单次）申请表
		List<SnapSingleborrowEntity> snapSingleborrowEntities = dto
				.getSnapSingleborrowEntities();
		// 02 临时借调（固定周期）申请表
		List<SnapRegularborrowEntity> snapRegularborrowEntities = dto
				.getSnapRegularborrowEntities();

		if (!ListUtils.isNullOrEmpty(snapRegularborrowEntities)) {
			borrowstatus = "2";
			for (SnapRegularborrowEntity entity : snapRegularborrowEntities) {
				// 临时借调表中的调入单位id
				borrowsdepartid = entity.getInUnitid();
				TSDepart tsDepart = getQyDepartByorgid(borrowsdepartid);
				if (oConvertUtils.isEmpty(tsDepart)||oConvertUtils.isEmpty(tsDepart.getId())) {
				}else {
					borrowspid = tsDepart.getId();
				} 
			}
		}
		if (!ListUtils.isNullOrEmpty(snapSingleborrowEntities)) {
			borrowstatus = "1";
			for (SnapSingleborrowEntity entity : snapSingleborrowEntities) {
				// 临时借调表中的调入单位id
				borrowspid = entity.getInUnitid();
			 // 查询当前员工的区域组织机构 
				TSDepart tsDepart = getQyDepartByorgid(borrowspid);
				if (oConvertUtils.isEmpty(tsDepart)||oConvertUtils.isEmpty(tsDepart.getId())) {
				}else {
					borrowspid = tsDepart.getId();
				} 
				borrowsdepartid = entity.getInUnitid();
//--author:zhaohualong-----start----date: 2018年1月19日--------for: 需求确认： 当且仅当是工作日的时候 才允许给该员工单日的日付薪------
				if (oConvertUtils.getString(dto.getDtype()).equals(Globals.dtype_0)) {
					dayPay = entity.getDayPay();
				}
			}
		}
		dto.setBorrowstatus(borrowstatus);
		dto.setBorrowspid(borrowspid);
		dto.setBorrowsdepartid(borrowsdepartid);
		dto.setDayPay(dayPay);
	}
	/**
	 * 根据组织机构id  获取项目 （直属项目  or  区域项目）
	 * @author hualong.zhao
	 * @date 2018-1-17
	 * @param orgid
	 * @return
	 */
	private TSDepart getQyDepartByorgid(String orgid) {
		if (oConvertUtils.isEmpty(orgid)) {
			return null;
		}
		TSDepart tsDepart = get(TSDepart.class, orgid);
		if (tsDepart.getOrgType().equals(Globals.org_type_3)||tsDepart.getOrgType().equals(Globals.org_type_5)) {
			return tsDepart;
		} else {
			TSDepart parentdepart = tsDepart.getTSPDepart();
			if (oConvertUtils.isEmpty(parentdepart)||oConvertUtils.isEmpty(parentdepart.getId())) {
				return null;
			} else {
				return getQyDepartByorgid(tsDepart.getTSPDepart().getId());
			}
		}
	}
	/**
	 * 
	 * 
	 * new*
1 如果"考勤退勤时间"晚于"排班基准时间"的"结束时间"，并且"考勤出勤时间"早于"排班基准时间"的"开始时间"：（未早退也未迟到） 
  实际出勤时间="排班基准时间"；（未更改） 
2如果"考勤退勤时间"早于"排班基准时间"的"结束时间"，并且"考勤出勤时间"早于"排班基准时间"的"开始时间"：（早退 但是没有迟到） 
  实际出勤时间=排班基准时间-早退的分钟数 
3 如果"考勤退勤时间"晚于"排班基准时间"的"结束时间"，并且"考勤出勤时间"晚于"排班基准时间"的"开始时间"：（迟到 但是没有早退） 
  实际出勤时间=排班基准时间-迟到的分钟数 
4 如果"考勤退勤时间"早于"排班基准时间"的"结束时间"，并且"考勤出勤时间"晚于"排班基准时间"的"开始时间"：（有迟到 也有早退） 
  实际出勤时间= 排班基准时间-(早退的分钟数"+迟到的分钟数)；
	 * old
	 * 根据实际考勤记录计算的时间 如果“考勤退勤时间”晚于“排班基准时间”的“结束时间”，并且“考勤出勤时间”早于“排班基准时间”的“开始时间”：
	 * 实际出勤时间=“排班基准时间”； 如果“考勤退勤时间”早于“排班基准时间”的“结束时间”，并且“考勤出勤时间”早于“排班基准时间”的“开始时间”：
	 * 实际出勤时间=“考勤退勤时间”-“排班基准时间”的开始时间；
	 * 如果“考勤退勤时间”晚于“排班基准时间”的“结束时间”，并且“考勤出勤时间”晚于“排班基准时间”的“开始时间”：
	 * 实际出勤时间=“排班基准时间”的结束时间-“考勤出勤时间”；
	 * 如果“考勤退勤时间”早于“排班基准时间”的“结束时间”，并且“考勤出勤时间”晚于“排班基准时间”的“开始时间”： 实际出勤时间=
	 * “考勤退勤时间”-“考勤出勤时间”； 实际出勤时长不考虑中间的休息时长；
	 * 考勤退勤时间、考勤出勤时间点应该是在当日打卡标准范围内的才计算，超出范围内视为漏打卡；
	 * 
	 * 
	 * 实际出勤时间大于基准时间的按照基准时间计算；
	 * 
	 * @author hualong.zhao
	 * @date 2017-11-24
	 * @param dto
	 */
	private void calculateActualAttendanceDate(UserAttendanceDetailDto dto) {
		BigDecimal actualAttendanceDate = new BigDecimal(0);
		// 正常上班时间
		String normalworkStime = dto.getNormalworkStime();
		// 正常下班时间
		String normalworkEtime = dto.getNormalworkEtime();
		if (oConvertUtils.isEmpty(normalworkStime)||oConvertUtils.isEmpty(normalworkEtime)) {
			String dutyType =  oConvertUtils.getString(dto.getDutyType());
			if (Globals.DUTYTYPE_jiaban.equals(dutyType)) {
				normalworkStime = oConvertUtils.getString(dto.getTimeOutOvertimeStime(), "00:00");
				normalworkEtime =oConvertUtils.getString( dto.getTimeOutOvertimeEtime(), "23:59");
				//计算加班的时候的实际出勤时间
			}else if ( Globals.DUTYTYPE_zhiban.equals(dutyType)) {
//				normalworkStime = oConvertUtils.getString(dto.getOndutyStime(), "00:00");
//				normalworkEtime =oConvertUtils.getString( dto.getOndutyEtime(), "23:59");
				return;
					//计算加班的时候的实际出勤时间
			}else if (Globals.DUTYTYPE_xiuxi.equals(dutyType)) {
					// 当他休息的时候
					//计算加班的时候的实际出勤时间
				return ;
			}
		}
		
	 
		Date normalworkStartdate = getexactDate(dto.getYmdDate(),
				normalworkStime, 0, 0);
		Integer t1flag = 0;
		if (oConvertUtils.getString(dto.getDutyType()).equals(Globals.DUTYTYPE_yeban115)) {
			t1flag = 1;
		}
		Date normalworkenddate = getexactDate(dto.getYmdDate(),
				normalworkEtime, t1flag, 0);
		// 实际打卡开始时间
		Date actattendanceDate = dto.getActattendanceDate();
		// 实际打卡结束时间
		Date actretreatDate = dto.getActretreatDate();
		if (normalworkStartdate.equals(normalworkenddate)) {
			//  当这天安排的工作是休息时---上班时间等于下班时间
		}
		
		

		// 正常工作基准工时
		BigDecimal datumWorkhours = dto.getDatumWorkhours();
		BigDecimal datumWorkmins = BigDecimal.ZERO;
		if (null != datumWorkhours) {
			datumWorkmins = datumWorkhours.multiply(new BigDecimal(60));
		}
		if (oConvertUtils.isEmpty(actattendanceDate)
				&& oConvertUtils.isEmpty(actretreatDate)) {
			dto.setActualAttendanceDate( new BigDecimal(0));
			//如果开始打卡时间  或结束打卡时间为空，则时间差值 应当等于 负的  正常工作基准工时
			return;
		}else if(oConvertUtils.isEmpty(actattendanceDate) && !oConvertUtils.isEmpty(actretreatDate)) {
			// 开始没打开，下班打卡
			if (actretreatDate.compareTo(normalworkenddate) >= 0) {
				// 如果“考勤退勤时间”晚于“排班基准时间”的“结束时间”，算漏打卡
				// 实际出勤时间=“排班基准时间”；
				actualAttendanceDate = datumWorkmins;
			}else {
				// 如果“考勤退勤时间”早于“排班基准时间”的“结束时间”，算早退
				Calendar actretreatDateCalendar = Calendar.getInstance();
				actretreatDateCalendar.setTime(actretreatDate);
				// “排班基准时间”的结束时间
				Calendar normalworkendCalendar = Calendar.getInstance();
				normalworkendCalendar.setTime(normalworkenddate);
				//早退的分钟数
				int dateDiffint = DataUtils.dateDiff('m', actretreatDateCalendar,normalworkendCalendar);
				actualAttendanceDate = datumWorkmins.subtract(new BigDecimal(Math.abs(dateDiffint)));
			}
		}else if(!oConvertUtils.isEmpty(actattendanceDate) && oConvertUtils.isEmpty(actretreatDate)) {
			// 上班打卡，结束没打卡
			if (actattendanceDate.compareTo(normalworkStartdate) <= 0) {
				// 如果“考勤开始时间”早于“排班基准时间”的“开始时间”，算漏打卡
				// 实际出勤时间=“排班基准时间”；
				actualAttendanceDate = datumWorkmins;
			}else {
				// 如果“考勤开始时间”晚于“排班基准时间”的“开始时间”，算迟到
				// “排班基准时间”的“开始时间”
				Calendar normalworkStartCalendar = Calendar.getInstance();
				normalworkStartCalendar.setTime(normalworkStartdate);
				// “考勤出勤时间”
				Calendar actattendanceCalendar = Calendar.getInstance();
				actattendanceCalendar.setTime(actattendanceDate);
				//迟到的分钟数
				int dateDiffint = DataUtils.dateDiff('m', normalworkStartCalendar,actattendanceCalendar);
				actualAttendanceDate = datumWorkmins.subtract(new BigDecimal(Math.abs(dateDiffint)));
			}
		}else {
			// 上下班都有考勤打卡
			// 如果“考勤退勤时间”晚于“排班基准时间”的“结束时间”，并且“考勤出勤时间”早于“排班基准时间”的“开始时间”：
			// 实际出勤时间=“排班基准时间”；

			if ((actretreatDate.compareTo(normalworkenddate) >= 0)
					&& (actattendanceDate.compareTo(normalworkStartdate) <= 0)) {
				actualAttendanceDate = datumWorkmins;
			}

			// 如果“考勤退勤时间”早于“排班基准时间”的“结束时间”，并且“考勤出勤时间”早于“排班基准时间”的“开始时间”：
			// 实际出勤时间=排班基准时间- 早退的分钟数
			if ((actretreatDate.compareTo(normalworkenddate) < 0)
					&& (actattendanceDate.compareTo(normalworkStartdate) <= 0)) {
				// 考勤退勤时间"
				Calendar actretreatDateCalendar = Calendar.getInstance();
				actretreatDateCalendar.setTime(actretreatDate);
				// “排班基准时间”的结束时间
				Calendar normalworkendCalendar = Calendar.getInstance();
				normalworkendCalendar.setTime(normalworkenddate);
				//早退的分钟数
				int dateDiffint = DataUtils.dateDiff('m', actretreatDateCalendar,normalworkendCalendar);
				actualAttendanceDate = datumWorkmins.subtract(new BigDecimal(Math.abs(dateDiffint)));
			}
			// 如果“考勤退勤时间”晚于“排班基准时间”的“结束时间”，并且“考勤出勤时间”晚于“排班基准时间”的“开始时间”：
			// 实际出勤时间=排班基准时间- 迟到的分钟数
			if ((actretreatDate.compareTo(normalworkenddate) >= 0)
					&& (actattendanceDate.compareTo(normalworkStartdate) > 0)) {
				// “排班基准时间”的“开始时间”
				Calendar normalworkStartCalendar = Calendar.getInstance();
				normalworkStartCalendar.setTime(normalworkStartdate);
				// “考勤出勤时间”
				Calendar actattendanceCalendar = Calendar.getInstance();
				actattendanceCalendar.setTime(actattendanceDate);
				//迟到的分钟数
				int dateDiffint = DataUtils.dateDiff('m', normalworkStartCalendar,actattendanceCalendar);
				actualAttendanceDate = datumWorkmins.subtract(new BigDecimal(Math.abs(dateDiffint)));
			}
			// 如果“考勤退勤时间”早于“排班基准时间”的“结束时间”，并且“考勤出勤时间”晚于“排班基准时间”的“开始时间”：
			// 实际出勤时间= 排班基准时间-    (“考勤退勤欠勤时间”+“考勤出勤欠勤时间”)；
			if ((actretreatDate.compareTo(normalworkenddate) < 0)
					&& (actattendanceDate.compareTo(normalworkStartdate) > 0)) {
				// 考勤退勤时间"
				Calendar actretreatCalendar = Calendar.getInstance();
				actretreatCalendar.setTime(actretreatDate);
				//“排班基准时间”的“结束时间”
				Calendar normalworkenddateCalendar = Calendar.getInstance();
				normalworkenddateCalendar.setTime(normalworkenddate);
				// “考勤出勤时间”
				Calendar actattendanceCalendar = Calendar.getInstance();
				actattendanceCalendar.setTime(actattendanceDate);
				// “排班基准时间”的“开始时间”
				Calendar normalworkStartdateCalendar = Calendar.getInstance();
				normalworkStartdateCalendar.setTime(normalworkStartdate);
				//出勤欠勤分钟数
				int belatedateDiffint = DataUtils.dateDiff('m', actattendanceCalendar,
						normalworkStartdateCalendar);
				//退勤欠勤分钟数
				int leaveearlyDiffint = DataUtils.dateDiff('m', normalworkenddateCalendar,
						actretreatCalendar);
				
				
				//实际出勤分钟数 = min(打卡结束时间， 理论下班结束时间)-max(实际打卡时间， 理论上班时间)
				Date startDate =normalworkStartdate.compareTo(actattendanceDate)<= 0?actattendanceDate:normalworkStartdate;
				Date endDate =normalworkenddate.compareTo(actretreatDate)<= 0?normalworkenddate:actretreatDate;
				Calendar startCalendar = Calendar.getInstance();
				startCalendar.setTime(startDate);
				Calendar endCalendar = Calendar.getInstance();
				endCalendar.setTime(endDate);
				int dateDiffint = 0;
				if (startDate.compareTo(endDate)<=0) {
					dateDiffint = Math.abs(DataUtils.dateDiff('m', startCalendar, endCalendar));
				}
				actualAttendanceDate =	datumWorkmins.subtract(new BigDecimal(Math.abs(belatedateDiffint)))
						.subtract(new BigDecimal(Math.abs(leaveearlyDiffint)));
				//当值班或者是加班的时候  只要有打卡记录， 代码就会走到这里来， 这个时候   将实际出勤时间 记作 加班/值班的基准时间 
				String dutyType =  oConvertUtils.getString(dto.getDutyType());
				if (Globals.DUTYTYPE_jiaban.equals(dutyType)||Globals.DUTYTYPE_zhiban.equals(dutyType)) {
					//当为值班或者是加班的时候   获取这一天的实际出勤分钟数， 与这一天的基准出勤分钟数  取这两个值的最小值 记为实际出勤时间
					BigDecimal actmins = new BigDecimal(dateDiffint);
					actualAttendanceDate =datumWorkmins.compareTo(actmins)<0?datumWorkmins:actmins;
				}
			}
			
		}
		
		//	 实际出勤时间大于基准时间的按照基准时间计算；
		if (!datumWorkmins.equals(BigDecimal.ZERO)&&datumWorkmins.compareTo(actualAttendanceDate)<0) {
			actualAttendanceDate  = datumWorkmins;
		}
		//实际出勤时间小于零的时候   写为零
		if (actualAttendanceDate.compareTo(BigDecimal.ZERO)<0) {
			actualAttendanceDate  = BigDecimal.ZERO;
		}
		//设置实际出勤时间
		dto.setActualAttendanceDate(actualAttendanceDate);
	}

	/**
	 * 根据钉钉打卡记录原始数据， 查询有效开始打卡时间内的最早打卡时间 和 最晚打卡时间
	 * update 2018年1月14日10:24:32
	 * 额外加班 只要有加班申请  就记作+1  不用查看是否有打卡记录
	 * @author hualong.zhao
	 * @date 2017-11-24
	 * @param dto
	 * @param dingAttendanceinfoEntities
	 * @param hm_specialAttendEntities 
	 * @param adjustedEntities 
	 * @param adjustedEntities 
	 * @param detailEntity 
	 */
	private void calculateActAttendancetime(UserAttendanceDetailDto dto,
			List<DingAttendanceinfoEntity> dingAttendanceinfoEntities, List<UserAttendanceDetailAdjustedEntity> adjustedEntities, List<UserAttendanceDetailDto> uatdlist, UserAttendanceDetailEntity detailEntity) {
		// 根据钉钉打卡记录原始数据， 查询有效开始打卡时间内的最早打卡时间 和 最晚打卡时间
		//获取有效开始打卡时间
		Date effectiveStime =dto.getEffectiveStime();
		//获取有效结束打卡时间
		Date effectiveEtime = dto.getEffectiveEtime();
		// 实际打卡开始时间
		Date actattendanceDate = null;
		// 实际打卡结束时间
		Date actretreatDate = null;
		boolean  yesterdayisyb = true; 
		// 有特殊考勤记录
		boolean hasSpecialAttendInfo = false;
		try {
			hasSpecialAttendInfo = specialAttendService.hasSpecialAttendInfo(dto.getUserid());
		} catch (Exception e) {
			e.printStackTrace();
		}
		
		// 如果是特殊考勤类型，不管钉钉记录如何，都进行统一处理，比如手工考勤——默认全勤
		if(hasSpecialAttendInfo) {
			// 默认全勤， 模拟钉钉考勤记录， 默认有效开始和结束打卡时间
			dingAttendanceinfoEntities = new ArrayList<DingAttendanceinfoEntity>();
			DingAttendanceinfoEntity startDingdingAttend = new DingAttendanceinfoEntity();
			
			startDingdingAttend.setAttendanceTime(effectiveStime);
			DingAttendanceinfoEntity endDingdingAttend = new DingAttendanceinfoEntity();
			endDingdingAttend.setAttendanceTime(effectiveEtime);
			
			dingAttendanceinfoEntities.add(startDingdingAttend);
			dingAttendanceinfoEntities.add(endDingdingAttend);
		}
		
		
		// 在钉钉打卡记录不为空情况下查询下述
		if (!ListUtils.isNullOrEmpty(dingAttendanceinfoEntities)) {
			//正向遍历打卡记录  查询在有效打开记录区间内 最早的一次打卡记录  
			if (oConvertUtils.isNotEmpty(effectiveStime)) {
				for (int i = 0; i < dingAttendanceinfoEntities.size(); i++) {
					DingAttendanceinfoEntity dingAttendanceinfoEntity = dingAttendanceinfoEntities
							.get(i);
					Date temp = dingAttendanceinfoEntity.getAttendanceTime();
					if (oConvertUtils.isNotEmpty(temp)
							&&temp.compareTo(effectiveEtime) <=0
							&& (temp.compareTo(effectiveStime) >= 0)) {
						actattendanceDate = dingAttendanceinfoEntity
								.getAttendanceTime();
						break;
					}
				}
			}else {
				//effectiveStime 值为空： 说明当天没有排班信息  或这天是休息查询这一天的最早打卡时间(必须是本天的最早开始时间)
				yesterdayisyb = checkYesterdaytype(dto,uatdlist);
				
				// 先校验上一天是否为夜班   如果是夜班  不执行下述操作
				if (!yesterdayisyb) {
					Date todayend =  getexactDate(dto.getYmdDate(), "00:00",1, 0 );
					for (int i = 0; i < dingAttendanceinfoEntities.size(); i++) {
						DingAttendanceinfoEntity dingAttendanceinfoEntity = dingAttendanceinfoEntities
								.get(i);
						Date temp = dingAttendanceinfoEntity.getAttendanceTime();
						if (oConvertUtils.isNotEmpty(temp)&&temp.before(todayend)) {
							actattendanceDate = dingAttendanceinfoEntity.getAttendanceTime();
							break;
						}
					}
				}
			}
			//如果值班/加班   和正常工作时间连续了   则 先查询 有效结束打卡时间后 的最新一次打卡，
			//  此处应该加限制   因为现在 加班时间有16:30~18:30    往后找  就找到了t1的07:15 去了
			//如果这个时间没有， 则查询值班/加班 结束时间之前的最后一次打卡
			// ----------值班情况处理 ---20180308---yangxi---add---start----------
			if(!Globals.DUTYTYPE_zhiban.equals(oConvertUtils.getString(dto.getDutyType()))) {
				if (dto.isJiabanContinuous()) {
					Integer epunchMinute = oConvertUtils.getInt(dto.getEpunchMinute(),0);
					Calendar calendar = Calendar.getInstance();
					calendar.setTime(effectiveEtime);
					calendar.add(Calendar.MINUTE, epunchMinute);
					// 默认全勤处理加班
					if(hasSpecialAttendInfo) {
						DingAttendanceinfoEntity endDingdingAttend = new DingAttendanceinfoEntity();
						endDingdingAttend.setAttendanceTime(effectiveEtime);
						dingAttendanceinfoEntities.add(endDingdingAttend);
					}
					
					Date endmaxTime  =   calendar.getTime();
					for (int i = 0; i < dingAttendanceinfoEntities.size(); i++) {
						DingAttendanceinfoEntity dingAttendanceinfoEntity = dingAttendanceinfoEntities
								.get(i);
						Date temp = dingAttendanceinfoEntity.getAttendanceTime();
						if (oConvertUtils.isNotEmpty(temp)
								&& (temp.compareTo(effectiveEtime) >= 0)
								&& (temp.compareTo(endmaxTime) <= 0)) {
							actretreatDate =temp;
							break;
						}
					}
				}
				//判断是否在超时加班时出勤，判断标准是超时加班时长内打卡至少一次
				//如果有出勤，则timeoutOvertimeDuration=timeOutOvertimeHours（排班中超时时长）；实际出勤中加上加班时长actualAttendanceDate += timeOutOvertimeHours
				//zy20180413
				String jiabanStarttimeStr = dto.getTimeOutOvertimeStime();
				String jiabanEndtimeStr = dto.getTimeOutOvertimeEtime();
				
				Date jiabanStarttime = getexactDate(dto.getYmdDate(), jiabanStarttimeStr, 0, 0);
				Date jiabanEndtime = getexactDate(dto.getYmdDate(), jiabanEndtimeStr, 0, 90);//增加90分钟有效范围
				// 如果超时加班跨天设置，则加一
				if(jiabanStarttime.after(jiabanEndtime)) {
					Calendar jiabanendCal = Calendar.getInstance();
					jiabanendCal.setTime(jiabanEndtime);
					jiabanendCal.add(Calendar.DATE, 1);
					jiabanEndtime = jiabanendCal.getTime();
				}
//				// 默认全勤处理值班
//				if(hm_specialAttendEntities.containsKey(dto.getUserid())) {
//					DingAttendanceinfoEntity endDingdingAttend = new DingAttendanceinfoEntity();
//					endDingdingAttend.setAttendanceTime(jiabanStarttime);
//					dingAttendanceinfoEntities.add(endDingdingAttend);
//				}
				if (oConvertUtils.isNotEmpty(jiabanStarttimeStr)&&oConvertUtils.isNotEmpty(jiabanEndtimeStr)) {
					for (int i = 0; i < dingAttendanceinfoEntities.size(); i++) {
						DingAttendanceinfoEntity dingAttendanceinfoEntity = dingAttendanceinfoEntities
								.get(i);
						Date temp = dingAttendanceinfoEntity.getAttendanceTime();
						if (oConvertUtils.isNotEmpty(temp)
								&&temp.compareTo(jiabanEndtime) <=0
								&& (temp.compareTo(jiabanStarttime) >= 0)) { 
							//设置实际超时加班时间
							dto.setTimeoutOvertimeDuration(dto.getTimeOutOvertimeHours());
						    //实际出勤时间加上超时加班时间
							BigDecimal actattendTime = dto.getActualAttendanceDate();
							if(actattendTime != null) {
								dto.setActualAttendanceDate(actattendTime.add(dto.getTimeoutOvertimeDuration()));
							}
							break;
						}
					}
				}
			}
			
			//反向遍历打卡记录， 寻找在有效打卡记录区间内 最后一次打卡  
			if (oConvertUtils.isNotEmpty(effectiveEtime)&&oConvertUtils.isEmpty(actretreatDate)) {
				for (int i = (dingAttendanceinfoEntities.size() - 1); i >= 0; i--) {
					DingAttendanceinfoEntity dingAttendanceinfoEntity = dingAttendanceinfoEntities
							.get(i);
					Date temp = dingAttendanceinfoEntity.getAttendanceTime();
					if (oConvertUtils.isNotEmpty(temp)
							&&temp.compareTo(effectiveStime) >=0
							&&temp.compareTo(effectiveEtime) <=0) {
						actretreatDate = temp;
						break;
					}
				}
			}
			if (oConvertUtils.isEmpty(effectiveEtime)) {
				// effectiveEtime 值为空： 说明当天没有排班信息 或这天是休息   查询这一天的最晚打卡时间
				// 先校验上一天是否为夜班   如果是夜班  不执行下述操作
				if (!yesterdayisyb){
					Date todayendDate = getexactDate(dto.getYmdDate(), "00:00",1, 0);
					for (int i = (dingAttendanceinfoEntities.size() - 1); i >= 0; i--) {
						DingAttendanceinfoEntity dingAttendanceinfoEntity = dingAttendanceinfoEntities
								.get(i);
						Date temp = dingAttendanceinfoEntity.getAttendanceTime();
						if (oConvertUtils.isNotEmpty(temp)&&temp.compareTo(todayendDate) <0) {
							actretreatDate = temp;
							break;
						}
					}		
				}
			}
		}
		UserAttendanceDetailAdjustedEntity currDateAdjustEntity = getCurrDateAdjustEntity(adjustedEntities, dto);
		dto.setActattendanceDate(actattendanceDate);
		dto.setActretreatDate(actretreatDate);
		//如果是通过页面编辑调用的该方法， 将实际打卡时间修改为页面填写的时间
		if (oConvertUtils.isNotEmpty(detailEntity)) {
			dto.setActattendanceDate(detailEntity.getAttendanceDate());
			//如果用户选择的结束时间为空， 在dto 中设置结束时间等于开始时间  便于dto相关计算
			Date retreatDate  =detailEntity.getRetreatDate();
			if (null==retreatDate) {
				retreatDate  = detailEntity.getAttendanceDate();
			}
			dto.setActretreatDate(retreatDate);
		}else if(currDateAdjustEntity != null) {
			dto.setPrimevalAttendanceDate(actattendanceDate);
			dto.setPrimevalRetreatDate(actretreatDate);
			dto.setActattendanceDate(currDateAdjustEntity.getAttendanceDate());
			dto.setActretreatDate(currDateAdjustEntity.getRetreatDate());
		}
//		值班天数	计算当月的班次中有值班时间的天数		累8计当前月的有值班时间的天数	值班按次计算，只要有实际出勤记录我们就计做一次值班；
		Date ondutyStarttime = dto.getOndutyStarttime();
		Date ondutyEndtime = dto.getOndutyEndtime();
		if (oConvertUtils.isNotEmpty(ondutyStarttime)&&oConvertUtils.isNotEmpty(ondutyEndtime)) {
//			for (int i = 0; i < dingAttendanceinfoEntities.size(); i++) {
//				DingAttendanceinfoEntity dingAttendanceinfoEntity = dingAttendanceinfoEntities
//						.get(i);
//				Date temp = dingAttendanceinfoEntity.getAttendanceTime();
//				if (oConvertUtils.isNotEmpty(temp)
//						&&temp.compareTo(ondutyEndtime) <=0
//						&& (temp.compareTo(ondutyStarttime) >= 0)) { 
//					dto.setIhadDuty(true);
//					break;
//				}
//			}
			// 默认全勤处理加班
			if(hasSpecialAttendInfo) {
				dto.setIhadDuty(true);
			}
			
			// 根据出勤时间和退勤时间计算值班是否有效，原因是出勤时间和退勤时间可能是手动修改后的结果 zy 20180425
			if (oConvertUtils.isNotEmpty(dto.getActattendanceDate())
					&& dto.getActattendanceDate().compareTo(ondutyEndtime) <=0
					&& (dto.getActattendanceDate().compareTo(ondutyStarttime) >= 0)) { 
				dto.setIhadDuty(true);
			}
			if (oConvertUtils.isNotEmpty(dto.getActretreatDate())
					&& dto.getActretreatDate().compareTo(ondutyEndtime) <=0
					&& (dto.getActretreatDate().compareTo(ondutyStarttime) >= 0)) { 
				dto.setIhadDuty(true);
			}
		}
		// =====查询加班情况
		List<OvertimeRecordEntity> overtimeRecordEntities =dto.getOvertimeRecordEntities();
		if (!ListUtils.isNullOrEmpty(overtimeRecordEntities)) {
			for (OvertimeRecordEntity entry:overtimeRecordEntities) {
				//额外加班 餐补次数，需要 考虑 加班备案申请里 的 是否 提供餐补。  否 的时候，不能计入次数。 
				//只要有加班记录  就记作额外加班一次
				//del-->如果有加班备案  且这个加班备案不是法定加班  校验在这个区间内是否有打卡记录 如果有  则 额外加班记一次  "0".equals(entry.getIfnational())
				if ("1".equals(oConvertUtils.getString(entry.getIfmeal()))) {
					dto.setExtraOvertime(1);
				}
				/*if (true) {
					*//**加班开始时间*//*
				  Date overtimeStime = entry.getOvertimeStime();
					*//**加班结束时间*//*
				     Date overtimeEtime=  entry.getOvertimeEtime();
				     for (int i = 0; i < dingAttendanceinfoEntities.size(); i++) {
							DingAttendanceinfoEntity dingAttendanceinfoEntity = dingAttendanceinfoEntities
									.get(i);
							Date temp = dingAttendanceinfoEntity.getAttendanceTime();
							if (oConvertUtils.isNotEmpty(temp)
									&&temp.compareTo(overtimeEtime) <=0
									&& (temp.compareTo(overtimeStime) >= 0)) {
								//额外加班 餐补次数，需要 考虑 加班备案申请里 的 是否 提供餐补。  否 的时候，不能计入次数。 
								if ("1".equals(oConvertUtils.getString(entry.getIfmeal()))) {
									dto.setExtraOvertime(1);
								}
								break;
							}
						}
				     //如果钉钉原始打卡记录为空， 在判断编辑页传入的开始打卡时间  和结束打卡时间  是否满足额外加班条件
				     if (ListUtils.isNullOrEmpty(dingAttendanceinfoEntities)) {
				    	 List<Date> tempdates = new ArrayList<Date>();
				    	 tempdates.add(dto.getActattendanceDate());
				    	 tempdates.add(dto.getActretreatDate());
				    	 for (int i = 0; i < tempdates.size(); i++) {
				    		 Date temp =  tempdates.get(i);
								if (oConvertUtils.isNotEmpty(temp)
										&&temp.compareTo(overtimeEtime) <=0
										&& (temp.compareTo(overtimeStime) >= 0)) {
									//额外加班 餐补次数，需要 考虑 加班备案申请里 的 是否 提供餐补。  否 的时候，不能计入次数。 
									if ("1".equals(oConvertUtils.getString(entry.getIfmeal()))) {
										dto.setExtraOvertime(1);
									}
									break;
								}
							}
					}
				}*/
			}
		}
	}
/**
 * 判断上一天是否为夜班  是夜班为true   其他为false
 * @author hualong.zhao
 * @date 2017-12-5
 * @param dto
 * @param uatdlist
 * @return
 */
	private boolean checkYesterdaytype(UserAttendanceDetailDto dto,
			List<UserAttendanceDetailDto> uatdlist) {
		boolean result = true; 
		for (int i = 0; i < uatdlist.size(); i++) {
			UserAttendanceDetailDto tdto = uatdlist.get(i);
			UserAttendanceDetailDto ydto = uatdlist.get(i);
			if (tdto.getYmdDate().equals(dto.getYmdDate())) {
				ydto =  uatdlist.get(Math.max(0, i-1));
				if (Globals.DUTYTYPE_yeban115.equals(oConvertUtils.getString(ydto.getDutyType()))) {
					result = true;
				}else {
					result = false;
				}
				if (i==0) {
					Date  yesterday = getexactDate(dto.getYmdDate(), "00:00", -1, 0);
					//月度首日  需要查询上一个月的最后一天 是否为夜班
					List<UserAttendanceDetailDto>   yestoryday = userAttendanceDetailDao.
							getlistbyProjarrangeDetailid(null,dto.getUserid(),DataUtils.date2Str(yesterday, DataUtils.date_sdf));
						if (!ListUtils.isNullOrEmpty(yestoryday)) {
							ydto =  yestoryday.get(0);
							if (Globals.DUTYTYPE_yeban115.equals(oConvertUtils.getString(ydto.getDutyType()))) {
								result = true;
							}else {
								result = false;
							}
						}
				}
			}
		}
		return result;
	}

	/**
	 * 获取有效结束打卡时间
	 * 
	 * 
	 * 如果是夜班，跨天的情况： 考勤机记录的本日后一天的认可范围内最晚刷卡时间，例如：7:30； 否则为 考勤机记录的本日最晚刷卡时间，例如：19:50
	 * 
	 * 要考虑是否有连续加班或值班的情况，如果排班中的“正常工作下班时间”>=“加班或值班开始时间”，退勤时间为最晚的打卡时间；
	 * 否则为正常打卡结束时间范围内的最后时间； 要考虑夜班跨自然日的情况；
	 * 
	 * 
	 * 如果值班/加班   和正常工作时间没有连续   则查询有效结束打卡时间 之前的最后一次打卡时间
	 * 如果值班/加班   和正常工作时间连续了   则 先查询 有效结束打卡时间 的最新一次打卡， 如果这个时间没有， 则查询值班/加班 结束时间之前的最后一次打卡
	 * 
	 * 
	 * @author hualong.zhao
	 * @date 2017-11-23
	 * @param dto
	 * @return
	 */
	private Date calculateEffectiveAttendanceEtime(UserAttendanceDetailDto dto) {
		Date effectiveEnddate = dto.getYmdDate();
		// 获取正常上班时间
		String normalworkStime = oConvertUtils.getString(dto
				.getNormalworkStime());
		if (oConvertUtils.isEmpty(normalworkStime)) {
			String dutyType =  oConvertUtils.getString(dto.getDutyType());
			if (Globals.DUTYTYPE_jiaban.equals(dutyType)||Globals.DUTYTYPE_zhiban.equals(dutyType)) {
				normalworkStime = "00:00";
			} 
		}
		// 获取正常下班时间
		String normalworkEtime = oConvertUtils.getString(dto
				.getNormalworkEtime());
		if (oConvertUtils.isEmpty(normalworkEtime)) {
			String dutyType =  oConvertUtils.getString(dto.getDutyType());
			if (Globals.DUTYTYPE_jiaban.equals(dutyType)||Globals.DUTYTYPE_zhiban.equals(dutyType)) {
				normalworkEtime = "23:59";
			}else{
				// 当他休息的时候
				//计算加班的时候的实际出勤时间
				return null;
			} 
		}
		Integer t1flag = 0;
		if (oConvertUtils.isNotEmpty(normalworkEtime)
				&& oConvertUtils.isNotEmpty(normalworkStime)) {
			t1flag = normalworkEtime.compareTo(normalworkStime) < 0 ? 1 : 0;
			if (Globals.DUTYTYPE_yeban115.equals(oConvertUtils.getString(dto.getDutyType()))) {
				t1flag = 1;
			}
			Integer epunchMinute = oConvertUtils.getInt(dto.getEpunchMinute(),
					0);
			effectiveEnddate = getexactDate(dto.getYmdDate(), normalworkEtime,
					t1flag, 0 + epunchMinute);
		}
		// 值班开始时间
		String ondutyStime = oConvertUtils.getString(dto.getOndutyStime());
		if (oConvertUtils.isNotEmpty(ondutyStime)) {
			// 获取值班 的开始时间
			Date ondutyStarttime = getexactDate(dto.getYmdDate(), ondutyStime, t1flag,0);
			dto.setOndutyStarttime(ondutyStarttime);
		}
		//值班结束时间
		String mondutyEtime = oConvertUtils.getString(dto.getOndutyEtime());
		if (oConvertUtils.isNotEmpty(mondutyEtime)) {
			// 获取值班 的结束时间
			if (mondutyEtime.compareTo(ondutyStime)<0) {
				Date ondutyEndtime = getexactDate(dto.getYmdDate(), mondutyEtime, t1flag+1,0);
				dto.setOndutyEndtime(ondutyEndtime);	
			}else {
			Date ondutyEndtime = getexactDate(dto.getYmdDate(), mondutyEtime, t1flag,0);
			dto.setOndutyEndtime(ondutyEndtime);
			}
		}
		// 加班开始时间
		String timeOutOvertimeStime = oConvertUtils.getString(dto
				.getTimeOutOvertimeStime());
		Date overtimeStartdate = null;
		if (oConvertUtils.isNotEmpty(timeOutOvertimeStime)) {
			// 加班开始时间date
			  overtimeStartdate = getexactDate(dto.getYmdDate(), timeOutOvertimeStime, t1flag,0);
		}
		// 加班结束时间
		String timeOutOvertimeEtime = oConvertUtils.getString(dto
				.getTimeOutOvertimeEtime());
		Date overtimeEnddate = null;
		if (oConvertUtils.isNotEmpty(timeOutOvertimeEtime)) {
			// 加班结束时间date
			if (timeOutOvertimeEtime.compareTo(timeOutOvertimeStime)<0) {
			  overtimeEnddate = getexactDate(dto.getYmdDate(), timeOutOvertimeEtime, t1flag+1,0);
			}else {
			  overtimeEnddate = getexactDate(dto.getYmdDate(), timeOutOvertimeEtime, t1flag,0);
			}
		}
		// 最早加班/值班开始时间
		 
		Date jiabanstartDate = null;
		Date jiabanendDate = null;
		//如果值班时间不为空   则将此值置为值班时间
		if (oConvertUtils.isNotEmpty(dto.getOndutyStarttime())) {
			jiabanstartDate = dto.getOndutyStarttime();
			jiabanendDate = dto.getOndutyEndtime();
		}
		//如果加班时间不为空 则将此值置为加班时间
		if (oConvertUtils.isNotEmpty(overtimeStartdate)) {
			jiabanstartDate = overtimeStartdate;
			jiabanendDate = overtimeEnddate;
		}
		if (oConvertUtils.isNotEmpty(dto.getOndutyStarttime())&&oConvertUtils.isNotEmpty(overtimeStartdate)) {
			jiabanstartDate = (dto.getOndutyStarttime().after(overtimeStartdate))?overtimeStartdate:dto.getOndutyStarttime();
			jiabanendDate = (dto.getOndutyStarttime().after(overtimeStartdate))?overtimeEnddate:dto.getOndutyEndtime();
		}
		if (oConvertUtils.isNotEmpty(jiabanstartDate)
				&&(oConvertUtils.isNotEmpty(jiabanendDate))
				&& (jiabanstartDate.compareTo(effectiveEnddate) <= 0)) {
			effectiveEnddate = jiabanendDate;
			dto.setJiabanContinuous(true);
		} else {
			dto.setJiabanContinuous(false);
		}
		// ----------值班情况处理 ---20180308---yangxi---add---start----------
		if(Globals.DUTYTYPE_zhiban.equals(dto.getDutyType())) {
			effectiveEnddate = dto.getOndutyEndtime();
		}
		// ----------值班情况处理 ---20180308---yangxi---add---end----------
		
		// 有效结束打卡时间应该为59秒
		Calendar calendar = Calendar.getInstance();    
	    calendar.setTime(effectiveEnddate);    
	    calendar.add(Calendar.SECOND, 59);
		
		return calendar.getTime();
	}

	/**
	 * 
	 * @author hualong.zhao
	 * @date 2017-11-23
	 * @param ymdDate
	 *            由年月日获取的Date类型的时间 基准时间
	 * @param time
	 *            小时：分钟
	 * @param t1
	 *            是否加一天
	 * @param addmins
	 *            时间波动
	 * @return
	 */
	private Date getexactDate(Date ymdDate, String time, int t1, int addmins) {
		Calendar effectivecal = Calendar.getInstance();
		effectivecal.setTime(ymdDate);
		if (oConvertUtils.isNotEmpty(time)) {
			String[] temp = time.split(":");
			// 将正常上班时间 设定至 时间戳上
			effectivecal.set(Calendar.HOUR_OF_DAY, Integer.valueOf(temp[0]));
			effectivecal.set(Calendar.MINUTE, Integer.valueOf(temp[1]));
		}
		effectivecal.add(Calendar.DATE, t1);
		// 开始打卡分钟数
		if (oConvertUtils.isNotEmpty(addmins)) {
			effectivecal.add(Calendar.MINUTE, addmins);
		}
		return effectivecal.getTime();
	}

	/**
	 * 获取有效开始打卡时间
	 * 
	 * 考勤机记录的本日认可范围内最早刷卡时间，例如：7:32
	 * 
	 * @author hualong.zhao
	 * @date 2017-11-23
	 * @param dto
	 * @return
	 */
	private Date calculateEffectiveAttendanceStime(UserAttendanceDetailDto dto) {
		// 获取正常上班时间
		String normalworkStime = oConvertUtils.getString(dto
				.getNormalworkStime());
		Date normalworkStartdate = dto.getYmdDate();
		if (oConvertUtils.isEmpty(normalworkStime)) {
			String dutyType =  oConvertUtils.getString(dto.getDutyType());
			if (Globals.DUTYTYPE_jiaban.equals(dutyType)||Globals.DUTYTYPE_zhiban.equals(dutyType)) {
				normalworkStime = "00:00";
			} else {
				return null;
			}
		}
		if (oConvertUtils.isNotEmpty(normalworkStime)) {
			int spunchMinute = oConvertUtils.getInt(dto.getSpunchMinute(), 0);
			normalworkStartdate = getexactDate(dto.getYmdDate(),
					normalworkStime, 0, 0 - spunchMinute);
		} 
		// ----------值班情况处理 ---20180308---yangxi---add---start----------
		if(Globals.DUTYTYPE_zhiban.equals(dto.getDutyType())) {
			normalworkStartdate = getexactDate(dto.getYmdDate(), dto.getOndutyStime(), 0, 0);
		}
		// ----------值班情况处理 ---20180308---yangxi---add---end----------
		return normalworkStartdate;
	}

	/**
	 * 包括： 正常、法定假日、带薪假、病假、事假、婚假、丧假、陪产假； “正常”、“法定假日”按照每年的法定节假日信息设定并校验；
	 * 其他假期，需要根据已经确认的“休假申请”中日期及休假类型设定并校验；
	 * 
	 * @author hualong.zhao
	 * @date 2017-11-23
	 * @param dto
	 * @return
	 */
	private void calculateCurdateStatus(UserAttendanceDetailDto dto) {
		String curdateStatus = Globals.ATTENDANCE_STATUS_EDIT_10;
		// 当这一天为法定假日时 ，切这一天该员工有排班。 则认定为该员工为正常上班。可手动调整为法定假日。
		List<HolidayEntity> userHolidayEntities = dto.getUserHolidayEntities();
		if (!ListUtils.isNullOrEmpty(userHolidayEntities)) {
			curdateStatus = userHolidayEntities.get(0).getHolidayType();
		}
		dto.setCurdateStatus(curdateStatus);
	}

	/**
	 * 检查某人某天是否有 固定周期临时借调
	 * 
	 * @author hualong.zhao
	 * @date 2017-11-23
	 * @param dto
	 * @param snapRegularborrowEntities
	 */
	private void checkIshavesnapRegularborrows(UserAttendanceDetailDto dto,
			List<SnapRegularborrowEntity> snapRegularborrowEntities) {
		Date curdate = dto.getYmdDate();
		List<SnapRegularborrowEntity> uSingleborrowEntities = dto
				.getSnapRegularborrowEntities();
		// 遍历本月固定周期临时借调，
		for (SnapRegularborrowEntity snapRegularborrowEntity : snapRegularborrowEntities) {
			Date inTime = snapRegularborrowEntity.getInTime();
			Date deadDate = snapRegularborrowEntity.getDeadDate();
			// 如果当前时间在固定周期临时调度范围内
			if (oConvertUtils.isNotEmpty(inTime)
					&& oConvertUtils.isNotEmpty(deadDate)
					&& (inTime.compareTo(curdate) <= 0 && curdate
							.compareTo(deadDate) <= 0)) {
				// 当天在固定周期的 调入日期 和终止日期之间
				String fixedCycle = oConvertUtils
						.getString(snapRegularborrowEntity.getFixedCycle());
				// 固定周期内有这一天 星期N = 星期N
				if (fixedCycle.contains(dto.getWeek())) {
					uSingleborrowEntities.add(snapRegularborrowEntity);
				}
			}
		}
		dto.setSnapRegularborrowEntities(uSingleborrowEntities);

	}

	/**
	 * 检查某人某天是否有单次临时借调
	 * 
	 * @author hualong.zhao
	 * @date 2017-11-23
	 * @param dto
	 * @param snapSingleborrowEntities
	 */
	private void checkIshavesnapSingleborrows(UserAttendanceDetailDto dto,
			List<SnapSingleborrowEntity> snapSingleborrowEntities) {
		Date curdate = dto.getYmdDate();
		List<SnapSingleborrowEntity> uSingleborrowEntities = dto
				.getSnapSingleborrowEntities();
		// 遍历本月单次临时借调，
		for (SnapSingleborrowEntity snapSingleborrowEntity : snapSingleborrowEntities) {
			Date inTime = snapSingleborrowEntity.getInTime();
			Date deadDate = snapSingleborrowEntity.getDeadDate();
			if (inTime.equals(curdate)
					|| (inTime.before(curdate) && curdate.before(deadDate))
					|| (deadDate.equals(curdate))) {
				uSingleborrowEntities.add(snapSingleborrowEntity);
			}
		}
		dto.setSnapSingleborrowEntities(uSingleborrowEntities);

	}

	/**
	 * 检查某人某天是否有加班备案记录
	 * 
	 * @author hualong.zhao
	 * @date 2017-11-23
	 * @param dto
	 * @param overtimeRecordEntities
	 */
	private void checkIshaveovertimeRecord(UserAttendanceDetailDto dto,
			List<OvertimeRecordEntity> overtimeRecordEntities) {
		Date curdate = dto.getYmdDate();
		Calendar calendar = Calendar.getInstance();
		calendar.setTime(curdate);
		calendar.add(Calendar.DATE, 1);
		Date tomDate = calendar.getTime();
		List<OvertimeRecordEntity> uOvertimeRecordEntities = dto
				.getOvertimeRecordEntities();
		// 遍历本月的加班记录，
		for (OvertimeRecordEntity overtimeRecordEntity : overtimeRecordEntities) {
			Date stime = overtimeRecordEntity.getOvertimeStime();
			// 如果加班开始时间在这一天内
			if (oConvertUtils.isNotEmpty(stime) && curdate.compareTo(stime)<=0
					&& stime.compareTo(tomDate)<=0) {
				// 将这一天的加班信息 记录至该天中
				uOvertimeRecordEntities.add(overtimeRecordEntity);
			}
		}
		dto.setOvertimeRecordEntities(uOvertimeRecordEntities);

	}

	/**
	 * 检查这一天是否有过请假
	 * 
	 * @author hualong.zhao
	 * @date 2017-11-23
	 * @param dto
	 * @param userHolidayEntities
	 */
	private void checkIshaveHolidaies(UserAttendanceDetailDto dto,
			List<HolidayEntity> userHolidayEntities) {
		//获取有效开始打卡时间
		Date effectiveStime =dto.getEffectiveStime();
		if (oConvertUtils.isEmpty(effectiveStime)) {
			effectiveStime =  dto.getYmdDate();
		} 
		//获取有效结束打卡时间
		Date effectiveEtime = dto.getEffectiveEtime();
		if (oConvertUtils.isEmpty(effectiveEtime)) {
			effectiveEtime =  getexactDate(dto.getYmdDate(), "23:59",0, 0);
		} 
		List<HolidayEntity> uHolidayEntities = new ArrayList<HolidayEntity>();
		// 遍历本月的请假记录，
		for (HolidayEntity holidayEntity : userHolidayEntities) {
			Date startdate = holidayEntity.getHolidayStime();
			Date enddate = holidayEntity.getHolidayEtime();
			// 如果请假开始日期是当天 或者是在当天之前 且 结束日期是当天或当天之后， 则这一天为请假日期
			if (oConvertUtils.isEmpty(startdate)||oConvertUtils.isEmpty(enddate)) {
				//如果开始时间或者是结束时间为空 则认定为该数据为脏数据
				continue;
			}
			// 当请假类型是病假和事假以外的情况
			// 杨曦 20180417
			if(!Globals.REST_TYPE_0.equals(holidayEntity.getHolidayType()) && !Globals.REST_TYPE_1.equals(holidayEntity.getHolidayType())) {
				// 如果跨天，将有效打卡时间设置成前一天的23:59:59
				SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");
				if(dateFormat.format(effectiveEtime).compareTo(dateFormat.format(effectiveStime)) > 0) {
					Calendar cal = Calendar.getInstance();
					cal.setTime(effectiveEtime);
					cal.add(Calendar.DATE, -1);
					cal.set(Calendar.HOUR_OF_DAY, 23);//时  
					cal.set(Calendar.MINUTE, 59);//分  
					cal.set(Calendar.SECOND, 59);//秒 
					effectiveEtime = cal.getTime();
				}
			}
			if (effectiveStime.compareTo(enddate)<=0&&effectiveEtime.compareTo(startdate)>=0) {
				// 将这一天的请假信息 记录至该天中
				uHolidayEntities.add(holidayEntity);
			}
		}
		dto.setUserHolidayEntities(uHolidayEntities);
	}
	
	
	private List<UserAttendanceDetailDto> getallUsefulFieldWithCache(HashMap<String, HashMap<String, Object>> hm_cache, UserAttendanceTotalEntity userAttendanceTotalEntity) throws Exception{
		List<UserAttendanceDetailDto> uatdlist =  new  ArrayList<UserAttendanceDetailDto>();
		List<UserAttendanceDetailDto> updatelist =  new  ArrayList<UserAttendanceDetailDto>();
		String yearmonth = userAttendanceTotalEntity.getYearmonth();
		String userid = userAttendanceTotalEntity.getUserId();
		
		List<ProjarrangeDetailEntity> projarrangeDetailEntities = getUserProjarrangeDetailEntityWithCache(hm_cache, userid, yearmonth);
		ArrayList<UserAttendanceDetailEntity> attendanceDetailEntities = new ArrayList<UserAttendanceDetailEntity>();
		if (!ListUtils.isNullOrEmpty(projarrangeDetailEntities)) {
			ProjarrangeDetailEntity projarrangeDetailEntity = projarrangeDetailEntities.get(0);
			{
				// 当前月无详细考勤记录数据
				// 查询当前月的排班记录。
				String ymddateString =  null;
				uatdlist = getlistbyProjarrangeDetailidWithCache(hm_cache, projarrangeDetailEntity.getId(), ymddateString);
				
				// =====查询请假情况
				List<HolidayEntity> userHolidayEntities = getUserHolidayEntitiesWithCache(hm_cache, userid, yearmonth);
				// =====查询加班情况
				List<OvertimeRecordEntity> overtimeRecordEntities = getOvertimeRecordEntitiesWithCache(hm_cache, userid, yearmonth);
				// =====查询调度情况
				// 01 临时借调（单次）申请表
				List<SnapSingleborrowEntity> snapSingleborrowEntities = getSnapSingleborrowEntitiesWithCache(hm_cache, userid, yearmonth);
					
				// 02 临时借调（固定周期）申请表
				List<SnapRegularborrowEntity> snapRegularborrowEntities = getSnapRegularborrowEntitiesWithCache(hm_cache, userid, yearmonth);
			
				//餐费补贴
				List<MealsSubsidyEntity> mealsSubsidyEntities = getMealsSubsidyEntitiesWithCache(hm_cache);
				
				//餐费扣除标准
				List<MealsDeductEntity> mealsDeductEntities= getMealsDeductEntitiesWithCache(hm_cache);
						
				
				//特殊考勤-手工考勤（默认全勤）的员工
			
				List<TBusSpecialAttendEntity> specialAttendEntities = getSpecialAttendEntitiesWithCache(hm_cache, userid);
				
					
				HashMap<String,TBusSpecialAttendEntity> hm_specialAttendEntities = new HashMap<String,TBusSpecialAttendEntity>();
				if(specialAttendEntities != null && !specialAttendEntities.isEmpty()) {
					for(TBusSpecialAttendEntity spe : specialAttendEntities) {
						hm_specialAttendEntities.put(spe.getUserid(), spe);
					}
				}
			
				if (!ListUtils.isNullOrEmpty(uatdlist)) {
						for (UserAttendanceDetailDto dto : uatdlist) {
							UserAttendanceDetailEntity detailEntity = 	getUserAttendanceDetailEntityfromList(dto,attendanceDetailEntities);
							if ((!ListUtils.isNullOrEmpty(attendanceDetailEntities))&&null==detailEntity) {
							continue;
						}
							dto.setUserid(userid);
						dto.setAttendanceId(userAttendanceTotalEntity.getId());
						if (oConvertUtils.isNotEmpty(dto.getYmdDate())) {
							
							if (!ListUtils.isNullOrEmpty(overtimeRecordEntities)) {
								checkIshaveovertimeRecord(dto,
										overtimeRecordEntities);
							}
							if (!ListUtils.isNullOrEmpty(snapSingleborrowEntities)) {
								checkIshavesnapSingleborrows(dto,
										snapSingleborrowEntities);
							}
							if (!ListUtils.isNullOrEmpty(snapRegularborrowEntities)) {
								checkIshavesnapRegularborrows(dto,
										snapRegularborrowEntities);
							}
							//将某人某天的餐费补贴 信息  添加至dto 中
							if (!ListUtils.isNullOrEmpty(mealsSubsidyEntities)) {
								checkIshavemealsSubsidyEntities(dto,
										mealsSubsidyEntities);
							}
							//将某人某天的餐费补贴  的餐费扣除标准  添加至dto 中
							if (!ListUtils.isNullOrEmpty(mealsDeductEntities)) {
								dto.setMealsDeductEntities(mealsDeductEntities);
							}
						}
						//获取有效开始打卡时间
						Date effectiveStime = calculateEffectiveAttendanceStime(dto);
						dto.setEffectiveStime(effectiveStime);
						//获取有效结束打卡时间
						Date effectiveEtime = calculateEffectiveAttendanceEtime(dto);
						dto.setEffectiveEtime(effectiveEtime);
					
						if (!ListUtils.isNullOrEmpty(userHolidayEntities)) {
							checkIshaveHolidaies(dto, userHolidayEntities);
						}
						
						// 获取当前状态；
						calculateCurdateStatus(dto);
						
						// 获取某人某天在某排班情况下的考勤记录
						List<DingAttendanceinfoEntity> dingAttendanceinfoEntities = getDingAttendanceinfoEntitiesWithCache(hm_cache,dto);
						Collections.sort(dingAttendanceinfoEntities);
//						dingAttendanceinfoService
//								.getDingAttendanceinfoEntities(dto);
						List<UserAttendanceDetailAdjustedEntity> adjustedEntities = getAdjustedAttendEntitiesWithCache(hm_cache, dto);
//						if("ff80808165eb2f2d01660e8b01f94905".equals(dto.getUserid())) {
//							System.out.println("wu");
//						}
						calculateActAttendancetime(dto, dingAttendanceinfoEntities, adjustedEntities, uatdlist,detailEntity);
						//设置基准时间
						calculateDatumDate(hm_cache,dto);
						// 获取实际出勤时间
						calculateActualAttendanceDate(dto);
						// 获取时间差值 
						calculateActualtimeDifference(dto);
						// 获取借调信息
						calculateBorrowsInfo(dto);
						//获取迟到/早退/旷工信息
						calculateBelateAndLeaveEarlyAndabsenteeism(dto);
						//获取加班信息
						calculateOvertime(hm_cache,dto,userAttendanceTotalEntity);
						//计算各种津贴
						calculateSubsidy(dto);
						if (oConvertUtils.isNotEmpty(detailEntity)) {
							updatelist.add(dto);
						}
					}
				} else {
					// 当前人员本月份排班列表为空
				}
			}
		}
		if (!ListUtils.isNullOrEmpty(attendanceDetailEntities)) {
			return updatelist ;
		}else {
			return uatdlist;
		}
	}
	
	/**
	 * @param hm_cache
	 * @param userid
	 * @return
	 */
	private List<UserAttendanceDetailAdjustedEntity> getAdjustedAttendEntitiesWithCache(
			HashMap<String, HashMap<String, Object>> hm_cache,UserAttendanceDetailDto dto) {
		HashMap<String, Object> hm = hm_cache.get("getAdjustedAttendEntitiesWithCache");
		Date curdate = dto.getYmdDate();
		String strDateFormat = "yyyy-MM";
		SimpleDateFormat sdf = new SimpleDateFormat(strDateFormat);
		
		List<UserAttendanceDetailAdjustedEntity> list = null;
		if(hm == null) {
			hm = new HashMap<>();
			hm_cache.put("getAdjustedAttendEntitiesWithCache", hm);
			
			String hql = "from UserAttendanceDetailAdjustedEntity where ymd_date like '" +sdf.format(curdate)+"%'";
			List<UserAttendanceDetailAdjustedEntity> entitiesFromDB = findHql(hql);
			for(UserAttendanceDetailAdjustedEntity entity : entitiesFromDB) {
				String userInEntity = entity.getUserId();
				if(hm.containsKey(userInEntity)) {
					List<UserAttendanceDetailAdjustedEntity> entitylist = (List<UserAttendanceDetailAdjustedEntity>)hm.get(userInEntity);
					entitylist.add(entity);
				}else {
					List<UserAttendanceDetailAdjustedEntity> newlist = new ArrayList<>();
					newlist.add(entity);
					hm.put(userInEntity, newlist);
				}
			}
		}
		return (List<UserAttendanceDetailAdjustedEntity>)hm.get(dto.getUserid());
	}
	/**
	 * @param hm_cache
	 * @param ymddateString
	 * @param ymddateString2 
	 * @return
	 */
	private List<UserAttendanceDetailDto> getlistbyProjarrangeDetailidWithCache(
			HashMap<String, HashMap<String, Object>> hm_cache, String projarrangeDetailEntityId, String ymddateString) {
		HashMap<String, Object> hm = hm_cache.get("getlistbyProjarrangeDetailidWithCache");
		if(hm == null) {
			hm = new HashMap<>();
			hm_cache.put("getlistbyProjarrangeDetailidWithCache", hm);
			
			List<UserAttendanceDetailDto> entitiesFromDB = userAttendanceDetailDao.getlistbyProjarrangeDetailid(null,null,ymddateString);
			for(UserAttendanceDetailDto entity : entitiesFromDB) {
				String id = entity.getProjarrangeDetailid();
				if(hm.containsKey(id)) {
					List<UserAttendanceDetailDto> entitylist = (List<UserAttendanceDetailDto>)hm.get(id);
					entitylist.add(entity);
				}else {
					List<UserAttendanceDetailDto> newlist = new ArrayList<>();
					newlist.add(entity);
					hm.put(id, newlist);
				}
			}
		}
		
		return (List<UserAttendanceDetailDto>)hm.get(projarrangeDetailEntityId);
	}
	/**
	 * @param dto
	 * @return
	 */
	private List<DingAttendanceinfoEntity> getDingAttendanceinfoEntitiesWithCache(HashMap<String, HashMap<String, Object>> hm_cache,UserAttendanceDetailDto dto) {
		HashMap<String, Object> hm = hm_cache.get("getDingAttendanceinfoEntitiesWithCache");
		Date curdate = dto.getYmdDate();
		String strDateFormat = "yyyy-MM";
		SimpleDateFormat sdf = new SimpleDateFormat(strDateFormat);
		Calendar calendar = Calendar.getInstance();
		calendar.setTime(curdate);
		calendar.add(Calendar.DATE, 2);
		Date tomdate = calendar.getTime();
		if(hm == null) {
			hm = new HashMap<>();
			hm_cache.put("getDingAttendanceinfoEntitiesWithCache", hm);
			
			CriteriaQuery cq = new CriteriaQuery(DingAttendanceinfoEntity.class);
			cq.like("attendanceTime", sdf.format(curdate)+"%");
			cq.add();
//			cq.between("attendanceTime", curdate, tomdate);
//			cq.add();
			cq.addOrder("attendanceTime", SortDirection.asc);
			String hql = "from DingAttendanceinfoEntity where attendanceTime like '" +sdf.format(curdate)+"%'";
			List<DingAttendanceinfoEntity> entitiesFromDB = findHql(hql);
					//getListByCriteriaQuery(cq, false);
			for(DingAttendanceinfoEntity entity : entitiesFromDB) {
				String userInEntity = entity.getUserId();
				if(hm.containsKey(userInEntity)) {
					List<DingAttendanceinfoEntity> entitylist = (List<DingAttendanceinfoEntity>)hm.get(userInEntity);
					entitylist.add(entity);
				}else {
					List<DingAttendanceinfoEntity> newlist = new ArrayList<>();
					newlist.add(entity);
					hm.put(userInEntity, newlist);
				}
			}
		}
		
		List<DingAttendanceinfoEntity> allList = (List<DingAttendanceinfoEntity>)hm.get(dto.getUserid());
		if(allList == null) {
			return new ArrayList<DingAttendanceinfoEntity>();
		}
		List<DingAttendanceinfoEntity> selectList = new ArrayList<>();
		for(DingAttendanceinfoEntity attInAll : allList) {
			Date attendanceTime = attInAll.getAttendanceTime();
			if(attendanceTime.after(curdate) && attendanceTime.before(tomdate)) {
				selectList.add(attInAll);
			}
		}
		return selectList;
	}
	/**
	 * @param hm_cache
	 * @return
	 */
	private List<TBusSpecialAttendEntity> getSpecialAttendEntitiesWithCache(HashMap<String, HashMap<String, Object>> hm_cache,String userid) {
		// TODO Auto-generated method stub
		HashMap<String, Object> hm = hm_cache.get("getSpecialAttendEntitiesWithCache");
		List<TBusSpecialAttendEntity> list = null;
		if(hm == null) {
			hm = new HashMap<>();
			hm_cache.put("getSpecialAttendEntitiesWithCache", hm);
			CriteriaQuery specialcq = new CriteriaQuery(TBusSpecialAttendEntity.class);
			specialcq.eq("attendtype", Globals.Special_Attend_Type_All_IN);
			specialcq.add();
			List<TBusSpecialAttendEntity> entitiesFromDB = getListByCriteriaQuery(specialcq, false);
			for(TBusSpecialAttendEntity entity : entitiesFromDB) {
				String userInEntity = entity.getUserid();
				if(hm.containsKey(userInEntity)) {
					List<TBusSpecialAttendEntity> entitylist = (List<TBusSpecialAttendEntity>)hm.get(userInEntity);
					entitylist.add(entity);
				}else {
					List<TBusSpecialAttendEntity> newlist = new ArrayList<>();
					newlist.add(entity);
					hm.put(userInEntity, newlist);
				}
			}
		}
		return (List<TBusSpecialAttendEntity>)hm.get(userid);
		
	}
	/**
	 * @param hm_cache
	 * @return
	 */
	private List<MealsDeductEntity> getMealsDeductEntitiesWithCache(HashMap<String, HashMap<String, Object>> hm_cache) {
		// TODO Auto-generated method stub
		HashMap<String, Object> hm = hm_cache.get("getMealsDeductEntitiesWithCache");
		List<MealsDeductEntity> list = null;
		if(hm == null) {
			hm = new HashMap<>();
			hm_cache.put("getMealsDeductEntitiesWithCache", hm);
			CriteriaQuery mdcq = new CriteriaQuery(MealsDeductEntity.class);
			mdcq.eq("deleteFlag", "0");
			mdcq.add();
			mdcq.eq("status", "0");
			mdcq.add();
			List<MealsDeductEntity> entitiesFromDB = getListByCriteriaQuery(mdcq, false);
			hm.put("ALL", entitiesFromDB);
		}
		
		return list = (List<MealsDeductEntity>)hm.get("ALL");
	}
	/**
	 * @param hm_cache
	 * @return
	 */
	private List<MealsSubsidyEntity> getMealsSubsidyEntitiesWithCache(HashMap<String, HashMap<String, Object>> hm_cache) {
		HashMap<String, Object> hm = hm_cache.get("getMealsSubsidyEntitiesWithCache");
		List<MealsSubsidyEntity> list = null;
		if(hm == null) {
			hm = new HashMap<>();
			hm_cache.put("getMealsSubsidyEntitiesWithCache", hm);
			CriteriaQuery mscq = new CriteriaQuery(MealsSubsidyEntity.class);
			mscq.eq("deleteFlag", "0");
			mscq.add();
			mscq.eq("status", "0");
			mscq.add();
			List<MealsSubsidyEntity> entitiesFromDB = getListByCriteriaQuery(mscq, false);
			hm.put("ALL", entitiesFromDB);
		}
		
		return  (List<MealsSubsidyEntity>)hm.get("ALL");
	}
	/**
	 * @param hm_cache
	 * @param userid
	 * @param yearmonth
	 * @return
	 * @throws Exception 
	 */
	private List<SnapRegularborrowEntity> getSnapRegularborrowEntitiesWithCache(
			HashMap<String, HashMap<String, Object>> hm_cache, String userid, String yearmonth) throws Exception {
		HashMap<String, Object> hm = hm_cache.get("getSnapRegularborrowEntitiesWithCache");
		List<SnapRegularborrowEntity> list = null;
		if(hm == null) {
			hm = new HashMap<>();
			hm_cache.put("getSnapRegularborrowEntitiesWithCache", hm);
			CriteriaQuery cq = new CriteriaQuery(
					SnapRegularborrowEntity.class);
			cq.eq("yearmonth", yearmonth);
			cq.add();
			List<SnapRegularborrowEntity> entitiesFromDB = 	snapRegularborrowService
					.getSnapRegularborrowEntities(null, yearmonth);
			for(SnapRegularborrowEntity entity : entitiesFromDB) {
				String userInEntity = entity.getUserid();
				if(hm.containsKey(userInEntity)) {
					List<SnapRegularborrowEntity> entitylist = (List<SnapRegularborrowEntity>)hm.get(userInEntity);
					entitylist.add(entity);
				}else {
					List<SnapRegularborrowEntity> newlist = new ArrayList<>();
					newlist.add(entity);
					hm.put(userInEntity, newlist);
				}
			}
		}
		
		return (List<SnapRegularborrowEntity>)hm.get(userid);
	}
	/**
	 * @param hm_cache
	 * @param userid
	 * @param yearmonth
	 * @return
	 * @throws Exception 
	 */
	private List<SnapSingleborrowEntity> getSnapSingleborrowEntitiesWithCache(
			HashMap<String, HashMap<String, Object>> hm_cache, String userid, String yearmonth) throws Exception {
		HashMap<String, Object> hm = hm_cache.get("getSnapSingleborrowEntitiesWithCache");
		List<SnapSingleborrowEntity> list = null;
		if(hm == null) {
			hm = new HashMap<>();
			hm_cache.put("getSnapSingleborrowEntitiesWithCache", hm);
			CriteriaQuery cq = new CriteriaQuery(
					SnapSingleborrowEntity.class);
			cq.eq("yearmonth", yearmonth);
			cq.add();
			List<SnapSingleborrowEntity> entitiesFromDB = snapSingleborrowService
					.getSnapSingleborrowEntities(null, yearmonth);
			for(SnapSingleborrowEntity entity : entitiesFromDB) {
				String userInEntity = entity.getUserid();
				if(hm.containsKey(userInEntity)) {
					List<SnapSingleborrowEntity> entitylist = (List<SnapSingleborrowEntity>)hm.get(userInEntity);
					entitylist.add(entity);
				}else {
					List<SnapSingleborrowEntity> newlist = new ArrayList<>();
					newlist.add(entity);
					hm.put(userInEntity, newlist);
				}
			}
		}
		
		return (List<SnapSingleborrowEntity>)hm.get(userid);
	}
	/**
	 * @param hm_cache
	 * @param userid
	 * @param yearmonth
	 * @return
	 * @throws Exception 
	 */
	private List<OvertimeRecordEntity> getOvertimeRecordEntitiesWithCache(
			HashMap<String, HashMap<String, Object>> hm_cache, String userid, String yearmonth) throws Exception {
		HashMap<String, Object> hm = hm_cache.get("getOvertimeRecordEntitiesWithCache");
		List<OvertimeRecordEntity> list = null;
		if(hm == null) {
			hm = new HashMap<>();
			hm_cache.put("getOvertimeRecordEntitiesWithCache", hm);
			CriteriaQuery cq = new CriteriaQuery(
					OvertimeRecordEntity.class);
			cq.eq("yearmonth", yearmonth);
			cq.add();
			List<OvertimeRecordEntity> entitiesFromDB = overtimeRecordService.getOvertimeRecordEntities(null, yearmonth);
			for(OvertimeRecordEntity entity : entitiesFromDB) {
				String userInEntity = entity.getUserid();
				if(hm.containsKey(userInEntity)) {
					List<OvertimeRecordEntity> entitylist = (List<OvertimeRecordEntity>)hm.get(userInEntity);
					entitylist.add(entity);
				}else {
					List<OvertimeRecordEntity> newlist = new ArrayList<>();
					newlist.add(entity);
					hm.put(userInEntity, newlist);
				}
			}
		}
		
		return (List<OvertimeRecordEntity>)hm.get(userid);
	}
	/**
	 * @param hm_cache
	 * @param userid
	 * @param yearmonth
	 * @return
	 * @throws Exception 
	 */
	private List<HolidayEntity> getUserHolidayEntitiesWithCache(HashMap<String, HashMap<String, Object>> hm_cache, String userid,
			String yearmonth) throws Exception {
		HashMap<String, Object> hm = hm_cache.get("getUserHolidayEntitiesWithCache");
		if(hm == null) {
			hm = new HashMap<>();
			hm_cache.put("getUserHolidayEntitiesWithCache", hm);
			List<HolidayEntity> userHolidayEntities = holidayService
					.getUserHolidayEntities(null, yearmonth);
			for(HolidayEntity entity : userHolidayEntities) {
				String userInEntity = entity.getUserid();
				if(hm.containsKey(userInEntity)) {
					List<HolidayEntity> entitylist = (List<HolidayEntity>)hm.get(userInEntity);
					entitylist.add(entity);
				}else {
					List<HolidayEntity> newlist = new ArrayList<>();
					newlist.add(entity);
					hm.put(userInEntity, newlist);
				}
			}
		}
		
		return (List<HolidayEntity>)hm.get(userid);
	}
	/**
	 * @param hm_cache
	 * @param userid
	 * @param yearmonth
	 * @return
	 */
	@SuppressWarnings("unchecked")
	private List<ProjarrangeDetailEntity> getUserProjarrangeDetailEntityWithCache(
			HashMap<String, HashMap<String, Object>> hm_cache, String userid, String yearmonth) {
		HashMap<String, Object> hm = hm_cache.get("getUserProjarrangeDetailEntityWithCache");
		List<ProjarrangeDetailEntity> list = null;
		if(hm == null) {
			hm = new HashMap<>();
			hm_cache.put("getUserProjarrangeDetailEntityWithCache", hm);
			CriteriaQuery cq = new CriteriaQuery(
					ProjarrangeDetailEntity.class);
			cq.eq("yearmonth", yearmonth);
			cq.add();
			List<ProjarrangeDetailEntity> projarrangeDetailEntities = getListByCriteriaQuery(
					cq, false);
			for(ProjarrangeDetailEntity entity : projarrangeDetailEntities) {
				String userInEntity = entity.getUserid();
				if(hm.containsKey(userInEntity)) {
					List<ProjarrangeDetailEntity> entitylist = (List<ProjarrangeDetailEntity>)hm.get(userInEntity);
					entitylist.add(entity);
				}else {
					List<ProjarrangeDetailEntity> newlist = new ArrayList<>();
					newlist.add(entity);
					hm.put(userInEntity, newlist);
				}
			}
		}
		
		return (List<ProjarrangeDetailEntity>)hm.get(userid);
	}
	
	private List<OvertimeRecordEntity> getOvertimeRecordEntities(String userid,
			String yearmonth) throws Exception {
		List<OvertimeRecordEntity> resultEntities = new ArrayList<OvertimeRecordEntity>();

		CriteriaQuery cq = new CriteriaQuery(OvertimeRecordEntity.class);
		cq.eq("deleteFlag", "0");
		cq.add();
		if (oConvertUtils.isNotEmpty(userid)) {
			cq.eq("userid", userid);
			cq.add();
		}
		if (oConvertUtils.isNotEmpty(yearmonth)) {
			Calendar cal = Calendar.getInstance();// 获取当前日期
			cal.set(Integer.valueOf(yearmonth.split("-")[0]),
					Integer.valueOf(yearmonth.split("-")[1]) - 2, 1);
			Date startdate = cal.getTime();// 上个月的一号
			cal.add(Calendar.MONTH, 2);
			Date enddate = cal.getTime();// 下个月的一号
			cq.between("overtimeStime", startdate, enddate);
			cq.add();
		}
		resultEntities = getListByCriteriaQuery(cq, false);
		return resultEntities;
	}
	
	public List<HolidayEntity> getUserHolidayEntities(String userid,
			String yearmonth) throws Exception {
		List<HolidayEntity>  resulEntities =  new ArrayList<HolidayEntity>();

		CriteriaQuery cq = new CriteriaQuery(HolidayEntity.class);
		cq.eq("bpmStatus", WorkFlowGlobals.BPM_BUS_STATUS_3);
		cq.add();
		cq.eq("deleteFlag", "0");
		cq.add();
		if (oConvertUtils.isNotEmpty(userid)) {
		cq.eq("userid", userid);
		cq.add();
		}
		if (oConvertUtils.isNotEmpty(yearmonth)) {
			Calendar cal = Calendar.getInstance();// 获取当前日期
			cal.set(Integer.valueOf(yearmonth.split("-")[0]), Integer.valueOf(yearmonth.split("-")[1]) - 1, 1);
			cal.set(Calendar.HOUR_OF_DAY, 0);
			cal.set(Calendar.MINUTE, 0);
			cal.set(Calendar.SECOND, 0);
			cal.add(Calendar.SECOND, -1);
			Date startdate = cal.getTime();// 上个月的一号
			cal.add(Calendar.MONTH, 1);
			cal.set(Calendar.HOUR_OF_DAY, 23);
			cal.set(Calendar.MINUTE, 59);
			cal.set(Calendar.SECOND, 59);
			Date enddate = cal.getTime();// 下个月的一号
		cq.between("holidayStime", startdate, enddate);
		cq.add();
		}
		resulEntities = getListByCriteriaQuery(cq, false);
		return resulEntities;
	}
	
	public List<SnapSingleborrowEntity> getSnapSingleborrowEntities(
			String userid, String yearmonth) throws Exception {
		List<SnapSingleborrowEntity>  resulEntities =  new ArrayList<SnapSingleborrowEntity>();
	//需求
	//	由A部门调到B部门     调出日5号   算在A部门    调入日六号   算在B部门  终止日8 号 算在B部门
		
		CriteriaQuery cq = new CriteriaQuery(SnapSingleborrowEntity.class);
		cq.eq("bpmStatus", WorkFlowGlobals.BPM_BUS_STATUS_3);
		cq.add();
		cq.eq("deleteFlag", "0");
		cq.add();
		if (oConvertUtils.isNotEmpty(userid)) {
		cq.eq("userid", userid);
		cq.add();
		}
		if (oConvertUtils.isNotEmpty(yearmonth)) {
			Calendar cal = Calendar.getInstance();
			cal.set(Integer.valueOf(yearmonth.split("-")[0]),
					Integer.valueOf(yearmonth.split("-")[1]) - 2, 1);
			Date startdate = cal.getTime();// 上个月的一号
			cal.add(Calendar.MONTH, 2);
			Date enddate = cal.getTime();// 下个月的一号
			cq.between("outTime", startdate, enddate);
			cq.add();
			cq.isNotNull("deadDate");
			cq.add();
		}
		resulEntities = getListByCriteriaQuery(cq, false);
		return resulEntities;
	}
	
	public List<SnapRegularborrowEntity> getSnapRegularborrowEntities(
			String userid, String yearmonth) throws Exception {
		List<SnapRegularborrowEntity>  resulEntities =  new ArrayList<SnapRegularborrowEntity>();
	//需求
	//	由A部门调到B部门     调出日5号   算在A部门    调入日六号   算在B部门  终止日8 号 算在B部门
		
		CriteriaQuery cq = new CriteriaQuery(SnapRegularborrowEntity.class);
		cq.eq("bpmStatus", WorkFlowGlobals.BPM_BUS_STATUS_3);
		cq.add();
		cq.eq("deleteFlag", "0");
		cq.add(); 
		if (oConvertUtils.isNotEmpty(userid)) {
		cq.eq("userid", userid);
		cq.add();
		}
		if (oConvertUtils.isNotEmpty(yearmonth)) {
			Calendar cal = Calendar.getInstance();
			cal.set(Integer.valueOf(yearmonth.split("-")[0]),
					Integer.valueOf(yearmonth.split("-")[1]) - 1, 1);
			Date startdate = cal.getTime();// 这个月的一号
			cal.add(Calendar.MONTH, 1);
			Date enddate = cal.getTime();// 下个月的一号
			cq.le("inTime", enddate);
			cq.add();
			cq.ge("deadDate", startdate);
			cq.between("outTime", startdate, enddate);
			cq.add();
			
		}
		resulEntities = getListByCriteriaQuery(cq, false);
		return resulEntities;
	}
	
	public List<DingAttendanceinfoEntity> getDingAttendanceinfoEntities(
			UserAttendanceDetailDto dto) throws Exception {
		List<DingAttendanceinfoEntity> resultlist = new ArrayList<DingAttendanceinfoEntity>();
		Date curdate = dto.getYmdDate();
		Calendar calendar = Calendar.getInstance();
		calendar.setTime(curdate);
		calendar.add(Calendar.DATE, 2);
		Date tomdate = calendar.getTime();
		CriteriaQuery cq = new CriteriaQuery(DingAttendanceinfoEntity.class);
		cq.eq("userId", dto.getUserid());
		cq.add();
		cq.between("attendanceTime", curdate, tomdate);
		cq.add();
		cq.addOrder("attendanceTime", SortDirection.asc);
		cq.add();
		resultlist = getListByCriteriaQuery(cq, false);
		return resultlist;
	}
	
	@Override
	public List<UserAttendanceDetailDto> getallUsefulField(UserAttendanceTotalEntity userAttendanceTotalEntity,List<UserAttendanceDetailEntity> attendanceDetailEntities ,Date ymdDate)
			throws Exception {
		List<UserAttendanceDetailDto> uatdlist =  new  ArrayList<UserAttendanceDetailDto>();
		List<UserAttendanceDetailDto> updatelist =  new  ArrayList<UserAttendanceDetailDto>();
		String yearmonth = userAttendanceTotalEntity.getYearmonth();
		String userid = userAttendanceTotalEntity.getUserId();
		 {
			// 查询当前员工在当前处理月度的【项目排班详细】
			CriteriaQuery cq = new CriteriaQuery(
					ProjarrangeDetailEntity.class);
			cq.eq("userid", userid);
			cq.add();
			cq.eq("yearmonth", yearmonth);
			cq.add();
			// 通过上述三个条件的筛选， 原则上而言， 应该是有且只有一条记录
			List<ProjarrangeDetailEntity> projarrangeDetailEntities = getListByCriteriaQuery(
					cq, false);
			if (!ListUtils.isNullOrEmpty(projarrangeDetailEntities)) {
				ProjarrangeDetailEntity projarrangeDetailEntity = projarrangeDetailEntities.get(0);
				{
					// 当前月无详细考勤记录数据
					// 查询当前月的排班记录。
					String ymddateString =  null;
					if (oConvertUtils.isNotEmpty(ymdDate)) {
						ymddateString =  DataUtils.date2Str(ymdDate, DataUtils.date_sdf);
					}
					uatdlist = userAttendanceDetailDao.getlistbyProjarrangeDetailid(projarrangeDetailEntity.getId(),null,ymddateString);
					// =====查询请假情况
					List<HolidayEntity> userHolidayEntities = getUserHolidayEntities(userid, yearmonth);
					// =====查询加班情况
					List<OvertimeRecordEntity> overtimeRecordEntities = getOvertimeRecordEntities(userid, yearmonth);
					// =====查询调度情况
					// 01 临时借调（单次）申请表
					List<SnapSingleborrowEntity> snapSingleborrowEntities = getSnapSingleborrowEntities(userid, yearmonth);
					// 02 临时借调（固定周期）申请表
					List<SnapRegularborrowEntity> snapRegularborrowEntities = getSnapRegularborrowEntities(userid, yearmonth);
					CriteriaQuery mscq = new CriteriaQuery(MealsSubsidyEntity.class);
					mscq.eq("deleteFlag", "0");
					mscq.add();
					mscq.eq("status", "0");
					mscq.add();
					//餐费补贴
					List<MealsSubsidyEntity> mealsSubsidyEntities=getListByCriteriaQuery(mscq, false);
					
					CriteriaQuery mdcq = new CriteriaQuery(MealsDeductEntity.class);
					mdcq.eq("deleteFlag", "0");
					mdcq.add();
					mdcq.eq("status", "0");
					mdcq.add();
					//餐费扣除标准
					List<MealsDeductEntity> mealsDeductEntities=getListByCriteriaQuery(mdcq, false);
					
					//特殊考勤-手工考勤（默认全勤）的员工
//					CriteriaQuery specialcq = new CriteriaQuery(TBusSpecialAttendEntity.class);
//					specialcq.eq("attendtype", Globals.Special_Attend_Type_All_IN);
//					specialcq.add();
//					List<TBusSpecialAttendEntity> specialAttendEntities = getListByCriteriaQuery(specialcq, false);
//					HashMap<String,TBusSpecialAttendEntity> hm_specialAttendEntities = new HashMap<String,TBusSpecialAttendEntity>();
//					if(specialAttendEntities != null && !specialAttendEntities.isEmpty()) {
//						for(TBusSpecialAttendEntity spe : specialAttendEntities) {
//							hm_specialAttendEntities.put(spe.getUserid(), spe);
//						}
//					}
					if (null==attendanceDetailEntities) {
						attendanceDetailEntities = new ArrayList<UserAttendanceDetailEntity>();
					}
					if (!ListUtils.isNullOrEmpty(uatdlist)) {
 						for (UserAttendanceDetailDto dto : uatdlist) {
 							UserAttendanceDetailEntity detailEntity = 	getUserAttendanceDetailEntityfromList(dto,attendanceDetailEntities);
 							if ((!ListUtils.isNullOrEmpty(attendanceDetailEntities))&&null==detailEntity) {
								continue;
							}
 							dto.setUserid(userid);
							dto.setAttendanceId(userAttendanceTotalEntity.getId());
							if (oConvertUtils.isNotEmpty(dto.getYmdDate())) {
								
								if (!ListUtils.isNullOrEmpty(overtimeRecordEntities)) {
									checkIshaveovertimeRecord(dto,
											overtimeRecordEntities);
								}
								if (!ListUtils.isNullOrEmpty(snapSingleborrowEntities)) {
									checkIshavesnapSingleborrows(dto,
											snapSingleborrowEntities);
								}
								if (!ListUtils.isNullOrEmpty(snapRegularborrowEntities)) {
									checkIshavesnapRegularborrows(dto,
											snapRegularborrowEntities);
								}
								//将某人某天的餐费补贴 信息  添加至dto 中
								if (!ListUtils.isNullOrEmpty(mealsSubsidyEntities)) {
									checkIshavemealsSubsidyEntities(dto,
											mealsSubsidyEntities);
								}
								//将某人某天的餐费补贴  的餐费扣除标准  添加至dto 中
								if (!ListUtils.isNullOrEmpty(mealsDeductEntities)) {
									dto.setMealsDeductEntities(mealsDeductEntities);
								}
							}
							//获取有效开始打卡时间
							Date effectiveStime = calculateEffectiveAttendanceStime(dto);
							dto.setEffectiveStime(effectiveStime);
							//获取有效结束打卡时间
							Date effectiveEtime = calculateEffectiveAttendanceEtime(dto);
							dto.setEffectiveEtime(effectiveEtime);
						
							if (!ListUtils.isNullOrEmpty(userHolidayEntities)) {
								checkIshaveHolidaies(dto, userHolidayEntities);
							}
							
							// 获取当前状态；
							calculateCurdateStatus(dto);
							
							// 获取某人某天在某排班情况下的考勤记录
							List<DingAttendanceinfoEntity> dingAttendanceinfoEntities = getDingAttendanceinfoEntities(dto);
							calculateActAttendancetime(dto, dingAttendanceinfoEntities, null,uatdlist,detailEntity);
							//设置基准时间
							calculateDatumDate(null,dto);
							// 获取实际出勤时间
							calculateActualAttendanceDate(dto);
							// 获取时间差值 
							calculateActualtimeDifference(dto);
							// 获取借调信息
							calculateBorrowsInfo(dto);
							//获取迟到/早退/旷工信息
							calculateBelateAndLeaveEarlyAndabsenteeism(dto);
							//获取加班信息
							calculateOvertime(null,dto,userAttendanceTotalEntity);
							//计算各种津贴
							calculateSubsidy(dto);
							if (oConvertUtils.isNotEmpty(detailEntity)) {
								updatelist.add(dto);
							}
							if (oConvertUtils.isNotEmpty(ymdDate)) {
								AttendanceDetailJsonObj jsonObj = getjsonObjfromDto(dto);
								dto.setJsonObj(jsonObj);
							}
						}
					} else {
						// 当前人员本月份排班列表为空
					}
				}  
			}
		} 
		if (!ListUtils.isNullOrEmpty(attendanceDetailEntities)) {
			return updatelist ;
		}else {
			return uatdlist;
		}
	}
	/**
	 * 通过考勤详情列表 获取考勤详情信息
	 * @author hualong.zhao
	 * @date 2017-12-5
	 * @param dto
	 * @param attendanceDetailEntities
	 * @return
	 */
	private UserAttendanceDetailEntity getUserAttendanceDetailEntityfromList(UserAttendanceDetailDto dto,
			List<UserAttendanceDetailEntity> attendanceDetailEntities){
		UserAttendanceDetailEntity resultentry = null;
		if (!ListUtils.isNullOrEmpty(attendanceDetailEntities)) {
			for (UserAttendanceDetailEntity entry:attendanceDetailEntities) {
				if (dto.getYmdDate().equals(entry.getYmdDate())) {
					resultentry = entry;
					 break;
				}
			}
		}
		return resultentry;
	}
 

/**
 * 检查某人某天的餐费补贴
 * @author hualong.zhao
 * @date 2017-12-2
 * @param dto
 * @param mealsSubsidyEntities
 */
private void checkIshavemealsSubsidyEntities(UserAttendanceDetailDto dto,
			List<MealsSubsidyEntity> mealsSubsidyEntities) {
		List<MealsSubsidyEntity> dtomealsSubsidyEntities = dto
				.getMealsSubsidyEntities();
		/** 班次餐补ID */
		String dutyMealid = oConvertUtils.getString(dto.getDutyMealid());
		if (oConvertUtils.isNotEmpty(dutyMealid)) {
			for (MealsSubsidyEntity entity : mealsSubsidyEntities) {
				if (dutyMealid.contains(entity.getId())) {
					if (Globals.SUBSIDY_TYPE_BCCB.equals(oConvertUtils.getString(entity.getSubsidyType()))) {
						dtomealsSubsidyEntities.add(entity);
					}
				}
			}
		}
		dto.setMealsSubsidyEntities(dtomealsSubsidyEntities);
	}
/**
 * 计算津贴
 * 夜班最多可提供两次餐补 ， 餐补类型【夜班白班津贴】 和【夜班夜班津贴】 由班次表 动态配置
 * 日班提供两次餐补，
 * 常班提供一次餐补， 
 * 扣除规则： 
 * 如果是夜班时 ，根据迟到时间， 判断是否给与第一次餐补【夜班夜班津贴】
 * 如果是夜班时 ，根据早退时间， 判断是否给与第二次餐补【夜班白班津贴】
 * 如果是日班时 ，根据总的欠勤数， 判断扣除几顿
 * 
 * 如果是常班时，根据总的欠勤数，判断是否给与餐补
 * 2018年1月12日  需求变更： 当员工当天没有打卡记录的时候， 该员工餐补不提供
 * @author hualong.zhao
 * @date 2017-12-2
 * @param dto
 */
private void calculateSubsidy(UserAttendanceDetailDto dto) {
	
	/**夜班白班津贴*/
     Integer dayShiftSubsidy = 0 ;
	/**夜班夜班津贴*/
     Integer nightShiftSubsidy = 0;
	/**日班*/
    Integer dayShift = 0;
	/**常班*/
     Integer regularShift = 0;
  
     /** 餐补补贴次数~餐补idmap */
     HashMap<String, MealsSubsidyEntity> mealsmap = new HashMap<>();
     //餐费补贴
     List<MealsSubsidyEntity> dtomealsSubsidyEntities = dto.getMealsSubsidyEntities();
     //餐费扣除标准
 	List<MealsDeductEntity> mealsDeductEntities=dto.getMealsDeductEntities();

 	//  请假 /休息  补贴清零    旷工一天  补贴清空 迟到早退   根据欠勤分钟数    按照餐费扣除标准 进行扣除  只记录  查询  判断    班次餐补  加班情况下  只考虑按此给0 or 1 
		if (dto.getLongHoliday()) {
			if(dto.getActualAttendanceDate() == null || dto.getActualAttendanceDate().compareTo(BigDecimal.ZERO)<=0) {
				dto.setDayShiftSubsidy(dayShiftSubsidy);
				dto.setNightShiftSubsidy(nightShiftSubsidy);
				dto.setDayShift(dayShift);
				dto.setRegularShift(regularShift);
				return;
			}
		}
		if((Globals.DUTYTYPE_xiuxi.equals(oConvertUtils.getString(dto.getDutyType())))) {
			dto.setDayShiftSubsidy(dayShiftSubsidy);
			dto.setNightShiftSubsidy(nightShiftSubsidy);
			dto.setDayShift(dayShift);
			dto.setRegularShift(regularShift);
			return;
		}
				if (!ListUtils.isNullOrEmpty(dtomealsSubsidyEntities)) {
			 	 	for (MealsSubsidyEntity entry:dtomealsSubsidyEntities) {
			 	 		String shiftSubsidyType = oConvertUtils.getString(entry.getShiftSubsidyType());
			 	 		if (Globals.SHIFT_SUBSIDY_TYPE_YEBANJINTIEWAN.equals(shiftSubsidyType)) {
			 	 			if (Globals.DUTYTYPE_yeban115.equals(oConvertUtils.getString(dto.getDutyType()))) {
			 	 			nightShiftSubsidy = 1 ;
			 	 			mealsmap.put("nightShiftSubsidy", entry);
			 	 			}
			 			}
			 	 		if (Globals.SHIFT_SUBSIDY_TYPE_BAIBANJINTIEZAO.equals(shiftSubsidyType)) {
			 	 			if (Globals.DUTYTYPE_yeban115.equals(oConvertUtils.getString(dto.getDutyType()))) {
			 	 			dayShiftSubsidy = 1 ;
			 	 			mealsmap.put("dayShiftSubsidy", entry);
			 	 			}
			 	 		}
			 	 		if (Globals.SHIFT_SUBSIDY_TYPE_RIBAN.equals(shiftSubsidyType)) {
			 	 			if (Globals.DUTYTYPE_riban11h.equals(oConvertUtils.getString(dto.getDutyType()))) {
			 					dayShift = 2;
			 	 	 			mealsmap.put("dayShift", entry);
			 				}
			 	 		}
			 	 		if (Globals.SHIFT_SUBSIDY_TYPE_CHANGBAN.equals(shiftSubsidyType)) {
			 	 			if (Globals.DUTYTYPE_CHANGBAN8H.equals(oConvertUtils.getString(dto.getDutyType()))) {
			 					regularShift = 1 ;
			 	 	 			mealsmap.put("regularShift", entry);
			 				}
			 	 		}
			 		}
				}
			
 
 	//如果扣费规则不为空
	 if (!ListUtils.isNullOrEmpty(mealsDeductEntities)) {
		 /**迟到分钟数*/
		 int  belatemins  =  dto.getBelatemins();
		 /**早退分钟数*/
		 int  leaveEarlymins  = dto.getLeaveEarlymins();
		 int thinsorsickmins = dto.getSickLeaveMins().intValue()+dto.getThingLeaveMins().intValue();
		 int qqmins =belatemins + leaveEarlymins+thinsorsickmins ; 
		 String durationCode =  dto.getDurationCode();
		//根据餐费扣除标准   扣除餐补  
		 	for (MealsDeductEntity entity : mealsDeductEntities) {
				if (Globals.SUBSIDY_TYPE_BCCB.equals(oConvertUtils.getString(entity.getSubsidyType()))) {
					Integer leftHours = entity.getLeftHours();
					Integer rightHours = entity.getRightHours();
					/**扣除数*/
					BigDecimal deductNum = entity.getDeductNum();
					if (oConvertUtils.isNotEmpty(leftHours)&&oConvertUtils.isNotEmpty(rightHours)) {
						leftHours = leftHours*60;
						rightHours = rightHours*60;
						if (Globals.DUTYTYPE_yeban115.equals(oConvertUtils.getString(dto.getDutyType()))) {
							int iamlate = belatemins ; 
							//迟到满足扣除标准
							if ("1".equals(oConvertUtils.getString(durationCode))) {
								//当天请假是前半夜假期
								iamlate += thinsorsickmins;
							}
							if (iamlate>=leftHours&&iamlate<rightHours) {
									if (null != deductNum) {
										try {
										int deductNumint =deductNum.intValue();
										nightShiftSubsidy = nightShiftSubsidy - deductNumint;
										} catch (Exception e) {
										}
									}
							}
							int iamleaveEarly = leaveEarlymins;
							if ("1".equals(oConvertUtils.getString(durationCode))) {
								//当天请假是后半夜假期
								iamleaveEarly += thinsorsickmins;
							}
							//早退满足扣除标准
							if (iamleaveEarly>=leftHours&&iamleaveEarly<rightHours) {
							
								if (null != deductNum) {
									try {
										int deductNumint =deductNum.intValue();
										dayShiftSubsidy = dayShiftSubsidy - deductNumint;
									} catch (Exception e) {
									}
								}
							}
							/**
							 * 迟到 or  早退 超过x 小时满足扣除两顿时  ， 两顿餐补都扣除。 
							 */
							if (qqmins>=leftHours&&qqmins<rightHours) {
								try {
									int deductNumint =deductNum.intValue();
									if (deductNumint>=2) {
										nightShiftSubsidy = 0;
										dayShiftSubsidy = 0;
									}
								} catch (Exception e) {
								}
							}
						}else {
							/**
							 * 迟到满足扣除标准
							 * 如果是日班时 ，根据总的欠勤数， 判断扣除几顿
							 * 如果是常班时，根据总的欠勤数，判断是否给与餐补
							 * 
							 * 欠勤分钟数 应该添加 当天申请的事假 or 病假的分钟数
							 */
							if (qqmins>=leftHours&&qqmins<rightHours) {
									if (null != deductNum) {
										try {
										int deductNumint =deductNum.intValue();
										if (Globals.DUTYTYPE_riban11h.equals(oConvertUtils.getString(dto.getDutyType()))) {
											dayShift = dayShift - deductNumint;
										}
										if (Globals.DUTYTYPE_CHANGBAN8H.equals(oConvertUtils.getString(dto.getDutyType()))) {
											regularShift = regularShift - deductNumint;
										}
										} catch (Exception e) {
										}
									}
							}
						}
					}
				}
			}
	}
	//实际上班时间
	Date   actattendanceDate = dto.getActattendanceDate();
	//实际下班时间
	Date   actretreatDate= dto.getActretreatDate();
	// 当员工当天没有打卡记录的时候， 该员工餐补不提供
	 if (oConvertUtils.isEmpty(actattendanceDate)&&oConvertUtils.isEmpty(actretreatDate)) {
		 	dayShiftSubsidy = 0;
		 	nightShiftSubsidy = 0;
		 	regularShift = 0;
		 	dayShift = 0;
	}
 	//对餐补进行非负处理   最小值为零
 	dayShiftSubsidy = dayShiftSubsidy<0?0:dayShiftSubsidy;
 	nightShiftSubsidy = nightShiftSubsidy<0?0:nightShiftSubsidy;
 	regularShift = regularShift<0?0:regularShift;
 	dayShift = dayShift<0?0:dayShift;
 	//夜班白班津贴
		if (0 != dayShiftSubsidy) {
			MealsSubsidyEntity entity = mealsmap.get("dayShiftSubsidy");
			if (entity != null) {
				  dto.setDayShiftSubsidyId(entity.getId());
			}
		}
  //夜班夜班津贴
	  if (0!=nightShiftSubsidy) {
		  MealsSubsidyEntity entity = mealsmap.get("nightShiftSubsidy");
			if (entity != null) {
				dto.setNightShiftSubsidyId(entity.getId());
			}
		  
	}
  // 日班
	  if (0!=dayShift) {
		  MealsSubsidyEntity entity = mealsmap.get("dayShift");
			if (entity != null) {
				dto.setDayShiftId(entity.getId());
			}
		  
		  
	}
  //常班
	  if (0!=regularShift) {
		  MealsSubsidyEntity entity = mealsmap.get("regularShift");
			if (entity != null) {
				dto.setRegularShiftId(entity.getId());
			}
		  
	}
	//如果同一天 已经有了 班次 餐补， 再次出现 加班 备案 餐补时， 这天的加班备案餐补 次数 不能计入 总数。按0处理。
    dto.setDayShiftSubsidy(dayShiftSubsidy);
    dto.setNightShiftSubsidy(nightShiftSubsidy);
    dto.setDayShift(dayShift);
    dto.setRegularShift(regularShift);
}

/**
 * 计算当天的加班时间(必须在计算当天实际出勤时长的方法之后执行)
 * @author hualong.zhao
 * @param hm_cache 
 * @date 2017-12-1
 * @param dto
 * @param userAttendanceTotalEntity 
 */
	private void calculateOvertime(HashMap<String, HashMap<String, Object>> hm_cache, UserAttendanceDetailDto dto, UserAttendanceTotalEntity userAttendanceTotalEntity) {
		/**国定加班时长*/
	     BigDecimal nationalOvertimeDuration = BigDecimal.ZERO;
		/**特殊加班费*/
	     BigDecimal specialOvertime = BigDecimal.ZERO;
	  
	     List<OvertimeRecordEntity> list = dto.getOvertimeRecordEntities();
	    
		/**
		 * 国定加班时长 包括两部分： 1. 排班中按照不同的班次及法定假日计算当月的法定假日； 2. 当月加班备案中申请的国定加班时长
		 * A=法定假日当天排班的基准时长累计； B=当月加班备案中国定加班时长累计； 国定加班时长 = A+B;
		 */
	     if (!ListUtils.isNullOrEmpty(list)) {
			 //检索加班
	    	 for (OvertimeRecordEntity entry:list) {
	    		 BigDecimal overtimeBigDecimal = entry.getOvertimeHours();
	    		 if (null==overtimeBigDecimal) {
	    			 overtimeBigDecimal = BigDecimal.ZERO;
				}
				if ("1".equals(oConvertUtils.getString(entry.getIfnational()))) {
					nationalOvertimeDuration =overtimeBigDecimal;
				}else {
					specialOvertime=overtimeBigDecimal;
				}
			}
		}
//	     if("000000006120dd1c01612cf52162014f".equals(dto.getUserid())) {
//    		 System.out.println();
//    	 }
	     //计算115夜班前半夜或者后半夜是国定假的情况
	     BigDecimal halfNationOvertime = calculateHalfNationalOvertime(hm_cache, dto,true);
	     if(halfNationOvertime.compareTo(BigDecimal.ZERO)>0 && halfNationOvertime.compareTo(new BigDecimal(11.5*60))<0) {
	    	
	    	 nationalOvertimeDuration = nationalOvertimeDuration.add(halfNationOvertime);
	    	
	    	 //把超时加班中计算的部分去掉，设置的是负数
//		     BigDecimal timeoverDuration = userAttendanceTotalEntity.getTimeoutOvertimeDuration_orig();
//		     if(timeoverDuration == null) {
//		    	 timeoverDuration = BigDecimal.ZERO;
//		     }
//	    	 timeoverDuration = timeoverDuration.subtract(halfNationOvertime);
//	    	 userAttendanceTotalEntity.setTimeoutOvertimeDuration_orig(timeoverDuration);
	     }else {
	 	    //如果是全天都在国定时间内，将这一天的实际出勤时间计入国定加班时长  zy 20180416
	 	     if ((Globals.dtype_2.equals(oConvertUtils.getString(dto.getDtype())))) {
//	 	    	 nationalOvertimeDuration =  dto.getDatumDate();
	 	    	 nationalOvertimeDuration =  dto.getActualAttendanceDate();
	 		}
	     }
	     dto.setNationalOvertimeDuration(nationalOvertimeDuration);
	     dto.setSpecialOvertime(specialOvertime);
	     
	     
	}

	/**
	 * 计算前半夜或者后半夜是国定加班的情况
	 * @param hm_cache 
	 * @param dto
	 */
	private BigDecimal calculateHalfNationalOvertime(HashMap<String, HashMap<String, Object>> hm_cache, UserAttendanceDetailDto dto, boolean isAccordingActualAttendance) {
		if (!Globals.DUTYTYPE_yeban115.equals(dto.getDutyType())) {
			 return BigDecimal.ZERO;
		}
		if (!oConvertUtils.isNotEmpty(dto.getNormalworkStime())||!oConvertUtils.isNotEmpty(dto.getNormalworkEtime())) {
			return BigDecimal.ZERO;
		}
		/**理应工作开始时间*/
		Date workStarttime =getexactDate(dto.getYmdDate(), dto.getNormalworkStime(), 0, 0);
		Calendar workStartCalendar = Calendar.getInstance();
		workStartCalendar.setTime(workStarttime);
		
		/**理应工作结束时间*/
		Date workendtime =  getexactDate(dto.getYmdDate(), dto.getNormalworkEtime(), 1, 0);
		Calendar workEndCalendar = Calendar.getInstance();
		workEndCalendar.setTime(workendtime);
		List<CalendarEntity> calendarList = new ArrayList<>();
		if(hm_cache == null) {
			String calendarHql = "from CalendarEntity where (year =? and month =? and day = ? ) or (year =? and month =? and day = ?5)";
			calendarList = calendarService.findHql(calendarHql, workStartCalendar.get(Calendar.YEAR), workStartCalendar.get(Calendar.MONTH)+1,  workStartCalendar.get(Calendar.DATE)
								,workEndCalendar.get(Calendar.YEAR), workEndCalendar.get(Calendar.MONTH)+1,  workEndCalendar.get(Calendar.DATE));
		}else {
			CalendarEntity calStart = getCalendarListWithCache(hm_cache,  workStartCalendar.get(Calendar.YEAR), workStartCalendar.get(Calendar.MONTH)+1,  workStartCalendar.get(Calendar.DATE));
			CalendarEntity calEnd = getCalendarListWithCache(hm_cache,  workEndCalendar.get(Calendar.YEAR), workEndCalendar.get(Calendar.MONTH)+1,  workEndCalendar.get(Calendar.DATE));
			if(calStart != null) {
				calendarList.add(calStart);
			}
			if(calEnd != null) {
				calendarList.add(calEnd);
			}
		}
		
		if(calendarList.size() != 2) {
			return BigDecimal.ZERO;
		}
		
		if(Globals.dtype_2.equals(calendarList.get(0).getDtype()) && Globals.dtype_2.equals(calendarList.get(1).getDtype())) {
			return new BigDecimal(11.5*60); //都是国定假
		}else if(!Globals.dtype_2.equals(calendarList.get(0).getDtype()) && !Globals.dtype_2.equals(calendarList.get(1).getDtype())) {
			return BigDecimal.ZERO;
		}
//		if("000000006120dd1c01612cf5232001d6".equals(dto.getUserid())) {
//			System.out.println();
//		}
		Date nationTypeDate = null;
		if(Globals.dtype_2.equals(calendarList.get(0).getDtype())){
			nationTypeDate = calendarList.get(0).getYmdDate();
		}else {
			nationTypeDate = calendarList.get(1).getYmdDate();
		}
		// 前半夜结束时间
		Date standardAttendEndDate = new Date(workendtime.getYear(), workendtime.getMonth(), workendtime.getDate());
		Calendar standardAttendEndCalendar = Calendar.getInstance();
		standardAttendEndCalendar.setTime(standardAttendEndDate);
		// 后半夜开始时间，有半小时休息。00:30分开始
		Calendar standardHalfTwoCalendar = Calendar.getInstance();
		standardHalfTwoCalendar.setTime(standardAttendEndDate);
		standardHalfTwoCalendar.add(Calendar.MINUTE, 30);
		
		// 实际打卡开始时间
		Date actattendanceDate = workStarttime;
		// 实际打卡结束时间
		Date actretreatDate = workendtime;
		
		if(isAccordingActualAttendance) {
			actattendanceDate = dto.getActattendanceDate();
			actretreatDate = dto.getActretreatDate();
			if(actattendanceDate == null || actretreatDate == null || actattendanceDate.equals(actretreatDate)) {
				return BigDecimal.ZERO;
			}
			
			if(actattendanceDate.compareTo(workStarttime) < 0) {
				actattendanceDate = workStarttime;
			}
			
			if(actretreatDate.compareTo(workendtime) > 0) {
				actretreatDate = workendtime;
			}
		}
	
		//差值
		int nationalDateDiffint = 0;
		if(nationTypeDate.compareTo(new Date(workStarttime.getYear(), workStarttime.getMonth(), workStarttime.getDate())) == 0) {
			// “考勤出勤时间”
			Calendar actattendanceCalendar = Calendar.getInstance();
			actattendanceCalendar.setTime(actattendanceDate);
			//差值
			nationalDateDiffint = DataUtils.dateDiff('m', standardAttendEndCalendar,actattendanceCalendar);
		}else {
			// “考勤出勤时间”
			Calendar actretreatCalendar = Calendar.getInstance();
			actretreatCalendar.setTime(actretreatDate);
			//差值
			nationalDateDiffint = DataUtils.dateDiff('m',actretreatCalendar, standardHalfTwoCalendar);
		}
		
		return new BigDecimal(Math.abs(nationalDateDiffint));
	}

	
	
	/**
	 * @param hm_cache
	 * @param i
	 * @param j
	 * @param k
	 * @return
	 */
	private CalendarEntity getCalendarListWithCache(HashMap<String, HashMap<String, Object>> hm_cache, int year, int month,
			int day) {
		HashMap<String, Object> hm = hm_cache.get("getCalendarListWithCache");
		if(hm == null) {
			hm = new HashMap<>();
			hm_cache.put("getCalendarListWithCache", hm);
			String calendarHql = "from CalendarEntity where 1=1";
			List<CalendarEntity> listDB = calendarService.findHql(calendarHql);
			for(CalendarEntity entity : listDB) {
				String userInEntity = entity.getYear()+"_"+entity.getMonth()+"_"+entity.getDay();
				hm.put(userInEntity, entity);
			}
		}
		
		return (CalendarEntity)hm.get(year+"_"+month+"_"+day);
	}
	// 计算时间差值 “实际出勤时间”与“基准时间”的差值； 实际出勤时间（每日）【时间小于等于  基准出勤时间】-基准时间（每日）【排班时间的N个小时】
	private void calculateActualtimeDifference(UserAttendanceDetailDto dto) {
		BigDecimal timeDifference = BigDecimal.ZERO;
		//	加班值班的时候为零
		String dutyType =  oConvertUtils.getString(dto.getDutyType());
		if (Globals.DUTYTYPE_xiuxi.equals(dutyType)||Globals.DUTYTYPE_jiaban.equals(dutyType)||Globals.DUTYTYPE_zhiban.equals(dutyType)) {
		}else {	
			// 基准时间 
			BigDecimal datumDate = dto.getDatumDate();
			BigDecimal actualAttendanceDate =dto.getActualAttendanceDate();
			if (datumDate==null) {
				datumDate = BigDecimal.ZERO;
			}
			if (actualAttendanceDate==null) {
				actualAttendanceDate = BigDecimal.ZERO;
			}
			//实际打卡开始时间
			  Date   actattendanceDate = dto.getActattendanceDate();
			//实际打卡结束时间
			  Date   actretreatDate = dto.getActretreatDate();
			
			if (oConvertUtils.isNotEmpty(actattendanceDate)&&
					oConvertUtils.isNotEmpty(actretreatDate)&&
					actattendanceDate.equals(actretreatDate)) {
			}else {
				timeDifference = actualAttendanceDate.subtract(datumDate);
			}
			
			 
		}
		// 設置时间差值
		dto.setTimeDifference(timeDifference);
	}

	
	/**
	 * 保存考勤调整记录
	 * @param entity
	 * @param userAttendanceTotalEntity
	 */
	private void saveOrUpdateAdjustEntity(UserAttendanceDetailEntity entity, UserAttendanceTotalEntity userAttendanceTotalEntity) {
		String detailId = entity.getId();
		if(detailId == null) {
			return;
		}
		List<UserAttendanceDetailAdjustedEntity> adjustedEntitiesInDB = findByProperty(UserAttendanceDetailAdjustedEntity.class
				, "attendanceDetailId", detailId);
		UserAttendanceDetailAdjustedEntity adjustedEntity = null;
		if(adjustedEntitiesInDB == null || adjustedEntitiesInDB.isEmpty()) {
			adjustedEntity = new UserAttendanceDetailAdjustedEntity();
		}else {
			adjustedEntity = adjustedEntitiesInDB.get(0);
		}
		adjustedEntity.setAttendanceDate(entity.getAttendanceDate());
		adjustedEntity.setRetreatDate(entity.getRetreatDate());
		adjustedEntity.setStatus(entity.getStatus());
		adjustedEntity.setFineTuningType(entity.getFineTuningType());
		adjustedEntity.setTimeFineTuning(entity.getTimeFineTuning());
		adjustedEntity.setAdjustReason(entity.getAdjustReason());
		adjustedEntity.setJsonObj(entity.getJsonObj());
		adjustedEntity.setUserId(userAttendanceTotalEntity.getUserId());
		adjustedEntity.setAttendanceDetailId(detailId);
		adjustedEntity.setAttendanceId(userAttendanceTotalEntity.getId());
		adjustedEntity.setTimeDifference(entity.getTimeDifference());
		//设置  国定加班时长
		adjustedEntity.setNationalOvertimeDuration(entity.getNationalOvertimeDuration());
		//设置  特殊加班时长
		adjustedEntity.setSpecialOvertime(entity.getSpecialOvertime());
		adjustedEntity.setAttendanceMins(entity.getActualAttendanceDate());
		adjustedEntity.setActualAttendanceDate(entity.getActualAttendanceDate());
		adjustedEntity.setTimeoutOvertimeDuration(entity.getTimeoutOvertimeDuration());
		adjustedEntity.setYmdDate(entity.getYmdDate());
		
		saveOrUpdate(adjustedEntity);
	}
}