Blame view

src/com/fh/controller/api/V1.java 105 KB
bed6e1fc   孙向锦   添加其他功能
1
2
  package com.fh.controller.api;
  
757dfed6   孙向锦   样例报表
3
  import java.io.File;
107fa3a0   孙向锦   修改试卷单选多远混合出题
4
5
6
  import java.sql.Connection;
  import java.sql.ResultSet;
  import java.sql.Statement;
338594c8   孙向锦   添加教师端页面
7
  import java.util.ArrayList;
757dfed6   孙向锦   样例报表
8
9
  import java.util.Collections;
  import java.util.Comparator;
bed6e1fc   孙向锦   添加其他功能
10
  import java.util.Date;
ce70231e   孙向锦   增加接口
11
  import java.util.Iterator;
bed6e1fc   孙向锦   添加其他功能
12
  import java.util.List;
ce70231e   孙向锦   增加接口
13
  import java.util.Map;
bed6e1fc   孙向锦   添加其他功能
14
15
  
  import javax.annotation.Resource;
2480c889   孙向锦   添加软件管理模块。对软件形成统一的管理
16
  import javax.servlet.http.HttpServletRequest;
bed6e1fc   孙向锦   添加其他功能
17
  
338594c8   孙向锦   添加教师端页面
18
  import org.apache.commons.lang.StringUtils;
d3d7b2ca   孙向锦   修改表格固定
19
  import org.apache.shiro.crypto.hash.SimpleHash;
bed6e1fc   孙向锦   添加其他功能
20
  import org.springframework.stereotype.Controller;
bed6e1fc   孙向锦   添加其他功能
21
  import org.springframework.web.bind.annotation.RequestMapping;
757dfed6   孙向锦   样例报表
22
  import org.springframework.web.bind.annotation.RequestParam;
bed6e1fc   孙向锦   添加其他功能
23
  import org.springframework.web.bind.annotation.ResponseBody;
757dfed6   孙向锦   样例报表
24
  import org.springframework.web.multipart.MultipartFile;
bed6e1fc   孙向锦   添加其他功能
25
  
338594c8   孙向锦   添加教师端页面
26
  import com.fh.bean.Paper;
ce70231e   孙向锦   增加接口
27
  import com.fh.bean.Point;
338594c8   孙向锦   添加教师端页面
28
  import com.fh.bean.Question;
a479f295   孙向锦   添加了报表逻辑
29
30
  import com.fh.bean.ResultHomework;
  import com.fh.bean.ResultHomework.ResultStudent;
91a745c9   孙向锦   完善后台功能
31
32
33
  import com.fh.bean.StudentAnswer;
  import com.fh.bean.TestPaper;
  import com.fh.bean.TestPaperInfo;
bed6e1fc   孙向锦   添加其他功能
34
  import com.fh.controller.base.BaseController;
338594c8   孙向锦   添加教师端页面
35
  import com.fh.controller.sunvote.Myelfun;
bed6e1fc   孙向锦   添加其他功能
36
37
38
  import com.fh.service.api.V1Manager;
  import com.fh.service.feedback.feedback.FeedbackManager;
  import com.fh.service.feedback.problemphenomenon.ProblemPhenomenonManager;
2480c889   孙向锦   添加软件管理模块。对软件形成统一的管理
39
  import com.fh.service.software.softwareversion.SoftwareVersionManager;
9f161055   孙向锦   修改高斯客户反馈
40
  import com.fh.service.sunvote.attachkeyboard.AttachKeyboardManager;
bed6e1fc   孙向锦   添加其他功能
41
  import com.fh.service.sunvote.basestation.BasestationManager;
ce70231e   孙向锦   增加接口
42
  import com.fh.service.sunvote.cache.CacheManager;
bed6e1fc   孙向锦   添加其他功能
43
44
45
46
47
  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;
9338b563   孙向锦   添加报表
48
  import com.fh.service.sunvote.event.EventManager;
bed6e1fc   孙向锦   添加其他功能
49
  import com.fh.service.sunvote.grade.GradeManager;
48d44272   孙向锦   添加一些action
50
  import com.fh.service.sunvote.headmaster.HeadmasterManager;
694fbd54   孙向锦   添加作业管理模块
51
  import com.fh.service.sunvote.homework.HomeworkManager;
a479f295   孙向锦   添加了报表逻辑
52
  import com.fh.service.sunvote.homework.HomeworkReportManager;
416902b7   孙向锦   添加课后作业部分API
53
  import com.fh.service.sunvote.homeworkproblem.HomeworkProblemManager;
bed6e1fc   孙向锦   添加其他功能
54
55
56
57
  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;
9338b563   孙向锦   添加报表
58
  import com.fh.service.sunvote.networkstatistics.NetworkStatisticsManager;
bed6e1fc   孙向锦   添加其他功能
59
60
61
62
63
64
65
66
67
  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;
bed6e1fc   孙向锦   添加其他功能
68
  import com.fh.service.sunvote.student.StudentManager;
91a745c9   孙向锦   完善后台功能
69
  import com.fh.service.sunvote.studenttest.StudentTestManager;
bed6e1fc   孙向锦   添加其他功能
70
  import com.fh.service.sunvote.subject.SubjectManager;
bed6e1fc   孙向锦   添加其他功能
71
  import com.fh.service.sunvote.teacher.TeacherManager;
ce70231e   孙向锦   增加接口
72
  import com.fh.service.sunvote.teachingmaterial.TeachingMaterialManager;
91a745c9   孙向锦   完善后台功能
73
  import com.fh.service.sunvote.testpaper.TestPaperManager;
bed6e1fc   孙向锦   添加其他功能
74
  import com.fh.service.sunvote.testpaperinfo.TestPaperInfoManager;
c617106f   孙向锦   添加即时测功能
75
  import com.fh.service.sunvote.textbook.TextbookManager;
d3d7b2ca   孙向锦   修改表格固定
76
  import com.fh.service.system.user.UserManager;
107fa3a0   孙向锦   修改试卷单选多远混合出题
77
  import com.fh.util.DbFH;
bed6e1fc   孙向锦   添加其他功能
78
  import com.fh.util.PageData;
bed6e1fc   孙向锦   添加其他功能
79
80
81
82
83
  import com.fh.util.Tools;
  
  @Controller
  @RequestMapping(value = "/api/v1")
  public class V1 extends BaseController {
91a745c9   孙向锦   完善后台功能
84
  
bed6e1fc   孙向锦   添加其他功能
85
86
87
88
89
  	@Resource(name = "schoolService")
  	private SchoolManager schoolService;
  
  	@Resource(name = "basestationService")
  	private BasestationManager basestationService;
91a745c9   孙向锦   完善后台功能
90
91
  
  	@Resource(name = "chapterService")
bed6e1fc   孙向锦   添加其他功能
92
  	private ChapterManager chapterService;
91a745c9   孙向锦   完善后台功能
93
94
  
  	@Resource(name = "classbasetationService")
bed6e1fc   孙向锦   添加其他功能
95
  	private ClassBasetationManager classbasetationService;
91a745c9   孙向锦   完善后台功能
96
97
  
  	@Resource(name = "classrosterService")
bed6e1fc   孙向锦   添加其他功能
98
  	private ClassRosterManager classrosterService;
91a745c9   孙向锦   完善后台功能
99
100
  
  	@Resource(name = "classtypeService")
1c817fc8   孙向锦   修改一些bug信息
101
  	private ClassTypeManager classtypeService; 
91a745c9   孙向锦   完善后台功能
102
103
  
  	@Resource(name = "gradeService")
bed6e1fc   孙向锦   添加其他功能
104
  	private GradeManager gradeService;
91a745c9   孙向锦   完善后台功能
105
106
  
  	@Resource(name = "coursemanagementService")
bed6e1fc   孙向锦   添加其他功能
107
108
109
110
  	private CourseManagementManager coursemanagementService;
  
  	@Resource(name = "keypadService")
  	private KeypadManager keypadService;
91a745c9   孙向锦   完善后台功能
111
112
  
  	@Resource(name = "keypadcheckService")
bed6e1fc   孙向锦   添加其他功能
113
  	private KeypadCheckManager keypadcheckService;
91a745c9   孙向锦   完善后台功能
114
115
  
  	@Resource(name = "knowledgeService")
bed6e1fc   孙向锦   添加其他功能
116
  	private KnowledgeManager knowledgeService;
91a745c9   孙向锦   完善后台功能
117
118
  
  	@Resource(name = "knowledgechapterService")
bed6e1fc   孙向锦   添加其他功能
119
  	private KnowledgeChapterManager knowledgechapterService;
91a745c9   孙向锦   完善后台功能
120
121
  
  	@Resource(name = "paperService")
bed6e1fc   孙向锦   添加其他功能
122
  	private PaperManager paperService;
91a745c9   孙向锦   完善后台功能
123
124
  
  	@Resource(name = "paperclassteacherService")
bed6e1fc   孙向锦   添加其他功能
125
  	private PaperClassTeacherManager paperclassteacherService;
91a745c9   孙向锦   完善后台功能
126
127
  
  	@Resource(name = "paperquestionService")
bed6e1fc   孙向锦   添加其他功能
128
  	private PaperQuestionManager paperquestionService;
91a745c9   孙向锦   完善后台功能
129
130
  
  	@Resource(name = "papertypeService")
bed6e1fc   孙向锦   添加其他功能
131
  	private PaperTypeManager papertypeService;
91a745c9   孙向锦   完善后台功能
132
133
  
  	@Resource(name = "questionService")
bed6e1fc   孙向锦   添加其他功能
134
  	private QuestionManager questionService;
91a745c9   孙向锦   完善后台功能
135
136
  
  	@Resource(name = "questiontypeService")
bed6e1fc   孙向锦   添加其他功能
137
  	private QuestionTypeManager questiontypeService;
91a745c9   孙向锦   完善后台功能
138
139
  
  	@Resource(name = "schoolgradesubjectService")
bed6e1fc   孙向锦   添加其他功能
140
  	private SchoolGradeSubjectManager schoolgradesubjectService;
91a745c9   孙向锦   完善后台功能
141
142
  
  	@Resource(name = "sclassService")
bed6e1fc   孙向锦   添加其他功能
143
  	private SClassManager sclassService;
694fbd54   孙向锦   添加作业管理模块
144
145
146
147
  	
  	@Resource(name="homeworkService")
  	private HomeworkManager homeworkService;
  	
91a745c9   孙向锦   完善后台功能
148
  	@Resource(name = "studentService")
bed6e1fc   孙向锦   添加其他功能
149
  	private StudentManager studentService;
91a745c9   孙向锦   完善后台功能
150
151
  
  	@Resource(name = "subjectService")
bed6e1fc   孙向锦   添加其他功能
152
  	private SubjectManager subjectService;
91a745c9   孙向锦   完善后台功能
153
154
  
  	@Resource(name = "teacherService")
bed6e1fc   孙向锦   添加其他功能
155
  	private TeacherManager teacherService;
48d44272   孙向锦   添加一些action
156
157
158
  	
  	@Resource(name="headmasterService")
  	private HeadmasterManager headmasterService;
91a745c9   孙向锦   完善后台功能
159
160
  
  	@Resource(name = "testpaperinfoService")
bed6e1fc   孙向锦   添加其他功能
161
162
  	private TestPaperInfoManager testpaperinfoService;
  
91a745c9   孙向锦   完善后台功能
163
164
165
166
167
168
  	@Resource(name = "testpaperService")
  	private TestPaperManager testpaperService;
  
  	@Resource(name = "studenttestService")
  	private StudentTestManager studenttestService;
  
bed6e1fc   孙向锦   添加其他功能
169
170
171
172
173
  	@Resource(name = "feedbackService")
  	private FeedbackManager feedbackService;
  
  	@Resource(name = "problemphenomenonService")
  	private ProblemPhenomenonManager problemphenomenonService;
91a745c9   孙向锦   完善后台功能
174
  
bed6e1fc   孙向锦   添加其他功能
175
  	@Resource(name = "v1Service")
91a745c9   孙向锦   完善后台功能
176
  	private V1Manager v1Service;
ce70231e   孙向锦   增加接口
177
178
  
  	@Resource(name = "softwareversionService")
2480c889   孙向锦   添加软件管理模块。对软件形成统一的管理
179
  	private SoftwareVersionManager softwareversionService;
ce70231e   孙向锦   增加接口
180
181
  
  	@Resource(name = "attachkeyboardService")
9f161055   孙向锦   修改高斯客户反馈
182
  	private AttachKeyboardManager attachkeyboardService;
ce70231e   孙向锦   增加接口
183
184
  
  	@Resource(name = "networkstatisticsService")
9338b563   孙向锦   添加报表
185
  	private NetworkStatisticsManager networkstatisticsService;
ce70231e   孙向锦   增加接口
186
187
  
  	@Resource(name = "eventService")
9338b563   孙向锦   添加报表
188
  	private EventManager eventService;
ce70231e   孙向锦   增加接口
189
190
  
  	@Resource(name = "userService")
d3d7b2ca   孙向锦   修改表格固定
191
  	private UserManager userService;
91a745c9   孙向锦   完善后台功能
192
  
ce70231e   孙向锦   增加接口
193
194
  	@Resource(name = "teachingmaterialService")
  	private TeachingMaterialManager teachingmaterialService;
107fa3a0   孙向锦   修改试卷单选多远混合出题
195
  
c617106f   孙向锦   添加即时测功能
196
197
  	@Resource(name = "textbookService")
  	private TextbookManager textbookService;
2ad7ca45   孙向锦   试卷bug修改
198
199
  
  	@Resource(name = "cacheService")
ce70231e   孙向锦   增加接口
200
  	private CacheManager cacheService;
416902b7   孙向锦   添加课后作业部分API
201
202
203
204
  	
  	@Resource(name="homeworkproblemService")
  	private HomeworkProblemManager homeworkproblemService;
  	
a479f295   孙向锦   添加了报表逻辑
205
206
207
  	@Resource(name="homeworkReporService")
  	private HomeworkReportManager homeworkReporkService;
  	
2ad7ca45   孙向锦   试卷bug修改
208
  	/**
107fa3a0   孙向锦   修改试卷单选多远混合出题
209
210
  	 * 登录 可以通过账号密码登录、 可以通过教师卡登录
  	 * 
2ad7ca45   孙向锦   试卷bug修改
211
212
213
  	 * @return
  	 * @throws Exception
  	 */
bed6e1fc   孙向锦   添加其他功能
214
215
216
  	@RequestMapping(value = "/login", produces = "application/json;charset=UTF-8")
  	@ResponseBody
  	public Object login() throws Exception {
3371dbc6   孙向锦   0720 版本
217
  		event("apilogin");
bed6e1fc   孙向锦   添加其他功能
218
219
  		PageData pd = this.getPageData();
  		ResponseGson<PageData> res = new ResponseGson();
91a745c9   孙向锦   完善后台功能
220
  		if (!pd.containsKey("ACCOUT")) {
bed6e1fc   孙向锦   添加其他功能
221
222
  			pd.put("ACCOUT", pd.get("USERNAME"));
  		}
ce70231e   孙向锦   增加接口
223
224
225
  		if (((pd.containsKey("USERNAME") || (pd.containsKey("ACCOUT") && pd
  				.get("ACCOUT") != null)) && pd.containsKey("PASSWORD"))
  				|| pd.containsKey("KEYPAD_ID")) {
48d44272   孙向锦   添加一些action
226
227
228
229
230
231
232
233
234
235
236
237
238
239
  			PageData eventPd = new PageData();
  			eventPd.put("EVENT_ID", get32UUID());
  			eventPd.put("EVENT_NAME", "login");
  			eventPd.put("EVENT_USER", pd.getString("USERNAME"));
  			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);
  			
bed6e1fc   孙向锦   添加其他功能
240
  			PageData pageData = teacherService.getUserInfo(pd);
d8407bb2   孙向锦   修复部分bug
241
242
243
244
245
246
  			if(pageData == null){
  				pd.put("PASSWORD",
  						new SimpleHash("SHA-1", pd.getString("ACCOUT"), pd
  								.getString("PASSWORD")).toString());
  				pageData = teacherService.getUserInfo(pd);
  			}
48d44272   孙向锦   添加一些action
247
  			PageData headerMaster = headmasterService.findByUsenameAndPassword(pd);
91a745c9   孙向锦   完善后台功能
248
249
  			if (pageData != null && pageData.getString("ID") != null) {
  				pageData.put("PASSWORD", "");// 返回参数中不返回密码
bed6e1fc   孙向锦   添加其他功能
250
251
252
  				PageData pt = new PageData();
  				pt.put("TEACHER_ID", pageData.get("ID"));
  				// 在任课表中查找老师教哪些班级,然后查出班级信息
91a745c9   孙向锦   完善后台功能
253
254
255
  				List<PageData> classInfoList = v1Service
  						.getTeacherClassInfo(pt);
  
bed6e1fc   孙向锦   添加其他功能
256
257
  				pageData.put("classInfoList", classInfoList);
  				// 在认可表中查找老师教哪些科目,然后查出科目信息
91a745c9   孙向锦   完善后台功能
258
259
  				List<PageData> subjectList = v1Service
  						.getTeacherSubjectInfo(pt);
bed6e1fc   孙向锦   添加其他功能
260
261
  				// 一个sql语句完成。
  				pageData.put("subjectList", subjectList);
91a745c9   孙向锦   完善后台功能
262
  
bed6e1fc   孙向锦   添加其他功能
263
  				pageData.remove("SUBJECT_IDS");
ce70231e   孙向锦   增加接口
264
  
48d44272   孙向锦   添加一些action
265
266
  				
  				pageData.put("role", "teacher");
bed6e1fc   孙向锦   添加其他功能
267
268
  				res.setData(pageData);
  				// 填充数据到返回数据中
48d44272   孙向锦   添加一些action
269
  			} else if(headerMaster != null && headerMaster.get("HEADMASTER_ID") != null){
48d44272   孙向锦   添加一些action
270
271
  				headerMaster.put("role", "headermaster");
  				List<PageData> classInfoList = sclassService.listAll(headerMaster);
015d5970   孙向锦   更新删除接口
272
273
274
275
276
277
278
  				for(PageData pttd : classInfoList){
  					pttd.put("CLASS_ID", pttd.get("ID"));
  					pttd.remove("ID");
  					pttd.remove("HEADMASTER_ID");
  					pttd.remove("SCHOOL_ID");
  					pttd.remove("CLASS_TYPE");
  				}
48d44272   孙向锦   添加一些action
279
  				headerMaster.put("classInfoList", classInfoList);
015d5970   孙向锦   更新删除接口
280
281
  				headerMaster.remove("USERNAME");
  				headerMaster.remove("PASSWORD");
a479f295   孙向锦   添加了报表逻辑
282
  				res.setData(headerMaster);
48d44272   孙向锦   添加一些action
283
284
  				
  			}else{
bed6e1fc   孙向锦   添加其他功能
285
286
  				res.set1Error();
  			}
91a745c9   孙向锦   完善后台功能
287
  		} else {
bed6e1fc   孙向锦   添加其他功能
288
289
  			res.set1Error();
  		}
91a745c9   孙向锦   完善后台功能
290
  
bed6e1fc   孙向锦   添加其他功能
291
292
  		return res.toJson();
  	}
107fa3a0   孙向锦   修改试卷单选多远混合出题
293
  
c617106f   孙向锦   添加即时测功能
294
  	/**
107fa3a0   孙向锦   修改试卷单选多远混合出题
295
296
  	 * 登录 可以通过账号密码登录、 可以通过教师卡登录
  	 * 
c617106f   孙向锦   添加即时测功能
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
  	 * @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"));
  			// 在任课表中查找老师教哪些班级,然后查出班级信息
107fa3a0   孙向锦   修改试卷单选多远混合出题
312
313
  			List<PageData> classInfoList = v1Service.getTeacherClassInfo(pt);
  
c617106f   孙向锦   添加即时测功能
314
315
  			pageData.put("classInfoList", classInfoList);
  			// 在认可表中查找老师教哪些科目,然后查出科目信息
107fa3a0   孙向锦   修改试卷单选多远混合出题
316
  			List<PageData> subjectList = v1Service.getTeacherSubjectInfo(pt);
c617106f   孙向锦   添加即时测功能
317
318
  			// 一个sql语句完成。
  			pageData.put("subjectList", subjectList);
107fa3a0   孙向锦   修改试卷单选多远混合出题
319
  
c617106f   孙向锦   添加即时测功能
320
  			pageData.remove("SUBJECT_IDS");
107fa3a0   孙向锦   修改试卷单选多远混合出题
321
  
c617106f   孙向锦   添加即时测功能
322
323
324
325
326
327
328
329
330
331
332
333
334
  			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);
107fa3a0   孙向锦   修改试卷单选多远混合出题
335
  
c617106f   孙向锦   添加即时测功能
336
337
338
339
340
  			res.setData(pageData);
  			// 填充数据到返回数据中
  		} else {
  			res.set1Error();
  		}
107fa3a0   孙向锦   修改试卷单选多远混合出题
341
  
c617106f   孙向锦   添加即时测功能
342
343
  		return res.toJson();
  	}
91a745c9   孙向锦   完善后台功能
344
  
2ad7ca45   孙向锦   试卷bug修改
345
  	/**
107fa3a0   孙向锦   修改试卷单选多远混合出题
346
347
  	 * 查询班级 班级及班级学生详细信息
  	 * 
2ad7ca45   孙向锦   试卷bug修改
348
349
350
  	 * @return
  	 * @throws Exception
  	 */
bed6e1fc   孙向锦   添加其他功能
351
352
353
  	@RequestMapping(value = "/class", produces = "application/json;charset=UTF-8")
  	@ResponseBody
  	public Object sclass() throws Exception {
3371dbc6   孙向锦   0720 版本
354
  		event("sclass");
2480c889   孙向锦   添加软件管理模块。对软件形成统一的管理
355
  		long cur = System.currentTimeMillis();
bed6e1fc   孙向锦   添加其他功能
356
  		PageData pd = this.getPageData();
bed6e1fc   孙向锦   添加其他功能
357
  		if (pd.containsKey("ID")) {
4fd2e08c   孙向锦   修复接口中的bug
358
  			ResponseGson<PageData> res = new ResponseGson();
bed6e1fc   孙向锦   添加其他功能
359
360
361
362
  			PageData pageData = sclassService.findById(pd);
  			if (pageData != null && pageData.containsKey("ID")) {
  				PageData pt = new PageData();
  				pt.put("SCLASS_ID", pageData.get("ID"));
91a745c9   孙向锦   完善后台功能
363
  				List<PageData> studentList = v1Service.getClassStudent(pt);
bed6e1fc   孙向锦   添加其他功能
364
  				pageData.put("studentList", studentList);
9f161055   孙向锦   修改高斯客户反馈
365
  				pt.put("CLASS_ID", pageData.get("ID"));
ce70231e   孙向锦   增加接口
366
367
  				List<PageData> keyboards = attachkeyboardService
  						.listAllClassId(pt);
9f161055   孙向锦   修改高斯客户反馈
368
  				pageData.put("keyboards", keyboards);
bed6e1fc   孙向锦   添加其他功能
369
370
371
372
  				res.setData(pageData);
  			} else {
  				res.set2Error();
  			}
ce70231e   孙向锦   增加接口
373
374
  			logger.info("class cost time : "
  					+ (System.currentTimeMillis() - cur));
4fd2e08c   孙向锦   修复接口中的bug
375
376
377
378
379
  			return res.toJson();
  		} else {
  			ResponseGson<List<PageData>> res = new ResponseGson();
  			List<PageData> list = sclassService.listAll(pd);
  			res.setData(list);
ce70231e   孙向锦   增加接口
380
381
  			logger.info("class cost time : "
  					+ (System.currentTimeMillis() - cur));
4fd2e08c   孙向锦   修复接口中的bug
382
  			return res.toJson();
4fd2e08c   孙向锦   修复接口中的bug
383
384
  		}
  	}
ce70231e   孙向锦   增加接口
385
  
2ad7ca45   孙向锦   试卷bug修改
386
387
  	/**
  	 * 问题类型
107fa3a0   孙向锦   修改试卷单选多远混合出题
388
  	 * 
2ad7ca45   孙向锦   试卷bug修改
389
390
391
  	 * @return
  	 * @throws Exception
  	 */
4fd2e08c   孙向锦   修复接口中的bug
392
393
394
  	@RequestMapping(value = "/questiontype", produces = "application/json;charset=UTF-8")
  	@ResponseBody
  	public Object questiontype() throws Exception {
3371dbc6   孙向锦   0720 版本
395
  		event("questiontype");
2480c889   孙向锦   添加软件管理模块。对软件形成统一的管理
396
  		long cur = System.currentTimeMillis();
4fd2e08c   孙向锦   修复接口中的bug
397
398
399
400
  		PageData pd = this.getPageData();
  		ResponseGson<List<PageData>> res = new ResponseGson();
  		List<PageData> list = questiontypeService.listAll(pd);
  		res.setData(list);
ce70231e   孙向锦   增加接口
401
402
  		logger.info("questiontype cost time : "
  				+ (System.currentTimeMillis() - cur));
4fd2e08c   孙向锦   修复接口中的bug
403
404
  		return res.toJson();
  	}
ce70231e   孙向锦   增加接口
405
  
2ad7ca45   孙向锦   试卷bug修改
406
407
  	/**
  	 * 班级类型
107fa3a0   孙向锦   修改试卷单选多远混合出题
408
  	 * 
2ad7ca45   孙向锦   试卷bug修改
409
410
411
  	 * @return
  	 * @throws Exception
  	 */
4fd2e08c   孙向锦   修复接口中的bug
412
413
414
  	@RequestMapping(value = "/classtype", produces = "application/json;charset=UTF-8")
  	@ResponseBody
  	public Object classtype() throws Exception {
3371dbc6   孙向锦   0720 版本
415
  		event("classtype");
2480c889   孙向锦   添加软件管理模块。对软件形成统一的管理
416
  		long cur = System.currentTimeMillis();
4fd2e08c   孙向锦   修复接口中的bug
417
418
419
420
  		PageData pd = this.getPageData();
  		ResponseGson<List<PageData>> res = new ResponseGson();
  		List<PageData> list = classtypeService.listAll(pd);
  		res.setData(list);
ce70231e   孙向锦   增加接口
421
422
  		logger.info("classtype cost time : "
  				+ (System.currentTimeMillis() - cur));
4fd2e08c   孙向锦   修复接口中的bug
423
424
  		return res.toJson();
  	}
ce70231e   孙向锦   增加接口
425
  
2ad7ca45   孙向锦   试卷bug修改
426
  	/**
107fa3a0   孙向锦   修改试卷单选多远混合出题
427
428
  	 * 年级 年级类型
  	 * 
2ad7ca45   孙向锦   试卷bug修改
429
430
431
  	 * @return
  	 * @throws Exception
  	 */
4fd2e08c   孙向锦   修复接口中的bug
432
433
434
  	@RequestMapping(value = "/grade", produces = "application/json;charset=UTF-8")
  	@ResponseBody
  	public Object grade() throws Exception {
3371dbc6   孙向锦   0720 版本
435
  		event("grade");
2480c889   孙向锦   添加软件管理模块。对软件形成统一的管理
436
  		long cur = System.currentTimeMillis();
4fd2e08c   孙向锦   修复接口中的bug
437
438
439
440
441
  		PageData pd = this.getPageData();
  		ResponseGson<List<PageData>> res = new ResponseGson();
  		if (!pd.containsKey("SCHOOL_ID")) {
  			List<PageData> list = gradeService.listAll(pd);
  			res.setData(list);
91a745c9   孙向锦   完善后台功能
442
  		} else {
4fd2e08c   孙向锦   修复接口中的bug
443
444
  			List<PageData> list = schoolgradesubjectService.listAllGrade(pd);
  			res.setData(list);
bed6e1fc   孙向锦   添加其他功能
445
  		}
2480c889   孙向锦   添加软件管理模块。对软件形成统一的管理
446
  		logger.info("class cost time : " + (System.currentTimeMillis() - cur));
bed6e1fc   孙向锦   添加其他功能
447
448
  		return res.toJson();
  	}
ce70231e   孙向锦   增加接口
449
  
2ad7ca45   孙向锦   试卷bug修改
450
451
  	/**
  	 * 科目
107fa3a0   孙向锦   修改试卷单选多远混合出题
452
  	 * 
2ad7ca45   孙向锦   试卷bug修改
453
454
455
  	 * @return
  	 * @throws Exception
  	 */
4fd2e08c   孙向锦   修复接口中的bug
456
457
458
  	@RequestMapping(value = "/subject", produces = "application/json;charset=UTF-8")
  	@ResponseBody
  	public Object subject() throws Exception {
3371dbc6   孙向锦   0720 版本
459
  		event("subject");
2480c889   孙向锦   添加软件管理模块。对软件形成统一的管理
460
  		long cur = System.currentTimeMillis();
4fd2e08c   孙向锦   修复接口中的bug
461
462
463
464
465
466
467
468
469
  		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);
  		}
2480c889   孙向锦   添加软件管理模块。对软件形成统一的管理
470
  		logger.info("subject cost time : " + (System.currentTimeMillis() - cur));
4fd2e08c   孙向锦   修复接口中的bug
471
472
  		return res.toJson();
  	}
107fa3a0   孙向锦   修改试卷单选多远混合出题
473
  
c617106f   孙向锦   添加即时测功能
474
475
  	/**
  	 * 科目
107fa3a0   孙向锦   修改试卷单选多远混合出题
476
  	 * 
c617106f   孙向锦   添加即时测功能
477
478
479
480
481
482
  	 * @return
  	 * @throws Exception
  	 */
  	@RequestMapping(value = "/subjectname", produces = "application/json;charset=UTF-8")
  	@ResponseBody
  	public Object subjectName() throws Exception {
757dfed6   孙向锦   样例报表
483
  		event("subjectName");
c617106f   孙向锦   添加即时测功能
484
485
486
487
488
489
490
491
492
493
494
495
496
  		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();
  	}
91a745c9   孙向锦   完善后台功能
497
  
2ad7ca45   孙向锦   试卷bug修改
498
499
  	/**
  	 * 键盘扫描
107fa3a0   孙向锦   修改试卷单选多远混合出题
500
  	 * 
2ad7ca45   孙向锦   试卷bug修改
501
502
503
  	 * @return
  	 * @throws Exception
  	 */
bed6e1fc   孙向锦   添加其他功能
504
505
506
  	@RequestMapping(value = "/keypadscan", produces = "application/json;charset=UTF-8")
  	@ResponseBody
  	public Object keypadScan() throws Exception {
3371dbc6   孙向锦   0720 版本
507
  		event("keypadScan");
2480c889   孙向锦   添加软件管理模块。对软件形成统一的管理
508
  		long cur = System.currentTimeMillis();
bed6e1fc   孙向锦   添加其他功能
509
  		PageData pd = this.getPageData();
91a745c9   孙向锦   完善后台功能
510
511
512
513
514
  		ResponseGson<String> res = new ResponseGson();
  		String ID = get32UUID();
  		pd.put("KEYPADCHECK_ID", ID); // 主键
  		pd.put("CREATE_DATE", Tools.date2Str(new Date())); // 创建时间
  		try {
bed6e1fc   孙向锦   添加其他功能
515
  			keypadcheckService.save(pd);
91a745c9   孙向锦   完善后台功能
516
  			res.setData(ID);
bed6e1fc   孙向锦   添加其他功能
517
  			res.setSuccess();
91a745c9   孙向锦   完善后台功能
518
  		} catch (Exception ex) {
bed6e1fc   孙向锦   添加其他功能
519
520
  			res.setDataError();
  		}
ce70231e   孙向锦   增加接口
521
522
  		logger.info("keypadScan cost time : "
  				+ (System.currentTimeMillis() - cur));
bed6e1fc   孙向锦   添加其他功能
523
524
  		return res.toJson();
  	}
91a745c9   孙向锦   完善后台功能
525
  
2ad7ca45   孙向锦   试卷bug修改
526
527
528
529
530
531
  	/**
  	 * showcount 数量 currentpage 当前页码
  	 * 
  	 * @return
  	 * @throws Exception
  	 */
bed6e1fc   孙向锦   添加其他功能
532
533
534
  	@RequestMapping(value = "/paper", produces = "application/json;charset=UTF-8")
  	@ResponseBody
  	public Object paper() throws Exception {
3371dbc6   孙向锦   0720 版本
535
  		event("paper");
2480c889   孙向锦   添加软件管理模块。对软件形成统一的管理
536
  		long cur = System.currentTimeMillis();
bed6e1fc   孙向锦   添加其他功能
537
538
  		PageData pd = this.getPageData();
  		ResponseGson<List<PageData>> res = new ResponseGson<List<PageData>>();
4b6a5239   孙向锦   管理员界面
539
  		if (pd.containsKey("PAPER_TYPE")) {
757dfed6   孙向锦   样例报表
540
541
  			String CURRENTPAGE = pd.getString("CURRENTPAGE");
  			String SHOWCOUNT = pd.getString("SHOWCOUNT");
107fa3a0   孙向锦   修改试卷单选多远混合出题
542
543
544
  			if (CURRENTPAGE != null && SHOWCOUNT != null
  					&& !"".equals(CURRENTPAGE.trim())
  					&& !"".equals(SHOWCOUNT.trim())) {
757dfed6   孙向锦   样例报表
545
546
  				int currentPage = Integer.parseInt(CURRENTPAGE);
  				int showcount = Integer.parseInt(SHOWCOUNT);
107fa3a0   孙向锦   修改试卷单选多远混合出题
547
548
  				currentPage = (currentPage > 0 ? currentPage - 1 : 0)
  						* showcount;
ddbc622f   孙向锦   0829版本
549
  				pd.put("CURRENTPAGE", "" + currentPage);
bed6e1fc   孙向锦   添加其他功能
550
  			}
d7525cae   jack   1.学生老师导入导出
551
552
553
554
555
556
557
  			PageData p = teacherService.findById2(pd.get("USER_ID").toString());
  			if(p != null){
  				pd.put("SCHOOL_ID", p.get("SCHOOL_ID"));
  				pd.remove("USER_ID");
  			}else{
  				pd.put("SCHOOL_ID", "");
  			}
757dfed6   孙向锦   样例报表
558
  			List<PageData> pageList = paperService.listAllByType(pd);
bed6e1fc   孙向锦   添加其他功能
559
  			res.setData(pageList);
91a745c9   孙向锦   完善后台功能
560
  		} else {
757dfed6   孙向锦   样例报表
561
  			res.setDataError();
bed6e1fc   孙向锦   添加其他功能
562
  		}
2480c889   孙向锦   添加软件管理模块。对软件形成统一的管理
563
  		logger.info("paper cost time : " + (System.currentTimeMillis() - cur));
bed6e1fc   孙向锦   添加其他功能
564
565
  		return res.toJson();
  	}
91a745c9   孙向锦   完善后台功能
566
  
2ad7ca45   孙向锦   试卷bug修改
567
568
  	/**
  	 * 试卷详细信息
107fa3a0   孙向锦   修改试卷单选多远混合出题
569
  	 * 
2ad7ca45   孙向锦   试卷bug修改
570
571
572
  	 * @return
  	 * @throws Exception
  	 */
91a745c9   孙向锦   完善后台功能
573
  	@RequestMapping(value = "/paperinfo", produces = "application/json;charset=UTF-8")
bed6e1fc   孙向锦   添加其他功能
574
  	@ResponseBody
91a745c9   孙向锦   完善后台功能
575
  	public Object paperInfo() throws Exception {
3371dbc6   孙向锦   0720 版本
576
  		event("paperInfo");
2480c889   孙向锦   添加软件管理模块。对软件形成统一的管理
577
  		long cur = System.currentTimeMillis();
bed6e1fc   孙向锦   添加其他功能
578
  		PageData pd = this.getPageData();
757dfed6   孙向锦   样例报表
579
580
581
582
583
584
585
586
587
588
589
590
591
592
  		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"));
4b6a5239   孙向锦   管理员界面
593
  						paper.setSchool_id(ppd.getString("SCHOOL_ID"));
757dfed6   孙向锦   样例报表
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
  						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"));
a0eff87f   孙向锦   修改课后练bug
609
610
611
  							String ttcontent = qpd.getString("CONTENT");
  							ttcontent = ttcontent.replaceAll("<fill></fill>", "______");
  							question.setContent(ttcontent);
757dfed6   孙向锦   样例报表
612
613
614
615
616
617
618
619
620
621
622
623
624
  							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"));
bda221f4   孙向锦   0830版本
625
  							question.setQuestions(new ArrayList<Question>());
757dfed6   孙向锦   样例报表
626
627
628
  							if ("-1".equals("" + qpd.getString("P_ID"))) {
  								PageData pidPd = new PageData();
  								pidPd.put("PID", question.getQuestion_id());
757dfed6   孙向锦   样例报表
629
630
631
632
633
634
635
636
637
638
639
640
641
  								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"));
a0eff87f   孙向锦   修改课后练bug
642
  									qq.setContent(q.getString("CONTENT").replaceAll("<fill></fill>", "______"));
757dfed6   孙向锦   样例报表
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
  									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();
  	}
107fa3a0   孙向锦   修改试卷单选多远混合出题
683
684
  
  	/*	*//**
757dfed6   孙向锦   样例报表
685
  	 * 试卷详细信息
107fa3a0   孙向锦   修改试卷单选多远混合出题
686
  	 * 
757dfed6   孙向锦   样例报表
687
688
  	 * @return
  	 * @throws Exception
107fa3a0   孙向锦   修改试卷单选多远混合出题
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
  	 */
  	/*
  	 * @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(); }
  	 *//**
757dfed6   孙向锦   样例报表
737
  	 * 试卷详细信息
107fa3a0   孙向锦   修改试卷单选多远混合出题
738
  	 * 
757dfed6   孙向锦   样例报表
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
  	 * @return
  	 * @throws Exception
  	 */
  	@RequestMapping(value = "/paperinfo2", produces = "application/json;charset=UTF-8")
  	@ResponseBody
  	public Object paperInfo2() throws Exception {
  		event("paperInfo2");
  		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) {
107fa3a0   孙向锦   修改试卷单选多远混合出题
758
  
757dfed6   孙向锦   样例报表
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
  							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)
107fa3a0   孙向锦   修改试卷单选多远混合出题
786
  												.split(",");
757dfed6   孙向锦   样例报表
787
788
789
790
791
792
793
794
  										pcd.put("OPTION_CONTENT", options);
  									} else {
  										pcd.put("OPTION_CONTENT",
  												new String[] { optionContent1 });
  									}
  								}
  								qpd.put("QUESTIONS", qs);
  							}
107fa3a0   孙向锦   修改试卷单选多远混合出题
795
  
757dfed6   孙向锦   样例报表
796
797
798
  						}
  						res.setData(ppd);
  						logger.info(res.toJson());
107fa3a0   孙向锦   修改试卷单选多远混合出题
799
  
338594c8   孙向锦   添加教师端页面
800
  					}
91a745c9   孙向锦   完善后台功能
801
802
  				} catch (Exception ex) {
  					ex.printStackTrace();
338594c8   孙向锦   添加教师端页面
803
  				}
91a745c9   孙向锦   完善后台功能
804
  			} catch (Exception ex) {
338594c8   孙向锦   添加教师端页面
805
806
  				ex.printStackTrace();
  				res.setError();
bed6e1fc   孙向锦   添加其他功能
807
  			}
91a745c9   孙向锦   完善后台功能
808
  		} else {
bed6e1fc   孙向锦   添加其他功能
809
810
  			res.setOtherError();
  		}
ce70231e   孙向锦   增加接口
811
812
  		logger.info("paperInfo cost time : "
  				+ (System.currentTimeMillis() - cur));
bed6e1fc   孙向锦   添加其他功能
813
814
  		return res.toJson();
  	}
4b6a5239   孙向锦   管理员界面
815
  	
107fa3a0   孙向锦   修改试卷单选多远混合出题
816
  
c617106f   孙向锦   添加即时测功能
817
818
  	/**
  	 * 试卷详细信息
107fa3a0   孙向锦   修改试卷单选多远混合出题
819
  	 * 
c617106f   孙向锦   添加即时测功能
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
  	 * @return
  	 * @throws Exception
  	 */
  	@RequestMapping(value = "/testpaperinfo", produces = "application/json;charset=UTF-8")
  	@ResponseBody
  	public Object testpaperinfo() throws Exception {
  		event("testpaperinfo");
  		long cur = System.currentTimeMillis();
  		PageData pd = this.getPageData();
  		ResponseGson<PageData> res = new ResponseGson();
  		String paperId = pd.getString("ID");
  		if (!StringUtils.isEmpty(paperId)) {
  			try {
  				pd.put("TESTPAPER_ID", paperId);
  				PageData testPd = testpaperService.findById(pd);
  				if (testPd != null) {
  					PageData testInfof = new PageData();
  					testInfof.put("PAPER_ID", testPd.getString("PAPER_ID"));
  					testInfof.put("TEST_ID", paperId);
107fa3a0   孙向锦   修改试卷单选多远混合出题
839
840
841
  					List<PageData> list = testpaperinfoService
  							.listTestPaperQuestionIDs(testInfof);
  					for (PageData pqd : list) {
c617106f   孙向锦   添加即时测功能
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
  						PageData tpqd = questionService.findById(pqd);
  						pqd.putAll(tpqd);
  						pqd.remove("P_ID");
  						pqd.remove("SUBJECT_ID");
  						pqd.remove("PROBLEM_TYPE_ID");
  						pqd.remove("CHAPTER_ID");
  						pqd.remove("TEACHER_ID");
  						pqd.remove("SCHOOL_ID");
  						pqd.remove("SUG_SCORE");
  						pqd.remove("SUG_PART_SCORE");
  						pqd.remove("USER_ID");
  						pqd.remove("CREATE_DATE");
  						pqd.remove("QUESTION_FROM");
  						pqd.remove("REMARK");
  						pqd.put("TEST_ID", paperId);
107fa3a0   孙向锦   修改试卷单选多远混合出题
857
858
  						List<PageData> listinfo = testpaperinfoService
  								.listTestPaperQuestionIDinfo(pqd);
c617106f   孙向锦   添加即时测功能
859
  						List<PageData> answerInfos = new ArrayList<PageData>();
757dfed6   孙向锦   样例报表
860
  						List<String> answerList = new ArrayList<String>();
107fa3a0   孙向锦   修改试卷单选多远混合出题
861
  						for (PageData pid : listinfo) {
c617106f   孙向锦   添加即时测功能
862
863
  							String answer = pid.getString("ANSWER");
  							PageData answerPd = null;
107fa3a0   孙向锦   修改试卷单选多远混合出题
864
865
866
867
868
  							if (answerInfos.size() > 0) {
  								answerPd = answerInfos
  										.get(answerInfos.size() - 1);
  								if (!answer
  										.equals(answerPd.getString("ANSWER"))) {
c617106f   孙向锦   添加即时测功能
869
870
  									answerPd = new PageData();
  									answerPd.put("ANSWER", answer);
107fa3a0   孙向锦   修改试卷单选多远混合出题
871
872
  									answerPd.put("ISRIGHT",
  											pid.getString("RIGHT"));
c617106f   孙向锦   添加即时测功能
873
  									answerInfos.add(answerPd);
757dfed6   孙向锦   样例报表
874
  									answerList.add(answer);
c617106f   孙向锦   添加即时测功能
875
  								}
107fa3a0   孙向锦   修改试卷单选多远混合出题
876
  							} else {
c617106f   孙向锦   添加即时测功能
877
878
879
880
  								answerPd = new PageData();
  								answerPd.put("ANSWER", answer);
  								answerPd.put("ISRIGHT", pid.getString("RIGHT"));
  								answerInfos.add(answerPd);
757dfed6   孙向锦   样例报表
881
  								answerList.add(answer);
c617106f   孙向锦   添加即时测功能
882
883
  							}
  							String strCount = answerPd.getString("COUNT");
107fa3a0   孙向锦   修改试卷单选多远混合出题
884
885
886
887
888
889
  							int count = 0;
  							if (strCount != null) {
  								try {
  									count = Integer.parseInt(strCount);
  								} catch (NumberFormatException ex) {
  								}
c617106f   孙向锦   添加即时测功能
890
  							}
107fa3a0   孙向锦   修改试卷单选多远混合出题
891
  							count++;
c617106f   孙向锦   添加即时测功能
892
893
  							answerPd.put("COUNT", count);
  						}
757dfed6   孙向锦   样例报表
894
895
  						String questionNumStr = pqd.getString("OPTION_NUM");
  						int questionNum = Integer.parseInt(questionNumStr);
107fa3a0   孙向锦   修改试卷单选多远混合出题
896
897
898
899
  						for (int i = 0; i < questionNum; i++) {
  							if ((!answerList.contains("" + (char) ('A' + i)))
  									&& !(answerList.contains(""
  											+ (char) ('a' + i)))) {
757dfed6   孙向锦   样例报表
900
  								PageData answerPd = new PageData();
107fa3a0   孙向锦   修改试卷单选多远混合出题
901
902
903
  								answerPd.put("ANSWER", "" + (char) ('A' + i));
  								answerPd.put("ISRIGHT", pqd.get("ANSWER")
  										.equals(('A' + i)) ? "1" : "0");
757dfed6   孙向锦   样例报表
904
905
906
907
  								answerPd.put("COUNT", 0);
  								answerInfos.add(answerPd);
  							}
  						}
107fa3a0   孙向锦   修改试卷单选多远混合出题
908
909
910
911
912
913
914
915
916
  						Collections.sort(answerInfos,
  								new Comparator<PageData>() {
  
  									@Override
  									public int compare(PageData p1, PageData p2) {
  										return p1.getString("ANSWER")
  												.compareToIgnoreCase(
  														p2.getString("ANSWER"));
  									}
757dfed6   孙向锦   样例报表
917
  
107fa3a0   孙向锦   修改试卷单选多远混合出题
918
  								});
c617106f   孙向锦   添加即时测功能
919
920
921
  						pqd.put("ANSWERINFO", answerInfos);
  						pqd.remove("TEST_ID");
  					}
107fa3a0   孙向锦   修改试卷单选多远混合出题
922
  					for (PageData pad : list) {
757dfed6   孙向锦   样例报表
923
  						String optionContent = pad.getString("OPTION_CONTENT");
107fa3a0   孙向锦   修改试卷单选多远混合出题
924
925
926
927
928
  						if (optionContent != null
  								&& optionContent.startsWith("[")
  								&& optionContent.endsWith("]")) {
  							String[] options = optionContent.substring(1,
  									optionContent.length() - 1).split(",");
757dfed6   孙向锦   样例报表
929
  							pad.put("OPTION_CONTENT", options);
107fa3a0   孙向锦   修改试卷单选多远混合出题
930
931
932
  						} else {
  							pad.put("OPTION_CONTENT",
  									new String[] { optionContent });
757dfed6   孙向锦   样例报表
933
934
  						}
  					}
c617106f   孙向锦   添加即时测功能
935
  					testPd.put("QUESTIONS", list);
107fa3a0   孙向锦   修改试卷单选多远混合出题
936
  
c617106f   孙向锦   添加即时测功能
937
938
939
940
941
942
943
944
945
946
947
948
  				}
  
  				res.setData(testPd);
  			} catch (Exception e) {
  				e.printStackTrace();
  				res.setError();
  			}
  		}
  		logger.info("testpaperinfo cost time:"
  				+ (System.currentTimeMillis() - cur));
  		return res.toJson();
  	}
107fa3a0   孙向锦   修改试卷单选多远混合出题
949
  
c617106f   孙向锦   添加即时测功能
950
951
  	/**
  	 * 试卷详细信息
107fa3a0   孙向锦   修改试卷单选多远混合出题
952
  	 * 
c617106f   孙向锦   添加即时测功能
953
954
955
956
957
958
  	 * @return
  	 * @throws Exception
  	 */
  	@RequestMapping(value = "/questionintestreportinfo", produces = "application/json;charset=UTF-8")
  	@ResponseBody
  	public Object questionInTestReportInfo() throws Exception {
757dfed6   孙向锦   样例报表
959
  		event("questionInTestReportInfo");
c617106f   孙向锦   添加即时测功能
960
961
962
963
964
965
966
967
  		long cur = System.currentTimeMillis();
  		PageData pd = this.getPageData();
  		ResponseGson<PageData> res = new ResponseGson();
  		if (pd.getString("QUESTION_ID") != null) {
  			String questionId = pd.getString("QUESTION_ID");
  			PageData pqd = new PageData();
  			pqd.put("QUESTION_ID", questionId);
  			PageData tpqd = questionService.findById(pqd);
757dfed6   孙向锦   样例报表
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
1001
1002
1003
1004
1005
1006
1007
1008
  			if (tpqd != null) {
  				pqd.putAll(tpqd);
  				pqd.remove("P_ID");
  				pqd.remove("SUBJECT_ID");
  				pqd.remove("PROBLEM_TYPE_ID");
  				pqd.remove("CHAPTER_ID");
  				pqd.remove("TEACHER_ID");
  				pqd.remove("SCHOOL_ID");
  				pqd.remove("SUG_SCORE");
  				pqd.remove("SUG_PART_SCORE");
  				pqd.remove("USER_ID");
  				pqd.remove("CREATE_DATE");
  				pqd.remove("QUESTION_FROM");
  				pqd.remove("REMARK");
  				String optionContent = pqd.getString("OPTION_CONTENT");
  				if (optionContent != null && optionContent.startsWith("[")
  						&& optionContent.endsWith("]")) {
  					String[] options = optionContent.substring(1,
  							optionContent.length() - 1).split(",");
  					pqd.put("OPTION_CONTENT", options);
  				} else {
  					pqd.put("OPTION_CONTENT", new String[] { optionContent });
  				}
  				if (pd.getString("TEST_ID") != null) {
  					pqd.put("TEST_ID", pd.getString("TEST_ID"));
  				}
  				List<PageData> listinfo = testpaperinfoService
  						.listTestPaperQuestionIDinfo(pqd);
  				List<PageData> answerInfos = new ArrayList<PageData>();
  				for (PageData pid : listinfo) {
  					String answer = pid.getString("ANSWER");
  					PageData answerPd = null;
  					if (answerInfos.size() > 0) {
  						answerPd = answerInfos.get(answerInfos.size() - 1);
  						if (!answer.equals(answerPd.getString("ANSWER"))) {
  							answerPd = new PageData();
  							answerPd.put("ANSWER", answer);
  							answerPd.put("ISRIGHT", pid.getString("RIGHT"));
  							answerInfos.add(answerPd);
  						}
  					} else {
c617106f   孙向锦   添加即时测功能
1009
1010
1011
1012
1013
  						answerPd = new PageData();
  						answerPd.put("ANSWER", answer);
  						answerPd.put("ISRIGHT", pid.getString("RIGHT"));
  						answerInfos.add(answerPd);
  					}
757dfed6   孙向锦   样例报表
1014
1015
1016
1017
1018
1019
1020
  					String strCount = answerPd.getString("COUNT");
  					int count = 0;
  					if (strCount != null) {
  						try {
  							count = Integer.parseInt(strCount);
  						} catch (NumberFormatException ex) {
  						}
c617106f   孙向锦   添加即时测功能
1021
  					}
757dfed6   孙向锦   样例报表
1022
1023
  					count++;
  					answerPd.put("COUNT", count);
c617106f   孙向锦   添加即时测功能
1024
  				}
757dfed6   孙向锦   样例报表
1025
1026
  				pqd.put("ANSWERINFO", answerInfos);
  				res.setData(pqd);
107fa3a0   孙向锦   修改试卷单选多远混合出题
1027
  			} else {
757dfed6   孙向锦   样例报表
1028
  				res.setDataError();
c617106f   孙向锦   添加即时测功能
1029
  			}
107fa3a0   孙向锦   修改试卷单选多远混合出题
1030
  		} else {
c617106f   孙向锦   添加即时测功能
1031
1032
  			res.setDataError();
  		}
757dfed6   孙向锦   样例报表
1033
  		logger.info("questionInTestReportInfo cost time:"
c617106f   孙向锦   添加即时测功能
1034
1035
1036
  				+ (System.currentTimeMillis() - cur));
  		return res.toJson();
  	}
91a745c9   孙向锦   完善后台功能
1037
  
2ad7ca45   孙向锦   试卷bug修改
1038
1039
  	/**
  	 * 试卷简要信息
107fa3a0   孙向锦   修改试卷单选多远混合出题
1040
  	 * 
2ad7ca45   孙向锦   试卷bug修改
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
  	 * @return
  	 * @throws Exception
  	 */
  	@RequestMapping(value = "/paperbriefinfo", produces = "application/json;charset=UTF-8")
  	@ResponseBody
  	public Object paperBriefInfo() throws Exception {
  		event("paperBriefInfo");
  		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.setQuestions(new ArrayList<Question>());
  
  						List<PageData> questList = v1Service
  								.getTestPaperInfo(pd);
  						for (PageData qpd : questList) {
  							Question question = new Question();
  							question.setQuestion_id(qpd
  									.getString("QUESTION_ID"));
  							if ("-1".equals("" + qpd.getString("P_ID"))) {
  								PageData pidPd = new PageData();
  								pidPd.put("PID", question.getQuestion_id());
  								question.setQuestions(new ArrayList<Question>());
  								List<PageData> qs = v1Service
  										.getQuestionsByPID(pidPd);
  								for (PageData q : qs) {
  									Question qq = new Question();
  									qq.setQuestion_id(q
  											.getString("QUESTION_ID"));
  									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();
  		}
757dfed6   孙向锦   样例报表
1105
  		logger.info("paperBriefInfo cost time : "
2ad7ca45   孙向锦   试卷bug修改
1106
1107
1108
1109
  				+ (System.currentTimeMillis() - cur));
  		return res.toBrifJson();
  	}
  
2ad7ca45   孙向锦   试卷bug修改
1110
1111
  	/**
  	 * 试卷问题
107fa3a0   孙向锦   修改试卷单选多远混合出题
1112
  	 * 
2ad7ca45   孙向锦   试卷bug修改
1113
1114
1115
  	 * @return
  	 * @throws Exception
  	 */
bed6e1fc   孙向锦   添加其他功能
1116
1117
1118
  	@RequestMapping(value = "/paperquestion", produces = "application/json;charset=UTF-8")
  	@ResponseBody
  	public Object paperQuestion() throws Exception {
3371dbc6   孙向锦   0720 版本
1119
  		event("paperQuestion");
2480c889   孙向锦   添加软件管理模块。对软件形成统一的管理
1120
  		long cur = System.currentTimeMillis();
bed6e1fc   孙向锦   添加其他功能
1121
1122
  		PageData pd = this.getPageData();
  		ResponseGson<PageData> res = new ResponseGson();
ce70231e   孙向锦   增加接口
1123
1124
  		logger.info("paperquestion cost time : "
  				+ (System.currentTimeMillis() - cur));
bed6e1fc   孙向锦   添加其他功能
1125
1126
  		return res.toJson();
  	}
ce70231e   孙向锦   增加接口
1127
  
2ad7ca45   孙向锦   试卷bug修改
1128
1129
  	/**
  	 * 问题
107fa3a0   孙向锦   修改试卷单选多远混合出题
1130
  	 * 
2ad7ca45   孙向锦   试卷bug修改
1131
1132
1133
  	 * @return
  	 * @throws Exception
  	 */
4fd2e08c   孙向锦   修复接口中的bug
1134
1135
1136
  	@RequestMapping(value = "/question", produces = "application/json;charset=UTF-8")
  	@ResponseBody
  	public Object question() throws Exception {
3371dbc6   孙向锦   0720 版本
1137
  		event("question");
2480c889   孙向锦   添加软件管理模块。对软件形成统一的管理
1138
  		long cur = System.currentTimeMillis();
4fd2e08c   孙向锦   修复接口中的bug
1139
  		PageData pd = this.getPageData();
2ad7ca45   孙向锦   试卷bug修改
1140
1141
  		ResponseGson<List<PageData>> res = new ResponseGson();
  		List<PageData> list = new ArrayList<PageData>();
ce70231e   孙向锦   增加接口
1142
  		if (pd.containsKey("ID")) {
2ad7ca45   孙向锦   试卷bug修改
1143
1144
1145
1146
1147
  			String ids = pd.getString("ID");
  			String[] id = ids.split(",");
  			for (String i : id) {
  				pd.put("QUESTION_ID", i);
  				PageData data = questionService.findById(pd);
c617106f   孙向锦   添加即时测功能
1148
  				String optionContent = data.getString("OPTION_CONTENT");
107fa3a0   孙向锦   修改试卷单选多远混合出题
1149
1150
1151
1152
  				if (optionContent != null && optionContent.startsWith("[")
  						&& optionContent.endsWith("]")) {
  					String[] options = optionContent.substring(1,
  							optionContent.length() - 1).split(",");
c617106f   孙向锦   添加即时测功能
1153
  					data.put("OPTION_CONTENT", options);
107fa3a0   孙向锦   修改试卷单选多远混合出题
1154
1155
  				} else {
  					data.put("OPTION_CONTENT", new String[] { optionContent });
c617106f   孙向锦   添加即时测功能
1156
  				}
2ad7ca45   孙向锦   试卷bug修改
1157
1158
1159
1160
1161
  				if (data != null) {
  					list.add(data);
  				}
  			}
  			res.setData(list);
ce70231e   孙向锦   增加接口
1162
  		} else {
4fd2e08c   孙向锦   修复接口中的bug
1163
1164
  			res.setDataError();
  		}
ce70231e   孙向锦   增加接口
1165
1166
  		logger.info("question cost time : "
  				+ (System.currentTimeMillis() - cur));
4fd2e08c   孙向锦   修复接口中的bug
1167
1168
  		return res.toJson();
  	}
ce70231e   孙向锦   增加接口
1169
  
2ad7ca45   孙向锦   试卷bug修改
1170
1171
  	/**
  	 * 查询知识点名称
107fa3a0   孙向锦   修改试卷单选多远混合出题
1172
  	 * 
2ad7ca45   孙向锦   试卷bug修改
1173
1174
1175
1176
1177
1178
  	 * @return
  	 * @throws Exception
  	 */
  	@RequestMapping(value = "/knowledgename", produces = "application/json;charset=UTF-8")
  	@ResponseBody
  	public Object knowledgename() throws Exception {
757dfed6   孙向锦   样例报表
1179
  		event("knowledgename");
2ad7ca45   孙向锦   试卷bug修改
1180
1181
1182
1183
1184
1185
1186
1187
1188
1189
1190
1191
1192
1193
1194
1195
1196
1197
1198
1199
1200
1201
1202
1203
  		ResponseGson<List<PageData>> res = new ResponseGson();
  		List<PageData> list = new ArrayList<PageData>();
  		PageData pd = getPageData();
  		if (pd.get("ID") != null) {
  			String ids = pd.getString("ID");
  			String[] id = ids.split(",");
  			for (String i : id) {
  				pd.put("KNOWLEDGE_ID", i);
  				PageData data = knowledgeService.findById(pd);
  				if (data != null) {
  					PageData t = new PageData();
  					t.put("KNOWLEDGE_ID", data.get("KNOWLEDGE_ID"));
  					t.put("NAME", data.get("NAME"));
  					list.add(t);
  				}
  			}
  			res.setData(list);
  		}
  		;
  		return res;
  	}
  
  	/**
  	 * 章节名称
107fa3a0   孙向锦   修改试卷单选多远混合出题
1204
  	 * 
2ad7ca45   孙向锦   试卷bug修改
1205
1206
1207
1208
1209
1210
  	 * @return
  	 * @throws Exception
  	 */
  	@RequestMapping(value = "/chaptername", produces = "application/json;charset=UTF-8")
  	@ResponseBody
  	public Object chaptername() throws Exception {
757dfed6   孙向锦   样例报表
1211
  		event("chaptername");
2ad7ca45   孙向锦   试卷bug修改
1212
1213
1214
1215
1216
1217
1218
1219
1220
1221
1222
1223
1224
1225
1226
1227
1228
1229
1230
1231
1232
1233
1234
1235
  		ResponseGson<List<PageData>> res = new ResponseGson();
  		List<PageData> list = new ArrayList<PageData>();
  		PageData pd = getPageData();
  		if (pd.get("ID") != null) {
  			String ids = pd.getString("ID");
  			String[] id = ids.split(",");
  			for (String i : id) {
  				pd.put("ID", i);
  				PageData data = chapterService.findById(pd);
  				if (data != null) {
  					PageData t = new PageData();
  					t.put("ID", data.get("ID"));
  					t.put("NAME", data.get("NAME"));
  					list.add(t);
  				}
  			}
  			res.setData(list);
  		}
  		;
  		return res;
  	}
  
  	/**
  	 * 试题添加
107fa3a0   孙向锦   修改试卷单选多远混合出题
1236
  	 * 
2ad7ca45   孙向锦   试卷bug修改
1237
1238
1239
  	 * @return
  	 * @throws Exception
  	 */
4fd2e08c   孙向锦   修复接口中的bug
1240
1241
1242
  	@RequestMapping(value = "/question/add", produces = "application/json;charset=UTF-8")
  	@ResponseBody
  	public Object questionAdd() throws Exception {
3371dbc6   孙向锦   0720 版本
1243
  		event("questionAdd");
2480c889   孙向锦   添加软件管理模块。对软件形成统一的管理
1244
  		long cur = System.currentTimeMillis();
4fd2e08c   孙向锦   修复接口中的bug
1245
1246
1247
1248
  		PageData pd = this.getPageData();
  		ResponseGson<PageData> res = new ResponseGson();
  		pd.put("QUESTION_ID", this.get32UUID());
  		questionService.save(pd);
ce70231e   孙向锦   增加接口
1249
1250
  		logger.info("questionAdd cost time : "
  				+ (System.currentTimeMillis() - cur));
4fd2e08c   孙向锦   修复接口中的bug
1251
1252
  		return res.toJson();
  	}
ce70231e   孙向锦   增加接口
1253
  
2ad7ca45   孙向锦   试卷bug修改
1254
1255
  	/***
  	 * 上传试卷
107fa3a0   孙向锦   修改试卷单选多远混合出题
1256
  	 * 
2ad7ca45   孙向锦   试卷bug修改
1257
1258
1259
  	 * @return
  	 * @throws Exception
  	 */
338594c8   孙向锦   添加教师端页面
1260
1261
1262
  	@RequestMapping(value = "/uploadpaper", produces = "application/json;charset=UTF-8")
  	@ResponseBody
  	public Object uploadpaper() throws Exception {
3371dbc6   孙向锦   0720 版本
1263
  		event("uploadpaper");
2480c889   孙向锦   添加软件管理模块。对软件形成统一的管理
1264
  		long cur = System.currentTimeMillis();
338594c8   孙向锦   添加教师端页面
1265
1266
  		PageData pd = this.getPageData();
  		ResponseGson<String> res = new ResponseGson();
91a745c9   孙向锦   完善后台功能
1267
1268
  
  		if (!StringUtils.isEmpty(pd.getJsonString())) {
4fd2e08c   孙向锦   修复接口中的bug
1269
  			logger.info(pd.getJsonString());
338594c8   孙向锦   添加教师端页面
1270
1271
1272
1273
  			Paper paper = Paper.parse(pd.getJsonString());
  			PageData paperPd = new PageData();
  			String paperID = this.get32UUID();
  			res.setData(paperID);
91a745c9   孙向锦   完善后台功能
1274
1275
1276
1277
1278
1279
1280
1281
1282
1283
  			paperPd.put("PAPER_ID", paperID);
  			paperPd.put("TITLE", paper.getTitle());
  			paperPd.put("USER_ID", paper.getUser_id());
  			paperPd.put("PAPER_TYPE", paper.getPaper_type());
  			paperPd.put("SUBJECT_ID", paper.getSubject_id());
  			paperPd.put("GRADE_ID", paper.getGrade_id());
  			paperPd.put("EXAM_TIME", paper.getExam_time());
  			paperPd.put("SCORE", paper.getScore());
  			paperPd.put("PAPER_STATE", "0");
  			paperPd.put("REMARK", "");
338594c8   孙向锦   添加教师端页面
1284
  			String schoolID = Myelfun.getUserID(paper.getUser_id());
4b6a5239   孙向锦   管理员界面
1285
  			paperPd.put("SCHOOL_ID", paper.getSchool_id() == null ? schoolID:paper.getSchool_id());
91a745c9   孙向锦   完善后台功能
1286
1287
1288
  			paperPd.put("CREATE_DATE", Tools.date2Str(new Date()));
  			paperPd.put("MODIFY_DATE", Tools.date2Str(new Date()));
  
ce70231e   孙向锦   增加接口
1289
  			int questionNum = 0;
91a745c9   孙向锦   完善后台功能
1290
  
338594c8   孙向锦   添加教师端页面
1291
  			List<Question> questions = paper.getQuestions();
91a745c9   孙向锦   完善后台功能
1292
1293
  			if (questions != null) {
  				for (Question question : questions) {
338594c8   孙向锦   添加教师端页面
1294
1295
1296
  					String questionID = this.get32UUID();
  					PageData qPd = new PageData();
  					qPd.put("QUESTION_ID", questionID);
91a745c9   孙向锦   完善后台功能
1297
1298
  					if (question.getQuestions() != null
  							&& question.getQuestions().size() > 0) {
338594c8   孙向锦   添加教师端页面
1299
  						qPd.put("P_ID", "-1");
91a745c9   孙向锦   完善后台功能
1300
  					} else {
ce70231e   孙向锦   增加接口
1301
  						questionNum++;
338594c8   孙向锦   添加教师端页面
1302
1303
1304
1305
  						qPd.put("P_ID", "0");
  					}
  					qPd.put("SUBJECT_ID", paper.getSubject_id());
  					qPd.put("CHAPTER_ID", question.getChapter_id());
ce70231e   孙向锦   增加接口
1306
1307
1308
  					qPd.put("PROBLEM_TYPE_ID",
  							question.getProblem_type_id() == null ? "1"
  									: question.getProblem_type_id());
338594c8   孙向锦   添加教师端页面
1309
1310
1311
1312
1313
1314
1315
1316
1317
1318
1319
1320
1321
1322
1323
1324
  					qPd.put("TEACHER_ID", paper.getUser_id());
  					qPd.put("SCHOOL_ID", schoolID);
  					qPd.put("KNOWLEDGE_ID", question.getKnowledge_id());
  					qPd.put("CONTENT", question.getContent());
  					qPd.put("OPTION_NUM", question.getOption_num());
  					qPd.put("OPTION_CONTENT", question.getOption_content());
  					qPd.put("ANSWER", question.getAnswer());
  					qPd.put("DIFFICULTY", question.getDifficulty());
  					qPd.put("ANALYSIS", question.getAnalysis());
  					qPd.put("QUESTION_FROM", question.getQuestion_from());
  					qPd.put("SUG_SCORE", question.getScore());
  					qPd.put("SUG_PART_SCORE", question.getPart_score());
  					qPd.put("USER_ID", paper.getUser_id());
  					qPd.put("CREATE_DATE", Tools.date2Str(new Date()));
  					qPd.put("REMARK", "");
  					questionService.save(qPd);
91a745c9   孙向锦   完善后台功能
1325
  
338594c8   孙向锦   添加教师端页面
1326
  					PageData pqPd = new PageData();
91a745c9   孙向锦   完善后台功能
1327
1328
1329
1330
1331
1332
1333
  					pqPd.put("PAPER_ID", paperID);
  					pqPd.put("QUESTION_ID", questionID);
  					pqPd.put("SCORE", question.getScore());
  					pqPd.put("PART_SCORE", "0");
  					pqPd.put("RANK", question.getRank());
  					pqPd.put("NO_NAME", question.getNo_name());
  					pqPd.put("PAPERQUESTION_ID", this.get32UUID());
338594c8   孙向锦   添加教师端页面
1334
  					paperquestionService.save(pqPd);
91a745c9   孙向锦   完善后台功能
1335
1336
  
  					if (question.getQuestions() != null) {
338594c8   孙向锦   添加教师端页面
1337
  						List<Question> qs = question.getQuestions();
91a745c9   孙向锦   完善后台功能
1338
  						for (Question q : qs) {
338594c8   孙向锦   添加教师端页面
1339
1340
1341
1342
1343
1344
  							String qID = this.get32UUID();
  							PageData cqPd = new PageData();
  							cqPd.put("QUESTION_ID", qID);
  							cqPd.put("P_ID", questionID);
  							cqPd.put("SUBJECT_ID", paper.getSubject_id());
  							cqPd.put("CHAPTER_ID", q.getChapter_id());
ce70231e   孙向锦   增加接口
1345
1346
1347
  							cqPd.put("PROBLEM_TYPE_ID", question
  									.getProblem_type_id() == null ? "1"
  									: question.getProblem_type_id());
338594c8   孙向锦   添加教师端页面
1348
1349
1350
1351
1352
1353
1354
1355
1356
1357
1358
1359
1360
1361
1362
  							cqPd.put("TEACHER_ID", paper.getUser_id());
  							cqPd.put("SCHOOL_ID", schoolID);
  							cqPd.put("KNOWLEDGE_ID", q.getKnowledge_id());
  							cqPd.put("CONTENT", q.getContent());
  							cqPd.put("OPTION_NUM", q.getOption_num());
  							cqPd.put("OPTION_CONTENT", q.getOption_content());
  							cqPd.put("ANSWER", q.getAnswer());
  							cqPd.put("DIFFICULTY", q.getDifficulty());
  							cqPd.put("ANALYSIS", q.getAnalysis());
  							cqPd.put("QUESTION_FROM", q.getQuestion_from());
  							cqPd.put("SUG_SCORE", q.getScore());
  							cqPd.put("SUG_PART_SCORE", q.getSug_part_score());
  							cqPd.put("USER_ID", paper.getUser_id());
  							cqPd.put("CREATE_DATE", Tools.date2Str(new Date()));
  							cqPd.put("REMARK", "");
91a745c9   孙向锦   完善后台功能
1363
  
338594c8   孙向锦   添加教师端页面
1364
  							questionService.save(cqPd);
91a745c9   孙向锦   完善后台功能
1365
  
338594c8   孙向锦   添加教师端页面
1366
  							PageData cpqPd = new PageData();
91a745c9   孙向锦   完善后台功能
1367
1368
1369
1370
1371
1372
1373
1374
  							cpqPd.put("PAPER_ID", paperID);
  							cpqPd.put("QUESTION_ID", qID);
  							cpqPd.put("SCORE", q.getScore());
  							cpqPd.put("PART_SCORE", "0");
  							cpqPd.put("RANK", q.getRank());
  							cpqPd.put("NO_NAME", q.getNo_name());
  							cpqPd.put("PAPERQUESTION_ID", this.get32UUID());
  
338594c8   孙向锦   添加教师端页面
1375
  							paperquestionService.save(cpqPd);
ce70231e   孙向锦   增加接口
1376
  							questionNum++;
338594c8   孙向锦   添加教师端页面
1377
1378
1379
1380
  						}
  					}
  				}
  			}
4fd2e08c   孙向锦   修复接口中的bug
1381
1382
  			paperPd.put("QUESTION_NUM", "" + questionNum);
  			paperService.save(paperPd);
91a745c9   孙向锦   完善后台功能
1383
1384
  
  		} else {
338594c8   孙向锦   添加教师端页面
1385
1386
  			res.setDataError();
  		}
ce70231e   孙向锦   增加接口
1387
1388
1389
1390
1391
  		logger.info("uploadpaper cost time : "
  				+ (System.currentTimeMillis() - cur));
  		return res.toJson();
  	}
  
2ad7ca45   孙向锦   试卷bug修改
1392
1393
  	/**
  	 * 上传试卷,不上传试题详细信息。试题从已有数据库中组卷
107fa3a0   孙向锦   修改试卷单选多远混合出题
1394
  	 * 
2ad7ca45   孙向锦   试卷bug修改
1395
1396
1397
1398
1399
1400
1401
1402
1403
1404
1405
1406
1407
1408
1409
1410
1411
1412
1413
1414
1415
1416
1417
1418
  	 * @return
  	 * @throws Exception
  	 */
  	@RequestMapping(value = "/publishpaper", produces = "application/json;charset=UTF-8")
  	@ResponseBody
  	public Object publishPaper() throws Exception {
  		event("publishpaper");
  		long cur = System.currentTimeMillis();
  		PageData pd = this.getPageData();
  		ResponseGson<String> res = new ResponseGson();
  
  		if (!StringUtils.isEmpty(pd.getJsonString())) {
  			logger.info(pd.getJsonString());
  			Paper paper = Paper.parse(pd.getJsonString());
  			PageData paperPd = new PageData();
  			String paperID = this.get32UUID();
  			res.setData(paperID);
  			paperPd.put("PAPER_ID", paperID);
  			paperPd.put("TITLE", paper.getTitle());
  			paperPd.put("USER_ID", paper.getUser_id());
  			paperPd.put("PAPER_TYPE", paper.getPaper_type());
  			paperPd.put("SUBJECT_ID", paper.getSubject_id());
  			paperPd.put("GRADE_ID", paper.getGrade_id());
  			paperPd.put("EXAM_TIME", paper.getExam_time());
757dfed6   孙向锦   样例报表
1419
  			paperPd.put("CLASS_ID", paper.getClass_id());
2ad7ca45   孙向锦   试卷bug修改
1420
1421
1422
1423
1424
1425
1426
  			paperPd.put("SCORE", paper.getScore());
  			paperPd.put("PAPER_STATE", "0");
  			paperPd.put("REMARK", "");
  			String schoolID = Myelfun.getUserID(paper.getUser_id());
  			paperPd.put("SCHOOL_ID", schoolID);
  			paperPd.put("CREATE_DATE", Tools.date2Str(new Date()));
  			paperPd.put("MODIFY_DATE", Tools.date2Str(new Date()));
2ad7ca45   孙向锦   试卷bug修改
1427
  			List<Question> questions = paper.getQuestions();
757dfed6   孙向锦   样例报表
1428
  			int questionNum = questions.size();
2ad7ca45   孙向锦   试卷bug修改
1429
1430
1431
1432
1433
1434
1435
1436
1437
1438
  			if (questions != null) {
  				for (Question question : questions) {
  					PageData pqPd = new PageData();
  					pqPd.put("PAPER_ID", paperID);
  					pqPd.put("QUESTION_ID", question.getQuestion_id());
  					pqPd.put("SCORE", question.getScore());
  					pqPd.put("PART_SCORE", "0");
  					pqPd.put("RANK", question.getRank());
  					pqPd.put("NO_NAME", question.getNo_name());
  					pqPd.put("PAPERQUESTION_ID", this.get32UUID());
c617106f   孙向锦   添加即时测功能
1439
  					pqPd.put("P_ID", "0");
227dbfbb   孙向锦   添加知识点id
1440
  					pqPd.put("KNOWLEDGE_ID", question.getKnowledge_id());//
2ad7ca45   孙向锦   试卷bug修改
1441
1442
1443
1444
1445
1446
1447
1448
1449
1450
  					paperquestionService.save(pqPd);
  
  				}
  			}
  			paperPd.put("QUESTION_NUM", "" + questionNum);
  			paperService.save(paperPd);
  
  		} else {
  			res.setDataError();
  		}
757dfed6   孙向锦   样例报表
1451
  		logger.info("publishpaper cost time : "
2ad7ca45   孙向锦   试卷bug修改
1452
1453
1454
1455
1456
1457
  				+ (System.currentTimeMillis() - cur));
  		return res.toJson();
  	}
  
  	/**
  	 * 上传知识点
107fa3a0   孙向锦   修改试卷单选多远混合出题
1458
  	 * 
2ad7ca45   孙向锦   试卷bug修改
1459
1460
1461
  	 * @return
  	 * @throws Exception
  	 */
ce70231e   孙向锦   增加接口
1462
1463
1464
1465
1466
1467
1468
1469
1470
1471
1472
1473
1474
1475
1476
1477
1478
1479
1480
1481
1482
1483
1484
1485
1486
1487
  	@RequestMapping(value = "/uploadpoint", produces = "application/json;charset=UTF-8")
  	@ResponseBody
  	public Object uploadpoint() throws Exception {
  		event("uploadpoint");
  		long cur = System.currentTimeMillis();
  		PageData pd = this.getPageData();
  		ResponseGson<String> res = new ResponseGson();
  
  		if (!StringUtils.isEmpty(pd.getJsonString())) {
  			try {
  				ResponseGson<List<Point>> req = ResponseGson.parse(
  						pd.getJsonString(), Point.class);
  				List<Point> list = req.getData();
  				if (list != null && list.size() > 0) {
  					for (Point point : list) {
  						savePoint(point, null);
  					}
  				}
  			} catch (Exception e) {
  				res.setError();
  			}
  		} else {
  			res.setDataError();
  		}
  		logger.info("uploadpoint cost time : "
  				+ (System.currentTimeMillis() - cur));
91a745c9   孙向锦   完善后台功能
1488
1489
1490
  		return res.toJson();
  	}
  
2ad7ca45   孙向锦   试卷bug修改
1491
  	/**
107fa3a0   孙向锦   修改试卷单选多远混合出题
1492
1493
  	 * 上传测验成绩
  	 * 
2ad7ca45   孙向锦   试卷bug修改
1494
1495
  	 * @return
  	 */
91a745c9   孙向锦   完善后台功能
1496
1497
1498
  	@RequestMapping(value = "/uploadtestpaper", produces = "application/json;charset=UTF-8")
  	@ResponseBody
  	public Object uploadTestpaper() {
3371dbc6   孙向锦   0720 版本
1499
  		event("uploadTestpaper");
4fd2e08c   孙向锦   修复接口中的bug
1500
  		long cur = System.currentTimeMillis();
91a745c9   孙向锦   完善后台功能
1501
1502
1503
  		PageData pd = this.getPageData();
  		ResponseGson<String> res = new ResponseGson();
  		if (!StringUtils.isEmpty(pd.getJsonString())) {
4fd2e08c   孙向锦   修复接口中的bug
1504
  			logger.info(pd.getJsonString());
91a745c9   孙向锦   完善后台功能
1505
1506
1507
1508
  			TestPaper testPaper = TestPaper.parse(pd.getJsonString());
  			try {
  				PageData testPd = new PageData();
  				String testPaperId = this.get32UUID();
91a745c9   孙向锦   完善后台功能
1509
  				testPd.put("TEACHER_ID", testPaper.getTeacherId());
91a745c9   孙向锦   完善后台功能
1510
1511
  				testPd.put("PAPER_ID", testPaper.getPaperId());
  				testPd.put("SCLASS_ID", testPaper.getClassId());
91a745c9   孙向锦   完善后台功能
1512
1513
1514
1515
1516
  				testPd.put(
  						"CREATE_DATE",
  						testPaper.getCreateDate() == null ? Tools
  								.date2Str(new Date()) : testPaper
  								.getCreateDate());
107fa3a0   孙向锦   修改试卷单选多远混合出题
1517
1518
1519
1520
  				testPd.put(
  						"TEST_TYPE",
  						testPaper.getTest_type() != null ? testPaper
  								.getTest_type() : "1");
2480c889   孙向锦   添加软件管理模块。对软件形成统一的管理
1521
1522
1523
1524
1525
1526
1527
1528
1529
1530
1531
1532
1533
1534
1535
1536
1537
1538
1539
1540
1541
1542
1543
1544
1545
1546
1547
1548
1549
1550
1551
1552
1553
1554
1555
1556
1557
1558
1559
1560
1561
1562
1563
1564
1565
1566
1567
1568
1569
1570
1571
1572
1573
1574
1575
1576
1577
1578
1579
1580
1581
1582
1583
1584
1585
1586
1587
1588
1589
1590
1591
1592
  				List<PageData> listData = testpaperService.listAll(testPd);
  				if (!(listData != null && listData.size() > 0)) {
  					testPd.put("START_DATE", testPaper.getStartDate());
  					testPd.put("END_DATE", testPaper.getEndDate());
  					testPd.put("NAME", testPaper.getName());
  					testPd.put("TESTPAPER_ID", testPaperId);
  					testPd.put("OTHER_SCORE", testPaper.getOtherScore());
  					testPd.put("HIGHT_SCORE", testPaper.getHighScore());
  					testPd.put("LOW_SCORE", testPaper.getLowScore());
  					testPd.put("AVG_SCORE", testPaper.getAvgScore());
  					testPd.put("REMARK", testPaper.getRemark());
  					testpaperService.save(testPd);
  					if (testPaper.getStudents() != null) {
  						List<PageData> testInfoPdList = new ArrayList();
  						PageData testInfoPd = null;
  						for (StudentAnswer studentAnswer : testPaper
  								.getStudents()) {
  							if (studentAnswer.getQuestions() != null) {
  								PageData studentPageData = new PageData();
  								studentPageData.put("STUDENTTEST_ID",
  										get32UUID());
  								studentPageData.put("STUDENT_ID",
  										studentAnswer.getStudentId());
  								studentPageData.put("TEST_ID", testPaperId);
  								studentPageData.put("PAPER_ID",
  										testPaper.getPaperId());
  								studentPageData.put("SCORE",
  										studentAnswer.getScore());
  								studentPageData.put("CLASS_ID",
  										testPaper.getClassId());
  								studenttestService.save(studentPageData);
  
  								for (TestPaperInfo testPaperInfo : studentAnswer
  										.getQuestions()) {
  									testInfoPd = new PageData();
  									testInfoPd.put("TESTPAPERINFO_ID",
  											this.get32UUID());
  									testInfoPd.put("PAPER_ID",
  											testPaper.getPaperId());
  									testInfoPd.put("STUDENT_ID",
  											studentAnswer.getStudentId());
  									testInfoPd.put("TEST_ID", testPaperId);
  									testInfoPd.put("QUESTION_ID",
  											testPaperInfo.getQuestionId());
  									testInfoPd.put("ANSWER",
  											testPaperInfo.getAnswer());
  									testInfoPd.put("RIGHT",
  											testPaperInfo.getRight());
  									testInfoPd.put("SCORE",
  											testPaperInfo.getScore());
  									testInfoPd.put("LIKES",
  											testPaperInfo.getLikes());
  									testInfoPd
  											.put("ANSWER_TYPE",
  													testPaperInfo
  															.getAnswerType() == null ? "1"
  															: testPaperInfo
  																	.getAnswerType());
  									testInfoPd.put("PRESS_TIME",
  											testPaperInfo.getPressTime());
  									testInfoPd.put("RECEIVER_DATE",
  											testPaperInfo.getReceiverDate());
  									testInfoPd.put("SUBJECTIVE",
  											testPaperInfo.getSubjective());
  									testInfoPd.put("NOTE",
  											testPaperInfo.getNote());
  									testInfoPd.put("MARK_NO",
  											testPaperInfo.getMarkNo());
  									testInfoPdList.add(testInfoPd);
  								}
  							}
  						}
1c817fc8   孙向锦   修改一些bug信息
1593
1594
1595
  						if(testInfoPdList != null && testInfoPdList.size() > 0){
  							testpaperinfoService.batchSave(testInfoPdList);
  						}
2480c889   孙向锦   添加软件管理模块。对软件形成统一的管理
1596
  					}
ce70231e   孙向锦   增加接口
1597
  				} else {
2480c889   孙向锦   添加软件管理模块。对软件形成统一的管理
1598
1599
1600
1601
1602
1603
1604
1605
1606
1607
1608
  					testPaperId = listData.get(0).getString("TESTPAPER_ID");
  				}
  				res.setData(testPaperId);
  			} catch (Exception e) {
  				e.printStackTrace();
  				res.setError();
  				res.setMessage(e.getMessage());
  			}
  		} else {
  			res.setDataError();
  		}
757dfed6   孙向锦   样例报表
1609
  		logger.info("uploadTestpaper cost time:"
ce70231e   孙向锦   增加接口
1610
  				+ (System.currentTimeMillis() - cur));
2480c889   孙向锦   添加软件管理模块。对软件形成统一的管理
1611
1612
1613
  
  		return res.toJson();
  
107fa3a0   孙向锦   修改试卷单选多远混合出题
1614
  	}
ce70231e   孙向锦   增加接口
1615
  
2ad7ca45   孙向锦   试卷bug修改
1616
  	/**
107fa3a0   孙向锦   修改试卷单选多远混合出题
1617
1618
  	 * 上传测验成绩
  	 * 
2ad7ca45   孙向锦   试卷bug修改
1619
1620
  	 * @return
  	 */
2480c889   孙向锦   添加软件管理模块。对软件形成统一的管理
1621
1622
1623
  	@RequestMapping(value = "/uploadupdatetestpaper", produces = "application/json;charset=UTF-8")
  	@ResponseBody
  	public Object uploadupdateTestpaper() {
3371dbc6   孙向锦   0720 版本
1624
  		event("uploadupdateTestpaper");
2480c889   孙向锦   添加软件管理模块。对软件形成统一的管理
1625
1626
1627
1628
1629
1630
1631
1632
1633
1634
1635
1636
1637
1638
1639
1640
1641
  		long cur = System.currentTimeMillis();
  		PageData pd = this.getPageData();
  		ResponseGson<String> res = new ResponseGson();
  		if (!StringUtils.isEmpty(pd.getJsonString())) {
  			logger.info(pd.getJsonString());
  			TestPaper testPaper = TestPaper.parse(pd.getJsonString());
  			try {
  				PageData testPd = new PageData();
  				String testPaperId = this.get32UUID();
  				testPd.put("TEACHER_ID", testPaper.getTeacherId());
  				testPd.put("PAPER_ID", testPaper.getPaperId());
  				testPd.put("SCLASS_ID", testPaper.getClassId());
  				testPd.put(
  						"CREATE_DATE",
  						testPaper.getCreateDate() == null ? Tools
  								.date2Str(new Date()) : testPaper
  								.getCreateDate());
107fa3a0   孙向锦   修改试卷单选多远混合出题
1642
1643
1644
1645
  				testPd.put(
  						"TEST_TYPE",
  						testPaper.getTest_type() != null ? testPaper
  								.getTest_type() : "1");
2480c889   孙向锦   添加软件管理模块。对软件形成统一的管理
1646
1647
1648
1649
1650
1651
1652
1653
1654
1655
1656
1657
  				List<PageData> listData = testpaperService.listAll(testPd);
  				if ((listData != null && listData.size() > 0)) {
  					testPaperId = listData.get(0).getString("TESTPAPER_ID");
  					testpaperService.deleteList(testPd);
  					testPd.put("TEST_ID", testPaperId);
  					testpaperinfoService.delete(testPd);
  					studenttestService.delete(testPd);
  				}
  				testPd.put("START_DATE", testPaper.getStartDate());
  				testPd.put("END_DATE", testPaper.getEndDate());
  				testPd.put("NAME", testPaper.getName());
  				testPd.put("TESTPAPER_ID", testPaperId);
91a745c9   孙向锦   完善后台功能
1658
1659
1660
1661
  				testPd.put("OTHER_SCORE", testPaper.getOtherScore());
  				testPd.put("HIGHT_SCORE", testPaper.getHighScore());
  				testPd.put("LOW_SCORE", testPaper.getLowScore());
  				testPd.put("AVG_SCORE", testPaper.getAvgScore());
03a14c0e   孙向锦   更新报表
1662
  				testPd.put("TOTAL_SCORE", testPaper.getTotalScore());
3a163205   孙向锦   报表优化
1663
  				testPd.put("SUBJECT_ID", testPaper.getSubject_id());
91a745c9   孙向锦   完善后台功能
1664
1665
1666
  				testPd.put("REMARK", testPaper.getRemark());
  				testpaperService.save(testPd);
  				if (testPaper.getStudents() != null) {
2480c889   孙向锦   添加软件管理模块。对软件形成统一的管理
1667
1668
  					List<PageData> testInfoPdList = new ArrayList();
  					PageData testInfoPd = null;
91a745c9   孙向锦   完善后台功能
1669
1670
1671
  					for (StudentAnswer studentAnswer : testPaper.getStudents()) {
  						if (studentAnswer.getQuestions() != null) {
  							PageData studentPageData = new PageData();
91a745c9   孙向锦   完善后台功能
1672
1673
1674
1675
1676
1677
1678
1679
1680
  							studentPageData.put("STUDENT_ID",
  									studentAnswer.getStudentId());
  							studentPageData.put("TEST_ID", testPaperId);
  							studentPageData.put("PAPER_ID",
  									testPaper.getPaperId());
  							studentPageData.put("SCORE",
  									studentAnswer.getScore());
  							studentPageData.put("CLASS_ID",
  									testPaper.getClassId());
2480c889   孙向锦   添加软件管理模块。对软件形成统一的管理
1681
  							studentPageData.put("STUDENTTEST_ID", get32UUID());
91a745c9   孙向锦   完善后台功能
1682
1683
1684
1685
  							studenttestService.save(studentPageData);
  
  							for (TestPaperInfo testPaperInfo : studentAnswer
  									.getQuestions()) {
2480c889   孙向锦   添加软件管理模块。对软件形成统一的管理
1686
  								testInfoPd = new PageData();
91a745c9   孙向锦   完善后台功能
1687
1688
1689
1690
1691
1692
1693
1694
1695
1696
1697
1698
1699
1700
1701
1702
1703
  								testInfoPd.put("TESTPAPERINFO_ID",
  										this.get32UUID());
  								testInfoPd.put("PAPER_ID",
  										testPaper.getPaperId());
  								testInfoPd.put("STUDENT_ID",
  										studentAnswer.getStudentId());
  								testInfoPd.put("TEST_ID", testPaperId);
  								testInfoPd.put("QUESTION_ID",
  										testPaperInfo.getQuestionId());
  								testInfoPd.put("ANSWER",
  										testPaperInfo.getAnswer());
  								testInfoPd.put("RIGHT",
  										testPaperInfo.getRight());
  								testInfoPd.put("SCORE",
  										testPaperInfo.getScore());
  								testInfoPd.put("LIKES",
  										testPaperInfo.getLikes());
2480c889   孙向锦   添加软件管理模块。对软件形成统一的管理
1704
1705
1706
  								testInfoPd.put("ANSWER_TYPE", testPaperInfo
  										.getAnswerType() == null ? "1"
  										: testPaperInfo.getAnswerType());
91a745c9   孙向锦   完善后台功能
1707
1708
1709
1710
1711
1712
1713
1714
1715
  								testInfoPd.put("PRESS_TIME",
  										testPaperInfo.getPressTime());
  								testInfoPd.put("RECEIVER_DATE",
  										testPaperInfo.getReceiverDate());
  								testInfoPd.put("SUBJECTIVE",
  										testPaperInfo.getSubjective());
  								testInfoPd.put("NOTE", testPaperInfo.getNote());
  								testInfoPd.put("MARK_NO",
  										testPaperInfo.getMarkNo());
2480c889   孙向锦   添加软件管理模块。对软件形成统一的管理
1716
  								testInfoPdList.add(testInfoPd);
91a745c9   孙向锦   完善后台功能
1717
1718
1719
  							}
  						}
  					}
1c817fc8   孙向锦   修改一些bug信息
1720
1721
1722
  					if(testInfoPdList != null && testInfoPdList.size() > 0){
  						testpaperinfoService.batchSave(testInfoPdList);
  					}
91a745c9   孙向锦   完善后台功能
1723
1724
1725
1726
1727
1728
1729
1730
1731
1732
  				}
  				res.setData(testPaperId);
  			} catch (Exception e) {
  				e.printStackTrace();
  				res.setError();
  				res.setMessage(e.getMessage());
  			}
  		} else {
  			res.setDataError();
  		}
757dfed6   孙向锦   样例报表
1733
  		logger.info("uploadupdatetestpaper cost time:"
2480c889   孙向锦   添加软件管理模块。对软件形成统一的管理
1734
  				+ (System.currentTimeMillis() - cur));
91a745c9   孙向锦   完善后台功能
1735
1736
1737
1738
  
  		return res.toJson();
  
  	}
107fa3a0   孙向锦   修改试卷单选多远混合出题
1739
  
757dfed6   孙向锦   样例报表
1740
  	/**
107fa3a0   孙向锦   修改试卷单选多远混合出题
1741
1742
  	 * 上传测验成绩
  	 * 
757dfed6   孙向锦   样例报表
1743
1744
1745
1746
1747
1748
1749
1750
1751
1752
1753
1754
1755
1756
1757
1758
1759
1760
1761
1762
1763
1764
1765
1766
1767
1768
1769
1770
1771
1772
1773
  	 * @return
  	 */
  	@RequestMapping(value = "/uploadupdatetestpaper2", produces = "application/json;charset=UTF-8")
  	@ResponseBody
  	public Object uploadupdateTestpaper2() {
  		event("uploadupdateTestpaper2");
  		long cur = System.currentTimeMillis();
  		PageData pd = this.getPageData();
  		ResponseGson<String> res = new ResponseGson();
  		if (!StringUtils.isEmpty(pd.getJsonString())) {
  			logger.info(pd.getJsonString());
  			TestPaper testPaper = TestPaper.parse(pd.getJsonString());
  			try {
  				PageData testPd = new PageData();
  				String testPaperId = this.get32UUID();
  				testPd.put("TEACHER_ID", testPaper.getTeacherId());
  				testPd.put("PAPER_ID", testPaper.getPaperId());
  				testPd.put("SCLASS_ID", testPaper.getClassId());
  				testPd.put(
  						"CREATE_DATE",
  						testPaper.getCreateDate() == null ? Tools
  								.date2Str(new Date()) : testPaper
  								.getCreateDate());
  				List<PageData> listData = testpaperService.listAll(testPd);
  				if ((listData != null && listData.size() > 0)) {
  					testPaperId = listData.get(0).getString("TESTPAPER_ID");
  					testpaperService.deleteList(testPd);
  					testPd.put("TEST_ID", testPaperId);
  					testpaperinfoService.delete(testPd);
  					studenttestService.delete(testPd);
  				}
107fa3a0   孙向锦   修改试卷单选多远混合出题
1774
1775
1776
1777
  				testPd.put(
  						"TEST_TYPE",
  						testPaper.getTest_type() != null ? testPaper
  								.getTest_type() : "101");
757dfed6   孙向锦   样例报表
1778
1779
1780
1781
1782
1783
1784
1785
1786
  				testPd.put("START_DATE", testPaper.getStartDate());
  				testPd.put("END_DATE", testPaper.getEndDate());
  				testPd.put("NAME", testPaper.getName());
  				testPd.put("TESTPAPER_ID", testPaperId);
  				testPd.put("OTHER_SCORE", testPaper.getOtherScore());
  				testPd.put("HIGHT_SCORE", testPaper.getHighScore());
  				testPd.put("LOW_SCORE", testPaper.getLowScore());
  				testPd.put("AVG_SCORE", testPaper.getAvgScore());
  				testPd.put("TOTAL_SCORE", testPaper.getTotalScore());
3a163205   孙向锦   报表优化
1787
  				testPd.put("SUBJECT_ID", testPaper.getSubject_id());
757dfed6   孙向锦   样例报表
1788
1789
1790
1791
1792
1793
1794
1795
1796
1797
1798
1799
1800
1801
1802
1803
1804
1805
1806
  				testPd.put("REMARK", testPaper.getRemark());
  				testpaperService.save(testPd);
  				if (testPaper.getStudents() != null) {
  					List<PageData> testInfoPdList = new ArrayList();
  					PageData testInfoPd = null;
  					for (StudentAnswer studentAnswer : testPaper.getStudents()) {
  						if (studentAnswer.getQuestions() != null) {
  							PageData studentPageData = new PageData();
  							studentPageData.put("STUDENT_ID",
  									studentAnswer.getStudentId());
  							studentPageData.put("TEST_ID", testPaperId);
  							studentPageData.put("PAPER_ID",
  									testPaper.getPaperId());
  							studentPageData.put("SCORE",
  									studentAnswer.getScore());
  							studentPageData.put("CLASS_ID",
  									testPaper.getClassId());
  							studentPageData.put("STUDENTTEST_ID", get32UUID());
  							studenttestService.save(studentPageData);
107fa3a0   孙向锦   修改试卷单选多远混合出题
1807
  
757dfed6   孙向锦   样例报表
1808
1809
1810
1811
1812
1813
1814
1815
1816
1817
1818
1819
1820
1821
1822
1823
1824
1825
1826
1827
1828
1829
  							for (TestPaperInfo testPaperInfo : studentAnswer
  									.getQuestions()) {
  								testInfoPd = new PageData();
  								testInfoPd.put("TESTPAPERINFO_ID",
  										this.get32UUID());
  								testInfoPd.put("PAPER_ID",
  										testPaperInfo.getPaperId());
  								testInfoPd.put("STUDENT_ID",
  										studentAnswer.getStudentId());
  								testInfoPd.put("TEST_ID", testPaperId);
  								testInfoPd.put("QUESTION_ID",
  										testPaperInfo.getQuestionId());
  								testInfoPd.put("ANSWER",
  										testPaperInfo.getAnswer());
  								testInfoPd.put("RIGHT",
  										testPaperInfo.getRight());
  								testInfoPd.put("SCORE",
  										testPaperInfo.getScore());
  								testInfoPd.put("LIKES",
  										testPaperInfo.getLikes());
  								testInfoPd.put("ANSWER_TYPE", testPaperInfo
  										.getAnswerType() == null ? "1"
107fa3a0   孙向锦   修改试卷单选多远混合出题
1830
  										: testPaperInfo.getAnswerType());
757dfed6   孙向锦   样例报表
1831
1832
1833
1834
1835
1836
1837
1838
1839
  								testInfoPd.put("PRESS_TIME",
  										testPaperInfo.getPressTime());
  								testInfoPd.put("RECEIVER_DATE",
  										testPaperInfo.getReceiverDate());
  								testInfoPd.put("SUBJECTIVE",
  										testPaperInfo.getSubjective());
  								testInfoPd.put("NOTE", testPaperInfo.getNote());
  								testInfoPd.put("MARK_NO",
  										testPaperInfo.getMarkNo());
107fa3a0   孙向锦   修改试卷单选多远混合出题
1840
1841
  								testInfoPd.put("RANDOM",
  										testPaperInfo.getRandom());
757dfed6   孙向锦   样例报表
1842
1843
1844
1845
1846
  								testInfoPd.put("RANK", testPaperInfo.getRank());
  								testInfoPdList.add(testInfoPd);
  							}
  						}
  					}
eca4feb5   孙向锦   管理员功能完善
1847
1848
1849
  					if(testInfoPdList.size() > 0){
  						testpaperinfoService.batchSave(testInfoPdList);
  					}
757dfed6   孙向锦   样例报表
1850
1851
1852
1853
1854
1855
1856
1857
1858
1859
  				}
  				res.setData(testPaperId);
  			} catch (Exception e) {
  				e.printStackTrace();
  				res.setError();
  				res.setMessage(e.getMessage());
  			}
  		} else {
  			res.setDataError();
  		}
bda221f4   孙向锦   0830版本
1860
  		logger.info("uploadupdateTestpaper2 cost time:"
757dfed6   孙向锦   样例报表
1861
  				+ (System.currentTimeMillis() - cur));
107fa3a0   孙向锦   修改试卷单选多远混合出题
1862
  
757dfed6   孙向锦   样例报表
1863
  		return res.toJson();
107fa3a0   孙向锦   修改试卷单选多远混合出题
1864
  
757dfed6   孙向锦   样例报表
1865
  	}
91a745c9   孙向锦   完善后台功能
1866
  
2ad7ca45   孙向锦   试卷bug修改
1867
1868
  	/**
  	 * 查询知识点
107fa3a0   孙向锦   修改试卷单选多远混合出题
1869
  	 * 
2ad7ca45   孙向锦   试卷bug修改
1870
1871
1872
  	 * @return
  	 * @throws Exception
  	 */
ce70231e   孙向锦   增加接口
1873
1874
1875
  	@RequestMapping(value = "/point", produces = "application/json;charset=UTF-8")
  	@ResponseBody
  	public Object point() throws Exception {
757dfed6   孙向锦   样例报表
1876
  		event("point");
ce70231e   孙向锦   增加接口
1877
  		ResponseGson<List<PageData>> res = new ResponseGson();
2ad7ca45   孙向锦   试卷bug修改
1878
  
ce70231e   孙向锦   增加接口
1879
  		PageData pd = getPageData();
2ad7ca45   孙向锦   试卷bug修改
1880
  		String key = this.getRequestKey(pd, "point");
ce70231e   孙向锦   增加接口
1881
1882
  		PageData pagedata = new PageData();
  		pagedata.put("KEY", key);
2ad7ca45   孙向锦   试卷bug修改
1883
  		if (!"".equals(key.trim())) {
ce70231e   孙向锦   增加接口
1884
  			PageData ret = cacheService.findById(pagedata);
2ad7ca45   孙向锦   试卷bug修改
1885
  			if (ret != null && ret.get("CACHE") != null) {
ce70231e   孙向锦   增加接口
1886
1887
1888
1889
1890
  				return ret.get("CACHE");
  			}
  		}
  		List<PageData> list = knowledgeService.listAllknowledge(pd);
  		String depth = pd.getString("DEPTH");
2ad7ca45   孙向锦   试卷bug修改
1891
1892
1893
  		int end = 3;
  		if (depth != null) {
  			try {
ce70231e   孙向锦   增加接口
1894
  				end = Integer.parseInt(depth);
2ad7ca45   孙向锦   试卷bug修改
1895
1896
  			} catch (Exception e) {
  
ce70231e   孙向锦   增加接口
1897
1898
  			}
  		}
2ad7ca45   孙向锦   试卷bug修改
1899
  		roundPointData(list, 1, end);
ce70231e   孙向锦   增加接口
1900
1901
  		res.setData(list);
  		String str = res.toJson();
2ad7ca45   孙向锦   试卷bug修改
1902
  		str = str.replaceAll("[^\\u0000-\\uFFFF]", "");
ce70231e   孙向锦   增加接口
1903
1904
1905
1906
1907
  		pagedata.put("CACHE", str);
  		cacheService.save(pagedata);
  		return str;
  	}
  
2ad7ca45   孙向锦   试卷bug修改
1908
1909
  	/**
  	 * 知识点递归查询
107fa3a0   孙向锦   修改试卷单选多远混合出题
1910
1911
1912
1913
1914
1915
1916
  	 * 
  	 * @param list
  	 *            查询知识点及子知识点
  	 * @param dept
  	 *            深度
  	 * @param end
  	 *            层深
2ad7ca45   孙向锦   试卷bug修改
1917
1918
1919
1920
  	 * @throws Exception
  	 */
  	private void roundPointData(List<PageData> list, int dept, int end)
  			throws Exception {
ce70231e   孙向锦   增加接口
1921
1922
1923
1924
1925
1926
1927
  		if (list != null) {
  			for (PageData pd : list) {
  				pd.put("P_ID", pd.getString("KNOWLEDGE_ID"));
  				if (pd.getString("P_ID") != null
  						&& !"".equals(pd.getString("P_ID")) && dept < end) {
  					List<PageData> ret = knowledgeService.listAllknowledge(pd);
  					if (ret != null && ret.size() > 0) {
2ad7ca45   孙向锦   试卷bug修改
1928
  						roundPointData(ret, dept + 1, end);
ce70231e   孙向锦   增加接口
1929
1930
1931
1932
1933
1934
1935
  						pd.put("CHILDREN", ret);
  					}
  				}
  				pd.remove("P_ID");
  			}
  		}
  	}
2ad7ca45   孙向锦   试卷bug修改
1936
1937
1938
  
  	/**
  	 * 章节递归查询
107fa3a0   孙向锦   修改试卷单选多远混合出题
1939
1940
1941
1942
1943
1944
1945
  	 * 
  	 * @param list
  	 *            章节
  	 * @param dept
  	 *            深度
  	 * @param end
  	 *            递归深度
2ad7ca45   孙向锦   试卷bug修改
1946
1947
1948
1949
1950
  	 * @throws Exception
  	 */
  	private void roundChapterData(List<PageData> list, int dept, int end)
  			throws Exception {
  		if (list != null) {
ce70231e   孙向锦   增加接口
1951
1952
  			for (PageData pd : list) {
  				pd.put("P_ID", pd.getString("ID"));
2ad7ca45   孙向锦   试卷bug修改
1953
1954
1955
1956
1957
1958
1959
1960
  				if (dept < end) {
  					if (pd.getString("P_ID") != null
  							&& !"".equals(pd.getString("P_ID"))) {
  						List<PageData> ret = chapterService.listAllChapter(pd);
  						if (ret != null && ret.size() > 0) {
  							roundChapterData(ret, dept + 1, end);
  							pd.put("CHILDREN", ret);
  						}
ce70231e   孙向锦   增加接口
1961
1962
1963
  					}
  				}
  				pd.remove("P_ID");
2ad7ca45   孙向锦   试卷bug修改
1964
  				pd.remove("TEACHINGMATERIAL_ID");
ce70231e   孙向锦   增加接口
1965
1966
1967
1968
  			}
  		}
  	}
  
2ad7ca45   孙向锦   试卷bug修改
1969
  	/**
107fa3a0   孙向锦   修改试卷单选多远混合出题
1970
1971
  	 * 下载测验成绩
  	 * 
2ad7ca45   孙向锦   试卷bug修改
1972
1973
  	 * @return
  	 */
91a745c9   孙向锦   完善后台功能
1974
1975
1976
  	@RequestMapping(value = "/downloadtestpaper", produces = "application/json;charset=UTF-8")
  	@ResponseBody
  	public Object downloadTestpaper() {
3371dbc6   孙向锦   0720 版本
1977
  		event("downloadTestpaper");
2480c889   孙向锦   添加软件管理模块。对软件形成统一的管理
1978
  		long cur = System.currentTimeMillis();
91a745c9   孙向锦   完善后台功能
1979
1980
1981
1982
1983
1984
1985
1986
1987
1988
1989
1990
1991
1992
1993
1994
1995
1996
1997
1998
1999
2000
2001
2002
2003
2004
2005
2006
2007
2008
2009
2010
2011
2012
2013
2014
2015
2016
2017
2018
2019
2020
2021
2022
2023
2024
2025
2026
2027
2028
2029
2030
2031
2032
2033
2034
2035
2036
2037
2038
2039
2040
2041
2042
2043
2044
2045
2046
2047
2048
2049
2050
2051
2052
2053
  		PageData pd = this.getPageData();
  		ResponseGson<TestPaper> res = new ResponseGson();
  
  		String paperId = pd.getString("ID");
  
  		if (!StringUtils.isEmpty(paperId)) {
  			TestPaper testPaper = new TestPaper();
  			try {
  				pd.put("TESTPAPER_ID", paperId);
  				PageData testPd = testpaperService.findById(pd);
  				if (testPd != null) {
  					testPaper.setTestpaperId(paperId);
  					testPaper.setTeacherId(testPd.getString("TEACHER_ID"));
  					testPaper.setName(testPd.getString("NAME"));
  					testPaper.setPaperId(testPd.getString("PAPER_ID"));
  					testPaper.setClassId(testPd.getString("SCLASS_ID"));
  					testPaper.setStartDate(testPd.getString("START_DATE"));
  					testPaper.setEndDate(testPd.getString("END_DATE"));
  					testPaper.setCreateDate(testPd.getString("CREATE_DATE"));
  					testPaper.setOtherScore(testPd.getString("OTHER_SCORE"));
  					testPaper.setHighScore(testPd.getString("HIGHT_SCORE"));
  					testPaper.setLowScore(testPd.getString("LOW_SCORE"));
  					testPaper.setAvgScore(testPd.getString("AVG_SCORE"));
  					testPaper.setRemark(testPd.getString("REMARK"));
  					PageData testInfof = new PageData();
  					testInfof.put("TEST_ID", paperId);
  
  					List<PageData> studentList = studenttestService
  							.listAll(testInfof);
  
  					for (PageData sPageData : studentList) {
  						StudentAnswer studentAnswer = new StudentAnswer();
  						testInfof.put("STDUENT_ID",
  								sPageData.getString("STDUENT_ID"));
  						studentAnswer.setScore(sPageData.getString("SCORE"));
  						List<PageData> list = testpaperinfoService
  								.listAll(testInfof);
  						for (PageData testInfoPd : list) {
  							TestPaperInfo testPaperInfo = new TestPaperInfo();
  							testPaperInfo.setTestPaperInfoId(testInfoPd
  									.getString("TESTPAPERINFO_ID"));
  							testPaperInfo.setQuestionId(testInfoPd
  									.getString("QUESTION_ID"));
  							testPaperInfo.setAnswer(testInfoPd
  									.getString("ANSWER"));
  							testPaperInfo.setRight(testInfoPd
  									.getString("RIGHT"));
  							testPaperInfo.setScore(testInfoPd
  									.getString("SCORE"));
  							testPaperInfo.setLikes(testInfoPd
  									.getString("LIKES"));
  							testPaperInfo.setAnswerType(testInfoPd
  									.getString("ANSWER_TYPE"));
  							testPaperInfo.setPressTime(testInfoPd
  									.getString("PRESS_TIME"));
  							testPaperInfo.setReceiverDate(testInfoPd
  									.getString("RECEIVER_DATE"));
  							testPaperInfo.setSubjective(testInfoPd
  									.getString("SUBJECTIVE"));
  							testPaperInfo.setNote(testInfoPd.getString("NOTE"));
  							testPaperInfo.setMarkNo(testInfoPd
  									.getString("MARK_NO"));
  							testPaperInfo.setRank(testInfoPd.getString("RANK"));
  							studentAnswer.getQuestions().add(testPaperInfo);
  						}
  						testPaper.getStudents().add(studentAnswer);
  					}
  				}
  
  				res.setData(testPaper);
  			} catch (Exception e) {
  				e.printStackTrace();
  				res.setError();
  			}
  		}
ce70231e   孙向锦   增加接口
2054
2055
  		logger.info("downloadtestpaper cost time:"
  				+ (System.currentTimeMillis() - cur));
338594c8   孙向锦   添加教师端页面
2056
  		return res.toJson();
91a745c9   孙向锦   完善后台功能
2057
  
338594c8   孙向锦   添加教师端页面
2058
2059
  	}
  
2ad7ca45   孙向锦   试卷bug修改
2060
2061
  	/**
  	 * 
107fa3a0   孙向锦   修改试卷单选多远混合出题
2062
2063
  	 * 下载测验成绩
  	 * 
2ad7ca45   孙向锦   试卷bug修改
2064
2065
  	 * @return
  	 */
91a745c9   孙向锦   完善后台功能
2066
2067
2068
  	@RequestMapping(value = "/testpaper", produces = "application/json;charset=UTF-8")
  	@ResponseBody
  	public Object testpaper() {
3371dbc6   孙向锦   0720 版本
2069
  		event("testpaper");
2480c889   孙向锦   添加软件管理模块。对软件形成统一的管理
2070
  		long cur = System.currentTimeMillis();
91a745c9   孙向锦   完善后台功能
2071
2072
2073
2074
2075
2076
2077
2078
2079
2080
2081
2082
2083
2084
2085
2086
2087
2088
2089
2090
2091
2092
2093
2094
2095
2096
2097
2098
2099
2100
2101
  		PageData pd = this.getPageData();
  		ResponseGson<List<TestPaper>> res = new ResponseGson();
  		pd.put("TEACHER_ID", pd.getString("USER_ID"));
  		try {
  			List<PageData> pageList = testpaperService.listAll(pd);
  			List<TestPaper> list = new ArrayList<TestPaper>();
  			if (pageList != null) {
  				for (PageData testPd : pageList) {
  					TestPaper testPaper = new TestPaper();
  					testPaper.setTestpaperId(testPd.getString("TESTPAPER_ID"));
  					testPaper.setTeacherId(testPd.getString("TEACHER_ID"));
  					testPaper.setName(testPd.getString("NAME"));
  					testPaper.setPaperId(testPd.getString("PAPER_ID"));
  					testPaper.setClassId(testPd.getString("SCLASS_ID"));
  					testPaper.setStartDate(testPd.getString("START_DATE"));
  					testPaper.setEndDate(testPd.getString("END_DATE"));
  					testPaper.setCreateDate(testPd.getString("CREATE_DATE"));
  					testPaper.setOtherScore(testPd.getString("OTHER_SCORE"));
  					testPaper.setHighScore(testPd.getString("HIGHT_SCORE"));
  					testPaper.setLowScore(testPd.getString("LOW_SCORE"));
  					testPaper.setAvgScore(testPd.getString("AVG_SCORE"));
  					testPaper.setRemark(testPd.getString("REMARK"));
  					list.add(testPaper);
  				}
  			}
  			res.setData(list);
  		} catch (Exception e) {
  			res.setError();
  			res.setMessage(e.getMessage());
  			e.printStackTrace();
  		}
2480c889   孙向锦   添加软件管理模块。对软件形成统一的管理
2102
  		logger.info("testpaper cost time:" + (System.currentTimeMillis() - cur));
91a745c9   孙向锦   完善后台功能
2103
2104
2105
  		return res.toJson();
  
  	}
ce70231e   孙向锦   增加接口
2106
  
2ad7ca45   孙向锦   试卷bug修改
2107
2108
2109
  	/***
  	 * 
  	 */
4fd2e08c   孙向锦   修复接口中的bug
2110
2111
  	@RequestMapping(value = "/schooladmin", produces = "application/json;charset=UTF-8")
  	@ResponseBody
ce70231e   孙向锦   增加接口
2112
  	public void schoolAdmin() {
3371dbc6   孙向锦   0720 版本
2113
  		event("schoolAdmin");
4fd2e08c   孙向锦   修复接口中的bug
2114
2115
  		PageData pd = this.getPageData();
  		this.getUserID();
4fd2e08c   孙向锦   修复接口中的bug
2116
  	}
ce70231e   孙向锦   增加接口
2117
  
2ad7ca45   孙向锦   试卷bug修改
2118
2119
  	/***
  	 * 网络
107fa3a0   孙向锦   修改试卷单选多远混合出题
2120
  	 * 
2ad7ca45   孙向锦   试卷bug修改
2121
2122
2123
  	 * @return
  	 * @throws Exception
  	 */
9338b563   孙向锦   添加报表
2124
2125
  	@RequestMapping(value = "/network", produces = "application/json;charset=UTF-8")
  	@ResponseBody
ce70231e   孙向锦   增加接口
2126
  	public Object network() throws Exception {
3371dbc6   孙向锦   0720 版本
2127
  		event("network");
9338b563   孙向锦   添加报表
2128
2129
2130
2131
2132
2133
2134
2135
2136
2137
2138
2139
  		PageData pd = this.getPageData();
  		ResponseGson<PageData> res = new ResponseGson();
  		PageData spd = networkstatisticsService.findByClientID(pd);
  		String seqStr = pd.getString("SEQ");
  		if (seqStr != null && pd.getString("CLIENT_ID") != null
  				&& pd.getString("SESSION_ID") != null) {
  			int seq = Integer.parseInt(seqStr);
  			if (spd != null) {
  				int successCount = Integer.parseInt(spd
  						.getString("SUCCESS_COUNT"));
  				spd.put("SUCCESS_COUNT", ++successCount + "");
  				int fail = seq - successCount;
ce70231e   孙向锦   增加接口
2140
  				if (fail < 0) {
9338b563   孙向锦   添加报表
2141
2142
2143
2144
2145
2146
2147
2148
2149
2150
2151
2152
2153
  					fail = 0;
  				}
  				spd.put("FAIL_COUNT", fail + "");
  				networkstatisticsService.edit(spd);
  				spd.remove("NETWORKSTATISTICS_ID");
  				spd.remove("CLIENT_ID");
  				spd.remove("SESSION_ID");
  				res.setData(spd);
  			} else {
  				pd.put("NETWORKSTATISTICS_ID", get32UUID());
  				pd.put("SUCCESS_COUNT", "1");
  				pd.put("CLIENT_IP", getRemoteIp());
  				int fail = seq - 1;
ce70231e   孙向锦   增加接口
2154
  				if (fail < 0) {
9338b563   孙向锦   添加报表
2155
2156
2157
2158
2159
2160
2161
2162
2163
2164
2165
  					fail = 0;
  				}
  				pd.put("FAIL_COUNT", fail + "");
  				networkstatisticsService.save(pd);
  				pd.remove("JSON");
  				pd.remove("CLIENT_ID");
  				pd.remove("SESSION_ID");
  				pd.remove("SEQ");
  				pd.remove("NETWORKSTATISTICS_ID");
  				res.setData(pd);
  			}
ce70231e   孙向锦   增加接口
2166
  		} else {
9338b563   孙向锦   添加报表
2167
2168
2169
2170
  			res.setDataError();
  		}
  		return res.toJson();
  	}
ce70231e   孙向锦   增加接口
2171
  
2ad7ca45   孙向锦   试卷bug修改
2172
2173
  	/**
  	 * 获取远端ip地址
107fa3a0   孙向锦   修改试卷单选多远混合出题
2174
  	 * 
2ad7ca45   孙向锦   试卷bug修改
2175
2176
  	 * @return
  	 */
ce70231e   孙向锦   增加接口
2177
  	public String getRemoteIp() {
9338b563   孙向锦   添加报表
2178
2179
2180
2181
2182
2183
2184
2185
2186
  		HttpServletRequest request = getRequest();
  		String ip = "";
  		if (request.getHeader("x-forwarded-for") == null) {
  			ip = request.getRemoteAddr();
  		} else {
  			ip = request.getHeader("x-forwarded-for");
  		}
  		return ip;
  	}
ce70231e   孙向锦   增加接口
2187
  
2ad7ca45   孙向锦   试卷bug修改
2188
2189
  	/**
  	 * 查询新版本信息
107fa3a0   孙向锦   修改试卷单选多远混合出题
2190
  	 * 
2ad7ca45   孙向锦   试卷bug修改
2191
2192
2193
2194
  	 * @param request
  	 * @return
  	 * @throws Exception
  	 */
2480c889   孙向锦   添加软件管理模块。对软件形成统一的管理
2195
2196
  	@RequestMapping(value = "/newversion", produces = "application/json;charset=UTF-8")
  	@ResponseBody
ce70231e   孙向锦   增加接口
2197
  	public Object getNewVersion(HttpServletRequest request) throws Exception {
3371dbc6   孙向锦   0720 版本
2198
  		event("getNewVersion");
2480c889   孙向锦   添加软件管理模块。对软件形成统一的管理
2199
2200
2201
  		PageData pd = this.getPageData();
  		String softId = pd.getString("SOFTID");
  		String path = request.getContextPath();
ce70231e   孙向锦   增加接口
2202
2203
  		String basePath = request.getScheme() + "://" + request.getServerName()
  				+ ":" + request.getServerPort() + path + "/";
2480c889   孙向锦   添加软件管理模块。对软件形成统一的管理
2204
  		ResponseGson<PageData> res = new ResponseGson();
ce70231e   孙向锦   增加接口
2205
  		if (softId != null && !"".equals(softId)) {
2480c889   孙向锦   添加软件管理模块。对软件形成统一的管理
2206
2207
  			pd.put("SOFTWARE_ID", softId);
  			PageData result = softwareversionService.findNewVersion(pd);
ce70231e   孙向锦   增加接口
2208
  			if (result != null) {
2480c889   孙向锦   添加软件管理模块。对软件形成统一的管理
2209
2210
  				result.remove("SOFTWAREVERSION_ID");
  				result.remove("SOFTWARE_ID");
ce70231e   孙向锦   增加接口
2211
2212
  				result.put("VERSION_PATH", basePath + "uploadFiles/uploadFile/"
  						+ result.getString("VERSION_PATH"));
2480c889   孙向锦   添加软件管理模块。对软件形成统一的管理
2213
  				res.setData(result);
ce70231e   孙向锦   增加接口
2214
  			} else {
2480c889   孙向锦   添加软件管理模块。对软件形成统一的管理
2215
2216
  				res.setDataError();
  			}
ce70231e   孙向锦   增加接口
2217
  		} else {
2480c889   孙向锦   添加软件管理模块。对软件形成统一的管理
2218
2219
2220
2221
  			res.setDataError();
  		}
  		return res.toJson();
  	}
ce70231e   孙向锦   增加接口
2222
2223
2224
2225
2226
2227
2228
2229
2230
2231
2232
2233
2234
2235
2236
2237
2238
2239
2240
2241
2242
2243
2244
2245
  
  	/**
  	 * 获取教材版本
  	 * 
  	 * @return
  	 * @throws Exception
  	 */
  	@RequestMapping(value = "/teachingmaterial", produces = "application/json;charset=UTF-8")
  	@ResponseBody
  	public Object teachingmaterial() throws Exception {
  		PageData pd = getPageData();
  		ResponseGson<List<PageData>> ret = new ResponseGson<List<PageData>>();
  		List<PageData> lpd = new ArrayList<PageData>();
  		List<PageData> list = teachingmaterialService.listAll(pd);
  		String subjectID = pd.getString("SUBJECT_ID");
  		if (subjectID != null && !"".equals(subjectID)) {
  			for (PageData pad : list) {
  				String subis = pad.getString("SUBJECT_ID");
  				if (subis != null) {
  					String[] subs = subis.split(",");
  					if (subs != null) {
  						for (String sub : subs) {
  							if (subjectID.trim().equals(sub.trim())) {
  								pad.remove("SUBJECT_ID");
2ad7ca45   孙向锦   试卷bug修改
2246
2247
  								pad.put("VERSION_CODE",
  										pad.getString("VERSION_CODE"));
ce70231e   孙向锦   增加接口
2248
2249
2250
2251
2252
2253
2254
2255
2256
2257
2258
2259
2260
2261
2262
2263
2264
  								lpd.add(pad);
  								break;
  							}
  						}
  					}
  				}
  			}
  		} else {
  			for (PageData pad : list) {
  				pad.remove("SUBJECT_ID");
  				pad.put("VERSION_CODE", pad.getString("VERSION_CODE"));
  				lpd.add(pad);
  			}
  		}
  		ret.setData(lpd);
  		return ret.toJson();
  	}
107fa3a0   孙向锦   修改试卷单选多远混合出题
2265
  
c617106f   孙向锦   添加即时测功能
2266
2267
2268
2269
2270
2271
2272
2273
2274
  	@RequestMapping(value = "/textbook", produces = "application/json;charset=UTF-8")
  	@ResponseBody
  	public Object textbook() throws Exception {
  		PageData pd = getPageData();
  		ResponseGson<List<PageData>> ret = new ResponseGson<List<PageData>>();
  		List<PageData> list = textbookService.listAll(pd);
  		ret.setData(list);
  		return ret.toJson();
  	}
2ad7ca45   孙向锦   试卷bug修改
2275
  
ce70231e   孙向锦   增加接口
2276
2277
2278
2279
2280
2281
2282
2283
2284
2285
  	/**
  	 * 获取教材版本
  	 * 
  	 * @return
  	 * @throws Exception
  	 */
  	@RequestMapping(value = "/chapter", produces = "application/json;charset=UTF-8")
  	@ResponseBody
  	public Object chapter() throws Exception {
  		PageData pd = getPageData();
2ad7ca45   孙向锦   试卷bug修改
2286
  		String key = this.getRequestKey(pd, "chapter");
ce70231e   孙向锦   增加接口
2287
2288
  		PageData pagedata = new PageData();
  		pagedata.put("KEY", key);
2ad7ca45   孙向锦   试卷bug修改
2289
  		if (!"".equals(key.trim())) {
ce70231e   孙向锦   增加接口
2290
  			PageData ret = cacheService.findById(pagedata);
2ad7ca45   孙向锦   试卷bug修改
2291
  			if (ret != null && ret.get("CACHE") != null) {
ce70231e   孙向锦   增加接口
2292
2293
2294
2295
2296
2297
  				return ret.get("CACHE");
  			}
  		}
  		ResponseGson<List<PageData>> res = new ResponseGson<List<PageData>>();
  		List<PageData> list = chapterService.listAllChapter(pd);
  		String depth = pd.getString("DEPTH");
2ad7ca45   孙向锦   试卷bug修改
2298
2299
2300
  		int end = 3;
  		if (depth != null) {
  			try {
ce70231e   孙向锦   增加接口
2301
  				end = Integer.parseInt(depth);
2ad7ca45   孙向锦   试卷bug修改
2302
2303
  			} catch (Exception e) {
  
ce70231e   孙向锦   增加接口
2304
2305
  			}
  		}
2ad7ca45   孙向锦   试卷bug修改
2306
  		roundChapterData(list, 1, end);
ce70231e   孙向锦   增加接口
2307
2308
  		res.setData(list);
  		String str = res.toJson();
ce70231e   孙向锦   增加接口
2309
2310
2311
2312
  		pagedata.put("CACHE", str);
  		cacheService.save(pagedata);
  		return str;
  	}
2ad7ca45   孙向锦   试卷bug修改
2313
  
ce70231e   孙向锦   增加接口
2314
2315
2316
2317
2318
2319
2320
2321
2322
2323
2324
2325
2326
  	/**
  	 * 获取试题
  	 * 
  	 * @return
  	 * @throws Exception
  	 */
  	@RequestMapping(value = "/questions", produces = "application/json;charset=UTF-8")
  	@ResponseBody
  	public Object questions() throws Exception {
  		PageData pd = getPageData();
  		ResponseGson<List<PageData>> res = new ResponseGson<List<PageData>>();
  		String teachingmaterialId = pd.getString("TEACHINGMATERIAL_ID");
  		String chapterId = pd.getString("CHAPTER_ID");
2ad7ca45   孙向锦   试卷bug修改
2327
2328
  		if (teachingmaterialId != null && !teachingmaterialId.equals("")
  				&& chapterId == null) {
ce70231e   孙向锦   增加接口
2329
2330
  			PageData chapterPd = new PageData();
  			chapterPd.put("TEACHINGMATERIAL_ID", teachingmaterialId);
2ad7ca45   孙向锦   试卷bug修改
2331
2332
  			List<PageData> chapterList = chapterService
  					.listAllChapter(chapterPd);
ce70231e   孙向锦   增加接口
2333
  			roundChapterData(chapterList, 1, 3);
2ad7ca45   孙向锦   试卷bug修改
2334
  			List<String> ids = getIds(chapterList, "ID");
ce70231e   孙向锦   增加接口
2335
  			pd.put("CHAPTER_IDS", ids);
2ad7ca45   孙向锦   试卷bug修改
2336
  		} else {
ce70231e   孙向锦   增加接口
2337
  			List<String> ids = new ArrayList<String>();
2ad7ca45   孙向锦   试卷bug修改
2338
  			if (chapterId != null && !"".equals(chapterId.trim())) {
ce70231e   孙向锦   增加接口
2339
2340
2341
2342
2343
2344
  				ids.add(chapterId);
  			}
  			pd.put("CHAPTER_IDS", ids);
  		}
  		pd.remove("CHAPTER_ID");
  		String knowledge = pd.getString("KNOWLEDGE_ID");
2ad7ca45   孙向锦   试卷bug修改
2345
  		if (knowledge != null && !"".equals(knowledge.trim())) {
ce70231e   孙向锦   增加接口
2346
2347
2348
2349
  			PageData knowPd = new PageData();
  			knowPd.put("P_ID", knowledge);
  			List<PageData> knowlist = knowledgeService.listAllknowledge(knowPd);
  			roundPointData(knowlist, 1, 3);
2ad7ca45   孙向锦   试卷bug修改
2350
  			List<String> ids = getIds(knowlist, "KNOWLEDGE_ID");
ce70231e   孙向锦   增加接口
2351
  			ids.add(knowledge);
2ad7ca45   孙向锦   试卷bug修改
2352
  			pd.put("KNOWLEDGE_IDS", ids);
ce70231e   孙向锦   增加接口
2353
2354
  			pd.remove("KNOWLEDGE_ID");
  		}
107fa3a0   孙向锦   修改试卷单选多远混合出题
2355
2356
  		int pageNumI = 0;
  		int count = 30;
0aad4b6b   孙向锦   修复试题分页功能
2357
2358
  		String pageNum = pd.getString("PAGENUM");
  		String countStr = pd.getString("COUNT");
107fa3a0   孙向锦   修改试卷单选多远混合出题
2359
2360
  		if (pageNum != null && !"".equals(pageNum) && countStr != null
  				&& !"".equals(countStr)) {
0aad4b6b   孙向锦   修复试题分页功能
2361
2362
  			pageNumI = Integer.parseInt(pageNum);
  			count = Integer.parseInt(countStr);
107fa3a0   孙向锦   修改试卷单选多远混合出题
2363
2364
2365
2366
  			if (pageNumI >= 1) {
  				pageNumI = (pageNumI - 1) * count;
  			} else {
  				pageNumI = 0;
0aad4b6b   孙向锦   修复试题分页功能
2367
2368
2369
2370
  			}
  			pd.put("PAGENUM", "" + pageNumI);
  			pd.put("COUNT", "" + count);
  		}
ce70231e   孙向锦   增加接口
2371
  		List<PageData> list = questionService.listAllquestion(pd);
107fa3a0   孙向锦   修改试卷单选多远混合出题
2372
  		for (PageData pad : list) {
c617106f   孙向锦   添加即时测功能
2373
  			String optionContent = pad.getString("OPTION_CONTENT");
107fa3a0   孙向锦   修改试卷单选多远混合出题
2374
2375
2376
2377
  			if (optionContent != null && optionContent.startsWith("[")
  					&& optionContent.endsWith("]")) {
  				String[] options = optionContent.substring(1,
  						optionContent.length() - 1).split(",");
c617106f   孙向锦   添加即时测功能
2378
  				pad.put("OPTION_CONTENT", options);
107fa3a0   孙向锦   修改试卷单选多远混合出题
2379
2380
  			} else {
  				pad.put("OPTION_CONTENT", new String[] { optionContent });
c617106f   孙向锦   添加即时测功能
2381
  			}
a0eff87f   孙向锦   修改课后练bug
2382
2383
2384
2385
  			
  			if(pad.getString("CONTENT") != null){
  				pad.put("CONTENT", pad.getString("CONTENT").replaceAll("<fill></fill>", "______"));
  			}
c617106f   孙向锦   添加即时测功能
2386
  		}
ce70231e   孙向锦   增加接口
2387
2388
2389
  		res.setData(list);
  		return res.toJson();
  	}
2ad7ca45   孙向锦   试卷bug修改
2390
  
ce70231e   孙向锦   增加接口
2391
2392
2393
2394
2395
2396
2397
2398
2399
2400
2401
2402
2403
  	/**
  	 * 随机获取试题
  	 * 
  	 * @return
  	 * @throws Exception
  	 */
  	@RequestMapping(value = "/randquestions", produces = "application/json;charset=UTF-8")
  	@ResponseBody
  	public Object randquestions() throws Exception {
  		PageData pd = getPageData();
  		ResponseGson<List<PageData>> res = new ResponseGson<List<PageData>>();
  		String teachingmaterialId = pd.getString("TEACHINGMATERIAL_ID");
  		String chapterId = pd.getString("CHAPTER_ID");
2ad7ca45   孙向锦   试卷bug修改
2404
2405
  		if (teachingmaterialId != null && !teachingmaterialId.equals("")
  				&& chapterId == null) {
ce70231e   孙向锦   增加接口
2406
2407
  			PageData chapterPd = new PageData();
  			chapterPd.put("TEACHINGMATERIAL_ID", teachingmaterialId);
2ad7ca45   孙向锦   试卷bug修改
2408
2409
  			List<PageData> chapterList = chapterService
  					.listAllChapter(chapterPd);
ce70231e   孙向锦   增加接口
2410
  			roundChapterData(chapterList, 1, 3);
2ad7ca45   孙向锦   试卷bug修改
2411
  			List<String> ids = getIds(chapterList, "ID");
ce70231e   孙向锦   增加接口
2412
  			pd.put("CHAPTER_IDS", ids);
2ad7ca45   孙向锦   试卷bug修改
2413
  		} else {
ce70231e   孙向锦   增加接口
2414
  			List<String> ids = new ArrayList<String>();
2ad7ca45   孙向锦   试卷bug修改
2415
  			if (chapterId != null && !"".equals(chapterId.trim())) {
ce70231e   孙向锦   增加接口
2416
2417
2418
2419
2420
2421
  				ids.add(chapterId);
  			}
  			pd.put("CHAPTER_IDS", ids);
  		}
  		pd.remove("CHAPTER_ID");
  		String knowledge = pd.getString("KNOWLEDGE_ID");
2ad7ca45   孙向锦   试卷bug修改
2422
  		if (knowledge != null && !"".equals(knowledge.trim())) {
ce70231e   孙向锦   增加接口
2423
2424
2425
2426
  			PageData knowPd = new PageData();
  			knowPd.put("P_ID", knowledge);
  			List<PageData> knowlist = knowledgeService.listAllknowledge(knowPd);
  			roundPointData(knowlist, 1, 3);
2ad7ca45   孙向锦   试卷bug修改
2427
  			List<String> ids = getIds(knowlist, "KNOWLEDGE_ID");
ce70231e   孙向锦   增加接口
2428
  			ids.add(knowledge);
2ad7ca45   孙向锦   试卷bug修改
2429
  			pd.put("KNOWLEDGE_IDS", ids);
ce70231e   孙向锦   增加接口
2430
2431
2432
  			pd.remove("KNOWLEDGE_ID");
  		}
  		List<PageData> list = questionService.listAllRandquestion(pd);
107fa3a0   孙向锦   修改试卷单选多远混合出题
2433
  		for (PageData pad : list) {
c617106f   孙向锦   添加即时测功能
2434
  			String optionContent = pad.getString("OPTION_CONTENT");
107fa3a0   孙向锦   修改试卷单选多远混合出题
2435
2436
2437
2438
  			if (optionContent != null && optionContent.startsWith("[")
  					&& optionContent.endsWith("]")) {
  				String[] options = optionContent.substring(1,
  						optionContent.length() - 1).split(",");
c617106f   孙向锦   添加即时测功能
2439
  				pad.put("OPTION_CONTENT", options);
107fa3a0   孙向锦   修改试卷单选多远混合出题
2440
2441
  			} else {
  				pad.put("OPTION_CONTENT", new String[] { optionContent });
c617106f   孙向锦   添加即时测功能
2442
2443
  			}
  		}
ce70231e   孙向锦   增加接口
2444
2445
2446
  		res.setData(list);
  		return res.toJson();
  	}
2ad7ca45   孙向锦   试卷bug修改
2447
2448
2449
2450
2451
2452
2453
2454
  
  	/**
  	 * 
  	 * @param chapterList
  	 * @param key
  	 * @return
  	 */
  	public List<String> getIds(List<PageData> chapterList, String key) {
ce70231e   孙向锦   增加接口
2455
  		List<String> ids = new ArrayList<String>();
2ad7ca45   孙向锦   试卷bug修改
2456
2457
  		if (chapterList != null && chapterList.size() > 0) {
  			for (PageData pd : chapterList) {
ce70231e   孙向锦   增加接口
2458
  				String chapterid = pd.getString(key);
2ad7ca45   孙向锦   试卷bug修改
2459
  				if (chapterid != null && !"".equals(chapterid)) {
ce70231e   孙向锦   增加接口
2460
2461
2462
  					ids.add(chapterid);
  				}
  				Object obj = pd.get("CHILDREN");
2ad7ca45   孙向锦   试卷bug修改
2463
  				if (obj != null && (obj instanceof List)) {
ce70231e   孙向锦   增加接口
2464
  					@SuppressWarnings("unchecked")
2ad7ca45   孙向锦   试卷bug修改
2465
2466
2467
  					List<PageData> list = (List<PageData>) obj;
  					List<String> ret = getIds(list, key);
  					if (ret != null && ret.size() > 0) {
ce70231e   孙向锦   增加接口
2468
2469
2470
2471
2472
  						ids.addAll(ret);
  					}
  				}
  			}
  		}
2ad7ca45   孙向锦   试卷bug修改
2473
  
ce70231e   孙向锦   增加接口
2474
  		return ids;
2ad7ca45   孙向锦   试卷bug修改
2475
  
ce70231e   孙向锦   增加接口
2476
2477
  	}
  
2ad7ca45   孙向锦   试卷bug修改
2478
2479
2480
2481
2482
  	/**
  	 * 
  	 * @return
  	 * @throws Exception
  	 */
d3d7b2ca   孙向锦   修改表格固定
2483
2484
  	@RequestMapping(value = "/tempcreateUser", produces = "application/json;charset=UTF-8")
  	@ResponseBody
ce70231e   孙向锦   增加接口
2485
  	public Object tempCreateUser() throws Exception {
d3d7b2ca   孙向锦   修改表格固定
2486
2487
2488
2489
  		PageData pd = new PageData();
  		pd = this.getPageData();
  		pd.put("ID", this.get32UUID());
  		teacherService.save(pd);
ce70231e   孙向锦   增加接口
2490
2491
2492
2493
  		pd.put("USER_ID", pd.getString("ID")); // ID 主键
  		pd.put("LAST_LOGIN", ""); // 最后登录时间
  		pd.put("IP", ""); // IP
  		pd.put("STATUS", "0"); // 状态
d3d7b2ca   孙向锦   修改表格固定
2494
  		pd.put("SKIN", "default");
ce70231e   孙向锦   增加接口
2495
  		pd.put("RIGHTS", "");
d3d7b2ca   孙向锦   修改表格固定
2496
  		pd.put("USERNAME", pd.getString("ACCOUT"));
ce70231e   孙向锦   增加接口
2497
2498
2499
2500
2501
2502
2503
  		pd.put("ROLE_ID", "57bb1e6f138247a0b05cc721a5da1b64");
  		pd.put("PASSWORD",
  				new SimpleHash("SHA-1", pd.getString("ACCOUT"), pd
  						.getString("PASSWORD")).toString()); // 密码加密
  
  		if (null == userService.findByUsername(pd)) { // 判断用户名是否存在
  			userService.saveU(pd); // 执行保存
d3d7b2ca   孙向锦   修改表格固定
2504
  		}
ce70231e   孙向锦   增加接口
2505
2506
2507
  
  		// ID, TEACHER_ID, CLASS_ID, SUBJECT_ID, START_DATE, END_DATE, GRADE_ID,
  		// TERM_ID, REMARK
d3d7b2ca   孙向锦   修改表格固定
2508
2509
2510
2511
  		pd.put("TEACHER_ID", pd.get("ID"));
  		pd.put("CLASS_ID", "bc33389101ec46e6b7d47daa8adf58ac");
  		pd.put("SUBJECT_ID", "1");
  		pd.put("GRADE_ID", "1");
ce70231e   孙向锦   增加接口
2512
  		pd.put("TERM_ID", "0d8ea2efdef74accbd0d00e9bc07dfbb");
d3d7b2ca   孙向锦   修改表格固定
2513
  		coursemanagementService.save(pd);
ce70231e   孙向锦   增加接口
2514
  
d3d7b2ca   孙向锦   修改表格固定
2515
2516
  		return "{'res':'success'}";
  	}
2480c889   孙向锦   添加软件管理模块。对软件形成统一的管理
2517
  
2ad7ca45   孙向锦   试卷bug修改
2518
2519
2520
2521
  	/**
  	 * 
  	 * @param apiName
  	 */
ce70231e   孙向锦   增加接口
2522
  	private void event(String apiName) {
48d44272   孙向锦   添加一些action
2523
2524
2525
2526
2527
2528
2529
2530
2531
2532
2533
2534
2535
  //		PageData eventPd = new PageData();
  //		eventPd.put("EVENT_ID", get32UUID());
  //		eventPd.put("EVENT_NAME", apiName);
  //		eventPd.put("EVENT_USER", getUsername());
  //		eventPd.put("EVENT_TYPE", "-1");
  //		eventPd.put("EVENT_START_TIME", Tools.date2Str(new Date()));
  //		eventPd.put("CLIENT_ID", "SERVER");
  //		eventPd.put("EVENT_IP", getRemoteIp());
  //		try {
  //			eventService.save(eventPd);
  //		} catch (Exception e) {
  //
  //		}
ce70231e   孙向锦   增加接口
2536
2537
2538
2539
  	}
  
  	static int index = 0;
  
2ad7ca45   孙向锦   试卷bug修改
2540
2541
2542
2543
2544
  	/**
  	 * 
  	 * @param point
  	 * @param pid
  	 */
ce70231e   孙向锦   增加接口
2545
2546
2547
2548
2549
2550
2551
2552
2553
2554
2555
2556
2557
2558
2559
2560
2561
2562
2563
  	private void savePoint(Point point, String pid) {
  		List<Point> children = point.getChildren();
  		if (children != null && children.size() > 0) {
  			for (Point p : children) {
  				savePoint(p, point.getCode());
  			}
  		}
  		PageData pageData = new PageData();
  		pageData.put("KNOWLEDGE_ID", point.getCode());
  		pageData.put("NAME", point.getName());
  		pageData.put("P_ID", pid);
  		pageData.put("RANK", ++index);
  		try {
  			knowledgeService.save(pageData);
  		} catch (Exception e) {
  			e.printStackTrace();
  		}
  	}
  
2ad7ca45   孙向锦   试卷bug修改
2564
2565
2566
2567
2568
  	/**
  	 * 
  	 * @return
  	 * @throws Exception
  	 */
ce70231e   孙向锦   增加接口
2569
2570
2571
2572
2573
2574
2575
2576
2577
2578
2579
2580
2581
2582
2583
2584
2585
2586
2587
2588
2589
2590
2591
2592
2593
2594
2595
2596
2597
  	@RequestMapping(value = "/uploadbook", produces = "application/json;charset=UTF-8")
  	@ResponseBody
  	public Object uploadbook() throws Exception {
  		event("uploadbook");
  		long cur = System.currentTimeMillis();
  		PageData pd = this.getPageData();
  		ResponseGson<String> res = new ResponseGson();
  
  		if (!StringUtils.isEmpty(pd.getJsonString())) {
  			try {
  				ResponseGson<List<Point>> req = ResponseGson.parse(
  						pd.getJsonString(), Point.class);
  				List<Point> list = req.getData();
  				if (list != null && list.size() > 0) {
  					for (Point point : list) {
  						saveBook(point);
  					}
  				}
  			} catch (Exception e) {
  				res.setError();
  			}
  		} else {
  			res.setDataError();
  		}
  		logger.info("uploadpoint cost time : "
  				+ (System.currentTimeMillis() - cur));
  		return res.toJson();
  	}
  
2ad7ca45   孙向锦   试卷bug修改
2598
2599
2600
2601
  	/**
  	 * 
  	 * @param point
  	 */
ce70231e   孙向锦   增加接口
2602
2603
2604
2605
2606
2607
2608
2609
2610
  	private void saveBook(Point point) {
  
  		PageData pd = new PageData();
  		pd.put("ID", point.getCode());
  		pd.put("NAME", point.getName());
  		pd.put("SUBJECT_ID", point.getSubjectCode());
  		try {
  			teachingmaterialService.save(pd);
  		} catch (Exception e) {
ce70231e   孙向锦   增加接口
2611
2612
2613
  			e.printStackTrace();
  		}
  	}
2ad7ca45   孙向锦   试卷bug修改
2614
2615
2616
2617
2618
2619
  
  	/**
  	 * 
  	 * @return
  	 * @throws Exception
  	 */
ce70231e   孙向锦   增加接口
2620
2621
2622
2623
2624
2625
2626
2627
2628
2629
  	@RequestMapping(value = "/uploadyuncelianquestion", produces = "application/json;charset=UTF-8")
  	@ResponseBody
  	public Object uploadyuncelianquestion() throws Exception {
  		event("uploadyuncelianquestion");
  		long cur = System.currentTimeMillis();
  		PageData pd = this.getPageData();
  		ResponseGson<Object> res = new ResponseGson();
  
  		if (!StringUtils.isEmpty(pd.getJsonString())) {
  			try {
2ad7ca45   孙向锦   试卷bug修改
2630
2631
  				ResponseGson<Object> req = ResponseGson.parse(pd
  						.getJsonString());
ce70231e   孙向锦   增加接口
2632
  				Object data = req.getData();
2ad7ca45   孙向锦   试卷bug修改
2633
2634
2635
2636
2637
2638
  				if (data instanceof List) {
  					List<Object> list = (List) data;
  					for (Object obj : list) {
  						if (obj instanceof Map) {
  							Map map = (Map) obj;
  
ce70231e   孙向锦   增加接口
2639
2640
2641
  							PageData pageData = new PageData();
  							pageData.put("QUESTION_ID", map.get("id"));
  							Object cateObj = map.get("cate");
2ad7ca45   孙向锦   试卷bug修改
2642
  							if (cateObj != null) {
ce70231e   孙向锦   增加接口
2643
2644
  								String cate = cateObj.toString();
  								float catef = Float.parseFloat(cate);
2ad7ca45   孙向锦   试卷bug修改
2645
  								pageData.put("QUESTION_TYPE_ID", (int) catef);
ce70231e   孙向锦   增加接口
2646
2647
  							}
  							Object contentObj = map.get("content");
2ad7ca45   孙向锦   试卷bug修改
2648
  							if (contentObj != null) {
ce70231e   孙向锦   增加接口
2649
2650
2651
2652
2653
  								String content = contentObj.toString();
  								content = replaceWebUrl(content);
  								pageData.put("CONTENT", content);
  							}
  							Object subjectCodeObj = map.get("subjectCode");
2ad7ca45   孙向锦   试卷bug修改
2654
  							if (subjectCodeObj != null) {
ce70231e   孙向锦   增加接口
2655
  								String subjectCode = subjectCodeObj.toString();
2ad7ca45   孙向锦   试卷bug修改
2656
  								pageData.put("SUBJECT_ID", subjectCode);
ce70231e   孙向锦   增加接口
2657
2658
  							}
  							Object optionsObj = map.get("options");
2ad7ca45   孙向锦   试卷bug修改
2659
2660
2661
2662
  							if (optionsObj instanceof List) {
  								List ss = (List) optionsObj;
  								pageData.put("OPTION_CONTENT",
  										optionsObj.toString());
ce70231e   孙向锦   增加接口
2663
2664
2665
  								pageData.put("OPTION_NUM", "" + ss.size());
  							}
  							Object answersObj = map.get("answers");
2ad7ca45   孙向锦   试卷bug修改
2666
2667
  							if (answersObj instanceof List) {
  								List answers = (List) answersObj;
ce70231e   孙向锦   增加接口
2668
  								StringBuilder sb = new StringBuilder();
2ad7ca45   孙向锦   试卷bug修改
2669
  								for (Object as : answers) {
ce70231e   孙向锦   增加接口
2670
2671
2672
2673
  									sb.append(as.toString());
  								}
  								pageData.put("ANSWER", sb.toString());
  							}
2ad7ca45   孙向锦   试卷bug修改
2674
2675
  							Object difficulty = map.get("difficulty");
  							try {
ce70231e   孙向锦   增加接口
2676
2677
2678
2679
2680
2681
  								if (difficulty != null) {
  									float fdifficulty = Float
  											.parseFloat(difficulty.toString());
  									pageData.put("DIFFICULTY",
  											(int) fdifficulty);
  								}
2ad7ca45   孙向锦   试卷bug修改
2682
  							} catch (Exception ex) {
ce70231e   孙向锦   增加接口
2683
2684
2685
  								ex.printStackTrace();
  							}
  							Object discussObj = map.get("discuss");
2ad7ca45   孙向锦   试卷bug修改
2686
  							if (discussObj != null) {
ce70231e   孙向锦   增加接口
2687
2688
2689
2690
2691
  								String discuss = discussObj.toString();
  								discuss = replaceWebUrl(discuss);
  								pageData.put("REMARK", discuss);
  							}
  							Object analyseObj = map.get("analyse");
2ad7ca45   孙向锦   试卷bug修改
2692
  							if (analyseObj != null) {
ce70231e   孙向锦   增加接口
2693
2694
2695
2696
2697
  								String analyse = analyseObj.toString();
  								analyse = replaceWebUrl(analyse);
  								pageData.put("ANALYSIS", analyse);
  							}
  							Object methodObj = map.get("method");
2ad7ca45   孙向锦   试卷bug修改
2698
  							if (methodObj != null) {
ce70231e   孙向锦   增加接口
2699
2700
2701
2702
2703
2704
  								String method = methodObj.toString();
  								method = replaceWebUrl(method);
  								pageData.put("METHOD", method);
  							}
  							Object points = map.get("points");
  							StringBuilder sb = new StringBuilder();
2ad7ca45   孙向锦   试卷bug修改
2705
2706
2707
2708
2709
  							if (points instanceof List) {
  								List pointsList = (List) points;
  								for (Object pObject : pointsList) {
  									if (pObject instanceof Map) {
  										Map pMap = (Map) pObject;
ce70231e   孙向锦   增加接口
2710
2711
2712
  										sb.append(pMap.get("code")).append(",");
  									}
  								}
2ad7ca45   孙向锦   试卷bug修改
2713
2714
  
  								if (sb.toString().length() > 1) {
ce70231e   孙向锦   增加接口
2715
2716
2717
2718
2719
  									sb.deleteCharAt(sb.length() - 1);
  								}
  								pageData.put("KNOWLEDGE_ID", sb.toString());
  							}
  							pageData.put("QUESTION_FROM", "101");
2ad7ca45   孙向锦   试卷bug修改
2720
  							try {
ce70231e   孙向锦   增加接口
2721
  								questionService.save(pageData);
2ad7ca45   孙向锦   试卷bug修改
2722
2723
  							} catch (Exception e) {
  								logger.error("save fail:" + map.get("id"), e);
ce70231e   孙向锦   增加接口
2724
2725
2726
2727
2728
2729
2730
2731
2732
  							}
  						}
  					}
  				}
  			} catch (Exception e) {
  				res.setError();
  			}
  		} else {
  			res.setDataError();
3371dbc6   孙向锦   0720 版本
2733
  		}
ce70231e   孙向锦   增加接口
2734
2735
2736
  		logger.info("uploadyuncelianquestion cost time : "
  				+ (System.currentTimeMillis() - cur));
  		return res.toJson();
3371dbc6   孙向锦   0720 版本
2737
  	}
ce70231e   孙向锦   增加接口
2738
  
2ad7ca45   孙向锦   试卷bug修改
2739
2740
2741
2742
2743
2744
2745
2746
2747
2748
  	/**
  	 * 
  	 * @param content
  	 * @return
  	 */
  	private String replaceWebUrl(String content) {
  		if (content != null) {
  			content = content.replaceAll(
  					"http://image.yuncelian.com/1/analysis/",
  					"http://image.yuncelian.com/1/analysis/");
ce70231e   孙向锦   增加接口
2749
2750
2751
  		}
  		return content;
  	}
2ad7ca45   孙向锦   试卷bug修改
2752
2753
2754
2755
2756
2757
2758
2759
2760
  
  	/**
  	 * 
  	 * @param pd
  	 * @param methodName
  	 * @return
  	 */
  	public String getRequestKey(PageData pd, String methodName) {
  		StringBuilder key = new StringBuilder();
ce70231e   孙向锦   增加接口
2761
2762
2763
2764
2765
2766
2767
2768
2769
2770
  		key.append(methodName).append("{");
  		if (pd != null) {
  			Iterator iterator = pd.keySet().iterator();
  			while (iterator.hasNext()) {
  				Object obj = iterator.next();
  				key.append(obj.toString()).append(":")
  						.append(pd.get(obj).toString()).append(";");
  			}
  		}
  		key.append("}");
2ad7ca45   孙向锦   试卷bug修改
2771
  
ce70231e   孙向锦   增加接口
2772
2773
  		return key.toString();
  	}
107fa3a0   孙向锦   修改试卷单选多远混合出题
2774
  
c617106f   孙向锦   添加即时测功能
2775
2776
  	/**
  	 * 根据ID,获取科目中文名称
107fa3a0   孙向锦   修改试卷单选多远混合出题
2777
  	 * 
c617106f   孙向锦   添加即时测功能
2778
2779
2780
2781
2782
2783
  	 * @param type
  	 * @return
  	 * @throws Exception
  	 */
  	@RequestMapping(value = "/subjectename", produces = "application/json;charset=UTF-8")
  	@ResponseBody
107fa3a0   孙向锦   修改试卷单选多远混合出题
2784
  	public String findSubjectEName() throws Exception {
c617106f   孙向锦   添加即时测功能
2785
2786
2787
  		PageData pageData = this.getPageData();
  		ResponseGson<String> res = new ResponseGson<String>();
  		pageData = subjectService.findById(pageData);
107fa3a0   孙向锦   修改试卷单选多远混合出题
2788
  		if (pageData != null) {
c617106f   孙向锦   添加即时测功能
2789
  			res.setData(pageData.getString("ENAME"));
107fa3a0   孙向锦   修改试卷单选多远混合出题
2790
  		} else {
c617106f   孙向锦   添加即时测功能
2791
2792
2793
2794
  			res.setDataError();
  		}
  		return res.toJson();
  	}
107fa3a0   孙向锦   修改试卷单选多远混合出题
2795
  
c617106f   孙向锦   添加即时测功能
2796
2797
  	/**
  	 * 根据ID或者科目英文名称
107fa3a0   孙向锦   修改试卷单选多远混合出题
2798
  	 * 
c617106f   孙向锦   添加即时测功能
2799
2800
2801
2802
2803
2804
  	 * @param type
  	 * @return
  	 * @throws Exception
  	 */
  	@RequestMapping(value = "/subjectcname", produces = "application/json;charset=UTF-8")
  	@ResponseBody
107fa3a0   孙向锦   修改试卷单选多远混合出题
2805
  	public String findSubjectCName() throws Exception {
c617106f   孙向锦   添加即时测功能
2806
2807
2808
  		ResponseGson<String> res = new ResponseGson<String>();
  		PageData pageData = new PageData();
  		StringBuilder sb = new StringBuilder();
107fa3a0   孙向锦   修改试卷单选多远混合出题
2809
2810
  		String type = this.getPageData().getString("ID");
  		if (type.contains(",")) {
c617106f   孙向锦   添加即时测功能
2811
2812
2813
2814
2815
2816
2817
2818
  			String[] types = type.split(",");
  			for (String t : types) {
  				pageData.put("ID", t);
  				pageData = subjectService.findById(pageData);
  				if (pageData != null) {
  					sb.append(pageData.getString("CNAME") + ";  ");
  				}
  			}
107fa3a0   孙向锦   修改试卷单选多远混合出题
2819
2820
  			sb.delete(sb.length() - 3, sb.length());
  		} else {
c617106f   孙向锦   添加即时测功能
2821
2822
2823
2824
2825
2826
2827
2828
2829
  			pageData.put("ID", type);
  			pageData = subjectService.findById(pageData);
  			if (pageData != null) {
  				sb.append(pageData.getString("CNAME"));
  			}
  		}
  		res.setData(sb.toString());
  		return res.toJson();
  	}
107fa3a0   孙向锦   修改试卷单选多远混合出题
2830
  
c617106f   孙向锦   添加即时测功能
2831
2832
  	/**
  	 * 根据ID班级名称
107fa3a0   孙向锦   修改试卷单选多远混合出题
2833
  	 * 
c617106f   孙向锦   添加即时测功能
2834
2835
2836
2837
2838
2839
  	 * @param id
  	 * @return
  	 * @throws Exception
  	 */
  	@RequestMapping(value = "/classname", produces = "application/json;charset=UTF-8")
  	@ResponseBody
107fa3a0   孙向锦   修改试卷单选多远混合出题
2840
  	public String findClassName() throws Exception {
c617106f   孙向锦   添加即时测功能
2841
2842
2843
  		ResponseGson<String> res = new ResponseGson<String>();
  		PageData pageData = this.getPageData();
  		pageData = sclassService.findById(pageData);
107fa3a0   孙向锦   修改试卷单选多远混合出题
2844
2845
  		String className = "";
  		if (pageData != null) {
c617106f   孙向锦   添加即时测功能
2846
  			className = pageData.getString("CLASS_NAME");
107fa3a0   孙向锦   修改试卷单选多远混合出题
2847
  		} else {
c617106f   孙向锦   添加即时测功能
2848
2849
2850
2851
  			res.setDataError();
  		}
  		res.setData(className);
  		return res.toJson();
107fa3a0   孙向锦   修改试卷单选多远混合出题
2852
  
c617106f   孙向锦   添加即时测功能
2853
  	}
694fbd54   孙向锦   添加作业管理模块
2854
2855
2856
2857
2858
2859
2860
2861
2862
2863
2864
2865
2866
  	
  	/**
  	 * 获取作业列表
  	 * 
  	 * @param id
  	 * @return
  	 * @throws Exception
  	 */
  	@RequestMapping(value = "/listhomework", produces = "application/json;charset=UTF-8")
  	@ResponseBody
  	public String listhomework() throws Exception {
  		ResponseGson<List<PageData>> res = new ResponseGson<List<PageData>>();
  		PageData pageData = this.getPageData();
a2414076   孙向锦   修改谢曲提交过来的bug
2867
2868
2869
  		if(pageData.get("COMPLETE_DATE") == null){
  			pageData.put("COMPLETE_DATE", pageData.get("COMPLETE"));
  		}
416902b7   孙向锦   添加课后作业部分API
2870
  		List<PageData> list = homeworkService.qlistAll(pageData);
694fbd54   孙向锦   添加作业管理模块
2871
2872
2873
2874
  		res.setData(list);
  		return res.toJson();
  		
  	}
416902b7   孙向锦   添加课后作业部分API
2875
2876
2877
2878
2879
2880
2881
2882
2883
2884
2885
2886
2887
  	
  	/**
  	 * 获取作业详情
  	 * 
  	 * @param id
  	 * @return
  	 * @throws Exception
  	 */
  	@RequestMapping(value = "/homework", produces = "application/json;charset=UTF-8")
  	@ResponseBody
  	public String homework() throws Exception {
  		ResponseGson<List<PageData>> res = new ResponseGson<List<PageData>>();
  		PageData pageData = this.getPageData();
5162dcee   孙向锦   添加上传作业接口
2888
  		pageData.put("CODE", pageData.get("HOMEWORK_ID"));
416902b7   孙向锦   添加课后作业部分API
2889
2890
2891
2892
2893
2894
2895
2896
2897
2898
2899
2900
2901
2902
2903
2904
2905
2906
2907
2908
2909
2910
2911
2912
2913
2914
2915
  		List<PageData> list = homeworkproblemService.listProblem(pageData);
  		for(PageData pd : list){
  			if(pd.get("P_HOMEWORK_PROBLEM_ID") != null){
  				List<PageData> childList = homeworkproblemService.listProblem(pd);
  				pd.put("PROBLEMS", childList);
  			}
  			
  		}
  		res.setData(list);
  		return res.toJson();
  		
  	}
  	
  	/**
  	 * 获取作业详情
  	 * 
  	 * @param id
  	 * @return
  	 * @throws Exception
  	 */
  	@RequestMapping(value = "/uploadhomework", produces = "application/json;charset=UTF-8")
  	@ResponseBody
  	public String uploadhomework() throws Exception {
  		ResponseGson<String> res = new ResponseGson<String>();
  		
  		PageData pd = this.getPageData();
  		if (!StringUtils.isEmpty(pd.getJsonString())) {
a479f295   孙向锦   添加了报表逻辑
2916
2917
2918
2919
2920
2921
2922
2923
  			ResultHomework resultHomework = ResultHomework.parse(pd.getJsonString());
  			PageData homePd = new PageData();
  			homePd.put("HOMEWORK_ID", resultHomework.getHOMEWORK_ID());
  			homePd.put("CLASS_ID", resultHomework.getCLASS_ID());
  			homePd.put("GET_SCORE", resultHomework.getGET_SCORE());
  			homePd.put("GET_SCORE_PERSENT", resultHomework.getGET_SCORE_PERSENT());
  			homePd.put("COMPLETE_DESC", resultHomework.getCOMPLETE_DESC());
  			homePd.put("GET_MAX_SCORE", resultHomework.getGET_MAX_SCORE());
f7e4dd61   孙向锦   根据客户UI的需求进行修改
2924
  			homePd.put("GET_MIN_SCORE", resultHomework.getGET_MIN_SCORE());
8dccad91   孙向锦   更新学生接口列表
2925
  			homePd.put("ANSWER_PERSENT", resultHomework.getANSWER_PERSENT());
27a15f6c   孙向锦   课后练bug修改
2926
  			homePd.put("COMPLETE_PERSENT", resultHomework.getCOMPLETE_PERSENT());
bd553929   孙向锦   修改接口
2927
  			homePd.put("COMPLETE_COUNT", "1");
a479f295   孙向锦   添加了报表逻辑
2928
2929
2930
2931
2932
2933
2934
  			homeworkService.edit(homePd);
  			List<PageData> list = homeworkReporkService.findByHomeworkID(homePd);
  			if(list == null || list.size() == 0){
  				// 初始化班級作业数据
  				// 1. 根据班级id 查询班级学生列表
  				List<PageData> student = studentService.findByClassId(homePd);
  				for(PageData ptd : student){
a764d288   孙向锦   修改课后练bug
2935
  					ptd.put("STUDENT_ID", ptd.get("ID"));
a479f295   孙向锦   添加了报表逻辑
2936
  					ptd.put("STUDENT_NAME", ptd.get("NAME"));
bd553929   孙向锦   修改接口
2937
  					ptd.put("HOMEWORK_REPORT_ID", this.get32UUID());
cc36e109   孙向锦   修复课后练bug
2938
  					ptd.put("STUDNET_NO", ptd.get("NUMBER"));
a479f295   孙向锦   添加了报表逻辑
2939
2940
2941
2942
2943
  					ptd.put("RANK", student.size() + "");
  					ptd.put("KEYBOARD", ptd.get("KEYPAD_ID"));
  					ptd.put("RIGHT_PERSENT", "0%");
  					ptd.put("GET_SCORE", "0");
  					ptd.put("ANSWER", "");
e7d09ea7   孙向锦   修改bug
2944
  					ptd.put("COMPLETE_COUNT", "0");
8dccad91   孙向锦   更新学生接口列表
2945
  					ptd.put("WHETHER", "0");
a479f295   孙向锦   添加了报表逻辑
2946
2947
2948
  					ptd.put("HOMEWORK_ID", resultHomework.getHOMEWORK_ID());
  				}
  				// 2. 根据学生列表生成初始化成绩
00af725f   孙向锦   修复bug
2949
2950
2951
  				if(student.size() > 0){
  					homeworkReporkService.batchSave(student);
  				}
a479f295   孙向锦   添加了报表逻辑
2952
2953
2954
2955
2956
2957
  			}
  			List<ResultStudent> students = resultHomework.getSTUDENTS();
  			for(ResultStudent student:students){
  				// update 学生作业情况
  				PageData tpd = new PageData();
  				tpd.put("STUDENT_NAME", student.getSTUDENT_NAME());
cc36e109   孙向锦   修复课后练bug
2958
  				tpd.put("STUDNET_NO", student.getSTUDENT_NO());
8dccad91   孙向锦   更新学生接口列表
2959
  				tpd.put("STUDENT_ID", student.getSTUDENT_ID());
a479f295   孙向锦   添加了报表逻辑
2960
2961
2962
2963
2964
  				tpd.put("RANK", student.getRANK());
  				tpd.put("KEYBOARD", student.getKEYBOARD());
  				tpd.put("RIGHT_PERSENT", student.getRIGHT_PERSENT());
  				tpd.put("GET_SCORE", student.getGET_SCORE());
  				tpd.put("ANSWER", student.getANSWER());
e7d09ea7   孙向锦   修改bug
2965
  				tpd.put("COMPLETE_COUNT", student.getCOMPLETE_COUNT());
a479f295   孙向锦   添加了报表逻辑
2966
  				tpd.put("HOMEWORK_ID", resultHomework.getHOMEWORK_ID());
a479f295   孙向锦   添加了报表逻辑
2967
2968
2969
2970
2971
2972
2973
2974
2975
2976
2977
2978
2979
2980
2981
2982
2983
2984
2985
2986
2987
2988
2989
2990
2991
2992
2993
2994
2995
2996
2997
2998
2999
3000
3001
3002
3003
3004
3005
3006
3007
3008
3009
3010
3011
3012
3013
3014
3015
3016
3017
  				homeworkReporkService.update(tpd);
  			}
  			res.setData(resultHomework.getHOMEWORK_ID());
  		}else{
  			res.setDataError();
  		}
  		
  		return res.toJson();
  		
  	}
  	
  	
  	/**
  	 * 更新学生详情
  	 * 
  	 * @param id
  	 * @return
  	 * @throws Exception
  	 */
  	@RequestMapping(value = "/uploadshomework", produces = "application/json;charset=UTF-8")
  	@ResponseBody
  	public String uploadshomework() throws Exception {
  		ResponseGson<String> res = new ResponseGson<String>();
  		
  		PageData pd = this.getPageData();
  		if (!StringUtils.isEmpty(pd.getJsonString())) {
  			ResultHomework resultHomework = ResultHomework.parse(pd.getJsonString());
  			PageData homePd = new PageData();
  			homePd.put("HOMEWORK_ID", resultHomework.getHOMEWORK_ID());
  			homePd.put("CLASS_ID", resultHomework.getCLASS_ID());
  			homePd.put("GET_SCORE", resultHomework.getGET_SCORE());
  			homePd.put("GET_SCORE_PERSENT", resultHomework.getGET_SCORE_PERSENT());
  			homePd.put("COMPLETE_DESC", resultHomework.getCOMPLETE_DESC());
  			homePd.put("GET_MAX_SCORE", resultHomework.getGET_MAX_SCORE());
  			homeworkService.edit(homePd);
  			List<PageData> list = homeworkReporkService.findByHomeworkID(homePd);
  			if(list == null || list.size() == 0){
  				// 初始化班級作业数据
  				// 1. 根据班级id 查询班级学生列表
  				List<PageData> student = studentService.findByClassId(homePd);
  				for(PageData ptd : student){
  					ptd.put("STUDENT_NAME", ptd.get("NAME"));
  					ptd.put("STUDENT_NO", ptd.get("SNO"));
  					ptd.put("RANK", student.size() + "");
  					ptd.put("KEYBOARD", ptd.get("KEYPAD_ID"));
  					ptd.put("RIGHT_PERSENT", "0%");
  					ptd.put("GET_SCORE", "0");
  					ptd.put("ANSWER", "");
  					ptd.put("HOMEWORK_ID", resultHomework.getHOMEWORK_ID());
  				}
  				// 2. 根据学生列表生成初始化成绩
1c817fc8   孙向锦   修改一些bug信息
3018
3019
3020
  				if(student != null && student.size() > 0){
  					homeworkReporkService.batchSave(student);
  				}
a479f295   孙向锦   添加了报表逻辑
3021
3022
3023
3024
3025
3026
3027
3028
3029
3030
3031
3032
3033
3034
3035
3036
3037
3038
  			}
  			List<ResultStudent> students = resultHomework.getSTUDENTS();
  			for(ResultStudent student:students){
  				// update 学生作业情况
  				PageData tpd = new PageData();
  				tpd.put("STUDENT_NAME", student.getSTUDENT_NAME());
  				tpd.put("STUDENT_NO", student.getSTUDENT_NO());
  				tpd.put("RANK", student.getRANK());
  				tpd.put("KEYBOARD", student.getKEYBOARD());
  				tpd.put("RIGHT_PERSENT", student.getRIGHT_PERSENT());
  				tpd.put("GET_SCORE", student.getGET_SCORE());
  				tpd.put("ANSWER", student.getANSWER());
  				tpd.put("HOMEWORK_ID", resultHomework.getHOMEWORK_ID());
  				homeworkReporkService.update(tpd);
  			}
  			res.setData(resultHomework.getHOMEWORK_ID());
  		}else{
  			res.setDataError();
416902b7   孙向锦   添加课后作业部分API
3039
  		}
a479f295   孙向锦   添加了报表逻辑
3040
  		
416902b7   孙向锦   添加课后作业部分API
3041
3042
3043
  		return res.toJson();
  		
  	}
107fa3a0   孙向锦   修改试卷单选多远混合出题
3044
  
757dfed6   孙向锦   样例报表
3045
3046
  	/**
  	 * 根据ID班级名称
107fa3a0   孙向锦   修改试卷单选多远混合出题
3047
  	 * 
757dfed6   孙向锦   样例报表
3048
3049
3050
3051
3052
3053
  	 * @param id
  	 * @return
  	 * @throws Exception
  	 */
  	@RequestMapping(value = "/qstudentinfo", produces = "application/json;charset=UTF-8")
  	@ResponseBody
107fa3a0   孙向锦   修改试卷单选多远混合出题
3054
  	public String qstudentinfo() throws Exception {
757dfed6   孙向锦   样例报表
3055
3056
3057
3058
3059
3060
  		ResponseGson<List<PageData>> res = new ResponseGson();
  		PageData pageData = this.getPageData();
  		if (pageData.containsKey("TEST_ID")
  				&& pageData.containsKey("QUESTION_ID")) {
  			List<PageData> list = v1Service.getQuestionWrongInfo(pageData);
  			res.setData(list);
107fa3a0   孙向锦   修改试卷单选多远混合出题
3061
  		} else {
757dfed6   孙向锦   样例报表
3062
3063
3064
  			res.setDataError();
  		}
  		return res.toJson();
107fa3a0   孙向锦   修改试卷单选多远混合出题
3065
  
bda221f4   孙向锦   0830版本
3066
  	}
107fa3a0   孙向锦   修改试卷单选多远混合出题
3067
  
bda221f4   孙向锦   0830版本
3068
3069
  	/**
  	 * 根据ID班级名称
107fa3a0   孙向锦   修改试卷单选多远混合出题
3070
  	 * 
bda221f4   孙向锦   0830版本
3071
3072
3073
3074
3075
3076
  	 * @param id
  	 * @return
  	 * @throws Exception
  	 */
  	@RequestMapping(value = "/wrongquestion", produces = "application/json;charset=UTF-8")
  	@ResponseBody
107fa3a0   孙向锦   修改试卷单选多远混合出题
3077
  	public String wrongquestion() throws Exception {
bda221f4   孙向锦   0830版本
3078
3079
3080
3081
3082
  		ResponseGson<List<PageData>> res = new ResponseGson();
  		PageData pageData = this.getPageData();
  		List<PageData> list = v1Service.getLastWrongQuestionInfo(pageData);
  		res.setData(list);
  		return res.toJson();
107fa3a0   孙向锦   修改试卷单选多远混合出题
3083
  
757dfed6   孙向锦   样例报表
3084
  	}
107fa3a0   孙向锦   修改试卷单选多远混合出题
3085
  
227dbfbb   孙向锦   添加知识点id
3086
3087
  	/**
  	 * 根据ID班级名称
107fa3a0   孙向锦   修改试卷单选多远混合出题
3088
  	 * 
227dbfbb   孙向锦   添加知识点id
3089
3090
3091
3092
3093
3094
  	 * @param id
  	 * @return
  	 * @throws Exception
  	 */
  	@RequestMapping(value = "/printmsg", produces = "application/json;charset=UTF-8")
  	@ResponseBody
107fa3a0   孙向锦   修改试卷单选多远混合出题
3095
  	public String printmsg() throws Exception {
227dbfbb   孙向锦   添加知识点id
3096
3097
3098
  		ResponseGson<Map> res = new ResponseGson();
  		res.setData(FileUploadProgressListener.map);
  		return res.toJson();
107fa3a0   孙向锦   修改试卷单选多远混合出题
3099
  
37b828b6   孙向锦   速度监测
3100
  	}
107fa3a0   孙向锦   修改试卷单选多远混合出题
3101
  
37b828b6   孙向锦   速度监测
3102
3103
  	/**
  	 * 根据ID班级名称
107fa3a0   孙向锦   修改试卷单选多远混合出题
3104
  	 * 
37b828b6   孙向锦   速度监测
3105
3106
3107
3108
3109
3110
  	 * @param id
  	 * @return
  	 * @throws Exception
  	 */
  	@RequestMapping(value = "/printresult", produces = "application/json;charset=UTF-8")
  	@ResponseBody
107fa3a0   孙向锦   修改试卷单选多远混合出题
3111
  	public String printresult() throws Exception {
37b828b6   孙向锦   速度监测
3112
3113
3114
  		ResponseGson<Map> res = new ResponseGson();
  		res.setData(FileUploadProgressListener.result);
  		return res.toJson();
107fa3a0   孙向锦   修改试卷单选多远混合出题
3115
  
227dbfbb   孙向锦   添加知识点id
3116
  	}
107fa3a0   孙向锦   修改试卷单选多远混合出题
3117
  
757dfed6   孙向锦   样例报表
3118
3119
  	@RequestMapping(value = "/uploadfile", produces = "application/json;charset=UTF-8")
  	@ResponseBody
107fa3a0   孙向锦   修改试卷单选多远混合出题
3120
3121
3122
  	public String uploadFile(
  			@RequestParam(value = "file", required = false) MultipartFile file,
  			HttpServletRequest request) throws Exception {
757dfed6   孙向锦   样例报表
3123
3124
3125
3126
  		ResponseGson<String> res = new ResponseGson<String>();
  		if (file != null) {
  			String path = request.getSession().getServletContext()
  					.getRealPath("/uploadFiles/uploadFile/");
107fa3a0   孙向锦   修改试卷单选多远混合出题
3127
3128
  			String name = System.currentTimeMillis()
  					+ file.getOriginalFilename();
757dfed6   孙向锦   样例报表
3129
3130
3131
  			File pathFile = new File(path);
  			pathFile.mkdirs();
  			File saveFile = new File(path + File.separator + name);
107fa3a0   孙向锦   修改试卷单选多远混合出题
3132
  			if (saveFile.exists()) {
757dfed6   孙向锦   样例报表
3133
3134
3135
3136
3137
  				saveFile.delete();
  			}
  			saveFile.createNewFile();
  			file.transferTo(saveFile);
  			path = request.getContextPath();
107fa3a0   孙向锦   修改试卷单选多远混合出题
3138
3139
3140
  			String basePath = request.getScheme() + "://"
  					+ request.getServerName() + ":" + request.getServerPort()
  					+ path + "/";
757dfed6   孙向锦   样例报表
3141
  			res.setData("/uploadFiles/uploadFile/" + name);
107fa3a0   孙向锦   修改试卷单选多远混合出题
3142
  		} else {
757dfed6   孙向锦   样例报表
3143
3144
3145
3146
  			res.setDataError();
  		}
  		return res.toJson();
  	}
107fa3a0   孙向锦   修改试卷单选多远混合出题
3147
3148
3149
3150
3151
3152
3153
3154
3155
3156
3157
3158
3159
3160
3161
3162
3163
3164
3165
3166
3167
3168
3169
3170
3171
3172
3173
3174
3175
3176
3177
3178
3179
3180
3181
3182
3183
3184
3185
3186
3187
3188
3189
3190
3191
3192
3193
3194
3195
3196
3197
3198
3199
3200
3201
3202
3203
3204
3205
3206
3207
3208
3209
3210
3211
3212
3213
3214
3215
3216
3217
3218
3219
3220
3221
3222
3223
3224
3225
3226
3227
3228
3229
3230
3231
3232
3233
3234
3235
3236
3237
3238
3239
3240
3241
3242
3243
3244
3245
3246
3247
3248
3249
3250
3251
3252
3253
3254
3255
3256
3257
3258
3259
3260
3261
3262
3263
3264
3265
3266
3267
3268
3269
3270
3271
3272
3273
3274
3275
3276
3277
3278
3279
3280
3281
3282
3283
3284
3285
3286
3287
3288
3289
3290
3291
3292
3293
3294
3295
3296
3297
3298
3299
3300
3301
3302
3303
3304
3305
3306
3307
3308
3309
3310
3311
3312
3313
3314
3315
3316
3317
3318
3319
3320
3321
3322
3323
3324
3325
3326
3327
3328
3329
3330
3331
3332
3333
3334
3335
3336
3337
3338
3339
3340
3341
3342
3343
3344
3345
3346
3347
3348
3349
3350
3351
3352
3353
3354
  
  	@RequestMapping(value = "/liuqin", produces = "application/json;charset=UTF-8")
  	@ResponseBody
  	public String dosunvotedata() /*throws Exception*/ {
  
  		PageData pd = new PageData();
  		pd.put("dbtype", "mysql");
  		pd.put("username", "root");
  		pd.put("password", "admin");
  		pd.put("dbAddress", "120.78.57.84");
  		pd.put("dbport", "3306");
  		pd.put("databaseName", "sunvote");
  		pd.put("dbport", "3306");
  		List<PageData> resultList = new ArrayList<PageData>();
  		
  		try {
  			Connection conn = DbFH.getFHCon(pd);
  
  			Statement stmt = conn.createStatement();
  			ResultSet rs = stmt
  					.executeQuery("select reportId,paperName,createTime,paperScore,classAverage,className from t_report where userId = '4000001' and className = 'G205' ");
  			while (rs.next()) {
  				PageData coloumData = new PageData();
  				String reportId = rs.getString("reportId");
  				coloumData.put("PAPER_ID", reportId);
  				coloumData.put("TESTPAPER_ID", reportId);
  				coloumData.put("NAME", rs.getString("paperName"));
  				coloumData.put("START_DATE", rs.getString("createTime"));
  				coloumData.put("END_DATE", rs.getString("createTime"));
  				coloumData.put("CREATE_DATE", rs.getString("createTime"));
  				coloumData.put("REMARK", rs.getString("paperScore"));
  				coloumData.put("TOTAL_SCORE", rs.getString("paperScore"));
  				coloumData.put("AVG_SCORE", rs.getString("classAverage"));
  				String className = rs.getString("className");
  				if ("G201".equals(className)) {
  					coloumData.put("SCLASS_ID",
  							"2af1ca03c40c4acab7b7d0f8243c9849");
  				}
  				if ("G202".equals(className)) {
  					coloumData.put("SCLASS_ID",
  							"49f1b14d10424bb6abc8aed56a4693cf");
  				}
  				if ("G203".equals(className)) {
  					coloumData.put("SCLASS_ID",
  							"80b5dde0138b405bb2bcfc5f33bad649");
  				}
  				if ("G204".equals(className)) {
  					coloumData.put("SCLASS_ID",
  							"f9de4a939ec54d7ba27d1248279a2f95");
  				}
  				if ("G205".equals(className)) {
  					coloumData.put("SCLASS_ID",
  							"0f10ce0a3bf146769213c49825c35feb");
  				}
  				if ("G206".equals(className)) {
  					coloumData.put("SCLASS_ID",
  							"d33edcd7a0f74ca9a0e92ebda9442869");
  				}
  				if ("G207".equals(className)) {
  					coloumData.put("SCLASS_ID",
  							"ffef54ef21c64525831f266b6fae34fc");
  				}
  				coloumData
  						.put("TEACHER_ID", "dbf8b49c641d47a8a811bb6d7480be72");
  				coloumData.put("TEST_TYPE", "1");
  
  				List<PageData> detailList = new ArrayList<PageData>();
  
  				Statement stmt1 = conn.createStatement();
  				ResultSet rs1 = stmt1
  						.executeQuery("select studentName,answerStr,score,totalScore from t_reportdetail where reportId = '"
  								+ reportId + "'");
  				while (rs1.next()) {
  					PageData detailPd = new PageData();
  					detailPd.put("NAME", rs1.getString("studentName"));
  					detailPd.put("answerStr", rs1.getString("answerStr"));
  					detailPd.put("SCORE", rs1.getString("totalScore"));
  					detailPd.put("totalScore",  rs.getString("paperScore"));
  					detailList.add(detailPd);
  				}
  				rs1.close();
  				stmt1.close();
  				stmt1 = null;
  				coloumData.put("STUDENT", detailList);
  
  				resultList.add(coloumData);
  			}
  			rs.close();
  			stmt.close();
  			conn.close();
  		}catch(Exception e){
  			e.printStackTrace();
  		}
  		for (PageData paper : resultList) {
  			PageData testPd = new PageData();
  			testPd.put("TESTPAPER_ID", paper.get("TESTPAPER_ID"));
  			testPd.put("PAPER_ID", paper.get("PAPER_ID"));
  			List<PageData> listData = null;
  			try {
  				listData = testpaperService.listAll(testPd);
  			} catch (Exception e) {
  				e.printStackTrace();
  			}
  			if ((listData != null && listData.size() > 0)) {
  				String testPaperId = listData.get(0).getString("TESTPAPER_ID");
  				try {
  					testpaperService.deleteList(testPd);
  				} catch (Exception e) {
  					e.printStackTrace();
  				}
  				testPd.put("TEST_ID", testPaperId);
  				try {
  					testpaperinfoService.delete(testPd);
  				} catch (Exception e) {
  					e.printStackTrace();
  				}
  				try {
  					studenttestService.delete(testPd);
  				} catch (Exception e) {
  					e.printStackTrace();
  				}
  				listData.clear();
  			}
  			if (!(listData != null && listData.size() > 0)) {
  				logger.info(paper);
  				try {
  					testpaperService.save(paper);
  				} catch (Exception e) {
  					e.printStackTrace();
  				}
  				logger.info("添加测试名称成功:" +  paper.get("TESTPAPER_ID"));
  				List<PageData> detailList = (List<PageData>) paper.get("STUDENT");
  				int i = 0;
  				List<PageData> testInfoPdList = new ArrayList();
  				for (PageData student : detailList) {
  					i++;
  					PageData studentDetail = null;
  					try {
  						studentDetail = studentService.findByName(student);
  					} catch (Exception e) {
  						e.printStackTrace();
  					}
  					PageData studentPageData = new PageData();
  					studentPageData.put("STUDENTTEST_ID", get32UUID());
  					studentPageData.put("STUDENT_ID", studentDetail.get("ID"));
  					studentPageData.put("TEST_ID", paper.get("TESTPAPER_ID"));
  					studentPageData.put("PAPER_ID", paper.get("TESTPAPER_ID"));
  					studentPageData.put("SCORE", student.get("SCORE"));
  					studentPageData.put("CLASS_ID", paper.get("SCLASS_ID"));
  					logger.info("学生测试数据");
  					logger.info(studentPageData);
  					try {
  						studenttestService.save(studentPageData);
  					} catch (Exception e) {
  						e.printStackTrace();
  					}
  					logger.info("添加学生测试成功:" +  studentDetail.get("NAME"));
  
  					String answerStr = student.getString("answerStr");
  					String[] answerStrs = answerStr.split(";");
  					int j = 0;
  					for (String answers : answerStrs) {
  						j++;
  						PageData testInfoPd = new PageData();
  						testInfoPd.put("TESTPAPERINFO_ID", this.get32UUID());
  						testInfoPd.put("PAPER_ID", paper.get("TESTPAPER_ID"));
  						testInfoPd.put("STUDENT_ID", studentDetail.get("ID"));
  						testInfoPd.put("TEST_ID", paper.get("TESTPAPER_ID"));
  						testInfoPd.put("QUESTION_ID", paper.get("TESTPAPER_ID") + "" + i);
  						String[] ans = answers.split(",");
  						testInfoPd.put("ANSWER", ans[0]);
  						testInfoPd.put("RIGHT", ans[1]);
  						testInfoPd.put("SCORE", "");
  						testInfoPd.put("LIKES", "");
  						testInfoPd.put("ANSWER_TYPE", "1");
  						testInfoPd.put("PRESS_TIME", "");
  						testInfoPd.put("RECEIVER_DATE", "");
  						testInfoPd.put("SUBJECTIVE", "");
  						testInfoPd.put("MARK_NO", "" + j);
  						testInfoPd.put("RANDOM", "" + j);
  						testInfoPd.put("RANK", "" + j);
  						try {
  							logger.info("学生详细测试数据");
  							logger.info(testInfoPd);
  							testpaperinfoService.save(testInfoPd);
  							logger.info("添加学生详细情况成功:");
  						} catch (Exception e) {
  							// TODO Auto-generated catch block
  							e.printStackTrace();
  						}
  //						testInfoPdList.add(testInfoPd);
  					}
  //					logger.info("学生详细测试数据");
  //					logger.info(testInfoPdList);
  					try {
  //						testpaperinfoService.batchSave(testInfoPdList);
  					} catch (Exception e) {
  						e.printStackTrace();
  					}
  //					logger.info("添加学生详细情况成功:");
  				}
  			}
  		}
  		
  		ResponseGson<String> res = new ResponseGson<String>();
  		return res.toJson();
  	}
  
bed6e1fc   孙向锦   添加其他功能
3355
  }