You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1643 lines
65 KiB
1643 lines
65 KiB
package com.dsideal.newUniversityExamination.selectcourse.service;
|
|
|
|
import com.alibaba.fastjson.JSONArray;
|
|
import com.alibaba.fastjson.JSONObject;
|
|
import com.dsideal.newUniversityExamination.selectcourse.bean.SecurityAES;
|
|
import com.dsideal.newUniversityExamination.selectcourse.model.*;
|
|
import com.dsideal.newUniversityExamination.util.*;
|
|
import com.jfinal.plugin.activerecord.Page;
|
|
import com.jfinal.plugin.activerecord.Record;
|
|
import com.jfinal.upload.UploadFile;
|
|
import org.apache.poi.hssf.usermodel.*;
|
|
|
|
import java.io.*;
|
|
import java.text.ParseException;
|
|
import java.util.*;
|
|
|
|
|
|
public class TaskService {
|
|
|
|
public static final TaskService service = new TaskService();
|
|
|
|
|
|
/**
|
|
* @Description: 新增和班级排课任务
|
|
* @author ：周明升
|
|
* @date: 2018-12-3 下午1:45:24
|
|
* @return: String
|
|
* @throws
|
|
*/
|
|
public JSONObject saveTask(String taskId,String taskName,String curriculumPlanId,String bureauId,String isOrdinary,String calculateType
|
|
,String classJson){
|
|
JSONObject returnJson = new JSONObject();
|
|
boolean success = false ;
|
|
/*校验名称*/
|
|
int length=taskName.length();
|
|
if(length>20){
|
|
returnJson.put("success", success);
|
|
returnJson.put("info", "名字超出范围");
|
|
return returnJson;
|
|
}
|
|
boolean flag = TaskModel.dao.checkTaskNames(taskName, bureauId, taskId);
|
|
if(flag){
|
|
returnJson.put("success", success);
|
|
returnJson.put("info", "排课任务名称重复！");
|
|
return returnJson;
|
|
}
|
|
/*拼接参数*/
|
|
Record record = new Record();
|
|
record.set("task_name", taskName);
|
|
record.set("curriculum_plan_id", curriculumPlanId);
|
|
record.set("bureau_id", bureauId);
|
|
record.set("is_ordinary", isOrdinary);
|
|
record.set("calculate_type", calculateType);
|
|
/*新增*/
|
|
if(COMMON.isEmpty(taskId)){
|
|
success = TaskModel.dao.saveTask(record);
|
|
String newTaskId = String.valueOf(record.get("id"));
|
|
/*保存排课任务对应的班级*/
|
|
saveTaskClass( newTaskId,calculateType,classJson);
|
|
/*保存排课任务班级对应课时*/
|
|
saveTaskclassTime(newTaskId,classJson,curriculumPlanId, bureauId,calculateType,-1);
|
|
}else{
|
|
/*更新*/
|
|
record.set("task_id", taskId);
|
|
success = TaskModel.dao.updateTask(record);
|
|
//int i = record.get("task_id");
|
|
updateTaskClass(taskId, classJson,curriculumPlanId, bureauId,calculateType);
|
|
}
|
|
return SelectCourseBaseService.service.returnJsonResult(success);
|
|
}
|
|
/**
|
|
* @Description: 保存排课任务对应的班级
|
|
* @author ：周明升
|
|
* @date: 2018-12-3 上午11:23:17
|
|
* @return: void
|
|
* @throws
|
|
*/
|
|
private void saveTaskClass(String taskId,String calculateType ,String classJson){
|
|
/*保存排课任务新的班级*/
|
|
List<Record> batchList = new ArrayList<>();
|
|
JSONObject json = new JSONObject();
|
|
if(!COMMON.isEmpty(classJson)){
|
|
json = JSONObject.parseObject(classJson);
|
|
JSONArray jsonArray = json.getJSONArray("class_list");
|
|
if(!COMMON.isEmpty(jsonArray)){
|
|
List<Record> list = ToolsUtil.JSONArray2List(jsonArray);
|
|
batchList = getSaveTaskClassList(taskId, calculateType,list);
|
|
}
|
|
}
|
|
TaskModel.dao.batchSaveTaskClass(batchList);
|
|
}
|
|
private List<Record> getSaveTaskClassList(String taskId,String calculateType ,List<Record> list){
|
|
List<Record> batchList = new ArrayList<>();
|
|
for (Record record : list) {
|
|
Record batchObj = new Record();
|
|
batchObj.set("task_id", taskId);
|
|
batchObj.set("class_id", record.get("class_id"));
|
|
batchObj.set("class_name", record.get("class_name"));
|
|
batchObj.set("class_type", record.get("class_type"));
|
|
batchObj.set("course", record.get("course"));
|
|
batchObj.set("course_type", record.get("course_type"));
|
|
batchObj.set("classtype_teaching", record.get("classtype_teaching"));
|
|
//当定二走一 选考走班的时候 默认一个分组
|
|
String groupId = String.valueOf(record.get("group_id"));
|
|
String classType = String.valueOf(record.get("class_type"));
|
|
if("1".equals(calculateType)&&"0".equals(classType)){
|
|
groupId = "1" ;
|
|
}
|
|
batchObj.set("group_id", groupId);
|
|
batchObj.set("base_class_type", record.get("base_class_type"));
|
|
batchList.add(batchObj);
|
|
}
|
|
return batchList ;
|
|
}
|
|
/**
|
|
* @param calculateType
|
|
* @param bureauId
|
|
* @param curriculumPlanId
|
|
* @Description: 更新排课任务对应的班级
|
|
* @author ：周明升
|
|
* @date: 2019-1-7 上午9:20:36
|
|
* @return: void
|
|
* @throws
|
|
*/
|
|
private void updateTaskClass(String taskId,String classJson, String curriculumPlanId, String bureauId, String calculateType){
|
|
JSONObject json = new JSONObject();
|
|
/*获取之前的排课任务班级*/
|
|
List<Record> classList = TaskModel.dao.getClassListByTaskId(taskId, "");
|
|
//要 删除的班级
|
|
List<Record> delClassList = new ArrayList<>();
|
|
// 要新增的班级
|
|
List<Record> addClassList = new ArrayList<>();
|
|
if(!COMMON.isEmpty(classJson)){
|
|
json = JSONObject.parseObject(classJson);
|
|
JSONArray jsonArray = json.getJSONArray("class_list");
|
|
if(!COMMON.isEmpty(jsonArray)){
|
|
List<Record> list = ToolsUtil.JSONArray2List(jsonArray);
|
|
Map<String, List<Record>> map = checkDelClassList(list, classList);
|
|
delClassList = map.get("del");
|
|
addClassList = map.get("add");
|
|
}
|
|
}
|
|
/*删除任务流里 相关的班级*/
|
|
delTaskFlowRelatedClass(taskId, delClassList);
|
|
/*新增班级课时*/
|
|
JSONObject classTimeJson = new JSONObject();
|
|
classTimeJson.put("class_list", COMMON.convertListRecord2(addClassList));
|
|
String classTimeStr = classTimeJson.toJSONString() ;
|
|
saveTaskclassTime(taskId,classTimeStr , curriculumPlanId, bureauId, calculateType,0);
|
|
saveTaskClass(taskId, calculateType,classTimeStr);
|
|
}
|
|
/**
|
|
* @Description: 获取班级规则
|
|
* @author ：周明升
|
|
* @date: 2019-1-7 上午11:04:38
|
|
* @return: Map<String,JSONObject>
|
|
* @throws
|
|
*/
|
|
private Map<String, JSONObject> getClassRuleList(String taskId){
|
|
JSONObject classRuleJSon = CoursetableRulesService.service.getLockClassJson(taskId, 1, 999);
|
|
JSONArray lockClassList = classRuleJSon.getJSONArray("lock_class_list");
|
|
Map<String, JSONObject> map = new HashMap<>();
|
|
for(int i = 0 ; i < lockClassList.size() ; i++){
|
|
JSONObject json = lockClassList.getJSONObject(i);
|
|
String classId = String.valueOf(json.get("class_id"));
|
|
map.put(classId, json);
|
|
}
|
|
return map ;
|
|
}
|
|
private Map<String, List<String> > getmergingMap(String taskId ,String typeSecondary){
|
|
Map<String, List<String> > mergingMap = new HashMap<>();
|
|
JSONObject mergingJson = CoursetableRulesService.service.getClassMergingJsonBySubject(typeSecondary, taskId, "", 1, 999);
|
|
JSONArray mergingArray = mergingJson.getJSONArray("class_merging_list");
|
|
for(int i = 0 ; i < mergingArray.size();i++){
|
|
JSONObject json = mergingArray.getJSONObject(i);
|
|
String regulationId = String.valueOf(json.get("regulation_id"));
|
|
JSONArray classArray = json.getJSONArray("classes_list");
|
|
for(int j = 0 ; j < classArray.size() ; j++){
|
|
JSONObject classObj = classArray.getJSONObject(j);
|
|
String classId = String.valueOf(classObj.get("class_id"));
|
|
List<String> regulationList = mergingMap.get(classId);
|
|
if(COMMON.isEmpty(regulationList)){
|
|
regulationList = new ArrayList<>();
|
|
}
|
|
regulationList.add(regulationId);
|
|
mergingMap.put(classId, regulationList);
|
|
}
|
|
}
|
|
return mergingMap ;
|
|
}
|
|
|
|
/**
|
|
* @Description: 删除任务流里 相关的班级信息
|
|
* @author ：周明升
|
|
* @date: 2019-1-7 上午9:44:06
|
|
* @return: void
|
|
*/
|
|
private void delTaskFlowRelatedClass(String taskId,List<Record> delClassList){
|
|
/*获取班级规则lISt*/
|
|
Map<String, JSONObject> map = getClassRuleList(taskId);
|
|
/*获取合班 */
|
|
Map<String, List<String> > mergingHeMapHe = getmergingMap(taskId, "41");
|
|
/*分层走班详情*/
|
|
Map<String, List<String> > mergingHeMapFen = getmergingMap(taskId, "42");
|
|
/*新合班*/
|
|
Map<String,String> advancedLayeredMap = CoursetableRulesService.service.getAdvancedLayeredMap(Integer.parseInt(taskId),43,9999,1);
|
|
for(Record record : delClassList){
|
|
String classId = String.valueOf(record.get("class_id"));
|
|
String classType = String.valueOf(record.get("class_type"));
|
|
/*删除班级课时*/
|
|
TaskModel.dao.deleteTaskclassTime(taskId,classId,classType);
|
|
/*删除班级的任课计划*/
|
|
TeachPlanModel.dao.delTeacherGoclass(taskId, classId, classType, "");
|
|
/*删除班级设置的教室*/
|
|
TaskClassRoomModel.dao.delClassRoom(taskId, "", classId, classType);
|
|
if("2".equals(classType)){
|
|
/*删除班级不授课规则*/
|
|
if(!COMMON.isEmpty(map.get(classId))){
|
|
JSONObject json = map.get(classId);
|
|
String regulationId = String.valueOf(json.get("regulation_id"));
|
|
CoursetableRulesService.service.deleteRegulation(taskId, regulationId, "2", "11");
|
|
}
|
|
/*删除走班*/
|
|
if(!COMMON.isEmpty(mergingHeMapHe.get(classId))){
|
|
List<String> regulationList = mergingHeMapHe.get(classId);
|
|
for(String regulationId : regulationList){
|
|
CoursetableRulesService.service.deleteRegulation(taskId, regulationId, "4", "41");
|
|
}
|
|
}
|
|
/*合班规则*/
|
|
if(!COMMON.isEmpty(mergingHeMapFen.get(classId))){
|
|
List<String> regulationList = mergingHeMapFen.get(classId);
|
|
for(String regulationId : regulationList){
|
|
CoursetableRulesService.service.deleteRegulation(taskId, regulationId, "4", "42");
|
|
}
|
|
}
|
|
/*新合班*/
|
|
if(!COMMON.isEmpty(advancedLayeredMap.get(classId))){
|
|
String regulationId = advancedLayeredMap.get(classId) ;
|
|
CoursetableRulesService.service.deleteRegulation(taskId, regulationId, "4", "43");
|
|
|
|
}
|
|
/*删除预排课*/
|
|
PreScheduleTimetableService.service.deleteCourseTableposition(taskId, classId, "", "", "");
|
|
}
|
|
/*删除课表*/
|
|
CourseSelectTimeModel.dao.delCourseTable(taskId, classId, classType);
|
|
/*删除课时*/
|
|
TaskModel.dao.deleteTaskclassTime(taskId, classId, classType);
|
|
/*删除绑定班级*/
|
|
TaskModel.dao.deleteTaskClass(taskId, classId,classType);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @Description: 获取要删除的班级 排课任务下
|
|
* @author ：周明升
|
|
* @date: 2019-1-7 上午9:42:27
|
|
* @return: List<Record>
|
|
* @throws
|
|
*/
|
|
private Map<String, List<Record>> checkDelClassList( List<Record> list,List<Record> classList ){
|
|
Map<String, List<Record>> Map = new HashMap<>();
|
|
List<Record> newAddLsit = new ArrayList<>();
|
|
List<Record> delClassList = new ArrayList<>();
|
|
/*新的班级列表*/
|
|
newAddLsit = getAddaListThanbList(list, classList, "class_id","class_type");
|
|
delClassList = getAddaListThanbList(classList,list , "class_id","class_type");
|
|
Map.put("add", newAddLsit);
|
|
Map.put("del", delClassList);
|
|
return Map ;
|
|
}
|
|
/**
|
|
* @Description: 计算列表aList相对于bList的增加的情况
|
|
* @author ：周明升
|
|
* @date: 2019-1-8 上午8:41:16
|
|
* @return: List<Record>
|
|
* @throws
|
|
*/
|
|
public List<Record> getAddaListThanbList(List<Record> aList, List<Record> bList,String element1 ,String element2){
|
|
List<Record> reduceaList = new ArrayList<Record>();
|
|
for (int i = 0; i < aList.size(); i++){
|
|
if(!myListContains(bList, aList.get(i), element1 , element2)){
|
|
reduceaList.add(aList.get(i));
|
|
}
|
|
}
|
|
return reduceaList;
|
|
}
|
|
|
|
private boolean myListContains(List<Record> sourceList, Record Record,String element1 ,String element2) {
|
|
if (COMMON.isEmpty(sourceList) ||COMMON.isEmpty(Record) ){
|
|
return false;
|
|
}
|
|
for (Record tip : sourceList){
|
|
if(ToolsUtil.equal(tip,Record,element1,element1)&&ToolsUtil.equal(tip,Record,element2,element2)){
|
|
return true ;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
|
|
/**
|
|
* @Description: 保存排课任务班级课时
|
|
* @author ：周明升
|
|
* @date: 2018-12-3 下午1:45:43
|
|
* @return: void
|
|
* @throws
|
|
*/
|
|
private void saveTaskclassTime(String taskId,String classJson,String curriculumPlanId,String bureauId,String calculateType,int startInt){
|
|
List<Record> batchList = new ArrayList<>();
|
|
/*获取课程计划基础课程时间*/
|
|
List<Record> subjectList = new ArrayList<>();
|
|
/*走班课时*/
|
|
List<Record> zouSubjectList = new ArrayList<>();
|
|
JSONObject subjectJson= CurriculumPlanService.service.getSubjectTimeList(curriculumPlanId, "");
|
|
JSONArray baseSubjectArray = subjectJson.getJSONArray("base_subject_list");
|
|
JSONArray subjectArray = subjectJson.getJSONArray("subject_list");
|
|
if(!COMMON.isEmpty(subjectArray)){
|
|
zouSubjectList = ToolsUtil.JSONArray2List(subjectArray);
|
|
}
|
|
if(!COMMON.isEmpty(baseSubjectArray)){
|
|
subjectList = ToolsUtil.JSONArray2List(baseSubjectArray);
|
|
}
|
|
JSONObject json = JSONObject.parseObject(classJson);
|
|
JSONArray jsonArray = json.getJSONArray("class_list");
|
|
for(int i = startInt ;i < jsonArray.size() ;i++){
|
|
String classType = "2";
|
|
JSONObject jsonOb = new JSONObject();
|
|
String [] courseArray = {};
|
|
if(-1 != i){
|
|
jsonOb = (JSONObject) jsonArray.get(i);
|
|
classType = String.valueOf(jsonOb.get("class_type"));
|
|
String course = String.valueOf(jsonOb.get("course"));
|
|
if(!COMMON.isEmpty(course)&&!"0".equals(course)){
|
|
courseArray = course.split("\\|");
|
|
}
|
|
}
|
|
if("2".equals(classType)){
|
|
addBatchClassTimeXz(batchList, subjectList, zouSubjectList, taskId, calculateType,jsonOb,courseArray,i);
|
|
}else{
|
|
addBatchClassTimejx(batchList, zouSubjectList, taskId, jsonOb,courseArray);
|
|
}
|
|
}
|
|
/*保存课时*/
|
|
TaskModel.dao.batchSaveTaskclassTime(batchList);
|
|
}
|
|
|
|
/**
|
|
* @Description: 根据学校，学段，学年 获取班级列表
|
|
* @author ：周明升
|
|
* @date: 2018-12-3 下午2:06:58
|
|
* @return: void
|
|
* @throws
|
|
*/
|
|
public String getClassList(int bureauId,int stageId,int year,int classType,int calculateType){
|
|
JSONObject returnJson = new JSONObject();
|
|
List<Record> resultList = new ArrayList<>();
|
|
int type = 2 == classType ?1:2;
|
|
JSONArray classArray = BorrowUtil.getClassInfoByType(bureauId,stageId,year,type);
|
|
if(!COMMON.isEmpty(classArray)){
|
|
for(int i=0;i<classArray.size();i++){
|
|
Record record = new Record();
|
|
JSONObject jsonOb = classArray.getJSONObject(i) ;
|
|
int classtypeTeaching = jsonOb.getIntValue("classtype_teaching") ;
|
|
record.set("class_id", jsonOb.get("class_id"));
|
|
record.set("base_class_type",jsonOb.getIntValue("class_type"));
|
|
record.set("class_name", jsonOb.get("class_name"));
|
|
record.set("stu_count", jsonOb.get("stu_count"));
|
|
record.set("course", COMMON.isEmpty(jsonOb.get("course"))?"0":jsonOb.get("course"));
|
|
String course = record.get("course");
|
|
if("0".equals(course)){
|
|
record.set("course_type",0);
|
|
}else{
|
|
int courseType = ToolsUtil.getSubCount_2(course, "|");
|
|
record.set("course_type",courseType+1);
|
|
}
|
|
record.set("classtype_teaching",classtypeTeaching);
|
|
Object groupObj = jsonOb.get("group_id");
|
|
record.set("group_id",COMMON.isEmpty(groupObj)?0:Integer.parseInt(String.valueOf(groupObj)));
|
|
record.set("class_type", classType);
|
|
/*行政班 */
|
|
if(2 == classType){
|
|
int courseType = record.get("course_type");
|
|
if(1 == calculateType && courseType != 2){
|
|
continue;
|
|
}else if(0 ==calculateType && courseType != 3){
|
|
continue;
|
|
}else{
|
|
resultList.add(record);
|
|
}
|
|
}else{
|
|
if(0 == classType && 0 == classtypeTeaching){
|
|
resultList.add(record);
|
|
}else if (1 == classType && 1 == classtypeTeaching){
|
|
resultList.add(record);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
returnJson.put("list", COMMON.convertListRecord2(resultList));
|
|
returnJson.put("success", true);
|
|
returnJson.put("info",Constant.SUCCESS_INFO);
|
|
return returnJson.toJSONString();
|
|
}
|
|
|
|
public JSONObject getClassTimeList(String taskId,String classType,String calculateType,String year,String bureauId,String stageId,String xqId){
|
|
JSONArray array = new JSONArray();
|
|
JSONObject returnJson = new JSONObject();
|
|
List<Record> resultList = new ArrayList<>();
|
|
/*课时安排*/
|
|
JSONObject dayJson = getWeek(year, bureauId, stageId,xqId);
|
|
int week = dayJson.getIntValue("week_of_class_count");
|
|
int day = dayJson.getIntValue("afternoon_of_class_count")+dayJson.getIntValue("morning_of_class_count")+dayJson.getIntValue("morning_study_count")+dayJson.getIntValue("night_study_count");
|
|
int allSection = week*day ;
|
|
/*获取行政班班级列表*/
|
|
List<Record> list = TaskModel.dao.getClassListByTaskId(taskId, classType);
|
|
/*获取行政班课时*/
|
|
List<Record> timeList = TaskModel.dao.getClassTimeList(taskId,"",classType,"","");
|
|
/*获取选考 学考最大课时*/
|
|
List<Record> allList = new ArrayList<>();
|
|
for(Record record : timeList){
|
|
String classId = String.valueOf(record.get("class_id"));
|
|
if("-1".equals(classId)){
|
|
allList.add(record);
|
|
}
|
|
}
|
|
Record allRecord =getMaxTime(allList,taskId,allSection,calculateType);
|
|
resultList.add(allRecord);
|
|
int max = allRecord.get("max");
|
|
for(int i = 0 ;i< list.size() ; i++){
|
|
Record record = list.get(i);
|
|
String classId = String.valueOf(record.get("class_id"));
|
|
List<Record> subjectList = new ArrayList<>();
|
|
int surInt = 0 ;
|
|
for(Record timeObj : timeList){
|
|
String classIdObj = String.valueOf(timeObj.get("class_id"));
|
|
if(classId.equals(classIdObj)){
|
|
Record recordOb = new Record();
|
|
recordOb.set("task_id", taskId);
|
|
recordOb.set("class_id", timeObj.get("class_id"));
|
|
recordOb.set("class_type", timeObj.get("class_type"));
|
|
recordOb.set("subject_id", timeObj.get("subject_id"));
|
|
recordOb.set("subject_name", timeObj.get("subject_name"));
|
|
recordOb.set("times", timeObj.get("times"));
|
|
recordOb.set("times_xue", COMMON.isEmpty(timeObj.get("times_xue"))?"":timeObj.get("times_xue"));
|
|
recordOb.set("edit", timeObj.get("edit"));
|
|
int edit = timeObj.get("edit");
|
|
if(1==edit){
|
|
int times = timeObj.get("times") ;
|
|
surInt += times;
|
|
}
|
|
subjectList.add(recordOb);
|
|
array.add(ToolsUtil.Record2Object(recordOb));
|
|
}
|
|
}
|
|
record.set("use_times", surInt);
|
|
record.set("max", max);
|
|
record.set("subject_list", COMMON.convertListRecord2(subjectList));
|
|
resultList.add(record);
|
|
}
|
|
returnJson.put("success", true);
|
|
returnJson.put("info", Constant.SUCCESS_INFO);
|
|
returnJson.put("list", COMMON.convertListRecord2(resultList));
|
|
return returnJson;
|
|
}
|
|
/**
|
|
* @Description: 批量改变课时
|
|
* @author ：周明升
|
|
* @date: 2018-12-4 上午9:44:50
|
|
* @return: String
|
|
* @throws
|
|
*/
|
|
public JSONObject updateTaskClassTime(String taskId,String timeList,String classType){
|
|
JSONObject returnJson = new JSONObject();
|
|
/*获取原班级课时*/
|
|
List<Record> classTimeList = TaskModel.dao.getClassTimeList(taskId, "", classType,"","");
|
|
Map<String, Integer> map = new HashMap<String, Integer>();
|
|
for(Record record : classTimeList){
|
|
int classId = record.get("class_id");
|
|
int subjectId = record.get("subject_id");
|
|
int times = record.get("times");
|
|
String key = ""+classId+subjectId ;
|
|
map.put(key, times);
|
|
}
|
|
/*要修改的班级课时*/
|
|
JSONArray allArray = new JSONArray();
|
|
JSONArray jsonArray = JSONArray.parseArray(timeList);
|
|
for(int i = 0 ; i < jsonArray.size() ;i++){
|
|
JSONObject timeOb = jsonArray.getJSONObject(i);
|
|
JSONArray subjectArray = timeOb.getJSONArray("subject_list");
|
|
allArray.addAll(subjectArray);
|
|
}
|
|
List<Record> batchList = ToolsUtil.JSONArray2List(allArray);
|
|
for(Record record : batchList){
|
|
String classId = String.valueOf(record.get("class_id"));
|
|
String subjectId = String.valueOf(record.get("subject_id")) ;
|
|
String key = classId+subjectId;
|
|
int times = record.get("times");
|
|
if(!COMMON.isEmpty(map.get(key))&×!= map.get(key)){
|
|
/*删除教师任课计划*/
|
|
TeachPlanModel.dao.delTeacherGoclass(taskId, classId,classType,subjectId);
|
|
/*删除预排课*/
|
|
PreScheduleTimetableService.service.deleteCourseTableposition(taskId, classId,subjectId, "", "");
|
|
}
|
|
if(COMMON.isEmpty(record.get("times_xue"))){
|
|
record.set("times_xue", null);
|
|
}
|
|
}
|
|
/*保存基础排课课时*/
|
|
TaskModel.dao.batchUpdateTaskclassTime(batchList);
|
|
returnJson.put("success", true);
|
|
returnJson.put("info", Constant.SUCCESS_INFO);
|
|
return returnJson;
|
|
}
|
|
|
|
public JSONObject getTaskList(Record record){
|
|
JSONObject returnJson = new JSONObject();
|
|
Page<Record> pageRecord = TaskModel.dao.getTaskList(record);
|
|
returnJson.put("curriculumPlanList", COMMON.convertListRecord2(pageRecord.getList()));
|
|
returnJson.put("pageNumber", pageRecord.getPageNumber());
|
|
returnJson.put("pageSize", pageRecord.getPageSize());
|
|
returnJson.put("totalPage", pageRecord.getTotalPage());
|
|
returnJson.put("totalRow", pageRecord.getTotalRow());
|
|
returnJson.put("success", true);
|
|
return returnJson;
|
|
}
|
|
|
|
public JSONObject getTaskInfoById(String taskId){
|
|
JSONObject returnJson = new JSONObject();
|
|
/*获取排课任务详细信息*/
|
|
Record record = new Record().set("task_id", taskId).set("pageSize", 1).set("pageNumber", 1);
|
|
Page<Record> pageRecord = TaskModel.dao.getTaskList(record);
|
|
List<Record> list = pageRecord.getList();
|
|
if(!COMMON.isEmpty(list)){
|
|
record = list.get(0);
|
|
}
|
|
/*获取班级列表*/
|
|
List<Record> xingList = new ArrayList<>();
|
|
List<Record> xuanList = new ArrayList<>();
|
|
List<Record> xueList = new ArrayList<>();
|
|
List<Record> classList = TaskModel.dao.getClassListByTaskId(taskId,"");
|
|
Object [] classListArray = {xuanList,xueList,xingList};
|
|
/*检验 当前排课任务的班级 是否还存在 （基础数据）*/
|
|
addClassList(record, classListArray, classList);
|
|
String grade = String.valueOf(record.get("grade"));
|
|
JSONObject json = checkClassIdsRelease(classList, grade);
|
|
boolean isEdit = json.getBooleanValue("success");
|
|
record.set("edit", isEdit);
|
|
returnJson.put("task_info", ToolsUtil.Record2Object(record));
|
|
returnJson.put("xing_list", COMMON.convertListRecord2(xingList));
|
|
returnJson.put("xue_list", COMMON.convertListRecord2(xueList));
|
|
returnJson.put("xuan_list", COMMON.convertListRecord2(xuanList));
|
|
returnJson.put("list", COMMON.convertListRecord2(classList));
|
|
returnJson.put("success", true);
|
|
returnJson.put("info",Constant.SUCCESS_INFO);
|
|
return returnJson;
|
|
}
|
|
private JSONObject checkClassIdsRelease(List<Record> classList,String grade){
|
|
String classIds = ToolsUtil.getIds(classList, "class_id");
|
|
String classTypes = ToolsUtil.getIds(classList, "base_class_type");
|
|
JSONObject json = MergeCourseTableService.service.checkClassIdsRelease(grade, classIds, classTypes);
|
|
return json ;
|
|
}
|
|
|
|
private void addClassList(Record record , Object [] classListArray ,List<Record> classList){
|
|
int [] classArray = {0,1,2};
|
|
for (int i = 0; i < classArray.length; i++) {
|
|
/*获取基础数据班级*/
|
|
int baseClassType = classArray[i];
|
|
for(Record recordOb : classList){
|
|
int classType = recordOb.get("class_type");
|
|
if(baseClassType == classType){
|
|
@SuppressWarnings("unchecked")
|
|
List<Record> classListObj = (List<Record>) classListArray[i];
|
|
classListObj.add(recordOb);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
public String getTimeTableClassInfoByTaskId(String taskId,String classType) {
|
|
List<Record> list = TaskModel.dao.getClassListByTaskId(taskId, classType);
|
|
return COMMON.convert2JsonStr(list);
|
|
}
|
|
|
|
public JSONObject getWeek(String year, String bureauId, String stageId,String xqId) {
|
|
JSONObject returnJson = new JSONObject();
|
|
returnJson.put("success", false);
|
|
JSONObject json = CourseSelectTimeService.service.getCoursetableTime(bureauId, year, stageId,xqId);
|
|
if(!COMMON.isEmpty(json)){
|
|
returnJson = json.getJSONObject("classInfo");
|
|
returnJson.put("success", true);
|
|
}
|
|
return returnJson ;
|
|
}
|
|
|
|
public JSONObject setTaskTime(String taskId, String timeJson) {
|
|
JSONObject returnJson = new JSONObject();
|
|
/*删除走班课时*/
|
|
TaskModel.dao.delTaskTimes(taskId);
|
|
JSONObject json = JSONObject.parseObject(timeJson);
|
|
JSONArray jsonArray = json.getJSONArray("time_list");
|
|
List<Record> batchList = new ArrayList<>();
|
|
for(int i = 0; i< jsonArray.size() ;i++){
|
|
JSONObject jsonOb = jsonArray.getJSONObject(i);
|
|
Record record = ToolsUtil.Object2Record(jsonOb);
|
|
String day = String.valueOf(record.get("day"));
|
|
String section = String.valueOf(record.get("section"));
|
|
record.set("task_id", taskId);
|
|
batchList.add(record);
|
|
/*删除预排课*/
|
|
PreScheduleTimetableService.service.deleteCourseTableposition(taskId, "", "", day, section);
|
|
}
|
|
/*插入走班课节*/
|
|
TaskModel.dao.insertTaskTime(batchList);
|
|
returnJson.put("success", true);
|
|
returnJson.put("info", "保存成功");
|
|
return returnJson ;
|
|
}
|
|
public JSONObject getTaskTime(String taskId) {
|
|
JSONObject returnJson = new JSONObject();
|
|
List<Record> list = TaskModel.dao.getTaskTimeList(taskId,"");
|
|
List<Record> timeList = new ArrayList<>();
|
|
List<Record> timeXueList = new ArrayList<>();
|
|
for(Record record :list){
|
|
int type = record.get("type");
|
|
switch (type) {
|
|
case 0:
|
|
timeList.add(record);
|
|
break;
|
|
case 1:
|
|
timeXueList.add(record);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
returnJson.put("success", true);
|
|
returnJson.put("timeStr", COMMON.convertListRecord2(timeList));
|
|
returnJson.put("timeStrXue", COMMON.convertListRecord2(timeXueList));
|
|
returnJson.put("info", Constant.SUCCESS_INFO);
|
|
return returnJson;
|
|
}
|
|
public JSONObject delTask(String taskId) {
|
|
JSONObject returnJson = new JSONObject();
|
|
/*删除排课任务*/
|
|
boolean flag = TaskModel.dao.delTask(taskId);
|
|
/*删除排课任务对应的班级*/
|
|
TaskModel.dao.deleteTaskClass(taskId,"","");
|
|
/*删除排课任务班级对应的课时*/
|
|
TaskModel.dao.deleteTaskclassTime(taskId,"","");
|
|
/*删除教师任课计划*/
|
|
TeachPlanModel.dao.delTeacherGoclass(taskId,"","","");
|
|
/*删除设置教室*/
|
|
TaskClassRoomModel.dao.delClassRoom(taskId, "","","");
|
|
/*删除规则*/
|
|
CourseTableRulesModel.dao.delAllRules(taskId);
|
|
/*删除预排课*/
|
|
PreScheduleTimetableService.service.deleteCourseTableposition(taskId, "","", "", "");
|
|
/*删除课表*/
|
|
CourseSelectTimeModel.dao.delCourseTable(taskId,"","");
|
|
//删除排课日志
|
|
TaskModel.dao.delTaskLog(taskId);
|
|
//删除排课优先级
|
|
CourseTableRulesModel.dao.delRegulationPriority(taskId);
|
|
//删除操作记录
|
|
TimetableAdjustModel.DAO.delTimetableAdjustOperationExtend(taskId,Constant.TYPE_TASK);
|
|
TimetableAdjustModel.DAO.delTimetableAdjustOperation(taskId,Constant.TYPE_TASK);
|
|
returnJson.put("success", flag);
|
|
if(flag){
|
|
returnJson.put("info", "删除成功");
|
|
}else{
|
|
returnJson.put("info", "删除失败");
|
|
}
|
|
return returnJson;
|
|
}
|
|
public JSONObject getTaskByTaskId(String taskId) {
|
|
JSONObject returnJson = new JSONObject();
|
|
/*获取排课任务详细信息*/
|
|
Record record = new Record().set("task_id", taskId).set("pageSize", 1).set("pageNumber", 1);
|
|
Page<Record> pageRecord = TaskModel.dao.getTaskList(record);
|
|
List<Record> list = pageRecord.getList();
|
|
if(!COMMON.isEmpty(list)){
|
|
record = list.get(0);
|
|
}
|
|
returnJson.put("success", true);
|
|
returnJson.put("task_info", COMMON.convertRecord2Json2(record));
|
|
returnJson.put("info", "查询成功");
|
|
return returnJson;
|
|
}
|
|
public JSONObject getTimesByTaskId(String taskId, String calculateType) {
|
|
JSONObject returnJson = new JSONObject();
|
|
/*获取选考 学考最大课时*/
|
|
List<Record> allList = TaskModel.dao.getClassTimeList(taskId,"-1","2","","");
|
|
Record allRecord =getMaxTime(allList,taskId,40,calculateType);
|
|
int maxTimes = allRecord.get("maxTimes");
|
|
int maxTimesChoice =allRecord.get("maxTimesChoice");
|
|
JSONArray jsonArray = new JSONArray();
|
|
/*是否存在学考和选考班级-------------根据分组来确定课时*/
|
|
// JSONObject classJson = getClassGroupList(taskId, "1");
|
|
// JSONArray xuanArray = classJson.getJSONArray("xuan_list");
|
|
// JSONArray xueArray = classJson.getJSONArray("xue_list");
|
|
// /*选考班级类型*/
|
|
// for(int i = 0 ; i < xuanArray.size()-1 ; i ++){
|
|
// JSONObject groupJson = new JSONObject();
|
|
// JSONObject json = xuanArray.getJSONObject(i);
|
|
// JSONArray array = json.getJSONArray("data");
|
|
// int type = Integer.parseInt(String.valueOf(json.get("type")));
|
|
// int invalid = 1 ;//无效的 分组
|
|
// if("1".equals(calculateType)){
|
|
// maxTimes = maxXuan ;
|
|
// if(0 ==i ){ // 定二走一 有效
|
|
// invalid = 0 ;
|
|
// }
|
|
// }else if (!COMMON.isEmpty(array)){
|
|
// maxTimes += maxXuan ; //不为空的时候 是有效分组
|
|
// invalid = 0 ;
|
|
// }
|
|
// groupJson = superpositionTime(invalid, type, maxXuan); //无效的 分组
|
|
// jsonArray.add(groupJson);
|
|
// }
|
|
// /*学考班级类型*/
|
|
// for(int i = 0 ; i < xueArray.size() -1; i ++){
|
|
// JSONObject json = xueArray.getJSONObject(i);
|
|
// JSONArray array = json.getJSONArray("data");
|
|
// int type = Integer.parseInt(String.valueOf(json.get("type")));
|
|
// int invalid = 1 ;//无效的 分组
|
|
// if (!COMMON.isEmpty(array)){
|
|
// maxTimesChoice += maxXue ;
|
|
// invalid = 0 ;
|
|
// }
|
|
// JSONObject groupJson = superpositionTime(invalid, type+3, maxXue);
|
|
// jsonArray.add(groupJson);
|
|
// }
|
|
returnJson.put("success", true);
|
|
returnJson.put("maxTimes", maxTimes);
|
|
returnJson.put("maxTimesChoice", maxTimesChoice);
|
|
returnJson.put("list", jsonArray);
|
|
returnJson.put("info", "查询成功");
|
|
return returnJson;
|
|
}
|
|
/**
|
|
* @Description: 以后会用到
|
|
* @author ：周明升
|
|
* @date: 2019-1-14 下午3:34:02
|
|
* @return: JSONObject
|
|
* @throws
|
|
*/
|
|
@SuppressWarnings("unused")
|
|
private JSONObject superpositionTime(int invalid ,int groupId,int maxOb){
|
|
JSONObject json = new JSONObject();
|
|
json.put("group_id", groupId);
|
|
json.put("times", maxOb);
|
|
json.put("invalid", invalid);
|
|
return json ;
|
|
}
|
|
public List<Record> getTaskTimeTable(String taskId,String type) {
|
|
List<Record> list = new ArrayList<>();
|
|
List<Record> timeList = TaskModel.dao.getTaskTimeList(taskId,type);
|
|
if(!COMMON.isEmpty(timeList)){
|
|
Record record = timeList.get(0);
|
|
String str = String.valueOf(record.get("time_table")) ;
|
|
String timeStr = str.substring(1, str.length()-1);
|
|
String [] strArray=timeStr.split(",");
|
|
if(!COMMON.isEmpty(strArray)){
|
|
for(String strObj :strArray){
|
|
String day = strObj.substring(0, 1);
|
|
String section = strObj.substring(1, strObj.length());
|
|
Record recod = new Record().set("day", day).set("section", section);
|
|
list.add(recod);
|
|
}
|
|
}
|
|
}
|
|
return list;
|
|
}
|
|
|
|
/*获取班级分组列表*/
|
|
public JSONObject getClassGroupList(String taskId,String classType) {
|
|
JSONObject returnJson = new JSONObject();
|
|
List<Record> xuanList = new ArrayList<>();
|
|
List<Record> xueList = new ArrayList<>();
|
|
List<Record> group1 = new ArrayList<>();
|
|
List<Record> group2 = new ArrayList<>();
|
|
List<Record> group3 = new ArrayList<>();
|
|
List<Record> group4 = new ArrayList<>();
|
|
List<Record> group5 = new ArrayList<>();
|
|
List<Record> group6 = new ArrayList<>();
|
|
List<Record> list = TaskModel.dao.getClassListByTaskId(taskId, classType);
|
|
for(Record record : list ){
|
|
String classTypeOb = String.valueOf(record.get("class_type"));
|
|
int groupId = record.get("group_id");
|
|
if("0".equals(classTypeOb)&&groupId==0){
|
|
groupId = -1 ;
|
|
}
|
|
switch (groupId) {
|
|
case 1:group1.add(record);
|
|
break;
|
|
case 2:group2.add(record);
|
|
break;
|
|
case 3:group3.add(record);
|
|
break;
|
|
case 4:group4.add(record);
|
|
break;
|
|
case 5:group5.add(record);
|
|
break;
|
|
case 6:group6.add(record);
|
|
break;
|
|
case 0:xueList.add(record);
|
|
break;
|
|
case -1:xuanList.add(record);
|
|
break;
|
|
default: xuanList.add(record);
|
|
break;
|
|
}
|
|
}
|
|
String [] infos = {"第一组","第二组","第三组","待分组班级"};
|
|
Object [] array = {group1,group2,group3,xuanList};
|
|
|
|
String [] xinfos = {"第一组","第二组","第三组","待分组班级"};
|
|
Object [] xarray = {group4,group5,group6,xueList};
|
|
|
|
List<Record> xuanGroupList = getGroupClassList(array, infos);
|
|
List<Record> xueGroupList = getGroupClassList(xarray, xinfos);
|
|
returnJson.put("xuan_list", COMMON.convertListRecord2(xuanGroupList));
|
|
returnJson.put("xue_list", COMMON.convertListRecord2(xueGroupList));
|
|
returnJson.put("success", Constant.SUCCESS_INFO);
|
|
return returnJson;
|
|
}
|
|
@SuppressWarnings("unchecked")
|
|
private List<Record> getGroupClassList(Object [] array,String [] infos){
|
|
List<Record> resultList = new ArrayList<>();
|
|
for (int i = 0; i < array.length; i++) {
|
|
Record record = new Record();
|
|
record.set("info", infos[i]);
|
|
record.set("type", i+1);
|
|
record.set("data", COMMON.convertListRecord2((List<Record>)array[i]));
|
|
resultList.add(record);
|
|
}
|
|
return resultList ;
|
|
}
|
|
|
|
|
|
|
|
public JSONObject saveClassGroup(String taskId, String classStr) {
|
|
JSONObject returnJson = new JSONObject();
|
|
List<Record> resultList = new ArrayList<>();
|
|
/*获取原班级的groupId*/
|
|
List<Record> classList = TaskModel.dao.getClassListByTaskId(taskId,"0,1");
|
|
Map<String, Record> map = ToolsUtil.list2Map(classList, "class_id");
|
|
/*要保存的groupId*/
|
|
JSONArray jsonArray = JSONArray.parseArray(classStr);
|
|
for(int i = 0 ;i< jsonArray.size() ;i++){
|
|
Record obj = new Record();
|
|
JSONObject jsonOb = jsonArray.getJSONObject(i);
|
|
String classId = String.valueOf(jsonOb.get("class_id"));
|
|
String classType = String.valueOf(jsonOb.get("class_type"));
|
|
String baseClassType = String.valueOf(jsonOb.get("base_class_type"));
|
|
String course = String.valueOf(jsonOb.get("course"));
|
|
String groupId = String.valueOf(jsonOb.get("group_id"));
|
|
Record record = map.get(classId);
|
|
String groupobj = String.valueOf(record.get("group_id"));
|
|
/*如果groupId 改变了*/
|
|
if(!groupId.equals(groupobj)&&!"-1".equals(groupobj)){
|
|
/*删除教师任课计划*/
|
|
TeachPlanModel.dao.delTeacherGoclass(taskId,classId,classType,course);
|
|
/*删除教室*/
|
|
TaskClassRoomModel.dao.delClassRoom(taskId, "",classId,classType);
|
|
/*删除预排课*/
|
|
PreScheduleTimetableService.service.deleteCourseTableposition(taskId, classId,course, "", "");
|
|
}
|
|
obj.set("task_id", taskId);
|
|
obj.set("class_id", classId);
|
|
obj.set("class_name", jsonOb.get("class_name"));
|
|
obj.set("class_type", classType);
|
|
obj.set("course", jsonOb.get("course"));
|
|
obj.set("course_type", jsonOb.get("course_type"));
|
|
obj.set("group_id", groupId);
|
|
obj.set("base_class_type", baseClassType);
|
|
resultList.add(obj);
|
|
}
|
|
/*更新班级group_id*/
|
|
TaskModel.dao.batchUpdateTaskClass(resultList);
|
|
returnJson.put("info", Constant.SUCCESS_INFO);
|
|
returnJson.put("success",Constant.TRUE);
|
|
return returnJson;
|
|
}
|
|
|
|
private Record getMaxTime(List<Record> list,String taskId,int allSection,String calculateType){
|
|
Record returnRecord = new Record();
|
|
returnRecord.set("class_id", -1).set("class_name", "课时").set("class_type", 2).set("course", "0");
|
|
List<Record> subjectList = new ArrayList<>();
|
|
int maxXuan = 0 ;
|
|
int maxXue = 0 ;
|
|
int surInt = 0 ;
|
|
for(Record record : list){
|
|
Record recordOb = new Record();
|
|
recordOb.set("task_id", taskId);
|
|
recordOb.set("class_id", record.get("class_id"));
|
|
recordOb.set("class_type", record.get("class_type"));
|
|
recordOb.set("subject_id", record.get("subject_id"));
|
|
recordOb.set("subject_name", record.get("subject_name"));
|
|
recordOb.set("times", record.get("times"));
|
|
recordOb.set("times_xue", COMMON.isEmpty(record.get("times_xue"))?"":record.get("times_xue"));
|
|
recordOb.set("edit", record.get("edit"));
|
|
if(!COMMON.isEmpty(record.get("times_xue"))){
|
|
int times = record.get("times");
|
|
int timesXue = record.get("times_xue");
|
|
maxXuan = maxXuan > times ? maxXuan:times;
|
|
maxXue = maxXue > timesXue ? maxXue:timesXue;
|
|
}else{
|
|
int edit = record.get("edit");
|
|
if(1==edit){
|
|
int times = record.get("times") ;
|
|
surInt += times;
|
|
}
|
|
}
|
|
subjectList.add(recordOb);
|
|
}
|
|
int max = allSection ;
|
|
int maxTimes = 0 ;
|
|
int maxTimesChoice = 0;
|
|
if("0".equals(calculateType)){
|
|
//优先三科
|
|
maxTimesChoice = maxXue*3 ;
|
|
}else if ("1".equals(calculateType)){
|
|
maxTimes = maxXuan ;
|
|
maxTimesChoice = maxXue*3 ;
|
|
}else if ("2".equals(calculateType)){
|
|
maxTimes = maxXuan*3 ;
|
|
maxTimesChoice = maxXue*3 ;
|
|
}
|
|
List<Record> xueList = TaskModel.dao.getClassListByTaskId(taskId, "1");//是否存在学考班级
|
|
if(COMMON.isEmpty(xueList)){
|
|
maxTimesChoice = 0 ;
|
|
}
|
|
max = allSection - maxTimes - maxTimesChoice ;
|
|
returnRecord.set("subject_list",COMMON.convertListRecord2(subjectList));
|
|
returnRecord.set("max_xuan", maxXuan);
|
|
returnRecord.set("max_xue", maxXue);
|
|
returnRecord.set("max", max);
|
|
returnRecord.set("use_times", surInt);
|
|
returnRecord.set("maxTimes", maxTimes);
|
|
returnRecord.set("maxTimesChoice", maxTimesChoice);
|
|
return returnRecord;
|
|
}
|
|
private void addBatchClassTimeXz(List<Record> batchList,List<Record> subjectList,List<Record> zouSubjectList,String taskId,String calculateType,JSONObject jsonOb,String [] courseArray,int i ){
|
|
for(Record subjectRecord : subjectList ){
|
|
Record recordOb = new Record();
|
|
recordOb.set("task_id", taskId);
|
|
recordOb.set("class_id", COMMON.isEmpty(jsonOb.get("class_id"))?-1:jsonOb.get("class_id"));
|
|
recordOb.set("class_type",2);
|
|
recordOb.set("subject_id", subjectRecord.get("subject_id"));
|
|
recordOb.set("times", subjectRecord.get("times"));
|
|
recordOb.set("edit", 1);
|
|
batchList.add(recordOb);
|
|
}
|
|
/*走班课程*/
|
|
for(Record subjectRecord : zouSubjectList ){
|
|
Record recordOb = new Record();
|
|
String subjectId = String.valueOf(subjectRecord.get("subject_id"));
|
|
recordOb.set("task_id", taskId);
|
|
recordOb.set("class_id", COMMON.isEmpty(jsonOb.get("class_id"))?-1:jsonOb.get("class_id"));
|
|
recordOb.set("class_type",2);
|
|
recordOb.set("subject_id", subjectRecord.get("subject_id"));
|
|
if(-1==i){
|
|
/*class_id = -1*/
|
|
recordOb.set("times", subjectRecord.get("times"));
|
|
recordOb.set("times_xue", subjectRecord.get("times_choice"));
|
|
recordOb.set("edit", 1);
|
|
}else if(ToolsUtil.arrayIncludeStr(courseArray, subjectId)&&!"2".equals(calculateType)){
|
|
recordOb.set("times", subjectRecord.get("times"));
|
|
recordOb.set("edit", 1);
|
|
}else{
|
|
recordOb.set("times", 0);
|
|
recordOb.set("edit", 0);
|
|
}
|
|
batchList.add(recordOb);
|
|
}
|
|
}
|
|
private void addBatchClassTimejx(List<Record> batchList,List<Record> zouSubjectList,String taskId,JSONObject jsonOb,String [] courseArray){
|
|
/*走班课程*/
|
|
for(Record subjectRecord : zouSubjectList ){
|
|
Record recordOb = new Record();
|
|
String subjectId = String.valueOf(subjectRecord.get("subject_id"));
|
|
recordOb.set("task_id", taskId);
|
|
recordOb.set("class_id", COMMON.isEmpty(jsonOb.get("class_id"))?-1:jsonOb.get("class_id"));
|
|
recordOb.set("class_type",jsonOb.get("class_type"));
|
|
recordOb.set("subject_id", subjectRecord.get("subject_id"));
|
|
if(ToolsUtil.arrayIncludeStr(courseArray, subjectId)){
|
|
String classType = String.valueOf(jsonOb.get("class_type"));
|
|
if("0".equals(classType)){
|
|
recordOb.set("times", subjectRecord.get("times"));
|
|
}else if("1".equals(classType)){
|
|
recordOb.set("times", subjectRecord.get("times_choice"));
|
|
}
|
|
recordOb.set("edit", 1);
|
|
batchList.add(recordOb);
|
|
break ;
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @description 排课任务发布
|
|
* @author Mr.zms
|
|
* @date 2019/5/15
|
|
* @return com.alibaba.fastjson.JSONObject
|
|
*/
|
|
public JSONObject saveTaskYearXq(Record record,String uuid ) {
|
|
boolean flag = false ;
|
|
record.set("uuid", uuid);
|
|
String bureauId = String.valueOf(record.get("bureau_id"));
|
|
String stageId = String.valueOf(record.get("stage_id"));
|
|
String year = String.valueOf(record.get("year"));
|
|
String xqId = String.valueOf(record.get("xq_id"));
|
|
String taskId = String.valueOf(record.get("task_id"));
|
|
//获取时间
|
|
Record dateRecord = CourseSelectTimeModel.dao.getCourseTableTime(bureauId,year,stageId,xqId);
|
|
int endWeek= dateRecord.getInt("week");
|
|
int startWeek = getReleaseWeek(dateRecord);
|
|
startWeek = startWeek==-1?1:(startWeek+1);
|
|
//插入结果表数据
|
|
if(!"0".equals(taskId)){
|
|
//单条发布
|
|
TaskModel.dao.insertTimetableRelease(uuid, taskId,"t_select_course_task_timetable");
|
|
TaskModel.dao.insertReleaseWeekByTaskId(taskId,uuid,startWeek,endWeek);
|
|
}else{
|
|
//获取 发布后的taskIds
|
|
Record records = MergeCourseTableModel.dao.getTimetableTaskIdsBypersonId("", uuid);
|
|
if(!COMMON.isEmpty(records)){
|
|
taskId = String.valueOf(records.get("task_id_ob"));
|
|
}
|
|
//合并发布
|
|
TaskModel.dao.insertTimetableRelease(uuid, "","t_select_course_task_timetable_merge");
|
|
TaskModel.dao.insertReleaseWeekByTaskId("",uuid,startWeek,endWeek);
|
|
MergeCourseTableModel.dao.delTimetableMerge(uuid);
|
|
MergeCourseTableModel.dao.delTimetableRoom(uuid, "", "");
|
|
}
|
|
|
|
//删除操作记录
|
|
TimetableAdjustModel.DAO.delTimetableAdjustOperationExtend(taskId,Constant.TYPE_TASK);
|
|
TimetableAdjustModel.DAO.delTimetableAdjustOperation(taskId,Constant.TYPE_TASK);
|
|
//发布课表的 课时 插入t_select_week_of_class_uuid
|
|
saveWeekOfClassUuid(uuid, bureauId, year, stageId,xqId);
|
|
// 新合班规则保存
|
|
//TaskModel.dao.saveClassMergingStudent(uuid,taskId);
|
|
saveClassMergingStudent(uuid,taskId,startWeek,endWeek);
|
|
//查询之前的发布记录
|
|
List<Record> taskList = TaskModel.dao.getTaskYearXq(bureauId, xqId, year, stageId);
|
|
if(COMMON.isEmpty(taskList)){
|
|
flag = TaskModel.dao.saveTaskYearXq(record);
|
|
}else{
|
|
Record recordTask = taskList.get(0);
|
|
//获取之前发布的uuid
|
|
String uuidOther = recordTask.get("uuid");
|
|
//调代课任务- 无效
|
|
updateAdjustRecord2invalid(record);
|
|
//更新发布记录表
|
|
record.set("id", String.valueOf(recordTask.get("id")));
|
|
flag=TaskModel.dao.updateTaskYearXq(record);
|
|
//取已经发布的 状态改成未发布
|
|
String taskIds = TaskModel.dao.getTaskIdsFromTimetableRelease(uuidOther);
|
|
if(!COMMON.isEmpty(taskIds)){
|
|
TaskModel.dao.updateTaskisRelease(0,taskIds);
|
|
}
|
|
/*删除之前的发布的课表数据*/
|
|
TaskModel.dao.delTimeTableRelease(uuidOther);
|
|
/*删除课表对应的课时*/
|
|
TaskModel.dao.delWeekOfClassUuid(uuidOther);
|
|
/*删除之前调课的课表*/
|
|
TaskModel.dao.delReleaseCourseTableBetweenWeek(uuidOther,String.valueOf(startWeek),String.valueOf(endWeek));
|
|
//原来的课表uuid刷新
|
|
TaskModel.dao.updateReleaseWeekUuid(uuid,uuidOther);
|
|
//删除之前高级合班学生数据
|
|
TaskModel.dao.delMergingStudent(uuidOther,startWeek,endWeek);
|
|
}
|
|
//排课任务 改成 发布状态
|
|
TaskModel.dao.updateTaskisRelease(1,taskId);
|
|
return SelectCourseBaseService.service.returnJsonResult(flag);
|
|
}
|
|
|
|
private void saveClassMergingStudent(String uuid ,String taskId,int startWeek,int endWeek){
|
|
TaskModel.dao.saveClassMergingStudent(uuid,taskId,startWeek,endWeek);
|
|
}
|
|
/**
|
|
* @description 更新调代课任务 变成无效
|
|
* @author Mr.zms
|
|
* @date 2019/9/3
|
|
* @return void
|
|
*/
|
|
private void updateAdjustRecord2invalid(Record record){
|
|
int bureauId = Integer.parseInt(String.valueOf(record.get("bureau_id")));
|
|
String stageId = String.valueOf(record.get("stage_id"));
|
|
String year = String.valueOf(record.get("year"));
|
|
String xqId = String.valueOf(record.get("xq_id"));
|
|
Page<Record> page = TimetableAdjustModel.DAO.getTimetableAdjustRecordList(-1,bureauId,-1,-1,9999, 1);
|
|
List<Record> list = page.getList();
|
|
List<String> idList = new ArrayList<>();
|
|
//遍历调代课任务
|
|
for (Record record1 : list) {
|
|
// 只有发布当前学期 才生效
|
|
String xqId1 = String.valueOf(record1.get("xq_id"));
|
|
if(!xqId.equals(xqId1)){
|
|
continue;
|
|
}
|
|
String id = String.valueOf(record1.get("id"));
|
|
// 如果学段为空 变成无效
|
|
if(COMMON.isEmpty(record1.get("stage_id"))){
|
|
idList.add(id);
|
|
continue;
|
|
}
|
|
// 学段相等
|
|
String stageId1 = String.valueOf(record1.get("stage_id"));
|
|
if(stageId.equals(stageId1)){
|
|
//如果学年为空 变成无效
|
|
if(COMMON.isEmpty(record1.get("year"))){
|
|
idList.add(id);
|
|
continue;
|
|
}
|
|
// 如果学年相等 变成无效
|
|
String year1 = String.valueOf(record1.get("year"));
|
|
if(year.equals(year1)){
|
|
idList.add(id);
|
|
}
|
|
}
|
|
}
|
|
if(!COMMON.isEmpty(idList)){
|
|
String [] strArr = new String[idList.size()];
|
|
idList.toArray(strArr);
|
|
String ids = ToolsUtil.getIds(strArr);
|
|
TimetableAdjustModel.DAO.updateAdjustRecord(ids,"","4","1,2");
|
|
//删除调课操作记录
|
|
TimetableAdjustModel.DAO.delTimetableAdjustOperationExtend(ids,Constant.TYPE_ADJUST);
|
|
TimetableAdjustModel.DAO.delTimetableAdjustOperation(ids,Constant.TYPE_ADJUST);
|
|
//删除代课操作记录
|
|
TimetableAdjustModel.DAO.delTimetableAdjustOperationExtend(ids,Constant.TYPE_ABSENT);
|
|
TimetableAdjustModel.DAO.delTimetableAdjustOperation(ids,Constant.TYPE_ABSENT);
|
|
}
|
|
}
|
|
/**
|
|
* @description 获取当前周
|
|
* @author Mr.zms
|
|
* @date 2019/8/12
|
|
* @return int
|
|
*/
|
|
public int getReleaseWeek(Record record ){
|
|
if(COMMON.isEmpty(record.get("start_date"))){
|
|
return -1 ;
|
|
}
|
|
int startWeek = -1 ;
|
|
try {
|
|
//开始日期
|
|
Date startDay = DateUtils.parse(String.valueOf(record.get("start_date")),DateUtils.FORMAT_YEAR_MONTH_DAY);
|
|
Date monday = DateUtils.getDateOfWeekDay(startDay,1);
|
|
Date endDay = DateUtils.getDateOfWeekDay(new Date(),1);
|
|
//当前日期的周1 - 开学日期的周1
|
|
float datDiff = DateUtils.dayDiff(endDay,monday);
|
|
if(datDiff >= 0 ){
|
|
//获取当前周
|
|
startWeek = (int)(datDiff/7)+1;
|
|
}
|
|
} catch (ParseException e) {
|
|
e.printStackTrace();
|
|
}
|
|
return startWeek ;
|
|
}
|
|
|
|
public void saveWeekOfClassUuid(String uuid,String bureauId,String year,String stageId,String xqId){
|
|
Record courseTime = CourseSelectTimeModel.dao.getCourseTableTime(bureauId,year,stageId,xqId);
|
|
Record recordTime = new Record().set("uuid", uuid).set("week_of_class_count", courseTime.get("week_of_class_count"))
|
|
.set("morning_of_class_count", courseTime.get("morning_of_class_count"))
|
|
.set("afternoon_of_class_count", courseTime.get("afternoon_of_class_count"))
|
|
.set("start_date", courseTime.get("start_date"))
|
|
.set("week", courseTime.get("week")).set("morning_study_count",courseTime.get("morning_study_count")).set("night_study_count",courseTime.get("night_study_count"));
|
|
TaskModel.dao.saveWeekOfClassUuid(recordTime);
|
|
}
|
|
public JSONObject checkStartStudyTask(String taskId, String calculateType) {
|
|
JSONObject returnJson = new JSONObject();
|
|
JSONObject taskJson = TaskService.service.getTaskByTaskId(taskId);
|
|
JSONObject taskInfo = taskJson.getJSONObject("task_info");
|
|
JSONObject bean = taskInfo.getJSONObject("bean");
|
|
boolean flag = true ;
|
|
returnJson.put("success", true);
|
|
returnJson.put("info", "成功");
|
|
//校验课时安排
|
|
if(!checkStartTaskTime(bean)){
|
|
returnJson.put("info", "当前排课任务未设置课时安排。");
|
|
returnJson.put("success", flag);
|
|
}
|
|
/*验证排课任务是否是进行中*/
|
|
flag = checkStartTaskStatus(bean);
|
|
if(!flag){
|
|
returnJson.put("info", "当前排课任务进行中，不允许开启排课。");
|
|
returnJson.put("success", flag);
|
|
}
|
|
/*如果是普通排课 暂时不校验*/
|
|
if("4".equals(calculateType)){
|
|
return returnJson ;
|
|
}
|
|
/*校验走班课时*/
|
|
flag = checkStartTaskTime( taskId, calculateType);
|
|
if(!flag){
|
|
returnJson.put("info", "走班课时为空，不允许开启排课。");
|
|
returnJson.put("success", flag);
|
|
return returnJson ;
|
|
}
|
|
/*校验是否有带分组*/
|
|
flag = checkStartTaskClass(taskId, calculateType);
|
|
if(!flag){
|
|
returnJson.put("info", "存在待分组班级，不允许开启排课。");
|
|
returnJson.put("success", flag);
|
|
}
|
|
return returnJson;
|
|
}
|
|
/**
|
|
* @Description: 校验排课任务 走班课时
|
|
* @author ：周明升
|
|
* @date: 2019-1-17 下午3:53:25
|
|
* @return: boolean
|
|
* @throws
|
|
*/
|
|
private boolean checkStartTaskTime(String taskId,String calculateType){
|
|
boolean flag = true ;
|
|
List<Record> timeList = TaskModel.dao.getTaskTimeList(taskId,"");
|
|
JSONObject timeJson = getTimesByTaskId(taskId, calculateType);
|
|
int time = Integer.parseInt(String.valueOf(timeJson.get("maxTimes")));
|
|
int choice = Integer.parseInt(String.valueOf(timeJson.get("maxTimesChoice")));
|
|
int allTime = time + choice ;
|
|
if(COMMON.isEmpty(timeList)&&0 != allTime){
|
|
flag = false ;
|
|
}
|
|
return flag ;
|
|
}
|
|
/**
|
|
* @Description: 校验排课任务 班级分组
|
|
* @author ：周明升
|
|
* @date: 2019-1-17 下午3:53:44
|
|
* @return: boolean
|
|
* @throws
|
|
*/
|
|
private boolean checkStartTaskClass(String taskId,String calculateType){
|
|
boolean flag = true ;
|
|
/*校验是否有带分组*/
|
|
String classType = "1" ; //默认学考
|
|
if("2".equals(calculateType)){
|
|
classType = "0,1";
|
|
}else if("5".equals(calculateType)){// 这个是 定四走二
|
|
return flag ;
|
|
}
|
|
List<Record> classList = TaskModel.dao.getClassListByTaskId(taskId, classType);
|
|
for(Record record : classList){
|
|
String groupId = String.valueOf(record.get("group_id"));
|
|
if("0".equals(groupId)){
|
|
flag = false ;
|
|
return flag ;
|
|
}
|
|
}
|
|
return flag ;
|
|
}
|
|
private boolean checkStartTaskStatus(JSONObject bean){
|
|
/*验证排课任务是否是进行中*/
|
|
int status = bean.getIntValue("status");
|
|
if(1 == status ){
|
|
return false;
|
|
}
|
|
return true ;
|
|
}
|
|
private boolean checkStartTaskTime(JSONObject bean){
|
|
String bureauId = String.valueOf(bean.get("bureau_id"));
|
|
String year = String.valueOf(bean.get("grade"));
|
|
String stageId = String.valueOf(bean.get("stage_id"));
|
|
String xqId = String.valueOf(bean.get("xq_id"));
|
|
Record weekOb = CourseSelectTimeModel.dao.getCourseTableTime(bureauId, year, stageId,xqId);
|
|
if(COMMON.isEmpty(weekOb)){
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
/**
|
|
* @Description: 获取发布后的班级列表
|
|
* @author ：周明升
|
|
* @date: 2019-1-18 上午10:05:08
|
|
* @return: JSONObject
|
|
* @throws
|
|
*/
|
|
public JSONObject getReleasePlanClassList(String planId,String bureauId,String stageId,String year,String calculateType) {
|
|
JSONObject returnJson = new JSONObject();
|
|
List<Record> classList = TaskModel.dao.getReleasePlanClassList(planId);
|
|
List<Record> xingList = new ArrayList<>();
|
|
List<Record> xuanList = new ArrayList<>();
|
|
List<Record> xueList = new ArrayList<>();
|
|
Object [] classListArray = {xuanList,xueList,xingList};
|
|
/*检验 当前排课任务的班级 是否还存在 （基础数据）*/
|
|
addTaskClassByPlan(bureauId,stageId,year, calculateType,classListArray, classList);
|
|
int sumLength = classList.size();
|
|
int legth = xingList.size() + xuanList.size() + xueList.size();
|
|
if(sumLength != legth||sumLength == 0){
|
|
returnJson.put("info", "该选科计划下基础数据信息已发生变动，不可选择！");
|
|
returnJson.put("success", false);
|
|
return returnJson ;
|
|
}
|
|
returnJson.put("xing_list", COMMON.convertListRecord2(xingList));
|
|
returnJson.put("xue_list", COMMON.convertListRecord2(xueList));
|
|
returnJson.put("xuan_list", COMMON.convertListRecord2(xuanList));
|
|
returnJson.put("info", "查询成功");
|
|
returnJson.put("success", true);
|
|
return returnJson;
|
|
}
|
|
private void addTaskClassByPlan(String bureauId, String stageId, String year,String calculateType,
|
|
Object[] classListArray, List<Record> classList) {
|
|
int [] classArray = {0,1,2};
|
|
for (int i = 0; i < classArray.length; i++) {
|
|
/*获取基础数据班级*/
|
|
int baseClassType = classArray[i];
|
|
String strXing = getClassList(Integer.parseInt(bureauId), Integer.parseInt(stageId), Integer.parseInt(year), baseClassType, Integer.parseInt(calculateType));
|
|
JSONArray xingJsonArray = JSONObject.parseObject(strXing).getJSONArray("list");
|
|
List<Record> xingclassList = ToolsUtil.JSONArray2List(xingJsonArray);
|
|
for(Record record : xingclassList){
|
|
String classId = String.valueOf(record.get("class_id"));
|
|
int baseClassTypeNew = Integer.parseInt(String.valueOf(record.get("base_class_type")));
|
|
for(Record classOb : classList){
|
|
int classType = Integer.parseInt(String.valueOf(classOb.get("class_type")));
|
|
String classIdob = String.valueOf(classOb.get("class_id"));
|
|
if(baseClassTypeNew == classType&&classId.equals(classIdob)){
|
|
@SuppressWarnings("unchecked")
|
|
List<Record> classListObj = (List<Record>) classListArray[i];
|
|
classListObj.add(classOb);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @description 获取班级的走班课程
|
|
* @author Mr.zms
|
|
* @date 2019/4/15
|
|
* @return com.alibaba.fastjson.JSONObject
|
|
*/
|
|
public JSONObject getClassGoCourse(String taskId, String classId,String classType) {
|
|
JSONObject returnJson = new JSONObject();
|
|
/*获取行政班课时*/
|
|
List<Record> timeList = TaskModel.dao.getClassTimeList(taskId,classId,classType,"","1");
|
|
returnJson.put("success",true);
|
|
returnJson.put("list",COMMON.convertListRecord2(timeList));
|
|
return returnJson ;
|
|
}
|
|
|
|
public HSSFWorkbook exportClassTimeExcel(String taskId,String classType) {
|
|
HSSFWorkbook wb = new HSSFWorkbook();
|
|
HSSFSheet sheet = wb.createSheet("课程课时");
|
|
sheet.protectSheet("edit");
|
|
HSSFCellStyle unLockCellStyle = wb.createCellStyle();
|
|
unLockCellStyle.setLocked(false);
|
|
//获取行政班班级列表
|
|
Record recordOb = new Record().set("class_id",-1).set("class_name","班级\\课程");
|
|
List<Record> list = TaskModel.dao.getClassListByTaskId(taskId, classType);
|
|
list.add(0,recordOb);
|
|
//获取行政班课时
|
|
List<Record> timeList = TaskModel.dao.getClassTimeList(taskId,"",classType,"","");
|
|
Map<String,Record> map = getClassSubjectTimeMap(timeList);
|
|
List<Record> subjectList = TaskModel.dao.getClassTimeList(taskId,"-1",classType,"","1");
|
|
for (int i = 0; i < list.size(); i++) {
|
|
Record record = list.get(i);
|
|
HSSFRow row = sheet.createRow(i);
|
|
String classId = String.valueOf(record.get("class_id"));
|
|
String className = String.valueOf(record.get("class_name"));
|
|
HSSFCell headCell = row.createCell(0);
|
|
headCell.setCellValue(className);
|
|
for (int i1 = 0; i1 <subjectList.size(); i1++) {
|
|
Record subject = subjectList.get(i1);
|
|
String subjectId = String.valueOf(subject.get("subject_id"));
|
|
String key = classId+"|"+subjectId;
|
|
HSSFCell cell = row.createCell(i1+1);
|
|
if("-1".equals(classId)){
|
|
String subjectName = String.valueOf(subjectList.get(i1).get("subject_name"));
|
|
cell.setCellValue(subjectName);
|
|
}else{
|
|
if(!COMMON.isEmpty( map.get(key))){
|
|
Record record1 = map.get(key);
|
|
int times = record1.get("times");
|
|
int edit =record1.get("edit");
|
|
if(1==edit){
|
|
cell.setCellValue(times);
|
|
cell.setCellStyle(unLockCellStyle);
|
|
}else {
|
|
cell.setCellValue("-");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return wb;
|
|
}
|
|
|
|
Map<String,Record> getClassSubjectTimeMap(List<Record> timeList){
|
|
Map<String,Record> map = new HashMap<>();
|
|
for (Record record : timeList) {
|
|
String key = record.get("class_id")+"|"+record.get("subject_id");
|
|
|
|
map.put(key,record);
|
|
}
|
|
return map ;
|
|
}
|
|
|
|
/**
|
|
* @description 导入班级课时Excel
|
|
* @author Mr.zms
|
|
* @date 2019/6/25
|
|
* @return com.alibaba.fastjson.JSONObject
|
|
*/
|
|
public JSONObject importClassTimeExcel(int taskId, UploadFile file) {
|
|
//校验文件
|
|
JSONObject returnJson = FileUtil.CheckUploadFileObject(file.getSaveDirectory() + File.separator + file.getFileName());
|
|
if(!returnJson.getBooleanValue("success")){
|
|
return returnJson ;
|
|
}
|
|
HSSFWorkbook wb = null;
|
|
try {
|
|
wb = new HSSFWorkbook(new FileInputStream(file.getSaveDirectory() + File.separator + file.getFileName()));
|
|
} catch (IOException e) {
|
|
e.printStackTrace();
|
|
}
|
|
//检验模板 是否为空
|
|
if(COMMON.isEmpty(wb)){
|
|
return SelectCourseBaseService.service.failedResult("导入模板为空");
|
|
}
|
|
//校验模板是否正确
|
|
HSSFSheet sheet = wb.getSheetAt(0);
|
|
String sheetName = sheet.getSheetName();
|
|
int rowNum=sheet.getLastRowNum();
|
|
if(!"课程课时".equals(sheetName)||rowNum<2){
|
|
return SelectCourseBaseService.service.failedResult("导入模板错误");
|
|
}
|
|
String uuid = COMMON.getGuid();
|
|
//检验和插入临时表
|
|
if(!checkAndInsertClassTime(sheet,uuid,taskId)){
|
|
return SelectCourseBaseService.service.failedResult("导入模板错误");
|
|
}
|
|
//删除临时表数据的record
|
|
Record delRecord = new Record().set("field_1",uuid).set("field_2",taskId);
|
|
//处理临时数据 获取正确的数据
|
|
List<Record> batchClassList = processingData(uuid,taskId);
|
|
if(COMMON.isEmpty(batchClassList)){
|
|
CurriculumPlanModel.dao.delImportTeacherTime(delRecord);
|
|
return SelectCourseBaseService.service.failedResult("导入模板不存在合格的班级课时");
|
|
}
|
|
//批量更新行政班班级课时
|
|
TaskModel.dao.batchUpdateTaskclassTime(batchClassList);
|
|
// 删除临时表数据
|
|
CurriculumPlanModel.dao.delImportTeacherTime(delRecord);
|
|
returnJson.put("success",Constant.TRUE);
|
|
returnJson.put("info","导入成功");
|
|
return returnJson ;
|
|
}
|
|
|
|
/**
|
|
* @description 处理临时表数据
|
|
* @author Mr.zms
|
|
* @date 2019/6/25
|
|
* @return java.util.List<com.jfinal.plugin.activerecord.Record>
|
|
*/
|
|
private List<Record> processingData(String uuid, int taskId) {
|
|
//获取临时数据
|
|
List<Record> list = TaskModel.dao.getImportClassTime(uuid,taskId);
|
|
//处理模板里的数据,课时是否是数字
|
|
List<Record> batchPersonList = new ArrayList<>();
|
|
for (Record record1 : list) {
|
|
String times = String.valueOf(record1.get("times"));
|
|
if(!COMMON.isEmpty(times)&&SelectCourseBaseService.service.isNumeric(times)){
|
|
record1.set("times",(int)Double.parseDouble(times));
|
|
batchPersonList.add(record1);
|
|
}
|
|
}
|
|
return batchPersonList ;
|
|
}
|
|
|
|
/**
|
|
* @description 检验和插入临时表
|
|
* @author Mr.zms
|
|
* @date 2019/6/25
|
|
* @return boolean
|
|
*/
|
|
boolean checkAndInsertClassTime(HSSFSheet sheet,String uuid, int taskId) {
|
|
//获取 学科列表
|
|
List<Record> subjectList = TaskModel.dao.getClassTimeList(String.valueOf(taskId),"-1","2","","1");
|
|
//校验学科是否 一一对应
|
|
HSSFRow subjectRow = sheet.getRow(0);
|
|
for (int i = 0; i < subjectList.size(); i++) {
|
|
HSSFCell cell = subjectRow.getCell(i+1);
|
|
if(COMMON.isEmpty(cell)){
|
|
return false;
|
|
}else {
|
|
String subjectName = cell.toString();
|
|
String compareSubjectName = subjectList.get(i).get("subject_name");
|
|
if(!subjectName.equals(compareSubjectName)){
|
|
return false ;
|
|
}
|
|
}
|
|
}
|
|
//获取班级列表
|
|
List<Record> list = TaskModel.dao.getClassListByTaskId(String.valueOf(taskId), "2");
|
|
//校验班级是否 --对应
|
|
for (int i = 0; i < list.size(); i++) {
|
|
HSSFRow classRow = sheet.getRow(i+1);
|
|
if(COMMON.isEmpty(classRow)){
|
|
return false;
|
|
}
|
|
HSSFCell cell = classRow.getCell(0);
|
|
if(COMMON.isEmpty(cell)){
|
|
return false;
|
|
}
|
|
String className = classRow.getCell(0).toString();
|
|
String compareClassName = list.get(i).get("class_name");
|
|
if(!className.equals(compareClassName)){
|
|
return false ;
|
|
}
|
|
}
|
|
//整理数据
|
|
List<Record> batchList = new ArrayList<>();
|
|
for (int i = 0; i < list.size(); i++) {
|
|
HSSFRow row = sheet.getRow(i+1);
|
|
String classId = String.valueOf(list.get(i).get("class_id"));
|
|
for (int i1 = 0; i1 < subjectList.size(); i1++) {
|
|
HSSFCell cell = row.getCell(i1+1);
|
|
if(COMMON.isEmpty(cell)){
|
|
continue;
|
|
}
|
|
String cellString = cell.toString();
|
|
cellString = cellString.replaceAll(" ","");
|
|
String subjectId = String.valueOf(subjectList.get(i1).get("subject_id"));
|
|
Record record = new Record().set("field_1",uuid).set("field_2",taskId);
|
|
record.set("field_3",classId).set("field_4","2").set("field_5",subjectId).set("field_6",cellString);
|
|
batchList.add(record);
|
|
}
|
|
}
|
|
//插入临时表
|
|
CurriculumPlanModel.dao.batchImportExcel(batchList,6);
|
|
return true ;
|
|
}
|
|
|
|
|
|
|
|
|
|
public String getStepYearTeacherInfo(String taskIds, int personId) {
|
|
List<Record> list = TaskModel.dao.getStepYearTeacherInfo(taskIds,personId);
|
|
return COMMON.convert2JsonStr(list);
|
|
}
|
|
|
|
public JSONObject getStepYearTaskList(String taskId, Record record) {
|
|
JSONObject returnJson = new JSONObject();
|
|
Page<Record> pageRecord = TaskModel.dao.getTaskList(record);
|
|
List<Record> list = pageRecord.getList();
|
|
for (Record record1 : list) {
|
|
String compareTaskId = String.valueOf(record1.get("task_id"));
|
|
if(taskId.equals(compareTaskId)){
|
|
list.remove(record1);
|
|
break;
|
|
}
|
|
}
|
|
returnJson.put("list", COMMON.convertListRecord2(list));
|
|
returnJson.put("success",Constant.TRUE);
|
|
return returnJson;
|
|
}
|
|
|
|
public JSONObject getStepYearTaskListByTaskId(String taskId) {
|
|
List<Record> list = TaskModel.dao.getStepYearTaskListByTaskId(taskId);
|
|
JSONObject returnJson = new JSONObject();
|
|
returnJson.put("success",true);
|
|
returnJson.put("list",COMMON.convertListRecord2(list));
|
|
return returnJson;
|
|
}
|
|
public String getStepYearTaskIds(String taskId){
|
|
List<Record> list = TaskModel.dao.getStepYearTaskListByTaskId(taskId);
|
|
Record record = new Record().set("task_id",taskId);
|
|
list.add(record);
|
|
return ToolsUtil.getIds(list,"task_id");
|
|
}
|
|
public Record getMaxDayJson(String taskId){
|
|
String taskIds = getStepYearTaskIds(taskId);
|
|
return TaskModel.dao.getMaxCourseClassInfo(taskIds);
|
|
}
|
|
|
|
public String downCourseTableBak(String taskId) {
|
|
List<Record> list = TaskModel.dao.getCourseTableList(taskId);
|
|
JSONObject jsonObject = new JSONObject();
|
|
jsonObject.put("task_id",taskId);
|
|
jsonObject.put("list",COMMON.convertListRecord2(list));
|
|
String str = jsonObject.toJSONString() ;
|
|
return SecurityAES.encrypt(str);
|
|
}
|
|
public String getBakName(String taskId){
|
|
Record record = new Record().set("task_id", taskId).set("pageSize", 1).set("pageNumber", 1);
|
|
Page<Record> pageRecord = TaskModel.dao.getTaskList(record);
|
|
List<Record> list = pageRecord.getList();
|
|
if(!COMMON.isEmpty(list)){
|
|
record = list.get(0);
|
|
}
|
|
String taskName = record.get("task_name");
|
|
String dataStr = DateUtils.getDateTime(DateUtils.FORMAT_FULL,new Date());
|
|
return taskName+"时间"+dataStr+".ds";
|
|
}
|
|
|
|
public JSONObject importCourseTableBak(String taskId ,UploadFile file) {
|
|
//校验文件
|
|
JSONObject returnJson = FileUtil.CheckUploadFileObject(file.getSaveDirectory() + File.separator + file.getFileName());
|
|
if(!returnJson.getBooleanValue("success")){
|
|
return returnJson ;
|
|
}
|
|
File filename = new File(file.getSaveDirectory() + File.separator + file.getFileName());
|
|
InputStreamReader reader = null;
|
|
try {
|
|
reader = new InputStreamReader(new FileInputStream(filename));
|
|
// 建立一个对象，它把文件内容转成计算机能读懂的语言
|
|
BufferedReader br = new BufferedReader(reader);
|
|
String line = "";
|
|
line = br.readLine();
|
|
String str = SecurityAES.decrypt(line);
|
|
if(COMMON.isEmpty(str)){
|
|
return SelectCourseBaseService.service.failedResult("导入错误备份文件");
|
|
}
|
|
JSONObject jsonObject = JSONObject.parseObject(str);
|
|
String compareTaskId = String.valueOf(jsonObject.get("task_id"));
|
|
if(!taskId.equals(compareTaskId)){
|
|
return SelectCourseBaseService.service.failedResult("导入的备份文件不是当前排课任务");
|
|
}
|
|
JSONArray jsonArray = jsonObject.getJSONArray("list");
|
|
List<Record> list = ToolsUtil.JSONArray2List(jsonArray);
|
|
//删除课表
|
|
CourseSelectTimeModel.dao.delCourseTable(taskId,"","");
|
|
CourseSelectTimeModel.dao.batchTaskTimeTable(list);
|
|
} catch (IOException e) {
|
|
e.printStackTrace();
|
|
}catch (Exception e){
|
|
e.printStackTrace();
|
|
return SelectCourseBaseService.service.failedResult("导入错误备份文件");
|
|
}
|
|
returnJson.put("success",true);
|
|
returnJson.put("info","导入成功");
|
|
return returnJson;
|
|
}
|
|
}
|