Blame view

src/com/fh/controller/api/V1.java 106 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
  			PageData p = teacherService.findById2(pd.get("USER_ID").toString());
  			if(p != null){
  				pd.put("SCHOOL_ID", p.get("SCHOOL_ID"));
f4a73594   jack   1.增加班级统计报表和导出
554
  				//pd.remove("USER_ID");
d7525cae   jack   1.学生老师导入导出
555
556
557
  			}else{
  				pd.put("SCHOOL_ID", "");
  			}
f4a73594   jack   1.增加班级统计报表和导出
558
559
560
  			if(pd.getString("PAPER_TYPE").equals("2")){
  				pd.remove("USER_ID");
  			}
757dfed6   孙向锦   样例报表
561
  			List<PageData> pageList = paperService.listAllByType(pd);
bed6e1fc   孙向锦   添加其他功能
562
  			res.setData(pageList);
91a745c9   孙向锦   完善后台功能
563
  		} else {
757dfed6   孙向锦   样例报表
564
  			res.setDataError();
bed6e1fc   孙向锦   添加其他功能
565
  		}
2480c889   孙向锦   添加软件管理模块。对软件形成统一的管理
566
  		logger.info("paper cost time : " + (System.currentTimeMillis() - cur));
bed6e1fc   孙向锦   添加其他功能
567
568
  		return res.toJson();
  	}
91a745c9   孙向锦   完善后台功能
569
  
2ad7ca45   孙向锦   试卷bug修改
570
571
  	/**
  	 * 试卷详细信息
107fa3a0   孙向锦   修改试卷单选多远混合出题
572
  	 * 
2ad7ca45   孙向锦   试卷bug修改
573
574
575
  	 * @return
  	 * @throws Exception
  	 */
91a745c9   孙向锦   完善后台功能
576
  	@RequestMapping(value = "/paperinfo", produces = "application/json;charset=UTF-8")
bed6e1fc   孙向锦   添加其他功能
577
  	@ResponseBody
91a745c9   孙向锦   完善后台功能
578
  	public Object paperInfo() throws Exception {
3371dbc6   孙向锦   0720 版本
579
  		event("paperInfo");
2480c889   孙向锦   添加软件管理模块。对软件形成统一的管理
580
  		long cur = System.currentTimeMillis();
bed6e1fc   孙向锦   添加其他功能
581
  		PageData pd = this.getPageData();
757dfed6   孙向锦   样例报表
582
583
584
585
586
587
588
589
590
591
592
593
594
595
  		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   孙向锦   管理员界面
596
  						paper.setSchool_id(ppd.getString("SCHOOL_ID"));
757dfed6   孙向锦   样例报表
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
  						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
612
613
614
  							String ttcontent = qpd.getString("CONTENT");
  							ttcontent = ttcontent.replaceAll("<fill></fill>", "______");
  							question.setContent(ttcontent);
757dfed6   孙向锦   样例报表
615
616
617
618
619
620
621
622
623
624
625
626
627
  							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版本
628
  							question.setQuestions(new ArrayList<Question>());
757dfed6   孙向锦   样例报表
629
630
631
  							if ("-1".equals("" + qpd.getString("P_ID"))) {
  								PageData pidPd = new PageData();
  								pidPd.put("PID", question.getQuestion_id());
757dfed6   孙向锦   样例报表
632
633
634
635
636
637
638
639
640
641
642
643
644
  								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
645
  									qq.setContent(q.getString("CONTENT").replaceAll("<fill></fill>", "______"));
757dfed6   孙向锦   样例报表
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
683
684
685
  									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   孙向锦   修改试卷单选多远混合出题
686
687
  
  	/*	*//**
757dfed6   孙向锦   样例报表
688
  	 * 试卷详细信息
107fa3a0   孙向锦   修改试卷单选多远混合出题
689
  	 * 
757dfed6   孙向锦   样例报表
690
691
  	 * @return
  	 * @throws Exception
107fa3a0   孙向锦   修改试卷单选多远混合出题
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
737
738
739
  	 */
  	/*
  	 * @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   孙向锦   样例报表
740
  	 * 试卷详细信息
107fa3a0   孙向锦   修改试卷单选多远混合出题
741
  	 * 
757dfed6   孙向锦   样例报表
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
  	 * @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   孙向锦   修改试卷单选多远混合出题
761
  
757dfed6   孙向锦   样例报表
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
  							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   孙向锦   修改试卷单选多远混合出题
789
  												.split(",");
757dfed6   孙向锦   样例报表
790
791
792
793
794
795
796
797
  										pcd.put("OPTION_CONTENT", options);
  									} else {
  										pcd.put("OPTION_CONTENT",
  												new String[] { optionContent1 });
  									}
  								}
  								qpd.put("QUESTIONS", qs);
  							}
107fa3a0   孙向锦   修改试卷单选多远混合出题
798
  
757dfed6   孙向锦   样例报表
799
800
801
  						}
  						res.setData(ppd);
  						logger.info(res.toJson());
107fa3a0   孙向锦   修改试卷单选多远混合出题
802
  
338594c8   孙向锦   添加教师端页面
803
  					}
91a745c9   孙向锦   完善后台功能
804
805
  				} catch (Exception ex) {
  					ex.printStackTrace();
338594c8   孙向锦   添加教师端页面
806
  				}
91a745c9   孙向锦   完善后台功能
807
  			} catch (Exception ex) {
338594c8   孙向锦   添加教师端页面
808
809
  				ex.printStackTrace();
  				res.setError();
bed6e1fc   孙向锦   添加其他功能
810
  			}
91a745c9   孙向锦   完善后台功能
811
  		} else {
bed6e1fc   孙向锦   添加其他功能
812
813
  			res.setOtherError();
  		}
ce70231e   孙向锦   增加接口
814
815
  		logger.info("paperInfo cost time : "
  				+ (System.currentTimeMillis() - cur));
bed6e1fc   孙向锦   添加其他功能
816
817
  		return res.toJson();
  	}
4b6a5239   孙向锦   管理员界面
818
  	
107fa3a0   孙向锦   修改试卷单选多远混合出题
819
  
c617106f   孙向锦   添加即时测功能
820
821
  	/**
  	 * 试卷详细信息
107fa3a0   孙向锦   修改试卷单选多远混合出题
822
  	 * 
c617106f   孙向锦   添加即时测功能
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
  	 * @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   孙向锦   修改试卷单选多远混合出题
842
843
844
  					List<PageData> list = testpaperinfoService
  							.listTestPaperQuestionIDs(testInfof);
  					for (PageData pqd : list) {
c617106f   孙向锦   添加即时测功能
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
  						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   孙向锦   修改试卷单选多远混合出题
860
861
  						List<PageData> listinfo = testpaperinfoService
  								.listTestPaperQuestionIDinfo(pqd);
c617106f   孙向锦   添加即时测功能
862
  						List<PageData> answerInfos = new ArrayList<PageData>();
757dfed6   孙向锦   样例报表
863
  						List<String> answerList = new ArrayList<String>();
107fa3a0   孙向锦   修改试卷单选多远混合出题
864
  						for (PageData pid : listinfo) {
c617106f   孙向锦   添加即时测功能
865
866
  							String answer = pid.getString("ANSWER");
  							PageData answerPd = null;
107fa3a0   孙向锦   修改试卷单选多远混合出题
867
868
869
870
871
  							if (answerInfos.size() > 0) {
  								answerPd = answerInfos
  										.get(answerInfos.size() - 1);
  								if (!answer
  										.equals(answerPd.getString("ANSWER"))) {
c617106f   孙向锦   添加即时测功能
872
873
  									answerPd = new PageData();
  									answerPd.put("ANSWER", answer);
107fa3a0   孙向锦   修改试卷单选多远混合出题
874
875
  									answerPd.put("ISRIGHT",
  											pid.getString("RIGHT"));
c617106f   孙向锦   添加即时测功能
876
  									answerInfos.add(answerPd);
757dfed6   孙向锦   样例报表
877
  									answerList.add(answer);
c617106f   孙向锦   添加即时测功能
878
  								}
107fa3a0   孙向锦   修改试卷单选多远混合出题
879
  							} else {
c617106f   孙向锦   添加即时测功能
880
881
882
883
  								answerPd = new PageData();
  								answerPd.put("ANSWER", answer);
  								answerPd.put("ISRIGHT", pid.getString("RIGHT"));
  								answerInfos.add(answerPd);
757dfed6   孙向锦   样例报表
884
  								answerList.add(answer);
c617106f   孙向锦   添加即时测功能
885
886
  							}
  							String strCount = answerPd.getString("COUNT");
107fa3a0   孙向锦   修改试卷单选多远混合出题
887
888
889
890
891
892
  							int count = 0;
  							if (strCount != null) {
  								try {
  									count = Integer.parseInt(strCount);
  								} catch (NumberFormatException ex) {
  								}
c617106f   孙向锦   添加即时测功能
893
  							}
107fa3a0   孙向锦   修改试卷单选多远混合出题
894
  							count++;
c617106f   孙向锦   添加即时测功能
895
896
  							answerPd.put("COUNT", count);
  						}
757dfed6   孙向锦   样例报表
897
898
  						String questionNumStr = pqd.getString("OPTION_NUM");
  						int questionNum = Integer.parseInt(questionNumStr);
107fa3a0   孙向锦   修改试卷单选多远混合出题
899
900
901
902
  						for (int i = 0; i < questionNum; i++) {
  							if ((!answerList.contains("" + (char) ('A' + i)))
  									&& !(answerList.contains(""
  											+ (char) ('a' + i)))) {
757dfed6   孙向锦   样例报表
903
  								PageData answerPd = new PageData();
107fa3a0   孙向锦   修改试卷单选多远混合出题
904
905
906
  								answerPd.put("ANSWER", "" + (char) ('A' + i));
  								answerPd.put("ISRIGHT", pqd.get("ANSWER")
  										.equals(('A' + i)) ? "1" : "0");
757dfed6   孙向锦   样例报表
907
908
909
910
  								answerPd.put("COUNT", 0);
  								answerInfos.add(answerPd);
  							}
  						}
107fa3a0   孙向锦   修改试卷单选多远混合出题
911
912
913
914
915
916
917
918
919
  						Collections.sort(answerInfos,
  								new Comparator<PageData>() {
  
  									@Override
  									public int compare(PageData p1, PageData p2) {
  										return p1.getString("ANSWER")
  												.compareToIgnoreCase(
  														p2.getString("ANSWER"));
  									}
757dfed6   孙向锦   样例报表
920
  
107fa3a0   孙向锦   修改试卷单选多远混合出题
921
  								});
c617106f   孙向锦   添加即时测功能
922
923
924
  						pqd.put("ANSWERINFO", answerInfos);
  						pqd.remove("TEST_ID");
  					}
107fa3a0   孙向锦   修改试卷单选多远混合出题
925
  					for (PageData pad : list) {
757dfed6   孙向锦   样例报表
926
  						String optionContent = pad.getString("OPTION_CONTENT");
107fa3a0   孙向锦   修改试卷单选多远混合出题
927
928
929
930
931
  						if (optionContent != null
  								&& optionContent.startsWith("[")
  								&& optionContent.endsWith("]")) {
  							String[] options = optionContent.substring(1,
  									optionContent.length() - 1).split(",");
757dfed6   孙向锦   样例报表
932
  							pad.put("OPTION_CONTENT", options);
107fa3a0   孙向锦   修改试卷单选多远混合出题
933
934
935
  						} else {
  							pad.put("OPTION_CONTENT",
  									new String[] { optionContent });
757dfed6   孙向锦   样例报表
936
937
  						}
  					}
c617106f   孙向锦   添加即时测功能
938
  					testPd.put("QUESTIONS", list);
107fa3a0   孙向锦   修改试卷单选多远混合出题
939
  
c617106f   孙向锦   添加即时测功能
940
941
942
943
944
945
946
947
948
949
950
951
  				}
  
  				res.setData(testPd);
  			} catch (Exception e) {
  				e.printStackTrace();
  				res.setError();
  			}
  		}
  		logger.info("testpaperinfo cost time:"
  				+ (System.currentTimeMillis() - cur));
  		return res.toJson();
  	}
107fa3a0   孙向锦   修改试卷单选多远混合出题
952
  
c617106f   孙向锦   添加即时测功能
953
954
  	/**
  	 * 试卷详细信息
107fa3a0   孙向锦   修改试卷单选多远混合出题
955
  	 * 
c617106f   孙向锦   添加即时测功能
956
957
958
959
960
961
  	 * @return
  	 * @throws Exception
  	 */
  	@RequestMapping(value = "/questionintestreportinfo", produces = "application/json;charset=UTF-8")
  	@ResponseBody
  	public Object questionInTestReportInfo() throws Exception {
757dfed6   孙向锦   样例报表
962
  		event("questionInTestReportInfo");
c617106f   孙向锦   添加即时测功能
963
964
965
966
967
968
969
970
  		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   孙向锦   样例报表
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
1009
1010
1011
  			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   孙向锦   添加即时测功能
1012
1013
1014
1015
1016
  						answerPd = new PageData();
  						answerPd.put("ANSWER", answer);
  						answerPd.put("ISRIGHT", pid.getString("RIGHT"));
  						answerInfos.add(answerPd);
  					}
757dfed6   孙向锦   样例报表
1017
1018
1019
1020
1021
1022
1023
  					String strCount = answerPd.getString("COUNT");
  					int count = 0;
  					if (strCount != null) {
  						try {
  							count = Integer.parseInt(strCount);
  						} catch (NumberFormatException ex) {
  						}
c617106f   孙向锦   添加即时测功能
1024
  					}
757dfed6   孙向锦   样例报表
1025
1026
  					count++;
  					answerPd.put("COUNT", count);
c617106f   孙向锦   添加即时测功能
1027
  				}
757dfed6   孙向锦   样例报表
1028
1029
  				pqd.put("ANSWERINFO", answerInfos);
  				res.setData(pqd);
107fa3a0   孙向锦   修改试卷单选多远混合出题
1030
  			} else {
757dfed6   孙向锦   样例报表
1031
  				res.setDataError();
c617106f   孙向锦   添加即时测功能
1032
  			}
107fa3a0   孙向锦   修改试卷单选多远混合出题
1033
  		} else {
c617106f   孙向锦   添加即时测功能
1034
1035
  			res.setDataError();
  		}
757dfed6   孙向锦   样例报表
1036
  		logger.info("questionInTestReportInfo cost time:"
c617106f   孙向锦   添加即时测功能
1037
1038
1039
  				+ (System.currentTimeMillis() - cur));
  		return res.toJson();
  	}
91a745c9   孙向锦   完善后台功能
1040
  
2ad7ca45   孙向锦   试卷bug修改
1041
1042
  	/**
  	 * 试卷简要信息
107fa3a0   孙向锦   修改试卷单选多远混合出题
1043
  	 * 
2ad7ca45   孙向锦   试卷bug修改
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
1105
1106
1107
  	 * @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   孙向锦   样例报表
1108
  		logger.info("paperBriefInfo cost time : "
2ad7ca45   孙向锦   试卷bug修改
1109
1110
1111
1112
  				+ (System.currentTimeMillis() - cur));
  		return res.toBrifJson();
  	}
  
2ad7ca45   孙向锦   试卷bug修改
1113
1114
  	/**
  	 * 试卷问题
107fa3a0   孙向锦   修改试卷单选多远混合出题
1115
  	 * 
2ad7ca45   孙向锦   试卷bug修改
1116
1117
1118
  	 * @return
  	 * @throws Exception
  	 */
bed6e1fc   孙向锦   添加其他功能
1119
1120
1121
  	@RequestMapping(value = "/paperquestion", produces = "application/json;charset=UTF-8")
  	@ResponseBody
  	public Object paperQuestion() throws Exception {
3371dbc6   孙向锦   0720 版本
1122
  		event("paperQuestion");
2480c889   孙向锦   添加软件管理模块。对软件形成统一的管理
1123
  		long cur = System.currentTimeMillis();
bed6e1fc   孙向锦   添加其他功能
1124
1125
  		PageData pd = this.getPageData();
  		ResponseGson<PageData> res = new ResponseGson();
ce70231e   孙向锦   增加接口
1126
1127
  		logger.info("paperquestion cost time : "
  				+ (System.currentTimeMillis() - cur));
bed6e1fc   孙向锦   添加其他功能
1128
1129
  		return res.toJson();
  	}
ce70231e   孙向锦   增加接口
1130
  
2ad7ca45   孙向锦   试卷bug修改
1131
1132
  	/**
  	 * 问题
107fa3a0   孙向锦   修改试卷单选多远混合出题
1133
  	 * 
2ad7ca45   孙向锦   试卷bug修改
1134
1135
1136
  	 * @return
  	 * @throws Exception
  	 */
4fd2e08c   孙向锦   修复接口中的bug
1137
1138
1139
  	@RequestMapping(value = "/question", produces = "application/json;charset=UTF-8")
  	@ResponseBody
  	public Object question() throws Exception {
3371dbc6   孙向锦   0720 版本
1140
  		event("question");
2480c889   孙向锦   添加软件管理模块。对软件形成统一的管理
1141
  		long cur = System.currentTimeMillis();
4fd2e08c   孙向锦   修复接口中的bug
1142
  		PageData pd = this.getPageData();
2ad7ca45   孙向锦   试卷bug修改
1143
1144
  		ResponseGson<List<PageData>> res = new ResponseGson();
  		List<PageData> list = new ArrayList<PageData>();
ce70231e   孙向锦   增加接口
1145
  		if (pd.containsKey("ID")) {
2ad7ca45   孙向锦   试卷bug修改
1146
1147
1148
1149
1150
  			String ids = pd.getString("ID");
  			String[] id = ids.split(",");
  			for (String i : id) {
  				pd.put("QUESTION_ID", i);
  				PageData data = questionService.findById(pd);
c617106f   孙向锦   添加即时测功能
1151
  				String optionContent = data.getString("OPTION_CONTENT");
107fa3a0   孙向锦   修改试卷单选多远混合出题
1152
1153
1154
1155
  				if (optionContent != null && optionContent.startsWith("[")
  						&& optionContent.endsWith("]")) {
  					String[] options = optionContent.substring(1,
  							optionContent.length() - 1).split(",");
c617106f   孙向锦   添加即时测功能
1156
  					data.put("OPTION_CONTENT", options);
107fa3a0   孙向锦   修改试卷单选多远混合出题
1157
1158
  				} else {
  					data.put("OPTION_CONTENT", new String[] { optionContent });
c617106f   孙向锦   添加即时测功能
1159
  				}
2ad7ca45   孙向锦   试卷bug修改
1160
1161
1162
1163
1164
  				if (data != null) {
  					list.add(data);
  				}
  			}
  			res.setData(list);
ce70231e   孙向锦   增加接口
1165
  		} else {
4fd2e08c   孙向锦   修复接口中的bug
1166
1167
  			res.setDataError();
  		}
ce70231e   孙向锦   增加接口
1168
1169
  		logger.info("question cost time : "
  				+ (System.currentTimeMillis() - cur));
4fd2e08c   孙向锦   修复接口中的bug
1170
1171
  		return res.toJson();
  	}
ce70231e   孙向锦   增加接口
1172
  
2ad7ca45   孙向锦   试卷bug修改
1173
1174
  	/**
  	 * 查询知识点名称
107fa3a0   孙向锦   修改试卷单选多远混合出题
1175
  	 * 
2ad7ca45   孙向锦   试卷bug修改
1176
1177
1178
1179
1180
1181
  	 * @return
  	 * @throws Exception
  	 */
  	@RequestMapping(value = "/knowledgename", produces = "application/json;charset=UTF-8")
  	@ResponseBody
  	public Object knowledgename() throws Exception {
757dfed6   孙向锦   样例报表
1182
  		event("knowledgename");
2ad7ca45   孙向锦   试卷bug修改
1183
1184
1185
1186
1187
1188
1189
1190
1191
1192
1193
1194
1195
1196
1197
1198
1199
1200
1201
1202
1203
1204
1205
1206
  		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   孙向锦   修改试卷单选多远混合出题
1207
  	 * 
2ad7ca45   孙向锦   试卷bug修改
1208
1209
1210
1211
1212
1213
  	 * @return
  	 * @throws Exception
  	 */
  	@RequestMapping(value = "/chaptername", produces = "application/json;charset=UTF-8")
  	@ResponseBody
  	public Object chaptername() throws Exception {
757dfed6   孙向锦   样例报表
1214
  		event("chaptername");
2ad7ca45   孙向锦   试卷bug修改
1215
1216
1217
1218
1219
1220
1221
1222
1223
1224
1225
1226
1227
1228
1229
1230
1231
1232
1233
1234
1235
1236
1237
1238
  		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   孙向锦   修改试卷单选多远混合出题
1239
  	 * 
2ad7ca45   孙向锦   试卷bug修改
1240
1241
1242
  	 * @return
  	 * @throws Exception
  	 */
4fd2e08c   孙向锦   修复接口中的bug
1243
1244
1245
  	@RequestMapping(value = "/question/add", produces = "application/json;charset=UTF-8")
  	@ResponseBody
  	public Object questionAdd() throws Exception {
3371dbc6   孙向锦   0720 版本
1246
  		event("questionAdd");
2480c889   孙向锦   添加软件管理模块。对软件形成统一的管理
1247
  		long cur = System.currentTimeMillis();
4fd2e08c   孙向锦   修复接口中的bug
1248
1249
1250
1251
  		PageData pd = this.getPageData();
  		ResponseGson<PageData> res = new ResponseGson();
  		pd.put("QUESTION_ID", this.get32UUID());
  		questionService.save(pd);
ce70231e   孙向锦   增加接口
1252
1253
  		logger.info("questionAdd cost time : "
  				+ (System.currentTimeMillis() - cur));
4fd2e08c   孙向锦   修复接口中的bug
1254
1255
  		return res.toJson();
  	}
ce70231e   孙向锦   增加接口
1256
  
2ad7ca45   孙向锦   试卷bug修改
1257
1258
  	/***
  	 * 上传试卷
107fa3a0   孙向锦   修改试卷单选多远混合出题
1259
  	 * 
2ad7ca45   孙向锦   试卷bug修改
1260
1261
1262
  	 * @return
  	 * @throws Exception
  	 */
338594c8   孙向锦   添加教师端页面
1263
1264
1265
  	@RequestMapping(value = "/uploadpaper", produces = "application/json;charset=UTF-8")
  	@ResponseBody
  	public Object uploadpaper() throws Exception {
3371dbc6   孙向锦   0720 版本
1266
  		event("uploadpaper");
2480c889   孙向锦   添加软件管理模块。对软件形成统一的管理
1267
  		long cur = System.currentTimeMillis();
338594c8   孙向锦   添加教师端页面
1268
1269
  		PageData pd = this.getPageData();
  		ResponseGson<String> res = new ResponseGson();
91a745c9   孙向锦   完善后台功能
1270
1271
  
  		if (!StringUtils.isEmpty(pd.getJsonString())) {
4fd2e08c   孙向锦   修复接口中的bug
1272
  			logger.info(pd.getJsonString());
338594c8   孙向锦   添加教师端页面
1273
1274
1275
1276
  			Paper paper = Paper.parse(pd.getJsonString());
  			PageData paperPd = new PageData();
  			String paperID = this.get32UUID();
  			res.setData(paperID);
91a745c9   孙向锦   完善后台功能
1277
1278
1279
1280
1281
1282
1283
1284
1285
1286
  			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   孙向锦   添加教师端页面
1287
  			String schoolID = Myelfun.getUserID(paper.getUser_id());
4b6a5239   孙向锦   管理员界面
1288
  			paperPd.put("SCHOOL_ID", paper.getSchool_id() == null ? schoolID:paper.getSchool_id());
91a745c9   孙向锦   完善后台功能
1289
1290
1291
  			paperPd.put("CREATE_DATE", Tools.date2Str(new Date()));
  			paperPd.put("MODIFY_DATE", Tools.date2Str(new Date()));
  
ce70231e   孙向锦   增加接口
1292
  			int questionNum = 0;
91a745c9   孙向锦   完善后台功能
1293
  
338594c8   孙向锦   添加教师端页面
1294
  			List<Question> questions = paper.getQuestions();
91a745c9   孙向锦   完善后台功能
1295
1296
  			if (questions != null) {
  				for (Question question : questions) {
338594c8   孙向锦   添加教师端页面
1297
1298
1299
  					String questionID = this.get32UUID();
  					PageData qPd = new PageData();
  					qPd.put("QUESTION_ID", questionID);
91a745c9   孙向锦   完善后台功能
1300
1301
  					if (question.getQuestions() != null
  							&& question.getQuestions().size() > 0) {
338594c8   孙向锦   添加教师端页面
1302
  						qPd.put("P_ID", "-1");
91a745c9   孙向锦   完善后台功能
1303
  					} else {
ce70231e   孙向锦   增加接口
1304
  						questionNum++;
338594c8   孙向锦   添加教师端页面
1305
1306
1307
1308
  						qPd.put("P_ID", "0");
  					}
  					qPd.put("SUBJECT_ID", paper.getSubject_id());
  					qPd.put("CHAPTER_ID", question.getChapter_id());
ce70231e   孙向锦   增加接口
1309
1310
1311
  					qPd.put("PROBLEM_TYPE_ID",
  							question.getProblem_type_id() == null ? "1"
  									: question.getProblem_type_id());
338594c8   孙向锦   添加教师端页面
1312
1313
1314
1315
1316
1317
1318
1319
1320
1321
1322
1323
1324
1325
1326
1327
  					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   孙向锦   完善后台功能
1328
  
338594c8   孙向锦   添加教师端页面
1329
  					PageData pqPd = new PageData();
91a745c9   孙向锦   完善后台功能
1330
1331
1332
1333
1334
1335
1336
  					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   孙向锦   添加教师端页面
1337
  					paperquestionService.save(pqPd);
91a745c9   孙向锦   完善后台功能
1338
1339
  
  					if (question.getQuestions() != null) {
338594c8   孙向锦   添加教师端页面
1340
  						List<Question> qs = question.getQuestions();
91a745c9   孙向锦   完善后台功能
1341
  						for (Question q : qs) {
338594c8   孙向锦   添加教师端页面
1342
1343
1344
1345
1346
1347
  							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   孙向锦   增加接口
1348
1349
1350
  							cqPd.put("PROBLEM_TYPE_ID", question
  									.getProblem_type_id() == null ? "1"
  									: question.getProblem_type_id());
338594c8   孙向锦   添加教师端页面
1351
1352
1353
1354
1355
1356
1357
1358
1359
1360
1361
1362
1363
1364
1365
  							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   孙向锦   完善后台功能
1366
  
338594c8   孙向锦   添加教师端页面
1367
  							questionService.save(cqPd);
91a745c9   孙向锦   完善后台功能
1368
  
338594c8   孙向锦   添加教师端页面
1369
  							PageData cpqPd = new PageData();
91a745c9   孙向锦   完善后台功能
1370
1371
1372
1373
1374
1375
1376
1377
  							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   孙向锦   添加教师端页面
1378
  							paperquestionService.save(cpqPd);
ce70231e   孙向锦   增加接口
1379
  							questionNum++;
338594c8   孙向锦   添加教师端页面
1380
1381
1382
1383
  						}
  					}
  				}
  			}
4fd2e08c   孙向锦   修复接口中的bug
1384
1385
  			paperPd.put("QUESTION_NUM", "" + questionNum);
  			paperService.save(paperPd);
91a745c9   孙向锦   完善后台功能
1386
1387
  
  		} else {
338594c8   孙向锦   添加教师端页面
1388
1389
  			res.setDataError();
  		}
ce70231e   孙向锦   增加接口
1390
1391
1392
1393
1394
  		logger.info("uploadpaper cost time : "
  				+ (System.currentTimeMillis() - cur));
  		return res.toJson();
  	}
  
2ad7ca45   孙向锦   试卷bug修改
1395
1396
  	/**
  	 * 上传试卷,不上传试题详细信息。试题从已有数据库中组卷
107fa3a0   孙向锦   修改试卷单选多远混合出题
1397
  	 * 
2ad7ca45   孙向锦   试卷bug修改
1398
1399
1400
1401
1402
1403
1404
1405
1406
1407
1408
1409
1410
1411
1412
1413
1414
1415
1416
1417
1418
1419
1420
1421
  	 * @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   孙向锦   样例报表
1422
  			paperPd.put("CLASS_ID", paper.getClass_id());
2ad7ca45   孙向锦   试卷bug修改
1423
1424
1425
1426
1427
1428
1429
  			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修改
1430
  			List<Question> questions = paper.getQuestions();
757dfed6   孙向锦   样例报表
1431
  			int questionNum = questions.size();
2ad7ca45   孙向锦   试卷bug修改
1432
1433
1434
1435
1436
1437
1438
1439
1440
1441
  			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   孙向锦   添加即时测功能
1442
  					pqPd.put("P_ID", "0");
227dbfbb   孙向锦   添加知识点id
1443
  					pqPd.put("KNOWLEDGE_ID", question.getKnowledge_id());//
2ad7ca45   孙向锦   试卷bug修改
1444
1445
1446
1447
1448
1449
1450
1451
1452
1453
  					paperquestionService.save(pqPd);
  
  				}
  			}
  			paperPd.put("QUESTION_NUM", "" + questionNum);
  			paperService.save(paperPd);
  
  		} else {
  			res.setDataError();
  		}
757dfed6   孙向锦   样例报表
1454
  		logger.info("publishpaper cost time : "
2ad7ca45   孙向锦   试卷bug修改
1455
1456
1457
1458
1459
1460
  				+ (System.currentTimeMillis() - cur));
  		return res.toJson();
  	}
  
  	/**
  	 * 上传知识点
107fa3a0   孙向锦   修改试卷单选多远混合出题
1461
  	 * 
2ad7ca45   孙向锦   试卷bug修改
1462
1463
1464
  	 * @return
  	 * @throws Exception
  	 */
ce70231e   孙向锦   增加接口
1465
1466
1467
1468
1469
1470
1471
1472
1473
1474
1475
1476
1477
1478
1479
1480
1481
1482
1483
1484
1485
1486
1487
1488
1489
1490
  	@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   孙向锦   完善后台功能
1491
1492
1493
  		return res.toJson();
  	}
  
2ad7ca45   孙向锦   试卷bug修改
1494
  	/**
107fa3a0   孙向锦   修改试卷单选多远混合出题
1495
1496
  	 * 上传测验成绩
  	 * 
2ad7ca45   孙向锦   试卷bug修改
1497
1498
  	 * @return
  	 */
91a745c9   孙向锦   完善后台功能
1499
1500
1501
  	@RequestMapping(value = "/uploadtestpaper", produces = "application/json;charset=UTF-8")
  	@ResponseBody
  	public Object uploadTestpaper() {
3371dbc6   孙向锦   0720 版本
1502
  		event("uploadTestpaper");
4fd2e08c   孙向锦   修复接口中的bug
1503
  		long cur = System.currentTimeMillis();
91a745c9   孙向锦   完善后台功能
1504
1505
1506
  		PageData pd = this.getPageData();
  		ResponseGson<String> res = new ResponseGson();
  		if (!StringUtils.isEmpty(pd.getJsonString())) {
4fd2e08c   孙向锦   修复接口中的bug
1507
  			logger.info(pd.getJsonString());
91a745c9   孙向锦   完善后台功能
1508
1509
1510
1511
  			TestPaper testPaper = TestPaper.parse(pd.getJsonString());
  			try {
  				PageData testPd = new PageData();
  				String testPaperId = this.get32UUID();
91a745c9   孙向锦   完善后台功能
1512
  				testPd.put("TEACHER_ID", testPaper.getTeacherId());
91a745c9   孙向锦   完善后台功能
1513
1514
  				testPd.put("PAPER_ID", testPaper.getPaperId());
  				testPd.put("SCLASS_ID", testPaper.getClassId());
91a745c9   孙向锦   完善后台功能
1515
1516
1517
1518
1519
  				testPd.put(
  						"CREATE_DATE",
  						testPaper.getCreateDate() == null ? Tools
  								.date2Str(new Date()) : testPaper
  								.getCreateDate());
107fa3a0   孙向锦   修改试卷单选多远混合出题
1520
1521
1522
1523
  				testPd.put(
  						"TEST_TYPE",
  						testPaper.getTest_type() != null ? testPaper
  								.getTest_type() : "1");
2480c889   孙向锦   添加软件管理模块。对软件形成统一的管理
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
  				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());
579f3266   jack   1.studenttest增加增加...
1570
  
2480c889   孙向锦   添加软件管理模块。对软件形成统一的管理
1571
1572
1573
1574
1575
1576
1577
1578
1579
1580
1581
1582
1583
1584
1585
1586
1587
1588
1589
1590
1591
1592
1593
1594
  									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);
  								}
579f3266   jack   1.studenttest增加增加...
1595
  
2480c889   孙向锦   添加软件管理模块。对软件形成统一的管理
1596
1597
  							}
  						}
1c817fc8   孙向锦   修改一些bug信息
1598
1599
1600
  						if(testInfoPdList != null && testInfoPdList.size() > 0){
  							testpaperinfoService.batchSave(testInfoPdList);
  						}
2480c889   孙向锦   添加软件管理模块。对软件形成统一的管理
1601
  					}
ce70231e   孙向锦   增加接口
1602
  				} else {
2480c889   孙向锦   添加软件管理模块。对软件形成统一的管理
1603
1604
1605
1606
1607
1608
1609
1610
1611
1612
1613
  					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   孙向锦   样例报表
1614
  		logger.info("uploadTestpaper cost time:"
ce70231e   孙向锦   增加接口
1615
  				+ (System.currentTimeMillis() - cur));
2480c889   孙向锦   添加软件管理模块。对软件形成统一的管理
1616
1617
1618
  
  		return res.toJson();
  
107fa3a0   孙向锦   修改试卷单选多远混合出题
1619
  	}
ce70231e   孙向锦   增加接口
1620
  
2ad7ca45   孙向锦   试卷bug修改
1621
  	/**
107fa3a0   孙向锦   修改试卷单选多远混合出题
1622
1623
  	 * 上传测验成绩
  	 * 
2ad7ca45   孙向锦   试卷bug修改
1624
1625
  	 * @return
  	 */
2480c889   孙向锦   添加软件管理模块。对软件形成统一的管理
1626
1627
1628
  	@RequestMapping(value = "/uploadupdatetestpaper", produces = "application/json;charset=UTF-8")
  	@ResponseBody
  	public Object uploadupdateTestpaper() {
3371dbc6   孙向锦   0720 版本
1629
  		event("uploadupdateTestpaper");
2480c889   孙向锦   添加软件管理模块。对软件形成统一的管理
1630
1631
1632
1633
1634
1635
1636
1637
1638
1639
1640
1641
1642
1643
1644
1645
1646
  		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   孙向锦   修改试卷单选多远混合出题
1647
1648
1649
1650
  				testPd.put(
  						"TEST_TYPE",
  						testPaper.getTest_type() != null ? testPaper
  								.getTest_type() : "1");
2480c889   孙向锦   添加软件管理模块。对软件形成统一的管理
1651
1652
1653
1654
1655
1656
1657
1658
1659
1660
1661
1662
  				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   孙向锦   完善后台功能
1663
1664
1665
1666
  				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   孙向锦   更新报表
1667
  				testPd.put("TOTAL_SCORE", testPaper.getTotalScore());
3a163205   孙向锦   报表优化
1668
  				testPd.put("SUBJECT_ID", testPaper.getSubject_id());
91a745c9   孙向锦   完善后台功能
1669
1670
1671
  				testPd.put("REMARK", testPaper.getRemark());
  				testpaperService.save(testPd);
  				if (testPaper.getStudents() != null) {
2480c889   孙向锦   添加软件管理模块。对软件形成统一的管理
1672
1673
  					List<PageData> testInfoPdList = new ArrayList();
  					PageData testInfoPd = null;
91a745c9   孙向锦   完善后台功能
1674
1675
1676
  					for (StudentAnswer studentAnswer : testPaper.getStudents()) {
  						if (studentAnswer.getQuestions() != null) {
  							PageData studentPageData = new PageData();
91a745c9   孙向锦   完善后台功能
1677
1678
1679
1680
1681
1682
1683
1684
1685
  							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   孙向锦   添加软件管理模块。对软件形成统一的管理
1686
  							studentPageData.put("STUDENTTEST_ID", get32UUID());
579f3266   jack   1.studenttest增加增加...
1687
1688
  							
  							String flag = "";
91a745c9   孙向锦   完善后台功能
1689
1690
  							for (TestPaperInfo testPaperInfo : studentAnswer
  									.getQuestions()) {
2480c889   孙向锦   添加软件管理模块。对软件形成统一的管理
1691
  								testInfoPd = new PageData();
91a745c9   孙向锦   完善后台功能
1692
1693
1694
1695
1696
1697
1698
1699
1700
1701
1702
  								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());
d6117fe9   jack   1.修改报表缺考bug
1703
  								flag = testPaperInfo.getAnswer().toString().equals("")?""+flag:testPaperInfo.getAnswer().toString();
91a745c9   孙向锦   完善后台功能
1704
1705
1706
1707
1708
1709
  								testInfoPd.put("RIGHT",
  										testPaperInfo.getRight());
  								testInfoPd.put("SCORE",
  										testPaperInfo.getScore());
  								testInfoPd.put("LIKES",
  										testPaperInfo.getLikes());
2480c889   孙向锦   添加软件管理模块。对软件形成统一的管理
1710
1711
1712
  								testInfoPd.put("ANSWER_TYPE", testPaperInfo
  										.getAnswerType() == null ? "1"
  										: testPaperInfo.getAnswerType());
91a745c9   孙向锦   完善后台功能
1713
1714
1715
1716
1717
1718
1719
1720
1721
  								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   孙向锦   添加软件管理模块。对软件形成统一的管理
1722
  								testInfoPdList.add(testInfoPd);
91a745c9   孙向锦   完善后台功能
1723
  							}
579f3266   jack   1.studenttest增加增加...
1724
1725
1726
1727
1728
  							
  							if(flag.equals("")){
  								studentPageData.put("LOST_TEST","1");
  							}
  							studenttestService.save(studentPageData);
91a745c9   孙向锦   完善后台功能
1729
1730
  						}
  					}
1c817fc8   孙向锦   修改一些bug信息
1731
1732
1733
  					if(testInfoPdList != null && testInfoPdList.size() > 0){
  						testpaperinfoService.batchSave(testInfoPdList);
  					}
91a745c9   孙向锦   完善后台功能
1734
1735
1736
1737
1738
1739
1740
1741
1742
1743
  				}
  				res.setData(testPaperId);
  			} catch (Exception e) {
  				e.printStackTrace();
  				res.setError();
  				res.setMessage(e.getMessage());
  			}
  		} else {
  			res.setDataError();
  		}
757dfed6   孙向锦   样例报表
1744
  		logger.info("uploadupdatetestpaper cost time:"
2480c889   孙向锦   添加软件管理模块。对软件形成统一的管理
1745
  				+ (System.currentTimeMillis() - cur));
91a745c9   孙向锦   完善后台功能
1746
1747
1748
1749
  
  		return res.toJson();
  
  	}
107fa3a0   孙向锦   修改试卷单选多远混合出题
1750
  
757dfed6   孙向锦   样例报表
1751
  	/**
107fa3a0   孙向锦   修改试卷单选多远混合出题
1752
1753
  	 * 上传测验成绩
  	 * 
757dfed6   孙向锦   样例报表
1754
1755
1756
1757
1758
1759
1760
1761
1762
1763
1764
1765
1766
1767
1768
1769
1770
1771
1772
1773
1774
1775
1776
1777
1778
1779
1780
1781
1782
1783
1784
  	 * @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   孙向锦   修改试卷单选多远混合出题
1785
1786
1787
1788
  				testPd.put(
  						"TEST_TYPE",
  						testPaper.getTest_type() != null ? testPaper
  								.getTest_type() : "101");
757dfed6   孙向锦   样例报表
1789
1790
1791
1792
1793
1794
1795
1796
1797
  				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   孙向锦   报表优化
1798
  				testPd.put("SUBJECT_ID", testPaper.getSubject_id());
757dfed6   孙向锦   样例报表
1799
1800
1801
1802
1803
1804
1805
1806
1807
1808
1809
1810
1811
1812
1813
1814
1815
1816
1817
  				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   孙向锦   修改试卷单选多远混合出题
1818
  
757dfed6   孙向锦   样例报表
1819
1820
1821
1822
1823
1824
1825
1826
1827
1828
1829
1830
1831
1832
1833
1834
1835
1836
1837
1838
1839
1840
  							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   孙向锦   修改试卷单选多远混合出题
1841
  										: testPaperInfo.getAnswerType());
757dfed6   孙向锦   样例报表
1842
1843
1844
1845
1846
1847
1848
1849
1850
  								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   孙向锦   修改试卷单选多远混合出题
1851
1852
  								testInfoPd.put("RANDOM",
  										testPaperInfo.getRandom());
757dfed6   孙向锦   样例报表
1853
1854
1855
1856
1857
  								testInfoPd.put("RANK", testPaperInfo.getRank());
  								testInfoPdList.add(testInfoPd);
  							}
  						}
  					}
eca4feb5   孙向锦   管理员功能完善
1858
1859
1860
  					if(testInfoPdList.size() > 0){
  						testpaperinfoService.batchSave(testInfoPdList);
  					}
757dfed6   孙向锦   样例报表
1861
1862
1863
1864
1865
1866
1867
1868
1869
1870
  				}
  				res.setData(testPaperId);
  			} catch (Exception e) {
  				e.printStackTrace();
  				res.setError();
  				res.setMessage(e.getMessage());
  			}
  		} else {
  			res.setDataError();
  		}
bda221f4   孙向锦   0830版本
1871
  		logger.info("uploadupdateTestpaper2 cost time:"
757dfed6   孙向锦   样例报表
1872
  				+ (System.currentTimeMillis() - cur));
107fa3a0   孙向锦   修改试卷单选多远混合出题
1873
  
757dfed6   孙向锦   样例报表
1874
  		return res.toJson();
107fa3a0   孙向锦   修改试卷单选多远混合出题
1875
  
757dfed6   孙向锦   样例报表
1876
  	}
91a745c9   孙向锦   完善后台功能
1877
  
2ad7ca45   孙向锦   试卷bug修改
1878
1879
  	/**
  	 * 查询知识点
107fa3a0   孙向锦   修改试卷单选多远混合出题
1880
  	 * 
2ad7ca45   孙向锦   试卷bug修改
1881
1882
1883
  	 * @return
  	 * @throws Exception
  	 */
ce70231e   孙向锦   增加接口
1884
1885
1886
  	@RequestMapping(value = "/point", produces = "application/json;charset=UTF-8")
  	@ResponseBody
  	public Object point() throws Exception {
757dfed6   孙向锦   样例报表
1887
  		event("point");
ce70231e   孙向锦   增加接口
1888
  		ResponseGson<List<PageData>> res = new ResponseGson();
2ad7ca45   孙向锦   试卷bug修改
1889
  
ce70231e   孙向锦   增加接口
1890
  		PageData pd = getPageData();
2ad7ca45   孙向锦   试卷bug修改
1891
  		String key = this.getRequestKey(pd, "point");
ce70231e   孙向锦   增加接口
1892
1893
  		PageData pagedata = new PageData();
  		pagedata.put("KEY", key);
2ad7ca45   孙向锦   试卷bug修改
1894
  		if (!"".equals(key.trim())) {
ce70231e   孙向锦   增加接口
1895
  			PageData ret = cacheService.findById(pagedata);
2ad7ca45   孙向锦   试卷bug修改
1896
  			if (ret != null && ret.get("CACHE") != null) {
ce70231e   孙向锦   增加接口
1897
1898
1899
1900
1901
  				return ret.get("CACHE");
  			}
  		}
  		List<PageData> list = knowledgeService.listAllknowledge(pd);
  		String depth = pd.getString("DEPTH");
2ad7ca45   孙向锦   试卷bug修改
1902
1903
1904
  		int end = 3;
  		if (depth != null) {
  			try {
ce70231e   孙向锦   增加接口
1905
  				end = Integer.parseInt(depth);
2ad7ca45   孙向锦   试卷bug修改
1906
1907
  			} catch (Exception e) {
  
ce70231e   孙向锦   增加接口
1908
1909
  			}
  		}
2ad7ca45   孙向锦   试卷bug修改
1910
  		roundPointData(list, 1, end);
ce70231e   孙向锦   增加接口
1911
1912
  		res.setData(list);
  		String str = res.toJson();
2ad7ca45   孙向锦   试卷bug修改
1913
  		str = str.replaceAll("[^\\u0000-\\uFFFF]", "");
ce70231e   孙向锦   增加接口
1914
1915
1916
1917
1918
  		pagedata.put("CACHE", str);
  		cacheService.save(pagedata);
  		return str;
  	}
  
2ad7ca45   孙向锦   试卷bug修改
1919
1920
  	/**
  	 * 知识点递归查询
107fa3a0   孙向锦   修改试卷单选多远混合出题
1921
1922
1923
1924
1925
1926
1927
  	 * 
  	 * @param list
  	 *            查询知识点及子知识点
  	 * @param dept
  	 *            深度
  	 * @param end
  	 *            层深
2ad7ca45   孙向锦   试卷bug修改
1928
1929
1930
1931
  	 * @throws Exception
  	 */
  	private void roundPointData(List<PageData> list, int dept, int end)
  			throws Exception {
ce70231e   孙向锦   增加接口
1932
1933
1934
1935
1936
1937
1938
  		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修改
1939
  						roundPointData(ret, dept + 1, end);
ce70231e   孙向锦   增加接口
1940
1941
1942
1943
1944
1945
1946
  						pd.put("CHILDREN", ret);
  					}
  				}
  				pd.remove("P_ID");
  			}
  		}
  	}
2ad7ca45   孙向锦   试卷bug修改
1947
1948
1949
  
  	/**
  	 * 章节递归查询
107fa3a0   孙向锦   修改试卷单选多远混合出题
1950
1951
1952
1953
1954
1955
1956
  	 * 
  	 * @param list
  	 *            章节
  	 * @param dept
  	 *            深度
  	 * @param end
  	 *            递归深度
2ad7ca45   孙向锦   试卷bug修改
1957
1958
1959
1960
1961
  	 * @throws Exception
  	 */
  	private void roundChapterData(List<PageData> list, int dept, int end)
  			throws Exception {
  		if (list != null) {
ce70231e   孙向锦   增加接口
1962
1963
  			for (PageData pd : list) {
  				pd.put("P_ID", pd.getString("ID"));
2ad7ca45   孙向锦   试卷bug修改
1964
1965
1966
1967
1968
1969
1970
1971
  				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   孙向锦   增加接口
1972
1973
1974
  					}
  				}
  				pd.remove("P_ID");
2ad7ca45   孙向锦   试卷bug修改
1975
  				pd.remove("TEACHINGMATERIAL_ID");
ce70231e   孙向锦   增加接口
1976
1977
1978
1979
  			}
  		}
  	}
  
2ad7ca45   孙向锦   试卷bug修改
1980
  	/**
107fa3a0   孙向锦   修改试卷单选多远混合出题
1981
1982
  	 * 下载测验成绩
  	 * 
2ad7ca45   孙向锦   试卷bug修改
1983
1984
  	 * @return
  	 */
91a745c9   孙向锦   完善后台功能
1985
1986
1987
  	@RequestMapping(value = "/downloadtestpaper", produces = "application/json;charset=UTF-8")
  	@ResponseBody
  	public Object downloadTestpaper() {
3371dbc6   孙向锦   0720 版本
1988
  		event("downloadTestpaper");
2480c889   孙向锦   添加软件管理模块。对软件形成统一的管理
1989
  		long cur = System.currentTimeMillis();
91a745c9   孙向锦   完善后台功能
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
2054
2055
2056
2057
2058
2059
2060
2061
2062
2063
2064
  		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   孙向锦   增加接口
2065
2066
  		logger.info("downloadtestpaper cost time:"
  				+ (System.currentTimeMillis() - cur));
338594c8   孙向锦   添加教师端页面
2067
  		return res.toJson();
91a745c9   孙向锦   完善后台功能
2068
  
338594c8   孙向锦   添加教师端页面
2069
2070
  	}
  
2ad7ca45   孙向锦   试卷bug修改
2071
2072
  	/**
  	 * 
107fa3a0   孙向锦   修改试卷单选多远混合出题
2073
2074
  	 * 下载测验成绩
  	 * 
2ad7ca45   孙向锦   试卷bug修改
2075
2076
  	 * @return
  	 */
91a745c9   孙向锦   完善后台功能
2077
2078
2079
  	@RequestMapping(value = "/testpaper", produces = "application/json;charset=UTF-8")
  	@ResponseBody
  	public Object testpaper() {
3371dbc6   孙向锦   0720 版本
2080
  		event("testpaper");
2480c889   孙向锦   添加软件管理模块。对软件形成统一的管理
2081
  		long cur = System.currentTimeMillis();
91a745c9   孙向锦   完善后台功能
2082
2083
2084
2085
2086
2087
2088
2089
2090
2091
2092
2093
2094
2095
2096
2097
2098
2099
2100
2101
2102
2103
2104
2105
2106
2107
2108
2109
2110
2111
2112
  		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   孙向锦   添加软件管理模块。对软件形成统一的管理
2113
  		logger.info("testpaper cost time:" + (System.currentTimeMillis() - cur));
91a745c9   孙向锦   完善后台功能
2114
2115
2116
  		return res.toJson();
  
  	}
ce70231e   孙向锦   增加接口
2117
  
2ad7ca45   孙向锦   试卷bug修改
2118
2119
2120
  	/***
  	 * 
  	 */
4fd2e08c   孙向锦   修复接口中的bug
2121
2122
  	@RequestMapping(value = "/schooladmin", produces = "application/json;charset=UTF-8")
  	@ResponseBody
ce70231e   孙向锦   增加接口
2123
  	public void schoolAdmin() {
3371dbc6   孙向锦   0720 版本
2124
  		event("schoolAdmin");
4fd2e08c   孙向锦   修复接口中的bug
2125
2126
  		PageData pd = this.getPageData();
  		this.getUserID();
4fd2e08c   孙向锦   修复接口中的bug
2127
  	}
ce70231e   孙向锦   增加接口
2128
  
2ad7ca45   孙向锦   试卷bug修改
2129
2130
  	/***
  	 * 网络
107fa3a0   孙向锦   修改试卷单选多远混合出题
2131
  	 * 
2ad7ca45   孙向锦   试卷bug修改
2132
2133
2134
  	 * @return
  	 * @throws Exception
  	 */
9338b563   孙向锦   添加报表
2135
2136
  	@RequestMapping(value = "/network", produces = "application/json;charset=UTF-8")
  	@ResponseBody
ce70231e   孙向锦   增加接口
2137
  	public Object network() throws Exception {
3371dbc6   孙向锦   0720 版本
2138
  		event("network");
9338b563   孙向锦   添加报表
2139
2140
2141
2142
2143
2144
2145
2146
2147
2148
2149
2150
  		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   孙向锦   增加接口
2151
  				if (fail < 0) {
9338b563   孙向锦   添加报表
2152
2153
2154
2155
2156
2157
2158
2159
2160
2161
2162
2163
2164
  					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   孙向锦   增加接口
2165
  				if (fail < 0) {
9338b563   孙向锦   添加报表
2166
2167
2168
2169
2170
2171
2172
2173
2174
2175
2176
  					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   孙向锦   增加接口
2177
  		} else {
9338b563   孙向锦   添加报表
2178
2179
2180
2181
  			res.setDataError();
  		}
  		return res.toJson();
  	}
ce70231e   孙向锦   增加接口
2182
  
2ad7ca45   孙向锦   试卷bug修改
2183
2184
  	/**
  	 * 获取远端ip地址
107fa3a0   孙向锦   修改试卷单选多远混合出题
2185
  	 * 
2ad7ca45   孙向锦   试卷bug修改
2186
2187
  	 * @return
  	 */
ce70231e   孙向锦   增加接口
2188
  	public String getRemoteIp() {
9338b563   孙向锦   添加报表
2189
2190
2191
2192
2193
2194
2195
2196
2197
  		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   孙向锦   增加接口
2198
  
2ad7ca45   孙向锦   试卷bug修改
2199
2200
  	/**
  	 * 查询新版本信息
107fa3a0   孙向锦   修改试卷单选多远混合出题
2201
  	 * 
2ad7ca45   孙向锦   试卷bug修改
2202
2203
2204
2205
  	 * @param request
  	 * @return
  	 * @throws Exception
  	 */
2480c889   孙向锦   添加软件管理模块。对软件形成统一的管理
2206
2207
  	@RequestMapping(value = "/newversion", produces = "application/json;charset=UTF-8")
  	@ResponseBody
ce70231e   孙向锦   增加接口
2208
  	public Object getNewVersion(HttpServletRequest request) throws Exception {
3371dbc6   孙向锦   0720 版本
2209
  		event("getNewVersion");
2480c889   孙向锦   添加软件管理模块。对软件形成统一的管理
2210
2211
2212
  		PageData pd = this.getPageData();
  		String softId = pd.getString("SOFTID");
  		String path = request.getContextPath();
ce70231e   孙向锦   增加接口
2213
2214
  		String basePath = request.getScheme() + "://" + request.getServerName()
  				+ ":" + request.getServerPort() + path + "/";
2480c889   孙向锦   添加软件管理模块。对软件形成统一的管理
2215
  		ResponseGson<PageData> res = new ResponseGson();
ce70231e   孙向锦   增加接口
2216
  		if (softId != null && !"".equals(softId)) {
2480c889   孙向锦   添加软件管理模块。对软件形成统一的管理
2217
2218
  			pd.put("SOFTWARE_ID", softId);
  			PageData result = softwareversionService.findNewVersion(pd);
ce70231e   孙向锦   增加接口
2219
  			if (result != null) {
2480c889   孙向锦   添加软件管理模块。对软件形成统一的管理
2220
2221
  				result.remove("SOFTWAREVERSION_ID");
  				result.remove("SOFTWARE_ID");
ce70231e   孙向锦   增加接口
2222
2223
  				result.put("VERSION_PATH", basePath + "uploadFiles/uploadFile/"
  						+ result.getString("VERSION_PATH"));
2480c889   孙向锦   添加软件管理模块。对软件形成统一的管理
2224
  				res.setData(result);
ce70231e   孙向锦   增加接口
2225
  			} else {
2480c889   孙向锦   添加软件管理模块。对软件形成统一的管理
2226
2227
  				res.setDataError();
  			}
ce70231e   孙向锦   增加接口
2228
  		} else {
2480c889   孙向锦   添加软件管理模块。对软件形成统一的管理
2229
2230
2231
2232
  			res.setDataError();
  		}
  		return res.toJson();
  	}
ce70231e   孙向锦   增加接口
2233
2234
2235
2236
2237
2238
2239
2240
2241
2242
2243
2244
2245
2246
2247
2248
2249
2250
2251
2252
2253
2254
2255
2256
  
  	/**
  	 * 获取教材版本
  	 * 
  	 * @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修改
2257
2258
  								pad.put("VERSION_CODE",
  										pad.getString("VERSION_CODE"));
ce70231e   孙向锦   增加接口
2259
2260
2261
2262
2263
2264
2265
2266
2267
2268
2269
2270
2271
2272
2273
2274
2275
  								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   孙向锦   修改试卷单选多远混合出题
2276
  
c617106f   孙向锦   添加即时测功能
2277
2278
2279
2280
2281
2282
2283
2284
2285
  	@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修改
2286
  
ce70231e   孙向锦   增加接口
2287
2288
2289
2290
2291
2292
2293
2294
2295
2296
  	/**
  	 * 获取教材版本
  	 * 
  	 * @return
  	 * @throws Exception
  	 */
  	@RequestMapping(value = "/chapter", produces = "application/json;charset=UTF-8")
  	@ResponseBody
  	public Object chapter() throws Exception {
  		PageData pd = getPageData();
2ad7ca45   孙向锦   试卷bug修改
2297
  		String key = this.getRequestKey(pd, "chapter");
ce70231e   孙向锦   增加接口
2298
2299
  		PageData pagedata = new PageData();
  		pagedata.put("KEY", key);
2ad7ca45   孙向锦   试卷bug修改
2300
  		if (!"".equals(key.trim())) {
ce70231e   孙向锦   增加接口
2301
  			PageData ret = cacheService.findById(pagedata);
2ad7ca45   孙向锦   试卷bug修改
2302
  			if (ret != null && ret.get("CACHE") != null) {
ce70231e   孙向锦   增加接口
2303
2304
2305
2306
2307
2308
  				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修改
2309
2310
2311
  		int end = 3;
  		if (depth != null) {
  			try {
ce70231e   孙向锦   增加接口
2312
  				end = Integer.parseInt(depth);
2ad7ca45   孙向锦   试卷bug修改
2313
2314
  			} catch (Exception e) {
  
ce70231e   孙向锦   增加接口
2315
2316
  			}
  		}
2ad7ca45   孙向锦   试卷bug修改
2317
  		roundChapterData(list, 1, end);
ce70231e   孙向锦   增加接口
2318
2319
  		res.setData(list);
  		String str = res.toJson();
ce70231e   孙向锦   增加接口
2320
2321
2322
2323
  		pagedata.put("CACHE", str);
  		cacheService.save(pagedata);
  		return str;
  	}
2ad7ca45   孙向锦   试卷bug修改
2324
  
ce70231e   孙向锦   增加接口
2325
2326
2327
2328
2329
2330
2331
2332
2333
2334
2335
2336
2337
  	/**
  	 * 获取试题
  	 * 
  	 * @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修改
2338
2339
  		if (teachingmaterialId != null && !teachingmaterialId.equals("")
  				&& chapterId == null) {
ce70231e   孙向锦   增加接口
2340
2341
  			PageData chapterPd = new PageData();
  			chapterPd.put("TEACHINGMATERIAL_ID", teachingmaterialId);
2ad7ca45   孙向锦   试卷bug修改
2342
2343
  			List<PageData> chapterList = chapterService
  					.listAllChapter(chapterPd);
ce70231e   孙向锦   增加接口
2344
  			roundChapterData(chapterList, 1, 3);
2ad7ca45   孙向锦   试卷bug修改
2345
  			List<String> ids = getIds(chapterList, "ID");
ce70231e   孙向锦   增加接口
2346
  			pd.put("CHAPTER_IDS", ids);
2ad7ca45   孙向锦   试卷bug修改
2347
  		} else {
ce70231e   孙向锦   增加接口
2348
  			List<String> ids = new ArrayList<String>();
2ad7ca45   孙向锦   试卷bug修改
2349
  			if (chapterId != null && !"".equals(chapterId.trim())) {
ce70231e   孙向锦   增加接口
2350
2351
2352
2353
2354
2355
  				ids.add(chapterId);
  			}
  			pd.put("CHAPTER_IDS", ids);
  		}
  		pd.remove("CHAPTER_ID");
  		String knowledge = pd.getString("KNOWLEDGE_ID");
2ad7ca45   孙向锦   试卷bug修改
2356
  		if (knowledge != null && !"".equals(knowledge.trim())) {
ce70231e   孙向锦   增加接口
2357
2358
2359
2360
  			PageData knowPd = new PageData();
  			knowPd.put("P_ID", knowledge);
  			List<PageData> knowlist = knowledgeService.listAllknowledge(knowPd);
  			roundPointData(knowlist, 1, 3);
2ad7ca45   孙向锦   试卷bug修改
2361
  			List<String> ids = getIds(knowlist, "KNOWLEDGE_ID");
ce70231e   孙向锦   增加接口
2362
  			ids.add(knowledge);
2ad7ca45   孙向锦   试卷bug修改
2363
  			pd.put("KNOWLEDGE_IDS", ids);
ce70231e   孙向锦   增加接口
2364
2365
  			pd.remove("KNOWLEDGE_ID");
  		}
107fa3a0   孙向锦   修改试卷单选多远混合出题
2366
2367
  		int pageNumI = 0;
  		int count = 30;
0aad4b6b   孙向锦   修复试题分页功能
2368
2369
  		String pageNum = pd.getString("PAGENUM");
  		String countStr = pd.getString("COUNT");
107fa3a0   孙向锦   修改试卷单选多远混合出题
2370
2371
  		if (pageNum != null && !"".equals(pageNum) && countStr != null
  				&& !"".equals(countStr)) {
0aad4b6b   孙向锦   修复试题分页功能
2372
2373
  			pageNumI = Integer.parseInt(pageNum);
  			count = Integer.parseInt(countStr);
107fa3a0   孙向锦   修改试卷单选多远混合出题
2374
2375
2376
2377
  			if (pageNumI >= 1) {
  				pageNumI = (pageNumI - 1) * count;
  			} else {
  				pageNumI = 0;
0aad4b6b   孙向锦   修复试题分页功能
2378
2379
2380
2381
  			}
  			pd.put("PAGENUM", "" + pageNumI);
  			pd.put("COUNT", "" + count);
  		}
ce70231e   孙向锦   增加接口
2382
  		List<PageData> list = questionService.listAllquestion(pd);
107fa3a0   孙向锦   修改试卷单选多远混合出题
2383
  		for (PageData pad : list) {
c617106f   孙向锦   添加即时测功能
2384
  			String optionContent = pad.getString("OPTION_CONTENT");
107fa3a0   孙向锦   修改试卷单选多远混合出题
2385
2386
2387
2388
  			if (optionContent != null && optionContent.startsWith("[")
  					&& optionContent.endsWith("]")) {
  				String[] options = optionContent.substring(1,
  						optionContent.length() - 1).split(",");
c617106f   孙向锦   添加即时测功能
2389
  				pad.put("OPTION_CONTENT", options);
107fa3a0   孙向锦   修改试卷单选多远混合出题
2390
2391
  			} else {
  				pad.put("OPTION_CONTENT", new String[] { optionContent });
c617106f   孙向锦   添加即时测功能
2392
  			}
a0eff87f   孙向锦   修改课后练bug
2393
2394
2395
2396
  			
  			if(pad.getString("CONTENT") != null){
  				pad.put("CONTENT", pad.getString("CONTENT").replaceAll("<fill></fill>", "______"));
  			}
c617106f   孙向锦   添加即时测功能
2397
  		}
ce70231e   孙向锦   增加接口
2398
2399
2400
  		res.setData(list);
  		return res.toJson();
  	}
2ad7ca45   孙向锦   试卷bug修改
2401
  
ce70231e   孙向锦   增加接口
2402
2403
2404
2405
2406
2407
2408
2409
2410
2411
2412
2413
2414
  	/**
  	 * 随机获取试题
  	 * 
  	 * @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修改
2415
2416
  		if (teachingmaterialId != null && !teachingmaterialId.equals("")
  				&& chapterId == null) {
ce70231e   孙向锦   增加接口
2417
2418
  			PageData chapterPd = new PageData();
  			chapterPd.put("TEACHINGMATERIAL_ID", teachingmaterialId);
2ad7ca45   孙向锦   试卷bug修改
2419
2420
  			List<PageData> chapterList = chapterService
  					.listAllChapter(chapterPd);
ce70231e   孙向锦   增加接口
2421
  			roundChapterData(chapterList, 1, 3);
2ad7ca45   孙向锦   试卷bug修改
2422
  			List<String> ids = getIds(chapterList, "ID");
ce70231e   孙向锦   增加接口
2423
  			pd.put("CHAPTER_IDS", ids);
2ad7ca45   孙向锦   试卷bug修改
2424
  		} else {
ce70231e   孙向锦   增加接口
2425
  			List<String> ids = new ArrayList<String>();
2ad7ca45   孙向锦   试卷bug修改
2426
  			if (chapterId != null && !"".equals(chapterId.trim())) {
ce70231e   孙向锦   增加接口
2427
2428
2429
2430
2431
2432
  				ids.add(chapterId);
  			}
  			pd.put("CHAPTER_IDS", ids);
  		}
  		pd.remove("CHAPTER_ID");
  		String knowledge = pd.getString("KNOWLEDGE_ID");
2ad7ca45   孙向锦   试卷bug修改
2433
  		if (knowledge != null && !"".equals(knowledge.trim())) {
ce70231e   孙向锦   增加接口
2434
2435
2436
2437
  			PageData knowPd = new PageData();
  			knowPd.put("P_ID", knowledge);
  			List<PageData> knowlist = knowledgeService.listAllknowledge(knowPd);
  			roundPointData(knowlist, 1, 3);
2ad7ca45   孙向锦   试卷bug修改
2438
  			List<String> ids = getIds(knowlist, "KNOWLEDGE_ID");
ce70231e   孙向锦   增加接口
2439
  			ids.add(knowledge);
2ad7ca45   孙向锦   试卷bug修改
2440
  			pd.put("KNOWLEDGE_IDS", ids);
ce70231e   孙向锦   增加接口
2441
2442
2443
  			pd.remove("KNOWLEDGE_ID");
  		}
  		List<PageData> list = questionService.listAllRandquestion(pd);
107fa3a0   孙向锦   修改试卷单选多远混合出题
2444
  		for (PageData pad : list) {
c617106f   孙向锦   添加即时测功能
2445
  			String optionContent = pad.getString("OPTION_CONTENT");
107fa3a0   孙向锦   修改试卷单选多远混合出题
2446
2447
2448
2449
  			if (optionContent != null && optionContent.startsWith("[")
  					&& optionContent.endsWith("]")) {
  				String[] options = optionContent.substring(1,
  						optionContent.length() - 1).split(",");
c617106f   孙向锦   添加即时测功能
2450
  				pad.put("OPTION_CONTENT", options);
107fa3a0   孙向锦   修改试卷单选多远混合出题
2451
2452
  			} else {
  				pad.put("OPTION_CONTENT", new String[] { optionContent });
c617106f   孙向锦   添加即时测功能
2453
2454
  			}
  		}
ce70231e   孙向锦   增加接口
2455
2456
2457
  		res.setData(list);
  		return res.toJson();
  	}
2ad7ca45   孙向锦   试卷bug修改
2458
2459
2460
2461
2462
2463
2464
2465
  
  	/**
  	 * 
  	 * @param chapterList
  	 * @param key
  	 * @return
  	 */
  	public List<String> getIds(List<PageData> chapterList, String key) {
ce70231e   孙向锦   增加接口
2466
  		List<String> ids = new ArrayList<String>();
2ad7ca45   孙向锦   试卷bug修改
2467
2468
  		if (chapterList != null && chapterList.size() > 0) {
  			for (PageData pd : chapterList) {
ce70231e   孙向锦   增加接口
2469
  				String chapterid = pd.getString(key);
2ad7ca45   孙向锦   试卷bug修改
2470
  				if (chapterid != null && !"".equals(chapterid)) {
ce70231e   孙向锦   增加接口
2471
2472
2473
  					ids.add(chapterid);
  				}
  				Object obj = pd.get("CHILDREN");
2ad7ca45   孙向锦   试卷bug修改
2474
  				if (obj != null && (obj instanceof List)) {
ce70231e   孙向锦   增加接口
2475
  					@SuppressWarnings("unchecked")
2ad7ca45   孙向锦   试卷bug修改
2476
2477
2478
  					List<PageData> list = (List<PageData>) obj;
  					List<String> ret = getIds(list, key);
  					if (ret != null && ret.size() > 0) {
ce70231e   孙向锦   增加接口
2479
2480
2481
2482
2483
  						ids.addAll(ret);
  					}
  				}
  			}
  		}
2ad7ca45   孙向锦   试卷bug修改
2484
  
ce70231e   孙向锦   增加接口
2485
  		return ids;
2ad7ca45   孙向锦   试卷bug修改
2486
  
ce70231e   孙向锦   增加接口
2487
2488
  	}
  
2ad7ca45   孙向锦   试卷bug修改
2489
2490
2491
2492
2493
  	/**
  	 * 
  	 * @return
  	 * @throws Exception
  	 */
d3d7b2ca   孙向锦   修改表格固定
2494
2495
  	@RequestMapping(value = "/tempcreateUser", produces = "application/json;charset=UTF-8")
  	@ResponseBody
ce70231e   孙向锦   增加接口
2496
  	public Object tempCreateUser() throws Exception {
d3d7b2ca   孙向锦   修改表格固定
2497
2498
2499
2500
  		PageData pd = new PageData();
  		pd = this.getPageData();
  		pd.put("ID", this.get32UUID());
  		teacherService.save(pd);
ce70231e   孙向锦   增加接口
2501
2502
2503
2504
  		pd.put("USER_ID", pd.getString("ID")); // ID 主键
  		pd.put("LAST_LOGIN", ""); // 最后登录时间
  		pd.put("IP", ""); // IP
  		pd.put("STATUS", "0"); // 状态
d3d7b2ca   孙向锦   修改表格固定
2505
  		pd.put("SKIN", "default");
ce70231e   孙向锦   增加接口
2506
  		pd.put("RIGHTS", "");
d3d7b2ca   孙向锦   修改表格固定
2507
  		pd.put("USERNAME", pd.getString("ACCOUT"));
ce70231e   孙向锦   增加接口
2508
2509
2510
2511
2512
2513
2514
  		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   孙向锦   修改表格固定
2515
  		}
ce70231e   孙向锦   增加接口
2516
2517
2518
  
  		// ID, TEACHER_ID, CLASS_ID, SUBJECT_ID, START_DATE, END_DATE, GRADE_ID,
  		// TERM_ID, REMARK
d3d7b2ca   孙向锦   修改表格固定
2519
2520
2521
2522
  		pd.put("TEACHER_ID", pd.get("ID"));
  		pd.put("CLASS_ID", "bc33389101ec46e6b7d47daa8adf58ac");
  		pd.put("SUBJECT_ID", "1");
  		pd.put("GRADE_ID", "1");
ce70231e   孙向锦   增加接口
2523
  		pd.put("TERM_ID", "0d8ea2efdef74accbd0d00e9bc07dfbb");
d3d7b2ca   孙向锦   修改表格固定
2524
  		coursemanagementService.save(pd);
ce70231e   孙向锦   增加接口
2525
  
d3d7b2ca   孙向锦   修改表格固定
2526
2527
  		return "{'res':'success'}";
  	}
2480c889   孙向锦   添加软件管理模块。对软件形成统一的管理
2528
  
2ad7ca45   孙向锦   试卷bug修改
2529
2530
2531
2532
  	/**
  	 * 
  	 * @param apiName
  	 */
ce70231e   孙向锦   增加接口
2533
  	private void event(String apiName) {
48d44272   孙向锦   添加一些action
2534
2535
2536
2537
2538
2539
2540
2541
2542
2543
2544
2545
2546
  //		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   孙向锦   增加接口
2547
2548
2549
2550
  	}
  
  	static int index = 0;
  
2ad7ca45   孙向锦   试卷bug修改
2551
2552
2553
2554
2555
  	/**
  	 * 
  	 * @param point
  	 * @param pid
  	 */
ce70231e   孙向锦   增加接口
2556
2557
2558
2559
2560
2561
2562
2563
2564
2565
2566
2567
2568
2569
2570
2571
2572
2573
2574
  	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修改
2575
2576
2577
2578
2579
  	/**
  	 * 
  	 * @return
  	 * @throws Exception
  	 */
ce70231e   孙向锦   增加接口
2580
2581
2582
2583
2584
2585
2586
2587
2588
2589
2590
2591
2592
2593
2594
2595
2596
2597
2598
2599
2600
2601
2602
2603
2604
2605
2606
2607
2608
  	@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修改
2609
2610
2611
2612
  	/**
  	 * 
  	 * @param point
  	 */
ce70231e   孙向锦   增加接口
2613
2614
2615
2616
2617
2618
2619
2620
2621
  	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   孙向锦   增加接口
2622
2623
2624
  			e.printStackTrace();
  		}
  	}
2ad7ca45   孙向锦   试卷bug修改
2625
2626
2627
2628
2629
2630
  
  	/**
  	 * 
  	 * @return
  	 * @throws Exception
  	 */
ce70231e   孙向锦   增加接口
2631
2632
2633
2634
2635
2636
2637
2638
2639
2640
  	@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修改
2641
2642
  				ResponseGson<Object> req = ResponseGson.parse(pd
  						.getJsonString());
ce70231e   孙向锦   增加接口
2643
  				Object data = req.getData();
2ad7ca45   孙向锦   试卷bug修改
2644
2645
2646
2647
2648
2649
  				if (data instanceof List) {
  					List<Object> list = (List) data;
  					for (Object obj : list) {
  						if (obj instanceof Map) {
  							Map map = (Map) obj;
  
ce70231e   孙向锦   增加接口
2650
2651
2652
  							PageData pageData = new PageData();
  							pageData.put("QUESTION_ID", map.get("id"));
  							Object cateObj = map.get("cate");
2ad7ca45   孙向锦   试卷bug修改
2653
  							if (cateObj != null) {
ce70231e   孙向锦   增加接口
2654
2655
  								String cate = cateObj.toString();
  								float catef = Float.parseFloat(cate);
2ad7ca45   孙向锦   试卷bug修改
2656
  								pageData.put("QUESTION_TYPE_ID", (int) catef);
ce70231e   孙向锦   增加接口
2657
2658
  							}
  							Object contentObj = map.get("content");
2ad7ca45   孙向锦   试卷bug修改
2659
  							if (contentObj != null) {
ce70231e   孙向锦   增加接口
2660
2661
2662
2663
2664
  								String content = contentObj.toString();
  								content = replaceWebUrl(content);
  								pageData.put("CONTENT", content);
  							}
  							Object subjectCodeObj = map.get("subjectCode");
2ad7ca45   孙向锦   试卷bug修改
2665
  							if (subjectCodeObj != null) {
ce70231e   孙向锦   增加接口
2666
  								String subjectCode = subjectCodeObj.toString();
2ad7ca45   孙向锦   试卷bug修改
2667
  								pageData.put("SUBJECT_ID", subjectCode);
ce70231e   孙向锦   增加接口
2668
2669
  							}
  							Object optionsObj = map.get("options");
2ad7ca45   孙向锦   试卷bug修改
2670
2671
2672
2673
  							if (optionsObj instanceof List) {
  								List ss = (List) optionsObj;
  								pageData.put("OPTION_CONTENT",
  										optionsObj.toString());
ce70231e   孙向锦   增加接口
2674
2675
2676
  								pageData.put("OPTION_NUM", "" + ss.size());
  							}
  							Object answersObj = map.get("answers");
2ad7ca45   孙向锦   试卷bug修改
2677
2678
  							if (answersObj instanceof List) {
  								List answers = (List) answersObj;
ce70231e   孙向锦   增加接口
2679
  								StringBuilder sb = new StringBuilder();
2ad7ca45   孙向锦   试卷bug修改
2680
  								for (Object as : answers) {
ce70231e   孙向锦   增加接口
2681
2682
2683
2684
  									sb.append(as.toString());
  								}
  								pageData.put("ANSWER", sb.toString());
  							}
2ad7ca45   孙向锦   试卷bug修改
2685
2686
  							Object difficulty = map.get("difficulty");
  							try {
ce70231e   孙向锦   增加接口
2687
2688
2689
2690
2691
2692
  								if (difficulty != null) {
  									float fdifficulty = Float
  											.parseFloat(difficulty.toString());
  									pageData.put("DIFFICULTY",
  											(int) fdifficulty);
  								}
2ad7ca45   孙向锦   试卷bug修改
2693
  							} catch (Exception ex) {
ce70231e   孙向锦   增加接口
2694
2695
2696
  								ex.printStackTrace();
  							}
  							Object discussObj = map.get("discuss");
2ad7ca45   孙向锦   试卷bug修改
2697
  							if (discussObj != null) {
ce70231e   孙向锦   增加接口
2698
2699
2700
2701
2702
  								String discuss = discussObj.toString();
  								discuss = replaceWebUrl(discuss);
  								pageData.put("REMARK", discuss);
  							}
  							Object analyseObj = map.get("analyse");
2ad7ca45   孙向锦   试卷bug修改
2703
  							if (analyseObj != null) {
ce70231e   孙向锦   增加接口
2704
2705
2706
2707
2708
  								String analyse = analyseObj.toString();
  								analyse = replaceWebUrl(analyse);
  								pageData.put("ANALYSIS", analyse);
  							}
  							Object methodObj = map.get("method");
2ad7ca45   孙向锦   试卷bug修改
2709
  							if (methodObj != null) {
ce70231e   孙向锦   增加接口
2710
2711
2712
2713
2714
2715
  								String method = methodObj.toString();
  								method = replaceWebUrl(method);
  								pageData.put("METHOD", method);
  							}
  							Object points = map.get("points");
  							StringBuilder sb = new StringBuilder();
2ad7ca45   孙向锦   试卷bug修改
2716
2717
2718
2719
2720
  							if (points instanceof List) {
  								List pointsList = (List) points;
  								for (Object pObject : pointsList) {
  									if (pObject instanceof Map) {
  										Map pMap = (Map) pObject;
ce70231e   孙向锦   增加接口
2721
2722
2723
  										sb.append(pMap.get("code")).append(",");
  									}
  								}
2ad7ca45   孙向锦   试卷bug修改
2724
2725
  
  								if (sb.toString().length() > 1) {
ce70231e   孙向锦   增加接口
2726
2727
2728
2729
2730
  									sb.deleteCharAt(sb.length() - 1);
  								}
  								pageData.put("KNOWLEDGE_ID", sb.toString());
  							}
  							pageData.put("QUESTION_FROM", "101");
2ad7ca45   孙向锦   试卷bug修改
2731
  							try {
ce70231e   孙向锦   增加接口
2732
  								questionService.save(pageData);
2ad7ca45   孙向锦   试卷bug修改
2733
2734
  							} catch (Exception e) {
  								logger.error("save fail:" + map.get("id"), e);
ce70231e   孙向锦   增加接口
2735
2736
2737
2738
2739
2740
2741
2742
2743
  							}
  						}
  					}
  				}
  			} catch (Exception e) {
  				res.setError();
  			}
  		} else {
  			res.setDataError();
3371dbc6   孙向锦   0720 版本
2744
  		}
ce70231e   孙向锦   增加接口
2745
2746
2747
  		logger.info("uploadyuncelianquestion cost time : "
  				+ (System.currentTimeMillis() - cur));
  		return res.toJson();
3371dbc6   孙向锦   0720 版本
2748
  	}
ce70231e   孙向锦   增加接口
2749
  
2ad7ca45   孙向锦   试卷bug修改
2750
2751
2752
2753
2754
2755
2756
2757
2758
2759
  	/**
  	 * 
  	 * @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   孙向锦   增加接口
2760
2761
2762
  		}
  		return content;
  	}
2ad7ca45   孙向锦   试卷bug修改
2763
2764
2765
2766
2767
2768
2769
2770
2771
  
  	/**
  	 * 
  	 * @param pd
  	 * @param methodName
  	 * @return
  	 */
  	public String getRequestKey(PageData pd, String methodName) {
  		StringBuilder key = new StringBuilder();
ce70231e   孙向锦   增加接口
2772
2773
2774
2775
2776
2777
2778
2779
2780
2781
  		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修改
2782
  
ce70231e   孙向锦   增加接口
2783
2784
  		return key.toString();
  	}
107fa3a0   孙向锦   修改试卷单选多远混合出题
2785
  
c617106f   孙向锦   添加即时测功能
2786
2787
  	/**
  	 * 根据ID,获取科目中文名称
107fa3a0   孙向锦   修改试卷单选多远混合出题
2788
  	 * 
c617106f   孙向锦   添加即时测功能
2789
2790
2791
2792
2793
2794
  	 * @param type
  	 * @return
  	 * @throws Exception
  	 */
  	@RequestMapping(value = "/subjectename", produces = "application/json;charset=UTF-8")
  	@ResponseBody
107fa3a0   孙向锦   修改试卷单选多远混合出题
2795
  	public String findSubjectEName() throws Exception {
c617106f   孙向锦   添加即时测功能
2796
2797
2798
  		PageData pageData = this.getPageData();
  		ResponseGson<String> res = new ResponseGson<String>();
  		pageData = subjectService.findById(pageData);
107fa3a0   孙向锦   修改试卷单选多远混合出题
2799
  		if (pageData != null) {
c617106f   孙向锦   添加即时测功能
2800
  			res.setData(pageData.getString("ENAME"));
107fa3a0   孙向锦   修改试卷单选多远混合出题
2801
  		} else {
c617106f   孙向锦   添加即时测功能
2802
2803
2804
2805
  			res.setDataError();
  		}
  		return res.toJson();
  	}
107fa3a0   孙向锦   修改试卷单选多远混合出题
2806
  
c617106f   孙向锦   添加即时测功能
2807
2808
  	/**
  	 * 根据ID或者科目英文名称
107fa3a0   孙向锦   修改试卷单选多远混合出题
2809
  	 * 
c617106f   孙向锦   添加即时测功能
2810
2811
2812
2813
2814
2815
  	 * @param type
  	 * @return
  	 * @throws Exception
  	 */
  	@RequestMapping(value = "/subjectcname", produces = "application/json;charset=UTF-8")
  	@ResponseBody
107fa3a0   孙向锦   修改试卷单选多远混合出题
2816
  	public String findSubjectCName() throws Exception {
c617106f   孙向锦   添加即时测功能
2817
2818
2819
  		ResponseGson<String> res = new ResponseGson<String>();
  		PageData pageData = new PageData();
  		StringBuilder sb = new StringBuilder();
107fa3a0   孙向锦   修改试卷单选多远混合出题
2820
2821
  		String type = this.getPageData().getString("ID");
  		if (type.contains(",")) {
c617106f   孙向锦   添加即时测功能
2822
2823
2824
2825
2826
2827
2828
2829
  			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   孙向锦   修改试卷单选多远混合出题
2830
2831
  			sb.delete(sb.length() - 3, sb.length());
  		} else {
c617106f   孙向锦   添加即时测功能
2832
2833
2834
2835
2836
2837
2838
2839
2840
  			pageData.put("ID", type);
  			pageData = subjectService.findById(pageData);
  			if (pageData != null) {
  				sb.append(pageData.getString("CNAME"));
  			}
  		}
  		res.setData(sb.toString());
  		return res.toJson();
  	}
107fa3a0   孙向锦   修改试卷单选多远混合出题
2841
  
c617106f   孙向锦   添加即时测功能
2842
2843
  	/**
  	 * 根据ID班级名称
107fa3a0   孙向锦   修改试卷单选多远混合出题
2844
  	 * 
c617106f   孙向锦   添加即时测功能
2845
2846
2847
2848
2849
2850
  	 * @param id
  	 * @return
  	 * @throws Exception
  	 */
  	@RequestMapping(value = "/classname", produces = "application/json;charset=UTF-8")
  	@ResponseBody
107fa3a0   孙向锦   修改试卷单选多远混合出题
2851
  	public String findClassName() throws Exception {
c617106f   孙向锦   添加即时测功能
2852
2853
2854
  		ResponseGson<String> res = new ResponseGson<String>();
  		PageData pageData = this.getPageData();
  		pageData = sclassService.findById(pageData);
107fa3a0   孙向锦   修改试卷单选多远混合出题
2855
2856
  		String className = "";
  		if (pageData != null) {
c617106f   孙向锦   添加即时测功能
2857
  			className = pageData.getString("CLASS_NAME");
107fa3a0   孙向锦   修改试卷单选多远混合出题
2858
  		} else {
c617106f   孙向锦   添加即时测功能
2859
2860
2861
2862
  			res.setDataError();
  		}
  		res.setData(className);
  		return res.toJson();
107fa3a0   孙向锦   修改试卷单选多远混合出题
2863
  
c617106f   孙向锦   添加即时测功能
2864
  	}
694fbd54   孙向锦   添加作业管理模块
2865
2866
2867
2868
2869
2870
2871
2872
2873
2874
2875
2876
2877
  	
  	/**
  	 * 获取作业列表
  	 * 
  	 * @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
2878
2879
2880
  		if(pageData.get("COMPLETE_DATE") == null){
  			pageData.put("COMPLETE_DATE", pageData.get("COMPLETE"));
  		}
416902b7   孙向锦   添加课后作业部分API
2881
  		List<PageData> list = homeworkService.qlistAll(pageData);
694fbd54   孙向锦   添加作业管理模块
2882
2883
2884
2885
  		res.setData(list);
  		return res.toJson();
  		
  	}
416902b7   孙向锦   添加课后作业部分API
2886
2887
2888
2889
2890
2891
2892
2893
2894
2895
2896
2897
2898
  	
  	/**
  	 * 获取作业详情
  	 * 
  	 * @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   孙向锦   添加上传作业接口
2899
  		pageData.put("CODE", pageData.get("HOMEWORK_ID"));
416902b7   孙向锦   添加课后作业部分API
2900
2901
2902
2903
2904
2905
2906
2907
2908
2909
2910
2911
2912
2913
2914
2915
2916
2917
2918
2919
2920
2921
2922
2923
2924
2925
2926
  		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   孙向锦   添加了报表逻辑
2927
2928
2929
2930
2931
2932
2933
2934
  			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的需求进行修改
2935
  			homePd.put("GET_MIN_SCORE", resultHomework.getGET_MIN_SCORE());
8dccad91   孙向锦   更新学生接口列表
2936
  			homePd.put("ANSWER_PERSENT", resultHomework.getANSWER_PERSENT());
27a15f6c   孙向锦   课后练bug修改
2937
  			homePd.put("COMPLETE_PERSENT", resultHomework.getCOMPLETE_PERSENT());
bd553929   孙向锦   修改接口
2938
  			homePd.put("COMPLETE_COUNT", "1");
a479f295   孙向锦   添加了报表逻辑
2939
2940
2941
2942
2943
2944
2945
  			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
2946
  					ptd.put("STUDENT_ID", ptd.get("ID"));
a479f295   孙向锦   添加了报表逻辑
2947
  					ptd.put("STUDENT_NAME", ptd.get("NAME"));
bd553929   孙向锦   修改接口
2948
  					ptd.put("HOMEWORK_REPORT_ID", this.get32UUID());
cc36e109   孙向锦   修复课后练bug
2949
  					ptd.put("STUDNET_NO", ptd.get("NUMBER"));
a479f295   孙向锦   添加了报表逻辑
2950
2951
2952
2953
2954
  					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
2955
  					ptd.put("COMPLETE_COUNT", "0");
8dccad91   孙向锦   更新学生接口列表
2956
  					ptd.put("WHETHER", "0");
a479f295   孙向锦   添加了报表逻辑
2957
2958
2959
  					ptd.put("HOMEWORK_ID", resultHomework.getHOMEWORK_ID());
  				}
  				// 2. 根据学生列表生成初始化成绩
00af725f   孙向锦   修复bug
2960
2961
2962
  				if(student.size() > 0){
  					homeworkReporkService.batchSave(student);
  				}
a479f295   孙向锦   添加了报表逻辑
2963
2964
2965
2966
2967
2968
  			}
  			List<ResultStudent> students = resultHomework.getSTUDENTS();
  			for(ResultStudent student:students){
  				// update 学生作业情况
  				PageData tpd = new PageData();
  				tpd.put("STUDENT_NAME", student.getSTUDENT_NAME());
cc36e109   孙向锦   修复课后练bug
2969
  				tpd.put("STUDNET_NO", student.getSTUDENT_NO());
8dccad91   孙向锦   更新学生接口列表
2970
  				tpd.put("STUDENT_ID", student.getSTUDENT_ID());
a479f295   孙向锦   添加了报表逻辑
2971
2972
2973
2974
2975
  				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
2976
  				tpd.put("COMPLETE_COUNT", student.getCOMPLETE_COUNT());
a479f295   孙向锦   添加了报表逻辑
2977
  				tpd.put("HOMEWORK_ID", resultHomework.getHOMEWORK_ID());
a479f295   孙向锦   添加了报表逻辑
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
3018
3019
3020
3021
3022
3023
3024
3025
3026
3027
3028
  				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信息
3029
3030
3031
  				if(student != null && student.size() > 0){
  					homeworkReporkService.batchSave(student);
  				}
a479f295   孙向锦   添加了报表逻辑
3032
3033
3034
3035
3036
3037
3038
3039
3040
3041
3042
3043
3044
3045
3046
3047
3048
3049
  			}
  			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
3050
  		}
a479f295   孙向锦   添加了报表逻辑
3051
  		
416902b7   孙向锦   添加课后作业部分API
3052
3053
3054
  		return res.toJson();
  		
  	}
107fa3a0   孙向锦   修改试卷单选多远混合出题
3055
  
757dfed6   孙向锦   样例报表
3056
3057
  	/**
  	 * 根据ID班级名称
107fa3a0   孙向锦   修改试卷单选多远混合出题
3058
  	 * 
757dfed6   孙向锦   样例报表
3059
3060
3061
3062
3063
3064
  	 * @param id
  	 * @return
  	 * @throws Exception
  	 */
  	@RequestMapping(value = "/qstudentinfo", produces = "application/json;charset=UTF-8")
  	@ResponseBody
107fa3a0   孙向锦   修改试卷单选多远混合出题
3065
  	public String qstudentinfo() throws Exception {
757dfed6   孙向锦   样例报表
3066
3067
3068
3069
3070
3071
  		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   孙向锦   修改试卷单选多远混合出题
3072
  		} else {
757dfed6   孙向锦   样例报表
3073
3074
3075
  			res.setDataError();
  		}
  		return res.toJson();
107fa3a0   孙向锦   修改试卷单选多远混合出题
3076
  
bda221f4   孙向锦   0830版本
3077
  	}
107fa3a0   孙向锦   修改试卷单选多远混合出题
3078
  
bda221f4   孙向锦   0830版本
3079
3080
  	/**
  	 * 根据ID班级名称
107fa3a0   孙向锦   修改试卷单选多远混合出题
3081
  	 * 
bda221f4   孙向锦   0830版本
3082
3083
3084
3085
3086
3087
  	 * @param id
  	 * @return
  	 * @throws Exception
  	 */
  	@RequestMapping(value = "/wrongquestion", produces = "application/json;charset=UTF-8")
  	@ResponseBody
107fa3a0   孙向锦   修改试卷单选多远混合出题
3088
  	public String wrongquestion() throws Exception {
bda221f4   孙向锦   0830版本
3089
3090
3091
3092
3093
  		ResponseGson<List<PageData>> res = new ResponseGson();
  		PageData pageData = this.getPageData();
  		List<PageData> list = v1Service.getLastWrongQuestionInfo(pageData);
  		res.setData(list);
  		return res.toJson();
107fa3a0   孙向锦   修改试卷单选多远混合出题
3094
  
757dfed6   孙向锦   样例报表
3095
  	}
107fa3a0   孙向锦   修改试卷单选多远混合出题
3096
  
227dbfbb   孙向锦   添加知识点id
3097
3098
  	/**
  	 * 根据ID班级名称
107fa3a0   孙向锦   修改试卷单选多远混合出题
3099
  	 * 
227dbfbb   孙向锦   添加知识点id
3100
3101
3102
3103
3104
3105
  	 * @param id
  	 * @return
  	 * @throws Exception
  	 */
  	@RequestMapping(value = "/printmsg", produces = "application/json;charset=UTF-8")
  	@ResponseBody
107fa3a0   孙向锦   修改试卷单选多远混合出题
3106
  	public String printmsg() throws Exception {
227dbfbb   孙向锦   添加知识点id
3107
3108
3109
  		ResponseGson<Map> res = new ResponseGson();
  		res.setData(FileUploadProgressListener.map);
  		return res.toJson();
107fa3a0   孙向锦   修改试卷单选多远混合出题
3110
  
37b828b6   孙向锦   速度监测
3111
  	}
107fa3a0   孙向锦   修改试卷单选多远混合出题
3112
  
37b828b6   孙向锦   速度监测
3113
3114
  	/**
  	 * 根据ID班级名称
107fa3a0   孙向锦   修改试卷单选多远混合出题
3115
  	 * 
37b828b6   孙向锦   速度监测
3116
3117
3118
3119
3120
3121
  	 * @param id
  	 * @return
  	 * @throws Exception
  	 */
  	@RequestMapping(value = "/printresult", produces = "application/json;charset=UTF-8")
  	@ResponseBody
107fa3a0   孙向锦   修改试卷单选多远混合出题
3122
  	public String printresult() throws Exception {
37b828b6   孙向锦   速度监测
3123
3124
3125
  		ResponseGson<Map> res = new ResponseGson();
  		res.setData(FileUploadProgressListener.result);
  		return res.toJson();
107fa3a0   孙向锦   修改试卷单选多远混合出题
3126
  
227dbfbb   孙向锦   添加知识点id
3127
  	}
107fa3a0   孙向锦   修改试卷单选多远混合出题
3128
  
757dfed6   孙向锦   样例报表
3129
3130
  	@RequestMapping(value = "/uploadfile", produces = "application/json;charset=UTF-8")
  	@ResponseBody
107fa3a0   孙向锦   修改试卷单选多远混合出题
3131
3132
3133
  	public String uploadFile(
  			@RequestParam(value = "file", required = false) MultipartFile file,
  			HttpServletRequest request) throws Exception {
757dfed6   孙向锦   样例报表
3134
3135
3136
3137
  		ResponseGson<String> res = new ResponseGson<String>();
  		if (file != null) {
  			String path = request.getSession().getServletContext()
  					.getRealPath("/uploadFiles/uploadFile/");
107fa3a0   孙向锦   修改试卷单选多远混合出题
3138
3139
  			String name = System.currentTimeMillis()
  					+ file.getOriginalFilename();
757dfed6   孙向锦   样例报表
3140
3141
3142
  			File pathFile = new File(path);
  			pathFile.mkdirs();
  			File saveFile = new File(path + File.separator + name);
107fa3a0   孙向锦   修改试卷单选多远混合出题
3143
  			if (saveFile.exists()) {
757dfed6   孙向锦   样例报表
3144
3145
3146
3147
3148
  				saveFile.delete();
  			}
  			saveFile.createNewFile();
  			file.transferTo(saveFile);
  			path = request.getContextPath();
107fa3a0   孙向锦   修改试卷单选多远混合出题
3149
3150
3151
  			String basePath = request.getScheme() + "://"
  					+ request.getServerName() + ":" + request.getServerPort()
  					+ path + "/";
757dfed6   孙向锦   样例报表
3152
  			res.setData("/uploadFiles/uploadFile/" + name);
107fa3a0   孙向锦   修改试卷单选多远混合出题
3153
  		} else {
757dfed6   孙向锦   样例报表
3154
3155
3156
3157
  			res.setDataError();
  		}
  		return res.toJson();
  	}
107fa3a0   孙向锦   修改试卷单选多远混合出题
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
3355
3356
3357
3358
3359
3360
3361
3362
3363
3364
3365
  
  	@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   孙向锦   添加其他功能
3366
  }