public class StudentCount {

	/** 班级对应学生人数折线图 */
	public static String createBarJson(Map<String, Object> data) {
		Set<String> set = data.keySet();
		
		GsonOption option = new GsonOption();
		option.title().text("班级学生数量统计").x(X.center).y(Y.top).borderWidth(1).textStyle().color("#438EB9");
		option.toolbox().show(true).feature(Tool.mark, Tool.restore, new MagicType(Magic.bar, Magic.line), Tool.saveAsImage).x(X.right).y(Y.top);
		//数据默认触发， 鼠标移入显示竖线  trigger(Trigger.axis)
		option.tooltip().formatter("{b} {c}人").trigger(Trigger.axis);
		option.legend().data("班级总人数").x(X.center).y(Y.bottom).borderWidth(1);
		Line line = new Line("班级总人数");
		//值轴
		ValueAxis valueAxis = new ValueAxis();
		valueAxis.axisLabel().formatter("{value}人").textStyle().color("#438EB9");
		//valueAxis.min(0);
		option.yAxis(valueAxis);
		//类目轴
		CategoryAxis categoryAxis = new CategoryAxis();
		//interval(0)：设置横轴信息全部显示
		//rotate(-30)：设置 -30 度角倾斜显示
		categoryAxis.axisLabel().interval(0).rotate(-30).textStyle().color("#438EB9");
		for (String className : set) {
			categoryAxis.data(className);
			ClassInfo classInfo = (ClassInfo)data.get(className);
			line.data(classInfo.getClassId());
		}
		option.xAxis(categoryAxis);
		line.smooth(true);
		option.series(line);
		option.grid().x(100);
		System.out.println(option.toString());
		return option.toString();
	}
}
public class StudentExamInfoCharts {
	public static String createExamCountBarJson(List<StudentExamInfo> examInfos) {
		GsonOption option = new GsonOption();
		option.title().text("学生考试次数统计").x(X.center).y(Y.top).borderWidth(1).textStyle().color("#438EB9");
		option.toolbox().show(true).feature(Tool.mark, Tool.restore, new MagicType(Magic.bar, Magic.line), Tool.saveAsImage).x(X.right).y(Y.top);
		option.tooltip().show(true).formatter("{b} {c}次");
		option.legend().data("学生考试次数统计").x(X.center).y(Y.bottom);
		Bar bar = new Bar();
		//值轴
		ValueAxis valueAxis = new ValueAxis();
		//设置y轴不出现小数值
		valueAxis.interval(1);
		valueAxis.axisLabel().formatter("{value} 次");
		option.yAxis(valueAxis);
		//类目轴
		CategoryAxis categoryAxis = new CategoryAxis();
		categoryAxis.axisLabel().interval(0);
		for (StudentExamInfo studentExamInfo : examInfos) {
			bar.data(studentExamInfo.getExamSum());
			categoryAxis.data(studentExamInfo.getStudentName());
		}
		bar.barCategoryGap("20");
		option.xAxis(categoryAxis);
		option.series(bar);
		return option.toString();
	}
	public static String createAvgCountLineJson(List<StudentExamInfo> examInfos) {
		GsonOption option = new GsonOption();
		option.title().text("学生考试平均成绩统计").x(X.center).y(Y.top).borderWidth(1).textStyle().color("#438EB9");
		option.toolbox().show(true).feature(Tool.mark, Tool.restore, new MagicType(Magic.bar, Magic.line), Tool.saveAsImage).x(X.right).y(Y.top);
		option.tooltip().show(true).trigger(Trigger.axis).axisPointer().type(PointerType.cross).crossStyle().color("#999");
		option.legend().data("考试次数", "平均分").x(X.center).y(Y.bottom);
		Line line = new Line("考试次数").smooth(true);
		Bar bar = new Bar("平均分");
		//值轴
		ValueAxis valueAxis = new ValueAxis();
		//设置y轴不出现小数值
		valueAxis.interval(1);
		valueAxis.axisLabel().formatter("{value} 次");
		ValueAxis valueAxis1 = new ValueAxis();
		valueAxis1.interval(1);
		valueAxis1.axisLabel().formatter("{value} 分");
		option.yAxis(valueAxis, valueAxis1);
		//类目轴
		CategoryAxis categoryAxis = new CategoryAxis();
		categoryAxis.axisLabel().interval(0);
		for (StudentExamInfo studentExamInfo : examInfos) {
			if (studentExamInfo.getAvgScore() != null || studentExamInfo.getExamSum() != 0) {
				bar.data(studentExamInfo.getAvgScore()/studentExamInfo.getExamSum());
			} else {
				bar.data("暂无记录");				
			}
			line.data(studentExamInfo.getExamSum());
			categoryAxis.data(studentExamInfo.getStudentName());
		}
		//实现双 y 轴，使用 yAxisIndex() 指定应用到哪个 y 轴
		bar.barCategoryGap("20").yAxisIndex(1);
		option.xAxis(categoryAxis);
		option.series(bar, line);
		return option.toString();
	}
	public static String createStudentExamLineJson(List<StudentExamInfo> examInfos) {
		GsonOption option = new GsonOption();
		option.title().text("学生考试试卷得分统计").x(X.center).y(Y.top).borderWidth(1).textStyle().color("#438EB9");
		option.toolbox().show(true).feature(Tool.mark, Tool.restore, new MagicType(Magic.bar, Magic.line), Tool.saveAsImage).x(X.right).y(Y.top);
		option.tooltip().show(true).formatter("{b} {c}分").trigger(Trigger.axis);
		option.legend().data("得分").x(X.center).y(Y.bottom);
		Line line = new Line("试卷得分");
		//值轴
		ValueAxis valueAxis = new ValueAxis();
		//设置y轴不出现小数值
		valueAxis.interval(1);
		valueAxis.axisLabel().formatter("{value} 分");
		option.yAxis(valueAxis);
		//类目轴
		CategoryAxis categoryAxis = new CategoryAxis();
		categoryAxis.axisLabel().interval(0).rotate(-30);
		
		for (StudentExamInfo studentExamInfo : examInfos) {
			line.data(studentExamInfo.getExamScore());
			categoryAxis.data(studentExamInfo.getExamPaperName());
		}
		option.xAxis(categoryAxis);
		option.series(line);
		System.out.println(option.toString());
		return option.toString();
	}
}
public class AdminHomeHandler {
	@Autowired
	ExamPaperInfoService examPaperInfoService;
	@Autowired
	SubjectInfoService subjectInfoService;
	@Autowired
	TeacherInfoService teacherInfoService;
	@Autowired
	StudentInfoService studentInfoService;
	@Autowired
	Gson gson;
	private Logger logger = Logger.getLogger(AdminHomeHandler.class);
	@RequestMapping("/homeInfo")
	public void homeInfo(HttpServletResponse response) throws IOException {
		logger.info("加载后台首页相关数据");
		int examPaperTotal = examPaperInfoService.getExamPpaerTotal();
		int subjectTotal = subjectInfoService.getSubjectTotal();
		int teacherTotal = teacherInfoService.getTeacherTotal();
		int studentTotal = studentInfoService.getStudentTotal();
		String json = "{\"examPaperTotal\":"+examPaperTotal+", " +
				"\"subjectTotal\":"+subjectTotal+", " +
				"\"teacherTotal\":"+teacherTotal+", " +
				"\"studentTotal\":"+studentTotal+"}";
		response.getWriter().print(json);
	}
}
public class ClassInfoHandler {
	@Autowired
	private ClassInfoService classInfoService;
	@Autowired
	private GradeInfoService gradeInfoService;
	@Autowired
	private TeacherInfoService teacherInfoService;
	@Autowired
	private TeacherInfo teacher;
	@Autowired
	private ClassInfo classInfo;
	@Autowired
	private Gson gson;
	private Logger logger = Logger.getLogger(ClassInfoHandler.class);
	@RequestMapping(value="/classes", method=RequestMethod.GET)
	public ModelAndView getClasses(@RequestParam(value="gradeId", required=false) Integer gradeId,
			@RequestParam(value="className", required=false) String className,
			@RequestParam(value="classId", required=false) Integer classId) {
		logger.info("获取班级集合 条件：gradeId： "+gradeId+", 班级编号："+classId+", 班级："+className);
		ModelAndView model = new ModelAndView();
		ClassInfo classInfo = new ClassInfo();
		/*处理查询条件*/
		if (gradeId != null) {
			GradeInfo gradeInfo = new GradeInfo();
			gradeInfo.setGradeId(gradeId);
			classInfo.setGrade(gradeInfo);
		}
		if (classId != null)
			classInfo.setClassId(classId);
		if (className != null) {
			if (className.trim() != "")
				classInfo.setClassName(className);
		}
		List<ClassInfo> classes = classInfoService.getClasses(classInfo);
		model.setViewName("admin/classes");
		model.addObject("classes", classes);
		return model;
	}
	@RequestMapping("/preAddClass")
	public ModelAndView preAddClass() {
		logger.info("预添加班级信息");
		ModelAndView model = new ModelAndView();
		//获取年级信息
		List<GradeInfo> grades = gradeInfoService.getGrades();
		model.setViewName("admin/classedit");
		model.addObject("grades", grades);
		//获取不是班主任的教师
		teacher.setIsWork(0);
		Map<String, Object> map = new HashMap<String, Object>();
		map.put("startIndex", null);
		map.put("pageShow", null);
		map.put("teacher", teacher);
		List<TeacherInfo> teachers = teacherInfoService.getTeachers(map);
		model.addObject("teachers", teachers);
		model.addObject("editClass", new ClassInfo());
		return model;
	}
	@RequestMapping(value="/class", method=RequestMethod.POST)
	public String isAddClass(ClassInfo classInfo, HttpServletRequest request) {
		logger.info("添加班级信息 "+classInfo);
		//修改教师班主任状态
		String returnMsg = isChangeTeacherWork(1, classInfo.getTeacher().getTeacherId());
		if (returnMsg != null) {
			request.setAttribute("error", "修改教师班主任状态 对应教师编号有误");
			return "error";
		}
		//添加
		int row = classInfoService.isAddClass(classInfo);
		if (row < 1) {
			logger.error("班级 "+classInfo+" 删除失败");
			request.setAttribute("error", "班级 "+classInfo.getClassName()+" 添加失败，请稍后再试！");
			return "../error";
		}
		return "redirect:/classes";
	}
	@RequestMapping(value="/del/class/{classId}", method=RequestMethod.DELETE)
	public String isDelClass(@PathVariable("classId") Integer classId, HttpServletRequest request) {
		logger.info("删除班级 "+classId);
		
		//将删除班级对于之前班主任改为 非班主任状态
		//需要在删除班级之前修改，如果先删除了班级，再根据班级获取教师编号，就不能获取
		ClassInfo delClass = classInfoService.getClassById(classId);
		String returnMsg = isChangeTeacherWork(0, delClass.getTeacher().getTeacherId());
		if (returnMsg != null) {
			request.setAttribute("error", "修改教师班主任状态 对应教师编号有误");
			return "error";
		}
		//删除
		int row = classInfoService.isDelClass(classId);
		if (row < 1) {
			logger.error("班级 "+classId+" 删除失败");
			request.setAttribute("error", "班级删除失败，请稍后再试！");
			return "../error";
		}
		return "redirect:/classes";
    }
	@RequestMapping(value="edit/class/{classId}", method=RequestMethod.GET)
	public ModelAndView preUpdateClass(@PathVariable("classId") Integer classId) {
		logger.info("预修改班级处理");
		ModelAndView model = new ModelAndView();
		//获取要修改班级
		ClassInfo classInfo = classInfoService.getClassById(classId);
		model.setViewName("/admin/classedit");
		model.addObject("editClass", classInfo);
		List<GradeInfo> grades = gradeInfoService.getGrades();
		//获取不是班主任的教师
		teacher.setIsWork(0);
		Map<String, Object> map = new HashMap<String, Object>();
		map.put("startIndex", null);
		map.put("pageShow", null);
		map.put("teacher", teacher);
		List<TeacherInfo> teachers = teacherInfoService.getTeachers(map);
		//如果没有可用班主任
		if (teachers.size() == 0 || teachers == null) {
			teacher.setTeacherId(classInfo.getTeacher().getTeacherId());
			teacher.setTeacherName("暂无剩余教师");
			teachers.add(teacher);
		}
		model.addObject("teachers", teachers);
		model.addObject("grades", grades);
		return model;
	}
	@RequestMapping(value="edit/class/class", method=RequestMethod.PUT)
	public String isUpdateClass(ClassInfo classInfo, HttpServletRequest request, 
			@RequestParam(value="lastTeacher", required=false) Integer lastTeacherId) {
		//修改上一教师不为班主任状态
		if (lastTeacherId != null) {
			String returnMsg = isChangeTeacherWork(0, lastTeacherId);
			if (returnMsg != null) {
				request.setAttribute("error", "修改教师班主任状态 对应教师编号有误");
				return "/error";
			}
		}
		//修改当前教师为班主任状态
		String returnMsg = isChangeTeacherWork(1, classInfo.getTeacher().getTeacherId());
		if (returnMsg != null) {
			request.setAttribute("error", "修改教师班主任状态 对应教师编号有误");
			return "/error";
      }
		logger.info("修改班级 "+classInfo);
		
		int row = classInfoService.isUpdateClass(classInfo);
		if (row < 1) {
			logger.error("班级 "+classInfo+" 修改失败");
			
			request.setAttribute("error", "班级修改失败，请稍后再试！");
			return "../error";
		}
		
		return "redirect:/classes";
	}
	@RequestMapping(value="/gradeclass/{gradeId}", method=RequestMethod.GET)
	public void getClassesByGradeId(@PathVariable("gradeId") Integer gradeId,
			HttpServletResponse response) throws IOException {
		logger.info("获取年级 "+gradeId+" 下的班级集合");
		
		List<ClassInfo> classes = classInfoService.getClassByGradeId(gradeId);
		
		String json = gson.toJson(classes);
		response.getWriter().print(json);
	}
isChangeTeacherWork(int status, Integer teacherId) {
		logger.info("修改教师 "+teacherId+" 的状态为 "+status);
		teacher.setIsWork(status);
		if (teacherId == null) {
			logger.error("修改教师班主任状态 对应教师编号有误");
			return "修改教师班主任状态 对应教师编号有误";
		}
		teacher.setTeacherId(teacherId);
		int row = teacherInfoService.updateTeacherIsWork(teacher);
		return null;
	}
	@RequestMapping("/stuCount")
	public void getStudentCountForClass(
			@RequestParam(value="gradeId", required=false) Integer gradeId,
			HttpServletResponse response) throws IOException {
		Map<String, Object> map = classInfoService.getStudentCountForClass(gradeId);
		String json = StudentCount.createBarJson(map);
		response.getWriter().print(json);
	}
	@RequestMapping("/preStudentCount")
	public ModelAndView preStudentCount() {
		ModelAndView model = new ModelAndView();
		//获取年级信息
		List<GradeInfo> grades = gradeInfoService.getGrades();
		model.setViewName("admin/charts/studentCount");
		model.addObject("grades", grades);
		return model;
	}
}
public class CourseInfoHandler {
	@Autowired
	private CourseInfoService courseInfoService;
	@Autowired
	private GradeInfoService gradeInfoService;
	
	private Logger logger = Logger.getLogger(CourseInfoHandler.class);
	
	/**
	 * 获取科目信息
	 * @param gradeId 年级编号
	 * @param division 分科情况
	 * @return
	 */
	@RequestMapping("/courses")
	public ModelAndView getCourses(@RequestParam(value="gradeId", required=false) Integer gradeId,
			@RequestParam(value="division", required=false) Integer division) {
		logger.info("获取科目集合 年级条件 "+gradeId+" 分科条件 "+division);
		ModelAndView model = new ModelAndView();
		model.setViewName("/admin/courses");
		
		CourseInfo course = new CourseInfo();
		if (gradeId != null)
			course.getGrade().setGradeId(gradeId);
		if (division != null)
			course.setDivision(division);
		List<CourseInfo> courses = courseInfoService.getCourses(course);
		model.addObject("courses", courses);
		
		return model;
	}
	
	/**
	 * 根据科目编号获取学科信息
	 * @param courseId 科目编号
	 * @return
	 */
	@RequestMapping("/course/{courseId}")
	public ModelAndView getCourseById(@PathVariable("courseId") Integer courseId) {
		logger.info("获取科目信息 科目编号 "+courseId);
		ModelAndView model = new ModelAndView();
		model.setViewName("/admin/courseedit");
		
		CourseInfo course = courseInfoService.getCourseById(courseId);
		model.addObject("course", course);
		/** 获取所有年级列表 */
		List<GradeInfo> grades = gradeInfoService.getGrades();
		model.addObject("grades", grades);
		
		return model;
	}
	
	/**
	 * 添加/修改科目信息
	 * @param courseId 科目编号
	 * @param isUpdate 标识是否为修改操作
	 * @param courseName 科目名称
	 * @param division 分科情况
	 * @param gradeId 年级编号
	 * @return
	 */
	@RequestMapping(value="/course/course", method=RequestMethod.POST)
	public String isUpdateOrAddCourse(@RequestParam(value="courseId", required=false) Integer courseId,
			@RequestParam(value="isupdate", required=false) Integer isUpdate,
			@RequestParam("courseName") String courseName,
			@RequestParam("division") Integer division,
			@RequestParam("gradeId") Integer gradeId) {
		
		CourseInfo course = new CourseInfo();
			course.setCourseId(courseId);
			course.setCourseName(courseName);
			course.setDivision(division);
			GradeInfo grade = new GradeInfo();
			grade.setGradeId(gradeId);
			course.setGrade(grade);
		
		//修改
		if (isUpdate != null) {
			logger.info("修改科目 "+course+" 的信息");
			int row = courseInfoService.isUpdateCourse(course);			
		}
		//添加
		else {
			logger.info("添加科目 "+course+" 的信息");
			int row = courseInfoService.isAddCourse(course);
		}
		
		return "redirect:/courses";
	}
	
	/**
	 * 删除科目
	 * @param courseId 待删除科目编号
	 * @return
	 */
	@RequestMapping(value="/course/{courseId}", method=RequestMethod.DELETE)
	public String isDelTeacher(@PathVariable("courseId") Integer courseId) {
		logger.info("删除科目 "+courseId);
		
		int row = courseInfoService.isDelCourse(courseId);
		
		return "redirect:/courses";
	}
	
	/**
	 * 预添加科目信息
	 * @return
	 */
	@RequestMapping("/preAddCourse")
	public ModelAndView preAddCourse() {
		logger.info("预添加科目信息");
		ModelAndView model = new ModelAndView();
		model.setViewName("/admin/courseedit");
		/** 获取年级集合 */
		List<GradeInfo> grades = gradeInfoService.getGrades();
		model.addObject("grades", grades);
		
		return model;
	}
}
public class ExamChooseInfoHandler {
	
	@Autowired
	private ExamChooseInfoService examChooseInfoService;
	@Autowired
	private ExamChooseInfo examChoose;

	private Logger logger = Logger.getLogger(ExamChooseInfoHandler.class);
	
	/**
	 * 记录考生考试选择答案
	 * @param studentId 考生编号
	 * @param examPaperId 考试试卷编号
	 * @param subjectId 当前选择试题编号
	 * @param index 前台控制索引
	 * @param chooseAswer 选择答案
	 * @param response
	 * @throws IOException
	 */
	@RequestMapping(value="/choose", method=RequestMethod.POST)
	public void examChooseHandler(
			@RequestParam("studentId") Integer studentId,
			@RequestParam("examPaperId") Integer examPaperId,
			@RequestParam("subjectId") Integer subjectId,
			@RequestParam(value="index", required=false) Integer index,
			@RequestParam("chooseAswer") String chooseAswer,
			HttpServletResponse response) throws IOException {
		logger.info("考生 "+studentId+" 在试卷 "+examPaperId+" 中试题 "+subjectId+" 选择了答案 "+chooseAswer+" 序号 "+index);
		
		//判断该考生是否已经选择过该试题
		Map<String, Object> map = new HashMap<String, Object>();
		map.put("studentId", studentId);
		map.put("examPaperId", examPaperId);
		map.put("subjectId", subjectId);
		examChoose = examChooseInfoService.getChooseWithIds(map);
		logger.info("考生是否选择过试题 "+subjectId+" "+examChoose+" (NULL-否)");
		if (examChoose == null) {
			logger.info("考生 "+studentId+" 尚未选择试题 "+subjectId+" 添加选择记录 答案 "+chooseAswer);
			map.put("chooseResult", chooseAswer);
			/** 添加选择记录 */
			examChooseInfoService.addChoose(map);
		} else if (examChoose.getChooseId() != null && examChoose != null) {
			logger.info("考生 "+studentId+" 已经选择试题 "+subjectId+" 修改选择记录 答案 "+examChoose.getChooseResult()+" 更新为 "+chooseAswer);
			/*
			 * 如果选择了和上次相同的答案，则不做修改操作
			 * 优化 -- 前台判断选择了相同答案则不发出请求
			 */
			if(!chooseAswer.equals(examChoose.getChooseResult())) {
				examChoose.setChooseResult(chooseAswer);
				/** 当前选择答案和之前选择答案不同 修改答案记录 */
				examChooseInfoService.updateChooseWithIds(examChoose);
			} else {
				logger.info("考生选择了相同答案，不做修改操作");
			}
		} else {
			response.getWriter().print("f");
			return;
		}
		
		response.getWriter().print("t");
	}
}
public class ExamHistoryInfoHandler {

	@Autowired
	private ExamHistoryPaperService examHistoryPaperService;
	
	private Logger logger = Logger.getLogger(ExamHistoryInfoHandler.class);
	
	
	@RequestMapping("/historys")
	public ModelAndView examHistorys() {
		List<ExamHistoryInfo> historys = examHistoryPaperService.getExamHistoryToTeacher();
		ModelAndView model = new ModelAndView("admin/examHistorys");
		logger.info("教师 查询历史考试信息 SIZE "+historys.size());
		
		model.addObject("historys", historys);
		
		return model;
	}
}
public class ExamPaperInfoHandler {

	@Autowired
	private ExamPaperInfoService examPaperInfoService;
	@Autowired
	private GradeInfoService gradeInfoService;
	@Autowired
	private GradeInfo grade;
	@Autowired
	private ExamPaperInfo examPaper;
	
	private Logger logger = Logger.getLogger(ExamPaperInfoHandler.class);
	
	
	/**
	 * 获取试卷信息
	 * @param gradeId 年级编号
	 * @param startPage 起始页 默认第一页
	 * @param pageShow 页容量 默认10
	 * @return
	 */
	@RequestMapping("/examPapers")
	public ModelAndView getCourses(@RequestParam(value = "gradeId", required = false) Integer gradeId,
			@RequestParam(value="startPage", required=false, defaultValue="1") Integer startPage,
			@RequestParam(value="pageShow", required=false, defaultValue="10") Integer pageShow ) {
		logger.info("获取试卷集合  gradeId="+gradeId+", startPage="+startPage+", pageShow="+pageShow);
		ModelAndView model = new ModelAndView();
		model.setViewName("/admin/examPapers");

		if (gradeId != null) {
			grade.setGradeId(gradeId);
			examPaper.setGrade(grade);
		}
		
		Map<String, Object> map = new HashMap<String, Object>();
		//计算当前查询起始数据索引
		int startIndex = (startPage-1) * pageShow;
		map.put("examPaper", examPaper);
		map.put("startIndex", startIndex);
		map.put("pageShow", pageShow);
		List<ExamPaperInfo> examPapers = examPaperInfoService.getExamPapers(map);
		model.addObject("examPapers", examPapers);
		
		//获取试卷总量
		int examPaperTotal = examPaperInfoService.getExamPpaerTotal();
		//计算总页数
		int pageTotal = 1;
		if (examPaperTotal % pageShow == 0)
			pageTotal = examPaperTotal / pageShow;
		else
			pageTotal = examPaperTotal / pageShow + 1;			
		model.addObject("pageTotal", pageTotal);
		model.addObject("pageNow", startPage);

		return model;
	}

	/**
	 * 根据编号获取试卷信息
	 * @param examPaperId 试卷编号
	 * @return
	 */
	@RequestMapping("/examPaper/{examPaperId}")
	public ModelAndView getCourseById(@PathVariable("examPaperId") Integer examPaperId) {
		logger.info("获取试卷 " + examPaperId);
		ModelAndView model = new ModelAndView();
		model.setViewName("/admin/examPaperedit");

		ExamPaperInfo paper = examPaperInfoService.getExamPaper(examPaperId);
		model.addObject("examPaper", paper);
		List<GradeInfo> grades = gradeInfoService.getGrades();
		model.addObject("grades", grades);

		return model;
	}

	/**
	 * 添加/修改试卷信息
	 * @param examPaperId 待操作试卷编号
	 * @param isUpdate 标识是否为修改操作
	 * @param examPaperName 试卷名称
	 * @param subjectNum 试卷试题数量
	 * @param examPaperScore 试卷总分
	 * @param examPaperTime 试卷规定考试时间
	 * @param division 分科情况
	 * @param examPaperEasy 难易程度
	 * @param gradeId 年级编号
	 * @return
	 */
	@RequestMapping(value = "/examPaper/examPaper", method = RequestMethod.POST)
	public String isUpdateOrAddCourse(
			@RequestParam(value = "examPaperId", required = false) Integer examPaperId,
			@RequestParam(value = "isupdate", required = false) Integer isUpdate,
			@RequestParam(value = "examPaperName", required = false) String examPaperName,
			@RequestParam("subjectNum") Integer subjectNum,
			@RequestParam("examPaperScore") Integer examPaperScore,
			@RequestParam("examPaperTime") Integer examPaperTime,
			@RequestParam("division") Integer division,
			@RequestParam("examPaperEasy") Integer examPaperEasy,
			@RequestParam("gradeId") Integer gradeId) {

		examPaper.setExamPaperId(examPaperId);
		examPaper.setExamPaperName(examPaperName);
		examPaper.setSubjectNum(subjectNum);
		examPaper.setExamPaperScore(examPaperScore);
		examPaper.setExamPaperTime(examPaperTime);
		examPaper.setDivision(division);
		examPaper.setExamPaperEasy(examPaperEasy);
		grade.setGradeId(gradeId);
		examPaper.setGrade(grade);

		if (isUpdate != null) {
			logger.info("修改试卷 " + examPaper + " 的信息");
			int row = examPaperInfoService.isUpdateExamPaper(examPaper);
		} else {
			logger.info("添加试卷 " + examPaper + " 的信息");
			int row = examPaperInfoService.isAddExamPaper(examPaper);
		}

		return "redirect:/examPapers";
	}

	/**
	 * 删除试卷
	 * @param examPaperId 待删除试卷编号
	 * @return
	 */
	@RequestMapping(value = "/examPaper/{examPaperId}", method = RequestMethod.DELETE)
	public String isDelTeacher(@PathVariable("examPaperId") Integer examPaperId) {
		logger.info("删除试卷 " + examPaperId);

		int row = examPaperInfoService.isDelExamPaper(examPaperId);

		return "redirect:/examPapers";
	}

	/**
	 * 预添加试卷
	 * @return
	 */
	@RequestMapping("/preAddExamPaper")
	public ModelAndView preAddStudent() {
		logger.info("预添加试卷信息");
		ModelAndView model = new ModelAndView();
		model.setViewName("/admin/examPaperedit");
		List<GradeInfo> grades = gradeInfoService.getGrades();
		model.addObject("grades", grades);

		return model;
	}
}
public class ExamPlanInfoHandler {

	@Autowired
	private ExamPlanInfoService examPlanInfoService;
	@Autowired
	private ClassInfoService classInfoService;
	@Autowired
	private CourseInfoService courseInfoService;
	@Autowired
	private ExamPaperInfoService examPaperInfoService;
	@Autowired
	private ExamPaperInfo examPaper;
	@Autowired
	private GradeInfo grade;
	
	private Logger logger = Logger.getLogger(ExamPlanInfoHandler.class);
	
	
	/**
	 * 获取所有待考记录
	 * @return
	 */
	@RequestMapping("/examPlans")
	public ModelAndView getExamPlans() {
		ModelAndView model = new ModelAndView();
		model.setViewName("admin/examPlans");
		logger.info("获取待考考试信息");
		
		List<ExamPlanInfo> examPlans = examPlanInfoService.getExamPlans(null);
		model.addObject("examPlans", examPlans);
		
		return model;
	}
	
	
	/**
	 * 预添加
	 * @return
	 */
	@RequestMapping("/preAddep")
	public ModelAndView preAddep() {
		ModelAndView model = new ModelAndView();
		model.setViewName("admin/examPlanedit");
		
		//获取所有班级信息
		List<ClassInfo> classes = classInfoService.getClasses(null);
		model.addObject("classes", classes);
		//获取所有科目信息
		List<CourseInfo> courses = courseInfoService.getCourses(null);
		model.addObject("courses", courses);
		//获取所有的试卷信息 -- 纯净的
		List<ExamPaperInfo> examPapers = examPaperInfoService.getExamPapersClear();
		model.addObject("examPapers", examPapers);
		
		return model;
	}

	/**
	 * 添加待考信息
	 * @param examPlan 考试安排记录信息
	 * @return
	 */
	@RequestMapping(value="examPlan", method=RequestMethod.POST)
	public String isAddExamPlan(ExamPlanInfo examPlan) {
		logger.info("添加待考记录："+examPlan);
		examPlanInfoService.isAddExamPlan(examPlan);
		
		return "redirect:examPlans";
	}
	
	
	/**
	 * 预修改
	 * @param examPlanId 考试安排(待考)编号
	 * @return
	 */
	@RequestMapping(value="/preUpdateep/{examPlanId}", method=RequestMethod.GET)
	public ModelAndView preUpdateep(@PathVariable("examPlanId") Integer examPlanId) {
		ModelAndView model = new ModelAndView();
		model.setViewName("/admin/examPlanedit");
		
		//获取所有班级信息
		List<ClassInfo> classes = classInfoService.getClasses(null);
		model.addObject("classes", classes);
		//获取所有科目信息
		List<CourseInfo> courses = courseInfoService.getCourses(null);
		model.addObject("courses", courses);
		//获取所有的试卷信息 -- 纯净的(简单的)
		List<ExamPaperInfo> examPapers = examPaperInfoService.getExamPapersClear();
		model.addObject("examPapers", examPapers);
		//获取当前修改对象
		ExamPlanInfo examPlanWithUpdate = examPlanInfoService.getExamPlanById(examPlanId);
		logger.info("获取要修改的待考记录："+examPlanWithUpdate);
		model.addObject("examPlan", examPlanWithUpdate);
		
		return model;
	}
	
	
	/**
	 * 修改待考信息
	 * @param examPlan 待考记录
	 * @return
	 */
	@RequestMapping(value="preUpdateep/examPlan", method=RequestMethod.PUT)
	public String isUpdateExamPlan(ExamPlanInfo examPlan) {
		logger.info("修改待考记录："+examPlan);
		examPlanInfoService.isUpdateExamPlan(examPlan);
		
		return "redirect:../examPlans";
	}
	
	
	/**
	 * 查询学生待考信息
	 * @param classId 学生所在班级编号
	 * @param gradeId 学生所在年级百年好
	 * @param studentId 学生编号
	 * @return
	 */
	@RequestMapping("/willexams")
	public ModelAndView getStudentWillExam(
			@RequestParam("classId") Integer classId,
			@RequestParam("gradeId") Integer gradeId,
			@RequestParam(value="studentId", required=false) Integer studentId) {
		logger.info("查询学生 "+studentId+"(NULL-未指定)待考信息 班级："+classId+", 年级："+gradeId);
		ModelAndView model = new ModelAndView();
		model.setViewName("/reception/examCenter");
		Map<String, Object> map = new HashMap<String, Object>();
		map.put("classId", classId);
		map.put("gradeId", gradeId);
		
		List<ExamPlanInfo> examPlans = examPlanInfoService.getStudentWillExam(map);
		model.addObject("examPlans", examPlans);
		model.addObject("gradeId", gradeId);
		
		return model;
	}
	
	
	
	/**
	 * 定时刷新考试安排记录，将过期考试移除
	 * 周一至周五 每隔15分钟刷新一次
	 */
	@Scheduled(cron="0 */15 * * * MON-FRI")
	public void refreshExamPlan() {
		List<ExamPlanInfo> examPlans = examPlanInfoService.getExamPlans(null);
		logger.info("刷新待考记录, SIZE "+examPlans.size());
		if (examPlans.size() > 0) {
			for (ExamPlanInfo examPlanInfo : examPlans) {
				String beginTime = examPlanInfo.getBeginTime();
				int examPaperTime = examPlanInfo.getExamPaper().getExamPaperTime();
				/** 验证是否可移除 */
				if (validateExamPaerBeOverdue(beginTime, examPaperTime)) {
					logger.info("待考试卷 "+examPlanInfo.getExamPaper().getExamPaperId()+" 已经过期，即将移除");
					//移除过期考试安排
					int row = examPlanInfoService.isRemoveExamPlan(examPlanInfo.getExamPlanId());
				} else {
					logger.info("待考试卷 "+examPlanInfo.getExamPaper().getExamPaperId()+" 暂未过期，无法移除");
					continue;
				}
			} 
		}
	}
	
	
	/**
	 * 验证试卷是否过期
	 * @param beginTime 考试开始时间
	 * @param examTime 考试时间
	 * @return
	 */
	private boolean validateExamPaerBeOverdue(String beginTime, int examTime) {
		boolean flag = false;
		try {
			SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
			Date beginTimeDate = sdf.parse(beginTime);
			Long beginTimeTime = beginTimeDate.getTime();
			
			/** 转换考试时间为毫秒单位 */
			int examTimeSecond = examTime * 60 * 1000;
			
			Date nowDate = new Date();
			Long nowDateTime = nowDate.getTime();
			
			/** 当前时间超过了 考试结束时间，即为过期记录 */
			if(nowDateTime > (beginTimeTime+examTimeSecond)) {
				flag = true;
			}
		} catch (ParseException e) {
			e.printStackTrace();
		}
		
		return flag;
	}
	
	
	/**
	 * 教师移除考试安排记录
	 * @param examPlanId
	 * @return
	 */
	@RequestMapping(value="/del/{examPlanId}")
	public String isDelExamPlan(
			@PathVariable("examPlanId") Integer examPlanId) {
		logger.info("教师 移除考试安排 "+examPlanId);
		
		int row = examPlanInfoService.isRemoveExamPlan(examPlanId);
		
		return "redirect:../examPlans";
	}
}
public class ExamSubjectMiddleInfoHandler {

	@Autowired
	private ExamSubjectMiddleInfoService esmService;
	@Autowired
	private ExamPaperInfoService examPaperInfoService;
	@Autowired
	private SubjectInfoService subjectInfoService;
	@Autowired
	private ExamSubjectMiddleInfo esm;
	@Autowired
	private ExamPaperInfo examPaper;
	@Autowired
	private SubjectInfo subject;
	@Autowired
	private CourseInfo course;
	@Autowired
	private GradeInfo grade;
	@Autowired
	private Gson gson;
	
	private Logger logger = Logger.getLogger(ExamSubjectMiddleInfoHandler.class);
	
	
	/**
	 * 查询试卷-试题信息
	 * 根据多条件查询
	 * @param examPaperId 试卷编号
	 * @param courseName 科目名称
	 * @param courseId 科目百年好
	 * @param gradeId 年级编号
	 * @param response
	 * @throws IOException
	 */
	@RequestMapping(value="/getESM", method={RequestMethod.GET, RequestMethod.POST})
	public void getExamPaperWithSubject(
			@RequestParam(value="examPaperId", required=false) Integer examPaperId,
			@RequestParam(value="courseName", required=false) String courseName,
			@RequestParam(value="courseId", required=false) Integer courseId,
			@RequestParam(value="gradeId", required=false) Integer gradeId,
			HttpServletResponse response) throws IOException {
		ModelAndView model = new ModelAndView();
		
		/*条件处理*/
		if (examPaperId != null) examPaper.setExamPaperId(examPaperId);
		if (courseName != null) course.setCourseName(courseName);
		if (courseId != null) course.setCourseId(courseId);
		if (gradeId != null) grade.setGradeId(gradeId);
		subject.setCourse(course);
		subject.setGrade(grade);
		
		esm.setExamPaper(examPaper);
		esm.setSubject(subject);
		
		logger.info("查询试卷试题信息 With "+esm);
		List<ExamSubjectMiddleInfo> esms = esmService.getExamPaperWithSubject(esm);
		
		response.getWriter().print(gson.toJson(esms));
	}
	
	/**
	 * 手动添加试题
	 * 手动将选择的试题添加到指定试卷中  -- 正式添加处理
	 * @param examPaperId 试卷编号
	 * @param session
	 * @param response
	 * @throws Exception
	 */
	@RequestMapping(value="/handAdd", method={RequestMethod.GET, RequestMethod.POST})
	public void isHandAddSubjectToExamPaper(
			@RequestParam(value="examPaperId") Integer examPaperId,
			HttpSession session,
			HttpServletResponse response) throws Exception {
		//添加试题总分统计
		int scoreSum = 0;
		//添加试题总量统计
		int subjectSum = 0;
		Map<String, Object> map = new HashMap<String, Object>();
		map.put("examPaperId", examPaperId);
		ArrayList<Integer> subjectIds = new ArrayList<Integer>();
		
		//试题信息
		List<String> ids = (List<String>) session.getAttribute("ids");
		if (ids != null) {
			for (String is : ids) {
				//分割试题编号和分数
				String[] idAndScore = is.split(",");
				subjectIds.add(Integer.parseInt(idAndScore[0]));
				//累加试题分数
				scoreSum += Integer.parseInt(idAndScore[1]);
				//累加试题数量
				subjectSum += 1;
			}
			/** 需要添加试题集合 */
			map.put("subjectIds", subjectIds);
		} else {
			logger.error("试题集合为空，不能进行添加试题操作！");
			response.getWriter().print("需要添加的试题为空，操作失败！");
			return;
		}
		logger.info("添加试题集合到试卷 "+examPaperId);
		//总分和题目数量信息
		Map<String, Object> scoreWithNum = new HashMap<String, Object>();
		scoreWithNum.put("subjectNum", subjectSum);
		scoreWithNum.put("score", scoreSum);
		scoreWithNum.put("examPaperId", examPaperId);
		/** 修改试卷总分 */
		examPaperInfoService.isUpdateExamPaperScore(scoreWithNum);
		/** 修改试卷试题总量 */
		examPaperInfoService.isUpdateExamPaperSubjects(scoreWithNum);
		
		/** 添加试题到试卷中 */
		esmService.isAddESM(map);
		
		response.getWriter().print("试题已成功添加到试卷中！");
	}
	
	
	/**
	 * 手动添加试题到试卷时 向 Session中存入试题信息
	 * @param subjectId 试题编号
	 * @param examPaperId 试卷编号
	 * @param score 试题分数
	 * @param handle 操作标识, 自动 OR 手动
	 * @param session
	 * @param response
	 * @throws IOException
	 */
	@RequestMapping("/getChooseSubId")
	public void getChooseSubjectId(
			@RequestParam("subjectId") Integer subjectId,
			@RequestParam("examPaperId") Integer examPaperId,
			@RequestParam("score") Integer score,
			@RequestParam(value="handle", required=false) Integer handle,
			HttpSession session, HttpServletResponse response) throws IOException {
		List<String> ids = null;
		/*
		 * 添加到 Session 中需先判断该试题是否已经存在该试卷中
		 * 如果存在，则不进行添加；反之添加
		 */
		examPaper.setExamPaperId(examPaperId);
		subject.setSubjectId(subjectId);
		esm.setExamPaper(examPaper);
		esm.setSubject(subject);
		/** 验证添加记录 是否已经存在 */
		Integer esmId = esmService.getEsmByExamIdWithSubjectId(esm);
		if (esmId == null) {
			logger.error("需要添加的试题 "+subjectId+" 暂不存在试卷 "+examPaperId+" 中，可进行添加");
			ids = (List<String>) session.getAttribute("ids");
			
			/** Session 记录非空验证 */
			if (subjectId != null && score != null) {
				//第一次添加
				if (ids == null) {
					ids = new ArrayList<String>();
					ids.add((subjectId+","+score));
					logger.info("Session 添加试题：是否手动"+handle+", 试题编号："+subjectId+", 试题分数"+score);
				} else {
					//存在就移除,反之添加
					if (ids.contains((subjectId+","+score))) {
						ids.remove((subjectId+","+score));
						logger.info("Session 移除试题：是否手动"+handle+", 试题编号："+subjectId+", 试题分数"+score);
					} else {
						ids.add((subjectId+","+score));
						logger.info("Session 添加试题：是否手动"+handle+", 试题编号："+subjectId+", 试题分数"+score);
					}
				}
			} else {
				logger.error("添加试题 "+subjectId+" 到 Session 失败");
				response.getWriter().print("添加失败，试题编号或试题分数异常！");
				return;
			}
		} else {
			logger.error("需要添加的试题 "+subjectId+" 已经存在试卷 "+examPaperId+" 中了, 无法进行添加");
			//同时返回添加失败的题号，用于前台方便移除选中
			response.getWriter().print("f-exists-"+subjectId);
			return;
		}
		
		session.setAttribute("ids", ids);
		
		response.getWriter().print("编号为 "+subjectId+" 的试题添加成功");
	}
	
	/**
	 * 清空Session中保存的试题编号集合
	 * @param session
	 * @return
	 */
	@RequestMapping("/clearSubjectIdsWithSession")
	public String isClearChooseSubjectIds(HttpSession session) {
		logger.info("清空 Session 中需要添加的试题编号集合");
		session.removeAttribute("ids");
		
		return "redirect:examPapers";
	}
	
	
	/**
	 * 从试卷中移除试题
	 * @param subjectId 试题编号
	 * @param examPaperId 试卷百年好
	 * @param score 试题分数
	 * @param response
	 * @throws IOException
	 */
	@RequestMapping(value="/removeSubjectFromPaper", method={RequestMethod.GET, RequestMethod.POST})
	public void removeSubjectWithExamPaper(
			@RequestParam("subjectId") Integer subjectId,
			@RequestParam("examPaperId") Integer examPaperId,
			@RequestParam("score") Integer score,
			HttpServletResponse response) throws IOException {
		logger.info("从试卷 "+examPaperId+" 中移除试题 "+subjectId+"，试题分值："+score);
		
		Map<String, Object> map = new HashMap<String, Object>();
		map.put("subjectNum", (-1));
		map.put("score", (-score));
		map.put("examPaperId", examPaperId);
		map.put("subjectId", subjectId);
		//修改试卷总分
		examPaperInfoService.isUpdateExamPaperScore(map);
		//修改试卷题目数量
		examPaperInfoService.isUpdateExamPaperSubjects(map);
		
		//从试卷中移除试题
		esmService.removeSubjectWithExamPaper(map);
		
		response.getWriter().print("t");
	}
	
	
	/**
	 * 自动生成试题到试卷
	 * @param examPaperId 试卷编号
	 * @param subjectEasy 试题难易程度
	 * @param courseId 科目编号
	 * @param gradeId 年级编号
	 * @param subjectSum 生成试题数量
	 * @param response
	 * @throws IOException
	 */
	@RequestMapping("/autoAddSubject")
	public void isAutoAddSubjectToExamPaper(
			@RequestParam(value="examPaperId") Integer examPaperId,
			@RequestParam(value="subjectEasy", required=false) Integer subjectEasy,
			@RequestParam(value="courseId", required=false) Integer courseId,
			@RequestParam(value="gradeId", required=false) Integer gradeId,
			@RequestParam("subjectSum") Integer subjectSum,
			HttpServletResponse response) throws IOException {
		Random random = new Random();
		
		/*生成条件处理*/
		if (subjectEasy != null) {
			subject.setSubjectEasy(subjectEasy);
		}
		if (courseId != null) {
			course.setCourseId(courseId);
			subject.setCourse(course);
		}
		if (gradeId != null) {
			grade.setGradeId(gradeId);
			subject.setGrade(grade);
		}
		
		
		Map<String, Object> map = new HashMap<String, Object>();
		map.put("subject", subject);
		map.put("startIndex", null);
		map.put("pageShow", null);
		
		List<SubjectInfo> subjects = subjectInfoService.getSubjects(map);
		int subjectTotal = subjects.size()-1;
		
		Map<String, Object> addMap = new HashMap<String, Object>();
		ArrayList<Integer> indexs = new ArrayList<Integer>();
		ArrayList<Integer> subjectIds = new ArrayList<Integer>();
		
		//添加试题总分
		int score = 0;
		for (int i=0; i<subjectSum; i++) {
			//产生随机索引
			int index = random.nextInt(subjectTotal);
			if (indexs.contains(index)) {  //随机索引已经存在
				i--;
				continue;
			} else {
				indexs.add(index);
				int subjectId = subjects.get(index).getSubjectId();
				subjectIds.add(subjectId);
				score += subjects.get(index).getSubjectScore();
				logger.info("索引 "+index+" 试题编号 "+subjectId+" 成立");
			}
		}
		
		//添加试题信息
		addMap.put("examPaperId", examPaperId);
		addMap.put("subjectIds", subjectIds);
		
		//总分和题目数量信息
		Map<String, Object> scoreWithNum = new HashMap<String, Object>();
		scoreWithNum.put("subjectNum", subjectSum);
		scoreWithNum.put("score", score);
		scoreWithNum.put("examPaperId", examPaperId);
		//修改试卷总分
		examPaperInfoService.isUpdateExamPaperScore(scoreWithNum);
		//修改试卷题目数量
		examPaperInfoService.isUpdateExamPaperSubjects(scoreWithNum);
		
		//添加
		logger.info("添加试题到试卷 "+examPaperId);
		esmService.isAddESM(addMap);
		
		response.getWriter().print("t");
	}
}
public class GradeInfoHandler {

	@Autowired
	@Qualifier("gson")
	private Gson gson;
	@Autowired
	private GradeInfoService gradeInfoService;
	
	private Logger logger = Logger.getLogger(GradeInfoHandler.class);
	
	/**
	 * 获取所有年级集合
	 * @return
	 */
	@RequestMapping(value="/grades")
	public ModelAndView getGrades() {
		logger.info("获取所有年级");
		
		ModelAndView model = new ModelAndView();
		model.setViewName("admin/grades");
		//获取所有年级
		List<GradeInfo> grades = gradeInfoService.getGrades();
		model.addObject("grades", grades);
		
		return model;
	}
	
	
	/**
	 * 预添加年级处理
	 * @param map
	 * @return
	 */
	@RequestMapping("/preAddGrade")
	public String preAddGrade(Map<String, Object> map) {
		logger.info("年级添加预处理");
		
		map.put("grade", new GradeInfo());
		
		return "admin/gradeedit";
	}
	
	/**
	 * 添加年级
	 * @param grade
	 * @param request
	 * @return
	 */
	@RequestMapping(value="/grade", method=RequestMethod.POST)
	public String isAddGrade(GradeInfo grade, HttpServletRequest request) {
		logger.info("添加年级 "+grade);

		if (grade == null) {
			logger.error("年级 "+grade+" 为空");
			
			request.setAttribute("error", "年级添加失败，请稍后再试！");
			return "error";
		}
		int row = gradeInfoService.isAddGrade(grade);
		if (row < 1) {
			logger.error("年级添加失败");
			
			request.setAttribute("error", "年级添加失败，请稍后再试！");
			return "error";
		}
		
		return "redirect:grades";
	}
	
	/**
	 * 预修改年级处理
	 * @param gradeId 待修改年级编号
	 * @param map
	 * @return
	 */
	@RequestMapping(value="/grade/update/{gradeId}", method=RequestMethod.GET)
	public String preUpdateGrade(@PathVariable("gradeId") Integer gradeId,
			Map<String, Object> map) {
		logger.info("年级修改预处理");
		
		map.put("grade", gradeInfoService.getGradeById(gradeId));
		
		return "/admin/gradeedit";
	}
	
	/**
	 * 修改年级信息
	 * @param grade
	 * @param request
	 * @return
	 */
	@RequestMapping(value="/grade/update/grade", method=RequestMethod.PUT)
	public String isUpdateGrade(GradeInfo grade, HttpServletRequest request) {
		logger.info("修改年级 "+grade+" 的信息");
		
		int row = gradeInfoService.isUpdateGrade(grade);
		if (row < 1) {
			logger.error("年级修改失败");
			
			request.setAttribute("error", "年级修改失败，请稍后再试！");
			return "/error";
		}
		
		return "redirect:/grades";
	}
	
	/**
	 * 删除年级
	 * @param gradeId
	 * @param request
	 * @return
	 */
	@RequestMapping(value="grade/del/{gradeId}", method=RequestMethod.DELETE)
	public String isDelGrade(@PathVariable("gradeId") Integer gradeId, HttpServletRequest request) {
		logger.info("删除年级 "+gradeId);
		
		int row = gradeInfoService.isDelGrade(gradeId);
		if (row < 1) {
			logger.error("年级删除失败");
			
			request.setAttribute("error", "年级删除失败，请稍后再试！");
			return "/error";
		}
		
		return "redirect:/grades";
	}
}
public class StudentExamInfoHandler {

	@Autowired
	private StudentExamInfoService studentExamInfoService;
	@Autowired
	private ClassInfoService classInfoService;
	@Autowired
	private StudentInfoService studentInfoService;
	@Autowired
	private Gson gson;
	
	private Logger logger = Logger.getLogger(StudentExamInfoHandler.class);
	
	/**
	 * 所有学生考试信息 图表 Json 字符串生成
	 * @param teacherId
	 * @param response
	 * @throws IOException
	 */
	@RequestMapping("/examCount")
	public void getStudentExamCount(@RequestParam("tid") Integer teacherId, HttpServletResponse response) throws IOException {
		if (teacherId == null) {
			response.getWriter().print("TID-NULL");			
		} else {
			//获取当前班主任对应的班级
			ClassInfo classInfo = classInfoService.getClassByTeacherId(teacherId);
			//获取学生考试信息
			List<StudentExamInfo> stuExamInfos = studentExamInfoService.getStudentExamCountByClassId(classInfo.getClassId());
			
			response.getWriter().print(StudentExamInfoCharts.createExamCountBarJson(stuExamInfos));
		}
	}
	
	
	/**
	 * 获取班级中的所有学生
	 * @param teacherId
	 * @param response
	 * @throws IOException
	 */
	@RequestMapping("/stus")
	public void getStudentsByClassId(@RequestParam("tid") Integer teacherId, HttpServletResponse response) throws IOException {
		if (teacherId == null) {
			response.getWriter().print("TID-NULL");			
		} else {
			//获取当前班主任对应的班级
			ClassInfo classInfo = classInfoService.getClassByTeacherId(teacherId);
			//获取所有学生信息
			List<StudentInfo> stus = studentInfoService.getStudentsByClassId(classInfo.getClassId());
			
			response.getWriter().print(gson.toJson(stus));
		}
	}
	
	
	/**
	 * 班级下所有学生考试平均分等信息 图表 Json 生成
	 * @param teacherId
	 * @param response
	 * @throws IOException
	 */
	@RequestMapping("/avgcounts")
	public void getAllStudentAvgScoreCount(@RequestParam("tid") Integer teacherId, HttpServletResponse response) throws IOException {
		if (teacherId == null) {
			response.getWriter().print("TID-NULL");			
		} else {
			//获取当前班主任对应的班级
			ClassInfo classInfo = classInfoService.getClassByTeacherId(teacherId);
			//获取所有学生信息 平局分等信息
			List<StudentExamInfo> stuExamInfos = studentExamInfoService.getAllStudentAvgScoreCount(classInfo.getClassId());
			
			response.getWriter().print(StudentExamInfoCharts.createAvgCountLineJson(stuExamInfos));
		}
	}
	
	
	@RequestMapping("/stuexam")
	public void getStudentExamInfoById(@RequestParam("stuId") Integer studentId, HttpServletResponse response) throws IOException {
		//获取学生考试信息
		List<StudentExamInfo> stuExamInfos = studentExamInfoService.getStudentExamInfo(studentId);
		
		response.getWriter().print(StudentExamInfoCharts.createStudentExamLineJson(stuExamInfos));
	}
}
public class StudentInfoHandler {

	@Autowired
	private StudentInfoService studentInfoService;
	@Autowired
	private ClassInfoService classInfoService;
	@Autowired
	private ExamSubjectMiddleInfoService examSubjectMiddleInfoService;
	@Autowired
	private ExamHistoryPaperService examHistoryPaperService;
	@Autowired
	private ExamChooseInfoService examChooseInfoService;
	@Autowired
	private ExamSubjectMiddleInfo esm;
	@Autowired
	private ClassInfo classInfo;
	@Autowired
	private ExamPaperInfo examPaper;
	@Autowired
	private GradeInfo grade;
	@Autowired
	private StudentInfo student;
	
	@Autowired
	private ExamPaperInfoService examPaperInfoService;

	private Logger logger = Logger.getLogger(StudentInfoHandler.class);

	/**
	 * 获取学生集合
	 * @param studentId 学生编号
	 * @param classId 班级编号
	 * @param gradeId 年级编号
	 * @param startPage 起始页 default=1
	 * @param pageShow 页容量 default=10
	 * @return
	 */
	@RequestMapping("/students")
	public ModelAndView getCourses(@RequestParam(value = "studentId", required = false) Integer studentId,
			@RequestParam(value = "classId", required = false) Integer classId,
			@RequestParam(value = "gradeId", required = false) Integer gradeId,
			@RequestParam(value="startPage", required=false, defaultValue="1") Integer startPage,
			@RequestParam(value="pageShow", required=false, defaultValue="10") Integer pageShow ) {
		logger.info("获取学生集合  classId="+classId+", gradeId="+gradeId+", startPage="+startPage+", pageShow="+pageShow);
		ModelAndView model = new ModelAndView();
		model.setViewName("/admin/students");

		//查询条件处理
		StudentInfo student = new StudentInfo();
		if (studentId != null)
			student.setStudentId(studentId);
		if (classId != null) {
			classInfo.setClassId(classId);
			student.setClassInfo(classInfo);
		}
		if (gradeId != null) {
			grade.setGradeId(gradeId);
			student.setGrade(grade);
		}
		
		Map<String, Object> map = new HashMap<String, Object>();
		//计算当前查询起始数据索引
		int startIndex = (startPage-1) * pageShow;
		map.put("student", student);
		map.put("startIndex", startIndex);
		map.put("pageShow", pageShow);
		List<StudentInfo> students = studentInfoService.getStudents(map);
		model.addObject("students", students);
		
		//获取学生总量
		int studentTotal = studentInfoService.getStudentTotal();
		//计算总页数
		int pageTotal = 1;
		if (studentTotal % pageShow == 0)
			pageTotal = studentTotal / pageShow;
		else
			pageTotal = studentTotal / pageShow + 1;			
		model.addObject("pageTotal", pageTotal);
		model.addObject("pageNow", startPage);

		return model;
	}

	/**
	 * 根据编号获取学生信息
	 * @param studentId
	 * @return
	 */
	@RequestMapping("/student/{studentId}")
	public ModelAndView getCourseById(@PathVariable("studentId") Integer studentId) {
		logger.info("获取学生 " + studentId);
		ModelAndView model = new ModelAndView();
		model.setViewName("/admin/studentedit");

		StudentInfo student = studentInfoService.getStudentById(studentId);
		model.addObject("student", student);
		List<ClassInfo> classes = classInfoService.getClasses(null);
		model.addObject("classes", classes);

		return model;
	}

	/**
	 * 添加/修改学生信息
	 * @param studentId
	 * @param isUpdate 操作标识
	 * @param studentName
	 * @param studentAccount
	 * @param studentPwd
	 * @param classId
	 * @return
	 */
	@RequestMapping(value = "/student/student", method = RequestMethod.POST)
	public String isUpdateOrAddCourse(
			@RequestParam(value = "studentId", required = false) Integer studentId,
			@RequestParam(value = "isupdate", required = false) Integer isUpdate,
			@RequestParam(value = "studentName", required = false) String studentName,
			@RequestParam("studentAccount") String studentAccount,
			@RequestParam("studentPwd") String studentPwd,
			@RequestParam("classId") Integer classId) {

		StudentInfo student = new StudentInfo();
			student.setStudentId(studentId);
			student.setStudentName(studentName);
			student.setStudentAccount(studentAccount);
			student.setStudentPwd(studentPwd);
			classInfo.setClassId(classId);
			student.setClassInfo(classInfo);

		if (isUpdate != null) {
			logger.info("修改学生 " + student + " 的信息");
			int row = studentInfoService.isUpdateStudent(student);
		} else {
			logger.info("添加学生 " + student + " 的信息");
			int row = studentInfoService.isAddStudent(student);
		}

		return "redirect:/students";
	}

	/**
	 * 删除学生
	 * @param studentId
	 * @return
	 */
	@RequestMapping(value = "/student/{studentId}", method = RequestMethod.DELETE)
	public String isDelTeacher(@PathVariable("studentId") Integer studentId) {
		logger.info("删除学生 " + studentId);

		int row = studentInfoService.isDelStudent(studentId);

		return "redirect:/students";
	}

	/**
	 * 预添加学生
	 * @return
	 */
	@RequestMapping("/preAddStudent")
	public ModelAndView preAddStudent() {
		logger.info("预添加学生信息");
		ModelAndView model = new ModelAndView();
		model.setViewName("/admin/studentedit");
		List<ClassInfo> classes = classInfoService.getClasses(null);
		model.addObject("classes", classes);

		return model;
	}
	
	/**
	 * 学生考试登录验证
	 * 
	 * 此处验证并不合理 登录验证实现如下：
	 *   前台学生登录传入账户，后台根据账户获取学生密码
	 *   返回学生密码，前台登录焦点离开密码框使用 JavaScript 判断
	 * 
	 * @param studentAccount 学生登录账户
	 * @param response
	 * @throws IOException
	 */
	@RequestMapping("/validateLoginStudent")
	public void validateLoginStudent(@RequestParam("studentAccount") String studentAccount,
			HttpServletResponse response) throws IOException {
		logger.info("学生账户 "+studentAccount+"，尝试登录考试");
		
		//获取需要登录的学生对象
		StudentInfo student = studentInfoService.getStudentByAccountAndPwd(studentAccount);
		
		if (student == null) {
			logger.error("登录学生账户 "+studentAccount+" 不存在");
			response.getWriter().print("n");
		} else {
			logger.error("登录学生账户 "+studentAccount+" 存在");
			response.getWriter().print(student.getStudentPwd());
		}
	}
	
	/**
	 * 学生登录考试
	 * @param student 登录学生
	 * @param request
	 * @return
	 */
	@RequestMapping(value="/studentLogin", method=RequestMethod.POST)
	public ModelAndView studentLogin(StudentInfo student, HttpServletRequest request) {
		ModelAndView model = new ModelAndView();
		StudentInfo loginStudent = studentInfoService.getStudentByAccountAndPwd(student.getStudentAccount());
		logger.info("学生 "+loginStudent+" 有效登录");
		if(loginStudent == null || !student.getStudentPwd().equals(loginStudent.getStudentPwd())){
			model.setViewName("reception/suc");
			model.addObject("success", "密码错误");
			return model;
		}
		request.getSession().setAttribute("loginStudent", loginStudent);
		
		model.setViewName("reception/suc");
		model.addObject("success", "登录成功");
		
		return model;
	}
	
	/**
	 * 退出登录
	 * @param session
	 * @return
	 */
	@RequestMapping("/exit")
	public String studentClearLogin(HttpSession session) {
		StudentInfo studnet = (StudentInfo) session.getAttribute("loginStudent");
		logger.info("学生 "+studnet.getStudentName()+", 编号 "+studnet.getStudentId()+" 退出登录");
		session.removeAttribute("loginStudent");
		
		return "redirect:index.jsp";
	}
	
	/**
	 * 学生注册 验证当前账户是否被占用
	 * @param studentAccount 注册账户
	 * @param response
	 * @throws IOException
	 */
	@RequestMapping("/validateAccount")
	public void validateRegisterAccount(@RequestParam("studentAccount") String studentAccount,
			HttpServletResponse response) throws IOException {
		logger.info("验证学生账户 "+studentAccount+"，是否已被注册");
		
		StudentInfo student = studentInfoService.getStudentByAccountAndPwd(studentAccount);
		
		if (student == null) {
			logger.error("注册学生账户 "+studentAccount+" 可以注册");
			response.getWriter().print("t");
		} else {
			logger.error("注册学生账户 "+studentAccount+" 已被注册");
			response.getWriter().print("f");
		}
	}
	
	/**
	 * 学生注册
	 * @param studentName
	 * @param studentAccount
	 * @param studentPwd
	 * @param classId
	 * @param response
	 * @throws IOException
	 */
	@RequestMapping(value="/studentReg", method=RequestMethod.POST)
	public void studentRegister(
			@RequestParam("name") String studentName,
			@RequestParam("account") String studentAccount,
			@RequestParam("pwd") String studentPwd,
			@RequestParam("classId") Integer classId,
			HttpServletResponse response) throws IOException {
		ModelAndView model = new ModelAndView();
		student.setStudentName(studentName);
		student.setStudentAccount(studentAccount);
		student.setStudentPwd(studentPwd);
		classInfo.setClassId(classId);
		student.setClassInfo(classInfo);
		logger.info("学生注册 "+student);
		int row = studentInfoService.isAddStudent(student);
		
		response.getWriter().print("t");
	}
	
	/**
	 * 预注册
	 * @return
	 */
	@RequestMapping("/preStudentReg")
	public ModelAndView preStudentReg() {
		ModelAndView model = new ModelAndView();
		model.setViewName("reception/register");
		model.addObject("classs", classInfoService.getClasses(null));
		return model;
	}
	
	/**
	 * 学生进入考试
	 * @param classId 班级编号
	 * @param examPaperId 试卷编号
	 * @param studentId 考生编号
	 * @param examTime 考试时间
	 * @param beginTime 考试开始时间
	 * @param gradeId 年级编号
	 * @param session
	 * @return
	 */
	@RequestMapping("/begin")
	public ModelAndView beginExam(
			@RequestParam("classId") Integer classId,
			@RequestParam("examPaperId") Integer examPaperId,
			@RequestParam(value="studentId", required=false) Integer studentId,
			@RequestParam("examTime") Integer examTime,
			@RequestParam("beginTime") String beginTime,
			@RequestParam("gradeId") Integer gradeId,
			HttpSession session) {
		ModelAndView model = new ModelAndView();
		
		/*
		 * 查询该考试当前进入的试卷是否已经在历史记录中存在
		 * 如果存在，则不能再次进入考试； 反之进入考试
		 */
		Map<String, Object> map = new HashMap<String, Object>();
		map.put("studentId", studentId);
		map.put("examPaperId", examPaperId);
		int count = examHistoryPaperService.getHistoryInfoWithIds(map);
		if(session.getAttribute("loginStudent") == null) {
			model.addObject("error", "请先登录后再操作");
			model.setViewName("error");
			return model;
		} else if (count >= 1) {
			model.addObject("error", "你已经考试过了");
			model.setViewName("error");
			return model;
		} else {			
			logger.info("学生 "+studentId+" 进入考试 班级 "+classId+" 试卷 "+examPaperId);
			model.setViewName("/reception/exam");
			
			ExamPaperInfo examPaper = new ExamPaperInfo();
			examPaper.setExamPaperId(examPaperId);
			esm.setExamPaper(examPaper);
			//获取试卷 试题集合
			List<ExamSubjectMiddleInfo> esms = examSubjectMiddleInfoService.getExamPaperWithSubject(esm);
			logger.info("考试试题总量 "+esms.size());
			
			//获取当前考生在当前试卷中已选答案记录
			Map<String, Object> choosedMap = new HashMap<String, Object>();
			choosedMap.put("studentId", studentId);
			choosedMap.put("examPaperId", examPaperId);
			List<ExamChooseInfo> chooses = examChooseInfoService.getChooseInfoWithSumScore(choosedMap); 
			if (chooses == null || chooses.size() == 0) {
				model.addObject("chooses", null);
			} else {
				model.addObject("chooses", chooses);				
			}
			
			
			model.addObject("esms", esms);
			model.addObject("sumSubject", esms.size());
			model.addObject("examPaperId", examPaperId);
			model.addObject("examTime", examTime);
			model.addObject("beginTime", beginTime);
			model.addObject("classId", classId);
			model.addObject("gradeId", gradeId);
			
			return model;
		}
	}
	
	
	/**
	 * 获取学生历史考试记录
	 * @param studentId 学生编号
	 * @return
	 */
	@RequestMapping("/history/{studentId}")
	public ModelAndView getExamHistoryInfo(@PathVariable("studentId") Integer studentId) {
		ModelAndView model = new ModelAndView();
		
		if (studentId == null) {
			logger.error("学生编号 为空");
			model.setViewName("error");
			return model;
		}
		logger.info("学生 "+studentId+" 获取考试历史记录");
		//获取历史考试信息记录集合
		List<ExamHistoryPaper> ehps = examHistoryPaperService.getExamHistoryToStudent(studentId);
		model.addObject("ehps", ehps);
		model.setViewName("/reception/examHistory");
		
		return model;
	}
	
	
	/**
	 * 考生提交考试
	 * @param studentId
	 * @param examPaperId
	 * @param classId
	 * @param gradeId
	 * @return
	 */
	@RequestMapping(value="/submit", method={RequestMethod.POST, RequestMethod.GET})
	public String examSubmit(
			@RequestParam("studentId") Integer studentId,
			@RequestParam("examPaperId") Integer examPaperId,
			@RequestParam("classId") Integer classId,
			@RequestParam("gradeId") Integer gradeId) {
		logger.info("学生 "+studentId+" 提交了试卷 "+examPaperId);
		
		//获取当前学生当前试卷所选择的全部答案
		Map<String, Object> map = new HashMap<String, Object>();
		map.put("studentId", studentId);
		map.put("examPaperId", examPaperId);
		List<ExamChooseInfo> chooses = examChooseInfoService.getChooseInfoWithSumScore(map);
		logger.info("学生 "+studentId+" 共选择了 "+chooses.size()+" 道题");
		
		//总分记录
		int sumScore = 0;
		for (ExamChooseInfo choose : chooses) {
			SubjectInfo subject = choose.getSubject();
			String chooseResult = choose.getChooseResult();
			String rightResult = subject.getRightResult();
			
			if (chooseResult.equals(rightResult)) {	//答案正确
				sumScore += subject.getSubjectScore();
				logger.info("学生 "+studentId+" 第 "+subject.getSubjectId()+" 选择正确答案 "+chooseResult+" 当前总分 "+sumScore);
			} else {
				logger.info("学生 "+studentId+" 第 "+subject.getSubjectId()+" 答案选择错误 "+chooseResult+" 正确答案为 "+rightResult+" 当前总分 "+sumScore);				
			}
		}
		
		/*
		 * 首先判断当前记录是否已经添加过
		 * 防止当前学生点击提交后，系统倒计时再次进行提交
		 */
		int count = examHistoryPaperService.getHistoryInfoWithIds(map);
		
		if (count == 0) {
			//添加到历史记录
			map.put("examScore", sumScore);
			int row = examHistoryPaperService.isAddExamHistory(map);
			logger.info("学生 "+studentId+" 提交的试卷 "+examPaperId+" 已成功处理，并添加到历史记录中");
		}
		
		return "redirect:willexams?gradeId="+gradeId+"&classId="+classId+"&studentId="+studentId;
	}
	
	
	/**
	 * 学生回顾试卷  --  后台教师查看也调用此方法
	 * @param studentId
	 * @param examPaperId
	 * @param score
	 * @param examPaperName
	 * @param studentName  后台教师查看需传入学生姓名
	 * @return
	 * @throws UnsupportedEncodingException
	 */
	@RequestMapping("/review")
	public ModelAndView reViewExam(
			@RequestParam("studentId") Integer studentId,
			@RequestParam("examPaperId") Integer examPaperId,
			@RequestParam("score") Integer score,
			@RequestParam("examPaperName") String examPaperName,
			@RequestParam(value="studentName", required=false) String studentName) throws UnsupportedEncodingException {
		ModelAndView model = new ModelAndView();
		if (studentId == null) {
			model.addObject("error", "请先登录后再操作");
			model.setViewName("error");
			return model;
		} else {
			//获取当前试卷的试题集合  -- 前台判断需要
			examPaper.setExamPaperId(examPaperId);
			esm.setExamPaper(examPaper);
			List<ExamSubjectMiddleInfo> esms = examSubjectMiddleInfoService.getExamPaperWithSubject(esm);
			
			Map<String, Object> map = new HashMap<String, Object>();
			map.put("studentId", studentId);
			map.put("examPaperId", examPaperId);
			
			//获取当前回顾试卷 试题、选择答案 信息
			List<ExamChooseInfo> reviews = examChooseInfoService.getChooseInfoWithExamSubject(map);
			logger.info("学生 "+studentId+" 回顾试卷 "+examPaperId+" 试题数量 "+reviews.size());
			//设置试卷名称、试卷总分
			model.addObject("examPaperName", examPaperName);
			model.addObject("score", score);
			
			model.setViewName("reception/review");
			model.addObject("views", reviews);
			
			model.addObject("esms", esms);
			if (studentName != null) model.addObject("studentName", studentName);
			
			model.addObject("ExamedPaper", examPaperInfoService.getExamPaper(examPaperId));
			
			return model;
		}
	}
	
	/**
	 * 学生查看自己信息
	 * @param studentId
	 * @return
	 */
	@RequestMapping("/self/{studentId}")
	public ModelAndView selfInfo(@PathVariable("studentId") Integer studentId) {
		StudentInfo stu = studentInfoService.getStudentById(studentId);
		
		ModelAndView model = new ModelAndView();
		model.setViewName("/reception/self");
		model.addObject("self", stu);
		
		
		return model;
	}
	
	
	/**
	 * 学生修改密码
	 * @param pwd
	 * @param studentId
	 * @param response
	 * @throws IOException
	 */
	@RequestMapping("/reset/{pwd}/{studentId}")
	public void isResetPwd(
			@PathVariable("pwd") String pwd,
			@PathVariable("studentId") Integer studentId,
			HttpServletResponse response) throws IOException {
		logger.info("学生 "+studentId+" 修改密码");
		student.setStudentId(studentId);
		student.setStudentPwd(pwd);
		
		int row = studentInfoService.isResetPwdWithStu(student);
		
		if (row > 0) {
			response.getWriter().print("t");
		} else {
			response.getWriter().print("f");			
		}
	}
public class SubjectInfoHandler {

	@Autowired
	private SubjectInfoService subjectInfoService;
	@Autowired
	private CourseInfoService courseInfoService;
	@Autowired
	private GradeInfoService gradeInfoService;
	@Autowired
	private ExamPaperInfoService examPaperInfoService;
	@Autowired
	private ExamSubjectMiddleInfoService esmService;
	@Autowired
	private SubjectInfo subject;
	@Autowired
	private CourseInfo course;
	@Autowired
	private GradeInfo grade;
	@Autowired
	private ExamPaperInfo examPaper;
	
	private Logger logger = Logger.getLogger(SubjectInfoHandler.class);
	
	
	/**
	 * 查询试题集合
	 * @param subjectId    查询条件
	 * @param courseId
	 * @param gradeId
	 * @param startPage
	 * @param pageShow
	 * @param handAdd  标识 是否为需要进行手动添加试题到试卷而发起的请求
	 * @param examPaperId
	 * @param session
	 * @return
	 */
	@RequestMapping(value="/subjects", method=RequestMethod.GET)
	public ModelAndView getTeachers(
			@RequestParam(value="subjectId", required=false) Integer subjectId,
			@RequestParam(value="courseId", required=false) Integer courseId,
			@RequestParam(value="gradeId", required=false) Integer gradeId,
			@RequestParam(value="startPage", required=false, defaultValue="1") Integer startPage,
			@RequestParam(value="pageShow", required=false, defaultValue="10") Integer pageShow,
			@RequestParam(value="handAdd", required=false) Integer handAdd,
			@RequestParam(value="examPaperId", required=false) Integer examPaperId,
			HttpSession session) {
		logger.info("查询试题集合");
		
		ModelAndView model = new ModelAndView();
		model.setViewName("admin/subjects");
		
		//条件处理
		if (subjectId != null) subject.setSubjectId(subjectId);
		if (courseId != null) course.setCourseId(courseId);
		if (gradeId != null) grade.setGradeId(gradeId);
		
		Map<String, Object> map = new HashMap<String, Object>();
		//计算当前查询起始数据索引
		int startIndex = (startPage-1) * pageShow;
		//map.put("subject", subject);
		map.put("startIndex", startIndex);
		map.put("pageShow", pageShow);
		List<SubjectInfo> subjects = subjectInfoService.getSubjects(map);
		model.addObject("subjects", subjects);
		
		//获取试题总量
		int subjectTotal = subjectInfoService.getSubjectTotal();
		//计算总页数
		int pageTotal = 1;
		if (subjectTotal % pageShow == 0)
			pageTotal = subjectTotal / pageShow;
		else
			pageTotal = subjectTotal / pageShow + 1;			
		model.addObject("pageTotal", pageTotal);
		model.addObject("pageNow", startPage);
		
		//是否为需要进行手动添加试题到试卷而发起的请求
		if (handAdd != null && handAdd == 1) {
			model.addObject("handAdd", "1");
		}
		//如果是手动添加试题到试卷，则需要返回试卷编号, 且返回当前已经选择试题数量
		if (examPaperId != null) {
			model.addObject("examPaperId", examPaperId);
			List<String> ids = (List<String>) session.getAttribute("ids");
			if (ids == null) {
				model.addObject("choosed", 0);
			} else {				
				model.addObject("choosed", ids.size());
			}
		}
		
		return model;
	}
	
	
	/**
	 * 添加试题
	 * @param subject
	 * @param response
	 * @throws IOException
	 */
	@RequestMapping(value="/addSubject", method=RequestMethod.POST)
	public void addSubject(SubjectInfo subject, HttpServletResponse response) throws IOException {
		if(subject != null){
			subject.setSubjectName(trimChar(subject.getSubjectName()));
			subject.setRightResult(trimChar(subject.getRightResult()));
			subject.setOptionA(trimChar(subject.getOptionA()));
			subject.setOptionB(trimChar(subject.getOptionB()));
			subject.setOptionC(trimChar(subject.getOptionC()));
			subject.setOptionD(trimChar(subject.getOptionD()));
		}
		int row = subjectInfoService.isAddSubject(subject);
		
		response.getWriter().print("试题添加成功!");
	}
	
	
	/**
	 * 删除试题
	 * @param subjectId
	 * @param response
	 * @throws IOException
	 */
	@RequestMapping(value="/delSubject", method=RequestMethod.POST)
	public void delSubject(@RequestParam("subjectId") Integer subjectId,
			HttpServletResponse response) throws IOException {
		logger.info("删除试题 "+subjectId);
		
		int row = subjectInfoService.isDelSubject(subjectId);
		
		if (row > 0) {
			response.getWriter().print("t");
		} else {
			response.getWriter().print("f");			
		}
	}
	
	
	/**
	 * 修改试题 -- 获取待修改试题信息
	 * @param subjectId
	 * @return
	 */
	@RequestMapping("/subject/{subjectId}")
	public ModelAndView updateSubject(@PathVariable("subjectId") Integer subjectId) {
		logger.info("修改试题 "+subjectId+" 的信息(获取试题信息)");
		
		SubjectInfo subject = subjectInfoService.getSubjectWithId(subjectId);
		
		ModelAndView model = new ModelAndView("/admin/subject-test");
		model.addObject("subject", subject);
		List<GradeInfo> grades = gradeInfoService.getGrades();
		model.addObject("grades", grades);
		model.addObject("courses", courseInfoService.getCourses(null));
		return model;
	}
	
	/**
	 * 修改试题
	 * @param subject
	 * @param response
	 * @throws IOException
	 */
	@RequestMapping(value="/updateSubject", method=RequestMethod.POST)
	public void updateSubject(SubjectInfo subject, HttpServletResponse response) throws IOException {
		logger.info("修改试题 "+subject.getSubjectId()+" 的信息(正式)");

		if(subject != null){
			subject.setSubjectName(trimChar(subject.getSubjectName()));
			subject.setRightResult(trimChar(subject.getRightResult()));
			subject.setOptionA(trimChar(subject.getOptionA()));
			subject.setOptionB(trimChar(subject.getOptionB()));
			subject.setOptionC(trimChar(subject.getOptionC()));
			subject.setOptionD(trimChar(subject.getOptionD()));
		}
		int row = subjectInfoService.isUpdateSubject(subject);
		if (row > 0) {
			response.getWriter().print("试题修改成功!");
		} else {
			response.getWriter().print("试题修改失败!");
		}
	}
	
	
	/**
	 * 初始化 导入 excel 试题信息
	 * @return
	 */
	@RequestMapping(value="/initImport")
	public ModelAndView initImportExcel() {
		logger.info("初始化 导入 EXCEL 试题信息");
		ModelAndView model = new ModelAndView("admin/importSubject");
		//获取所有科目
		List<CourseInfo> courses = courseInfoService.getCourses(null);
		//获取所有年级
		List<GradeInfo> grades = gradeInfoService.getGrades();
		//获取所有试卷名称
		List<ExamPaperInfo> examPapers = examPaperInfoService.getExamPapersClear();
		
		model.addObject("courses", courses);
		model.addObject("grades", grades);
		model.addObject("examPapers", examPapers);
		
		return model;
	}
	
	
	/**
	 * 试题导入 处理
	 * @param request
	 * @param importOption
	 * @param excel
	 */
	@RequestMapping(value="/dispatcherUpload", method=RequestMethod.POST)
	public ModelAndView dispatcherUpload(HttpServletRequest request,
			@RequestParam("division") Integer division,
			@RequestParam("courseId") Integer courseId,
			@RequestParam("gradeId") Integer gradeId,
			@RequestParam("examPaperId") Integer examPaperId,
			@RequestParam("importOption") String importOption,
			@RequestParam("examPaperEasy") Integer examPaperEasy,
			@RequestParam("examPaperName") String examPaperName,
			@RequestParam("examPaperTime") Integer examPaperTime,
			@RequestParam("inputfile") MultipartFile excel) {
		ModelAndView model = new ModelAndView("reception/suc");
		String savePath = "";
		
		try {
			/** 保存上传 excel 文件 */
			savePath = saveUploadFile(excel, request.getRealPath("/WEB-INF/upload"));
			
			/** 解析上传 excel 文件, 得到试题集合 */
			List<SubjectInfo> subjects = SubjectImportUtil.parseSubjectExcel(savePath, courseId, gradeId, division);
			
			/** 只添加试题 */
			if ("0".equals(importOption)) {
				Map<String, Object> subjectsMap = new HashMap<String, Object>();
				subjectsMap.put("subjects", subjects);
				
				importSubejctOnly(subjects, subjectsMap);
			}
			/** 添加试题到指定的已有试卷 */
			else if ("1".equals(importOption)) {
				dispatcherExamPaperAndSubject(subjects, examPaperId);
			}
			/** 添加试题到新建试卷 */
			else if ("2".equals(importOption)) {
				/** 创建新试卷 */
				examPaper.setExamPaperName(examPaperName);
				examPaper.setExamPaperEasy(examPaperEasy);
				examPaper.setExamPaperTime(examPaperTime);
				grade.setGradeId(gradeId);
				examPaper.setGrade(grade);
				examPaper.setDivision(division);
				int row = examPaperInfoService.isAddExamPaper(examPaper);
				logger.info("添加的新试卷 编号 "+examPaper.getExamPaperId());
				
				dispatcherExamPaperAndSubject(subjects, examPaper.getExamPaperId());
			}
			
			if (subjects.size() == 0) {
				model.addObject("success", "操作处理失败，共添加 <b style='color:red;'>"+subjects.size()+"</b> 道题, 请检查上传数据正确性!");
			} else {
				model.addObject("success", "操作处理成功，共添加 "+subjects.size()+" 道题");
			}
			
		} catch (Exception e) {
			e.printStackTrace();
			model.setViewName("error");
			model.addObject("error", "上传失败, 请检查上传数据合理性或联系管理员!");
		} finally {
			/** 删除上传文件 */
			deleteUploadFile(savePath);
		}
		return model;
	}
	
	
	/**
	 * 保存上传 excel 文件
	 * @param file 上传文件
	 * @return 保存路径
	 */
	private String saveUploadFile(MultipartFile file, String rootPath) {
		String fileName = file.getOriginalFilename();
		logger.info("保存上传文件 "+fileName+" 到 "+rootPath);
		
		try {
			file.transferTo(new File(rootPath+"/"+fileName));
		} catch (IllegalStateException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}
		
		return rootPath+"/"+fileName;
	}
	
	
	/**
	 * 只将试题上传到数据库
	 * @param subjects
	 * @param subjectsMap
	 */
	private void importSubejctOnly(List<SubjectInfo> subjects, Map<String, Object> subjectsMap) {
		try {
			if (subjects != null && subjects.size() > 0) {
				//添加试题
				int row = subjectInfoService.isAddSubjects(subjectsMap);
				logger.info("只将 excel 中的试题添加到数据库成功 SIZE "+subjects.size());
			} else {
				logger.info("上传试题文件中不存在试题，或解析失败");
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
	
	
	/**
	 * 处理 试题 添加到 试卷
	 * @param subjects 试题集合
	 * @param examPaperId 对应试卷编号
	 */
	private void dispatcherExamPaperAndSubject(List<SubjectInfo> subjects, Integer examPaperId) {
		List<Integer> subjectIds = new ArrayList<Integer>();
		//试题总量统计
		int count = 0;
		//试题总分统计
		int score = 0;
		
		/** 添加试题 */
		for (SubjectInfo subjectInfo : subjects) {
			int row1 = subjectInfoService.isAddSubject(subjectInfo);
			score += subjectInfo.getSubjectScore();
			subjectIds.add(subjectInfo.getSubjectId());
			count++;
		}
		logger.info("添加试题 SIZE "+count);
		
		/** 添加试题到试卷 */
		Map<String, Object> esmMap = new HashMap<String, Object>();
		esmMap.put("examPaperId", examPaperId);
		esmMap.put("subjectIds", subjectIds);
		esmService.isAddESM(esmMap);
		logger.info("添加试题 SIZE "+count+" SCORE "+score+" 到试卷 "+examPaperId);
		
		//修改试卷信息
		Map<String, Object> scoreWithNum = new HashMap<String, Object>();
		scoreWithNum.put("subjectNum", count);
		scoreWithNum.put("score", score);
		scoreWithNum.put("examPaperId", examPaperId);
		/** 修改试卷总分 */
		examPaperInfoService.isUpdateExamPaperScore(scoreWithNum);
		/** 修改试卷试题总量 */
		examPaperInfoService.isUpdateExamPaperSubjects(scoreWithNum);
	}
	
	
	/**
	 * 删除上传文件
	 * @param filePath 文件路径
	 */
	private void deleteUploadFile(String filePath) {
		File file = new File(filePath);
		
		if (file.exists()) {
			file.delete();
			logger.info("上传文件已被删除 "+filePath);
		}
	}
	
	/**
	 * 预添加试题
	 * @return
	 */
	@RequestMapping("/preAddSubject")
	public ModelAndView preAddStudent() {
		logger.info("预添加试卷信息");
		ModelAndView model = new ModelAndView();
		model.setViewName("/admin/subject-test");
		List<GradeInfo> grades = gradeInfoService.getGrades();
		model.addObject("grades", grades);
		model.addObject("courses", courseInfoService.getCourses(null));
		return model;
	}
	
	private String trimChar(String str){
		if(str != null){
			return str.replaceAll("^,*|,*$", "");
		}
		return str;
	}
	
}
public class TeacherInfoHandler {
	
	@Autowired
	private TeacherInfoService teacherInfoService;
	
	private Logger logger = Logger.getLogger(TeacherInfoHandler.class);
	
	
	/**
	 * 获取  验证教师信息
	 * @param teacherAccount
	 * @param response
	 * @throws Exception
	 */
	@RequestMapping(value="/validateTeacher", method=RequestMethod.POST)
	public void queryTeacherExists(@RequestParam(value="account") String teacherAccount,
			HttpServletResponse response) throws Exception {
		logger.info("获取教师 "+teacherAccount+" 的信息");

		TeacherInfo teacherInfo = null;
		teacherInfo = teacherInfoService.getTeacherByAccount(teacherAccount);
		
		//教师账户不存在
		if (teacherInfo == null) {
			response.getWriter().print("1");
		} else {			
			response.getWriter().print(teacherInfo.getTeacherPwd());
		}
	}
	
	
	/**
	 * 教师登录
	 * @param teacherAccount
	 * @param request
	 * @return
	 */
	@RequestMapping(value="/teacherlogin", method=RequestMethod.POST)
	public String teacherLogin(@RequestParam("teacherAccount") String teacherAccount,
			HttpServletRequest request) {
		if (teacherAccount == null || "".equals(teacherAccount)) {
			logger.error("教师账号为空");
			request.setAttribute("error", "登录信息有误");
			return "/error";
		}
		logger.info("教师  "+teacherAccount+" 登录");
		
		//获取当前登录教师
		TeacherInfo teacherInfo = teacherInfoService.getTeacherByAccount(teacherAccount);
		
		if(teacherInfo == null){
			logger.error("教师账号为空");
			request.setAttribute("error", "账号不存在！");
			return "/error";
		}
		String teacherPwd = request.getParameter("teacherPwd");
		if(!teacherInfo.getTeacherPwd().equals(teacherPwd)){
			logger.error("密码错误");
			request.setAttribute("error", "密码错误！");
			return "/error";
		}
		//将当前登录教师 后台权限存入 Session
		request.getSession().setAttribute("adminPower", teacherInfo.getAdminPower());
		request.getSession().setAttribute("loginTeacher", teacherInfo);
		
		return "redirect:admin/index.jsp";
	}
	
	/**
	 * 教师查看自己的信息
	 * @param teacherId
	 * @return
	 */
	@RequestMapping("/selfinfo/{teacherId}")
	public ModelAndView loginTeacherSelf(@PathVariable("teacherId") Integer teacherId) {
		ModelAndView model = new ModelAndView();
		logger.error("教师 "+teacherId+" 查看自己的信息");
		if (teacherId == null) {
			model.setViewName("../error");
			return model;
		} else {
			List<TeacherInfo> teachers = new ArrayList<TeacherInfo>();
			TeacherInfo teacher = teacherInfoService.getTeacherById(teacherId);
			teachers.add(teacher);
			model.addObject("teachers", teachers);
			model.setViewName("/admin/teachers");
			
			return model;
		}
	}
	
	
	/**
	 * 教师退出登录
	 * @throws IOException 
	 */
	@RequestMapping("/exitTeacher")
	public void exitTeacher(HttpSession session, HttpServletResponse response) throws IOException {
		session.removeAttribute("loginTeacher");
		session.removeAttribute("adminPower");
		
		response.sendRedirect("admin/login.jsp");
	}
	
	
	/**
	 * 查询教师集合
	 * @param startPage
	 * @param pageShow
	 * @return
	 */
	@RequestMapping(value="/teachers", method=RequestMethod.GET)
	public ModelAndView getTeachers(
			@RequestParam(value="startPage", required=false, defaultValue="1") Integer startPage,  //当前页码,默认第一页
			@RequestParam(value="pageShow", required=false, defaultValue="10") Integer pageShow /*每页显示数据量，默认10条*/) {
		logger.info("查询教师集合");
		
		ModelAndView model = new ModelAndView();
		model.setViewName("admin/teachers");
		
		List<TeacherInfo> teachers;
		
		Map<String, Object> map = new HashMap<String, Object>();
		//计算当前查询起始数据索引
		int startIndex = (startPage-1) * pageShow;
		map.put("startIndex", startIndex);
		map.put("pageShow", pageShow);
		map.put("teacher", null);
		teachers = teacherInfoService.getTeachers(map);
		model.addObject("teachers", teachers);
		
		//获取教师总量
		int teacherTotal = teacherInfoService.getTeacherTotal();
		//计算总页数
		int pageTotal = 1;
		if (teacherTotal % pageShow == 0)
			pageTotal = teacherTotal / pageShow;
		else
			pageTotal = teacherTotal / pageShow + 1;			
		model.addObject("pageTotal", pageTotal);
		model.addObject("pageNow", startPage);
		
		return model;
	}
	
	/**
	 * 预修改教师
	 * @param teacherId
	 * @return
	 */
	@RequestMapping(value="/teacher/{teacherId}", method=RequestMethod.GET)
	public ModelAndView preUpdateTeacher(@PathVariable("teacherId") Integer teacherId) {
		logger.info("预修改教师处理");
		
		ModelAndView model = new ModelAndView();
		//获取要修改教师
		TeacherInfo teacher = teacherInfoService.getTeacherById(teacherId);
		model.setViewName("/admin/teacheredit");
		model.addObject("teacher", teacher);
		
		return model;
	}
	
	/**
	 * 修改/添加 教师
	 * @param teacherId
	 * @param isUpdate 操作标识
	 * @param teacherName
	 * @param teacherAccount
	 * @param teacherPwd
	 * @param adminPower
	 * @return
	 */
	@RequestMapping(value="/teacher/teacher", method=RequestMethod.POST)
	public String isUpdateOrAddTeacher(@RequestParam(value="teacherId", required=false) Integer teacherId,
			@RequestParam(value="isupdate", required=false) Integer isUpdate,
			@RequestParam("teacherName") String teacherName,
			@RequestParam("teacherAccount") String teacherAccount,
			@RequestParam("teacherPwd") String teacherPwd,
			@RequestParam("adminPower") Integer adminPower) {
		
		TeacherInfo teacher = new TeacherInfo();
			teacher.setTeacherId(teacherId);
			teacher.setTeacherName(teacherName);
			teacher.setTeacherAccount(teacherAccount);
			teacher.setTeacherPwd(teacherPwd);
			teacher.setAdminPower(adminPower);
		
		if (isUpdate != null) {  //修改
			logger.info("修改教师 "+teacher+" 的信息");
			int row = teacherInfoService.isUpdateTeacherInfo(teacher);			
		} else {  //添加
			logger.info("添加教师 "+teacher+" 的信息");
			int row = teacherInfoService.isAddTeacherInfo(teacher);
		}
		
		return "redirect:/teachers";
	}
	
	
	/**
	 * 删除教师
	 * @param teacherId
	 * @return
	 */
	@RequestMapping(value="/teacher/{teacherId}", method=RequestMethod.DELETE)
	public String isDelTeacher(@PathVariable("teacherId") Integer teacherId) {
		logger.info("删除教师 "+teacherId);
		
		int row = teacherInfoService.isDelTeacherInfo(teacherId);
		
		return "redirect:/teachers";
	}
}

public class LoginInterceptor extends HandlerInterceptorAdapter {

	private Logger logger = Logger.getLogger(LoginInterceptor.class);
	
	@Override
	public boolean preHandle(HttpServletRequest request,
			HttpServletResponse response, Object handler) throws Exception {
		
		HttpSession session = request.getSession();
		if (session.getAttribute("loginTeacher") != null) {
			return true;
		} else {
			logger.info("检测到未登录访问后台内容操作");
			//如果没有登录，跳转至登录页面
			response.sendRedirect("admin/login.jsp");
			
			return false;
		}
	}
}
public class ExamSubjectMiddleInfoTest {

	private SqlSessionFactory sqlSessionFactory;
	
	public void init() throws Exception {
		InputStream is = Resources.getResourceAsStream("test/SqlMapConfig-test.xml");
		sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);
	}
	
	@Test
	public void addTest() throws Exception {
		init();
		
		SqlSession session = sqlSessionFactory.openSession();
		
		Map<String, Object> map = new HashMap<String, Object>();
		map.put("examPaperId", 2);
		ArrayList<Integer> subjectIds = new ArrayList<Integer>();
		subjectIds.add(100);
		subjectIds.add(200);
		subjectIds.add(300);
		subjectIds.add(400);
		map.put("subjectIds", subjectIds);
		
		session.insert("isAddESM", map);
		session.commit();
	}
}
public class StudentInfoTest {

	private SqlSessionFactory sqlSessionFactory;
	
	public void init() throws Exception {
		InputStream is = Resources.getResourceAsStream("test/SqlMapConfig-test.xml");
		sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);
	}
	
	@Test
	public void test2() throws Exception {
		init();
		
		StudentInfo student = new StudentInfo();
		ClassInfo classInfo = new ClassInfo();
		classInfo.setClassId(1);
		student.setClassInfo(classInfo);
		
		Map<String, Object> map = new HashMap<String, Object>();
		map.put("student", student);
		map.put("startIndex", 0);
		map.put("pageShow", 3);
		
		SqlSession session = sqlSessionFactory.openSession();
		List<StudentInfo> students = session.selectList("getStudents", map);
		System.out.println(students);

		session.close();
	}
}
public class TeacherInfoTest {

	private SqlSessionFactory sqlSessionFactory;
	
	public void init() throws Exception {
		InputStream is = Resources.getResourceAsStream("test/SqlMapConfig-test.xml");
		sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);
	}
	
	//分页测试
	@Test
	public void paginationTest() throws Exception {
		init();
		
		Map<String, Object> map = new HashMap<String, Object>();
		map.put("startPage", 0);
		map.put("pageShow", 2);
		
		SqlSession session = sqlSessionFactory.openSession();
		List<TeacherInfo> teachers = session.selectList("getTest", map);
		System.out.println(teachers);

		session.close();
	}
	
	@Test
	public void test2() throws Exception {
		init();
		
		TeacherInfo teacherInfo = new TeacherInfo();
		teacherInfo.setIsWork(1);

		Map<String, Object> map = new HashMap<String, Object>();
		map.put("teacher", teacherInfo);
		map.put("startIndex", 1);
		map.put("pageShow", 3);
		
		SqlSession session = sqlSessionFactory.openSession();
		List<TeacherInfo> teachers = session.selectList("getTeachers", map);
		System.out.println(teachers);

		session.close();
	}
}
public class SubjectImportUtil {
	private static int subjectNameIndex;
	private static int optionAIndex;
	private static int optionBIndex;
	private static int optionCIndex;
	private static int optionDIndex;
	private static int rightResultIndex;
	private static int subjectScoreIndex;
	private static int subjectTypeIndex;
	private static int subjectEasyIndex;

	/**
	 * 解析导入 excel 生成试题对象
	 * @param filePath
	 * @param indexs
	 * @param courseId
	 * @param gradeId
	 * @param division
	 * @return
	 */
	public static List<SubjectInfo> parseSubjectExcel(String filePath, Integer courseId, Integer gradeId, Integer division) {
		List<SubjectInfo> subjects = new LinkedList<SubjectInfo>();
		try {
			//读取工作本
			XSSFWorkbook workBook = new XSSFWorkbook(filePath);
			//读取工作簿
			XSSFSheet sheet = workBook.getSheet("Sheet1");
			//总行数
			int sumRow = sheet.getLastRowNum()-sheet.getFirstRowNum();
			
			//第一行
			XSSFRow firstRow = sheet.getRow(0);
			getCellIndexs(firstRow);
			
			for (int i = 1; i <= sumRow; i++) {
				XSSFRow row = (XSSFRow) sheet.getRow(i);
				XSSFCell subjectName = row.getCell(subjectNameIndex);
				XSSFCell optionA = row.getCell(optionAIndex);
				XSSFCell optionB = row.getCell(optionBIndex);
				XSSFCell optionC = row.getCell(optionCIndex);
				XSSFCell optionD = row.getCell(optionDIndex);
				XSSFCell rightResult = row.getCell(rightResultIndex);
				XSSFCell subjectScore = row.getCell(subjectScoreIndex);
				if(subjectScore.getCellType()==0) { subjectScore.setCellType(1); }
				XSSFCell subjectType = row.getCell(subjectTypeIndex);
				XSSFCell subjectEasy = row.getCell(subjectEasyIndex);
				
				SubjectInfo subject = new SubjectInfo();
				subject.setSubjectName(subjectName.toString());
				
				subject.setOptionA(optionA == null ? "" : optionA.toString());
				subject.setOptionB(optionB == null ? "" : optionB.toString());
				subject.setOptionC(optionC == null ? "" : optionC.toString());
				subject.setOptionD(optionD == null ? "" : optionD.toString());
				
				subject.setRightResult(rightResult.toString());
				subject.setSubjectScore(Integer.parseInt(subjectScore.toString()));
				//试题类型
				if("单选".equals(row.getCell(subjectTypeIndex).toString())){
					subject.setSubjectType(0);
				}else if("多选".equals(row.getCell(subjectTypeIndex).toString())){
					subject.setSubjectType(1);
				}else{
					subject.setSubjectType(2);
				}
				
				if ("简单".equals(subjectEasy.toString())) {
					subject.setSubjectEasy(0);					
				} else if ("普通".equals(subjectEasy.toString())) {
					subject.setSubjectEasy(1);					
				} else {
					subject.setSubjectEasy(2);						
				}
				subject.setCourse(new CourseInfo(courseId));
				subject.setGrade(new GradeInfo(gradeId));
				subject.setDivision(division);
				
				subjects.add(subject);
			}
			
			workBook.close();
		} catch (Exception e) {
			e.printStackTrace();
		}
		
		return subjects;
	}
	
	
	/**
	 * 解析第一行标题名得到列索引
	 * @param firstRow
	 */
	private static void getCellIndexs(XSSFRow firstRow) {
		int cellNum = firstRow.getLastCellNum()-firstRow.getFirstCellNum();
		for (int i=0; i<cellNum; i++) {
			String cell = firstRow.getCell(i).toString();
			if ("题目".equals(cell)) {
				subjectNameIndex = i;
				continue;
			}
			if ("答案A".equals(cell)) {
				optionAIndex = i;
				continue;
			}
			if ("答案B".equals(cell)) {
				optionBIndex = i;
				continue;
			}
			if ("答案C".equals(cell)) {
				optionCIndex = i;
				continue;
			}
			if ("答案D".equals(cell)) {
				optionDIndex = i;
				continue;
			}
			if ("正确答案".equals(cell)) {
				rightResultIndex = i;
				continue;
			}
			if ("分值".equals(cell)) {
				subjectScoreIndex = i;
				continue;
			}
			if ("试题类型".equals(cell)) {
				subjectTypeIndex = i;
				continue;
			}
			if ("难易程度".equals(cell)) {
				subjectEasyIndex = i;
				continue;
			}
		}
	}
}