|
|
package com.dsideal.newUniversityExamination.selectcourse.service;
|
|
|
|
|
|
import java.util.ArrayList;
|
|
|
import java.util.HashMap;
|
|
|
import java.util.List;
|
|
|
import java.util.Map;
|
|
|
|
|
|
import com.alibaba.fastjson.JSONArray;
|
|
|
import com.alibaba.fastjson.JSONObject;
|
|
|
import com.dsideal.newUniversityExamination.selectcourse.model.CoreCourseModel;
|
|
|
import com.dsideal.newUniversityExamination.selectcourse.model.SelectCoursePlanModel;
|
|
|
import com.dsideal.newUniversityExamination.selectcourse.model.StudentApplyModel;
|
|
|
import com.dsideal.newUniversityExamination.selectcourse.util.CoreUtil;
|
|
|
import com.dsideal.newUniversityExamination.selectcourse.util.SelectCourseUtil;
|
|
|
import com.dsideal.newUniversityExamination.util.COMMON;
|
|
|
import com.dsideal.newUniversityExamination.util.Constant;
|
|
|
import com.dsideal.newUniversityExamination.util.ToolsUtil;
|
|
|
import com.jfinal.plugin.activerecord.Page;
|
|
|
import com.jfinal.plugin.activerecord.Record;
|
|
|
|
|
|
public class SelectCoursePlanService {
|
|
|
public static final SelectCoursePlanService service = new SelectCoursePlanService();
|
|
|
|
|
|
|
|
|
/*更新t_select_course_plan 的发布状态*/
|
|
|
public void updatePlanIsRelease(String planId){
|
|
|
/*本此计划下的 班级*/
|
|
|
List<Record> classList = SelectCoursePlanModel.dao.getClassListByplanId(planId);
|
|
|
if(!COMMON.isEmpty(classList)){
|
|
|
String classIds = ToolsUtil.getIds(classList, "class_id");
|
|
|
/*选择过班级 的计划s*/
|
|
|
List<Record> planList = SelectCoursePlanModel.dao.getPlanListByClassIdAndStatus(classIds, "","");
|
|
|
if(!COMMON.isEmpty(planList)){
|
|
|
/*所有计划变无效*/
|
|
|
String planIds = ToolsUtil.getIds(planList, "plan_id");
|
|
|
/*未生成报告的 - 状态 变成 8 */
|
|
|
SelectCoursePlanModel.dao.updatePlanStatus("8", planIds,"1,2,3,4");
|
|
|
/*生成报告的-状态改成 7 */
|
|
|
SelectCoursePlanModel.dao.updatePlanStatus("7", planIds,"5");
|
|
|
}
|
|
|
}
|
|
|
|
|
|
}
|
|
|
private int String2Integer(String str){
|
|
|
int value = 0 ;
|
|
|
try {
|
|
|
value = Integer.parseInt(str);
|
|
|
} catch (NumberFormatException e) {
|
|
|
e.printStackTrace();
|
|
|
}
|
|
|
return value ;
|
|
|
}
|
|
|
|
|
|
/*新增和修改选科计划*/
|
|
|
@SuppressWarnings("unchecked")
|
|
|
public JSONObject setCoursePlan(String planId, String planName, String startTime,
|
|
|
String endTime, String type, String curriculumId,
|
|
|
String maxStudentCount, String minStudentCount, String classIds,
|
|
|
String classRoomIds,String bureauId,String status,String sequenceYear,String sequenceStage,String testId,String testIndex,String subjectType,String subjects,String classRoomCount,String courseType,String isReport) {
|
|
|
Record record= new Record();
|
|
|
record.set("bureau_id", bureauId);
|
|
|
record.set("plan_name", planName);
|
|
|
record.set("start_time", startTime);
|
|
|
record.set("end_time", endTime);
|
|
|
record.set("type", type);
|
|
|
record.set("curriculum_id", curriculumId);
|
|
|
record.set("max_student_count", maxStudentCount);
|
|
|
record.set("min_student_count", minStudentCount);
|
|
|
record.set("status", COMMON.isEmpty(status)?"1":status);
|
|
|
record.set("sequence_year", sequenceYear);
|
|
|
record.set("sequence_stage", sequenceStage);
|
|
|
record.set("test_index", testIndex);
|
|
|
record.set("subject_type", subjectType);
|
|
|
record.set("subjects", subjects);
|
|
|
record.set("class_room_count", classRoomCount);
|
|
|
record.set("course_type", courseType);
|
|
|
record.set("is_report", isReport);
|
|
|
int test_id = String2Integer(testId);
|
|
|
record.set("test_id", test_id);
|
|
|
JSONObject returnJson = new JSONObject() ;
|
|
|
/*校验是否上报*/
|
|
|
if(!COMMON.isEmpty(classIds)&&"1".equals(isReport)){
|
|
|
List<Record> list = SelectCoursePlanModel.dao.getIsReportByPlanList(bureauId, classIds,planId);
|
|
|
if(!COMMON.isEmpty(list)){
|
|
|
returnJson.put("success", false);
|
|
|
returnJson.put("info", "本计划下班级已存在上报记录，不允许上报");
|
|
|
return returnJson;
|
|
|
}
|
|
|
}
|
|
|
/*校验班级是否正常*/
|
|
|
String[] classStr = classIds.split(",");
|
|
|
int [] classTypeArray = new int [classStr.length];
|
|
|
for(int i=0;i<classStr.length;i++){
|
|
|
int classType = 1;
|
|
|
classTypeArray[i] = classType;
|
|
|
}
|
|
|
String classTypes = ToolsUtil.getIds(classTypeArray) ;
|
|
|
JSONObject mapJson = SelectCourseBaseService.service.getClassInfoByClassId(classIds, classTypes, 3);
|
|
|
Map<String, Record> map = new HashMap<>();
|
|
|
map = (Map<String, Record>) mapJson.get("map");
|
|
|
boolean flag = mapJson.getBooleanValue("success");
|
|
|
if(!flag){
|
|
|
returnJson.put("info", "计划对应的班级存在无效班级，不允许操作");
|
|
|
returnJson.put("success", false);
|
|
|
return returnJson ;
|
|
|
}
|
|
|
|
|
|
/*校验计划名是否重复*/
|
|
|
List<Record> list = SelectCoursePlanModel.dao.getCoursePlanNameListYz(planName, bureauId, planId);
|
|
|
if(!COMMON.isEmpty(list)){
|
|
|
returnJson.put("success", false);
|
|
|
returnJson.put("info", "选科计划名称已存在");
|
|
|
return returnJson;
|
|
|
}else{
|
|
|
if(COMMON.isEmpty(planId)){
|
|
|
SelectCoursePlanModel.dao.saveCoursePlan(record);
|
|
|
planId = String.valueOf(record.get("id"));
|
|
|
}else{
|
|
|
record.set("plan_id", planId);
|
|
|
SelectCoursePlanModel.dao.updateCoursePlan(record);
|
|
|
}
|
|
|
}
|
|
|
/*删除之前的计划绑定的班级 和人*/
|
|
|
SelectCoursePlanModel.dao.delCoursePlanClass(planId);
|
|
|
SelectCoursePlanModel.dao. delCoursePlanClassPerson(planId);
|
|
|
/*插入班级 和学生*/
|
|
|
List<Record> batchClassList = new ArrayList<>();
|
|
|
List<Record> batchPersonList = new ArrayList<>();
|
|
|
for(int i=0;i<classStr.length;i++){
|
|
|
String classId = classStr[i];
|
|
|
int classType = classTypeArray [i];
|
|
|
String key = classId+"|"+classType;
|
|
|
Record recordOb = map.get(key);
|
|
|
Record classRecord = new Record();
|
|
|
classRecord.set("plan_id", planId);
|
|
|
classRecord.set("class_id", recordOb.get("class_id"));
|
|
|
classRecord.set("class_type", classType);
|
|
|
classRecord.set("class_name", recordOb.get("class_name"));
|
|
|
batchClassList.add(classRecord);
|
|
|
JSONArray personArray = recordOb.get("student_list");
|
|
|
for(int j = 0 ; j < personArray.size() ; j++){
|
|
|
JSONObject json = personArray.getJSONObject(j);
|
|
|
Record personRecord = new Record();
|
|
|
personRecord.set("plan_id", planId);
|
|
|
personRecord.set("class_id", json.get("class_id"));
|
|
|
personRecord.set("class_type", json.get("class_type"));
|
|
|
personRecord.set("person_id", json.get("person_id"));
|
|
|
personRecord.set("student_name", json.get("person_name"));
|
|
|
batchPersonList.add(personRecord);
|
|
|
}
|
|
|
}
|
|
|
SelectCoursePlanModel.dao.batchSavePlanClass(batchClassList);
|
|
|
SelectCoursePlanModel.dao.batchSavePlanClassPerson(batchPersonList);
|
|
|
/*查询出 不应该在本此计划有志愿的学生ids,然后删除*/
|
|
|
Record students = StudentApplyModel.dao.getDeleteStudentApplyPersonIds(planId);
|
|
|
String personIds = String.valueOf(students.get("personIds"));
|
|
|
StudentApplyModel.dao.delCourseApply(planId, personIds, "");
|
|
|
returnJson.put("success", true);
|
|
|
returnJson.put("info", "操作成功");
|
|
|
return returnJson;
|
|
|
}
|
|
|
//0 选 1 学 2 行政班
|
|
|
public List<Record> getClassListByPlanIdAndType(String planId,String type){
|
|
|
List<Record> list = new ArrayList<>();
|
|
|
Page<Record> pageRecord= getClassPageByPlanIdAndType(planId, type);
|
|
|
list = pageRecord.getList();
|
|
|
return list ;
|
|
|
}
|
|
|
/**
|
|
|
* @Description:获取未成班学生 personIds
|
|
|
* @author ：周明升
|
|
|
* @date: 2019-1-19 上午8:52:53
|
|
|
* @return: String
|
|
|
* @throws
|
|
|
*/
|
|
|
private String getNotInClassStudent(String planId){
|
|
|
String personIds = "" ;
|
|
|
List<Record> coreResultList = SelectCoursePlanModel.dao.getCoreResult(planId, "", "", "", "0", "1", "0", "0");
|
|
|
if(!COMMON.isEmpty(coreResultList)){
|
|
|
String resultId = String.valueOf(coreResultList.get(0).get("result_id"));
|
|
|
Page<Record> noClass =SelectCoursePlanModel.dao.getNotClassStudentList(resultId, planId, "999", "1");
|
|
|
List<Record> notClassStudentList = noClass.getList();
|
|
|
personIds = ToolsUtil.getIds(notClassStudentList, "person_id");
|
|
|
}
|
|
|
return personIds ;
|
|
|
}
|
|
|
|
|
|
public Page<Record> getClassPageByPlanIdAndType(String planId,String type){
|
|
|
Page<Record> pageRecord = null ;
|
|
|
if("2".equals(type)){
|
|
|
pageRecord= SelectCoursePlanModel.dao.getResultClassList(planId, "", "", "0", "", "1", "0", "","0,1", "","","0","",999,1);
|
|
|
}else if("1".equals(type)){
|
|
|
/*学考获取未成班的学生*/
|
|
|
String personIds = getNotInClassStudent(planId);
|
|
|
pageRecord = SelectCoursePlanModel.dao.getResultClassList(planId, "", "", "1", "2", "0", "0", "", "2", "","","0",personIds,999,1);
|
|
|
}else if("0".equals(type)){
|
|
|
pageRecord = SelectCoursePlanModel.dao.getResultClassList(planId, "", "", "0", "", "1", "", "", "2", "","","0","",999,1);
|
|
|
}
|
|
|
return pageRecord ;
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* Description:根据ID获取选课计划详情
|
|
|
* @author huyue
|
|
|
* @date 2018-1-19
|
|
|
*/
|
|
|
public JSONObject getPlanInfoById(String planId,String classId,String status,String personName,String pageSize,String pageNumber,String calculateType,String type){
|
|
|
//获取先科计划信息
|
|
|
JSONObject coursePlanOb = new JSONObject();
|
|
|
coursePlanOb = CoreUtil.getCoursePlanStudentCount(planId);
|
|
|
Record record = SelectCoursePlanModel.dao.getPlanInfo(planId);
|
|
|
/*获取班级List*/
|
|
|
List<Record> classList = SelectCoursePlanModel.dao.getClassListByplanId(planId);
|
|
|
String total_person_count = String.valueOf(coursePlanOb.get("total_person_count"));
|
|
|
String finish_person_count = String.valueOf(coursePlanOb.get("finish_person_count"));
|
|
|
String unfinish_person_count = String.valueOf(coursePlanOb.get("unfinish_person_count"));
|
|
|
record.set("finish_person_count", finish_person_count);
|
|
|
record.set("unfinish_person_count", Integer.parseInt(unfinish_person_count));
|
|
|
record.set("total_person_count", total_person_count);
|
|
|
|
|
|
for(Record classListRecord:classList){
|
|
|
String count1 = String.valueOf(classListRecord.get("count"));
|
|
|
classListRecord.set("student_count", count1);
|
|
|
}
|
|
|
record.set("class_list", classList );
|
|
|
/*获取学生列表*/
|
|
|
List<Record> resulList = new ArrayList<>();
|
|
|
Page<Record> pageRecord = new Page<>(resulList,Integer.parseInt(pageNumber) , Integer.parseInt(pageSize), 0, 0);
|
|
|
List<Record> records = new ArrayList<>();
|
|
|
// type = 1 没有学生列表 type = 2 学生基础班级 列表 3 学生的新班级列表
|
|
|
if("1".equals(type)){
|
|
|
|
|
|
}else if ("2".equals(type)){
|
|
|
pageRecord = SelectCoursePlanModel.dao.getStudentListByPlanId(planId, classId, status, personName, pageSize, pageNumber);
|
|
|
records = pageRecord.getList();
|
|
|
for(int i=0;i<records.size();i++){
|
|
|
Record recordStudent = records.get(i);
|
|
|
String studentId = String.valueOf(recordStudent.get("student_id"));
|
|
|
recordStudent.set("person_id", studentId);
|
|
|
//获取当前选择算法的planId
|
|
|
recordStudent.set("courseClassNameStr", "");
|
|
|
recordStudent.set("jxClassName", "未成班");
|
|
|
//获取学生第一志愿、第二志愿
|
|
|
JSONObject studnetApplyOb = CoreUtil.getStudentApply(planId,studentId);
|
|
|
boolean statusDesc = studnetApplyOb.getBooleanValue("is_exist");
|
|
|
if(statusDesc){
|
|
|
recordStudent.set("status", 0);
|
|
|
recordStudent.set("statusDesc", "已选择");
|
|
|
}else{
|
|
|
recordStudent.set("status", 1);
|
|
|
recordStudent.set("statusDesc", "未选择");
|
|
|
}
|
|
|
//查询学生一二志愿选择学科
|
|
|
recordStudent.set("firstSubject", studnetApplyOb.get("firstSubject"));
|
|
|
recordStudent.set("sedSubject",studnetApplyOb.get("sedSubject") );
|
|
|
recordStudent.set("firstSubjectId",studnetApplyOb.get("firstSubjectId") );
|
|
|
recordStudent.set("sedSubjectId", studnetApplyOb.get("sedSubjectId"));
|
|
|
}
|
|
|
}else if ("3".equals(type)){
|
|
|
pageRecord = SelectCoursePlanModel.dao.getResultClassStudentList(planId, "", "", "0", "", "1", "0", "","0,1", "",classId,"0","999","1" );
|
|
|
List<Record> studentList = pageRecord.getList();
|
|
|
Map<String,Record> studentMap = ToolsUtil.list2Map(studentList, "person_id");
|
|
|
pageRecord = SelectCoursePlanModel.dao.getStudentListByPlanId(planId, classId, status, personName, pageSize, pageNumber);
|
|
|
records = pageRecord.getList();
|
|
|
for(int i=0;i<records.size();i++){
|
|
|
Record recordStudent = records.get(i);
|
|
|
String studentId = String.valueOf(recordStudent.get("student_id"));
|
|
|
recordStudent.set("person_id", studentId);
|
|
|
Record stuOb = studentMap.get(studentId);
|
|
|
if(!COMMON.isEmpty(stuOb)){
|
|
|
String course = String.valueOf(stuOb.get("course"));
|
|
|
String jxClassName = String.valueOf(stuOb.get("teach_class_name"));
|
|
|
String courseStr = Constant.getSubjectMap().get(course);
|
|
|
recordStudent.set("courseClassNameStr", courseStr);
|
|
|
recordStudent.set("jxClassName", jxClassName);
|
|
|
recordStudent.set("calculate_type", stuOb.get("calculate_type"));
|
|
|
}else{
|
|
|
recordStudent.set("courseClassNameStr", "");
|
|
|
recordStudent.set("jxClassName", "未成班");
|
|
|
}
|
|
|
}
|
|
|
/*获取学生成绩map 获取test_id*/
|
|
|
String testId= String.valueOf(record.get("test_id")) ;
|
|
|
StudentSelectCourseService.service.addPmToStudentlist(records, planId, testId);
|
|
|
}
|
|
|
//未成班 放在后面
|
|
|
List<Record> resulListClass = new ArrayList<>();
|
|
|
for(Record recordOb: records){
|
|
|
String courseClassNameStr = recordOb.get("courseClassNameStr");
|
|
|
if(!COMMON.isEmpty(courseClassNameStr)){
|
|
|
resulList.add(recordOb);
|
|
|
}else{
|
|
|
resulListClass.add(recordOb);
|
|
|
}
|
|
|
}
|
|
|
resulList.addAll(resulListClass);
|
|
|
JSONObject resultJson = new JSONObject();
|
|
|
resultJson.put("studentList", COMMON.convertListRecord2(resulList));
|
|
|
resultJson.put("pageNumber", pageRecord.getPageNumber());
|
|
|
resultJson.put("pageSize", pageRecord.getPageSize());
|
|
|
resultJson.put("totalPage", pageRecord.getTotalPage());
|
|
|
resultJson.put("totalRow", pageRecord.getTotalRow());
|
|
|
resultJson.put("coursePlanInfo", COMMON.convertRecord2Json2(record));
|
|
|
resultJson.put("success", true);
|
|
|
return resultJson;
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* @Description: 删除选科计划
|
|
|
* @author ：周明升
|
|
|
* @date: 2018-12-25 下午4:32:26
|
|
|
* @return: String
|
|
|
* @throws
|
|
|
*/
|
|
|
public JSONObject delSelectCoursePlan(String planId,String type) {
|
|
|
//验证排课任务 是否使用
|
|
|
JSONObject resultJson = new JSONObject();
|
|
|
//1删除 2还原
|
|
|
if("2".equals(type)){
|
|
|
/*校验选科计划是否可以还原*/
|
|
|
resultJson = checkCoursePlanCanDel(planId);
|
|
|
boolean success = resultJson.getBooleanValue("success");
|
|
|
if(!success){
|
|
|
return resultJson ;
|
|
|
}
|
|
|
}
|
|
|
//获取 resultIds
|
|
|
List<Record> list = SelectCoursePlanModel.dao.getCoreResult(planId, "","", "", "", "", "","");
|
|
|
String resultIds = ToolsUtil.getIds(list, "result_id");
|
|
|
//获取班级Ids
|
|
|
Page<Record> pageRecord = SelectCoursePlanModel.dao.getResultClassList(planId, "", "", "", "", "", "", "", "", "", "","" ,"",9999, 1);
|
|
|
List<Record> classList = pageRecord.getList();
|
|
|
String classIds = ToolsUtil.getIds(classList, "class_id");
|
|
|
if(!COMMON.isEmpty(resultIds)){
|
|
|
// 删除 未成班的 学生
|
|
|
CoreCourseModel.dao.delResultNotInClass(resultIds);
|
|
|
//删除 算法分出来的班级
|
|
|
CoreCourseModel.dao.delResultClass(resultIds);
|
|
|
// 删除 算法计算出的教师剩余情况
|
|
|
CoreCourseModel.dao.delResultTeacherCount(resultIds);
|
|
|
}
|
|
|
// 删除选科 计划日志
|
|
|
SelectCoursePlanModel.dao.delSelectCoursePlanLog(planId);
|
|
|
// 删除学生志愿
|
|
|
StudentApplyModel.dao.delStudentApplyByPlanId(planId);
|
|
|
// 删除 算法结果
|
|
|
CoreCourseModel.dao.delResultCore(planId,"","","");
|
|
|
if(!COMMON.isEmpty(classIds)){
|
|
|
CoreCourseModel.dao.delResultClassPerson(classIds);
|
|
|
}
|
|
|
//还原 把同步状态改掉
|
|
|
if("2".equals(type)){
|
|
|
SelectCoursePlanModel.dao.updateCoursePlanIsRelease(planId, "0");
|
|
|
}
|
|
|
if("1".equals(type)){
|
|
|
SelectCoursePlanModel.dao.delCoursePlan(planId);
|
|
|
//删除 计划对应的班级
|
|
|
SelectCoursePlanModel.dao.delCoursePlanClass(planId);
|
|
|
//删除 计划班级对应的人
|
|
|
SelectCoursePlanModel.dao.delCoursePlanClassPerson(planId);
|
|
|
}
|
|
|
resultJson.put("info", "删除成功");
|
|
|
resultJson.put("success", true);
|
|
|
|
|
|
return resultJson;
|
|
|
}
|
|
|
private JSONObject checkCoursePlanCanDel(String planId){
|
|
|
JSONObject returnJson = new JSONObject();
|
|
|
returnJson.put("success", true);
|
|
|
/*无效计划不让还原*/
|
|
|
JSONObject planInfo = getPlanInfo(planId);
|
|
|
String status = String.valueOf(planInfo.get("status"));
|
|
|
if("7".equals(status)||"8".equals(status)){
|
|
|
returnJson.put("info", "选科计划无效，不能还原！");
|
|
|
returnJson.put("success", false);
|
|
|
return returnJson;
|
|
|
}
|
|
|
List<Record> resultList = SelectCoursePlanModel.dao.getCoreResult(planId, "","", "", "0", "", "0","0");
|
|
|
int resultLenth = 0 ;
|
|
|
if(!COMMON.isEmpty(resultList)&&resultList.size()>0){
|
|
|
resultLenth = resultList.size();
|
|
|
}
|
|
|
if(resultLenth != 3){
|
|
|
returnJson.put("info", "选科计划下走班策略报告正在生成中，不能还原！");
|
|
|
returnJson.put("success", false);
|
|
|
return returnJson;
|
|
|
}
|
|
|
return returnJson;
|
|
|
}
|
|
|
|
|
|
|
|
|
/*获取选科计划列表*/
|
|
|
public JSONObject getCoursePlanList(String bureauId, String pageNumber,
|
|
|
String pageSize, String stageId, String type, String status,
|
|
|
String planName,String isRelease) {
|
|
|
Page<Record> pageRecord = SelectCoursePlanModel.dao.getCoursePlanList(stageId, type, status, planName, bureauId, isRelease,pageSize, pageNumber);
|
|
|
List<Record> records = pageRecord.getList();
|
|
|
for(Record recordPlan:records){
|
|
|
String planId = String.valueOf(recordPlan.get("plan_id"));
|
|
|
//获取先科计划信息
|
|
|
JSONObject coursePlanOb = new JSONObject();
|
|
|
coursePlanOb = CoreUtil.getCoursePlanStudentCount(planId);
|
|
|
String total_person_count = String.valueOf(coursePlanOb.get("total_person_count"));
|
|
|
String finish_person_count = String.valueOf(coursePlanOb.get("finish_person_count"));
|
|
|
String unfinish_person_count = String.valueOf(coursePlanOb.get("unfinish_person_count"));
|
|
|
recordPlan.set("finish_person_count", finish_person_count);
|
|
|
recordPlan.set("unfinish_person_count", Integer.parseInt(unfinish_person_count));
|
|
|
recordPlan.set("total_person_count", total_person_count);
|
|
|
|
|
|
//查询已选择算法的内容，添加已分班人数，未分班人数，和算法名称
|
|
|
List<Record> classDetailList = SelectCoursePlanModel.dao.getAllStudentByPlanId(planId);
|
|
|
int inClassCount = 0;
|
|
|
int notInClassCount =0;
|
|
|
String calculateType = "";;
|
|
|
for(Record classDetailRecord:classDetailList){
|
|
|
int count = Integer.parseInt(String.valueOf(classDetailRecord.get("count")));
|
|
|
int indexs = Integer.parseInt(String.valueOf(classDetailRecord.get("indexs")));
|
|
|
if(indexs==0){
|
|
|
inClassCount = count;
|
|
|
if(!COMMON.isEmpty(classDetailRecord.get("calculate_type"))){
|
|
|
calculateType = String.valueOf(classDetailRecord.get("calculate_type"));
|
|
|
}
|
|
|
}else{
|
|
|
notInClassCount = count ;
|
|
|
}
|
|
|
}
|
|
|
recordPlan.set("inClassCount", inClassCount);
|
|
|
recordPlan.set("notInClassCount", notInClassCount);
|
|
|
recordPlan.set("calculate_type", calculateType);
|
|
|
if("0".equals(calculateType)){
|
|
|
recordPlan.set("calculate_type_name", "优先三科成班");
|
|
|
recordPlan.set("check_flag", 1);
|
|
|
}else if ("1".equals(calculateType)){
|
|
|
recordPlan.set("calculate_type_name", "定二走一");
|
|
|
recordPlan.set("check_flag", 1);
|
|
|
}else if ("2".equals(calculateType)){
|
|
|
recordPlan.set("calculate_type_name", "大走班");
|
|
|
recordPlan.set("check_flag", 1);
|
|
|
}else{
|
|
|
recordPlan.set("calculate_type_name", "还未选择算法，暂无教学班分班信息");
|
|
|
recordPlan.set("check_flag", 0);
|
|
|
}
|
|
|
|
|
|
}
|
|
|
JSONObject resultJson = new JSONObject();
|
|
|
resultJson.put("coursePlanList", COMMON.convertListRecord2(records));
|
|
|
resultJson.put("pageNumber", pageRecord.getPageNumber());
|
|
|
resultJson.put("pageSize", pageRecord.getPageSize());
|
|
|
resultJson.put("totalPage", pageRecord.getTotalPage());
|
|
|
resultJson.put("totalRow", pageRecord.getTotalRow());
|
|
|
resultJson.put("success", true);
|
|
|
return resultJson;
|
|
|
}
|
|
|
/**
|
|
|
* @Description: 清空选科计划
|
|
|
* @author ：周明升
|
|
|
* @date: 2018-12-26 上午8:53:34
|
|
|
* @return: String
|
|
|
* @throws
|
|
|
*/
|
|
|
public JSONObject delCoursePlanApply(String planId) {
|
|
|
JSONObject resultJson = new JSONObject();
|
|
|
Record record = SelectCoursePlanModel.dao.getPlanInfo(planId);
|
|
|
int status=Integer.valueOf(String.valueOf(record.get("status"))) ;
|
|
|
if(status==1){
|
|
|
resultJson.put("info", "任务尚未开始，系统暂无选科数据");
|
|
|
resultJson.put("success", false);
|
|
|
}else if(status==2){
|
|
|
resultJson.put("info", "选科计划正在进行中，请'暂停'后，再选择'清空选科结果'操作");
|
|
|
resultJson.put("success", false);
|
|
|
}else{
|
|
|
StudentApplyModel.dao.delStudentApplyByPlanId(planId);
|
|
|
resultJson.put("info", "删除成功");
|
|
|
resultJson.put("success", true);
|
|
|
}
|
|
|
return resultJson;
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* @Description: 获取计划详情
|
|
|
* @author ：周明升
|
|
|
* @date: 2018-12-26 上午8:59:15
|
|
|
* @return: String
|
|
|
* @throws
|
|
|
*/
|
|
|
public JSONObject getPlanInfo(String planId) {
|
|
|
JSONObject resultJson = new JSONObject();
|
|
|
Record record = SelectCoursePlanModel.dao.getPlanInfo(planId);
|
|
|
String planName = String.valueOf(record.get("plan_name"));
|
|
|
String startTime = String.valueOf(record.get("start_time"));
|
|
|
String endTime = String.valueOf(record.get("end_time"));
|
|
|
String type = String.valueOf(record.get("type"));
|
|
|
String curriculumId = String.valueOf(record.get("curriculum_id"));
|
|
|
String maxStudentCount = String.valueOf(record.get("max_student_count"));
|
|
|
String minStudentCount = String.valueOf(record.get("min_student_count"));
|
|
|
String sequenceYear = String.valueOf(record.get("sequence_year"));
|
|
|
String sequenceStage = String.valueOf(record.get("sequence_stage"));
|
|
|
String testId = String.valueOf(record.get("test_id"));
|
|
|
String testIndex = String.valueOf(record.get("test_index"));
|
|
|
String subjectType = String.valueOf(record.get("subject_type"));
|
|
|
String classRoomCount = String.valueOf(record.get("class_room_count"));
|
|
|
String courseType = String.valueOf(record.get("course_type"));
|
|
|
String isReport = String.valueOf(record.get("is_report"));
|
|
|
String status = String.valueOf(record.get("status"));
|
|
|
String subjects = String.valueOf(record.get("subjects"));
|
|
|
String subjectName="";
|
|
|
String [] subjectArray = subjects.split(",");
|
|
|
Map<String,String> map=Constant.getThreeSubjectMap();
|
|
|
for (int i = 0; i < subjectArray.length; i++) {
|
|
|
subjectName += map.get(subjectArray[i]);
|
|
|
if(i!=subjectArray.length-1){
|
|
|
subjectName +=",";
|
|
|
}
|
|
|
}
|
|
|
JSONArray classArr = new JSONArray();
|
|
|
List<Record> classList = SelectCoursePlanModel.dao.getClassListByplanId(planId);
|
|
|
for(Record classRecord : classList){
|
|
|
JSONObject ob = new JSONObject();
|
|
|
String classId = String.valueOf(classRecord.get("class_id"));
|
|
|
String className = String.valueOf(classRecord.get("class_name"));
|
|
|
ob.put("class_id", classId);
|
|
|
ob.put("class_name", className);
|
|
|
classArr.add(ob);
|
|
|
}
|
|
|
JSONArray roomArr = new JSONArray();
|
|
|
resultJson.put("subject_type", subjectType);
|
|
|
resultJson.put("subjects", subjects);
|
|
|
resultJson.put("subjectName", subjectName);
|
|
|
resultJson.put("class_room_count", classRoomCount);
|
|
|
resultJson.put("classArr", classArr);
|
|
|
resultJson.put("classCount", classArr.size());
|
|
|
resultJson.put("roomArr", roomArr);
|
|
|
resultJson.put("plan_id", planId);
|
|
|
resultJson.put("plan_name", planName);
|
|
|
resultJson.put("start_time", startTime.substring(0, startTime.length()-2));
|
|
|
resultJson.put("end_time", endTime.substring(0, startTime.length()-2));
|
|
|
resultJson.put("type", type);
|
|
|
resultJson.put("curriculum_id", curriculumId);
|
|
|
resultJson.put("max_student_count", maxStudentCount);
|
|
|
resultJson.put("min_student_count", minStudentCount);
|
|
|
resultJson.put("sequence_stage", sequenceStage);
|
|
|
resultJson.put("sequence_year", sequenceYear);
|
|
|
resultJson.put("test_id", testId);
|
|
|
resultJson.put("test_index", testIndex);
|
|
|
resultJson.put("course_type", courseType);
|
|
|
resultJson.put("is_report", isReport);
|
|
|
resultJson.put("status", status);
|
|
|
resultJson.put("stage_id", record.get("stage_id"));
|
|
|
resultJson.put("entrance_year", record.get("grade"));
|
|
|
resultJson.put("bureau_id", record.get("bureau_id"));
|
|
|
resultJson.put("success", true);
|
|
|
resultJson.put("info", "查询成功");
|
|
|
return resultJson;
|
|
|
}
|
|
|
|
|
|
public JSONObject saveCoursePlanStatus(String planId, String status) {
|
|
|
JSONObject resultJson= new JSONObject();
|
|
|
SelectCoursePlanModel.dao.updatePlanStatus(status, planId,"");
|
|
|
resultJson.put("info", "操作成功");
|
|
|
resultJson.put("success", true);
|
|
|
if("4".equals(status)){
|
|
|
//这直接调用service
|
|
|
CoreCourseService.service.startSelectCoursePlan(planId);
|
|
|
}
|
|
|
return resultJson;
|
|
|
}
|
|
|
private JSONObject checkTheSelectionToBegin(String planId, String status){
|
|
|
JSONObject resultJson=new JSONObject();
|
|
|
resultJson.put("success", false);
|
|
|
/*校验课程计划下数据*/
|
|
|
JSONObject planInfo = getPlanInfo(planId);
|
|
|
//校验选课开始时 是否有班级在别的选课计划下进行选课
|
|
|
if("2".equals(status)){
|
|
|
//求出当前计划的班级Ids
|
|
|
List<Record> classList = SelectCoursePlanModel.dao.getClassListByplanId(planId);
|
|
|
String classIds = ToolsUtil.getIds(classList, "class_id");
|
|
|
List<Record> planList = SelectCoursePlanModel.dao.getPlanListByClassIdAndStatus(classIds,"2,3",planId);
|
|
|
if(!COMMON.isEmpty(planList)){
|
|
|
resultJson.put("info", "存在部分班级正在选科！");
|
|
|
return resultJson ;
|
|
|
}
|
|
|
String curriculumId=String.valueOf(planInfo.get("curriculum_id"));
|
|
|
JSONObject subjectTimeJson= CurriculumPlanService.service.getSubjectTimeList(curriculumId, "1");
|
|
|
//校验 所有科目是否有课时（所有）
|
|
|
JSONArray subjectArray = subjectTimeJson.getJSONArray("subject_list");
|
|
|
JSONArray baseSubjectArray = subjectTimeJson.getJSONArray("base_subject_list");
|
|
|
baseSubjectArray.addAll(subjectArray);
|
|
|
int timeSum = 0 ;
|
|
|
for(int i = 0 ;i <baseSubjectArray.size() ; i++){
|
|
|
JSONObject json = baseSubjectArray.getJSONObject(i);
|
|
|
int time = json.getIntValue("times");
|
|
|
int timesChoice = json.getIntValue("times_choice");
|
|
|
timeSum += (time+timesChoice);
|
|
|
/*学科课时是否是100%*/
|
|
|
String percentage = json.getString("percentage");
|
|
|
if(!"100%".equals(percentage)){
|
|
|
resultJson.put("info", "部分教师没有设置课时！");
|
|
|
return resultJson ;
|
|
|
}
|
|
|
/*部分学科没有设置教师*/
|
|
|
if(COMMON.isEmpty(json.get("personNames"))){
|
|
|
resultJson.put("info", json.get("subject_name")+"..没有设置教师！");
|
|
|
return resultJson ;
|
|
|
}
|
|
|
}
|
|
|
if(timeSum == 0){
|
|
|
resultJson.put("info", "所对应的课程计划中所有科目课时为0！");
|
|
|
return resultJson ;
|
|
|
}
|
|
|
}
|
|
|
if("4".equals(status)){
|
|
|
JSONObject planInfoCount = CoreUtil.getCoursePlanStudentCount(planId);
|
|
|
long finishPersonCount = planInfoCount.getLongValue("finish_person_count");
|
|
|
if(0==finishPersonCount){
|
|
|
resultJson.put("info", "当前选科计划中没有学生进行志愿选择，不允许进行结束操作！");
|
|
|
resultJson.put("error", 1);
|
|
|
return resultJson ;
|
|
|
}
|
|
|
/*校验年级课时*/
|
|
|
String bureauId=String.valueOf(planInfo.get("bureau_id"));
|
|
|
String year=String.valueOf(planInfo.get("entrance_year"));
|
|
|
String stageId=String.valueOf(planInfo.get("stage_id"));
|
|
|
JSONObject dayJson = CourseSelectTimeService.service.getCoursetableTime(bureauId, year, stageId,"");
|
|
|
if(COMMON.isEmpty(dayJson)){
|
|
|
resultJson.put("info","未设置"+year+"年级课时！");
|
|
|
resultJson.put("error", 1);
|
|
|
return resultJson ;
|
|
|
}
|
|
|
/*查询学生志愿 是否正常*/
|
|
|
List<Record> studentList = StudentApplyModel.dao.getStudentApplyList(planId);
|
|
|
if(!COMMON.isEmpty(studentList)){
|
|
|
resultJson.put("info", "学生志愿存在异常，联系管理员！");
|
|
|
resultJson.put("error", 1);
|
|
|
return resultJson ;
|
|
|
}
|
|
|
/*校验选科计划是否是套餐模式*/
|
|
|
if(!checkSubectType(planInfo)){
|
|
|
resultJson.put("info", "部分选科志愿结果与计划不匹配，是否继续？ 选择确定，将以当前志愿结果进行分班排课，与当前选科计划不一致！");
|
|
|
resultJson.put("error", 2);
|
|
|
return resultJson ;
|
|
|
}
|
|
|
}
|
|
|
resultJson.put("success", true);
|
|
|
resultJson.put("info", Constant.SUCCESS_INFO);
|
|
|
return resultJson;
|
|
|
}
|
|
|
public void updateCoursePlanIsRelease(String planId,String IsRelease){
|
|
|
SelectCoursePlanModel.dao.updateCoursePlanIsRelease(String.valueOf(planId), IsRelease);
|
|
|
}
|
|
|
private boolean checkSubectType(JSONObject planInfo){
|
|
|
String subjectType = String.valueOf(planInfo.get("subject_type"));
|
|
|
String planId = String.valueOf(planInfo.get("plan_id"));
|
|
|
//非全科模式
|
|
|
if(!"0".equals(subjectType)){
|
|
|
String subjects = String.valueOf(planInfo.get("subjects"));
|
|
|
List<Record> list = StudentApplyModel.dao.getStudentApplyNotInSubjectIds(planId, subjects);
|
|
|
if(!COMMON.isEmpty(list)){
|
|
|
return false;
|
|
|
}
|
|
|
}
|
|
|
return true ;
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* @Description: 校验 是否存在正在发布中的 选科计划
|
|
|
* @author ：周明升
|
|
|
* @date: 2019-1-7 上午8:46:49
|
|
|
* @return: JSONObject
|
|
|
* @throws
|
|
|
*/
|
|
|
public JSONObject checkPlanExistIsRelease(String bureauId,String planId) {
|
|
|
JSONObject returnJson = new JSONObject();
|
|
|
List<Record> list = SelectCoursePlanModel.dao.getCoursePlanListByRelease(bureauId, "2");
|
|
|
if(!COMMON.isEmpty(list)){
|
|
|
returnJson.put("success", Constant.FALSE);
|
|
|
returnJson.put("info", "存在正在发布中的选科计划，不允许发布！");
|
|
|
return returnJson ;
|
|
|
}
|
|
|
// String personIds = getNotInClassStudent(planId);
|
|
|
// if(!COMMON.isEmpty(personIds)){
|
|
|
// returnJson.put("success", Constant.FALSE);
|
|
|
// returnJson.put("info", "存在未成班的学生，不允许发布");
|
|
|
// return returnJson ;
|
|
|
// }
|
|
|
returnJson.put("success", Constant.TRUE);
|
|
|
returnJson.put("info", Constant.SUCCESS_INFO);
|
|
|
return returnJson;
|
|
|
}
|
|
|
|
|
|
public JSONObject checkPlanChangeStatus(String planId, String status) {
|
|
|
JSONObject returnJson= checkTheSelectionToBegin(planId, status);
|
|
|
return returnJson;
|
|
|
}
|
|
|
|
|
|
public JSONObject getChoiceExam(String personId) {
|
|
|
return SelectCourseUtil.getChoiceExam(personId);
|
|
|
}
|
|
|
public void updateBaseClassId(List<Record> list){
|
|
|
SelectCoursePlanModel.dao.updateBaseClassId(list);
|
|
|
}
|
|
|
/**
|
|
|
* @Description: 保存发布后的班级分层信息
|
|
|
* @author ：周明升
|
|
|
* @date: 2019-2-23 下午4:19:27
|
|
|
* @return: void
|
|
|
* @throws
|
|
|
*/
|
|
|
public void inserCoursePlanClassRelease(int planId, List<Record> list) {
|
|
|
/*删除之前的发布的班级记录*/
|
|
|
SelectCoursePlanModel.dao.delCoursePlanClassRelease(planId);
|
|
|
List<Record> batchList = new ArrayList<>() ;
|
|
|
for(Record record : list ){
|
|
|
Record recordOb = new Record() ;
|
|
|
recordOb.set("plan_id", planId);
|
|
|
recordOb.set("class_id", record.get("class_id"));
|
|
|
recordOb.set("level", record.get("level"));
|
|
|
recordOb.set("base_class_id", record.get("base_class_id"));
|
|
|
recordOb.set("base_class_type", record.get("base_class_type"));
|
|
|
recordOb.set("classtype_teaching", record.get("classtype_teaching"));
|
|
|
String baseClassType = String.valueOf(record.get("base_class_type"));
|
|
|
String classtypeTeaching = String.valueOf(record.get("classtype_teaching"));
|
|
|
int classType = SelectCourseBaseService.service.getCusinessClassType(baseClassType, classtypeTeaching);
|
|
|
recordOb.set("class_type",classType);
|
|
|
batchList.add(recordOb);
|
|
|
}
|
|
|
SelectCoursePlanModel.dao.batchInserCoursePlanClassRelease(batchList);
|
|
|
}
|
|
|
|
|
|
}
|
