public interface WxUserMapping {

	/*
	 * 插入一个微信用户
	 */
	@Insert("insert into `wxusers` (`open_id`, `nick_name`, `avatar_url`, `gender`, `city`, `province`) "
			+ "values(#{openId}, #{nickName}, #{avatarUrl}, #{gender}, #{city}, #{province})")
	public void insert(WxUserEntity wxUserEntity);
	
	/*
	 * 根据微信用户openId查询用户
	 * 这里不用返回用户所有信息，使用覆盖索引，提高效率
	 */
	@Select("select `open_id` from `wxusers` where `open_id`=#{openId}")
	public String getOpenId(@Param("openId") String openId);
	
	/*
	 * 根据openId查询id
	 */
	@Select("select `id` from `wxusers` where `open_id`=#{openId}")
	public int getIdByOpenId(String openId);
}

public class WxUserService {

	@Autowired
	private WxUserMapping wxUserMapping;
	
	/*
	 * 添加用户
	 */
	public String addWxUser(WxUserEntity wxUserEntity) {
		if(wxUserEntity == null) {
			return Constants.FAILCODE;
		}
		try {
			wxUserMapping.insert(wxUserEntity);
			return Constants.SUCCESSCODE;
		} catch (Exception e) {
			// TODO: handle exception
			log.info("WxUserService/addWxUser", e);
			return Constants.FAILCODE;
		}
	}
	
	/*
	 * 根据openId判断是否是新用户
	 */
	public String isNewWxUser(String openId) {
		// 注意这里null和""的判读不能写反了。
		if(openId == null || openId.equals("")) {
			return Constants.SUCCESSCODE;
		}
		try {
			String res = wxUserMapping.getOpenId(openId);
			if(res == null || res.equals("")) {
				return Constants.SUCCESSCODE;
			}else {
				return Constants.FAILCODE;
			}
		} catch (Exception e) {
			// TODO: handle exception
			log.info("WxUserService/isNewWxUser", e);
			return Constants.ERROR;
		}
	}
	
	/*
	 * 根据用户openId查询id
	 */
	public int getId(String openId) {
		try {
			int id = wxUserMapping.getIdByOpenId(openId);
			log.info("WxUserService/getId, 查询ID成功," + id);
			return id;
		} catch (Exception e) {
			// TODO: handle exception
			log.info("WxUserService/getId, 查询ID失败", e);
			return -1;
		}
	}
}

public class WxUserController extends BaseController{

	@Autowired
	private RestTemplate restTemplate;
	
	/*
	 * 微信用户登陆/注册
	 */
	@RequestMapping("/wxLogin")
	public String wxLogin(WxUserEntity wxUserEntity, String code) {
		// 查询Redis是否存在用户
		// 这里好像不太能通过用户的微信信息来判断用户
		// 得想办法从客户端获取用户唯一识别码，方能通过redis缓存用户登陆信息。
		
		// 请求微信接口
		String params = "appid=" + Constants.APPID + "&secret=" + Constants.APPSECRET + "&js_code="
				+ code + "&grant_type=authorization_code";//参数
        String url = "https://api.weixin.qq.com/sns/jscode2session?"+params;// 微信接口 用于查询oponid
        String response = restTemplate.getForObject(url,String.class);
        JSONObject jsonObject = JSON.parseObject(response);
        response = jsonObject.getString("openid");
        log.info("UserController/wxLogin, 微信用户接口返回openid：" + response);
        wxUserEntity.setOpenId(response);
        // 是否是新添加用户
        String isNewWxUser = wxUserService.isNewWxUser(wxUserEntity.getOpenId());
        if(isNewWxUser.equals(Constants.SUCCESSCODE)) {
        	// 是新用户
            String addResult = wxUserService.addWxUser(wxUserEntity);
            if(addResult.equals(Constants.SUCCESSCODE)) {
            	// 添加成功
            	log.info("UserController/wxLogin, 新用户添加成功");
            }else {
            	// 添加失败
            	log.info("UserController/wxLogin, 新用户注册失败");
            	return Constants.ERROR;
            }
        }else if(isNewWxUser.equals(Constants.ERROR)) {
        	// 查询失败
        	log.info("UserController/wxLogin, 用户信息查询失败");
        	return Constants.ERROR;
        }
        log.info("UserController/wxLogin, 登陆/注册成功返回openid");
        return response;
	}
}

public interface FileMapping {

	/*
	 * 插入一个文件
	 */
	@Insert("insert into `file_info` (`file_name`, `file_url`, `year`, `month`, `day`,"
			+ " `pepole_id`, `client_created`) "
			+ "values(#{fileName}, #{fileUrl}, #{year}, #{month}, #{day}"
			+ ", #{pepoleId}, #{clientCreated});")
	public void addFile(FileEntity fileEntity);
  
}

public class FileService extends BaseService{

	@Value("${fileBasePath}")
	private String fileBasePath;
	@Autowired
	private ThreadPoolExecutor threadPoolExecutor;

	/*
	 * 将数据插入文件
	 */
	public String saveData(HttpServletRequest req, int onedata, int pepoleid, String filepath) {
		// 判读是否需要新建文件
		String res = "";
		BufferedOutputStream out = null;
		try {
			if(filepath == null || filepath.equals("")) {
				String time = TimeUtil.getCurrentTime();
				String[] strs = time.split(" ");
				// fileName格式：pepoleId_yy-mm-dd_hh_mm_ss_.txt 0_2021-07-29_16_38_01_.txt
				String[] hours = strs[1].split(":");
				String filename = pepoleid + "_" + strs[0] + "_" + hours[0] + "_" 
							  + hours[1] + "_" + hours[2] + "_.txt";
				// 文件名存Session
				String[] arr = strs[0].split("-");
				String path = fileBasePath + pepoleid + "/" + arr[0] + "/" + arr[1] + "/" + arr[2];
				isExist(path);
				filepath = path + "/" + filename;
			}
			out = new BufferedOutputStream(new FileOutputStream(new File(filepath), true));
			// 这里写入文件不能直接写int会没有反应。
			out.write(String.valueOf(onedata).getBytes());
			out.flush();
			log.info("FileService/saveData, 写入文件成功");
			res = filepath;
		} catch (Exception e) {
			log.info("FileService/saveData, 写入文件失败", e);
			res = Constants.FAILCODE;
		} finally {
			try {
				out.close();
			} catch (IOException e) {
				log.info("FileService/saveData, 关闭文件失败", e);
				res = Constants.FAILCODE;
			}
		}
		return res;
	}

	private void isExist(String path) {
		File folder = new File(path);
		if (!folder.exists() && !folder.isDirectory()) {
			folder.mkdirs();
			log.info("创建文件夹: " + path);
		}
	}
}

/*
	 * 接收一个数据点
	 */
	@RequestMapping("/recieveData")
	public String recieveData(HttpServletRequest req, int onedata, int pepoleid, String filepath) {
		String res = fileService.saveData(req, onedata, pepoleid, filepath);
		return res;
	}

public interface MonthReportMapping {

	/*
	 * 插入一个月份报告
	 */
	@Insert("insert into `month_report` values(#{y}, #{m}, #{imgurl}, #{title}, #{description}, #{healthIndex},"
			+ "#{pepoleId})")
	public void insertMonthReport(MonthReport monthReport);
	
	/*
	 * 判断月报告是否存在
	 */
	@Select("select id from `month_report` WHERE `y`=#{y} and `m`=#{m} and `pepole_id`=#{pepoleId}")
	public Integer isExist(@Param("y") int year, @Param("m") int month, @Param("pepoleId") int pepoleId);
	
	/*
	 * 根据年份查询所有月份前两个月报告
	 */
	@Select("select * from `month_report` WHERE `y`=#{y} and `pepole_id`=#{pepoleId}  ORDER BY m limit 2;")
	public List<MonthReport> getFront2months(@Param("y") int year, @Param("pepoleId") int pepoleId);
}

	public String getSummryReport(String openId) {
		try {
			// 从redis中，用openId提取pepoleId
			// 。。。
			// 这里先直接从数据库查询
			int pepoleId = wxUserService.getId(openId);
			if (pepoleId == -1) {
				log.info("ReportService/getSummryReport, 用户openid查询失败，获取健康报告失败");
				return Constants.ERROR;
			}
			// 查询用户使用年份
			List<String> allYearsByPepoleId = fileMapping.getAllYearsByPepoleId(pepoleId);
			// 查询前两个月的信息并封装
			JSONObject report = new JSONObject();
			JSONArray yearArray = new JSONArray();
			for (String year : allYearsByPepoleId) {
				// 组合简略报告
				JSONObject smallYearReport = new JSONObject();
				smallYearReport.put(Constants.YEAR, year);

				JSONArray monthArray = new JSONArray();
				List<MonthReport> front2months = monthReportMapping.getFront2months(Integer.valueOf(year), pepoleId);
				for (MonthReport mR : front2months) {
					monthArray.add(Report.monthReportJSON(mR));
				}

				smallYearReport.put(Constants.MONTH, monthArray);
				yearArray.add(smallYearReport);
			}
			report.put(Constants.DATA, yearArray);
			log.info("ReportService/getSummryReport, 获取健康报告成功" + report.toJSONString());
			// 算法分析
			return report.toJSONString();
		} catch (Exception e) {
			// TODO: handle exception
			log.info("ReportService/getSummryReport, 获取健康报告失败", e);
			return Constants.ERROR;
		}
	}

/*
	 * 查询用户健康报告首页
	 */
	@RequestMapping("/getReport")
	public String getReport(String openid) {
		// 查询用户是否存在
        String isNewWxUser = wxUserService.isNewWxUser(openid);
        if(isNewWxUser.equals(Constants.SUCCESSCODE)) {
        	// 是新用户           
            return Constants.FAILCODE;
        }else if(isNewWxUser.equals(Constants.ERROR)) {
        	// 查询失败
        	log.info("ReportController/getReport, 用户信息查询失败");
        	return Constants.ERROR;
        }
        String summryReport = reportService.getSummryReport(openid);
        if(summryReport.equals(Constants.ERROR)) {
        	log.info("ReportController/getReport, 报告获取失败");
        	return Constants.ERROR;
        }
        log.info("ReportController/getReport, 报告获取成功");
        return summryReport;
	}

public interface MonthReportMapping {

	// ...
  
	/*
	 * 根据年份查询所有月份的月报告
	 */
	@Select("select * from `month_report` WHERE `y`=#{y} and `pepole_id`=#{pepoleId}  ORDER BY m;")
	public List<MonthReport> getAllMonthsByYear(@Param("y") int year, @Param("pepoleId") int pepoleId);
}

/*
	 * 根据openid/pepoleid查询某年所有月缩略报告
	 */
	public String getYearReport(String year, String openId) {
		try {
			// 从redis中，用openId提取pepoleId
			// 。。。
			// 这里先直接从数据库查询
			int pepoleId = wxUserService.getId(openId);
			if (pepoleId == -1) {
				log.info("ReportService/getYearReport, 用户openid查询失败，获取年度健康报告失败");
				return Constants.ERROR;
			}
			// 查询前两个月的信息并封装
			JSONObject report = new JSONObject();
			JSONArray yearArray = new JSONArray(); // 小程序端只使用数组的第一个值

			// 组合年度报告
			JSONObject yearReport = new JSONObject();
			yearReport.put(Constants.YEAR, year);

			JSONArray monthArray = new JSONArray();
			List<MonthReport> allMonthsByYear = monthReportMapping.getAllMonthsByYear(Integer.valueOf(year), pepoleId);
			for (MonthReport mR : allMonthsByYear) {
				monthArray.add(Report.monthReportJSON(mR));
			}

			yearReport.put(Constants.MONTH, monthArray);
			yearArray.add(yearReport);
			report.put(Constants.DATA, yearArray);
			log.info("ReportService/getYearReport, 获取年度健康报告成功" + report.toJSONString());
			// 算法分析
			return report.toJSONString();
		} catch (Exception e) {
			// TODO: handle exception
			log.info("ReportService/getYearReport, 获取年度健康报告失败", e);
			return Constants.ERROR;
		}
	}

/*
	 * 查询用户年度健康报告
	 */
	@RequestMapping("/getYearReport")
	public String getYearReport(String year, String openid) {
		// 查询用户是否存在
        String isNewWxUser = wxUserService.isNewWxUser(openid);
        if(isNewWxUser.equals(Constants.SUCCESSCODE)) {
        	// 是新用户           
            return Constants.FAILCODE;
        }else if(isNewWxUser.equals(Constants.ERROR)) {
        	// 查询失败
        	log.info("ReportController/getYearReport, 用户信息查询失败");
        	return Constants.ERROR;
        }
        String yearReport = reportService.getYearReport(year, openid);
        if(yearReport.equals(Constants.ERROR)) {
        	log.info("ReportController/getYearReport, 报告获取失败");
        	return Constants.ERROR;
        }
        log.info("ReportController/getYearReport, 报告获取成功");
        return yearReport;
	}

public interface MonthReportMapping {

	// ...
  
	/*
	 * 查询某月的月报告
	 */
	@Select("select * from `month_report` WHERE `y`=#{y} and `m`=#{m} and `pepole_id`=#{pepoleId}")
	public MonthReport getMonthReportByYearAndMonth(@Param("y") int year, @Param("m") int month, @Param("pepoleId") int pepoleId);
}

public interface DayReportMapping {

	/*
	 * 插入一个记录
	 */
	@Insert("insert into `day_report` values(#{y}, #{m}, #{d}, #{imgurl}, #{isUsed}, #{healthIndex},"
			+ "#{pepoleId})")
	public void insertDayReport(DayReport dayReport);
	
	/*
	 * 根据openid、year、month查询所有缩略日报告
	 */
	@Select("select * from `day_report` where `y`=#{y} and `m`=#{m} and `pepole_id`=#{pepoleId} ORDER BY d;")
	public List<DayReport> getAllDayReportByYearAndMonth(@Param("y") int year, @Param("m") int month, 
			@Param("pepoleId") int pepoleId);
}

/*
	 * 根据openid/pepoleid查询某年某月所有天缩略报告
	 */
	public String getMonthReport(String year, String month, String openId) {
		try {
			// 从redis中，用openId提取pepoleId
			// 。。。
			// 这里先直接从数据库查询
			int pepoleId = wxUserService.getId(openId);
			if (pepoleId == -1) {
				log.info("ReportService/getMonthReport, 用户openid查询失败，获取年度健康报告失败");
				return Constants.ERROR;
			}
			// 查询该月所有“天报告”的信息并封装
			JSONObject report = new JSONObject();
			JSONArray yearArray = new JSONArray(); // 小程序端只使用数组的第一个值

			// 组合详细月报告
			JSONObject yearReport = new JSONObject();
			yearReport.put(Constants.YEAR, year);

			JSONArray monthArray = new JSONArray();
				// 查询该月报告
			MonthReport monthReportByYearAndMonth = monthReportMapping.getMonthReportByYearAndMonth(Integer.valueOf(year), 
					Integer.valueOf(month), pepoleId);
				// 查询该月所有日报告
			List<DayReport> allDayReportByYearAndMonth = dayReportMapping.getAllDayReportByYearAndMonth(Integer.valueOf(year), 
					Integer.valueOf(month), pepoleId);
			monthReportByYearAndMonth.setDayLists(allDayReportByYearAndMonth);
			monthArray.add(Report.monthReportJSON(monthReportByYearAndMonth));
			
			yearReport.put(Constants.MONTH, monthArray);
			yearArray.add(yearReport);
			report.put(Constants.DATA, yearArray);
			log.info("ReportService/getMonthReport, 获取详细月健康报告成功" + report.toJSONString());
			// 算法分析
			return report.toJSONString();
		} catch (Exception e) {
			// TODO: handle exception
			log.info("ReportService/getMonthReport, 获取详细月健康报告失败", e);
			return Constants.ERROR;
		}
	}

/*
	 * 查询用户详细月健康报告
	 */
	@RequestMapping("/getMonthReport")
	public String getMonthReport(String year, String month, String openid) {
		// 查询用户是否存在
        String isNewWxUser = wxUserService.isNewWxUser(openid);
        if(isNewWxUser.equals(Constants.SUCCESSCODE)) {
        	// 是新用户           
            return Constants.FAILCODE;
        }else if(isNewWxUser.equals(Constants.ERROR)) {
        	// 查询失败
        	log.info("ReportController/getMonthReport, 用户信息查询失败");
        	return Constants.ERROR;
        }
        String monthReport = reportService.getMonthReport(year, month, openid);
        if(monthReport.equals(Constants.ERROR)) {
        	log.info("ReportController/getMonthReport, 报告获取失败");
        	return Constants.ERROR;
        }
        log.info("ReportController/getMonthReport, 报告获取成功");
        return monthReport;
	}

@Setter
@Getter
public class FileReport {
	private int id;
	private int y;
	private int m;
	private int d;
	private int avgBeat;
	@JSONField(format="yyyy-MM-dd HH:mm:ss")//首先设定日期时间格式,HH指使用24小时制,hh是使用12小时制
	private Timestamp startTime;
	@JSONField(format="yyyy-MM-dd HH:mm:ss")
	private Timestamp endTime;
	private int pepoleId;
}

public interface FileReportMapping {

	/*
	 * 插入一个记录
	 */
	@Insert("insert into `file_report` values(null, #{y}, #{m}, #{d}, #{avgBeat}, "
			+ "#{startTime}, #{endTime}, #{pepoleId});")
	public void insert(FileReport filReport);
	
	/*
	 * 查询某天的所有文件记录
	 */
	@Select("select * from `file_report` where `y`=#{y} and `m`=#{m} and `d`=#{d} and "
			+ "`pepole_id`=#{pepoleId} ORDER BY `startTime`;")
	public List<FileReport> getAllFileReport(@Param("y") int year, @Param("m") int month, @Param("d") int day,
			@Param("pepoleId") int pepoleId);
}

public interface DayReportMapping {

	//...
	
	/*
	 * 根据openid、year、month、day查询当日报告
	 */
	@Select("select * from `day_report` where `y`=#{y} and `m`=#{m} and `d`=#{d} and `pepole_id`=#{pepoleId};")
	public DayReport getDayReportByYearAndMonthAndDay(@Param("y") int year, @Param("m") int month, @Param("d") int day,
			@Param("pepoleId") int pepoleId);
}

/*
	 * 根据openid/pepoleid查询某年某月某天所有的文件报告
	 */
	public String getDayReport(String year, String month, String day, String openId) {
		try {
			// 从redis中，用openId提取pepoleId
			// 。。。
			// 这里先直接从数据库查询
			int pepoleId = wxUserService.getId(openId);
			if (pepoleId == -1) {
				log.info("ReportService/getDayReport, 用户openid查询失败，获取年度健康报告失败");
				return Constants.ERROR;
			}
			// 查询某天所有文件报告的信息并封装
			JSONObject report = new JSONObject();
			
				// 组合年报告
			JSONObject yearReport = new JSONObject();
			yearReport.put(Constants.YEAR, year);
			
				// 组合月报告
					// 新建月报告，月报告信息不用传输客户端，不查询数据库
			MonthReport monthReportByYearAndMonth = new MonthReport();
					// 查询该月该日报告
			DayReport dayReportByYearAndMonthAndDay = dayReportMapping.getDayReportByYearAndMonthAndDay(Integer.valueOf(year), 
					Integer.valueOf(month), Integer.valueOf(day), pepoleId);
					// 查询改日所有文件报告
			List<FileReport> allFileReport = fileReportMapping.getAllFileReport(Integer.valueOf(year), 
					Integer.valueOf(month), Integer.valueOf(day), pepoleId);
					// 组合字段
			dayReportByYearAndMonthAndDay.setFileReportLists(allFileReport);
			List<DayReport> dayLists = new ArrayList<DayReport>();
			dayLists.add(dayReportByYearAndMonthAndDay);
			monthReportByYearAndMonth.setDayLists(dayLists);
			JSONArray monthArray = new JSONArray();
			monthArray.add(Report.toReportJSON(monthReportByYearAndMonth));
			
			yearReport.put(Constants.MONTH, monthArray);
			JSONArray yearArray = new JSONArray(); // 小程序端只使用数组的第一个值
			yearArray.add(yearReport);
			report.put(Constants.DATA, yearArray);
			log.info("ReportService/getDayReport, 获取详细日健康报告成功" + report.toJSONString());
			// 算法分析
			return report.toJSONString();
		} catch (Exception e) {
			// TODO: handle exception
			log.info("ReportService/getMonthReport, 获取详细日健康报告失败", e);
			return Constants.ERROR;
		}
	}

/*
	 * 查询用户详细日健康报告
	 */
	@RequestMapping("/getDayReport")
	public String getDayReport(String year, String month, String day, String openid) {
		// 查询用户是否存在
        String isNewWxUser = wxUserService.isNewWxUser(openid);
        if(isNewWxUser.equals(Constants.SUCCESSCODE)) {
        	// 是新用户           
            return Constants.FAILCODE;
        }else if(isNewWxUser.equals(Constants.ERROR)) {
        	// 查询失败
        	log.info("ReportController/getDayReport, 用户信息查询失败");
        	return Constants.ERROR;
        }
        String dayReport = reportService.getDayReport(year, month, day, openid);
        if(dayReport.equals(Constants.ERROR)) {
        	log.info("ReportController/getDayReport, 报告获取失败");
        	return Constants.ERROR;
        }
        log.info("ReportController/getDayReport, 报告获取成功");
        return dayReport;
	}

	public void generateReport() {
		/**
		 * 遍历file_info数据库，搜素当天新添的所有文件
		 */
		// 1. 获取当前时间
		String time = TimeUtil.getCurrentTime();
		String[] strs = time.split(" ");// yy-mm-dd hh_mm_ss
		String[] ymd = strs[0].split("-"); // yy mm dd
		String[] hours = strs[1].split(":"); // hh mm ss
		// 查询当天文件
		List<FileEntity> filesListByYMD = fileMapping.getFilesListByYMD(ymd[0], ymd[1], ymd[2]);
		log.info("FileService/generateReport, 查询当天新添报告成功 {}", filesListByYMD);
		Runnable reportRunable = new ReportRunable(filesListByYMD, fileReportMapping, dayReportMapping,
				monthReportMapping, wxUserService);
		threadPoolExecutor.submit(reportRunable);
		log.info("生成报告中。。");
	}

public void run() {
		// TODO Auto-generated method stub
		// 遍历filesToday列表，插入file_report数据库表
		Map<Integer, List<FileReport>> map = new HashMap<Integer, List<FileReport>>();
		int[] ymd = new int[3];
		for (FileEntity f : this.filesToday) {
			// 封装fileReport
			FileReport fileReport = new FileReport();
			fileReport.setY(Integer.valueOf(f.getYear()));
			fileReport.setM(Integer.valueOf(f.getMonth()));
			fileReport.setD(Integer.valueOf(f.getDay()));
			ymd[0] = fileReport.getY();
			ymd[1] = fileReport.getM();
			ymd[2] = fileReport.getD();
			fileReport.setStartTime(f.getClientCreated());
			fileReport.setEndTime(f.getServerCreated());
			fileReport.setPepoleId(f.getPepoleId());
			// 读取磁盘文件，计算平均心率
			// try {
			fileReport.setAvgBeat(calAvgHeart(f.getFileUrl()));
			// } catch (Exception e) {
			// // TODO: handle exception
			// // 若文件不存在或读取失败，则直接赋值为-1进行报错提示。
			// fileReport.setAvgBeat(-1);
			// log.info("ReportRunable/run, 读取文件失败", e);
			// }
			// try {
			fileReportMapping.insert(fileReport);
			log.info("ReportRunable/run, 插入fileReport成功");
			// } catch (Exception e) {
			// // TODO: handle exception
			// log.info("ReportRunable/run, 插入fileReport失败", e);
			// }
			if (!map.containsKey(f.getPepoleId())) {
				map.put(f.getPepoleId(), new ArrayList<FileReport>());
			}
			map.get(f.getPepoleId()).add(fileReport);
		}
		// 获取数据库所有人的id
		List<Integer> allPepoleId = wxUserService.getAllId();
		// 日报告生成和修改..
		for (Integer pid : allPepoleId) {
			DayReport dayReport = new DayReport();
			dayReport.setY(ymd[0]);
			dayReport.setM(ymd[1]);
			dayReport.setD(ymd[2]);
			dayReport.setImgurl("/static/imgs/reports/riqi" + ymd[2] + ".png");
			dayReport.setPepoleId(pid);
			if (!map.containsKey(pid)) {
				// 今天没有新增
				dayReport.setUsed(false);
				dayReport.setHealthIndex(0);
			} else {
				// 今天新增
				dayReport.setUsed(true);
				// 计算平均心率
				float dayAvg = 0;
				for (FileReport fr : map.get(pid)) {
					if (fr.getAvgBeat() == -1) {
						dayAvg = -1;
						break;
					}
					dayAvg += fr.getAvgBeat();
				}
				if (dayAvg != -1) {
					dayReport.setHealthIndex(dayAvg / map.get(pid).size());
				}
			}
			// try {
			dayReportMapping.insertDayReport(dayReport);
			log.info("ReportRunable/run, 插入dayReport成功");
			// } catch (Exception e) {
			// // TODO: handle exception
			// log.info("ReportRunable/run, 插入dayReport失败", e);
			// }
		}
		// 月报告生成和修改
		// try {
		for (Integer pid : allPepoleId) {
			// 查询本月每天的记录
			List<DayReport> allDayReportByYearAndMonth = dayReportMapping.getAllDayReportByYearAndMonth(ymd[0], ymd[1],
					pid);
			// 计算平均心率
			float monthAvg = 0;
			int len = 0;
			for (DayReport dr : allDayReportByYearAndMonth) {
				if (dr.isUsed()) {
					if (dr.getHealthIndex() == -1) {
						monthAvg = -1;
						break;
					}
				}
				monthAvg += dr.getHealthIndex();
				len = len + 1;
			}
			if (monthAvg != -1) {
				monthAvg = monthAvg / len;
			}
			if (ymd[2] == 1) {
				// 今天是新的1个月，需要进行新增月报告
				MonthReport monthReport = new MonthReport();
				monthReport.setY(ymd[0]);
				monthReport.setM(ymd[1]);
				monthReport.setImgurl("/static/imgs/reports/riqi" + ymd[1] + ".png");
				monthReport.setTitle(ymd[1] + "月报告");
				monthReport.setDescription("良好");
				monthReport.setPepoleId(pid);
				monthReport.setHealthIndex(monthAvg);
				monthReportMapping.insertMonthReport(monthReport);
				log.info("ReportRunable/run, 插入monthReport成功");
			} else {
				// 本月月报告已经存在，需要进行修改
				monthReportMapping.updateMonthHealthIndex(monthAvg, ymd[0], ymd[1], pid);
				log.info("ReportRunable/run, 修改monthReport成功");
			}
		}
		// } catch (Exception e) {
		// // TODO: handle exception
		// log.info("ReportRunable/run, 插入monthReport失败", e);
		// }
	}

@Scheduled(cron="0 0 22 * * ?")