ClockInController.java

package cn.timer.api.controller.kqgl;

import java.math.BigDecimal;
import java.sql.Timestamp;
import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Calendar;
import java.util.Date;
import java.util.List;
import java.util.Locale;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.github.xiaoymin.knife4j.annotations.ApiOperationSupport;

import cn.hutool.core.bean.BeanUtil;
import cn.hutool.json.JSONObject;
import cn.timer.api.bean.kqgl.AttConditions;
import cn.timer.api.bean.kqgl.AttGroupBinPunchMode;
import cn.timer.api.bean.kqgl.AttendanceMachine;
import cn.timer.api.bean.kqgl.AttendanceWeeklySch;
import cn.timer.api.bean.kqgl.PunchCardAddress;
import cn.timer.api.bean.kqgl.PunchCardWiFi;
import cn.timer.api.bean.kqgl.Schedule;
import cn.timer.api.bean.kqmk.KqglAssoBcsz;
import cn.timer.api.bean.kqmk.KqglAssoDkjl;
import cn.timer.api.bean.kqmk.KqglAssoDkmx;
import cn.timer.api.bean.kqmk.KqglAssoKqj;
import cn.timer.api.bean.kqmk.KqglAssoKqzdkfs;
import cn.timer.api.bean.kqmk.KqglAssoLeaveRules;
import cn.timer.api.bean.kqmk.KqglAssoPbmx;
import cn.timer.api.bean.kqmk.KqglAssoRelationSummary;
import cn.timer.api.bean.kqmk.KqglAssoTeshu;
import cn.timer.api.bean.kqmk.KqglAssoZhoupaiban;
import cn.timer.api.bean.kqmk.KqglMainKqz;
import cn.timer.api.bean.yggl.YgglMainEmp;
import cn.timer.api.config.annotation.CurrentUser;
import cn.timer.api.config.annotation.UserBean;
import cn.timer.api.config.exception.CustomException;
import cn.timer.api.dao.kqgl.AttGroupBinPunchModeMapper;
import cn.timer.api.dao.kqgl.AttendanceMachineMapper;
import cn.timer.api.dao.kqgl.AttendanceWeeklySchMapper;
import cn.timer.api.dao.kqgl.PunchCardAddressMapper;
import cn.timer.api.dao.kqgl.PunchCardWiFiMapper;
import cn.timer.api.dao.kqgl.ScheduleMapper;
import cn.timer.api.dao.kqmk.KqglAssoBcszMapper;
import cn.timer.api.dao.kqmk.KqglAssoDkjlMapper;
import cn.timer.api.dao.kqmk.KqglAssoDkmxMapper;
import cn.timer.api.dao.kqmk.KqglAssoPbmxMapper;
import cn.timer.api.dao.kqmk.KqglAssoRelationSummaryMapper;
import cn.timer.api.dao.kqmk.KqglAssoTeshuMapper;
import cn.timer.api.dao.kqmk.KqglMainKqzMapper;
import cn.timer.api.dto.kqmk.AttClockMethod;
import cn.timer.api.dto.kqmk.AttLateLate;
import cn.timer.api.dto.kqmk.AttSchedule;
import cn.timer.api.dto.kqmk.AttendanceCardListDto;
import cn.timer.api.dto.kqmk.ClockCollectData;
import cn.timer.api.dto.kqmk.KqglAssoMonthPunchSummaryDto;
import cn.timer.api.dto.kqmk.KqglAssoPbmxDto;
import cn.timer.api.dto.kqmk.WorkbenchCalendarDto;
import cn.timer.api.utils.DateUtil;
import cn.timer.api.utils.Result;
import cn.timer.api.utils.ResultUtil;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiModelProperty;
import io.swagger.annotations.ApiOperation;

@Api(tags = "3.0[3]考勤打卡")
@RestController
@Transactional
@RequestMapping(value = "/kqdk", produces = { "application/json", "multipart/form-data" })
public class ClockInController {
	@Autowired
	private KqglMainKqzMapper kqglmainkqzmapper;
	
	//打卡明细表
	@Autowired
	private KqglAssoDkmxMapper kqglassodkmxmapper;
	@Autowired
	private KqglAssoDkjlMapper kqglassodkjlmapper;
	@Autowired
	private KqglAssoBcszMapper kqglassobcszmapper;
	@Autowired
	private KqglAssoRelationSummaryMapper kqglassorelationsummarymapper;
	
	
	SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-dd");
	SimpleDateFormat sdf2 = new SimpleDateFormat("EEE");
	SimpleDateFormat df1 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
	/**
	 * 考勤打卡
	 * 
	 * @param json dev_id : 考勤机id user_id : 打卡用户id verify_mode : 打卡方式（1：指纹、20：人脸）
	 *             io_time : 打卡时间
	 * @return
	 */
	@PostMapping(value = "/punchclock")
	@ApiOperation(value = "1：考勤机打卡", httpMethod = "POST", notes = "接口发布说明")
	@ApiOperationSupport(order = 1)
	public Result<Object> punchclock(@RequestParam String json) throws Exception {
		
		String current_time = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date());
		
		String current = new SimpleDateFormat("yyyy-MM-dd").format(new Date());
		String yesterday = ClockInTool.requires_extra_times(current,-1,3,1);//前一天
		
		Long startDateyesterday = DateUtil.getStartTime(0,DateUtil.getStringTime(yesterday,"yyyy-MM-dd")).getTime();
		Long endDateyesterday = DateUtil.getnowEndTime(23,DateUtil.getStringTime(yesterday,"yyyy-MM-dd")).getTime();
		
		Long attendance_date = 0l;//考勤日期
		String toweek = "";
		
		String msg = "未知错误，请联系管理员";
		int sbyf = 1;//0:失败；1:成功
		int status_ = 0;
		
		JSONObject jsonArray = new JSONObject(json);
		String asDevId = jsonArray.get("dev_id").toString();//考勤机编码
		String asUserId = jsonArray.get("user_id").toString();//打卡用户id
		String asVerifyMode = jsonArray.get("verify_mode").toString();//考勤机打卡方式(1:指纹;20:人脸;40:掌纹;60:密码(猜的^v^))
		String sStdIoTime = jsonArray.get("io_time").toString();//打卡时间 **判断次日打卡情况**
		
		KqglAssoKqj kqjdev = KqglAssoKqj.builder().build().selectOne(new QueryWrapper<KqglAssoKqj>().lambda().eq(KqglAssoKqj::getCode, asDevId));
		if (kqjdev == null) 
			return ResultUtil.error("考勤机不存在！");
		YgglMainEmp user = YgglMainEmp.builder().build().selectOne(new QueryWrapper<YgglMainEmp>().lambda().eq(YgglMainEmp::getEmpNum, asUserId).eq(YgglMainEmp::getOrgCode, kqjdev.getQyid()));
		if(user != null) {
			int qyid = user.getOrgCode();
			int userid = user.getEmpNum();
			KqglMainKqz attgro = kqglmainkqzmapper.getAttendanceGroupInformationByUserid(userid,qyid); //考勤组信息
			//pbfs;// 排班方式 1：固定排班；2：自由排班；3：自由工时
			
			/*******/
			long time_ = DateUtil.getStringTime(sStdIoTime, "yyyy-MM-dd HH:mm:ss");//打卡时间戳
			String putime = new SimpleDateFormat("yyyy-MM-dd").format(time_);//转换打卡时间格式 年月日
			
			String putimehhmm = new SimpleDateFormat("yyyy-MM-dd HH:mm").format(time_);//转换打卡时间格式 年月日
			//打卡当天开始时间,打卡当天结束时间
			Long startDate = DateUtil.getStartTime(0,DateUtil.getStringTime(putime,"yyyy-MM-dd")).getTime();
			Long endDate = DateUtil.getnowEndTime(23,DateUtil.getStringTime(putime,"yyyy-MM-dd")).getTime();
			int dkmx = 0;
			int shifid = 0;
			long punchcardtime = 0,punchstart = 0,punchend = 0;//应打卡时间,应打卡开始时间,应打卡结束时间
			boolean isRange = true;//是否在打卡时间范围内
			int atttype = 0;
			int execution_status = 0;//执行状态
			boolean kskd = true;//识别是否更新最后一次打卡   针对于最后一次下班卡
			boolean sbdkkd = false;//针对于上班  未超过上班卡打卡  视为无效打卡
			ClockCollectData clockt = new ClockCollectData();
			//putime： 根据日期  得到打卡所需的详细信息
			AttendanceCardListDto attdate = MethodCall(qyid,userid,putime);
			/*******/
			if(attgro != null) {//判断考勤组是否存在
				List<KqglAssoKqzdkfs> kqjs = KqglAssoKqzdkfs.builder().build().selectList(new QueryWrapper<KqglAssoKqzdkfs>().lambda().eq(KqglAssoKqzdkfs::getKqzId, attgro.getId()));
				if(kqjs.size() > 0) {
					/**
					 * 	当考勤组为“固定排班”和“自定义排班”时 方可使用
					 */
					if(attdate.getAttgrouptype() != 3) {
							 //查询打卡当天是否有记录**********************************
							KqglAssoDkmx dkmc = KqglAssoDkmx.builder().build();
							String dakariqi = new SimpleDateFormat("yy-MM-dd").format(Double.valueOf(startDateyesterday))+" "+ClockInTool.dateToWeek2(yesterday);
							//检查昨日的班次是否存在次日打卡
							KqglAssoDkjl balan = kqglassodkjlmapper.selectOne(new QueryWrapper<KqglAssoDkjl>().lambda().eq(KqglAssoDkjl::getUserId, userid).eq(KqglAssoDkjl::getAttdate, dakariqi).ne(KqglAssoDkjl::getBcid, 0).orderByDesc(KqglAssoDkjl :: getSort).last("LIMIT 1"));
							boolean dnck = false;
							boolean crdk = false;//当次打卡是否存在次日打卡
							if(balan != null) {//前一天是否打过卡    去班次id查询是否存在次日打卡
								//班次信息
								KqglAssoBcsz shif = kqglassobcszmapper.selectOne(new QueryWrapper<KqglAssoBcsz>().lambda().eq(KqglAssoBcsz::getId, balan.getBcid()));
								int dkcs = shif.getSxbcs()*2;
								List<AttSchedule> ashss = attdate.getAttsch();//获取今天应打卡时间
								if(ashss.size() > 0) {
									Date sd1=df1.parse(ClockInTool.stampToDate(String.valueOf(ashss.get(0).getTime())));//当天应打的首次上班卡时间
									Date sd2=df1.parse(current_time);//当前时间
									if(sd1.after(sd2)) {
										dnck = true;
									}
								}
								int isXbdk1Cr = shif.getIsXbdk1Cr();//下班1是否次日（0：否；1：是）
								int isSbdk2Cr = shif.getIsSbdk2Cr();//上班2是否次日（0：否；1：是）
								int isXbdk2Cr = shif.getIsXbdk2Cr();//下班2是否次日（0：否；1：是）
								int isSbdk3Cr = shif.getIsSbdk3Cr();//上班3是否次日（0：否；1：是）
								int isXbdk3Cr = shif.getIsXbdk3Cr();//下班3是否次日（0：否；1：是）
								if(balan.getSort() < dkcs) {
									if(balan.getSort()+1 == 2 && dkcs == 2) {
										if(isXbdk1Cr > 0) {//次日
											crdk = true;
										}
									}
									if(balan.getSort()+1 == 3 && dkcs == 4) {
										if(isSbdk2Cr > 0) {//次日
											crdk = true;
										}
									}
									if(balan.getSort()+1 == 4 && dkcs == 4) {
										if(isXbdk2Cr > 0) {//次日
											crdk = true;
										}
									}
									if(balan.getSort()+1 == 5 && dkcs == 6) {
										if(isSbdk3Cr > 0) {//次日
											crdk = true;
										}
									}
									if(balan.getSort()+1 == 6 && dkcs == 6) {
										if(isXbdk3Cr > 0) {//次日
											crdk = true;
										}
									}
								}
								
							}else {
								//无记录的话就找昨天的数据
//								AttendanceCardListDto attdate1 = MethodCall(qyid,userid,yesterday);
							}
							
							if(crdk && dnck) {
								dkmc = KqglAssoDkmx.builder().build().selectOne(new QueryWrapper<KqglAssoDkmx>().lambda().eq(KqglAssoDkmx::getUserid, userid)
										.ge(KqglAssoDkmx::getDksj, startDateyesterday).le(KqglAssoDkmx::getDksj, endDateyesterday));
								attdate = MethodCall(qyid,userid,yesterday);
								attendance_date = startDateyesterday;
								toweek = yesterday;
							}else {
								dkmc = KqglAssoDkmx.builder().build().selectOne(new QueryWrapper<KqglAssoDkmx>().lambda().eq(KqglAssoDkmx::getUserid, userid)
										.ge(KqglAssoDkmx::getDksj, startDate).le(KqglAssoDkmx::getDksj, endDate));
								attendance_date = startDate;
								toweek = putime;
							}
							if(EmptyUtil.isEmpty(attdate.getAttsch())) {
								msg = "当前未排班";
								sbyf = 0;
								status_ = 2;
							}else {
								//排查请假是否在最后一次打卡范围内  查询当月的请假所有日期
								KqglAssoRelationSummary leainv = kqglassorelationsummarymapper.leaveinvesti(userid, 2, putime,qyid);
								boolean adopt = false;
								if(leainv != null) {
									adopt = ClockInTool.hourMinuteBetween(putimehhmm, leainv.getStartTime().substring(0, 16), leainv.getEndTime().substring(0, 16),"yyyy-MM-dd HH:mm");
								}
								
								if(adopt) {
									msg = "已请假";
									sbyf = 0;
									status_ = 2;
								}else {
									long starttime1 = 0,starttime1ks = 0,starttime1js = 0,endtime1 = 0,endtime1ks = 0,endtime1js = 0,starttime2 = 0,starttime2ks = 0,starttime2js = 0,endtime2 = 0,endtime2ks = 0,endtime2js = 0,starttime3 = 0,starttime3ks = 0,starttime3js = 0,
											endtime3 = 0,endtime3ks = 0,endtime3js = 0; 
									if(attdate.getAttsch().size() > 0) {
										 List<AttSchedule> ash = attdate.getAttsch();
										 int y = 0;
										 clockt.setShifid(ash.get(y).getId());
										 shifid = ash.get(y).getId();//班次id
										 if(attdate.getAttsch().size() == 2 || attdate.getAttsch().size() == 4 || attdate.getAttsch().size() == 6) {
											 starttime1 = ash.get(0).getTime();starttime1ks = ash.get(0).getStarttime();starttime1js = ash.get(0).getEndtime();
											 endtime1 = ash.get(1).getTime();endtime1ks = ash.get(1).getStarttime();endtime1js = ash.get(1).getEndtime();
										 }
									 	if(attdate.getAttsch().size() == 4 || attdate.getAttsch().size() == 6) {
									 		starttime2 = ash.get(2).getTime();starttime2ks = ash.get(2).getStarttime();starttime2js = ash.get(2).getEndtime();
										    endtime2 = ash.get(3).getTime();endtime2ks = ash.get(3).getStarttime();endtime2js = ash.get(3).getEndtime();
										}
									 	if(attdate.getAttsch().size() == 6) {
									 		starttime3 = ash.get(4).getTime();starttime3ks = ash.get(4).getStarttime();starttime3js = ash.get(4).getEndtime();
											endtime3 = ash.get(5).getTime();endtime3ks = ash.get(5).getStarttime();endtime3js = ash.get(5).getEndtime();
										 }
									 	
									 	if(dkmc == null) {
									 		kskd = false;
									 		
									 		if(attdate.getAttsch().size() == 2) {//一套上下班  上班1
									 			Date sd1=df1.parse(ClockInTool.stampToDate(String.valueOf(starttime1)));//应打卡时间
												Date sd2=df1.parse(sStdIoTime);//打卡时间
												Date sd3=df1.parse(ClockInTool.stampToDate(String.valueOf(endtime1)));//应打卡时间
												if(sd2.before(sd3)) {
													atttype = 1;
												}
												
												if(sd2.after(sd1) && sd2.after(sd3)) {
													atttype = 2;
												}
									 			
									 		}else {
									 			boolean getinto = true;
									 			//打卡时间  对比班次  接近哪个时间就打哪个时间的卡
										 		if(attdate.getAttsch().size() == 4 || attdate.getAttsch().size() == 6) {
										 			//punchstart 应打卡开始时间 punchend:应打卡结束时间  time_:打卡时间
										 			boolean effectiveDate1 = ClockInTool.hourMinuteBetween(new SimpleDateFormat("yyyy-MM-dd HH:mm").format(time_), new SimpleDateFormat("yyyy-MM-dd HH:mm").format(starttime1ks), new SimpleDateFormat("yyyy-MM-dd HH:mm").format(starttime1js),"yyyy-MM-dd HH:mm");
												    if (effectiveDate1) {//在范围内就打卡 
												    	atttype = 1;
												    	getinto = false;
												    }else {
												    	if(getinto) {
												    		isRange = false;
												    	}
												    }
												    boolean effectiveDate2 = ClockInTool.hourMinuteBetween(new SimpleDateFormat("yyyy-MM-dd HH:mm").format(time_), new SimpleDateFormat("yyyy-MM-dd HH:mm").format(endtime1ks), new SimpleDateFormat("yyyy-MM-dd HH:mm").format(endtime1js),"yyyy-MM-dd HH:mm");
												    if (effectiveDate2) {//在范围内就打卡 
												    	atttype = 2;
												    	isRange = true;//在范围
												    	
												    	getinto = false;
												    }else {
												    	if(getinto) {
												    		isRange = false;
												    	}
												    }	
													boolean effectiveDate3 = ClockInTool.hourMinuteBetween(new SimpleDateFormat("yyyy-MM-dd HH:mm").format(time_), new SimpleDateFormat("yyyy-MM-dd HH:mm").format(starttime2ks), new SimpleDateFormat("yyyy-MM-dd HH:mm").format(starttime2js),"yyyy-MM-dd HH:mm");
												    if (effectiveDate3) {//在范围内就打卡 
												    	atttype = 3;
												    	isRange = true;//在范围
												    	
												    	getinto = false;
												    }else {
												    	if(getinto) {
												    		isRange = false;
												    	}
												    }
												    boolean effectiveDate4 = ClockInTool.hourMinuteBetween(new SimpleDateFormat("yyyy-MM-dd HH:mm").format(time_), new SimpleDateFormat("yyyy-MM-dd HH:mm").format(endtime2ks), new SimpleDateFormat("yyyy-MM-dd HH:mm").format(endtime2js),"yyyy-MM-dd HH:mm");
												    if (effectiveDate4) {//在范围内就打卡 
												    	atttype = 4;
												    	isRange = true;//在范围
												    	
												    	getinto = false;
												    }else {
												    	if(getinto) {
												    		isRange = false;
												    	}
												    }	
										 		}
										 		if(attdate.getAttsch().size() == 6) {
										 			boolean effectiveDate5 = ClockInTool.hourMinuteBetween(new SimpleDateFormat("yyyy-MM-dd HH:mm").format(time_), new SimpleDateFormat("yyyy-MM-dd HH:mm").format(starttime3ks), new SimpleDateFormat("yyyy-MM-dd HH:mm").format(starttime3js),"yyyy-MM-dd HH:mm");
												    if (effectiveDate5) {//在范围内就打卡 
												    	atttype = 5;
												    	isRange = true;//在范围
												    	
												    	getinto = false;
												    }else {
												    	if(getinto) {
												    		isRange = false;
												    	}
												    }
												    boolean effectiveDate6 = ClockInTool.hourMinuteBetween(new SimpleDateFormat("yyyy-MM-dd HH:mm").format(time_), new SimpleDateFormat("yyyy-MM-dd HH:mm").format(endtime3ks), new SimpleDateFormat("yyyy-MM-dd HH:mm").format(endtime3js),"yyyy-MM-dd HH:mm");
												    if (effectiveDate6) {//在范围内就打卡 
												    	atttype = 6;
												    	isRange = true;//在范围
												    	
												    	getinto = false;
												    }else {
												    	if(getinto) {
												    		isRange = false;
												    	}
												    }	
										 		}
									 		}
										 	 execution_status = 1;
									 	}else {
									 		boolean getinto2 = true;
									 		execution_status = 2;
									 		if(attdate.getAttsch().size() == 2) {	//下班1
									 			if(dkmc.getSbdk1() != null && dkmc.getXbdk1() == null){
									 				//如果第二次后打卡，未超过上班时间  即为打卡失效
									 				Date sd1=df1.parse(ClockInTool.stampToDate(String.valueOf(starttime1)));//应打卡时间
													Date sd2=df1.parse(sStdIoTime);//打卡时间
													if(sd1.after(sd2)) {
														sbdkkd = true;//打卡无效
//														atttype = 1;
													}else {
														kskd = false;
														atttype = 2;
													}
											     }else {
											    	//最后一次卡的时候 再继续打视为更新最后一次打卡
											    	 kskd = true;
											    	 atttype = 2;
											     }
									 		}	
									 		if(attdate.getAttsch().size() == 4 || attdate.getAttsch().size() == 6) {
									 			boolean effectiveDate1 = ClockInTool.hourMinuteBetween(new SimpleDateFormat("yyyy-MM-dd HH:mm").format(time_), new SimpleDateFormat("yyyy-MM-dd HH:mm").format(starttime1ks), new SimpleDateFormat("yyyy-MM-dd HH:mm").format(starttime1js),"yyyy-MM-dd HH:mm");
											    if (effectiveDate1) {//在范围内就打卡 
											    	if(dkmc.getSbdk1() != null) {
											    		sbdkkd = true;//打卡无效
//											    		atttype = 1;
											    	}else {
											    		atttype = 1;
											    		getinto2 = false;
											    		isRange = true;//在范围
											    	}
											    }else { 
											    	if(getinto2) {
											    		isRange = false; 
											    	}
											    }
											    boolean effectiveDate2 = ClockInTool.hourMinuteBetween(new SimpleDateFormat("yyyy-MM-dd HH:mm").format(time_), new SimpleDateFormat("yyyy-MM-dd HH:mm").format(endtime1ks), new SimpleDateFormat("yyyy-MM-dd HH:mm").format(endtime1js),"yyyy-MM-dd HH:mm");
											    if (effectiveDate2) {//在范围内就打卡 
											    	if(dkmc.getXbdk1() != null) {
											    		kskd = true;
											    		atttype = 2;
											    	}else {
											    		kskd = false;
											    		atttype = 2;
											    		getinto2 = false;
											    		isRange = true;//在范围
											    	}
											    }else { 
											    	if(getinto2) {
											    		isRange = false; 
											    	}
											    }
									 			boolean effectiveDate3 = ClockInTool.hourMinuteBetween(new SimpleDateFormat("yyyy-MM-dd HH:mm").format(time_), new SimpleDateFormat("yyyy-MM-dd HH:mm").format(starttime2ks), new SimpleDateFormat("yyyy-MM-dd HH:mm").format(starttime2js),"yyyy-MM-dd HH:mm");
											    if (effectiveDate3) {//在范围内就打卡 
											    	if(dkmc.getSbdk2() != null) {
											    		sbdkkd = true;//
//											    		atttype = 3;
											    	}else {
											    		atttype = 3;
											    		getinto2 = false;
											    		isRange = true;//在范围
											    	}
											    }else { 
											    	if(getinto2) {
											    		isRange = false; 
											    	}
											    }
											    boolean effectiveDate4 = ClockInTool.hourMinuteBetween(new SimpleDateFormat("yyyy-MM-dd HH:mm").format(time_), new SimpleDateFormat("yyyy-MM-dd HH:mm").format(endtime2ks), new SimpleDateFormat("yyyy-MM-dd HH:mm").format(endtime2js),"yyyy-MM-dd HH:mm");
											    if (effectiveDate4) {//在范围内就打卡 
											    	if(dkmc.getXbdk2() != null) {
											    		kskd = true;//更新最后一次打卡
											    		atttype = 4;
											    	}else {
											    		kskd = false;
											    		atttype = 4;
											    		getinto2 = false;
											    		isRange = true;//在范围
											    	}
											    }else { 
											    	if(getinto2) {
											    		isRange = false; 
											    	}
											    }	
									 		}
									 		if(attdate.getAttsch().size() == 6) {
									 			boolean effectiveDate5 = ClockInTool.hourMinuteBetween(new SimpleDateFormat("yyyy-MM-dd HH:mm").format(time_), new SimpleDateFormat("yyyy-MM-dd HH:mm").format(starttime3ks), new SimpleDateFormat("yyyy-MM-dd HH:mm").format(starttime3js),"yyyy-MM-dd HH:mm");
											    if (effectiveDate5) {//在范围内就打卡 
											    	if(dkmc.getSbdk2() != null) {
											    		sbdkkd = true;//
//											    		atttype = 5;
											    	}else {
											    		atttype = 5;
											    		getinto2 = false;
											    		isRange = true;//在范围
											    	}
											    }else { 
											    	if(getinto2) {
											    		isRange = false; 
										    		}
											    }
											    boolean effectiveDate6 = ClockInTool.hourMinuteBetween(new SimpleDateFormat("yyyy-MM-dd HH:mm").format(time_), new SimpleDateFormat("yyyy-MM-dd HH:mm").format(endtime3ks), new SimpleDateFormat("yyyy-MM-dd HH:mm").format(endtime3js),"yyyy-MM-dd HH:mm");
											    if (effectiveDate6) {//在范围内就打卡 
											    	if(dkmc.getXbdk2() != null) {
											    		kskd = true;////更新最后一次打卡
											    		atttype = 6;
											    	}else {
											    		kskd = false;
											    		atttype = 6;
											    		getinto2 = false;
											    		isRange = true;//在范围
											    	}
											    }else { 
											    	if(getinto2) {
											    		isRange = false; 
										    		}
											    }	
									 		}
									 	}
									 }
									if(atttype == 1) {
										punchcardtime = starttime1;
										 punchstart = starttime1ks;
								    	 punchend = starttime1js;
									}else if(atttype == 2) {
										punchcardtime = endtime1;
										 punchstart = endtime1ks;
										 punchend = endtime1js;
									}else if(atttype == 3) {
										punchcardtime = starttime2;
								    	 punchstart = starttime2ks;
								    	 punchend = starttime2js;
									}else if(atttype == 4) {
										punchcardtime = endtime2;
								    	 punchstart = endtime2ks;
								    	 punchend = endtime2js;
									}else if(atttype == 5) {
										 punchcardtime = starttime3;
								    	 punchstart = starttime3ks;
								    	 punchend = starttime3js;
									}else if(atttype == 6) {
										punchcardtime = endtime3;
								    	 punchstart = endtime3ks;
								    	 punchend = endtime3js;
									}
									
									
									 if(clockt.getShifid() != 0) {
									 
										 KqglAssoBcsz shif = KqglAssoBcsz.builder().build();
										 if(attdate.getAttsch().size() > 0 && clockt.getShifid() > 0){//有无班次
											 shif = shif.selectOne(new QueryWrapper<KqglAssoBcsz>().lambda().eq(KqglAssoBcsz::getId, clockt.getShifid()));
										 }
										//打卡记录录入 -- 打卡是否有时间范围限制
										 if(attdate.getAttsch().size() == 2) {
											 if(punchstart>0 && punchend>0) {
												 String staputime = new SimpleDateFormat("yyyy-MM-dd HH:mm").format(punchstart);//应打卡开始时间
												 String entputime = new SimpleDateFormat("yyyy-MM-dd HH:mm").format(punchend);//应打卡结束时间
												 String DKputime = new SimpleDateFormat("yyyy-MM-dd HH:mm").format(time_);//打卡时间
												 boolean effectiveDate = ClockInTool.hourMinuteBetween(DKputime, staputime, entputime,"yyyy-MM-dd HH:mm");
												 if (!effectiveDate) {
													 System.out.println("当前打卡时间不在范围内");
													// 手动抛出异常
													 isRange = false;
				//									throw new Exception();
												 }
											 }
										 }
											if(isRange) {
												int yxcd = shif.getYxcdfzs();//允许迟到
												int yzcd = shif.getYzcdfzs();//严重迟到分钟数
												int kgcdfzs  = shif.getKgcdfzs();//旷工迟到分钟数 
												
												int dkcs_ = shif.getSxbcs();//上下班打卡次数
												int iswzwd = shif.getIsWzwd();//是否开启晚走晚到(0：否；1：是)
												
												long rest_time = 0;
												if(shif.getStartTime() != null && shif.getEndTime() != null) {
													long kaishixiuxi = Long.valueOf(ClockInTool.dateToStamp(putime + " " +shif.getStartTime()+":00"));
												    long jieshuxiuxi = Long.valueOf(ClockInTool.dateToStamp(putime + " " +shif.getEndTime()+":00"));
												    rest_time = (jieshuxiuxi - kaishixiuxi)/1000/60;//休息时间
												}
												
												double xbwz1 = 0,xbwz2=0,xbwz3=0;
												int sbwd1=0,sbwd2=0,sbwd3=0;
												
												int arrive_late = 0;//晚到时间
												String clock_date = "";//应打卡时间
												Long latetime = 0l;//前天晚走时长（分钟）
												
												KqglAssoDkmx yesterdaymx = KqglAssoDkmx.builder().build();
												AttendanceCardListDto attdateyesterday;
												long yesendtime1=0,yesendtime2=0,yesendtime3=0;
												//存在晚走玩到
												 if(iswzwd > 0) {
													//统一分钟数
												    xbwz1 = Double.valueOf(shif.getXbwz1()) * 60;//下班晚走1
												    String sbwd1_ = String.valueOf(Double.valueOf(shif.getSbwd1()) * 60);
													sbwd1 = Integer.valueOf(sbwd1_.substring(0, sbwd1_.lastIndexOf(".")));//上班晚到1
													
													xbwz2 = Double.valueOf(shif.getXbwz2()) * 60;//下班晚走2
													String sbwd2_ = String.valueOf(Double.valueOf(shif.getSbwd2()) * 60);
													sbwd2 = Integer.valueOf(sbwd2_.substring(0, sbwd2_.lastIndexOf(".")));//上班晚到2
													
													xbwz3 = Double.valueOf(shif.getXbwz3()) * 60;//下班晚走3
													String sbwd3_ = String.valueOf(Double.valueOf(shif.getSbwd3()) * 60);
													sbwd3 = Integer.valueOf(sbwd3_.substring(0, sbwd3_.lastIndexOf(".")));//上班晚到3
														
													 //获取前一天最后下班的时间
													 yesterdaymx = KqglAssoDkmx.builder().build().selectOne(new QueryWrapper<KqglAssoDkmx>().lambda().eq(KqglAssoDkmx::getUserid, userid)
																.ge(KqglAssoDkmx::getDksj, startDateyesterday).le(KqglAssoDkmx::getDksj, endDateyesterday));
													 attdateyesterday = MethodCall(qyid,userid,yesterday);
													 
													 List<AttSchedule> ash = attdateyesterday.getAttsch();
													 if(attdateyesterday.getAttsch().size() == 2 || attdateyesterday.getAttsch().size() == 4 || attdateyesterday.getAttsch().size() == 6) {
														 yesendtime1 = ash.get(1).getTime();
													 }
												 	 if(attdateyesterday.getAttsch().size() == 4 || attdateyesterday.getAttsch().size() == 6) {
												 		yesendtime2 = ash.get(3).getTime();
													 }
												 	 if(attdateyesterday.getAttsch().size() == 6) {
												 		yesendtime3 = ash.get(5).getTime();
													  }
												 }
												
												 if(execution_status == 1) {//上班1   ****新增
													 KqglAssoDkmx pcd = KqglAssoDkmx.builder().userid(userid).data(putime).qyid(qyid).dksj(startDate).build();
													 int sbdkjg = 0,yzcdsc = 0,yzcdcs = 0,kgcdcs = 0,dkst1 = 0;
													 if(punchcardtime != 0){//有应打卡时间时
														 Long time = (time_ - punchcardtime)/1000/60;
														 if((atttype)%2 > 0){//上班
															if(time > 0){
																sbdkjg = Integer.valueOf(time.toString());
															}// 打卡结果
														 }else{//下班
															if(time > 0){}else{
																sbdkjg = Math.abs(Integer.valueOf(time.toString()));
															}// 打卡结果
														 }
														 
														 //存在晚走玩到
														 if(iswzwd > 0 && yesterdaymx != null) {
															 if(dkcs_ == 1) {
																 if(yesterdaymx.getXbdk1() != null && yesterdaymx.getXbdk1jg() == 0) {
																	 latetime = (yesterdaymx.getXbdk1() - yesendtime1)/1000/60;
																 }
															 }else if(dkcs_ == 2){
																 if(yesterdaymx.getXbdk2() != null && yesterdaymx.getXbdk2jg() == 0) {
																	 latetime = (yesterdaymx.getXbdk2() - yesendtime2)/1000/60;
																 }
															 }else {
																 if(yesterdaymx.getXbdk3() != null && yesterdaymx.getXbdk3jg() == 0) {
																	 latetime = (yesterdaymx.getXbdk3() - yesendtime3)/1000/60;
																 }
															 }
															 if(latetime != 0) {
																 double latetime_ = Double.valueOf(String.valueOf(latetime));//前天晚走时长（分钟）
																 if(latetime_ > xbwz1 && latetime_ < xbwz2) {
																	 arrive_late = sbwd1;
																 }else if(latetime_ > xbwz2 && latetime_ < xbwz3) {
																	 arrive_late = sbwd2;
																 }else if(latetime_ > xbwz3) {
																	 arrive_late = sbwd3;
																 }
																 
																 clock_date = ClockInTool.stampToDate(String.valueOf(punchcardtime));
																 Long changed_time = Long.valueOf(ClockInTool.dateToStamp(ClockInTool.addtime(clock_date, "+"+arrive_late)));//晚到后应打卡时间
																 
																 punchcardtime = changed_time;//更换当天打卡时间
																 Long timeyes = (time_ - changed_time)/1000/60;//
																 if((atttype)%2 > 0){//上班
																	if(timeyes > 0){
																		sbdkjg = Integer.valueOf(timeyes.toString());
																	}else {
																		sbdkjg = 0;
																	}
																 }else{//下班
																	if(timeyes > 0){
																		sbdkjg = 0;
																	}else{
																		sbdkjg = Math.abs(Integer.valueOf(timeyes.toString()));
																	}
																 }
															 }
														 }
														 
													 }
													 //允许迟到范围
													 if(sbdkjg <= yxcd) {
														 sbdkjg = 0;
													 }
													 
												    if(atttype == 1) {
												    	pcd.setSbdk1(time_);
												    	pcd.setSbdk1jg(sbdkjg);
													}else if(atttype == 2) {
														pcd.setXbdk1(time_);
														pcd.setXbdk1jg(sbdkjg);
													}else if(atttype == 3) {
														pcd.setSbdk2(time_);
												    	pcd.setSbdk2jg(sbdkjg);
													}else if(atttype == 4) {
														pcd.setXbdk2(time_);
														pcd.setXbdk2jg(sbdkjg);
													}else if(atttype == 5) {
														pcd.setSbdk3(time_);
												    	pcd.setSbdk3jg(sbdkjg);
													}else if(atttype == 6) {
														pcd.setXbdk3(time_);
														pcd.setXbdk3jg(sbdkjg);
													}
													 int ydkcs = 0;
													 if(shif != null){
														 ydkcs = shif.getSxbcs()*2;
													 }//应打卡次数
													 pcd.setYdkcs(ydkcs);
													 
													 //严重迟到范围
													 if(sbdkjg>yzcd && sbdkjg < kgcdfzs && yzcd>0) {
														 yzcdcs++;
														 yzcdsc = sbdkjg;
														 dkst1 = 1;
													 }
													 //旷工迟到
													 if(sbdkjg>kgcdfzs && kgcdfzs>0) {
														 kgcdcs++;
														 dkst1 = 2;
													 }
													 
													 pcd.setDkst1(dkst1);//打卡时态（0：无；1：严重迟到；2：旷工迟到）
													 
													 pcd.setYzcdcs(yzcdcs);//严重迟到次数
													 pcd.setYzcdsc(Double.valueOf(yzcdsc));//严重迟到时长（分钟）
													 pcd.setKgcdfzs(kgcdcs);//旷工迟到次数
													 
													 if (!pcd.insert()) {
														throw new CustomException("打卡明细-新增异常-1");
													 }
													 dkmx = pcd.getId();
												 }else if(execution_status == 2){ //*****修改
													 dkmx = dkmc.getId();
													 KqglAssoDkmx pcd = KqglAssoDkmx.builder().build();
													 if(atttype == 2){//下班1
														 pcd.setId(dkmc.getId());
														 pcd.setXbdk1(time_);//下班1打卡时间
														 if(punchcardtime != 0){//有应打卡时间时
															 Long time = (time_ - punchcardtime)/1000/60;
															 if(time > 0){
																 pcd.setXbdk1jg(0);// 打卡结果
															 }else{
																 pcd.setXbdk1jg(Math.abs(Integer.valueOf(time.toString())));
															 }
														 }
														 if(dkmc.getSbdk1() != null){
															Long time = (time_ - dkmc.getSbdk1())/1000/60 - rest_time;
															pcd.setGzsc(Math.abs(Double.valueOf(time.toString())));//只打一次卡时计算工作时长
														 }
														 kqglassodkmxmapper.updateByPrimaryKeySelective(pcd);//修改打卡记录
														 
												     }else if(atttype == 3){//上班2
												    	 
												    	 int sbdk2jg = 0,yzcdsc = 0,yzcdcs = 0,kgcdcs = 0,dkst2=0;
														 if(punchcardtime != 0){//有应打卡时间时
															 Long time = (time_ - punchcardtime)/1000/60;
															 if(time > 0){sbdk2jg = Math.abs(Integer.valueOf(time.toString()));}
														 }
														 
														//允许迟到范围
														 if(sbdk2jg <= yxcd) {
															 sbdk2jg = 0;
														 }
														 
														 //严重迟到范围
														 if(sbdk2jg>yzcd && sbdk2jg < kgcdfzs && yzcd>0) {
															 yzcdcs = dkmc.getYzcdcs()+1;
															 yzcdsc = sbdk2jg;
															 dkst2 = 1;
														 }
														 //旷工迟到
														 if(sbdk2jg>kgcdfzs && kgcdfzs>0) {
															 kgcdcs++;
															 kgcdcs = kgcdcs + dkmc.getKgcdfzs();
															 dkst2 = 2;
														 }
														 
														 pcd.setDkst2(dkst2);//打卡时态（0：无；1：严重迟到；2：旷工迟到）
														 
														 pcd.setId(dkmc.getId());
												    	 pcd.setSbdk2(time_);//上班1打卡时间
														 pcd.setSbdk2jg(sbdk2jg);
														 
														 pcd.setYzcdcs(yzcdcs);
														 pcd.setYzcdsc(Double.valueOf(yzcdsc));
														 pcd.setKgcdfzs(kgcdcs);
														 kqglassodkmxmapper.updateByPrimaryKeySelective(pcd);//修改打卡记录
												     }else if(atttype == 4){//下班2
														 pcd.setId(dkmc.getId());
												    	 pcd.setXbdk2(time_);//下班1打卡时间
														 if(punchcardtime != 0){//有应打卡时间时
															 Long time = (time_ - punchcardtime)/1000/60;
															 if(time > 0){
																 pcd.setXbdk2jg(0);// 打卡结果
															 }else{
																 pcd.setXbdk2jg(Math.abs(Integer.valueOf(time.toString())));
															 }
														 }
														//班次为4次时，计算工作时长
														 if(dkmc.getSbdk2() != null){
															 Long time = (time_ - dkmc.getSbdk2())/1000/60;
															 BigDecimal om = new BigDecimal(dkmc.getGzsc());
															 BigDecimal on = new BigDecimal(time);
															 BigDecimal worktime_ = new BigDecimal(Math.abs(om.add(on).doubleValue()));
															 
															 BigDecimal xx = new BigDecimal(rest_time);
															 
															 double worktime = Math.abs(worktime_.subtract(xx).doubleValue());
															 
															 pcd.setGzsc(worktime);
														 }
														 kqglassodkmxmapper.updateByPrimaryKeySelective(pcd);//修改打卡记录
												     }else if(atttype == 5){//上班3
												    	 int sbdk3jg = 0,yzcdsc = 0,yzcdcs = 0,kgcdcs = 0,dkst3=0;
														 if(punchcardtime != 0){//有应打卡时间时
															 Long time = (time_ - punchcardtime)/1000/60;
															 if(time > 0){sbdk3jg = Math.abs(Integer.valueOf(time.toString()));}
														 }
														//允许迟到范围
														 if(sbdk3jg <= yxcd) {
															 sbdk3jg = 0;
														 }
														 
														 //严重迟到范围
														 if(sbdk3jg>yzcd && sbdk3jg < kgcdfzs && yzcd>0) {
															 yzcdcs = dkmc.getYzcdcs()+1;
															 yzcdsc = sbdk3jg;
															 dkst3 = 1;
														 }
														 //旷工迟到
														 if(sbdk3jg>kgcdfzs && kgcdfzs>0) {
															 kgcdcs++;
															 kgcdcs = kgcdcs + dkmc.getKgcdfzs();
															 dkst3 = 2;
														 }
														 
														 pcd.setDkst3(dkst3);//打卡时态（0：无；1：严重迟到；2：旷工迟到）
														 
														 pcd.setId(dkmc.getId());
												    	 pcd.setSbdk3(time_);//上班1打卡时间
														 pcd.setSbdk3jg(sbdk3jg);
														 pcd.setYzcdcs(yzcdcs);
														 pcd.setYzcdsc(Double.valueOf(yzcdsc));
														 pcd.setKgcdfzs(kgcdcs);
														 kqglassodkmxmapper.updateByPrimaryKeySelective(pcd);//修改打卡记录
												     }else if(atttype == 6){//下班3
														 pcd.setId(dkmc.getId());
												    	 pcd.setXbdk3(time_);//下班1打卡时间
														 if(punchcardtime != 0){//有应打卡时间时
															 Long time = (time_ - punchcardtime)/1000/60;
															 if(time > 0){
																 pcd.setXbdk3jg(0);// 打卡结果
															 }else{
																 pcd.setXbdk3jg(Math.abs(Integer.valueOf(time.toString())));
															 }
														 }
														//班次为6次时，计算工作时长
														 if(dkmc.getSbdk3() != null){
															 Long time = (time_ - dkmc.getSbdk3())/1000/60;
															 BigDecimal om = new BigDecimal(dkmc.getGzsc());//第二次
															 BigDecimal on = new BigDecimal(time);
															 BigDecimal worktime_ = new BigDecimal(Math.abs(om.add(on).doubleValue()));
															 
															 BigDecimal xx = new BigDecimal(rest_time);
															 
															 double worktime = Math.abs(worktime_.subtract(xx).doubleValue());
															 
															 pcd.setGzsc(worktime);
														 }
												     }
													 pcd.setId(dkmc.getId());
													 if(atttype <= 6 && atttype > 0 && !sbdkkd){
														 kqglassodkmxmapper.updateByPrimaryKeySelective(pcd);//修改打卡记录
													 }
												 }
											 }else {
												 msg = "当前打卡时间不在范围内";
												 sbyf = 0;
												 status_ = 2;
											 }
									 }else {
										 msg = "当前是休息时间";
										 sbyf = 0;
										 status_ = 2;
									 }
								}
							}
					}else {
						//自由工时打卡
						Long stapclotime = attdate.getStapclotime();// 今天考勤 自由排班开始时间
						int canpunchworkdate = Integer.valueOf(String.valueOf(attdate.getCanpunchworkdate()).replaceAll("(\\d+)(?:(\\.\\d*[^0])|\\.)0*", "$1$2"));// 上班打卡后多久大下班卡
						KqglAssoDkmx zydkmc = KqglAssoDkmx.builder().build();
						Date sd1=df1.parse(ClockInTool.stampToDate(String.valueOf(stapclotime)));//应打卡时间   2020-06-10 18:30:00
						Date sd2=df1.parse(current_time);//当前时间  2020-06-10 16:06:58
						if(sd1.after(sd2)) {//为true时  打的是昨天的卡
							zydkmc = KqglAssoDkmx.builder().build().selectOne(new QueryWrapper<KqglAssoDkmx>().lambda().eq(KqglAssoDkmx::getUserid, userid)
									.ge(KqglAssoDkmx::getDksj, startDateyesterday).le(KqglAssoDkmx::getDksj, endDateyesterday));
							attendance_date = startDateyesterday;
							toweek = yesterday;
						}else {
							zydkmc = KqglAssoDkmx.builder().build().selectOne(new QueryWrapper<KqglAssoDkmx>().lambda().eq(KqglAssoDkmx::getUserid, userid)
									.ge(KqglAssoDkmx::getDksj, startDate).le(KqglAssoDkmx::getDksj, endDate));
							attendance_date = startDate;
							toweek = putime;
						}  
						if(zydkmc == null) {//新增
							KqglAssoDkmx pcd  = KqglAssoDkmx.builder().build();
							if(sd1.after(sd2)) {
								pcd = KqglAssoDkmx.builder().userid(userid).data(yesterday).sbdk1(time_).sbdk1jg(0).ydkcs(0).qyid(qyid).dksj(startDateyesterday).yzcdcs(0).yzcdsc(Double.valueOf(0)).kgcdfzs(0).build();
							}else {
								pcd = KqglAssoDkmx.builder().userid(userid).data(putime).sbdk1(time_).sbdk1jg(0).ydkcs(0).qyid(qyid).dksj(startDate).yzcdcs(0).yzcdsc(Double.valueOf(0)).kgcdfzs(0).build();
							}
//							KqglAssoDkmx pcd = KqglAssoDkmx.builder().userid(userid).data(putime).sbdk1(time_).sbdk1jg(0).ydkcs(0).qyid(qyid).dksj(startDate).yzcdcs(0).yzcdsc(Double.valueOf(0)).kgcdfzs(0).build();
							 if (!pcd.insert()) {
								throw new CustomException("打卡明细-新增异常-1");
							 }
							 dkmx = pcd.getId();
							 atttype = 1;
						}else {//修改	
							dkmx = zydkmc.getId();
							KqglAssoDkmx zypcd = KqglAssoDkmx.builder().build();
							if((!("").equals(zydkmc.getSbdk1()) || zydkmc.getSbdk1() != null) && (("").equals(zydkmc.getXbdk1()) || zydkmc.getXbdk1() == null)){//下班1
								String clock_time = ClockInTool.requires_extra_times(ClockInTool.stampToDate(String.valueOf(zydkmc.getSbdk1())),canpunchworkdate,5,2);
								Date zysd1=df1.parse(clock_time);//上班打卡后多久大下班卡的时间
								Date zysd2=df1.parse(current_time);//当前时间  
								if(zysd1.after(zysd2)) {//当zysd1大于zysd2时，返回TRUE，当小于等于时，返回false； 
									msg = "自由工时：上班打卡后"+canpunchworkdate+"小时后，才可打下班卡";
									sbyf = 0;
									status_ = 2;
								}else {
									zypcd.setId(zydkmc.getId());
									zypcd.setXbdk1(time_);//下班1打卡时间
									if(zydkmc.getSbdk1() != null){
										Long time = (time_ - zydkmc.getSbdk1())/1000/60;
										zypcd.setGzsc(Math.abs(Double.valueOf(time.toString())));//只打一次卡时计算工作时长
									 }
									kqglassodkmxmapper.updateByPrimaryKeySelective(zypcd);//修改打卡记录
								}
								atttype = 2;
							}else if((!("").equals(zydkmc.getSbdk1()) || zydkmc.getSbdk1() != null) && (!("").equals(zydkmc.getXbdk1()) || zydkmc.getXbdk1() != null)
						    		 && (("").equals(zydkmc.getSbdk2()) || zydkmc.getSbdk2() == null)){//上班2
								zypcd.setId(zydkmc.getId());
								zypcd.setSbdk2(time_);//上班1打卡时间
								kqglassodkmxmapper.updateByPrimaryKeySelective(zypcd);//修改打卡记录
								atttype = 3;
							}else if((!("").equals(zydkmc.getSbdk1()) || zydkmc.getSbdk1() != null) && (!("").equals(zydkmc.getXbdk1()) || zydkmc.getXbdk1() != null)
						    		 && (!("").equals(zydkmc.getSbdk2()) || zydkmc.getSbdk2() != null) && (("").equals(zydkmc.getXbdk2()) || zydkmc.getXbdk2() == null)){//下班2
								String clock_time = ClockInTool.requires_extra_times(ClockInTool.stampToDate(String.valueOf(zydkmc.getSbdk2())),canpunchworkdate,5,2);
								Date zysd1=df1.parse(clock_time);//上班打卡后多久大下班卡的时间
								Date zysd2=df1.parse(current_time);//当前时间  
								if(zysd1.after(zysd2)) {//当zysd1大于zysd2时，返回TRUE，当小于等于时，返回false； 
									msg = "自由工时：上班打卡后"+canpunchworkdate+"小时后，才可打下班卡";
									sbyf = 0;
									status_ = 2;
								}else {
									zypcd.setId(zydkmc.getId());
									zypcd.setXbdk2(time_);//下班1打卡时间
									//班次为4次时，计算工作时长
									 if(zydkmc.getSbdk2() != null){
										 Long time = (time_ - zydkmc.getSbdk2())/1000/60;
										 BigDecimal om = new BigDecimal(zydkmc.getGzsc());
										 BigDecimal on = new BigDecimal(time);
										 double worktime = Math.abs(om.add(on).doubleValue());
										 zypcd.setGzsc(worktime);
									 }
									 kqglassodkmxmapper.updateByPrimaryKeySelective(zypcd);//修改打卡记录
								}
								 atttype = 4;
							}else if((!("").equals(zydkmc.getSbdk1()) || zydkmc.getSbdk1() != null) && (!("").equals(zydkmc.getXbdk1()) || zydkmc.getXbdk1() != null)
						    		 && (!("").equals(zydkmc.getSbdk2()) || zydkmc.getSbdk2() != null) && (!("").equals(zydkmc.getXbdk2()) || zydkmc.getXbdk2() != null)
						    		 && (("").equals(zydkmc.getSbdk3()) || zydkmc.getSbdk3() == null)){//上班3
								zypcd.setId(zydkmc.getId());
								zypcd.setSbdk3(time_);//上班1打卡时间
								kqglassodkmxmapper.updateByPrimaryKeySelective(zypcd);//修改打卡记录
								atttype = 5;
							}else if((!("").equals(zydkmc.getSbdk1()) || zydkmc.getSbdk1() != null) && (!("").equals(zydkmc.getXbdk1()) || zydkmc.getXbdk1() != null)
						    		 && (!("").equals(zydkmc.getSbdk2()) || zydkmc.getSbdk2() != null) && (!("").equals(zydkmc.getXbdk2()) || zydkmc.getXbdk2() != null)
						    		 && (!("").equals(zydkmc.getSbdk3()) || zydkmc.getSbdk3() != null) && (("").equals(zydkmc.getXbdk3()) || zydkmc.getXbdk3() == null)){//下班3
								String clock_time = ClockInTool.requires_extra_times(ClockInTool.stampToDate(String.valueOf(zydkmc.getSbdk3())),canpunchworkdate,5,2);
								Date zysd1=df1.parse(clock_time);//上班打卡后多久大下班卡的时间
								Date zysd2=df1.parse(current_time);//当前时间  
								if(zysd1.after(zysd2)) {//当zysd1大于zysd2时，返回TRUE，当小于等于时，返回false； 
									msg = "自由工时：上班打卡后"+canpunchworkdate+"小时后，才可打下班卡";
									sbyf = 0;
									status_ = 2;
								}else {
									zypcd.setId(zydkmc.getId());
									zypcd.setXbdk3(time_);//下班1打卡时间
									//班次为6次时，计算工作时长
									 if(zydkmc.getSbdk3() != null){
										 Long time = (time_ - zydkmc.getSbdk3())/1000/60;
										 BigDecimal om = new BigDecimal(zydkmc.getGzsc());//第二次
										 BigDecimal on = new BigDecimal(time);
										 double worktime = Math.abs(om.add(on).doubleValue());
										 zypcd.setGzsc(worktime);
									 }
									 kqglassodkmxmapper.updateByPrimaryKeySelective(zypcd);//修改打卡记录
								}
								
								 atttype = 6;
							}else {
								atttype = 7;
							}
						}
					}
				}else {
					msg = "未检测到考勤机";
					sbyf = 0;
					status_ = 2;
				}
				
/*****************************************************************************************************************************************************************************************************/
/*******************************************************************原始打卡记录数据录入**************************************************************************************************************/
/*****************************************************************************************************************************************************************************************************/
				
				String attdate_ = new SimpleDateFormat("yy-MM-dd").format(Double.valueOf(attendance_date));//转换打卡时间格式
				
				//true：确认为最后一次打卡更新打卡时  之前打卡的一条数据变为“打卡更新数据”
				if(kskd && (atttype == 2 || atttype == 4 || atttype == 6) && attdate.getAttgrouptype() != 3) {
					KqglAssoDkjl dkjj = KqglAssoDkjl.builder().build().selectOne(new QueryWrapper<KqglAssoDkjl>().lambda().eq(KqglAssoDkjl::getUserId, userid).eq(KqglAssoDkjl::getType, 2)
							.eq(KqglAssoDkjl::getSort, atttype).eq(KqglAssoDkjl::getQyid, qyid).eq(KqglAssoDkjl::getAttdate, attdate_+" "+ClockInTool.dateToWeek2(toweek)));
					
					KqglAssoDkjl.builder().id(dkjj.getId()).status(0).sort(0).build().updateById();
					msg = "打卡已更新数据";
					sbyf = 0;
					status_ = 2;
				}
					
					int results = 0;
					Long time = (time_ - punchcardtime)/1000/60;
					if(punchcardtime != 0){
						if(isRange) {
							if((atttype)%2 > 0){//上班
								if(time > 0){
									results = Integer.valueOf(time.toString());
								}// 打卡结果
							}else{//下班
								if(time > 0){}else{
									results = Math.abs(Integer.valueOf(time.toString()));
								}// 打卡结果
							}
						}
					}
					int type = 0,status = 0;
					if(atttype != 0) {
						if((atttype)%2 > 0){
							type = 1;// 类型(类型 0:无排班打卡 1：上班 2：下班)   punchcardtime == 0：无班次打卡
							if(attdate.getAttgrouptype() != 3) {
								if(EmptyUtil.isNotEmpty(attdate.getAttsch())) {
									if(punchcardtime == 0 && clockt.getShifid() != 0){
										status = 1;
									}if(punchcardtime == 0 && clockt.getShifid() == 0) {
										status = 2;
									}else{
										if(isRange) {// 状态（0：打卡无效:此记录已被更新 1：正常 2：异常 3：迟到 4：早退 5：补卡 6：请假 7：加班 8：调休）
											if(time > 0){
												status = 3;
											}else if(results == 0){
												status = 1;
											}
										}else {
											status = 2;
										}
									}
								}else if(EmptyUtil.isEmpty(attdate.getAttsch())) {
									status = 2;
								}
							}else {
								if(sbyf == 1) {
									status = 1;
								}else {
									status = 2;
								}
							}
						}else{
							type = 2;// 类型(类型 0:无排班打卡 1：上班 2：下班)
							if(attdate.getAttgrouptype() != 3) {
								if(EmptyUtil.isNotEmpty(attdate.getAttsch())) {
									if(punchcardtime == 0 && clockt.getShifid() != 0){
										status = 1;
									}if(punchcardtime == 0 && clockt.getShifid() == 0) {
										status = 2;
									}else{
										if(isRange) {
											if(time < 0){
												status = 4;
											}else if(results == 0){
												status = 1;
											}
										}else {
											status = 2;
										}
									}
								}else if(EmptyUtil.isEmpty(attdate.getAttsch())) {
									status = 2;
								}
							}else {
								if(sbyf == 1) {
									status = 1;
								}else {
									status = 2;
								}
							}
						}
					}
					
					//第二次未超过应上班打卡时间 打卡为无效
					if(sbdkkd) {
						sbyf = 0;
						status = 2;
						atttype = 0;
						msg = "已有最优的打卡记录存在";
					}
					
					long attime;
					if(punchcardtime == 0){// 考勤时间(应打卡时间)
						attime = new Date().getTime();
					}else{
						attime = punchcardtime;
					}
					String remarks = "";
					if(("1").equals(asVerifyMode)) {
						remarks = "考勤机指纹打卡";
					}else if(("20").equals(asVerifyMode)) {
						remarks = "考勤机人脸打卡";
					}else if(("40").equals(asVerifyMode)) {
						remarks = "考勤机掌纹打卡";
					}else if(("60").equals(asVerifyMode)) {
						remarks = "考勤机密码打卡";
					}
					String commentary = "未知";
					if(sbyf == 1) {
						commentary = "打卡成功";
					}else {
						commentary = msg;
						if(status_ == 2) {
							status = status_;
						}
					}
					
					
					//cardtype--1：GPS，2：WIFI，3：考勤机
					KqglAssoDkjl pre = KqglAssoDkjl.builder().dktime(time_).results(results).userId(userid).type(type).status(status).sort(atttype)
							.cardType(3).qyid(qyid).attdate(attdate_+" "+ClockInTool.dateToWeek2(toweek)).attime(attime).dkmxid(dkmx).bcid(shifid).remarks(remarks).punchmode(Integer.valueOf(asVerifyMode))
							.punchequipment(asDevId).commentary(commentary).build();
					
					if (!pre.insert()) {
						throw new CustomException("打卡记录-新增异常-2");
					 }
				}else {
					msg="打卡失败！，未加入考勤组！";
					sbyf = 0;
				}
		}else {
			return ResultUtil.error("打卡失败！，用户不存在！");
		}
		
		if(sbyf == 1) {
			return  ResultUtil.data(null, "打卡成功");
		}else {
			return  ResultUtil.data(msg, "打卡失败");
		}
	}
	
	@Autowired
	private KqglAssoPbmxMapper kqglassopbmxmapper;
	/**
	 * @param qyid 
	 * @param userid
	 * @param date
	 * @return
	 *	获取当天打卡班次数据
	 */
	public AttendanceCardListDto MethodCall(int qyid,int userid,String date) throws ParseException {
		 
		AttendanceCardListDto attcar = new AttendanceCardListDto();
		 String str = null;
		 if(!("").equals(date)){
			 str = date;
		 }else{
			 Date d = new Date();
			 SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
			 str = sdf.format(d);
		 }
	     KqglMainKqz attgro = kqglmainkqzmapper.getAttendanceGroupInformationByUserid(userid,qyid); //考勤组信息
	     //pbfs：排班方式 1：固定排班；2：自由排班；3：自由工时
		 if(attgro != null){//判断当前用户是否加入到考勤组
			 //排班制
			 KqglAssoPbmxDto jrpb = kqglassopbmxmapper.getScheduleSpecificAttendance(attgro.getId(),userid,str);
		     //固定排班
		     int week = Integer.valueOf(ClockInTool.dateToWeek(str));//4
		     KqglAssoZhoupaiban atwek = KqglAssoZhoupaiban.builder().build().selectOne(new QueryWrapper<KqglAssoZhoupaiban>().lambda().eq(KqglAssoZhoupaiban::getKqzid, attgro.getId())
		    		 .eq(KqglAssoZhoupaiban::getType, week).ne(KqglAssoZhoupaiban::getBcid, 0));
		    if(attgro.getPbfs() == 1){//固定排班
		    	if(atwek != null){//有固定周排班
		    		KqglAssoTeshu rest = KqglAssoTeshu.builder().build().selectOne(new QueryWrapper<KqglAssoTeshu>().lambda().eq(KqglAssoTeshu::getKqzid, attgro.getId())
		    				.eq(KqglAssoTeshu::getTsrq, str).eq(KqglAssoTeshu::getBcid, 0));
		    		if(rest != null){//今天休息  Sort返回0【特殊日期--休息】
		    			List<AttSchedule> atts = new ArrayList<AttSchedule>();
			    		AttSchedule as = AttSchedule.builder().id(0).sort(0).time(0l).starttime(0l).endtime(0l).build();
			    		atts.add(as);
			    		attcar.setAttsch(atts);
		    		}else{//今天上班
			    		KqglAssoBcsz bcz = KqglAssoBcsz.builder().build().selectOne(new QueryWrapper<KqglAssoBcsz>().lambda().eq(KqglAssoBcsz::getId, atwek.getBcid()));
			    		
			    		if(bcz != null){
			    			Getshiftinformationbatch(bcz,attcar,str);
			    		}
		    		}
		    	}else{//必须打卡
		    		KqglAssoTeshu tsri = KqglAssoTeshu.builder().build().selectOne(new QueryWrapper<KqglAssoTeshu>().lambda().eq(KqglAssoTeshu::getKqzid, attgro.getId())
		    				.eq(KqglAssoTeshu::getTsrq, str).ne(KqglAssoTeshu::getBcid, 0));
		    		if(tsri != null){
		    			KqglAssoBcsz tsrq = KqglAssoBcsz.builder().build().selectOne(new QueryWrapper<KqglAssoBcsz>().lambda().eq(KqglAssoBcsz::getId, tsri.getBcid()));
		    			if(tsrq!=null){
		    				Getshiftinformationbatch(tsrq,attcar,str);
		    			}
		    		}else{//休息
		    			List<AttSchedule> atts = new ArrayList<AttSchedule>();
			    		AttSchedule as = AttSchedule.builder().id(0).sort(0).time(0l).starttime(0l).endtime(0l).build();
			    		atts.add(as);
			    		attcar.setAttsch(atts);
		    		}
		    	}
			}else if(attgro.getPbfs() == 2){//自由排班
				//未排班时,员工可选择班次打卡
//			    if(attgro.getIsXzbcdk() == 1){
//			    	attcar.setOptscheduling(true);	
//			    }else{
//			    	attcar.setOptscheduling(false);
//			    }
				if(jrpb != null){
					if(jrpb.getBcid() != 0){//有班次时("Bcid"不为0时)
						KqglAssoBcsz tsrq = KqglAssoBcsz.builder().build().selectOne(new QueryWrapper<KqglAssoBcsz>().lambda().eq(KqglAssoBcsz::getId, jrpb.getBcid()));
						/**已简化**/
						Getshiftinformationbatch(tsrq,attcar,str);
					}else{//当天排班为休息
						List<AttSchedule> atts1 = new ArrayList<AttSchedule>();
			    		AttSchedule as = AttSchedule.builder().id(0).sort(0).time(0l).starttime(0l).endtime(0l).build();
			    		atts1.add(as);
			    		attcar.setAttsch(atts1);
					}
				}
			}else{//自由工时
				KqglAssoZhoupaiban wekz = KqglAssoZhoupaiban.builder().build().selectOne(new QueryWrapper<KqglAssoZhoupaiban>().lambda().eq(KqglAssoZhoupaiban::getKqzid, attgro.getId())
						.eq(KqglAssoZhoupaiban::getBcid, 0).eq(KqglAssoZhoupaiban::getType, week));
				if(wekz != null){//
					String dada = str+" "+attgro.getKqkssjTime()+":00";
					attcar.setStapclotime(Long.valueOf(ClockInTool.dateToStamp(dada)));
				}
				
				if(!("").equals(attgro.getJbzdsc())){
					attcar.setCanpunchworkdate(Double.valueOf(attgro.getJbzdsc()));//上班打卡后多久大下班卡
				}
			}
		    if(jrpb != null || atwek != null){
		    	KqglAssoBcsz shif = KqglAssoBcsz.builder().build();
		    	if(attgro.getPbfs() == 1){
		    		shif = shif.selectOne(new QueryWrapper<KqglAssoBcsz>().lambda().eq(KqglAssoBcsz::getId, atwek.getBcid()));
		    	}else if(attgro.getPbfs() == 2){
		    		shif = shif.selectOne(new QueryWrapper<KqglAssoBcsz>().lambda().eq(KqglAssoBcsz::getId, jrpb.getBcid()));
		    	}
		    	
		    	if(shif != null){
		    		if(shif.getIsXbdk() == 1){
		    			attcar.setNoclockout(true);// 下班不用打卡
		    		}else{
		    			attcar.setNoclockout(false);// 下班不用打卡
		    		}
		    		attcar.setAllowlate(shif.getYxcdfzs());// 允许迟到分钟数
		    		attcar.setSeriouslate(shif.getYzcdfzs());// 严重迟到分钟数
		    		attcar.setAbsenteeismlate(shif.getKgcdfzs());// 旷工迟到分钟数
		    		if(shif.getIsWzwd() == 1){
		    			attcar.setIslatelate(true);// 晚走晚到
		    			List<AttLateLate> atwzwd = new ArrayList<AttLateLate>();
		    			int p = 0;
		    			if(!("").equals(shif.getXbwz1()) && !("").equals(shif.getSbwd1())){p = 2;}
		    			if(!("").equals(shif.getXbwz1()) && !("").equals(shif.getSbwd1()) && !("").equals(shif.getXbwz2()) && !("").equals(shif.getSbwd2())){p = 4;}
		    			if(!("").equals(shif.getXbwz1()) && !("").equals(shif.getSbwd1()) && !("").equals(shif.getXbwz2()) && !("").equals(shif.getSbwd2()) && !("").equals(shif.getXbwz3()) && !("").equals(shif.getSbwd3())){p = 6;}
		    			AttLateLate ala = AttLateLate.builder().build();
		    			ala.setLatewalk(shif.getXbwz1());
		    			ala.setArrivelate(shif.getSbwd1());
		    			atwzwd.add(ala);
		    			if(p == 4 || p == 6){
		    				AttLateLate alat = AttLateLate.builder().build();
		    				alat.setLatewalk(shif.getXbwz2());
		    				alat.setArrivelate(shif.getSbwd2());
		    				atwzwd.add(alat);
		    			}
		    			if(p == 6){
		    				AttLateLate alas = AttLateLate.builder().build();
		    				alas.setLatewalk(shif.getXbwz3());
		    				alas.setArrivelate(shif.getSbwd3());
		    				atwzwd.add(alas);
		    			}
		    			attcar.setAttlat(atwzwd);
		    		}else{
		    			attcar.setIslatelate(false);// 晚走晚到
		    		}
		    	}
		    }
		    attcar.setAttgrouptype(attgro.getPbfs());//1：固定排班；2：自由排班；3：自由工时
		 }else{
			 attcar.setAttgrouptype(0);//1：固定排班；2：自由排班；3：自由工时
		 }
		 
		 
		 
		 return attcar;
	 }
	
	/**
	 * @param shiftm
	 * @param attcar
	 * @param str
	 */
	public void Getshiftinformationbatch(KqglAssoBcsz shiftm,AttendanceCardListDto attcar,String str){
		int isXbdk1Cr = shiftm.getIsXbdk1Cr();//下班1是否次日（0：否；1：是）
		int isSbdk2Cr = shiftm.getIsSbdk2Cr();//上班2是否次日（0：否；1：是）
		int isXbdk2Cr = shiftm.getIsXbdk2Cr();//下班2是否次日（0：否；1：是）
		int isSbdk3Cr = shiftm.getIsSbdk3Cr();//上班3是否次日（0：否；1：是）
		int isXbdk3Cr = shiftm.getIsXbdk3Cr();//下班3是否次日（0：否；1：是）
		
		//次日专用
		String next_day = ClockInTool.requires_extra_times(str,1,2,1);
		
		 List<AttSchedule> atts = new ArrayList<AttSchedule>();
	    	if(shiftm.getSxbcs() == 1 || shiftm.getSxbcs() == 2 || shiftm.getSxbcs() == 3){//1次上下班
	    		for(int o=0;o<2;o++){
	    			if(o==0){
			    		AttSchedule as = AttSchedule.builder().id(shiftm.getId()).sort(1).time(Long.valueOf(ClockInTool.dateToStamp((str+" "+shiftm.getSbdk1()+":00").replaceAll("\r|\n", ""))))
			    				.starttime(("").equals(shiftm.getSbqjks1()) || shiftm.getSbqjks1() == null ? 0 : Long.valueOf(ClockInTool.dateToStamp((str+" "+shiftm.getSbqjks1()+":00").replaceAll("\r|\n", ""))))
			    				.endtime(("").equals(shiftm.getSbqjjs1()) || shiftm.getSbqjjs1() == null ? 0 : Long.valueOf(ClockInTool.dateToStamp((str+" "+shiftm.getSbqjjs1()+":00").replaceAll("\r|\n", ""))))
			    				.nextday(0).build();
			    		
			    		atts.add(as);
	    			}else{
	    				//次日
	    				if(isXbdk1Cr > 0) {
	    					AttSchedule as = AttSchedule.builder().id(shiftm.getId()).sort(2).time(Long.valueOf(ClockInTool.dateToStamp((next_day+" "+shiftm.getXbdk1()+":00").replaceAll("\r|\n", ""))))
				    				.starttime(("").equals(shiftm.getXbqjks1()) || shiftm.getXbqjks1() == null ? 0 : Long.valueOf(ClockInTool.dateToStamp((next_day+" "+shiftm.getXbqjks1()+":00").replaceAll("\r|\n", ""))))
				    				.endtime(("").equals(shiftm.getXbqjjs1()) || shiftm.getXbqjjs1() ==null ? 0 : Long.valueOf(ClockInTool.dateToStamp((next_day+" "+shiftm.getXbqjjs1()+":00").replaceAll("\r|\n", ""))))
				    				.nextday(1).build();
				    		atts.add(as);
	    				}else {
	    					AttSchedule as = AttSchedule.builder().id(shiftm.getId()).sort(2).time(Long.valueOf(ClockInTool.dateToStamp((str+" "+shiftm.getXbdk1()+":00").replaceAll("\r|\n", ""))))
				    				.starttime(("").equals(shiftm.getXbqjks1()) || shiftm.getXbqjks1() == null ? 0 : Long.valueOf(ClockInTool.dateToStamp((str+" "+shiftm.getXbqjks1()+":00").replaceAll("\r|\n", ""))))
				    				.endtime(("").equals(shiftm.getXbqjjs1()) || shiftm.getXbqjjs1() ==null ? 0 : Long.valueOf(ClockInTool.dateToStamp((str+" "+shiftm.getXbqjjs1()+":00").replaceAll("\r|\n", ""))))
				    				.nextday(0).build();
				    		atts.add(as);
	    				}
			    		
	    			}
	    		}
	    		attcar.setAttsch(atts);
	    	}
	    	if(shiftm.getSxbcs() == 2 || shiftm.getSxbcs() == 3){//2次上下班
	    		for(int o=0;o<2;o++){
	    			if(o==0){
	    				if(isSbdk2Cr > 0) {//次日
	    					AttSchedule as = AttSchedule.builder().id(shiftm.getId()).sort(3).time(Long.valueOf(ClockInTool.dateToStamp((next_day+" "+shiftm.getSbdk2()+":00").replaceAll("\r|\n", ""))))
				    				.starttime(("").equals(shiftm.getSbqjks2())|| shiftm.getSbqjks2()== null ? 0 : Long.valueOf(ClockInTool.dateToStamp((next_day+" "+shiftm.getSbqjks2()+":00").replaceAll("\r|\n", ""))))
				    				.endtime(("").equals(shiftm.getSbqjjs2()) || shiftm.getSbqjjs2()== null ? 0 : Long.valueOf(ClockInTool.dateToStamp((next_day+" "+shiftm.getSbqjjs2()+":00").replaceAll("\r|\n", ""))))
				    				.nextday(1).build();
				    		atts.add(as);
	    				}else {
	    					AttSchedule as = AttSchedule.builder().id(shiftm.getId()).sort(3).time(Long.valueOf(ClockInTool.dateToStamp((str+" "+shiftm.getSbdk2()+":00").replaceAll("\r|\n", ""))))
				    				.starttime(("").equals(shiftm.getSbqjks2())|| shiftm.getSbqjks2()== null ? 0 : Long.valueOf(ClockInTool.dateToStamp((str+" "+shiftm.getSbqjks2()+":00").replaceAll("\r|\n", ""))))
				    				.endtime(("").equals(shiftm.getSbqjjs2()) || shiftm.getSbqjjs2()== null ? 0 : Long.valueOf(ClockInTool.dateToStamp((str+" "+shiftm.getSbqjjs2()+":00").replaceAll("\r|\n", ""))))
				    				.nextday(0).build();
				    		atts.add(as);
	    				}
			    		
	    			}else{
	    				if(isXbdk2Cr > 0) {//次日
	    					AttSchedule as = AttSchedule.builder().id(shiftm.getId()).sort(4).time(Long.valueOf(ClockInTool.dateToStamp((next_day+" "+shiftm.getXbdk2()+":00").replaceAll("\r|\n", ""))))
				    				.starttime(("").equals(shiftm.getXbqjks2()) || shiftm.getXbqjks2()== null? 0 : Long.valueOf(ClockInTool.dateToStamp((next_day+" "+shiftm.getXbqjks2()+":00").replaceAll("\r|\n", ""))))
				    				.endtime(("").equals(shiftm.getXbqjjs2()) || shiftm.getXbqjjs2()== null? 0 : Long.valueOf(ClockInTool.dateToStamp((next_day+" "+shiftm.getXbqjjs2()+":00").replaceAll("\r|\n", ""))))
				    				.nextday(1).build();
				    		atts.add(as);
	    				}else {
	    					AttSchedule as = AttSchedule.builder().id(shiftm.getId()).sort(4).time(Long.valueOf(ClockInTool.dateToStamp((str+" "+shiftm.getXbdk2()+":00").replaceAll("\r|\n", ""))))
				    				.starttime(("").equals(shiftm.getXbqjks2()) || shiftm.getXbqjks2()== null? 0 : Long.valueOf(ClockInTool.dateToStamp((str+" "+shiftm.getXbqjks2()+":00").replaceAll("\r|\n", ""))))
				    				.endtime(("").equals(shiftm.getXbqjjs2()) || shiftm.getXbqjjs2()== null? 0 : Long.valueOf(ClockInTool.dateToStamp((str+" "+shiftm.getXbqjjs2()+":00").replaceAll("\r|\n", ""))))
				    				.nextday(0).build();
				    		atts.add(as);
	    				}
			    		
	    			}
	    		}
	    		attcar.setAttsch(atts);
	    	}
	    	if(shiftm.getSxbcs() == 3){//3次上下班
	    		for(int o=0;o<2;o++){
	    			if(o==0){
	    				if(isSbdk3Cr > 0) {//次日
	    					AttSchedule as = AttSchedule.builder().id(shiftm.getId()).sort(5).time(Long.valueOf(ClockInTool.dateToStamp((next_day+" "+shiftm.getSbdk3()+":00").replaceAll("\r|\n", ""))))
				    				.starttime(("").equals(shiftm.getSbqjks3()) || shiftm.getSbqjks3() == null? 0 : Long.valueOf(ClockInTool.dateToStamp((next_day+" "+shiftm.getSbqjks3()+":00").replaceAll("\r|\n", ""))))
				    				.endtime(("").equals(shiftm.getSbqjjs3()) || shiftm.getSbqjjs3() == null ? 0 : Long.valueOf(ClockInTool.dateToStamp((next_day+" "+shiftm.getSbqjjs3()+":00").replaceAll("\r|\n", ""))))
				    				.nextday(1).build();
				    		atts.add(as);
	    				}else {
	    					AttSchedule as = AttSchedule.builder().id(shiftm.getId()).sort(5).time(Long.valueOf(ClockInTool.dateToStamp((str+" "+shiftm.getSbdk3()+":00").replaceAll("\r|\n", ""))))
				    				.starttime(("").equals(shiftm.getSbqjks3()) || shiftm.getSbqjks3() == null? 0 : Long.valueOf(ClockInTool.dateToStamp((str+" "+shiftm.getSbqjks3()+":00").replaceAll("\r|\n", ""))))
				    				.endtime(("").equals(shiftm.getSbqjjs3()) || shiftm.getSbqjjs3() == null ? 0 : Long.valueOf(ClockInTool.dateToStamp((str+" "+shiftm.getSbqjjs3()+":00").replaceAll("\r|\n", ""))))
				    				.nextday(0).build();
				    		atts.add(as);
	    				}
			    		
	    			}else{
	    				if(isXbdk3Cr > 0) {//次日
	    					AttSchedule as = AttSchedule.builder().id(shiftm.getId()).sort(6).time(Long.valueOf(ClockInTool.dateToStamp((next_day+" "+shiftm.getXbdk3()+":00").replaceAll("\r|\n", ""))))
				    				.starttime(("").equals(shiftm.getXbqjks3()) || shiftm.getXbqjks3()== null ? 0 : Long.valueOf(ClockInTool.dateToStamp((next_day+" "+shiftm.getXbqjks3()+":00").replaceAll("\r|\n", ""))))
				    				.endtime(("").equals(shiftm.getXbqjjs3()) || shiftm.getXbqjjs3() ==null? 0 : Long.valueOf(ClockInTool.dateToStamp((next_day+" "+shiftm.getXbqjjs3()+":00").replaceAll("\r|\n", ""))))
				    				.nextday(1).build();
				    		atts.add(as);
	    				}else {
	    					AttSchedule as = AttSchedule.builder().id(shiftm.getId()).sort(6).time(Long.valueOf(ClockInTool.dateToStamp((str+" "+shiftm.getXbdk3()+":00").replaceAll("\r|\n", ""))))
				    				.starttime(("").equals(shiftm.getXbqjks3()) || shiftm.getXbqjks3()== null ? 0 : Long.valueOf(ClockInTool.dateToStamp((str+" "+shiftm.getXbqjks3()+":00").replaceAll("\r|\n", ""))))
				    				.endtime(("").equals(shiftm.getXbqjjs3()) || shiftm.getXbqjjs3() ==null? 0 : Long.valueOf(ClockInTool.dateToStamp((str+" "+shiftm.getXbqjjs3()+":00").replaceAll("\r|\n", ""))))
				    				.nextday(0).build();
				    		atts.add(as);
	    				}
			    		
	    			}
	    		}
	    		attcar.setAttsch(atts);
	    	}
	 }
	
	
	
	/************************************************************************************************************************************************************************************************/
	/**************************************************************************	APP打卡	*************************************************************************************************************/
	/************************************************************************************************************************************************************************************************/
	
	/**
	  * 	考勤打卡------APP打卡
	 * @throws ParseException 
	  */
	 @PostMapping(value = "/AttendanceCard")
	 @ApiOperation(value = "考勤打卡------APP打卡", httpMethod = "POST", notes = "接口发布说明")
	 @ApiOperationSupport(order = 2)
	 public Result<Object> AttendanceCard(@CurrentUser UserBean userBean,@RequestBody ClockCollectData clock) throws ParseException {
		 //当前时间
		 String current_time = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date());
		 String current = new SimpleDateFormat("yyyy-MM-dd").format(new Date());
		 //当前用户打卡时间
		 String sStdIoTime = clock.getPunchtime();
		 
		 //基于当前的前一天时间   和当天开始与结束时间戳
		 String yesterday = ClockInTool.requires_extra_times(current,-1,3,1);
		 Long startDateyesterday = DateUtil.getStartTime(0,DateUtil.getStringTime(yesterday,"yyyy-MM-dd")).getTime();
		 Long endDateyesterday = DateUtil.getnowEndTime(23,DateUtil.getStringTime(yesterday,"yyyy-MM-dd")).getTime();
		 
		 Long attendance_date = 0l;//考勤日期
		 String toweek = "";
		 
		 String msg = "未知错误，请联系管理员";
		 int sbyf = 1;//0:失败；1:成功
		 
		 YgglMainEmp user = YgglMainEmp.builder().build().selectOne(new QueryWrapper<YgglMainEmp>().lambda().eq(YgglMainEmp::getEmpNum, clock.getUserid()).eq(YgglMainEmp::getOrgCode, userBean.getOrgCode()));
		 if(user != null) {
			 int qyid = user.getOrgCode();
			 int userid = user.getEmpNum();	 
				 
//		     AttendanceGroup attgro = attendancegroupmapper.getAttendanceGroupInformationByUserid(userid,qyid); //考勤组信息
		     KqglMainKqz attgro = kqglmainkqzmapper.getAttendanceGroupInformationByUserid(userid,qyid); //考勤组信息
//			 pbfs;// 排班方式 1：固定排班；2：自由排班；3：自由工时
			 
		     long time_ = DateUtil.getStringTime(clock.getPunchtime(), "yyyy-MM-dd HH:mm:ss");//打卡时间戳
		     
				
			String putime = sStdIoTime.substring(0, 10);////转换打卡时间格式 yyyy-MM-dd
//		     String putime = new SimpleDateFormat("yyyy-MM-dd").format(Double.valueOf(clock.getPunchtime()));//转换打卡时间格式
		     
			 Long startDate = DateUtil.getStartTime(0,DateUtil.getStringTime(putime,"yyyy-MM-dd")).getTime();//打卡当天开始时间
		     Long endDate = DateUtil.getnowEndTime(23,DateUtil.getStringTime(putime,"yyyy-MM-dd")).getTime();//打卡当天结束时间
			 
		     int dkmx = 0;//打卡明细id
		     int atttype = 0;//打卡顺序
		     int shifid = 0;//班次id
		     boolean isRange = true;//是否在打卡时间范围内
		     int execution_status = 0;//执行状态
		     boolean kskd = true;//识别是否更新最后一次打卡   针对于最后一次下班卡
			 boolean sbdkkd = false;//针对于上班  未超过上班卡打卡  视为无效打卡
			 long punchcardtime = 0,punchstart = 0,punchend = 0;//应打卡时间,应打卡开始时间,应打卡结束时间
		     
		     ClockCollectData clockt = new ClockCollectData();
//			 putime： 根据日期  得到打卡所需的详细信息
			 AttendanceCardListDto attdate = MethodCall(qyid,userid,putime);
			 if(attgro != null) {//判断考勤组是否存在
				 
				 if(attdate.getAttgrouptype() != 3) {
					//查询打卡当天是否有记录**********************************
					KqglAssoDkmx dkmc = KqglAssoDkmx.builder().build();
					String dakariqi = new SimpleDateFormat("yy-MM-dd").format(Double.valueOf(startDateyesterday))+" "+ClockInTool.dateToWeek2(yesterday);
					//检查昨日的班次是否存在次日打卡
					KqglAssoDkjl balan = kqglassodkjlmapper.selectOne(new QueryWrapper<KqglAssoDkjl>().lambda().eq(KqglAssoDkjl::getUserId, userid).eq(KqglAssoDkjl::getAttdate, dakariqi).ne(KqglAssoDkjl::getBcid, 0).orderByDesc(KqglAssoDkjl :: getSort).last("LIMIT 1"));
					boolean dnck = false;
					boolean crdk = false;//当次打卡是否存在次日打卡
					if(balan != null) {//前一天是否打过卡    去班次id查询是否存在次日打卡
						//昨日的班次信息
						KqglAssoBcsz shif = kqglassobcszmapper.selectOne(new QueryWrapper<KqglAssoBcsz>().lambda().eq(KqglAssoBcsz::getId, balan.getBcid()));
						int dkcs = shif.getSxbcs()*2;
						List<AttSchedule> ashss = attdate.getAttsch();//获取今天应打卡时间
						if(ashss.size() > 0) {
							Date sd1=df1.parse(ClockInTool.stampToDate(String.valueOf(ashss.get(0).getTime())));//当天应打的首次上班卡时间
							Date sd2=df1.parse(current_time);//当前时间
							if(sd1.after(sd2)) {//大于
								dnck = true;
							}
						}
						int isXbdk1Cr = shif.getIsXbdk1Cr();//下班1是否次日（0：否；1：是）
						int isSbdk2Cr = shif.getIsSbdk2Cr();//上班2是否次日（0：否；1：是）
						int isXbdk2Cr = shif.getIsXbdk2Cr();//下班2是否次日（0：否；1：是）
						int isSbdk3Cr = shif.getIsSbdk3Cr();//上班3是否次日（0：否；1：是）
						int isXbdk3Cr = shif.getIsXbdk3Cr();//下班3是否次日（0：否；1：是）
						if(balan.getSort() < dkcs) {
							if(balan.getSort()+1 == 2 && dkcs == 2) {
								//次日
								if(isXbdk1Cr > 0) { crdk = true; }
							}
							if(balan.getSort()+1 == 3 && dkcs == 4) {
								if(isSbdk2Cr > 0) {crdk = true; }
							}
							if(balan.getSort()+1 == 4 && dkcs == 4) {
								if(isXbdk2Cr > 0) { crdk = true; }
							}
							if(balan.getSort()+1 == 5 && dkcs == 6) {
								if(isSbdk3Cr > 0) { crdk = true; }
							}
							if(balan.getSort()+1 == 6 && dkcs == 6) {
								if(isXbdk3Cr > 0) { crdk = true; }
							}
						}
					}else {
						//无记录的话就找昨天的数据
						AttendanceCardListDto attdate1 = MethodCall(qyid,userid,yesterday);
						List<AttSchedule> ashssyebo = attdate1.getAttsch();//获取昨天应打卡时间
						
						
						
					}
					if(crdk && dnck) {
						dkmc = KqglAssoDkmx.builder().build().selectOne(new QueryWrapper<KqglAssoDkmx>().lambda().eq(KqglAssoDkmx::getUserid, userid)
								.ge(KqglAssoDkmx::getDksj, startDateyesterday).le(KqglAssoDkmx::getDksj, endDateyesterday));
						attdate = MethodCall(qyid,userid,yesterday);
						attendance_date = startDateyesterday;
						toweek = yesterday;
					}else {
						dkmc = KqglAssoDkmx.builder().build().selectOne(new QueryWrapper<KqglAssoDkmx>().lambda().eq(KqglAssoDkmx::getUserid, userid)
								.ge(KqglAssoDkmx::getDksj, startDate).le(KqglAssoDkmx::getDksj, endDate));
						attendance_date = startDate;
						toweek = putime;
					}
					
					if(EmptyUtil.isEmpty(attdate.getAttsch())) {
						msg = "当前未排班";
						sbyf = 0;
					}else {
						
						long starttime1 = 0,starttime1ks = 0,starttime1js = 0,endtime1 = 0,endtime1ks = 0,endtime1js = 0,starttime2 = 0,starttime2ks = 0,starttime2js = 0,endtime2 = 0,endtime2ks = 0,endtime2js = 0,starttime3 = 0,starttime3ks = 0,starttime3js = 0,
								endtime3 = 0,endtime3ks = 0,endtime3js = 0; 
						if(attdate.getAttsch().size() > 0) {
							 List<AttSchedule> ash = attdate.getAttsch();
							 int y = 0;
							 clockt.setShifid(ash.get(y).getId());
							 shifid = ash.get(y).getId();//班次id
							 if(attdate.getAttsch().size() == 2 || attdate.getAttsch().size() == 4 || attdate.getAttsch().size() == 6) {
								 starttime1 = ash.get(0).getTime();starttime1ks = ash.get(0).getStarttime();starttime1js = ash.get(0).getEndtime();
								 endtime1 = ash.get(1).getTime();endtime1ks = ash.get(1).getStarttime();endtime1js = ash.get(1).getEndtime();
							 }
						 	if(attdate.getAttsch().size() == 4 || attdate.getAttsch().size() == 6) {
						 		starttime2 = ash.get(2).getTime();starttime2ks = ash.get(2).getStarttime();starttime2js = ash.get(2).getEndtime();
							    endtime2 = ash.get(3).getTime();endtime2ks = ash.get(3).getStarttime();endtime2js = ash.get(3).getEndtime();
							}
						 	if(attdate.getAttsch().size() == 6) {
						 		starttime3 = ash.get(4).getTime();starttime3ks = ash.get(4).getStarttime();starttime3js = ash.get(4).getEndtime();
								endtime3 = ash.get(5).getTime();endtime3ks = ash.get(5).getStarttime();endtime3js = ash.get(5).getEndtime();
							 }
						 	
						 	if(dkmc == null) {
						 		kskd = false;
						 		if(attdate.getAttsch().size() == 2) {//一套上下班  上班1
						 			
						 			Date sd1=df1.parse(ClockInTool.stampToDate(String.valueOf(starttime1)));//应打卡时间
									Date sd2=df1.parse(sStdIoTime);//打卡时间
									Date sd3=df1.parse(ClockInTool.stampToDate(String.valueOf(endtime1)));//应打卡时间
									if(sd2.before(sd3)) {
										atttype = 1;
									}
									
									if(sd2.after(sd1) && sd2.after(sd3)) {
										atttype = 2;
									}
						 			
						 		}else {
						 			boolean getinto = true;
						 			//打卡时间  对比班次  接近哪个时间就打哪个时间的卡
							 		if(attdate.getAttsch().size() == 4 || attdate.getAttsch().size() == 6) {
							 			//punchstart 应打卡开始时间 punchend:应打卡结束时间  time_:打卡时间
							 			if(clock.getType() == 1) {
							 				boolean effectiveDate1 = ClockInTool.hourMinuteBetween(new SimpleDateFormat("yyyy-MM-dd HH:mm").format(time_), new SimpleDateFormat("yyyy-MM-dd HH:mm").format(starttime1ks), new SimpleDateFormat("yyyy-MM-dd HH:mm").format(starttime1js),"yyyy-MM-dd HH:mm");
										    if (effectiveDate1) {//在范围内就打卡 
										    	atttype = clock.getType();
										    	getinto = false;
										    }else {
										    	if(getinto) {
										    		isRange = false;
										    	}
										    }
							 			}else if(clock.getType() == 2){
							 				boolean effectiveDate2 = ClockInTool.hourMinuteBetween(new SimpleDateFormat("yyyy-MM-dd HH:mm").format(time_), new SimpleDateFormat("yyyy-MM-dd HH:mm").format(endtime1ks), new SimpleDateFormat("yyyy-MM-dd HH:mm").format(endtime1js),"yyyy-MM-dd HH:mm");
										    if (effectiveDate2) {//在范围内就打卡 
										    	atttype = clock.getType();
										    	isRange = true;//在范围
										    	
										    	getinto = false;
										    }else {
										    	if(getinto) {
										    		isRange = false;
										    	}
										    }
							 			}else if(clock.getType() == 3) {
							 				boolean effectiveDate3 = ClockInTool.hourMinuteBetween(new SimpleDateFormat("yyyy-MM-dd HH:mm").format(time_), new SimpleDateFormat("yyyy-MM-dd HH:mm").format(starttime2ks), new SimpleDateFormat("yyyy-MM-dd HH:mm").format(starttime2js),"yyyy-MM-dd HH:mm");
										    if (effectiveDate3) {//在范围内就打卡 
										    	atttype = clock.getType();
										    	isRange = true;//在范围
										    	
										    	getinto = false;
										    }else {
										    	if(getinto) {
										    		isRange = false;
										    	}
										    }
							 			}else if(clock.getType() == 4) {
							 				boolean effectiveDate4 = ClockInTool.hourMinuteBetween(new SimpleDateFormat("yyyy-MM-dd HH:mm").format(time_), new SimpleDateFormat("yyyy-MM-dd HH:mm").format(endtime2ks), new SimpleDateFormat("yyyy-MM-dd HH:mm").format(endtime2js),"yyyy-MM-dd HH:mm");
										    if (effectiveDate4) {//在范围内就打卡 
										    	atttype = clock.getType();
										    	isRange = true;//在范围
										    	
										    	getinto = false;
										    }else {
										    	if(getinto) {
										    		isRange = false;
										    	}
										    }
							 			}
							 		}
							 		if(attdate.getAttsch().size() == 6) {
							 			if(clock.getType() == 5) {
							 				boolean effectiveDate5 = ClockInTool.hourMinuteBetween(new SimpleDateFormat("yyyy-MM-dd HH:mm").format(time_), new SimpleDateFormat("yyyy-MM-dd HH:mm").format(starttime3ks), new SimpleDateFormat("yyyy-MM-dd HH:mm").format(starttime3js),"yyyy-MM-dd HH:mm");
										    if (effectiveDate5) {//在范围内就打卡 
										    	atttype = clock.getType();
										    	isRange = true;//在范围
										    	
										    	getinto = false;
										    }else {
										    	if(getinto) {
										    		isRange = false;
										    	}
										    }
							 			}else if(clock.getType() == 6) {
							 				boolean effectiveDate6 = ClockInTool.hourMinuteBetween(new SimpleDateFormat("yyyy-MM-dd HH:mm").format(time_), new SimpleDateFormat("yyyy-MM-dd HH:mm").format(endtime3ks), new SimpleDateFormat("yyyy-MM-dd HH:mm").format(endtime3js),"yyyy-MM-dd HH:mm");
										    if (effectiveDate6) {//在范围内就打卡 
										    	atttype = clock.getType();
										    	isRange = true;//在范围
										    	
										    	getinto = false;
										    }else {
										    	if(getinto) {
										    		isRange = false;
										    	}
										    }
							 			}
							 		}
						 		}
							 	 execution_status = 1;
						 	}else {
						 		boolean getinto2 = true;
						 		execution_status = 2;
						 		if(attdate.getAttsch().size() == 2) {	//下班1
						 			if(clock.getType() == 1) {
						 				if(clock.getDiffer() == 2) {//更新打卡
						 					//如果第二次后打卡，未超过上班时间  即为打卡失效
							 				Date sd1=df1.parse(ClockInTool.stampToDate(String.valueOf(starttime1)));//应打卡时间
											Date sd2=df1.parse(sStdIoTime);//打卡时间
											if(sd1.after(sd2)) {
												sbdkkd = true;//打卡无效
//												atttype = 1;
											}
						 				}
						 			}else if(clock.getType() == 2){
						 				if(dkmc.getSbdk1() != null && dkmc.getXbdk1() == null){
						 					kskd = false;
						 					atttype = clock.getType();
						 				}else {
						 					//最后一次卡的时候 再继续打视为更新最后一次打卡
									    	kskd = true;//更新最后一次打卡
									    	atttype = clock.getType();
						 				}
						 				
						 			}
						 		}	
						 		if(attdate.getAttsch().size() == 4 || attdate.getAttsch().size() == 6) {
						 			if(clock.getType() == 1) {
						 				boolean effectiveDate1 = ClockInTool.hourMinuteBetween(new SimpleDateFormat("yyyy-MM-dd HH:mm").format(time_), new SimpleDateFormat("yyyy-MM-dd HH:mm").format(starttime1ks), new SimpleDateFormat("yyyy-MM-dd HH:mm").format(starttime1js),"yyyy-MM-dd HH:mm");
									    if (effectiveDate1) {//在范围内就打卡 
									    	if(dkmc.getSbdk1() != null) {
									    		sbdkkd = true;//打卡无效
									    	}else {
									    		atttype = clock.getType();
									    		isRange = true;//在范围
										    	getinto2 = false;
									    	}
									    }else { 
									    	if(getinto2) {
									    		isRange = false; 
									    	}
									    }
						 			}else if(clock.getType() == 2) {
						 				boolean effectiveDate2 = ClockInTool.hourMinuteBetween(new SimpleDateFormat("yyyy-MM-dd HH:mm").format(time_), new SimpleDateFormat("yyyy-MM-dd HH:mm").format(endtime1ks), new SimpleDateFormat("yyyy-MM-dd HH:mm").format(endtime1js),"yyyy-MM-dd HH:mm");
									    if (effectiveDate2) {//在范围内就打卡 
									    	if(dkmc.getXbdk1() != null) {
									    		kskd = true;////更新最后一次打卡
									    		atttype = clock.getType();
									    		isRange = true;//在范围
										    	getinto2 = false;
									    	}else {
									    		kskd = false;//更新最后一次打卡
									    		atttype = clock.getType();
									    	}
									    }else { 
									    	if(getinto2) {
									    		isRange = false; 
									    	}
									    }
						 			}else if(clock.getType() == 3) {
						 				boolean effectiveDate3 = ClockInTool.hourMinuteBetween(new SimpleDateFormat("yyyy-MM-dd HH:mm").format(time_), new SimpleDateFormat("yyyy-MM-dd HH:mm").format(starttime2ks), new SimpleDateFormat("yyyy-MM-dd HH:mm").format(starttime2js),"yyyy-MM-dd HH:mm");
									    if (effectiveDate3) {//在范围内就打卡 
									    	if(dkmc.getSbdk2() != null) {
									    		sbdkkd = true;//打卡无效
									    	}else {
									    		atttype = clock.getType();
									    		isRange = true;//在范围
										    	getinto2 = false;
									    	}
									    }else { 
									    	if(getinto2) {
									    		isRange = false; 
									    	}
									    }
						 			}else if(clock.getType() == 4) {
						 				 boolean effectiveDate4 = ClockInTool.hourMinuteBetween(new SimpleDateFormat("yyyy-MM-dd HH:mm").format(time_), new SimpleDateFormat("yyyy-MM-dd HH:mm").format(endtime2ks), new SimpleDateFormat("yyyy-MM-dd HH:mm").format(endtime2js),"yyyy-MM-dd HH:mm");
										    if (effectiveDate4) {//在范围内就打卡 
										    	if(dkmc.getXbdk2() != null) {
										    		kskd = true;////更新最后一次打卡
										    		atttype = clock.getType();
										    		isRange = true;//在范围
											    	getinto2 = false;
										    	}else {
										    		kskd = false;
										    		atttype = clock.getType();
										    	}
										    }else { 
										    	if(getinto2) {
										    		isRange = false; 
										    	}
										    }	
						 			}
						 		}
						 		if(attdate.getAttsch().size() == 6) {
						 			if(clock.getType() == 5) {
						 				boolean effectiveDate5 = ClockInTool.hourMinuteBetween(new SimpleDateFormat("yyyy-MM-dd HH:mm").format(time_), new SimpleDateFormat("yyyy-MM-dd HH:mm").format(starttime3ks), new SimpleDateFormat("yyyy-MM-dd HH:mm").format(starttime3js),"yyyy-MM-dd HH:mm");
									    if (effectiveDate5) {//在范围内就打卡 
									    	if(dkmc.getSbdk2() != null) {
									    		sbdkkd = true;//打卡无效
									    	}else {
									    		atttype = clock.getType();
									    		isRange = true;//在范围
										    	getinto2 = false;
									    	}
									    }else { 
									    	if(getinto2) {
									    		isRange = false; 
									    	}
									    }
						 			}else if(clock.getType() == 6) {
						 				boolean effectiveDate6 = ClockInTool.hourMinuteBetween(new SimpleDateFormat("yyyy-MM-dd HH:mm").format(time_), new SimpleDateFormat("yyyy-MM-dd HH:mm").format(endtime3ks), new SimpleDateFormat("yyyy-MM-dd HH:mm").format(endtime3js),"yyyy-MM-dd HH:mm");
									    if (effectiveDate6) {//在范围内就打卡 
									    	if(dkmc.getXbdk2() != null) {
									    		kskd = true;//更新最后一次打卡
									    		atttype = clock.getType();
									    		isRange = true;//在范围
										    	getinto2 = false;
									    	}else {
									    		kskd = false;
									    		atttype = clock.getType();
									    	}
									    }else { 
									    	if(getinto2) {
									    		isRange = false; 
									    	}
									    }	
						 			}
						 		}
						 	}
						 }
						if(atttype == 1) {
							punchcardtime = starttime1; punchstart = starttime1ks; punchend = starttime1js;
						}else if(atttype == 2) {
							punchcardtime = endtime1; punchstart = endtime1ks; punchend = endtime1js;
						}else if(atttype == 3) {
							punchcardtime = starttime2; punchstart = starttime2ks; punchend = starttime2js;
						}else if(atttype == 4) {
							punchcardtime = endtime2; punchstart = endtime2ks; punchend = endtime2js;
						}else if(atttype == 5) {
							punchcardtime = starttime3; punchstart = starttime3ks; punchend = starttime3js;
						}else if(atttype == 6) {
							punchcardtime = endtime3; punchstart = endtime3ks; punchend = endtime3js;
						}
						
						if(clockt.getShifid() != 0) {
							
							KqglAssoBcsz shif = KqglAssoBcsz.builder().build();
							if(attdate.getAttsch().size() > 0 && clockt.getShifid() > 0){//有无班次
								shif = shif.selectOne(new QueryWrapper<KqglAssoBcsz>().lambda().eq(KqglAssoBcsz::getId, clockt.getShifid()));
							}
							//打卡记录录入 -- 打卡是否有时间范围限制
							 if(attdate.getAttsch().size() == 2) {
								 if(punchstart>0 && punchend>0) {
									 String staputime = new SimpleDateFormat("yyyy-MM-dd HH:mm").format(punchstart);//应打卡开始时间
									 String entputime = new SimpleDateFormat("yyyy-MM-dd HH:mm").format(punchend);//应打卡结束时间
									 String DKputime = new SimpleDateFormat("yyyy-MM-dd HH:mm").format(time_);//打卡时间
									 boolean effectiveDate = ClockInTool.hourMinuteBetween(DKputime, staputime, entputime,"yyyy-MM-dd HH:mm");
									 if (!effectiveDate) {
//										 System.out.println("当前打卡时间不在范围内");
										 isRange = false;
									 }
								 }
							 }
							 if(isRange) {
								 int yzcd = shif.getYzcdfzs();//严重迟到分钟数
								 int kgcdfzs  = shif.getKgcdfzs();//旷工迟到分钟数 
								 
								 //班次的休息时间
								 long rest_time = 0;
								 if(shif.getStartTime() != null && shif.getEndTime() != null) {
									 long kaishixiuxi = Long.valueOf(ClockInTool.dateToStamp(putime + " " +shif.getStartTime()+":00"));
								     long jieshuxiuxi = Long.valueOf(ClockInTool.dateToStamp(putime + " " +shif.getEndTime()+":00"));
								     rest_time = (jieshuxiuxi - kaishixiuxi)/1000/60;//休息时间
								 }
								 
								 if(execution_status == 1) {//上班1   ****新增
									 KqglAssoDkmx pcd = KqglAssoDkmx.builder().userid(userid).data(putime).qyid(qyid).dksj(startDate).build();
									 int sbdkjg = 0,yzcdsc = 0,yzcdcs = 0,kgcdcs = 0;
									 if(punchcardtime != 0){//有应打卡时间时
										 Long time = (time_ - punchcardtime)/1000/60;
										 if((atttype)%2 > 0){//上班
											if(time > 0){
												sbdkjg = Integer.valueOf(time.toString());
											}// 打卡结果
										 }else{//下班
											if(time > 0){}else{
												sbdkjg = Math.abs(Integer.valueOf(time.toString()));
											}// 打卡结果
										 }
									 }
									 
									 if(atttype == 1) {
								    	pcd.setSbdk1(time_); pcd.setSbdk1jg(sbdkjg);
									 }else if(atttype == 2) {
										pcd.setXbdk1(time_); pcd.setXbdk1jg(sbdkjg);
									 }else if(atttype == 3) {
										pcd.setSbdk2(time_); pcd.setSbdk2jg(sbdkjg);
									 }else if(atttype == 4) {
										pcd.setXbdk2(time_); pcd.setXbdk2jg(sbdkjg);
									 }else if(atttype == 5) {
										pcd.setSbdk3(time_); pcd.setSbdk3jg(sbdkjg);
									 }else if(atttype == 6) {
										pcd.setXbdk3(time_); pcd.setXbdk3jg(sbdkjg);
									 }
									 
									 int ydkcs = 0;
									 if(shif != null){ydkcs = shif.getSxbcs()*2;}//应打卡次数
									 if(sbdkjg > yzcd && yzcd>0) {
										 yzcdcs++;
										 yzcdsc = sbdkjg - yzcd;
									 }
									 if(sbdkjg > kgcdfzs && kgcdfzs>0) {kgcdcs++;}
									 pcd.setYdkcs(ydkcs);
									 pcd.setYzcdcs(yzcdcs);
									 pcd.setYzcdsc(Double.valueOf(yzcdsc));
									 pcd.setKgcdfzs(kgcdcs);
									 if (!pcd.insert()) {
										throw new CustomException("打卡明细-新增异常-1");
									 }
									 dkmx = pcd.getId();
									 
								 }else if(execution_status == 2){
									 dkmx = dkmc.getId();
									 KqglAssoDkmx pcd = KqglAssoDkmx.builder().build();
									 if(atttype == 2){//下班1
										 pcd.setId(dkmc.getId());
										 pcd.setXbdk1(time_);//下班1打卡时间
										 if(punchcardtime != 0){//有应打卡时间时
											 Long time = (time_ - punchcardtime)/1000/60;
											 if(time > 0){
												 pcd.setXbdk1jg(0);// 打卡结果
											 }else{
												 pcd.setXbdk1jg(Math.abs(Integer.valueOf(time.toString())));
											 }
										 }
										 if(dkmc.getSbdk1() != null){
											Long time = (time_ - dkmc.getSbdk1())/1000/60 - rest_time;
											pcd.setGzsc(Math.abs(Double.valueOf(time.toString())));//只打一次卡时计算工作时长
										 }
										 kqglassodkmxmapper.updateByPrimaryKeySelective(pcd);//修改打卡记录
										 
								     }else if(atttype == 3){//上班2
								    	 
								    	 int sbdk2jg = 0,yzcdsc = 0,yzcdcs = 0,kgcdcs = 0;
										 if(punchcardtime != 0){//有应打卡时间时
											 Long time = (time_ - punchcardtime)/1000/60;
											 if(time > 0){sbdk2jg = Math.abs(Integer.valueOf(time.toString()));}
										 }
										 if(sbdk2jg > yzcd&& yzcd>0) {
											 yzcdcs = dkmc.getYzcdcs()+1;
											 yzcdsc = sbdk2jg - yzcd;
										 }
										 if(sbdk2jg > kgcdfzs&& kgcdfzs>0) {kgcdcs++;}
										 
										 pcd.setId(dkmc.getId());
								    	 pcd.setSbdk2(time_);//上班1打卡时间
										 pcd.setSbdk2jg(sbdk2jg);
										 pcd.setYzcdcs(yzcdcs);
										 pcd.setYzcdsc(Double.valueOf(yzcdsc));
										 pcd.setKgcdfzs(kgcdcs);
										 kqglassodkmxmapper.updateByPrimaryKeySelective(pcd);//修改打卡记录
								     }else if(atttype == 4){//下班2
										 pcd.setId(dkmc.getId());
								    	 pcd.setXbdk2(time_);//下班1打卡时间
										 if(punchcardtime != 0){//有应打卡时间时
											 Long time = (time_ - punchcardtime)/1000/60;
											 if(time > 0){
												 pcd.setXbdk2jg(0);// 打卡结果
											 }else{
												 pcd.setXbdk2jg(Math.abs(Integer.valueOf(time.toString())));
											 }
										 }
										//班次为4次时，计算工作时长
										 if(dkmc.getSbdk2() != null){
											 Long time = (time_ - dkmc.getSbdk2())/1000/60;
											 BigDecimal om = new BigDecimal(dkmc.getGzsc());
											 BigDecimal on = new BigDecimal(time);
											 BigDecimal worktime_ = new BigDecimal(Math.abs(om.add(on).doubleValue()));
											 
											 BigDecimal xx = new BigDecimal(rest_time);
											 
											 double worktime = Math.abs(worktime_.subtract(xx).doubleValue());
											 
											 pcd.setGzsc(worktime);
										 }
										 kqglassodkmxmapper.updateByPrimaryKeySelective(pcd);//修改打卡记录
								     }else if(atttype == 5){//上班3
								    	 int sbdk3jg = 0,yzcdsc = 0,yzcdcs = 0,kgcdcs = 0;
										 if(punchcardtime != 0){//有应打卡时间时
											 Long time = (time_ - punchcardtime)/1000/60;
											 if(time > 0){sbdk3jg = Math.abs(Integer.valueOf(time.toString()));}
										 }
										 if(sbdk3jg > yzcd&& yzcd>0) {
											 yzcdcs = dkmc.getYzcdcs()+1;
											 yzcdsc = sbdk3jg - yzcd;
										 }
										 if(sbdk3jg > kgcdfzs&& kgcdfzs>0) {kgcdcs++;}
										 pcd.setId(dkmc.getId());
								    	 pcd.setSbdk3(time_);//上班1打卡时间
										 pcd.setSbdk3jg(sbdk3jg);
										 pcd.setYzcdcs(yzcdcs);
										 pcd.setYzcdsc(Double.valueOf(yzcdsc));
										 pcd.setKgcdfzs(kgcdcs);
										 kqglassodkmxmapper.updateByPrimaryKeySelective(pcd);//修改打卡记录
								     }else if(atttype == 6){//下班3
										 pcd.setId(dkmc.getId());
								    	 pcd.setXbdk3(time_);//下班1打卡时间
										 if(punchcardtime != 0){//有应打卡时间时
											 Long time = (time_ - punchcardtime)/1000/60;
											 if(time > 0){
												 pcd.setXbdk3jg(0);// 打卡结果
											 }else{
												 pcd.setXbdk3jg(Math.abs(Integer.valueOf(time.toString())));
											 }
										 }
										//班次为6次时，计算工作时长
										 if(dkmc.getSbdk3() != null){
											 Long time = (time_ - dkmc.getSbdk3())/1000/60;
											 BigDecimal om = new BigDecimal(dkmc.getGzsc());//第二次
											 BigDecimal on = new BigDecimal(time);
											 BigDecimal worktime_ = new BigDecimal(Math.abs(om.add(on).doubleValue()));
											 
											 BigDecimal xx = new BigDecimal(rest_time);
											 
											 double worktime = Math.abs(worktime_.subtract(xx).doubleValue());
											 
											 pcd.setGzsc(worktime);
										 }
								     }
									 pcd.setId(dkmc.getId());
									 if(atttype <= 6 && atttype > 0 && !sbdkkd){
										 kqglassodkmxmapper.updateByPrimaryKeySelective(pcd);//修改打卡记录
									 }
								 }
							 }else {
								 msg = "当前打卡时间不在范围内";
								 sbyf = 0;
							 }
						}else {
						  msg = "当前是休息时间";
						  sbyf = 0;
						}
					}
				 }else {
					 
					//需要再次调整********************
					 
					//自由工时打卡
					Long stapclotime = attdate.getStapclotime();// 今天考勤 自由排班开始时间
					int canpunchworkdate = Integer.valueOf(String.valueOf(attdate.getCanpunchworkdate()).replaceAll("(\\d+)(?:(\\.\\d*[^0])|\\.)0*", "$1$2"));// 上班打卡后多久大下班卡
					KqglAssoDkmx zydkmc = KqglAssoDkmx.builder().build();
					Date sd1=df1.parse(ClockInTool.stampToDate(String.valueOf(stapclotime)));//应打卡时间   2020-06-10 18:30:00
					Date sd2=df1.parse(current_time);//当前时间  2020-06-10 16:06:58
					if(sd1.after(sd2)) {//为true时  打的是昨天的卡
						zydkmc = KqglAssoDkmx.builder().build().selectOne(new QueryWrapper<KqglAssoDkmx>().lambda().eq(KqglAssoDkmx::getUserid, userid)
								.ge(KqglAssoDkmx::getDksj, startDateyesterday).le(KqglAssoDkmx::getDksj, endDateyesterday));
						attendance_date = startDateyesterday;
						toweek = yesterday;
					}else {
						zydkmc = KqglAssoDkmx.builder().build().selectOne(new QueryWrapper<KqglAssoDkmx>().lambda().eq(KqglAssoDkmx::getUserid, userid)
								.ge(KqglAssoDkmx::getDksj, startDate).le(KqglAssoDkmx::getDksj, endDate));
						attendance_date = startDate;
						toweek = putime;
					}  
					if(zydkmc == null) {//新增
						KqglAssoDkmx pcd  = KqglAssoDkmx.builder().build();
						if(sd1.after(sd2)) {
							pcd = KqglAssoDkmx.builder().userid(userid).data(yesterday).sbdk1(time_).sbdk1jg(0).ydkcs(0).qyid(qyid).dksj(startDateyesterday).yzcdcs(0).yzcdsc(Double.valueOf(0)).kgcdfzs(0).build();
						}else {
							pcd = KqglAssoDkmx.builder().userid(userid).data(putime).sbdk1(time_).sbdk1jg(0).ydkcs(0).qyid(qyid).dksj(startDate).yzcdcs(0).yzcdsc(Double.valueOf(0)).kgcdfzs(0).build();
						}
//							KqglAssoDkmx pcd = KqglAssoDkmx.builder().userid(userid).data(putime).sbdk1(time_).sbdk1jg(0).ydkcs(0).qyid(qyid).dksj(startDate).yzcdcs(0).yzcdsc(Double.valueOf(0)).kgcdfzs(0).build();
						 if (!pcd.insert()) {
							throw new CustomException("打卡明细-新增异常-1");
						 }
						 dkmx = pcd.getId();
						 atttype = 1;
					}else {//修改	
						boolean zydk = true;
						dkmx = zydkmc.getId();
						KqglAssoDkmx zypcd = KqglAssoDkmx.builder().build();
						if((!("").equals(zydkmc.getSbdk1()) || zydkmc.getSbdk1() != null) && (("").equals(zydkmc.getXbdk1()) || zydkmc.getXbdk1() == null)){//下班1
							String clock_time = ClockInTool.requires_extra_times(ClockInTool.stampToDate(String.valueOf(zydkmc.getSbdk1())),canpunchworkdate,5,2);
							Date zysd1=df1.parse(clock_time);//上班打卡后多久大下班卡的时间
							Date zysd2=df1.parse(current_time);//当前时间  
							if(zysd1.after(zysd2)) {//当zysd1大于zysd2时，返回TRUE，当小于等于时，返回false； 
								msg = "自由工时：上班打卡后"+canpunchworkdate+"小时后，才可打下班卡";
								sbyf = 0;
								zydk = false;
								atttype = 0;
							}else {
								zypcd.setId(zydkmc.getId());
								zypcd.setXbdk1(time_);//下班1打卡时间
								if(zydkmc.getSbdk1() != null){
									Long time = (time_ - zydkmc.getSbdk1())/1000/60;
									zypcd.setGzsc(Math.abs(Double.valueOf(time.toString())));//只打一次卡时计算工作时长
								 }
								kqglassodkmxmapper.updateByPrimaryKeySelective(zypcd);//修改打卡记录
							}
							if(zydk) {
								atttype = 2;
							}
							
						}else if((!("").equals(zydkmc.getSbdk1()) || zydkmc.getSbdk1() != null) && (!("").equals(zydkmc.getXbdk1()) || zydkmc.getXbdk1() != null)
					    		 && (("").equals(zydkmc.getSbdk2()) || zydkmc.getSbdk2() == null)){//上班2
							zypcd.setId(zydkmc.getId());
							zypcd.setSbdk2(time_);//上班1打卡时间
							kqglassodkmxmapper.updateByPrimaryKeySelective(zypcd);//修改打卡记录
							atttype = 3;
						}else if((!("").equals(zydkmc.getSbdk1()) || zydkmc.getSbdk1() != null) && (!("").equals(zydkmc.getXbdk1()) || zydkmc.getXbdk1() != null)
					    		 && (!("").equals(zydkmc.getSbdk2()) || zydkmc.getSbdk2() != null) && (("").equals(zydkmc.getXbdk2()) || zydkmc.getXbdk2() == null)){//下班2
							String clock_time = ClockInTool.requires_extra_times(ClockInTool.stampToDate(String.valueOf(zydkmc.getSbdk2())),canpunchworkdate,5,2);
							Date zysd1=df1.parse(clock_time);//上班打卡后多久大下班卡的时间
							Date zysd2=df1.parse(current_time);//当前时间  
							if(zysd1.after(zysd2)) {//当zysd1大于zysd2时，返回TRUE，当小于等于时，返回false； 
								msg = "自由工时：上班打卡后"+canpunchworkdate+"小时后，才可打下班卡";
								sbyf = 0;
								zydk = false;
								atttype = 0;
							}else {
								zypcd.setId(zydkmc.getId());
								zypcd.setXbdk2(time_);//下班1打卡时间
								//班次为4次时，计算工作时长
								 if(zydkmc.getSbdk2() != null){
									 Long time = (time_ - zydkmc.getSbdk2())/1000/60;
									 BigDecimal om = new BigDecimal(zydkmc.getGzsc());
									 BigDecimal on = new BigDecimal(time);
									 double worktime = Math.abs(om.add(on).doubleValue());
									 zypcd.setGzsc(worktime);
								 }
								 kqglassodkmxmapper.updateByPrimaryKeySelective(zypcd);//修改打卡记录
							}
							if(zydk) {
							 atttype = 4;
							}
						}else if((!("").equals(zydkmc.getSbdk1()) || zydkmc.getSbdk1() != null) && (!("").equals(zydkmc.getXbdk1()) || zydkmc.getXbdk1() != null)
					    		 && (!("").equals(zydkmc.getSbdk2()) || zydkmc.getSbdk2() != null) && (!("").equals(zydkmc.getXbdk2()) || zydkmc.getXbdk2() != null)
					    		 && (("").equals(zydkmc.getSbdk3()) || zydkmc.getSbdk3() == null)){//上班3
							zypcd.setId(zydkmc.getId());
							zypcd.setSbdk3(time_);//上班1打卡时间
							kqglassodkmxmapper.updateByPrimaryKeySelective(zypcd);//修改打卡记录
							atttype = 5;
						}else if((!("").equals(zydkmc.getSbdk1()) || zydkmc.getSbdk1() != null) && (!("").equals(zydkmc.getXbdk1()) || zydkmc.getXbdk1() != null)
					    		 && (!("").equals(zydkmc.getSbdk2()) || zydkmc.getSbdk2() != null) && (!("").equals(zydkmc.getXbdk2()) || zydkmc.getXbdk2() != null)
					    		 && (!("").equals(zydkmc.getSbdk3()) || zydkmc.getSbdk3() != null) && (("").equals(zydkmc.getXbdk3()) || zydkmc.getXbdk3() == null)){//下班3
							String clock_time = ClockInTool.requires_extra_times(ClockInTool.stampToDate(String.valueOf(zydkmc.getSbdk3())),canpunchworkdate,5,2);
							Date zysd1=df1.parse(clock_time);//上班打卡后多久大下班卡的时间
							Date zysd2=df1.parse(current_time);//当前时间  
							if(zysd1.after(zysd2)) {//当zysd1大于zysd2时，返回TRUE，当小于等于时，返回false； 
								msg = "自由工时：上班打卡后"+canpunchworkdate+"小时后，才可打下班卡";
								sbyf = 0;
								zydk = false;
								atttype = 0;
							}else {
								zypcd.setId(zydkmc.getId());
								zypcd.setXbdk3(time_);//下班1打卡时间
								//班次为6次时，计算工作时长
								 if(zydkmc.getSbdk3() != null){
									 Long time = (time_ - zydkmc.getSbdk3())/1000/60;
									 BigDecimal om = new BigDecimal(zydkmc.getGzsc());//第二次
									 BigDecimal on = new BigDecimal(time);
									 double worktime = Math.abs(om.add(on).doubleValue());
									 zypcd.setGzsc(worktime);
								 }
								 kqglassodkmxmapper.updateByPrimaryKeySelective(zypcd);//修改打卡记录
							}
							if(zydk) {
							 atttype = 6;
							}
						}else {
							atttype = 7;
						}
					}
				 }
				 
 /*****************************************************************************************************************************************************************************************************/
 /*******************************************************************APP 原始打卡记录数据录入**************************************************************************************************************/
 /*****************************************************************************************************************************************************************************************************/
				 
				 String attdate_ = new SimpleDateFormat("yy-MM-dd").format(Double.valueOf(attendance_date));//转换打卡时间格式
					
				//true：确认为最后一次打卡更新打卡时  之前打卡的一条数据变为“打卡更新数据”
				if(kskd && (atttype == 2 || atttype == 4 || atttype == 6) && attdate.getAttgrouptype() != 3) {
					KqglAssoDkjl dkjj = KqglAssoDkjl.builder().build().selectOne(new QueryWrapper<KqglAssoDkjl>().lambda().eq(KqglAssoDkjl::getUserId, userid).eq(KqglAssoDkjl::getType, 2)
							.eq(KqglAssoDkjl::getSort, atttype).eq(KqglAssoDkjl::getQyid, qyid).eq(KqglAssoDkjl::getAttdate, attdate_+" "+ClockInTool.dateToWeek2(toweek)));
					
					KqglAssoDkjl.builder().id(dkjj.getId()).status(0).sort(0).build().updateById();
					msg = "打卡已更新数据";
					sbyf = 0;
				}
				
				int results = 0;
				Long time = (time_ - punchcardtime)/1000/60;
				if(punchcardtime != 0){
					if(isRange) {
						if((atttype)%2 > 0){//上班
							if(time > 0){
								results = Integer.valueOf(time.toString());
							}// 打卡结果
						}else{//下班
							if(time > 0){}else{
								results = Math.abs(Integer.valueOf(time.toString()));
							}// 打卡结果
						}
					}
				}
				int type = 0,status = 0;
				if(atttype > 0) {
					if((atttype)%2 > 0){
						type = 1;// 类型(类型 0:无排班打卡 1：上班 2：下班)   punchcardtime == 0：无班次打卡
						if(attdate.getAttgrouptype() != 3) {
							if(EmptyUtil.isNotEmpty(attdate.getAttsch())) {
								if(punchcardtime == 0 && clockt.getShifid() != 0){
									status = 1;
								}if(punchcardtime == 0 && clockt.getShifid() == 0) {
									status = 2;
								}else{
									if(isRange) {// 状态（0：打卡无效:此记录已被更新 1：正常 2：异常 3：迟到 4：早退 5：补卡 6：请假 7：加班 8：调休）
										if(time > 0){
											status = 3;
										}else if(results == 0){
											status = 1;
										}
									}else {
										status = 2;
									}
								}
							}else if(EmptyUtil.isEmpty(attdate.getAttsch())) {
								status = 2;
							}
						}else {
							if(sbyf == 1) {
								status = 1;
							}else {
								status = 2;
							}
						}
					}else{
						type = 2;// 类型(类型 0:无排班打卡 1：上班 2：下班)
						if(attdate.getAttgrouptype() != 3) {
							if(EmptyUtil.isNotEmpty(attdate.getAttsch())) {
								if(punchcardtime == 0 && clockt.getShifid() != 0){
									status = 1;
								}if(punchcardtime == 0 && clockt.getShifid() == 0) {
									status = 2;
								}else{
									if(isRange) {
										if(time < 0){
											status = 4;
										}else if(results == 0){
											status = 1;
										}
									}else {
										status = 2;
									}
								}
							}else if(EmptyUtil.isEmpty(attdate.getAttsch())) {
								status = 2;
							}
						}else {
							if(sbyf == 1) {
								status = 1;
							}else {
								status = 2;
							}
						}
					}
				}
				
				//第二次未超过应上班打卡时间 打卡为无效
				if(sbdkkd) {
					sbyf = 0;
					status = 2;
					atttype = 0;
					msg = "已有最优的打卡记录存在";
				}
				
				long attime;
				if(punchcardtime == 0){// 考勤时间(应打卡时间)
					attime = new Date().getTime();
				}else{
					attime = punchcardtime;
				}
				
				String remarks = "";//考勤备注
				String punchequipment = "";//打卡设备
				
				String commentary = "未知";
				if(sbyf == 1) {
					commentary = "打卡成功";
					msg = "打卡成功";
				}else {
					commentary = msg;
				}
				
				
				KqglAssoDkjl pre = KqglAssoDkjl.builder().dktime(time_).results(results).userId(userid).type(type).status(status).sort(atttype)
						.qyid(qyid).attdate(attdate_+" "+ClockInTool.dateToWeek2(toweek)).attime(attime).dkmxid(dkmx).bcid(shifid).remarks(remarks)
						.punchequipment(punchequipment).commentary(commentary).build();
				//cardtype--1：GPS，2：WIFI，3：考勤机，4：外勤
				int cardtype = 0;
				if(clock.getPunchcardtype() == 1 || clock.getPunchcardtype() == 4) {
					pre.setAddress(clock.getAddress());
					pre.setLat(Double.valueOf(clock.getLat()));
					pre.setLon(Double.valueOf(clock.getLon()));
				}else if(clock.getPunchcardtype() == 2) {
					pre.setMacname(clock.getMacname());
					pre.setMac(clock.getMac());
				}
				pre.setCardType(clock.getPunchcardtype());
				
				if (!pre.insert()) {
					throw new CustomException("打卡记录-新增异常-2");
				 }
				
			 }else {
				msg="打卡失败！，未加入考勤组！";
				sbyf = 0;
			 }
		 }else {
			 return ResultUtil.error("打卡失败！，用户不存在！");
		 }
//		 if(sbyf == 1) {
//			return  ResultUtil.data("打卡成功");
//		 }else {
//			return  ResultUtil.data(msg, "打卡失败"); 
//		 }
		 return ResultUtil.success(msg);
	 }
	 
	 //****************************************************&&*******&&&******&&&****************************************************//
	 //***************************************************&**&******&***&****&***&**************************************************//
	 //**************************************************&&&&&&*****&&&******&&&****************************************************//
	 //*************************************************&******&****&********&******************************************************//
	//考勤组绑定的打卡方式
	@Autowired
	private AttGroupBinPunchModeMapper attgroupbinpunchmodemapper;
	//考勤机
	@Autowired
	private AttendanceMachineMapper attendancemachinemapper;
	//考勤地址
	@Autowired
	private PunchCardAddressMapper punchcardaddressmapper;
	//考勤WIFI
	@Autowired
	private PunchCardWiFiMapper punchcardwifimapper;
	/**
	 * 	获取考勤打卡数据------APP打卡
	 * @throws ParseException 
	 */
	 @PostMapping(value = "/ClockData")
	 @ApiOperation(value = "获取考勤打卡数据------APP打卡", httpMethod = "POST", notes = "接口发布说明")
	 @ApiOperationSupport(order = 3)
	 public Result<Object> getAttClockData(@CurrentUser UserBean userBean,@RequestBody AttConditions attconditions) throws ParseException {
		 
		 long nowdate = new Date().getTime();
		 
		 String str = null;
		 if(!("").equals(attconditions.getDate())){
			 str = attconditions.getDate();
		 }else{
			 Date d = new Date();
			 SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
			 str = sdf.format(d);
		 }
		 
		 //前一天时间
		 String yesterday = ClockInTool.requires_extra_times(str,-1,3,1);//前一天
		 Long startDateyesterday = DateUtil.getStartTime(0,DateUtil.getStringTime(yesterday,"yyyy-MM-dd")).getTime();
		 Long endDateyesterday = DateUtil.getnowEndTime(23,DateUtil.getStringTime(yesterday,"yyyy-MM-dd")).getTime();
		 
		 Long startDate = DateUtil.getStartTime(0,DateUtil.getStringTime(str,"yyyy-MM-dd")).getTime();
	     Long endDate = DateUtil.getnowEndTime(23,DateUtil.getStringTime(str,"yyyy-MM-dd")).getTime();
		 
	     String stampToDate = ClockInTool.stampToDate(String.valueOf(endDate));//当天打卡的最后时间
		 Timestamp d = Timestamp.valueOf(stampToDate);
		 
		 Timestamp b = Timestamp.valueOf(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()));//当前时间
		 
		 String now = new SimpleDateFormat("yyyy-MM-dd").format(new Date());
		 
		 KqglMainKqz attgro = kqglmainkqzmapper.getAttendanceGroupInformationByUserid(userBean.getEmpNum(),userBean.getOrgCode()); //考勤组信息
		 
		 if(attgro != null) {
			 //APP获取当前天的考勤信息
			 AttendanceCardListDto attdate = MethodCall(userBean.getOrgCode(),userBean.getEmpNum(),attconditions.getDate());
			 //打卡记录
//		     List<KqglAssoDkjl> dajllist = kqglassodkjlmapper.getDetailedRecordClock(startDate,endDate,userBean.getEmpNum());
//		     attdate.setAttpr(dajllist);
			 int dkcs = 0;
			 int isxbdk = 0;
			 List<KqglAssoDkjl> dajllist_ = kqglassodkjlmapper.getDetailedRecordClock(startDate,endDate,userBean.getEmpNum());
			 
			 if(dajllist_.size() > 0) {
				 dkcs = dajllist_.size();
				 isxbdk = dajllist_.get(dajllist_.size()-1).getSort();
			 }
			 
			 if(attdate.getAttgrouptype() != 3) {
				 List<AttSchedule> attsch = attdate.getAttsch();
				 
				 if(EmptyUtil.isNotEmpty(attdate.getAttsch()) && attsch.get(0).getId() != 0) {//班次不为空
					 /******次日开始*****/
					 int sb1 = 0,xb1 = 0,sb2 = 0,xb2 = 0,sb3 = 0,xb3 = 0;
					 //先判断前一天是否存在次日打卡的方式
					 KqglAssoBcsz jianchashif = KqglAssoBcsz.builder().build().selectOne(new QueryWrapper<KqglAssoBcsz>().lambda().eq(KqglAssoBcsz::getId, attsch.get(0).getId()));
					 if(jianchashif.getIsSbdk1Cr() == 1) { sb1 = 1; }
					 if(jianchashif.getIsXbdk1Cr() == 1) { xb1 = 1; }
					 if(jianchashif.getIsSbdk2Cr() == 1) { sb2 = 1; }
					 if(jianchashif.getIsXbdk2Cr() == 1) { xb2 = 1; }
					 if(jianchashif.getIsSbdk3Cr() == 1) { sb3 = 1; }
					 if(jianchashif.getIsXbdk3Cr() == 1) { xb3 = 1; }
					 //
					 if(sb1 == 1 ||xb1 == 1 || sb2 == 1 ||xb2 == 1 || sb3 == 1 ||xb3 == 1) {
						 //前一天的班次
						 AttendanceCardListDto beforeattdate = MethodCall(userBean.getOrgCode(),userBean.getEmpNum(),yesterday);
						 //前一天的打卡数据
						 List<KqglAssoDkjl> dajllistbefo = kqglassodkjlmapper.getDetailedRecordClock(startDateyesterday,endDateyesterday,userBean.getEmpNum());
						 
						 List<AttSchedule> beforeattsch = beforeattdate.getAttsch();
						 
						 int p = 0;
						 for(AttSchedule befo : beforeattsch) {
							 if(befo.getNextday() == 1) {
								 AttSchedule attschbefo = AttSchedule.builder().build();
								 BeanUtil.copyProperties(befo, attschbefo,"nextdaycard","dajl");
								 attschbefo.setNextday(2);//昨日
								 KqglAssoDkjl dkjlbefo = KqglAssoDkjl.builder().build();
								 for(KqglAssoDkjl ka : dajllistbefo) {
									 if(befo.getId() == ka.getBcid() && befo.getSort() == ka.getSort()) {//班次id和打卡顺序对应
										 BeanUtil.copyProperties(ka, dkjlbefo,"attdate","remarks","userId","attime","dkmxid","commentary","punchequipment","punchmode");
									 }
								 }
								 attschbefo.setDajl(dkjlbefo);
								 attsch.add(p,attschbefo);
								 p++;
							 }
						 }
					 }
					 /******次日结束*****/
					 
					 int bccs = attdate.getAttsch().size();
					 int r = 1,bc = 0;
					 int bsz = 0;
					 for(AttSchedule ash : attsch) {
						 if(ash.getNextdaycard() == 0) {
							 if(attdate.getAttsch().size() == 2) {
								 //有范围
								 if(ash.getStarttime() != 0 && ash.getEndtime() != 0) {
									 boolean ectivedate = ClockInTool.hourMinuteBetween(new SimpleDateFormat("yyyy-MM-dd HH:mm").format(nowdate), new SimpleDateFormat("yyyy-MM-dd HH:mm").format(ash.getStarttime()), new SimpleDateFormat("yyyy-MM-dd HH:mm").format(ash.getEndtime()),"yyyy-MM-dd HH:mm");
									 
									 String timme = ClockInTool.stampToDate2(String.valueOf(ash.getTime()));
									 
									 if(r == 1) {
										 if(ectivedate) {
											 bsz = 1;
											 ash.setIsdk(0);
										 }else {
											 bc++;
											 ash.setIsdk(1);
											 
											 
											 if(!now.equals(timme)) {//小于
												 ash.setIsupdate(0);
											 }else {
												 
												 ash.setIsupdate(1);
											 }
										 }
									 }
									 
									 if(r == 2) {
										 if(ectivedate) {
											 bsz = 1;
											 ash.setIsdk(0);
										 }else {
											 bc++;
											 ash.setIsdk(1);
											 
											 if(!now.equals(timme)) {//小于
												 ash.setIsupdate(0);
											 }else {
												 if(isxbdk == 2) {
													 ash.setIsupdate(1);
												 }
												 
											 }
										 }
									 }
									 r++;
									 
									 //是否请假
							        KqglAssoRelationSummary leainv = kqglassorelationsummarymapper.leaveinvesti(userBean.getEmpNum(), 2, str,userBean.getOrgCode());
									boolean adopt = false;
									if(leainv != null) {
										String time = ClockInTool.stampToDate4(String.valueOf(ash.getTime()));//当天打卡的最后时间
										adopt = ClockInTool.hourMinuteBetween(time, leainv.getStartTime().substring(0, 16), leainv.getEndTime().substring(0, 16),"yyyy-MM-dd HH:mm");
									}
									if(adopt) {
										ash.setIsleave(1);
									}
								 }else {
									 KqglAssoBcsz shif = KqglAssoBcsz.builder().build().selectOne(new QueryWrapper<KqglAssoBcsz>().lambda().eq(KqglAssoBcsz::getId, ash.getId()));
									 String xbdk1 = (str+" "+shif.getXbdk1()+":00").replaceAll("\r|\n", "");
									 Timestamp a = Timestamp.valueOf(xbdk1);
									 String sbdk1 = (str+" "+shif.getSbdk1()+":00").replaceAll("\r|\n", "");
							         Timestamp c = Timestamp.valueOf(sbdk1);
									 
									 if(r == 1) {
								         if (b.after(a) && b.after(c)) {//  当前时间大于下班打卡时间
								        	 bc++;
								        	 ash.setIsdk(1);
								        	 if(b.before(d)) {
								        		 ash.setIsupdate(1);
								        	 }
								         }else {
								        	 bsz = 1;
								         }
									 }
									 if(r == 2) {
										 if(b.after(a) && b.after(c) && b.before(d)) {
											 bsz = 1;
											 ash.setIsdk(0);
										 }else {
											 bc++;
											 ash.setIsdk(1);
										 }
									 }
									 r++;
									 
									 //是否请假
							        KqglAssoRelationSummary leainv = kqglassorelationsummarymapper.leaveinvesti(userBean.getEmpNum(), 2, str,userBean.getOrgCode());
									boolean adopt = false;
									if(leainv != null) {
										String time = ClockInTool.stampToDate4(String.valueOf(ash.getTime()));//当天打卡的最后时间
										adopt = ClockInTool.hourMinuteBetween(time, leainv.getStartTime().substring(0, 16), leainv.getEndTime().substring(0, 16),"yyyy-MM-dd HH:mm");
									}
									if(adopt) {
										ash.setIsleave(1);
									}
								 }
							 }else {
								 boolean ectivedate = ClockInTool.hourMinuteBetween(new SimpleDateFormat("yyyy-MM-dd HH:mm").format(nowdate), new SimpleDateFormat("yyyy-MM-dd HH:mm").format(ash.getStarttime()), new SimpleDateFormat("yyyy-MM-dd HH:mm").format(ash.getEndtime()),"yyyy-MM-dd HH:mm");
								 if(ectivedate) {
									 bsz = 1;
									 ash.setIsdk(0);
								 }else {
									 bc++;
									 ash.setIsdk(1);
								 }
								 
								//是否请假
						        KqglAssoRelationSummary leainv = kqglassorelationsummarymapper.leaveinvesti(userBean.getEmpNum(), 2, str,userBean.getOrgCode());
								boolean adopt = false;
								if(leainv != null) {
									String time = ClockInTool.stampToDate4(String.valueOf(ash.getTime()));//当天打卡的最后时间
									adopt = ClockInTool.hourMinuteBetween(time, leainv.getStartTime().substring(0, 16), leainv.getEndTime().substring(0, 16),"yyyy-MM-dd HH:mm");
								}
								if(adopt) {
									ash.setIsleave(1);
								}
							 }
							 
							 ////
	//						 List<KqglAssoDkjl> dajllist_ = kqglassodkjlmapper.getDetailedRecordClock(startDate,endDate,userBean.getEmpNum());
	//						 dkcs = dajllist_.size();
							 KqglAssoDkjl dkjl = KqglAssoDkjl.builder().build();
							 for(KqglAssoDkjl daj : dajllist_) {
								 if(ash.getId() == daj.getBcid() && ash.getSort() == daj.getSort()) {//班次id和打卡顺序对应
									 BeanUtil.copyProperties(daj, dkjl,"attdate","remarks","userId","attime","dkmxid","commentary","punchequipment","punchmode");
									 int bcid = dkjl.getBcid();
									 int results = dkjl.getResults();
									 KqglAssoBcsz bcsz = KqglAssoBcsz.builder().build().selectOne(new QueryWrapper<KqglAssoBcsz>().lambda().eq(KqglAssoBcsz::getId, bcid));
									 if(bcsz != null) {
										 int yxcdfzs = bcsz.getYxcdfzs();//允许迟到分钟数
										 int yzcdfzs = bcsz.getYzcdfzs();//严重迟到分钟数
										 int kgcdfzs = bcsz.getKgcdfzs();//旷工迟到分钟数
										 //允许迟到范围
										 if(results < yxcdfzs) {
											 dkjl.setResults(0);
											 if(dkjl.getStatus() == 3) {//原本是迟到的  但是在“允许迟到”范围内  则更改为正常
												 dkjl.setStatus(1);
											 }
										 }
										 //严重迟到范围
										 if(results>yzcdfzs && results < kgcdfzs && yzcdfzs>0) {
											 dkjl.setStatus(15);//严重迟到
										 }
										 //旷工迟到
										 if(results>kgcdfzs && kgcdfzs>0) {
											 dkjl.setStatus(16);//旷工迟到
										 }
									 }
									 
									 if(bsz == 1) {
										 bc++;
										 ash.setIsdk(1);
									 }else {
										 ash.setIsdk(1);
									 }
								 }
							 }
							 
							 KqglAssoBcsz shif = KqglAssoBcsz.builder().build().selectOne(new QueryWrapper<KqglAssoBcsz>().lambda().eq(KqglAssoBcsz::getId, ash.getId()));
							 Timestamp tt = Timestamp.valueOf(ClockInTool.stampToDate(String.valueOf(ash.getTime())));
							 //处理下班不用打卡的数据
							 if(shif.getIsXbdk() == 1 && (ash.getSort())%2 == 0) { 
								 
								 if(dkjl.getDktime() == null && b.after(tt)) {
									 dkjl.setDktime(ash.getTime());
									 dkjl.setStatus(1);
									 dkjl.setSort(ash.getSort());
									 dkjl.setId(999);
								 }else if(dkjl.getDktime() != null){
									 dkjl.setStatus(1);
								 }
							 }
							 //处理当天完全没打卡的数据
							 if(ash.getIsdk() == 1 && b.after(tt) && dkcs == 0) {
								 dkjl.setDktime(null);
								 dkjl.setStatus(17);//缺卡
								 dkjl.setSort(ash.getSort());
								 dkjl.setId(888);
								 //更新打卡关闭
								 ash.setIsupdate(0);
							 }
							 
							 //
							 if(ash.getIsdk() == 1 && b.after(tt) && dkjl.getDktime() == null && dkjl.getId() == null && dkcs > 0) {
								 dkjl.setStatus(17);//缺卡
								 dkjl.setSort(ash.getSort());
								 dkjl.setId(888);
								 //更新打卡关闭
								 ash.setIsupdate(0);
							 }
							 
							 /****/
								//事务(请假，加班，调休，出差)
		 		    			KqglAssoRelationSummary asssum1 = KqglAssoRelationSummary.builder().build().selectOne(new QueryWrapper<KqglAssoRelationSummary>().lambda().eq(KqglAssoRelationSummary::getUserId, userBean.getEmpNum())
				    						.eq(KqglAssoRelationSummary::getAppTime, str).last("LIMIT 1"));
				    				if(asssum1 != null) {
				    					
				    					//0:无；1：事假；2：调休；3：病假；4：年假；5：产假；6：陪产假；7：婚假；8：例假；9：丧假；10：哺乳假；11：加班；12：出差；13：外出
				    					if(asssum1.getApprovalType() == 1) {
				    						dkjl.setCalendar_status_type(11);
				    						
				    						ash.setCalendar_status_type(11);
				    					}else if(asssum1.getApprovalType() == 2) {
				    						//请假
				    						KqglAssoLeaveRules rul = KqglAssoLeaveRules.builder().build().selectOne(new QueryWrapper<KqglAssoLeaveRules>().lambda().eq(KqglAssoLeaveRules::getId,asssum1.getLeaveTypeId()));
				    						if(rul.getRulesType() == 1) {
				    							dkjl.setCalendar_status_type(1);
				    							
				    							ash.setCalendar_status_type(1);
				    						}else if(rul.getRulesType() == 2) {
				    							dkjl.setCalendar_status_type(2);
				    							
				    							ash.setCalendar_status_type(2);
				    						}else if(rul.getRulesType() == 3) {
				    							dkjl.setCalendar_status_type(3);
				    							
				    							ash.setCalendar_status_type(3);
				    						}else if(rul.getRulesType() == 4) {
				    							dkjl.setCalendar_status_type(4);
				    							
				    							ash.setCalendar_status_type(4);
				    						}else if(rul.getRulesType() == 5) {
				    							dkjl.setCalendar_status_type(5);
				    							
				    							ash.setCalendar_status_type(5);
				    						}else if(rul.getRulesType() == 6) {
				    							dkjl.setCalendar_status_type(6);
				    							
				    							ash.setCalendar_status_type(6);
				    						}else if(rul.getRulesType() == 7) {
				    							dkjl.setCalendar_status_type(7);
				    							
				    							ash.setCalendar_status_type(7);
				    						}else if(rul.getRulesType() == 8) {
				    							dkjl.setCalendar_status_type(8);
				    							
				    							ash.setCalendar_status_type(8);
				    						}else if(rul.getRulesType() == 9) {
				    							dkjl.setCalendar_status_type(9);
				    							
				    							ash.setCalendar_status_type(9);
				    						}else if(rul.getRulesType() == 10) {
				    							dkjl.setCalendar_status_type(10);
				    							
				    							ash.setCalendar_status_type(10);
				    						}
				    					}else if(asssum1.getApprovalType() == 3) {
				    						dkjl.setCalendar_status_type(12);
				    						
				    						ash.setCalendar_status_type(12);
				    					}else if(asssum1.getApprovalType() == 4) {
				    						dkjl.setCalendar_status_type(13);
				    						
				    						ash.setCalendar_status_type(13);
				    					}
				    				}else {
				    					dkjl.setCalendar_status_type(0);
				    					
				    					ash.setCalendar_status_type(0);
				    				}
								 /****/
							 
							 ash.setDajl(dkjl);//班次信息中插入打卡打卡 数据
						 }
					 }
					 
					 
					 boolean lcdkgb = true;
					 if(attdate.getAttsch().size() == 2 && dkcs == 2 && now.equals(str)) {
						 lcdkgb = false;
						 
						 KqglAssoDkjl dk = KqglAssoDkjl.builder().build().selectOne(new QueryWrapper<KqglAssoDkjl>().lambda().eq(KqglAssoDkjl::getQyid, userBean.getOrgCode())
								 .eq(KqglAssoDkjl::getUserId, userBean.getEmpNum()).ge(KqglAssoDkjl::getDktime, startDate).le(KqglAssoDkjl::getDktime, endDate)
								 .ne(KqglAssoDkjl::getSort, 0).ne(KqglAssoDkjl::getStatus, 2).ne(KqglAssoDkjl::getStatus, 0)
								 .orderByDesc(KqglAssoDkjl::getSort).last("LIMIT 1"));
						 
						 AttSchedule att = attsch.get(dk.getSort()-1);
						 att.setIsupdate(1);
						 
						 AttSchedule attw = attsch.get(dk.getSort()-2);
						 attw.setIsupdate(0);
					 }
					 
					 //全部为 1 时
					 if(bccs == bc && b.before(d) && lcdkgb) {
						 KqglAssoDkjl dk = KqglAssoDkjl.builder().build().selectOne(new QueryWrapper<KqglAssoDkjl>().lambda().eq(KqglAssoDkjl::getQyid, userBean.getOrgCode())
								 .eq(KqglAssoDkjl::getUserId, userBean.getEmpNum()).ge(KqglAssoDkjl::getDktime, startDate).le(KqglAssoDkjl::getDktime, endDate)
								 .ne(KqglAssoDkjl::getSort, 0).ne(KqglAssoDkjl::getStatus, 2).ne(KqglAssoDkjl::getStatus, 0)
								 .orderByDesc(KqglAssoDkjl::getSort).last("LIMIT 1"));
						 
						 if(dk != null && attdate.getAttsch().size() != dk.getSort()) {
							 AttSchedule att = attsch.get(dk.getSort());
							 att.setIsdk(0);
							 
							 AttSchedule attw = attsch.get(dk.getSort()-1);
							 attw.setIsupdate(1);
						 }else {
							 AttSchedule attc = attsch.get(0);
							 attc.setIsdk(0);
						 }
					 }
				 }else {
					 //休息的时候
					 List<AttSchedule> attsch_ = new ArrayList<AttSchedule>();
					 attdate.setAttsch(attsch_);
				 }
				 
				 
			 }else {
				 //自由工时
				 List<AttSchedule> attsch = new ArrayList<AttSchedule>();
				 
//				 List<KqglAssoDkjl> dajllist_ = kqglassodkjlmapper.getDetailedRecordClock(startDate,endDate,userBean.getEmpNum());
//				 KqglAssoDkjl dkjl = KqglAssoDkjl.builder().build();
				 
				 if(dajllist_.size() > 0) {
					 for(int i=1;i<=dajllist_.size();i++){
						 KqglAssoDkjl dkjl = KqglAssoDkjl.builder().build();
//						 for(KqglAssoDkjl ddk : dajllist_) {
							 BeanUtil.copyProperties(dajllist_.get(i-1), dkjl,"attdate","bcid","remarks","userId","attime","dkmxid","commentary","punchequipment","punchmode");
//						 }
						 AttSchedule ast = AttSchedule.builder().build();
						 ast.setId(0);
						 ast.setIsdk(1);
						 ast.setDajl(dkjl);
						 ast.setSort(i);
						 attsch.add(ast);
						 attdate.setAttsch(attsch);
					 }
					 
					 
					 KqglAssoDkjl dkjj_ = KqglAssoDkjl.builder().build();
					 AttSchedule ast_ = AttSchedule.builder().build();
					 ast_.setId(0);
					 ast_.setIsdk(0);
					 ast_.setDajl(dkjj_);
					 ast_.setSort(dajllist_.size() + 1);
					 attsch.add(ast_);
					 attdate.setAttsch(attsch);
					 
					 
				 }else {
					 KqglAssoDkjl dkjj = KqglAssoDkjl.builder().build();
					 AttSchedule ast = AttSchedule.builder().build();
					 ast.setId(0);
					 ast.setIsdk(0);
					 ast.setDajl(dkjj);
					 ast.setSort(1);
					 attsch.add(ast);
					 attdate.setAttsch(attsch);
				 }
			 }
			 
			   //外勤   true:开   false:关
			    if(attgro.getIsWq() == 1) {
			    	attdate.setFieldpersonnel(true);
			    }else {
			    	attdate.setFieldpersonnel(false);
			    }
			    
				//打卡方式
			    List<AttGroupBinPunchMode> attmetlist =  attgroupbinpunchmodemapper.selectByPrimaryByKqzId(attgro.getId());
			    for(AttGroupBinPunchMode agbp:attmetlist){
			    	//类型（1：考勤机；2：地址；3：WIFI）
			    	if(agbp.getType() == 1){
			    		attdate.setAttmachine(true);
			    	}else if(agbp.getType() == 2){
			    		attdate.setAttaddress(true);
			    	}else{
			    		attdate.setAttwifi(true);
			    	}
			    }
			    
			    //详细打卡方式
			    List<AttClockMethod> akms = new ArrayList<AttClockMethod>();
			    
			    for(AttGroupBinPunchMode abp:attmetlist){
			    	if(abp.getType() == 1){
			    		AttendanceMachine kqjs = attendancemachinemapper.selectByPrimaryKey(abp.getDkfsid()); 
			    		AttClockMethod akm = AttClockMethod.builder().build();
			    		akm.setName(kqjs.getName());// 打卡名称
			    		akm.setMac("");// wifi【wifi】
			    		akm.setAttrange(0);// 范围【地址】
			    		akm.setType(1);// 类型（1：考勤机；2：地址；3：WIFI）
			    		akm.setLongitude(0);// 经度【地址】
			    		akm.setLatitude(0);// 纬度【地址】
			    		akms.add(akm);
			    	}else if(abp.getType() == 2){
			    		PunchCardAddress kqdzs = punchcardaddressmapper.selectByPrimaryKey(abp.getDkfsid()); 
			    		AttClockMethod akm = AttClockMethod.builder().build();
			    		akm.setName(kqdzs.getName());// 打卡名称
			    		akm.setMac("");// wifi【wifi】
			    		akm.setAttrange(kqdzs.getDkfw());// 范围【地址】
			    		akm.setType(2);// 类型（1：考勤机；2：地址；3：WIFI）
			    		akm.setLongitude(kqdzs.getLon());// 经度【地址】
			    		akm.setLatitude(kqdzs.getLat());// 纬度【地址】
			    		akms.add(akm);
			    	}else{
			    		PunchCardWiFi kqwfs = punchcardwifimapper.selectByPrimaryKey(abp.getDkfsid()); 
			    		AttClockMethod akm = AttClockMethod.builder().build();
			    		akm.setName(kqwfs.getName());// 打卡名称
			    		akm.setMac(kqwfs.getMac());// wifi【wifi】
			    		akm.setAttrange(0);// 范围【地址】
			    		akm.setType(3);// 类型（1：考勤机；2：地址；3：WIFI）
			    		akm.setLongitude(0);// 经度【地址】
			    		akm.setLatitude(0);// 纬度【地址】
			    		akms.add(akm);
			    	}
			    }
			    attdate.setMachine(akms);
			    
		     
		    //当天第一次打卡 前一天晚走小时**************************************************
		     double latetime_ = 0;//前天晚走时长（分钟）
		     Long changed_time = 0l;//晚到后应打卡时间
		     
		     if(attdate.getAttgrouptype() != 3) {
		    	 List<AttSchedule> ash = attdate.getAttsch();
		    	 if(EmptyUtil.isNotEmpty(attdate.getAttsch()) && ash.get(0).getId() != 0) {
		    		 KqglAssoBcsz shif = KqglAssoBcsz.builder().build().selectOne(new QueryWrapper<KqglAssoBcsz>().lambda().eq(KqglAssoBcsz::getId, ash.get(0).getId()));
					 
				     if(shif != null) {
						int dkcs_ = shif.getSxbcs();//上下班打卡次数
						int iswzwd = shif.getIsWzwd();//是否开启晚走晚到(0：否；1：是)
						
						//统一分钟数
						double xbwz1 = 0,xbwz2=0,xbwz3=0;
						int sbwd1=0,sbwd2=0,sbwd3=0;
						
						int arrive_late = 0;//晚到时间
						String clock_date = "";//应打卡时间
						Long latetime = 0l;//前天晚走时长（分钟）
						
						KqglAssoDkmx yesterdaymx = KqglAssoDkmx.builder().build();
						AttendanceCardListDto attdateyesterday;
						long yesendtime1=0,yesendtime2=0,yesendtime3=0;
						String regex = "(\\d+)(?:(\\.\\d*[^0])|\\.)0*";
						//存在晚走玩到
						 if(iswzwd > 0) {
							//统一分钟数
							xbwz1 = Double.valueOf(shif.getXbwz1()) * 60;//下班晚走1
							
							String as = String.valueOf(Double.valueOf(shif.getSbwd1()) * 60);
							sbwd1 = Integer.valueOf(as.replaceAll(regex, "$1$2"));//上班晚到1
							
							xbwz2 = Double.valueOf(shif.getXbwz2()) * 60;//下班晚走2
							String qw = String.valueOf(Double.valueOf(shif.getSbwd2()) * 60);
							sbwd2 = Integer.valueOf(qw.replaceAll(regex, "$1$2"));//上班晚到2
							xbwz3 = Double.valueOf(shif.getXbwz3()) * 60;//下班晚走3
							
							String ed = String.valueOf(Double.valueOf(shif.getSbwd3()) * 60);
							sbwd3 = Integer.valueOf(ed.replaceAll(regex, "$1$2"));//上班晚到3
							 
							 //获取前一天最后下班的时间
							 yesterdaymx = KqglAssoDkmx.builder().build().selectOne(new QueryWrapper<KqglAssoDkmx>().lambda().eq(KqglAssoDkmx::getUserid, userBean.getEmpNum())
										.ge(KqglAssoDkmx::getDksj, startDateyesterday).le(KqglAssoDkmx::getDksj, endDateyesterday));
							 attdateyesterday = MethodCall(userBean.getOrgCode(),userBean.getEmpNum(),yesterday);
							 
							 List<AttSchedule> ashyes = attdateyesterday.getAttsch();
							 if(attdateyesterday.getAttsch().size() == 2 || attdateyesterday.getAttsch().size() == 4 || attdateyesterday.getAttsch().size() == 6) {
								 yesendtime1 = ashyes.get(1).getTime();
							 }
						 	 if(attdateyesterday.getAttsch().size() == 4 || attdateyesterday.getAttsch().size() == 6) {
						 		yesendtime2 = ashyes.get(3).getTime();
							 }
						 	 if(attdateyesterday.getAttsch().size() == 6) {
						 		yesendtime3 = ashyes.get(5).getTime();
							  }
						 	 
						 	 if(yesterdaymx != null) {
						 		 if(dkcs_ == 1) {
									 if(yesterdaymx.getXbdk1() != null && yesterdaymx.getXbdk1jg() == 0) {
										 latetime = (yesterdaymx.getXbdk1() - yesendtime1)/1000/60;
									 }
								 }else if(dkcs_ == 2){
									 if(yesterdaymx.getXbdk2() != null && yesterdaymx.getXbdk2jg() == 0) {
										 latetime = (yesterdaymx.getXbdk2() - yesendtime2)/1000/60;
									 }
								 }else {
									 if(yesterdaymx.getXbdk3() != null && yesterdaymx.getXbdk3jg() == 0) {
										 latetime = (yesterdaymx.getXbdk3() - yesendtime3)/1000/60;
									 }
								 }
						 	 }
							 
							 if(latetime != 0) {
								 latetime_ = Double.valueOf(String.valueOf(latetime));//前天晚走时长（分钟）
								 if(latetime_ > xbwz1 && latetime_ < xbwz2) {
									 arrive_late = sbwd1;
								 }else if(latetime_ > xbwz2 && latetime_ < xbwz3) {
									 arrive_late = sbwd2;
								 }else if(latetime_ > xbwz3) {
									 arrive_late = sbwd3;
								 }
								 //ash.get(0).getTime()：当天第一次应打卡时间
								 clock_date = ClockInTool.stampToDate(String.valueOf(ash.get(0).getTime()));
								 changed_time = Long.valueOf(ClockInTool.dateToStamp(ClockInTool.addtime(clock_date, "+"+arrive_late)));//晚到后应打卡时间
							 }
						 }
						 attdate.setLatetime(latetime_);
						 attdate.setChanged_time(changed_time);
				     }
		    	 }
			     
		     }
		     
			return ResultUtil.data(attdate);
		 }else {
			 
			 AttendanceCardListDto attdate_ = AttendanceCardListDto.builder().build();
			 
			 return ResultUtil.data(attdate_,"未加入考勤组");
		 }
	 }
	 
	 
	 private SimpleDateFormat mat = new SimpleDateFormat("yyyy-MM-dd");
	 
	    @Autowired
		private KqglAssoTeshuMapper kqglassoteshumapper;
	    @Autowired
		private AttendanceWeeklySchMapper attendanceweeklyschmapper;
	    @Autowired
		private ScheduleMapper schedulemapper;
	   /**
		 * 	APP 手机日历数据
		 * @param userBean
		 * @return
		 * @throws ParseException 
		 */
		@GetMapping(value = "/workbench_calendar/{date}")
		@ApiOperation(value = "手机日历数据", httpMethod = "GET", notes = "查询数据")
		public Result<Object> Workbench_calendar(@CurrentUser UserBean userBean,@PathVariable("date") String date) throws ParseException {
			SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd");//设置日期格式  
			
			String current = new SimpleDateFormat("yyyy-MM-dd").format(new Date());
			String yue = new SimpleDateFormat("yyyy-MM").format(new Date());
			
			SimpleDateFormat df1 = new SimpleDateFormat("yyyy-MM");
	        Date date_;
	        try {
	        	date_ = df1.parse(date);
	        }catch (ParseException e){
	            e.printStackTrace();
	            date_=new Date();
	        }
	        int dateOne= ClockInTool.getYearMonth(date_);
	        int dangqian = ClockInTool.getYearMonth(new Date());//当前
			
	        List<WorkbenchCalendarDto> workcal = new ArrayList<WorkbenchCalendarDto>();
	        
	        if(dateOne<=dangqian){
	        	Long startMonth = 0l;
	    		Long endMonth = 0l;
	    		if(date == null || ("").equals(date)) {
	    			Calendar c = Calendar.getInstance();    
	    	        c.add(Calendar.MONTH, 0);
	    	        c.set(Calendar.DAY_OF_MONTH,1);//设置为1号,当前日期既为本月第一天 
	    	        String first = mat.format(c.getTime());
	    	        startMonth = DateUtil.getStartTime(0,DateUtil.getStringTime(first,"yyyy-MM-dd")).getTime();
	    	        
	    	        endMonth = new Date().getTime();
	    	        
	    		}else {
	    			String time = date+"-01";
	    			String sdaet = ClockInTool.getMinMonthDate(time);
	    		    startMonth = ClockInTool.getStartTime(0,ClockInTool.getStringTime(sdaet,"yyyy-MM-dd")).getTime();
	    			String edate = ClockInTool.getMaxMonthDate(time);
	    		    endMonth = ClockInTool.getnowEndTime(23,ClockInTool.getStringTime(edate,"yyyy-MM-dd")).getTime();
	    		    
	    		    if(date.equals(yue)) {
	    		    	endMonth = new Date().getTime();
	    		    }
	    		    
	    		}
	    		
	    	    String[] rangeArray=ClockInTool.listToString(ClockInTool.getDays(df.format(startMonth),df.format(endMonth))).split(";");//目前为止所有日期
	    		String[] range=rangeArray[0].split(",");
	    		
	    		KqglMainKqz attgro = kqglmainkqzmapper.getAttendanceGroupInformationByUserid(userBean.getEmpNum(),userBean.getOrgCode()); //考勤组信息
	    		
	    	    for(String num : range) {
	    	    	Long start_time = DateUtil.getStartTime(0,DateUtil.getStringTime(num,"yyyy-MM-dd")).getTime();
	    	        Long end_time = DateUtil.getnowEndTime(23,DateUtil.getStringTime(num,"yyyy-MM-dd")).getTime();
	    	    	
	    	    	WorkbenchCalendarDto wocal = WorkbenchCalendarDto.builder().build();
	    	    	wocal.setDate(num);
	    	    	if(attgro != null) {//有无考勤组  
	    	    		AttendanceCardListDto attdate = MethodCall(userBean.getOrgCode(),userBean.getEmpNum(),num);//获取当天所打卡班次
	    	    		List<AttSchedule> ashss = attdate.getAttsch();//获取今天应打卡时间
	    	    		
	    	    		if(EmptyUtil.isNotEmpty(attdate.getAttsch()) && attdate.getAttgrouptype() != 3) {//班次不为空
	    	    			
	    	    			KqglAssoBcsz bcsts = KqglAssoBcsz.builder().build().selectOne(new QueryWrapper<KqglAssoBcsz>().lambda().eq(KqglAssoBcsz::getId, ashss.get(0).getId()));
	    	    			
	    	    			if(ashss.get(0).getId() != 0) {
	    	    				KqglAssoDkmx dkmc = KqglAssoDkmx.builder().build().selectOne(new QueryWrapper<KqglAssoDkmx>().lambda().eq(KqglAssoDkmx::getUserid, userBean.getEmpNum()).eq(KqglAssoDkmx::getQyid, userBean.getOrgCode())
	    								.ge(KqglAssoDkmx::getDksj, start_time).le(KqglAssoDkmx::getDksj, end_time));
	    		    			if(dkmc != null) {
	    		    				if(attdate.getAttsch().size() == 2 || attdate.getAttsch().size() == 4 || attdate.getAttsch().size() == 6) {
	    			    				if(dkmc.getSbdk1() != null && dkmc.getSbdk1jg() == 0 && dkmc.getXbdk1() != null && dkmc.getXbdk1jg() == 0) {
	    			    					wocal.setCalendar_status(1);//打卡正常
	    			    					wocal.setCalendar_status_type(0);
	    			    				}else {
	    			    					if(dkmc.getXbdk1() == null && attdate.getAttsch().size() == 2) {
	    			    						if(bcsts.getIsXbdk()==1) {//下班不用打卡
	    			    							wocal.setCalendar_status(1);//打卡正常
	    			    							wocal.setCalendar_status_type(0);
	    			    						}else {
	    			    							wocal.setCalendar_status(3);//打卡异常
	    			    							wocal.setCalendar_status_type(0);
	    			    						}
	    			    					}else {
	    			    						wocal.setCalendar_status(3);//打卡异常
	    			    						wocal.setCalendar_status_type(0);
	    			    					}
//	    			    					wocal.setCalendar_status(3);//打卡异常
	    			    				}
	    			    			}
	    		    				
	    		    				if(attdate.getAttsch().size() == 4 || attdate.getAttsch().size() == 6) {
	    		    					if(dkmc.getSbdk2() != null && dkmc.getSbdk2jg() == 0 && dkmc.getXbdk2() != null && dkmc.getXbdk2jg() == 0) {
	    			    					wocal.setCalendar_status(1);//打卡正常
	    			    					wocal.setCalendar_status_type(0);
	    			    				}else {
	    			    					if(dkmc.getXbdk2() == null && attdate.getAttsch().size() == 4) {
	    			    						if(bcsts.getIsXbdk()==1) {//下班不用打卡
	    			    							wocal.setCalendar_status(1);//打卡正常
	    			    							wocal.setCalendar_status_type(0);
	    			    						}else {
	    			    							wocal.setCalendar_status(3);//打卡异常
	    			    							wocal.setCalendar_status_type(0);
	    			    						}
	    			    					}else {
	    			    						wocal.setCalendar_status(3);//打卡异常	
	    			    						wocal.setCalendar_status_type(0);
	    			    					}
//	    			    					wocal.setCalendar_status(3);//打卡异常
	    			    				}
	    		    				}
	    		    				
	    		    				if(attdate.getAttsch().size() == 6) {
	    		    					if(dkmc.getSbdk3() != null && dkmc.getSbdk3jg() == 0 && dkmc.getXbdk3() != null && dkmc.getXbdk3jg() == 0) {
	    			    					wocal.setCalendar_status(1);//打卡正常
	    			    					wocal.setCalendar_status_type(0);
	    			    				}else {
	    			    					if(dkmc.getXbdk3() == null && attdate.getAttsch().size() == 6) {
	    			    						if(bcsts.getIsXbdk()==1) {//下班不用打卡
	    			    							wocal.setCalendar_status(1);//打卡正常
	    			    							wocal.setCalendar_status_type(0);
	    			    						}else {
	    			    							wocal.setCalendar_status(3);//打卡异常
	    			    							wocal.setCalendar_status_type(0);
	    			    						}
	    			    					}else {
	    			    						wocal.setCalendar_status(3);//打卡异常	
	    			    						wocal.setCalendar_status_type(0);
	    			    					}
//	    			    					wocal.setCalendar_status(3);//打卡异常
	    			    				}
	    		    				}
	    		    				
//	    		    				KqglAssoRelationSummary asssum = KqglAssoRelationSummary.builder().build().selectOne(new QueryWrapper<KqglAssoRelationSummary>().lambda().eq(KqglAssoRelationSummary::getUserId, userBean.getEmpNum())
//	    		    						.eq(KqglAssoRelationSummary::getAppTime, num).last("LIMIT 1"));
//	    		    				if(asssum != null) {
//	    		    					wocal.setCalendar_status(2);//事务(请假，加班，调休，出差)
//	    		    				}
	    		    			}else {
	    		    				wocal.setCalendar_status(3);//打卡异常
	    		    				wocal.setCalendar_status_type(0);
	    		    			}
	    		    			
	    		    			//事务(请假，加班，调休，出差)
	    		    			KqglAssoRelationSummary asssum = KqglAssoRelationSummary.builder().build().selectOne(new QueryWrapper<KqglAssoRelationSummary>().lambda().eq(KqglAssoRelationSummary::getUserId, userBean.getEmpNum())
    		    						.eq(KqglAssoRelationSummary::getAppTime, num).last("LIMIT 1"));
    		    				if(asssum != null) {
    		    					wocal.setCalendar_status(2);//事务(请假，加班，调休，出差)
    		    					
    		    					//0:无；1：事假；2：调休；3：病假；4：年假；5：产假；6：陪产假；7：婚假；8：例假；9：丧假；10：哺乳假；11：加班；12：出差；13：外出
    		    					if(asssum.getApprovalType() == 1) {
    		    						wocal.setCalendar_status_type(11);
    		    					}else if(asssum.getApprovalType() == 2) {
    		    						//请假
    		    						KqglAssoLeaveRules rul = KqglAssoLeaveRules.builder().build().selectOne(new QueryWrapper<KqglAssoLeaveRules>().lambda().eq(KqglAssoLeaveRules::getId,asssum.getLeaveTypeId()));
    		    						if(rul.getRulesType() == 1) {
    		    							wocal.setCalendar_status_type(1);
    		    						}else if(rul.getRulesType() == 2) {
    		    							wocal.setCalendar_status_type(2);
    		    						}else if(rul.getRulesType() == 3) {
    		    							wocal.setCalendar_status_type(3);
    		    						}else if(rul.getRulesType() == 4) {
    		    							wocal.setCalendar_status_type(4);
    		    						}else if(rul.getRulesType() == 5) {
    		    							wocal.setCalendar_status_type(5);
    		    						}else if(rul.getRulesType() == 6) {
    		    							wocal.setCalendar_status_type(6);
    		    						}else if(rul.getRulesType() == 7) {
    		    							wocal.setCalendar_status_type(7);
    		    						}else if(rul.getRulesType() == 8) {
    		    							wocal.setCalendar_status_type(8);
    		    						}else if(rul.getRulesType() == 9) {
    		    							wocal.setCalendar_status_type(9);
    		    						}else if(rul.getRulesType() == 10) {
    		    							wocal.setCalendar_status_type(10);
    		    						}
    		    					}else if(asssum.getApprovalType() == 3) {
    		    						wocal.setCalendar_status_type(12);
    		    					}else if(asssum.getApprovalType() == 4) {
    		    						wocal.setCalendar_status_type(13);
    		    					}
    		    				}
	    	    			}else {
	    	    				wocal.setCalendar_status(4);//休息
	    	    				wocal.setCalendar_status_type(0);
	    	    			}
	    	    		}else {
	    	    			wocal.setCalendar_status(0);//无排班
	    	    			wocal.setCalendar_status_type(0);
	    	    		}
	    	    	}else {
	    	    		wocal.setCalendar_status(0);//无排班
	    	    		wocal.setCalendar_status_type(0);
	    	    	}
	    	    	workcal.add(wocal);
	    	    }
	    	    
	    	    //当月后续补贴数据
	    	    if(date == null || ("").equals(date) || date.equals(yue)) {
	    	    	int pbfs = 0;
	    	    	String next_day = ClockInTool.requires_extra_times(current,1,2,1);
					Calendar ca = Calendar.getInstance();    
	    	        ca.set(Calendar.DAY_OF_MONTH, ca.getActualMaximum(Calendar.DAY_OF_MONTH));  
	    	        String last = mat.format(ca.getTime());
	    	        Long endMonth_ = DateUtil.getnowEndTime(23,DateUtil.getStringTime(last,"yyyy-MM-dd")).getTime();
	    	    	String[] nextrangeArray=ClockInTool.listToString(ClockInTool.getDays(next_day,sdf1.format(endMonth_))).split(";");//目前为止所有日期
					String[] nextrange=nextrangeArray[0].split(",");
	    	    	
	    			String ttstr = date;//
	    			String[] ycqts = new String[31];//应上班的具体天数（yyyy-MM-dd）
					String[] xxts = new String[31];//休息的具体天数（yyyy-MM-dd）
	    			
		    		if(attgro != null){//该员工是否加入到考勤组  排班方式 1：固定排班；2：自由排班；3：自由工时         计算出应出勤，实际出勤，休息天数
		    			if(attgro.getPbfs() == 1){	//固定排班
		    				pbfs = 1;
							List<KqglAssoTeshu> bxdklist = kqglassoteshumapper.ShouldSpecialDatessetByKqzid(attgro.getId(), ttstr,1);//当前月     必须打卡日期
							int bxdk = bxdklist.size();
							String[] bxdkss = new String[bxdk];////特殊-必须打卡天数（工作日）
							int b = 0;
							for(KqglAssoTeshu bxd : bxdklist) {
								bxdkss[b] = bxd.getTsrq();
								b++;
							}
							List<KqglAssoTeshu> wxdk = kqglassoteshumapper.ShouldSpecialDatessetByKqzid(attgro.getId(), ttstr,2);//当前月     无需打卡日期
							String[] appmaps= new String[wxdk.size()];//特殊-无需打卡天数（休息日）
							int d1 = 0;
							for(KqglAssoTeshu spe:wxdk){
								appmaps[d1] = spe.getTsrq();
								d1++;
							}
							//应打卡周期时间
							List<AttendanceWeeklySch> atwek = attendanceweeklyschmapper.selectAttendanceMadeByUserid(userBean.getEmpNum(),userBean.getOrgCode());
							String[] week= new String[atwek.size()];
							String[] needfig = new String[atwek.size()];//应打卡周期时间
							int e = 0;
							for(AttendanceWeeklySch awek : atwek){
								week[e] = awek.getWekmc();
								needfig[e] = String.valueOf(awek.getType());//获取设置的应打卡周几
								e++;
							}
							 
							//目前为止应出勤天数
							 int w = 0,x=0;
							 int zj = 6;
							 if(!(nextrange[0]).equals("")) {
								 for(String num : nextrange) {
										if(Arrays.binarySearch(needfig, String.valueOf(ClockInTool.dateToWeek(num))) >= 0) {//对比排班应打卡时间
											String[] ycqtst = new String[ycqts.length + zj];
											System.arraycopy(ycqts, 0, ycqtst, 0, ycqts.length);
											ycqtst[w] = num;
											ycqts = ycqtst;
											w++;
										}else {
											String[] xxtst = new String[xxts.length + zj];
											System.arraycopy(xxts, 0, xxtst, 0, xxts.length);
											xxtst[x] = num;
											xxts = xxtst;
											x++;
										}
										if(Arrays.binarySearch(bxdkss, num) >= 0) {//检查是否存在 必须打卡名单中
											String[] ycqtst = new String[ycqts.length + zj];
											System.arraycopy(ycqts, 0, ycqtst, 0, ycqts.length);
											ycqtst[w] = num;
											ycqts = ycqtst;
											w++;
											xxts =	ClockInTool.doChinFilters(ClockInTool.deleteArrayNull(xxts), num);//为必须上班的话从休息日期中去除
										}
										if(Arrays.binarySearch(appmaps, num) >= 0) {//检查是否存在 无需打卡名单中
											ycqts = ClockInTool.doChinFilters(ClockInTool.deleteArrayNull(ycqts), num);//为必须休息的话从上班日期中去除
											String[] xxtst = new String[xxts.length + zj];
											System.arraycopy(xxts, 0, xxtst, 0, xxts.length);
											xxtst[x] = num;
											xxts = xxtst;
											x++;
										}
									 }
							 }
						}else if(attgro.getPbfs() == 2){	//自由排班
							pbfs = 2;
							DateFormat df11 = new SimpleDateFormat("EEE MMM dd HH:mm:ss zzz yyyy", Locale.US);
							List<Schedule> ycqs = schedulemapper.getAttendanceShouldList(userBean.getEmpNum(),startMonth,endMonth);
							int z=0;
							String[] ziyoupb = new String[ycqs.size()];
							for(Schedule sc : ycqs){
								String data = new SimpleDateFormat("yyyy-MM-dd").format(df11.parse(String.valueOf(sc.getData())));// 获得格式化后的日期字符串
								ziyoupb[z] = data;
								z++;
							}
							//目前为止应出勤天数
							int y = 0,x=0;
							for(String num : nextrange) {
								if(Arrays.binarySearch(ziyoupb, num) >= 0) {
									KqglAssoPbmx pbx = KqglAssoPbmx.builder().build().selectOne(new QueryWrapper<KqglAssoPbmx>().lambda().eq(KqglAssoPbmx::getUserid, userBean.getEmpNum()).eq(KqglAssoPbmx::getData, num).eq(KqglAssoPbmx::getKqzid, attgro.getId()));
									if(pbx!=null && pbx.getBcid()!=0) {
										ycqts[y] = num;
										y++;
									}else {
										xxts[x] = num;
										x++;
									}
								}
							}
						}else{
							pbfs = 3;
							List<AttendanceWeeklySch> atwek = attendanceweeklyschmapper.selectAttendanceMadeByUserid(userBean.getEmpNum(),userBean.getOrgCode());
							String[] week= new String[atwek.size()];
							int e = 0;
							String[] ziyoupb = new String[atwek.size()];
							for(AttendanceWeeklySch awek : atwek){
								week[e] = awek.getWekmc();
								ziyoupb[e] = String.valueOf(awek.getType());
								e++;
							}
						     //目前为止应出勤天数
						     int g = 0,x=0;
						     for(String num : nextrange) {
						    	 if(Arrays.binarySearch(ziyoupb, String.valueOf(ClockInTool.dateToWeek(num))) >= 0) {//对比排班应打卡时间
						    		 ycqts[g] = num;	
						    		 g++;
								 }else {
									xxts[x] = num;
									x++;
								 }
						     }
						}
		    		}
					
					
		    		for(String nus : nextrange) {
		    			WorkbenchCalendarDto wocal = WorkbenchCalendarDto.builder().build();
		    	    	wocal.setDate(nus);
		    	    	if(pbfs == 3) {
		    	    		wocal.setCalendar_status(0);//
		    	    		wocal.setCalendar_status_type(0);
		    	    	}else {
		    	    		if(ClockInTool.contains(ClockInTool.deleteArrayNull(ycqts),nus)) {
			    	    		wocal.setCalendar_status(1);//
			    	    		wocal.setCalendar_status_type(0);
			    	    	}
			    	    	if(ClockInTool.contains(ClockInTool.deleteArrayNull(xxts),nus)) {
			    	    		wocal.setCalendar_status(4);//
			    	    		wocal.setCalendar_status_type(0);
			    	    	}
		    	    	}
		    	    	
		    	    	workcal.add(wocal);
		    		}
		    		
	    		}
	        }
			
			return ResultUtil.data(workcal, "操作成功!");
		}
	 
	 
	
}