孙向锦 / SunvoteEducation

  package com.fh.controller.api;
  

  import java.io.File;

  import java.sql.Connection;
  import java.sql.ResultSet;
  import java.sql.Statement;

  import java.util.ArrayList;

  import java.util.Collections;
  import java.util.Comparator;

  import java.util.Date;

  import java.util.Iterator;

  import java.util.List;

  import java.util.Map;

  
  import javax.annotation.Resource;

  import javax.servlet.http.HttpServletRequest;

  import org.apache.commons.lang.StringUtils;

  import org.apache.shiro.crypto.hash.SimpleHash;

  import org.springframework.stereotype.Controller;

  import org.springframework.web.bind.annotation.RequestMapping;

  import org.springframework.web.bind.annotation.RequestParam;

  import org.springframework.web.bind.annotation.ResponseBody;

  import org.springframework.web.multipart.MultipartFile;

  import com.fh.bean.Paper;

  import com.fh.bean.Point;

  import com.fh.bean.Question;

  import com.fh.bean.StudentAnswer;
  import com.fh.bean.TestPaper;
  import com.fh.bean.TestPaperInfo;

  import com.fh.controller.base.BaseController;

  import com.fh.controller.sunvote.Myelfun;

  import com.fh.service.api.V1Manager;
  import com.fh.service.feedback.feedback.FeedbackManager;
  import com.fh.service.feedback.problemphenomenon.ProblemPhenomenonManager;

  import com.fh.service.software.softwareversion.SoftwareVersionManager;

  import com.fh.service.sunvote.attachkeyboard.AttachKeyboardManager;

  import com.fh.service.sunvote.basestation.BasestationManager;

  import com.fh.service.sunvote.cache.CacheManager;

  import com.fh.service.sunvote.chapter.ChapterManager;
  import com.fh.service.sunvote.classbasetation.ClassBasetationManager;
  import com.fh.service.sunvote.classroster.ClassRosterManager;
  import com.fh.service.sunvote.classtype.ClassTypeManager;
  import com.fh.service.sunvote.coursemanagement.CourseManagementManager;

  import com.fh.service.sunvote.event.EventManager;

  import com.fh.service.sunvote.grade.GradeManager;

  import com.fh.service.sunvote.homework.HomeworkManager;

  import com.fh.service.sunvote.homeworkproblem.HomeworkProblemManager;

  import com.fh.service.sunvote.keypad.KeypadManager;
  import com.fh.service.sunvote.keypadcheck.KeypadCheckManager;
  import com.fh.service.sunvote.knowledge.KnowledgeManager;
  import com.fh.service.sunvote.knowledgechapter.KnowledgeChapterManager;

  import com.fh.service.sunvote.networkstatistics.NetworkStatisticsManager;

  import com.fh.service.sunvote.paper.PaperManager;
  import com.fh.service.sunvote.paperclassteacher.PaperClassTeacherManager;
  import com.fh.service.sunvote.paperquestion.PaperQuestionManager;
  import com.fh.service.sunvote.papertype.PaperTypeManager;
  import com.fh.service.sunvote.question.QuestionManager;
  import com.fh.service.sunvote.questiontype.QuestionTypeManager;
  import com.fh.service.sunvote.school.SchoolManager;
  import com.fh.service.sunvote.schoolgradesubject.SchoolGradeSubjectManager;
  import com.fh.service.sunvote.sclass.SClassManager;

  import com.fh.service.sunvote.student.StudentManager;

  import com.fh.service.sunvote.studenttest.StudentTestManager;

  import com.fh.service.sunvote.subject.SubjectManager;

  import com.fh.service.sunvote.teacher.TeacherManager;

  import com.fh.service.sunvote.teachingmaterial.TeachingMaterialManager;

  import com.fh.service.sunvote.testpaper.TestPaperManager;

  import com.fh.service.sunvote.testpaperinfo.TestPaperInfoManager;

  import com.fh.service.sunvote.textbook.TextbookManager;

  import com.fh.service.system.user.UserManager;

  import com.fh.util.DbFH;

  import com.fh.util.PageData;

  import com.fh.util.Tools;
  
  @Controller
  @RequestMapping(value = "/api/v1")
  public class V1 extends BaseController {

  	@Resource(name = "schoolService")
  	private SchoolManager schoolService;
  
  	@Resource(name = "basestationService")
  	private BasestationManager basestationService;

  
  	@Resource(name = "chapterService")

  	private ChapterManager chapterService;

  
  	@Resource(name = "classbasetationService")

  	private ClassBasetationManager classbasetationService;

  
  	@Resource(name = "classrosterService")

  	private ClassRosterManager classrosterService;

  
  	@Resource(name = "classtypeService")

  	private ClassTypeManager classtypeService;

  
  	@Resource(name = "gradeService")

  	private GradeManager gradeService;

  
  	@Resource(name = "coursemanagementService")

  	private CourseManagementManager coursemanagementService;
  
  	@Resource(name = "keypadService")
  	private KeypadManager keypadService;

  
  	@Resource(name = "keypadcheckService")

  	private KeypadCheckManager keypadcheckService;

  
  	@Resource(name = "knowledgeService")

  	private KnowledgeManager knowledgeService;

  
  	@Resource(name = "knowledgechapterService")

  	private KnowledgeChapterManager knowledgechapterService;

  
  	@Resource(name = "paperService")

  	private PaperManager paperService;

  
  	@Resource(name = "paperclassteacherService")

  	private PaperClassTeacherManager paperclassteacherService;

  
  	@Resource(name = "paperquestionService")

  	private PaperQuestionManager paperquestionService;

  
  	@Resource(name = "papertypeService")

  	private PaperTypeManager papertypeService;

  
  	@Resource(name = "questionService")

  	private QuestionManager questionService;

  
  	@Resource(name = "questiontypeService")

  	private QuestionTypeManager questiontypeService;

  
  	@Resource(name = "schoolgradesubjectService")

  	private SchoolGradeSubjectManager schoolgradesubjectService;

  
  	@Resource(name = "sclassService")

  	private SClassManager sclassService;

  	
  	@Resource(name="homeworkService")
  	private HomeworkManager homeworkService;
  	

  	@Resource(name = "studentService")

  	private StudentManager studentService;

  
  	@Resource(name = "subjectService")

  	private SubjectManager subjectService;

  
  	@Resource(name = "teacherService")

  	private TeacherManager teacherService;

  
  	@Resource(name = "testpaperinfoService")

  	private TestPaperInfoManager testpaperinfoService;
  

  	@Resource(name = "testpaperService")
  	private TestPaperManager testpaperService;
  
  	@Resource(name = "studenttestService")
  	private StudentTestManager studenttestService;
  

  	@Resource(name = "feedbackService")
  	private FeedbackManager feedbackService;
  
  	@Resource(name = "problemphenomenonService")
  	private ProblemPhenomenonManager problemphenomenonService;

  	@Resource(name = "v1Service")

  	private V1Manager v1Service;

  
  	@Resource(name = "softwareversionService")

  	private SoftwareVersionManager softwareversionService;

  
  	@Resource(name = "attachkeyboardService")

  	private AttachKeyboardManager attachkeyboardService;

  
  	@Resource(name = "networkstatisticsService")

  	private NetworkStatisticsManager networkstatisticsService;

  
  	@Resource(name = "eventService")

  	private EventManager eventService;

  
  	@Resource(name = "userService")

  	private UserManager userService;

  	@Resource(name = "teachingmaterialService")
  	private TeachingMaterialManager teachingmaterialService;

  	@Resource(name = "textbookService")
  	private TextbookManager textbookService;

  
  	@Resource(name = "cacheService")

  	private CacheManager cacheService;

  	
  	@Resource(name="homeworkproblemService")
  	private HomeworkProblemManager homeworkproblemService;
  	

  	/**

  	 * 登录 可以通过账号密码登录、 可以通过教师卡登录
  	 * 

  	 * @return
  	 * @throws Exception
  	 */

  	@RequestMapping(value = "/login", produces = "application/json;charset=UTF-8")
  	@ResponseBody
  	public Object login() throws Exception {

  		event("apilogin");

  		PageData pd = this.getPageData();
  		ResponseGson<PageData> res = new ResponseGson();

  		if (!pd.containsKey("ACCOUT")) {

  			pd.put("ACCOUT", pd.get("USERNAME"));
  		}

  		if (((pd.containsKey("USERNAME") || (pd.containsKey("ACCOUT") && pd
  				.get("ACCOUT") != null)) && pd.containsKey("PASSWORD"))
  				|| pd.containsKey("KEYPAD_ID")) {

  			PageData pageData = teacherService.getUserInfo(pd);

  			if (pageData != null && pageData.getString("ID") != null) {
  				pageData.put("PASSWORD", "");// 返回参数中不返回密码

  				PageData pt = new PageData();
  				pt.put("TEACHER_ID", pageData.get("ID"));
  				// 在任课表中查找老师教哪些班级，然后查出班级信息

  				List<PageData> classInfoList = v1Service
  						.getTeacherClassInfo(pt);
  

  				pageData.put("classInfoList", classInfoList);
  				// 在认可表中查找老师教哪些科目，然后查出科目信息

  				List<PageData> subjectList = v1Service
  						.getTeacherSubjectInfo(pt);

  				// 一个sql语句完成。
  				pageData.put("subjectList", subjectList);

  				pageData.remove("SUBJECT_IDS");

  				PageData eventPd = new PageData();
  				eventPd.put("EVENT_ID", get32UUID());
  				eventPd.put("EVENT_NAME", "login");
  				eventPd.put("EVENT_USER", pageData.getString("ID"));
  				eventPd.put("EVENT_TYPE", "0");

  				eventPd.put("EVENT_START_TIME", Tools.date2Str(new Date()));
  				if (pd.getString("CLIENT_ID") != null) {

  					eventPd.put("CLIENT_ID", pd.getString("CLIENT_ID"));

  				} else {

  					eventPd.put("CLIENT_ID", "CLIENT");
  				}

  				eventPd.put("EVENT_IP", getRemoteIp());

  				eventService.save(eventPd);

  				res.setData(pageData);
  				// 填充数据到返回数据中

  			} else {

  				res.set1Error();
  			}

  		} else {

  			res.set1Error();
  		}

  		return res.toJson();
  	}

  	/**

  	 * 登录 可以通过账号密码登录、 可以通过教师卡登录
  	 * 

  	 * @return
  	 * @throws Exception
  	 */
  	@RequestMapping(value = "/userinfo", produces = "application/json;charset=UTF-8")
  	@ResponseBody
  	public Object userinfo() throws Exception {
  		event("userinfo");
  		PageData pd = this.getPageData();
  		ResponseGson<PageData> res = new ResponseGson();
  		PageData pageData = teacherService.findById(pd);
  		if (pageData != null && pageData.getString("ID") != null) {
  			pageData.put("PASSWORD", "");// 返回参数中不返回密码
  			PageData pt = new PageData();
  			pt.put("TEACHER_ID", pageData.get("ID"));
  			// 在任课表中查找老师教哪些班级，然后查出班级信息

  			List<PageData> classInfoList = v1Service.getTeacherClassInfo(pt);
  

  			pageData.put("classInfoList", classInfoList);
  			// 在认可表中查找老师教哪些科目，然后查出科目信息

  			List<PageData> subjectList = v1Service.getTeacherSubjectInfo(pt);

  			// 一个sql语句完成。
  			pageData.put("subjectList", subjectList);

  			pageData.remove("SUBJECT_IDS");

  			PageData eventPd = new PageData();
  			eventPd.put("EVENT_ID", get32UUID());
  			eventPd.put("EVENT_NAME", "login");
  			eventPd.put("EVENT_USER", pageData.getString("ID"));
  			eventPd.put("EVENT_TYPE", "0");
  			eventPd.put("EVENT_START_TIME", Tools.date2Str(new Date()));
  			if (pd.getString("CLIENT_ID") != null) {
  				eventPd.put("CLIENT_ID", pd.getString("CLIENT_ID"));
  			} else {
  				eventPd.put("CLIENT_ID", "CLIENT");
  			}
  			eventPd.put("EVENT_IP", getRemoteIp());
  			eventService.save(eventPd);

  			res.setData(pageData);
  			// 填充数据到返回数据中
  		} else {
  			res.set1Error();
  		}

  		return res.toJson();
  	}

  	/**

  	 * 查询班级 班级及班级学生详细信息
  	 * 

  	 * @return
  	 * @throws Exception
  	 */

  	@RequestMapping(value = "/class", produces = "application/json;charset=UTF-8")
  	@ResponseBody
  	public Object sclass() throws Exception {

  		event("sclass");

  		long cur = System.currentTimeMillis();

  		PageData pd = this.getPageData();

  		if (pd.containsKey("ID")) {

  			ResponseGson<PageData> res = new ResponseGson();

  			PageData pageData = sclassService.findById(pd);
  			if (pageData != null && pageData.containsKey("ID")) {
  				PageData pt = new PageData();
  				pt.put("SCLASS_ID", pageData.get("ID"));

  				List<PageData> studentList = v1Service.getClassStudent(pt);

  				pageData.put("studentList", studentList);

  				pt.put("CLASS_ID", pageData.get("ID"));

  				List<PageData> keyboards = attachkeyboardService
  						.listAllClassId(pt);

  				pageData.put("keyboards", keyboards);

  				res.setData(pageData);
  			} else {
  				res.set2Error();
  			}

  			logger.info("class cost time : "
  					+ (System.currentTimeMillis() - cur));

  			return res.toJson();
  		} else {
  			ResponseGson<List<PageData>> res = new ResponseGson();
  			List<PageData> list = sclassService.listAll(pd);
  			res.setData(list);

  			logger.info("class cost time : "
  					+ (System.currentTimeMillis() - cur));

  			return res.toJson();

  		}
  	}

  	/**
  	 * 问题类型

  	 * 

  	 * @return
  	 * @throws Exception
  	 */

  	@RequestMapping(value = "/questiontype", produces = "application/json;charset=UTF-8")
  	@ResponseBody
  	public Object questiontype() throws Exception {

  		event("questiontype");

  		long cur = System.currentTimeMillis();

  		PageData pd = this.getPageData();
  		ResponseGson<List<PageData>> res = new ResponseGson();
  		List<PageData> list = questiontypeService.listAll(pd);
  		res.setData(list);

  		logger.info("questiontype cost time : "
  				+ (System.currentTimeMillis() - cur));

  		return res.toJson();
  	}

  	/**
  	 * 班级类型

  	 * 

  	 * @return
  	 * @throws Exception
  	 */

  	@RequestMapping(value = "/classtype", produces = "application/json;charset=UTF-8")
  	@ResponseBody
  	public Object classtype() throws Exception {

  		event("classtype");

  		long cur = System.currentTimeMillis();

  		PageData pd = this.getPageData();
  		ResponseGson<List<PageData>> res = new ResponseGson();
  		List<PageData> list = classtypeService.listAll(pd);
  		res.setData(list);

  		logger.info("classtype cost time : "
  				+ (System.currentTimeMillis() - cur));

  		return res.toJson();
  	}

  	/**

  	 * 年级 年级类型
  	 * 

  	 * @return
  	 * @throws Exception
  	 */

  	@RequestMapping(value = "/grade", produces = "application/json;charset=UTF-8")
  	@ResponseBody
  	public Object grade() throws Exception {

  		event("grade");

  		long cur = System.currentTimeMillis();

  		PageData pd = this.getPageData();
  		ResponseGson<List<PageData>> res = new ResponseGson();
  		if (!pd.containsKey("SCHOOL_ID")) {
  			List<PageData> list = gradeService.listAll(pd);
  			res.setData(list);

  		} else {

  			List<PageData> list = schoolgradesubjectService.listAllGrade(pd);
  			res.setData(list);

  		}

  		logger.info("class cost time : " + (System.currentTimeMillis() - cur));

  		return res.toJson();
  	}

  	/**
  	 * 科目

  	 * 

  	 * @return
  	 * @throws Exception
  	 */

  	@RequestMapping(value = "/subject", produces = "application/json;charset=UTF-8")
  	@ResponseBody
  	public Object subject() throws Exception {

  		event("subject");

  		long cur = System.currentTimeMillis();

  		PageData pd = this.getPageData();
  		ResponseGson<List<PageData>> res = new ResponseGson();
  		if (!pd.containsKey("SCHOOL_ID")) {
  			List<PageData> list = subjectService.listAll(pd);
  			res.setData(list);
  		} else {
  			List<PageData> list = schoolgradesubjectService.listAllSubject(pd);
  			res.setData(list);
  		}

  		logger.info("subject cost time : " + (System.currentTimeMillis() - cur));

  		return res.toJson();
  	}

  	/**
  	 * 科目

  	 * 

  	 * @return
  	 * @throws Exception
  	 */
  	@RequestMapping(value = "/subjectname", produces = "application/json;charset=UTF-8")
  	@ResponseBody
  	public Object subjectName() throws Exception {

  		event("subjectName");

  		long cur = System.currentTimeMillis();
  		PageData pd = this.getPageData();
  		ResponseGson<List<PageData>> res = new ResponseGson();
  		if (!pd.containsKey("SCHOOL_ID")) {
  			List<PageData> list = subjectService.listAll(pd);
  			res.setData(list);
  		} else {
  			List<PageData> list = schoolgradesubjectService.listAllSubject(pd);
  			res.setData(list);
  		}
  		logger.info("subject cost time : " + (System.currentTimeMillis() - cur));
  		return res.toJson();
  	}

  	/**
  	 * 键盘扫描

  	 * 

  	 * @return
  	 * @throws Exception
  	 */

  	@RequestMapping(value = "/keypadscan", produces = "application/json;charset=UTF-8")
  	@ResponseBody
  	public Object keypadScan() throws Exception {

  		event("keypadScan");

  		long cur = System.currentTimeMillis();

  		PageData pd = this.getPageData();

  		ResponseGson<String> res = new ResponseGson();
  		String ID = get32UUID();
  		pd.put("KEYPADCHECK_ID", ID); // 主键
  		pd.put("CREATE_DATE", Tools.date2Str(new Date())); // 创建时间
  		try {

  			keypadcheckService.save(pd);

  			res.setData(ID);

  			res.setSuccess();

  		} catch (Exception ex) {

  			res.setDataError();
  		}

  		logger.info("keypadScan cost time : "
  				+ (System.currentTimeMillis() - cur));

  		return res.toJson();
  	}

  	/**
  	 * showcount 数量 currentpage 当前页码
  	 * 
  	 * @return
  	 * @throws Exception
  	 */

  	@RequestMapping(value = "/paper", produces = "application/json;charset=UTF-8")
  	@ResponseBody
  	public Object paper() throws Exception {

  		event("paper");

  		long cur = System.currentTimeMillis();

  		PageData pd = this.getPageData();
  		ResponseGson<List<PageData>> res = new ResponseGson<List<PageData>>();

  		if (pd.containsKey("PAPER_TYPE")) {

  			String CURRENTPAGE = pd.getString("CURRENTPAGE");
  			String SHOWCOUNT = pd.getString("SHOWCOUNT");

  			if (CURRENTPAGE != null && SHOWCOUNT != null
  					&& !"".equals(CURRENTPAGE.trim())
  					&& !"".equals(SHOWCOUNT.trim())) {

  				int currentPage = Integer.parseInt(CURRENTPAGE);
  				int showcount = Integer.parseInt(SHOWCOUNT);

  				currentPage = (currentPage > 0 ? currentPage - 1 : 0)
  						* showcount;

  				pd.put("CURRENTPAGE", "" + currentPage);

  			}

  			List<PageData> pageList = paperService.listAllByType(pd);

  			res.setData(pageList);

  		} else {

  			res.setDataError();

  		}

  		logger.info("paper cost time : " + (System.currentTimeMillis() - cur));

  		return res.toJson();
  	}

  	/**
  	 * 试卷详细信息

  	 * 

  	 * @return
  	 * @throws Exception
  	 */

  	@RequestMapping(value = "/paperinfo", produces = "application/json;charset=UTF-8")

  	@ResponseBody

  	public Object paperInfo() throws Exception {

  		event("paperInfo");

  		long cur = System.currentTimeMillis();

  		PageData pd = this.getPageData();

  		ResponseGson<Paper> res = new ResponseGson<Paper>();
  		if (pd.containsKey("PAPER_ID")) {
  			try {
  				try {
  					Paper paper = new Paper();
  					PageData ppd = paperService.findById(pd);
  					if (ppd != null) {
  						paper.setTitle(ppd.getString("TITLE"));
  						paper.setExam_time(ppd.getString("EXAM_TIME"));
  						paper.setUser_id(ppd.getString("USER_ID"));
  						paper.setPaper_type(ppd.getString("PAPER_TYPE"));
  						paper.setSubject_id(ppd.getString("SUBJECT_ID"));
  						paper.setGrade_id(ppd.getString("GRADE_ID"));
  						paper.setScore(ppd.getString("SCORE"));

  						paper.setSchool_id(ppd.getString("SCHOOL_ID"));

  						paper.setQuestions(new ArrayList<Question>());
  
  						List<PageData> questList = v1Service
  								.getTestPaperInfo(pd);
  						for (PageData qpd : questList) {
  							Question question = new Question();
  							question.setAnswer(qpd.getString("ANSWER"));
  							question.setQuestion_id(qpd
  									.getString("QUESTION_ID"));
  							question.setSubject_id(qpd.getString("SUBJECT_ID"));
  							question.setChapter_id(qpd.getString("CHAPTER_ID"));
  							question.setProblem_type_id(qpd
  									.getString("PROBLEM_TYPE_ID"));
  							question.setKnowledge_id(qpd
  									.getString("KNOWLEDGE_ID"));
  							question.setContent(qpd.getString("CONTENT"));
  							question.setOption_num(qpd.getString("OPTION_NUM"));
  							question.setOption_content(qpd
  									.getString("OPTION_CONTENT"));
  							question.setDifficulty(qpd.getString("DIFFICULTY"));
  							question.setAnalysis(qpd.getString("ANALYSIS"));
  							question.setQuestion_from(qpd
  									.getString("QUESTION_FROM"));
  							question.setScore(qpd.getString("SCORE"));
  							question.setPart_score(qpd.getString("PART_SCORE"));
  							question.setQuestionType(qpd
  									.getString("PROBLEM_TYPE_ID"));
  							question.setRank(qpd.getString("RANK"));
  							question.setNo_name(qpd.getString("NO_NAME"));

  							question.setQuestions(new ArrayList<Question>());

  							if ("-1".equals("" + qpd.getString("P_ID"))) {
  								PageData pidPd = new PageData();
  								pidPd.put("PID", question.getQuestion_id());

  								List<PageData> qs = v1Service
  										.getQuestionsByPID(pidPd);
  								for (PageData q : qs) {
  									Question qq = new Question();
  									qq.setAnswer(q.getString("ANSWER"));
  									qq.setQuestion_id(q
  											.getString("QUESTION_ID"));
  									qq.setSubject_id(q.getString("SUBJECT_ID"));
  									qq.setChapter_id(q.getString("CHAPTER_ID"));
  									qq.setProblem_type_id(q
  											.getString("PROBLEM_TYPE_ID"));
  									qq.setKnowledge_id(q
  											.getString("KNOWLEDGE_ID"));
  									qq.setContent(q.getString("CONTENT"));
  									qq.setOption_num(q.getString("OPTION_NUM"));
  									qq.setOption_content(q
  											.getString("OPTION_CONTENT"));
  									qq.setDifficulty(q.getString("DIFFICULTY"));
  									qq.setAnalysis(q.getString("ANALYSIS"));
  									qq.setQuestion_from(q
  											.getString("QUESTION_FROM"));
  									qq.setScore(q.getString("SCORE"));
  									qq.setPart_score(q.getString("PART_SCORE"));
  									qq.setQuestionType(qpd
  											.getString("PROBLEM_TYPE_ID"));
  									qq.setRank(q.getString("RANK"));
  									qq.setNo_name(q.getString("NO_NAME"));
  									question.getQuestions().add(qq);
  								}
  							}
  							if ("-1".equals(qpd.getString("P_ID"))
  									|| "0".equals(qpd.getString("P_ID"))) {
  								paper.getQuestions().add(question);
  							}
  						}
  						// pd.put("JSON", paper.toJson());
  						res.setData(paper);
  						logger.info(paper.toJson());
  
  					}
  				} catch (Exception ex) {
  					ex.printStackTrace();
  				}
  			} catch (Exception ex) {
  				ex.printStackTrace();
  				res.setError();
  			}
  		} else {
  			res.setOtherError();
  		}
  		logger.info("paperInfo cost time : "
  				+ (System.currentTimeMillis() - cur));
  		return res.toJson();
  	}

  
  	/*	*//**

  	 * 试卷详细信息

  	 * 

  	 * @return
  	 * @throws Exception

  	 */
  	/*
  	 * @RequestMapping(value = "/paperinfo", produces =
  	 * "application/json;charset=UTF-8")
  	 * 
  	 * @ResponseBody public Object paperInfo() throws Exception {
  	 * event("paperInfo"); long cur = System.currentTimeMillis(); PageData pd =
  	 * this.getPageData(); ResponseGson<PageData> res = new
  	 * ResponseGson<PageData>(); if (pd.containsKey("PAPER_ID")) { try { try {
  	 * PageData ppd = paperService.findById(pd); if (ppd != null) {
  	 * List<PageData> questList = v1Service .getTestPaperInfo(pd);
  	 * ppd.put("QUESTIONS", questList); for (PageData qpd : questList) {
  	 * 
  	 * String optionContent = qpd .getString("OPTION_CONTENT"); if
  	 * (optionContent != null && optionContent.startsWith("[") &&
  	 * optionContent.endsWith("]")) { String[] options =
  	 * optionContent.substring(1, optionContent.length() - 1).split(",");
  	 * qpd.put("OPTION_CONTENT", options); } else { qpd.put("OPTION_CONTENT",
  	 * new String[] { optionContent }); } if ("-1".equals("" +
  	 * qpd.getString("P_ID"))) { PageData pidPd = new PageData();
  	 * pidPd.put("PID", qpd.getString("QUESTION_ID")); List<PageData> qs =
  	 * v1Service .getQuestionsByPID(pidPd); for (PageData pcd : qs) { String
  	 * optionContent1 = pcd .getString("OPTION_CONTENT"); if (optionContent1 !=
  	 * null && optionContent1.startsWith("[") && optionContent1.endsWith("]")) {
  	 * String[] options = optionContent1 .substring( 1, optionContent1.length()
  	 * - 1) .split(","); pcd.put("OPTION_CONTENT", options); } else {
  	 * pcd.put("OPTION_CONTENT", new String[] { optionContent1 }); } String[]
  	 * keys = new String[pcd.keySet().size()]; pcd.keySet().toArray(keys);
  	 * Iterator map1it = pcd.entrySet().iterator(); for (String key : keys) {
  	 * pcd.put(key.toLowerCase(),pcd.get(key)); pcd.remove(key.toUpperCase()); }
  	 * } qpd.put("QUESTIONS", qs); }
  	 * 
  	 * String[] keys = new String[qpd.keySet().size()];
  	 * qpd.keySet().toArray(keys); for (String key : keys) {
  	 * qpd.put(key.toLowerCase(), qpd.get(key)); qpd.remove(key.toUpperCase());
  	 * }
  	 * 
  	 * } String[] keys = new String[ppd.keySet().size()];
  	 * ppd.keySet().toArray(keys); for (String key : keys) {
  	 * ppd.put(key.toLowerCase(), ppd.get(key)); ppd.remove(key.toUpperCase());
  	 * } // pd.put("JSON", paper.toJson()); res.setData(ppd);
  	 * logger.info(res.toJson());
  	 * 
  	 * } } catch (Exception ex) { ex.printStackTrace(); } } catch (Exception ex)
  	 * { ex.printStackTrace(); res.setError(); } } else { res.setOtherError(); }
  	 * logger.info("paperInfo cost time : " + (System.currentTimeMillis() -
  	 * cur)); return res.toJson(); }
  	 *//**