|
|
package com.dsideal.newUniversityExamination.selectcourse.service;
|
|
|
|
|
|
import com.alibaba.fastjson.JSON;
|
|
|
import com.alibaba.fastjson.JSONArray;
|
|
|
import com.alibaba.fastjson.JSONException;
|
|
|
import com.alibaba.fastjson.JSONObject;
|
|
|
import com.alibaba.fastjson.serializer.SerializerFeature;
|
|
|
import com.dsideal.newUniversityExamination.selectcourse.core.util.dto.TimeDto;
|
|
|
import com.dsideal.newUniversityExamination.selectcourse.model.CourseSelectTimeModel;
|
|
|
import com.dsideal.newUniversityExamination.selectcourse.model.MergeCourseTableModel;
|
|
|
import com.dsideal.newUniversityExamination.selectcourse.model.TaskModel;
|
|
|
import com.dsideal.newUniversityExamination.selectcourse.model.TimetableAdjustModel;
|
|
|
import com.dsideal.newUniversityExamination.util.BorrowUtil;
|
|
|
import com.dsideal.newUniversityExamination.util.COMMON;
|
|
|
import com.dsideal.newUniversityExamination.util.Constant;
|
|
|
import com.dsideal.newUniversityExamination.util.ToolsUtil;
|
|
|
import com.jfinal.plugin.activerecord.Record;
|
|
|
import org.apache.poi.hssf.usermodel.*;
|
|
|
import org.apache.poi.ss.util.CellRangeAddress;
|
|
|
|
|
|
import java.text.ParseException;
|
|
|
import java.util.ArrayList;
|
|
|
import java.util.HashMap;
|
|
|
import java.util.List;
|
|
|
import java.util.Map;
|
|
|
|
|
|
|
|
|
public class CourseSelectTimeService {
|
|
|
|
|
|
public static final CourseSelectTimeService service =new CourseSelectTimeService();
|
|
|
|
|
|
/*获取班级课表和教师课表*/
|
|
|
public JSONObject getCourseTime(String uuid,String week,String baseClassId,String baseClassType,String teacherId){
|
|
|
JSONObject resultJson=new JSONObject();
|
|
|
resultJson.put("success", false);
|
|
|
resultJson.put("info", "暂无课表");
|
|
|
/*获取课表*/
|
|
|
List<Record> list;
|
|
|
if(COMMON.isEmpty(week)){
|
|
|
list= CourseSelectTimeModel.dao.getCourseTableByUuid(uuid, baseClassId, baseClassType,teacherId,"","","","","");
|
|
|
}else {
|
|
|
list= CourseSelectTimeModel.dao.getCourseTableByUuidWeek(uuid,week,baseClassId,baseClassType,teacherId,"","","","","");
|
|
|
}
|
|
|
/*拼接返回值*/
|
|
|
JSONArray jsonArr = getDaySectionArray(list, resultJson);
|
|
|
/*获取课节和天数*/
|
|
|
JSONObject dayJson = getCourseTableTimeByUuid(uuid);
|
|
|
if(!COMMON.isEmpty(dayJson.get("classInfo"))){
|
|
|
JSONObject [][] arr = initializationArray(dayJson.getJSONObject("classInfo"));
|
|
|
courseTableAddToArray(jsonArr,arr);
|
|
|
if(!COMMON.isEmpty(arr)){
|
|
|
resultJson.put("table_Time",dayJson);
|
|
|
resultJson.put("table_arry", arr);
|
|
|
resultJson.put("success", true);
|
|
|
resultJson.put("info", Constant.SUCCESS_INFO);
|
|
|
return resultJson;
|
|
|
}
|
|
|
}
|
|
|
return resultJson;
|
|
|
}
|
|
|
public JSONArray getDaySectionArray(List<Record> list, JSONObject resultJson){
|
|
|
/*获取班级名*/
|
|
|
String classIds = ToolsUtil.getIds(list, "base_class_id");
|
|
|
String classTypes = ToolsUtil.getIds(list, "base_class_type");
|
|
|
JSONObject mapJson = SelectCourseBaseService.service.getClassInfoByClassId(classIds, classTypes, 1);
|
|
|
@SuppressWarnings("unchecked")
|
|
|
Map<String, Record> map = (Map<String, Record>) mapJson.get("map");
|
|
|
boolean flag = mapJson.getBooleanValue("success");
|
|
|
resultJson.put("error", "");
|
|
|
if(!flag){
|
|
|
resultJson.put("error", "课表班级存在异常");
|
|
|
if(COMMON.isEmpty(map)){
|
|
|
resultJson.put("success", false);
|
|
|
resultJson.put("info", "暂无课表");
|
|
|
}
|
|
|
}
|
|
|
/*拼接返回值*/
|
|
|
JSONArray jsonArr = new JSONArray();
|
|
|
for(Record records : list){
|
|
|
JSONObject jsonOb=getCourseTableJsonOb(records, map);
|
|
|
if(!COMMON.isEmpty(jsonOb)){
|
|
|
jsonArr.add(jsonOb);
|
|
|
}
|
|
|
}
|
|
|
return jsonArr ;
|
|
|
}
|
|
|
|
|
|
|
|
|
/*获取学生课表*/
|
|
|
public JSONObject getCouresTimeTable(String personId,String bureauId) {
|
|
|
JSONObject returnJson = new JSONObject();
|
|
|
returnJson.put("success", false);
|
|
|
returnJson.put("info", "暂无课表");
|
|
|
/*获取当前学期*/
|
|
|
JSONObject xqOb=BorrowUtil.getCurrentTerm();
|
|
|
String xqId=String.valueOf(xqOb.get("XQ_ID")) ;
|
|
|
/*获取学生的当前所在的班级*/
|
|
|
JSONObject classJson = BorrowUtil.getAllInfoOfStudent(personId);
|
|
|
boolean success = classJson.getBooleanValue("success");
|
|
|
if(success){
|
|
|
/*获取 学年学段和班级列表*/
|
|
|
JSONArray classArray = classJson.getJSONArray("class_list");
|
|
|
if(!COMMON.isEmpty(classArray)){
|
|
|
/*查询学生是否存在课表*/
|
|
|
JSONObject classObj = classArray.getJSONObject(0);
|
|
|
String year = classObj.getString("entrance_year");
|
|
|
String stageId = classObj.getString("stage_id");
|
|
|
Record record = CourseSelectTimeModel.dao.getCourseTaskYearXq(year, xqId, bureauId, stageId);
|
|
|
if(!COMMON.isEmpty(record)){
|
|
|
String uuid = String.valueOf(record.get("uuid"));
|
|
|
/*获取课节和天数*/
|
|
|
JSONObject dayJson = getCourseTableTimeByUuid(uuid);
|
|
|
//获取当前周
|
|
|
int week = TaskService.service.getReleaseWeek(ToolsUtil.Object2Record(dayJson.getJSONObject("classInfo")));
|
|
|
//处理未到开学时间取第一周的 学生高级合班信息
|
|
|
int meringWeek = week==-1?1:week;
|
|
|
/*获取班级名称*/
|
|
|
List<Record> classList = ToolsUtil.JSONArray2List(classArray);
|
|
|
int classId = getStudentClassId(classList);
|
|
|
// 学生新合班规则
|
|
|
List<Record> mergingClassList = CourseSelectTimeModel.dao.getMergingClassList(uuid,personId,meringWeek);
|
|
|
addClassList(mergingClassList,classList);
|
|
|
String classIds = ToolsUtil.getIds(classList, "class_id");
|
|
|
String classTypes = ToolsUtil.getIds(classList, "class_type");
|
|
|
JSONObject mapJson = SelectCourseBaseService.service.getClassInfoByClassId(classIds, classTypes, 1);
|
|
|
@SuppressWarnings("unchecked")
|
|
|
Map<String, Record> map = (Map<String, Record>) mapJson.get("map");
|
|
|
boolean flag = mapJson.getBooleanValue("success");
|
|
|
if(!flag){
|
|
|
returnJson.put("error", "课表班级存在异常");
|
|
|
if(COMMON.isEmpty(map)){
|
|
|
returnJson.put("success", false);
|
|
|
returnJson.put("info", "暂无课表");
|
|
|
return returnJson ;
|
|
|
}
|
|
|
}
|
|
|
JSONArray jsonArr=new JSONArray();
|
|
|
List<Record> mergingStudentList = CourseSelectTimeModel.dao.getMergingStudentList(uuid,meringWeek);
|
|
|
for(Record classRecord : classList ){
|
|
|
String baseClassId = String.valueOf(classRecord.get("class_id"));
|
|
|
String baseClassType = String.valueOf(classRecord.get("class_type"));
|
|
|
/*获取班级课表*/
|
|
|
if(week < 1 ){
|
|
|
List<Record> list = CourseSelectTimeModel.dao.getCourseTableByUuid(uuid, baseClassId, baseClassType,"","","0","","","");
|
|
|
checkMeringStudent(list,map,jsonArr,mergingStudentList,personId,classId);
|
|
|
}else{
|
|
|
List<Record> list= CourseSelectTimeModel.dao.getCourseTableByUuidWeek(uuid,String.valueOf(week),baseClassId,baseClassType,"","","0","","","");
|
|
|
checkMeringStudent(list,map,jsonArr,mergingStudentList,personId,classId);
|
|
|
}
|
|
|
}
|
|
|
if(!COMMON.isEmpty(dayJson.get("classInfo"))){
|
|
|
/*初始化和填充课表二维数组*/
|
|
|
JSONObject [][] arr = initializationArray(dayJson.getJSONObject("classInfo"));
|
|
|
courseTableAddToArray(jsonArr,arr);
|
|
|
if(!COMMON.isEmpty(arr)){
|
|
|
returnJson.put("table_Time",dayJson);
|
|
|
returnJson.put("table_arry", arr);
|
|
|
returnJson.put("success", true);
|
|
|
returnJson.put("info", Constant.SUCCESS_INFO);
|
|
|
return returnJson;
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
return returnJson;
|
|
|
}
|
|
|
private int getStudentClassId(List<Record> classList ){
|
|
|
int classId = 0;
|
|
|
for (Record record1 : classList) {
|
|
|
if(1 == record1.getInt("class_type")){
|
|
|
classId = Integer.parseInt(String.valueOf(record1.get("class_id")));
|
|
|
}
|
|
|
}
|
|
|
return classId;
|
|
|
}
|
|
|
/**
|
|
|
* @description 学生新合班规则
|
|
|
* @author Mr.zms
|
|
|
* @date 2019/5/5
|
|
|
* @return void
|
|
|
*/
|
|
|
private void addClassList(List<Record> list,List<Record> classList){
|
|
|
Map<String,Record> map = getClassMap(classList);
|
|
|
for (Record record : list) {
|
|
|
Record record1 = new Record();
|
|
|
String classId = String.valueOf(record.get("target_class_id"));
|
|
|
record1.set("class_id",classId);
|
|
|
record1.set("class_type",1);
|
|
|
if(COMMON.isEmpty(map.get(classId))){
|
|
|
classList.add(record1);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
private Map<String,Record> getClassMap(List<Record> classList){
|
|
|
Map<String,Record> map = new HashMap<>();
|
|
|
for (Record record : classList) {
|
|
|
String classType = String.valueOf(record.get("class_type"));
|
|
|
String classId = String.valueOf(record.get("class_id"));
|
|
|
if("1".equals(classType)){
|
|
|
map.put(classId,record);
|
|
|
}
|
|
|
}
|
|
|
return map;
|
|
|
}
|
|
|
/**
|
|
|
* @description 学生课表 增加新合班规则校验
|
|
|
* @author Mr.zms
|
|
|
* @date 2019/5/5
|
|
|
* @return void
|
|
|
*/
|
|
|
private void checkMeringStudent(List<Record> list ,Map<String, Record> map,JSONArray jsonArr,List<Record> mergingStudentList,String personId,int classId){
|
|
|
for (Record records : list) {
|
|
|
int baseClassId = records.get("base_class_id");
|
|
|
int baseClassType = records.get("base_class_type");
|
|
|
int courseId = records.get("courseId");
|
|
|
if(checkMerging(mergingStudentList,baseClassId,baseClassType,courseId,personId,classId)||2==baseClassType){
|
|
|
JSONObject jsonOb=getCourseTableJsonOb(records, map);
|
|
|
if(!COMMON.isEmpty(jsonOb)){
|
|
|
jsonArr.add(jsonOb);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
|
|
|
/*教室课表*/
|
|
|
public JSONObject getRoomCourseTimeTable(String uuid,String week,String roomId) {
|
|
|
JSONObject resultJson = new JSONObject();
|
|
|
resultJson.put("success", false);
|
|
|
resultJson.put("info", "暂无课表");
|
|
|
/*获取教室课表*/
|
|
|
List<Record> list;
|
|
|
if(COMMON.isEmpty(week)){
|
|
|
list = CourseSelectTimeModel.dao.getCourseTableByUuid(uuid, "", "","",roomId,"0","","","");
|
|
|
}else {
|
|
|
list = CourseSelectTimeModel.dao.getCourseTableByUuidWeek(uuid,week,"","","",roomId,"0","","","");
|
|
|
}
|
|
|
/*查询班级名称*/
|
|
|
JSONArray jsonArr = getDaySectionArray(list, resultJson);
|
|
|
/*获取课节和天数*/
|
|
|
JSONObject dayJson = getCourseTableTimeByUuid(uuid);
|
|
|
if(!COMMON.isEmpty(dayJson.get("classInfo"))){
|
|
|
JSONObject [][] arr = initializationArray(dayJson.getJSONObject("classInfo"));
|
|
|
courseTableAddToArray(jsonArr,arr);
|
|
|
if(!COMMON.isEmpty(arr)){
|
|
|
resultJson.put("table_Time",dayJson);
|
|
|
resultJson.put("table_arry", arr);
|
|
|
resultJson.put("success", true);
|
|
|
resultJson.put("info", Constant.SUCCESS_INFO);
|
|
|
return resultJson;
|
|
|
}
|
|
|
}
|
|
|
return resultJson;
|
|
|
}
|
|
|
/*获取教室列表*/
|
|
|
public String getRoomInfo(String uuid,String week,String roomName) {
|
|
|
if(!COMMON.isEmpty(week)){
|
|
|
return getRoomInfo(uuid,week);
|
|
|
}
|
|
|
List<Record> list = CourseSelectTimeModel.dao.getRoomListByUuid(uuid,"",roomName);
|
|
|
String classIds = ToolsUtil.getIds(list, "base_class_id");
|
|
|
String classTypes = ToolsUtil.getIds(list, "base_class_type");
|
|
|
JSONObject mapJson = SelectCourseBaseService.service.getClassInfoByClassId(classIds, classTypes, 1);
|
|
|
@SuppressWarnings("unchecked")
|
|
|
Map<String, Record> map = (Map<String, Record>) mapJson.get("map");
|
|
|
/*查询不到班级*/
|
|
|
if(COMMON.isEmpty(map)){
|
|
|
List<Record> nullList = new ArrayList<>();
|
|
|
return COMMON.convert2JsonStr(nullList);
|
|
|
}
|
|
|
return COMMON.convert2JsonStr(list);
|
|
|
}
|
|
|
private String getRoomInfo(String uuid,String week){
|
|
|
List<Record> list = CourseSelectTimeModel.dao.getRoomListByUuidWeek(uuid,week,"");
|
|
|
return COMMON.convert2JsonStr(list);
|
|
|
}
|
|
|
|
|
|
/*获取走班课节详情*/
|
|
|
public String getStudentInfoByClassId(String uuid,String week,String day, String section, String type, String classId,String classType) {
|
|
|
List<Record> list = new ArrayList<>();
|
|
|
Record recordOb = new Record().set("base_class_id", classId).set("base_class_type", classType);
|
|
|
list.add(recordOb);
|
|
|
List<Record> classList = new ArrayList<>() ;
|
|
|
if(COMMON.isEmpty(week)){
|
|
|
classList= CourseSelectTimeModel.dao.getCourseTableByUuid(uuid,"","","","","0",type, day, section);
|
|
|
}else {
|
|
|
classList = CourseSelectTimeModel.dao.getCourseTableByUuidWeek(uuid,week,"","","","","0",type,day,section);
|
|
|
}
|
|
|
list.addAll(classList);
|
|
|
String classIds = ToolsUtil.getIds(list, "base_class_id");
|
|
|
String classTypes = ToolsUtil.getIds(list, "base_class_type");
|
|
|
JSONObject mapJson = SelectCourseBaseService.service.getClassInfoByClassId(classIds, classTypes, 3);
|
|
|
@SuppressWarnings("unchecked")
|
|
|
Map<String, Record> map =(Map<String, Record>) mapJson.get("map");
|
|
|
List<Record> returnList = new ArrayList<>();
|
|
|
/*获取全部人数*/
|
|
|
String key = classId+"|"+classType;
|
|
|
Record recordTotal = map.get(key);
|
|
|
List<Record> totalStudenttList = ToolsUtil.JSONArray2List((JSONArray) recordTotal.get("student_list")) ;
|
|
|
/*遍历教学班*/
|
|
|
for(int i = 1; i< list.size() ;i++){
|
|
|
Record record = list.get(i);
|
|
|
String key1 = record.get("base_class_id")+"|"+record.get("base_class_type");
|
|
|
Record recordObj = map.get(key1);
|
|
|
//如果 是无效班级跳过
|
|
|
if(COMMON.isEmpty(recordObj)){
|
|
|
continue ;
|
|
|
}
|
|
|
List<Record> studentList = ToolsUtil.JSONArray2List((JSONArray) recordObj.get("student_list")) ;
|
|
|
Record resultRecord = new Record();
|
|
|
resultRecord.set("class_id", recordObj.get("class_id"));
|
|
|
resultRecord.set("class_name", recordObj.get("class_name"));
|
|
|
resultRecord.set("class_room_name", COMMON.isEmpty(record.get("class_room_name"))?"":record.get("class_room_name"));
|
|
|
JSONArray jsonArray = new JSONArray();
|
|
|
/*获取行政班的学生在次节课教学班上课的学生*/
|
|
|
for(Record toatlStudent : totalStudenttList){
|
|
|
String personId = String.valueOf(toatlStudent.get("person_id"));
|
|
|
String personName = toatlStudent.get("person_name");
|
|
|
for(Record student : studentList){
|
|
|
String studentId = String.valueOf(student.get("person_id"));
|
|
|
if(personId.equals(studentId)){
|
|
|
JSONObject jsonOb = BorrowUtil.getAvatarSuffix(personId, "6");
|
|
|
jsonOb.put("student_name", personName);
|
|
|
jsonOb.put("student_id", personId);
|
|
|
jsonArray.add(jsonOb);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if(!COMMON.isEmpty(jsonArray)){
|
|
|
resultRecord.set("table_list", jsonArray);
|
|
|
returnList.add(resultRecord);
|
|
|
}
|
|
|
}
|
|
|
return COMMON.convert2JsonStr(returnList);
|
|
|
}
|
|
|
/*获取年级课表*/
|
|
|
public JSONObject getCouresTimeTableYear(String uuid,String week) {
|
|
|
//获取天数和节数
|
|
|
JSONObject tableTime = getCourseTableTimeByUuid(uuid);
|
|
|
JSONObject returnJson=new JSONObject();
|
|
|
//获取此次排课下所有的班级
|
|
|
List<Record> classArray;
|
|
|
if(COMMON.isEmpty(week)){
|
|
|
classArray = CourseSelectTimeModel.dao.getClassListByUuid(uuid,"","" ,"1,2");
|
|
|
}else{
|
|
|
classArray = CourseSelectTimeModel.dao.getClassListByReleaseWeek(uuid,week,"");
|
|
|
}
|
|
|
String classIds = ToolsUtil.getIds(classArray, "base_class_id");
|
|
|
String classTypes = ToolsUtil.getIds(classArray, "base_class_type");
|
|
|
JSONObject mapJson = SelectCourseBaseService.service.getClassInfoByClassId(classIds, classTypes, 1);
|
|
|
@SuppressWarnings("unchecked")
|
|
|
Map<String, Record> classMap = (Map<String, Record>) mapJson.get("map");
|
|
|
boolean flag = mapJson.getBooleanValue("success");
|
|
|
returnJson.put("error", "");
|
|
|
if(!flag){
|
|
|
returnJson.put("error", "课表班级存在异常");
|
|
|
if(COMMON.isEmpty(classMap)){
|
|
|
returnJson.put("success", false);
|
|
|
returnJson.put("info", "暂无课表");
|
|
|
return returnJson ;
|
|
|
}
|
|
|
}
|
|
|
/*获取出有效的班级列表*/
|
|
|
List<Record> classArrayNew = new ArrayList<>();
|
|
|
for(Record record : classArray){
|
|
|
String key = record.get("base_class_id")+"|"+record.get("base_class_type");
|
|
|
if(!COMMON.isEmpty(classMap.get(key))){
|
|
|
record.set("class_id", record.get("base_class_id"));
|
|
|
record.set("class_name", classMap.get(key).get("class_name"));
|
|
|
classArrayNew.add(record);
|
|
|
}
|
|
|
}
|
|
|
Map<String, Integer> map = new HashMap<>();
|
|
|
/*初始化二维数组*/
|
|
|
Object [][] arrTable = getArrTableAndMap(tableTime, map, classArrayNew);
|
|
|
//查询出所有班级课表
|
|
|
List<Record> list ;
|
|
|
if(COMMON.isEmpty(week)){
|
|
|
list = CourseSelectTimeModel.dao.getCourseTableByUuid(uuid, "", "", "", "", "", "", "", "");
|
|
|
}else {
|
|
|
list = CourseSelectTimeModel.dao.getCourseTableByUuidWeek(uuid,week,"","","","","","","","");
|
|
|
}
|
|
|
for (int j = 0; j < list.size(); j++) {
|
|
|
Record records = list.get(j);
|
|
|
addArrTableValue(arrTable, records, map,classMap);
|
|
|
}
|
|
|
|
|
|
returnJson.put("table_Time",tableTime);
|
|
|
returnJson.put("success", true);
|
|
|
returnJson.put("table_arry", arrTable);
|
|
|
returnJson.put("table_vertical", verticalYearCourseTable(arrTable,classArrayNew,uuid));
|
|
|
returnJson.put("table_list", COMMON.convertListRecord2(classArrayNew));
|
|
|
return returnJson;
|
|
|
}
|
|
|
/**
|
|
|
* @description 竖版年级课表
|
|
|
* @author Mr.zms
|
|
|
* @date 2019/7/1
|
|
|
* @return com.alibaba.fastjson.JSONObject[][]
|
|
|
*/
|
|
|
private JSONObject [][] verticalYearCourseTable(Object [][] arrTable,List<Record> classArrayNew,String uuid){
|
|
|
Record weekOb = CourseSelectTimeModel.dao.getCourseTableTimeByUuid(uuid);
|
|
|
List<TimeDto> timeDtoList = CoreCourseService.service.generateTimeData("", weekOb, "", "-1");
|
|
|
int length1 = arrTable.length * arrTable[0].length ;
|
|
|
JSONObject [][] objectArray = new JSONObject[classArrayNew.size()][length1];
|
|
|
for (int i = 0; i < arrTable.length; i++) {
|
|
|
for (int j = 0; j < arrTable[i].length; j++) {
|
|
|
JSONArray classArray= (JSONArray) arrTable[i][j];
|
|
|
for(int len = 0; len < classArray.size(); len++){
|
|
|
int day = i+1 ;
|
|
|
int section = j+1 ;
|
|
|
TimeDto timeDto = new TimeDto(day,section);
|
|
|
int timeIndex =timeDto.getTimeIndex(timeDtoList);
|
|
|
objectArray[len][timeIndex] = classArray.getJSONObject(len);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
return objectArray ;
|
|
|
}
|
|
|
|
|
|
/*获取发布后的课表的班级列表*/
|
|
|
public String getTimeTableClassInfoByUuid(String uuid,String week,String baseClassId,String baseClasstype) {
|
|
|
List<Record> list;
|
|
|
if(!COMMON.isEmpty(week)){
|
|
|
list = CourseSelectTimeModel.dao.getClassListByReleaseWeek(uuid,week,baseClasstype);
|
|
|
}else {
|
|
|
list = CourseSelectTimeModel.dao.getClassListByUuid(uuid,"",baseClassId,baseClasstype);
|
|
|
}
|
|
|
String classIds = ToolsUtil.getIds(list, "base_class_id");
|
|
|
String classTypes = ToolsUtil.getIds(list, "base_class_type");
|
|
|
JSONObject mapJson = SelectCourseBaseService.service.getClassInfoByClassId(classIds, classTypes, 1);
|
|
|
@SuppressWarnings("unchecked")
|
|
|
Map<String, Record> map = (Map<String, Record>) mapJson.get("map");
|
|
|
/*查询不到班级*/
|
|
|
if(COMMON.isEmpty(map)){
|
|
|
List<Record> nullList = new ArrayList<>();
|
|
|
return COMMON.convert2JsonStr(nullList);
|
|
|
}
|
|
|
List<Record> resultList = new ArrayList<>();
|
|
|
for(Record record : list){
|
|
|
String classId = String.valueOf(record.get("base_class_id"));
|
|
|
String baseclassType = String.valueOf(record.get("base_class_type"));
|
|
|
String key = classId+"|"+baseclassType;
|
|
|
Record recordClass = map.get(key);
|
|
|
record.set("class_id", record.get("base_class_id"));
|
|
|
if(!COMMON.isEmpty(recordClass)){
|
|
|
record.set("class_name", recordClass.get("class_name"));
|
|
|
resultList.add(record);
|
|
|
}
|
|
|
}
|
|
|
return COMMON.convert2JsonStr(resultList);
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* @description 查询uuid
|
|
|
* @author Mr.zms
|
|
|
* @return java.lang.String
|
|
|
*/
|
|
|
public String getTaskIdFromYearxq(String year, String xqId,String stageId,String bureauId) {
|
|
|
Record recordresult= CourseSelectTimeModel.dao.getCourseTaskYearXq(year, xqId, bureauId, stageId);
|
|
|
JSONObject resultJson = new JSONObject();
|
|
|
resultJson.put("success", false);
|
|
|
resultJson.put("info", "当前学期没有发布的课表");
|
|
|
if(!COMMON.isEmpty(recordresult)){
|
|
|
resultJson.put("classInfo", ToolsUtil.Record2Object(recordresult));
|
|
|
resultJson.put("info", Constant.SUCCESS_INFO);
|
|
|
resultJson.put("success", true);
|
|
|
}
|
|
|
return resultJson.toJSONString();
|
|
|
}
|
|
|
/**
|
|
|
* @description 获取课时
|
|
|
* @author Mr.zms
|
|
|
* @return com.alibaba.fastjson.JSONObject
|
|
|
*/
|
|
|
public JSONObject getCoursetableTime(String bureauId ,String year ,String stageId,String xqId){
|
|
|
JSONObject jsonOb = new JSONObject();
|
|
|
Record record = CourseSelectTimeModel.dao.getCourseTableTime(bureauId,year,stageId,xqId);
|
|
|
if(COMMON.isEmpty(record)){
|
|
|
return jsonOb;
|
|
|
}
|
|
|
jsonOb.put("classInfo", ToolsUtil.Record2Object(record));
|
|
|
jsonOb.put("success", true);
|
|
|
return jsonOb;
|
|
|
}
|
|
|
/**
|
|
|
* @description 班牌所需要的接口
|
|
|
* @author Mr.zms
|
|
|
* @return java.lang.String
|
|
|
*/
|
|
|
public String getClassWithRoom(String uuid, String roomId,String classId,String classType) {
|
|
|
List<Record> list = CourseSelectTimeModel.dao.getClassListByUuid(uuid, roomId, classId, classType);
|
|
|
for(Record record:list){
|
|
|
record.set("class_room_id", COMMON.isEmpty(record.get("class_room_id"))?0:record.get("class_room_id"));
|
|
|
record.set("class_room_name", COMMON.isEmpty(record.get("class_room_name"))?"":record.get("class_room_name"));
|
|
|
}
|
|
|
JSONObject json = new JSONObject();
|
|
|
json.put("success", true);
|
|
|
json.put("info", "操作成功");
|
|
|
json.put("list", COMMON.convertListRecord2(list));
|
|
|
return json.toJSONString();
|
|
|
}
|
|
|
public String getClassListByPeronId(String personId ,String xqId){
|
|
|
JSONObject returnJson = new JSONObject();
|
|
|
List<Record> list = CourseSelectTimeModel.dao.getClassListByPeronId(personId,xqId);
|
|
|
returnJson.put("list", COMMON.convertListRecord2(list));
|
|
|
returnJson.put("success", true);
|
|
|
return returnJson.toJSONString();
|
|
|
}
|
|
|
public String getTeacherInfoByUuid(String uuid,String week, String subjectId) {
|
|
|
if(!COMMON.isEmpty(week)){
|
|
|
return getTeacherInfoByUuidWeek(uuid,week,subjectId) ;
|
|
|
}
|
|
|
List<Record> list=CourseSelectTimeModel.dao.getTeacherListByUuid(uuid, subjectId,"");
|
|
|
String classIds = ToolsUtil.getIds(list, "base_class_id");
|
|
|
String classTypes = ToolsUtil.getIds(list, "base_class_type");
|
|
|
JSONObject mapJson = SelectCourseBaseService.service.getClassInfoByClassId(classIds, classTypes, 1);
|
|
|
@SuppressWarnings("unchecked")
|
|
|
Map<String, Record> map = (Map<String, Record>) mapJson.get("map");
|
|
|
/*查询不到班级*/
|
|
|
if(COMMON.isEmpty(map)){
|
|
|
List<Record> nullList = new ArrayList<>();
|
|
|
return COMMON.convert2JsonStr(nullList);
|
|
|
}
|
|
|
return COMMON.convert2JsonStr(list);
|
|
|
}
|
|
|
private String getTeacherInfoByUuidWeek(String uuid,String week,String subjectId){
|
|
|
List<Record> list= CourseSelectTimeModel.dao.getReleaseTeacherList(uuid,week,subjectId,"","");
|
|
|
return COMMON.convert2JsonStr(list);
|
|
|
}
|
|
|
|
|
|
|
|
|
/*初始化二维数组---年级课表*/
|
|
|
private Object [][] getArrTableAndMap(JSONObject tableTime,Map<String, Integer> map,List<Record> classArray ){
|
|
|
JSONObject dayOb = tableTime.getJSONObject("classInfo");
|
|
|
int rank = Integer.parseInt(String.valueOf(dayOb.get("week_of_class_count"))) ;
|
|
|
int row = MergeCourseTableService.service.getDayAndSectionNumber(dayOb) ;
|
|
|
Object [][] arrTable = new Object [rank][row];
|
|
|
for (int i = 0; i < arrTable.length; i++) {
|
|
|
for (int j = 0; j < arrTable[i].length; j++) {
|
|
|
arrTable[i][j] = new JSONArray() ;
|
|
|
for(int len = 0; len < classArray.size(); len++){
|
|
|
JSONObject jsonOb = getArrJsonOb();
|
|
|
String classId = String.valueOf(classArray.get(len).get("BASE_CLASS_ID")) ;
|
|
|
String baseClassType = String.valueOf(classArray.get(len).get("base_class_type")) ;
|
|
|
jsonOb.put("class_id", classId);
|
|
|
jsonOb.put("base_class_id", classId);
|
|
|
jsonOb.put("base_class_type", baseClassType);
|
|
|
String key = classId+"|"+baseClassType;
|
|
|
map.put(key, len);
|
|
|
((JSONArray) arrTable[i][j]) .add(jsonOb);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
return arrTable ;
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* @description 年级课表 元素添加
|
|
|
* @author Mr.zms
|
|
|
* @date 2019/4/18
|
|
|
* @return void
|
|
|
*/
|
|
|
private void addArrTableValue(Object [][] arrTable ,Record records,Map<String, Integer> map ,Map<String, Record> classMap ){
|
|
|
JSONObject json=getCourseTableJsonOb(records, classMap);
|
|
|
if(COMMON.isEmpty(json)) {
|
|
|
return;
|
|
|
}
|
|
|
json.put("base_class_id",COMMON.isEmpty(records.get("base_class_id"))?-1:records.get("base_class_id")) ;
|
|
|
json.put("base_class_type",COMMON.isEmpty(records.get("base_class_type"))?-1:records.get("base_class_type")) ;
|
|
|
int day = records.get("day");
|
|
|
int section = records.get("section");
|
|
|
String baseClassId = String.valueOf(records.get("base_class_id"));
|
|
|
String baseClassType = String.valueOf(records.get("base_class_type"));
|
|
|
JSONArray jsonArray = (JSONArray) arrTable[day-1][section-1];
|
|
|
String key = baseClassId+"|"+baseClassType;
|
|
|
JSONObject jsonNew = jsonArray.getJSONObject(map.get(key));
|
|
|
if(baseClassId.equals(jsonNew.get("base_class_id"))&&baseClassType.equals(jsonNew.get("base_class_type"))){
|
|
|
JSONArray jsonOb = jsonNew.getJSONArray("jsonOb");
|
|
|
//如果课程id == 0
|
|
|
String courseId = String.valueOf(records.get("courseId")) ;
|
|
|
if("0".equals(courseId)) {
|
|
|
getZouJsonOb(json, String.valueOf(records.get("type")));
|
|
|
}
|
|
|
jsonOb.add(json);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
|
|
|
public JSONObject getCourseTableTimeByUuid(String uuid){
|
|
|
JSONObject returnJson = new JSONObject();
|
|
|
Record record = CourseSelectTimeModel.dao.getCourseTableTimeByUuid(uuid);
|
|
|
returnJson.put("success", true);
|
|
|
returnJson.put("classInfo", ToolsUtil.Record2Object(record));
|
|
|
return returnJson ;
|
|
|
}
|
|
|
/**
|
|
|
* 课表添加到而二维数组里
|
|
|
*/
|
|
|
void courseTableAddToArray(JSONArray jsonArr, JSONObject [][] arr){
|
|
|
for (Object obj : jsonArr) {
|
|
|
JSONObject jsonOb = (JSONObject) obj;
|
|
|
int day = Integer.parseInt(String.valueOf(jsonOb.get("day")));
|
|
|
int section = Integer.parseInt(String.valueOf(jsonOb.get("section")));
|
|
|
int column = arr.length;
|
|
|
int row = arr[0].length;
|
|
|
/*是否是越界*/
|
|
|
if (day > row && section > column) {
|
|
|
return;
|
|
|
}
|
|
|
String courseId = String.valueOf(jsonOb.get("courseId"));
|
|
|
if ("0".equals(courseId)) {
|
|
|
String type = String.valueOf(jsonOb.get("type"));
|
|
|
//jsonOb = getZouJsonOb(jsonOb, type);
|
|
|
int sectionType = 3;
|
|
|
if ("1".equals(type)) {
|
|
|
sectionType = 4;
|
|
|
}
|
|
|
arr[section - 1][day - 1].put("section_type", sectionType);
|
|
|
}
|
|
|
JSONArray arrList = arr[section - 1][day - 1].getJSONArray("jsonOb");
|
|
|
arrList.add(jsonOb);
|
|
|
String str = JSON.toJSONString(arrList, SerializerFeature.DisableCircularReferenceDetect);
|
|
|
arr[section - 1][day - 1].put("number", arrList.size());
|
|
|
arr[section - 1][day - 1].put("jsonOb", JSONArray.parseArray(str));
|
|
|
String singleDouble = String.valueOf(jsonOb.get("single_double"));
|
|
|
if (!"0".equals(singleDouble)) {
|
|
|
arr[section - 1][day - 1].put("single_double_type", 1);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
}
|
|
|
private void getZouJsonOb(JSONObject jsonOb,String type){
|
|
|
String zero = "0" ;
|
|
|
String one = "1";
|
|
|
if(zero.equals(type)){
|
|
|
jsonOb.put("className", "选考走班课");
|
|
|
jsonOb.put("subjectName", "选考走班课");
|
|
|
jsonOb.put("type", type);
|
|
|
}else if(one.equals(type)){
|
|
|
jsonOb.put("className", "学考走班课");
|
|
|
jsonOb.put("subjectName", "学考走班课");
|
|
|
jsonOb.put("type", type);
|
|
|
}
|
|
|
}
|
|
|
/**
|
|
|
* @description 初始化二维数组
|
|
|
* @author Mr.zms
|
|
|
* @date 2019/4/18
|
|
|
* @return com.alibaba.fastjson.JSONObject[][]
|
|
|
*/
|
|
|
public JSONObject [][] initializationArray(JSONObject jsonOb){
|
|
|
int row = jsonOb.getIntValue("week_of_class_count") ;
|
|
|
int column = MergeCourseTableService.service.getDayAndSectionNumber(jsonOb) ;
|
|
|
//初始化数组
|
|
|
JSONObject [][] arr;
|
|
|
arr = new JSONObject [column][row];
|
|
|
for (int i = 0; i < arr.length; i++) {
|
|
|
for (int j = 0; j < arr[i].length; j++) {
|
|
|
arr[i][j] = getArrJsonOb() ;
|
|
|
}
|
|
|
}
|
|
|
return arr;
|
|
|
}
|
|
|
|
|
|
|
|
|
public JSONObject getArrJsonOb(){
|
|
|
JSONObject json = new JSONObject();
|
|
|
//0可以替换的位置，1课程冲突,3选考走班，4学考走班,5 灰色单元格
|
|
|
json.put("section_type", 0);
|
|
|
//0.普通 1单双周
|
|
|
json.put("single_double_type", 0);
|
|
|
//教室冲突 标记位 0 不冲突 1 冲突
|
|
|
json.put("room_conflict_tab", 0);
|
|
|
json.put("position_type", 0);
|
|
|
JSONArray jsonArray = new JSONArray();
|
|
|
json.put("jsonOb", jsonArray);
|
|
|
json.put("number", 0);
|
|
|
return json ;
|
|
|
}
|
|
|
/**
|
|
|
* @description 获取课表返回值JSONOb
|
|
|
* @author Mr.zms
|
|
|
* @date 2019/4/18
|
|
|
* @return com.alibaba.fastjson.JSONObject
|
|
|
*/
|
|
|
private JSONObject getCourseTableJsonOb(Record records,Map<String, Record> map){
|
|
|
JSONObject jsonOb=new JSONObject();
|
|
|
String key = records.get("base_class_id") +"|"+ records.get("base_class_type");
|
|
|
Record record = map.get(key);
|
|
|
String className ;
|
|
|
if(!COMMON.isEmpty(record)){
|
|
|
className = map.get(key).get("class_name") ;
|
|
|
}else{
|
|
|
return jsonOb ;
|
|
|
}
|
|
|
jsonOb.put("className", className);
|
|
|
jsonOb.put("teacherName",COMMON.isEmpty(records.get("person_name"))?"":records.get("person_name"));
|
|
|
jsonOb.put("subjectName", records.get("subject_name"));
|
|
|
jsonOb.put("task_id", records.get("task_id"));
|
|
|
jsonOb.put("single_double", records.get("single_double"));
|
|
|
jsonOb.put("day", records.get("day"));
|
|
|
jsonOb.put("section", records.get("section"));
|
|
|
jsonOb.put("roomId", records.get("roomId"));
|
|
|
jsonOb.put("roomName", COMMON.isEmpty(records.get("class_room_name"))?"":records.get("class_room_name"));
|
|
|
jsonOb.put("classId", records.get("classId"));
|
|
|
jsonOb.put("teacherId", records.get("teacherId"));
|
|
|
jsonOb.put("courseId", records.get("courseId"));
|
|
|
jsonOb.put("type", records.get("type"));
|
|
|
jsonOb.put("baseClassId", COMMON.isEmpty(records.get("base_class_id"))?-1:records.get("base_class_id"));
|
|
|
jsonOb.put("baseClassType", COMMON.isEmpty(records.get("base_class_type"))?-1:records.get("base_class_type"));
|
|
|
String courseId = String.valueOf(records.get("courseId"));
|
|
|
if("0".equals(courseId)){
|
|
|
getZouJsonOb(jsonOb, records.get("type").toString());
|
|
|
}
|
|
|
return jsonOb ;
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* @description 导出教师课表
|
|
|
* @author Mr.zms
|
|
|
* @date 2019/4/17
|
|
|
* @return java.io.File
|
|
|
*/
|
|
|
public HSSFWorkbook exportTeacherCourseTable(String uuid,String week ,String subjectId, String personId,String parameterType) {
|
|
|
//获取教师LIST
|
|
|
HSSFWorkbook wb ;
|
|
|
if(COMMON.isEmpty(week)){
|
|
|
wb = exportTeacherCourseTable(uuid,subjectId,personId,parameterType);
|
|
|
}else {
|
|
|
wb = exportTeacherCourseTableWeek(uuid,week,subjectId,personId,parameterType);
|
|
|
}
|
|
|
return wb;
|
|
|
}
|
|
|
private HSSFWorkbook exportTeacherCourseTableWeek(String uuid, String week , String subjectId, String personId, String parameterType){
|
|
|
List<Record> teacherList = CourseSelectTimeModel.dao.getReleaseTeacherList(uuid,week,subjectId,personId,"");
|
|
|
List<Record> list = CourseSelectTimeModel.dao.getCourseTableByUuidWeek(uuid, week, "","",personId,"","","","","");
|
|
|
String[] value = {"person_name", "person_id", "teacherId"};
|
|
|
//获取天数
|
|
|
JSONObject dayJson = getCourseTableTimeByUuid(uuid);
|
|
|
return getHSSFWorkbook(dayJson,list,teacherList,value,parameterType);
|
|
|
}
|
|
|
private HSSFWorkbook exportTeacherCourseTable(String uuid,String subjectId, String personId,String parameterType){
|
|
|
List<Record> teacherList = CourseSelectTimeModel.dao.getTeacherListByUuid(uuid, subjectId,personId); ;
|
|
|
List<Record> list = CourseSelectTimeModel.dao.getCourseTableByUuid(uuid, "", "",personId,"","","","","");
|
|
|
String[] value = {"person_name", "person_id", "teacherId"};
|
|
|
//获取天数
|
|
|
JSONObject dayJson = getCourseTableTimeByUuid(uuid);
|
|
|
return getHSSFWorkbook(dayJson,list,teacherList,value,parameterType);
|
|
|
}
|
|
|
|
|
|
private String [] analysisParameterType(String parameterType){
|
|
|
//parameter_type = {subjectName:1,className:1,teacherName:1,roomName:1}
|
|
|
String [] parameter = {"subjectName","roomName","className","teacherName"};
|
|
|
JSONObject jsonObject = new JSONObject();
|
|
|
try {
|
|
|
jsonObject = JSONObject.parseObject(parameterType);
|
|
|
}catch (JSONException e){
|
|
|
e.printStackTrace();
|
|
|
}
|
|
|
List<String> list = new ArrayList<>();
|
|
|
if(!COMMON.isEmpty(jsonObject)){
|
|
|
for (String parameterObj : parameter) {
|
|
|
if(!COMMON.isEmpty(jsonObject.get(parameterObj))){
|
|
|
String status = String.valueOf(jsonObject.get(parameterObj));
|
|
|
if("1".equals(status)){
|
|
|
list.add(parameterObj);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if(!COMMON.isEmpty(list)&&list.size() > 0 ){
|
|
|
int size = list.size();
|
|
|
parameter = list.toArray(new String[size]);
|
|
|
}
|
|
|
return parameter;
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* @description 创建课表的sheet页
|
|
|
* @author Mr.zms
|
|
|
* @date 2019/4/17
|
|
|
* @return org.apache.poi.hssf.usermodel.HSSFSheet
|
|
|
*/
|
|
|
private HSSFSheet createCourseTableSheet(HSSFSheet sheet, String sheetName, JSONObject dayJson){
|
|
|
boolean success = dayJson.getBooleanValue("success");
|
|
|
if(success){
|
|
|
JSONObject dayInfo = dayJson.getJSONObject("classInfo");
|
|
|
int weekCount = dayInfo.getIntValue("week_of_class_count") ;
|
|
|
int sectionCount = dayInfo.getIntValue("morning_of_class_count") + dayInfo.getIntValue("afternoon_of_class_count");
|
|
|
HSSFRow row1 = sheet.createRow(0);
|
|
|
HSSFCell cell1 = row1.createCell(3);
|
|
|
cell1.setCellValue(sheetName);
|
|
|
//创建课表格子
|
|
|
sectionCount = sectionCount +2 ;
|
|
|
for (int i = 1; i <sectionCount ; i++) {
|
|
|
HSSFRow row = sheet.createRow(i);
|
|
|
row.setHeight((short)1000);
|
|
|
for (int j = 0; j < weekCount+1; j++) {
|
|
|
HSSFCell cell = row.createCell(j);
|
|
|
if(1 == i && j > 0){
|
|
|
cell.setCellValue("星期"+j);
|
|
|
}else if(0 == j && i > 1 ){
|
|
|
cell.setCellValue("节数"+(i-1));
|
|
|
}
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
}
|
|
|
return sheet ;
|
|
|
}
|
|
|
|
|
|
public HSSFWorkbook exportRoomCourseTable(String uuid, String week ,String roomId,String parameterType) {
|
|
|
//获取教室LIST
|
|
|
HSSFWorkbook wb ;
|
|
|
if(COMMON.isEmpty(week)){
|
|
|
wb = exportRoomCourseTable(uuid,roomId,parameterType);
|
|
|
}else {
|
|
|
wb = exportRoomCourseTableWeek(uuid,week,roomId,parameterType);
|
|
|
}
|
|
|
return wb;
|
|
|
}
|
|
|
private HSSFWorkbook exportRoomCourseTable(String uuid,String roomId,String parameterType){
|
|
|
//获取教室LIST
|
|
|
List<Record> roomList = CourseSelectTimeModel.dao.getRoomListByUuid(uuid,roomId,"");
|
|
|
//获取课节信息LIST
|
|
|
List<Record> list = CourseSelectTimeModel.dao.getCourseTableByUuid(uuid,"", "","",roomId,"","","","");
|
|
|
String[] value = {"class_room_name", "class_room_id", "roomId"};
|
|
|
//获取天数
|
|
|
JSONObject dayJson = getCourseTableTimeByUuid(uuid);
|
|
|
return getHSSFWorkbook(dayJson,list,roomList,value,parameterType);
|
|
|
}
|
|
|
private HSSFWorkbook exportRoomCourseTableWeek(String uuid,String week,String roomId,String parameterType){
|
|
|
//获取教室LIST
|
|
|
List<Record> roomList = CourseSelectTimeModel.dao.getRoomListByUuidWeek(uuid,week,roomId);
|
|
|
//获取课节信息LIST
|
|
|
List<Record> list = CourseSelectTimeModel.dao.getCourseTableByUuidWeek(uuid, week,"", "","",roomId,"","","","");
|
|
|
String[] value = {"class_room_name", "class_room_id", "roomId"};
|
|
|
//获取天数
|
|
|
JSONObject dayJson = getCourseTableTimeByUuid(uuid);
|
|
|
return getHSSFWorkbook(dayJson,list,roomList,value,parameterType);
|
|
|
}
|
|
|
|
|
|
public HSSFCellStyle getCellStyle(HSSFWorkbook wb){
|
|
|
HSSFCellStyle cellStyle=wb.createCellStyle();
|
|
|
// 左右居中 上下居中
|
|
|
cellStyle.setAlignment(HSSFCellStyle.ALIGN_CENTER);
|
|
|
cellStyle.setVerticalAlignment(HSSFCellStyle.VERTICAL_CENTER);
|
|
|
//自动换行
|
|
|
cellStyle.setWrapText(true);
|
|
|
cellStyle.setAlignment(HSSFCellStyle.ALIGN_CENTER);
|
|
|
cellStyle.setBorderBottom(HSSFCellStyle.BORDER_THIN);
|
|
|
cellStyle.setBorderLeft(HSSFCellStyle.BORDER_THIN);
|
|
|
cellStyle.setBorderTop(HSSFCellStyle.BORDER_THIN);
|
|
|
cellStyle.setBorderRight(HSSFCellStyle.BORDER_THIN);
|
|
|
return cellStyle ;
|
|
|
}
|
|
|
|
|
|
private HSSFWorkbook getHSSFWorkbook(JSONObject dayJson,List<Record> list ,List<Record> elementList,String [] value,String parameterType){
|
|
|
HSSFWorkbook wb = new HSSFWorkbook();
|
|
|
//单元格样式
|
|
|
HSSFCellStyle cellStyle=getCellStyle(wb) ;
|
|
|
JSONObject resultJson = new JSONObject() ;
|
|
|
//获取课表
|
|
|
JSONArray jsonArr = getDaySectionArray(list, resultJson);
|
|
|
for (Record teacher : elementList) {
|
|
|
String sheetValue = teacher.getStr(value[0]);
|
|
|
String compareValue = String.valueOf(teacher.get(value[1]));
|
|
|
if(value.length ==5 ){
|
|
|
compareValue += String.valueOf(teacher.get(value[3]));
|
|
|
}
|
|
|
String sheetName = sheetValue + "的课表";
|
|
|
HSSFSheet sheet = wb.createSheet(sheetName);
|
|
|
Map<Integer,Short> maxHeight = new HashMap<>();
|
|
|
createCourseTable(sheet,sheetName,0,dayJson,cellStyle,maxHeight);
|
|
|
for (int j = 0; j < jsonArr.size(); j++) {
|
|
|
JSONObject jsonObject = jsonArr.getJSONObject(j);
|
|
|
String compareValue1 = String.valueOf(jsonObject.get(value[2]));
|
|
|
if(value.length==5){
|
|
|
compareValue1 += String.valueOf(jsonObject.get(value[4]));
|
|
|
}
|
|
|
if (compareValue.equals(compareValue1)) {
|
|
|
String [] valueArray = analysisParameterType(parameterType);
|
|
|
setCellValue(jsonObject,sheet,valueArray,maxHeight);
|
|
|
}
|
|
|
}
|
|
|
//如果是班级课表查询走班课节
|
|
|
if(value.length == 5){
|
|
|
String uuid= String.valueOf(dayJson.get("uuid"));
|
|
|
getClassCourseTableSheet(uuid,teacher,sheet,maxHeight);
|
|
|
}
|
|
|
}
|
|
|
return wb ;
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* @description 导出班级课表
|
|
|
* @author Mr.zms
|
|
|
* @date 2019/4/18
|
|
|
* @return java.io.File
|
|
|
*/
|
|
|
public HSSFWorkbook exportClassCourseTable(String uuid, String week ,String baseClassId, String baseClassType,String parameterType) {
|
|
|
HSSFWorkbook wb = new HSSFWorkbook();
|
|
|
//获取班级LIST
|
|
|
String classStr = getTimeTableClassInfoByUuid(uuid,"",baseClassId,baseClassType);
|
|
|
JSONObject jsonObject = JSONObject.parseObject(classStr);
|
|
|
if(jsonObject.getBooleanValue("success")){
|
|
|
JSONArray jsonArray =jsonObject.getJSONArray("table_List");
|
|
|
List<Record> elementList = ToolsUtil.JSONArray2List(jsonArray);
|
|
|
//获取课节信息LIST
|
|
|
List<Record> list;
|
|
|
if(COMMON.isEmpty(week)){
|
|
|
list = CourseSelectTimeModel.dao.getCourseTableByUuid(uuid, baseClassId, baseClassType,"","","0","","","");
|
|
|
}else {
|
|
|
list = CourseSelectTimeModel.dao.getCourseTableByUuidWeek(uuid,week,baseClassId, baseClassType,"","","0","","","");
|
|
|
}
|
|
|
String[] value = {"CLASS_NAME", "BASE_CLASS_ID", "baseClassId", "BASE_CLASS_TYPE","baseClassType"};
|
|
|
//获取天数
|
|
|
JSONObject dayJson = getCourseTableTimeByUuid(uuid);
|
|
|
wb= getHSSFWorkbook(dayJson,list,elementList,value,parameterType);
|
|
|
}
|
|
|
return wb;
|
|
|
}
|
|
|
|
|
|
public HSSFWorkbook exportCourseTableYear(String uuid,String week,String parameterType,String type) {
|
|
|
//获取天数
|
|
|
JSONObject dayJson = getCourseTableTimeByUuid(uuid);
|
|
|
JSONObject classInfo = dayJson.getJSONObject("classInfo");
|
|
|
HSSFWorkbook wb;
|
|
|
if(COMMON.isEmpty(week)){
|
|
|
wb = exportCourseTableYear(uuid,classInfo,parameterType,type);
|
|
|
}else {
|
|
|
wb = exportCourseTableYearWeek(uuid,week,classInfo,parameterType,type);
|
|
|
}
|
|
|
return wb;
|
|
|
}
|
|
|
|
|
|
private HSSFWorkbook exportCourseTableYear(String uuid,JSONObject classInfo,String parameterType,String verticalType){
|
|
|
JSONObject resultJson = new JSONObject();
|
|
|
HSSFWorkbook wb = new HSSFWorkbook();
|
|
|
//班级List
|
|
|
String string = getTimeTableClassInfoByUuid(uuid,"","","");
|
|
|
JSONArray classArray = JSON.parseObject(string).getJSONArray("table_List");
|
|
|
//教室List
|
|
|
List<Record> roomList = CourseSelectTimeModel.dao.getRoomListByUuid(uuid,"","");
|
|
|
//课表List
|
|
|
List<Record> courseList = CourseSelectTimeModel.dao.getCourseTableByUuid(uuid, "", "", "", "", "", "", "", "");
|
|
|
//获取课表
|
|
|
JSONArray jsonArray = getDaySectionArray(courseList, resultJson);
|
|
|
List<Record> classList = ToolsUtil.JSONArray2List(classArray);
|
|
|
HSSFCellStyle cellStyle = getCellStyle(wb) ;
|
|
|
//导出班级-年级课表
|
|
|
createSheet(wb,cellStyle,classList,jsonArray,classInfo,1,parameterType,verticalType);
|
|
|
//教室年级课表
|
|
|
createSheet(wb,cellStyle,roomList,jsonArray,classInfo,2,parameterType,verticalType);
|
|
|
return wb;
|
|
|
}
|
|
|
private HSSFWorkbook exportCourseTableYearWeek(String uuid,String week,JSONObject classInfo,String parameterType,String verticalType){
|
|
|
JSONObject resultJson = new JSONObject();
|
|
|
HSSFWorkbook wb = new HSSFWorkbook();
|
|
|
//班级List
|
|
|
String string = getTimeTableClassInfoByUuid(uuid,week,"","");
|
|
|
JSONArray classArray = JSON.parseObject(string).getJSONArray("table_List");
|
|
|
//教室List
|
|
|
List<Record> roomList = CourseSelectTimeModel.dao.getRoomListByUuidWeek(uuid,week,"");
|
|
|
//课表List
|
|
|
List<Record> courseList = CourseSelectTimeModel.dao.getCourseTableByUuidWeek(uuid, week,"", "", "", "", "", "", "", "");
|
|
|
//获取课表
|
|
|
JSONArray jsonArray = getDaySectionArray(courseList, resultJson);
|
|
|
List<Record> classList = ToolsUtil.JSONArray2List(classArray);
|
|
|
HSSFCellStyle cellStyle = getCellStyle(wb) ;
|
|
|
//导出班级-年级课表
|
|
|
createSheet(wb,cellStyle,classList,jsonArray,classInfo,1,parameterType,verticalType);
|
|
|
//教室年级课表
|
|
|
createSheet(wb,cellStyle,roomList,jsonArray,classInfo,2,parameterType,verticalType);
|
|
|
return wb;
|
|
|
}
|
|
|
/**
|
|
|
* @description 获取教室课节细腻
|
|
|
* @author Mr.zms
|
|
|
* @date 2019/5/6
|
|
|
* @return java.lang.String
|
|
|
*/
|
|
|
private String getCellString(String classRoomId, JSONArray jsonArray, int day, int section,String parameterType) {
|
|
|
StringBuilder cellString = new StringBuilder();
|
|
|
for (int i = 0; i < jsonArray.size(); i++) {
|
|
|
JSONObject json = jsonArray.getJSONObject(i);
|
|
|
String roomId = String.valueOf(json.get("roomId"));
|
|
|
int day1 = json.getIntValue("day");
|
|
|
int section1 = json.getIntValue("section");
|
|
|
if(classRoomId.equals(roomId)&&day == day1 && section == section1 ){
|
|
|
String [] valueArray = analysisParameterType(parameterType);
|
|
|
if(!COMMON.isEmpty(cellString.toString())){
|
|
|
cellString.append("\r\n");
|
|
|
}
|
|
|
cellString.append(getAddCellValue(json, valueArray));
|
|
|
}
|
|
|
}
|
|
|
return cellString.toString();
|
|
|
}
|
|
|
/**
|
|
|
* @description 创建sheet页
|
|
|
* @author Mr.zms
|
|
|
* @date 2019/5/6
|
|
|
* @return void
|
|
|
*/
|
|
|
public void createSheet(HSSFWorkbook wb, HSSFCellStyle cellStyle, List<Record> classList, JSONArray jsonArray, JSONObject classInfo, int type, String parameterType, String verticalType) {
|
|
|
String sheetName = "班级-年级课表";
|
|
|
if(2 == type){
|
|
|
sheetName = "教室-年级课表";
|
|
|
}
|
|
|
HSSFSheet sheet = wb.createSheet(sheetName);
|
|
|
int weekCount = classInfo.getIntValue("week_of_class_count") ;
|
|
|
int row1 = Integer.parseInt(String.valueOf(classInfo.get("afternoon_of_class_count"))) ;
|
|
|
int row2 = Integer.parseInt(String.valueOf(classInfo.get("morning_of_class_count"))) ;
|
|
|
int row3 = Integer.parseInt(String.valueOf(classInfo.get("morning_study_count"))) ;
|
|
|
int row4 = Integer.parseInt(String.valueOf(classInfo.get("night_study_count"))) ;
|
|
|
if("0".equals(verticalType)){
|
|
|
//横版 年级课表
|
|
|
horizontalYearCourseTable(sheet,cellStyle,classList,jsonArray,parameterType,type,weekCount,row1,row2,row3,row4);
|
|
|
}else {
|
|
|
//竖版年级课表
|
|
|
verticalYearCourseTable(sheet,cellStyle,classList,jsonArray,parameterType,type,weekCount,row1,row2,row3,row4);
|
|
|
}
|
|
|
|
|
|
}
|
|
|
/**
|
|
|
* @description 竖版年级课表
|
|
|
* @author Mr.zms
|
|
|
* @date 2019/7/1
|
|
|
* @return void
|
|
|
*/
|
|
|
private void verticalYearCourseTable(HSSFSheet sheet, HSSFCellStyle cellStyle, List<Record> classList, JSONArray jsonArray, String parameterType, int type, int weekCount, int row1, int row2, int row3, int row4) {
|
|
|
//创建表头
|
|
|
short maxHeight = 500;
|
|
|
HSSFRow sheetRow1 = sheet.createRow(0);
|
|
|
HSSFRow sheetRow2 = sheet.createRow(1);
|
|
|
sheetRow1.setHeight(maxHeight);
|
|
|
int sectionCount = row1 + row2+row3+row4;;
|
|
|
int sumCount = weekCount * sectionCount ;
|
|
|
//创建了表头
|
|
|
for (int i = 1; i < sumCount+1; i++) {
|
|
|
int day = getDayInt(i,sectionCount);
|
|
|
int section = getSectionInt(i,sectionCount);
|
|
|
HSSFCell cell1 = sheetRow1.createCell(i);
|
|
|
cell1.setCellValue("星期"+day);
|
|
|
cell1.setCellStyle(cellStyle);
|
|
|
HSSFCell cell2 = sheetRow2.createCell(i);
|
|
|
String cellString = getSectionCellString(section,row1,row2,row3);
|
|
|
cell2.setCellValue(cellString);
|
|
|
cell2.setCellStyle(cellStyle);
|
|
|
}
|
|
|
//增加单元格内容
|
|
|
int rowCount = 2 ;
|
|
|
for (Record record : classList) {
|
|
|
HSSFRow hssfRow = sheet.createRow(rowCount);
|
|
|
rowCount++;
|
|
|
HSSFCell cell1 = hssfRow.createCell(0);
|
|
|
String key = "CLASS_NAME";
|
|
|
if(2 == type ){
|
|
|
key = "CLASS_ROOM_NAME";
|
|
|
}
|
|
|
cell1.setCellValue(String.valueOf(record.get(key)));
|
|
|
cell1.setCellStyle(cellStyle);
|
|
|
for (int i = 1; i < sumCount+1; i++) {
|
|
|
int day = getDayInt(i,sectionCount);
|
|
|
int section = getSectionInt(i,sectionCount);
|
|
|
HSSFCell cell2 = hssfRow.createCell(i);
|
|
|
String cellString = getTeacherSubjectInfo(record,type,jsonArray,day,section,parameterType);
|
|
|
short height = (short)((cellString.split("\n").length+1 ) * 225 );
|
|
|
if(height > maxHeight ){
|
|
|
maxHeight = height ;
|
|
|
hssfRow.setHeight(height);
|
|
|
}
|
|
|
cell2.setCellValue(cellString);
|
|
|
cell2.setCellStyle(cellStyle);
|
|
|
}
|
|
|
}
|
|
|
//合并单元格
|
|
|
int rowInt = 0 ;
|
|
|
for (int i1 = 0; i1 < weekCount; i1++) {
|
|
|
//起始行,结束行,起始列,结束列
|
|
|
int startCol = 1+(sectionCount*i1);
|
|
|
int endCol = sectionCount*(i1+1);
|
|
|
CellRangeAddress callRangeAddress = new CellRangeAddress(rowInt,rowInt, startCol, endCol);
|
|
|
setRegionStyle(sheet,callRangeAddress,cellStyle);
|
|
|
sheet.addMergedRegion(callRangeAddress);
|
|
|
|
|
|
}
|
|
|
}
|
|
|
|
|
|
private int getDayInt(int i ,int sectionCount){
|
|
|
int day;
|
|
|
if ((i % sectionCount) != 0) {
|
|
|
day = (i / sectionCount) + 1;
|
|
|
} else {
|
|
|
day = i / sectionCount;
|
|
|
}
|
|
|
return day;
|
|
|
}
|
|
|
private int getSectionInt(int i ,int sectionCount){
|
|
|
int section;
|
|
|
if ((i % sectionCount) != 0) {
|
|
|
section = i % sectionCount;
|
|
|
} else {
|
|
|
section = sectionCount;
|
|
|
}
|
|
|
return section;
|
|
|
}
|
|
|
private String getSectionCellString(int section,int row1,int row2,int row3){
|
|
|
String cellString = "节数"+(section - row3);
|
|
|
if(section<=row3){
|
|
|
cellString = "早"+section ;
|
|
|
}else if(section>(row1+row2+row3)){
|
|
|
cellString = "晚"+(section - (row1+row2+row3));
|
|
|
}
|
|
|
return cellString;
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* @description 横版年级课表
|
|
|
* @author Mr.zms
|
|
|
* @date 2019/7/1
|
|
|
* @return void
|
|
|
*/
|
|
|
private void horizontalYearCourseTable(HSSFSheet sheet,HSSFCellStyle cellStyle,List<Record> classList,JSONArray jsonArray,String parameterType,int type,int weekCount,int row1,int row2,int row3,int row4){
|
|
|
int sectionCount = row1 + row2+row3+row4;;
|
|
|
int sumCount = weekCount * sectionCount ;
|
|
|
//创建表头
|
|
|
short maxHeight = 500;
|
|
|
createLine(sheet,maxHeight,cellStyle,classList,type);
|
|
|
for (int i = 1; i < sumCount+1; i++) {
|
|
|
int day = getDayInt(i,sectionCount);
|
|
|
int section = getSectionInt(i,sectionCount);
|
|
|
HSSFRow hssfRow = sheet.createRow(i);
|
|
|
hssfRow.setHeight(maxHeight);
|
|
|
for (int j = 0; j < classList.size()+3; j++) {
|
|
|
String cellString = "";
|
|
|
int index = j -3 ;
|
|
|
HSSFCell cell = hssfRow.createCell(j);
|
|
|
if(index>=0){
|
|
|
Record record = classList.get(index);
|
|
|
cellString = getTeacherSubjectInfo(record,type,jsonArray,day,section,parameterType);
|
|
|
short height = (short)((cellString.split("\n").length+1 ) * 225 );
|
|
|
if(height > maxHeight ){
|
|
|
maxHeight = height ;
|
|
|
hssfRow.setHeight(height);
|
|
|
}
|
|
|
}
|
|
|
if(0 == j){
|
|
|
cellString = "星期"+day;
|
|
|
}
|
|
|
if(1 == j){
|
|
|
if(section<=row2){
|
|
|
cellString = "上午";
|
|
|
}else {
|
|
|
cellString = "下午";
|
|
|
}
|
|
|
}
|
|
|
if(2 == j){
|
|
|
cellString = getSectionCellString(section,row1,row2,row3);
|
|
|
}
|
|
|
cell.setCellValue(cellString);
|
|
|
cell.setCellStyle(cellStyle);
|
|
|
}
|
|
|
}
|
|
|
int colNumber = 2 ;
|
|
|
for (int i = 0; i < colNumber; i++) {
|
|
|
for (int i1 = 0; i1 < weekCount; i1++) {
|
|
|
int firstRow = i1*sectionCount ;
|
|
|
int lastRow = firstRow+row2+row3 ;
|
|
|
int lastRow2 = lastRow+row1+row4 ;
|
|
|
firstRow = firstRow+1;
|
|
|
if(0 ==i ){
|
|
|
//起始行,结束行,起始列,结束列
|
|
|
CellRangeAddress callRangeAddress = new CellRangeAddress(firstRow,lastRow2, i, i);
|
|
|
setRegionStyle(sheet,callRangeAddress,cellStyle);
|
|
|
sheet.addMergedRegion(callRangeAddress);
|
|
|
}else{
|
|
|
CellRangeAddress callRangeAddress = new CellRangeAddress(firstRow,lastRow, i, i);
|
|
|
setRegionStyle(sheet,callRangeAddress,cellStyle);
|
|
|
sheet.addMergedRegion(callRangeAddress);
|
|
|
lastRow = lastRow+1 ;
|
|
|
CellRangeAddress callRangeAddress2 = new CellRangeAddress(lastRow,lastRow2, i, i);
|
|
|
setRegionStyle(sheet,callRangeAddress,cellStyle);
|
|
|
sheet.addMergedRegion(callRangeAddress2);
|
|
|
}
|
|
|
sheet.getRow(firstRow).getCell(i);
|
|
|
sheet.getRow(lastRow).getCell(i);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
/**
|
|
|
* @description 获取课节信息
|
|
|
* @author Mr.zms
|
|
|
* @date 2019/5/6
|
|
|
* @return java.lang.String
|
|
|
*/
|
|
|
private String getTeacherSubjectInfo(Record record,int type,JSONArray jsonArray ,int day,int section,String parameterType){
|
|
|
String cellString;
|
|
|
if(1 == type){
|
|
|
String baseClassId = String.valueOf(record.get("BASE_CLASS_ID"));
|
|
|
String baseClassType = String.valueOf(record.get("BASE_CLASS_TYPE"));
|
|
|
cellString = getCellString(baseClassId,baseClassType,jsonArray,day,section,parameterType);
|
|
|
}else{
|
|
|
String classRoomId = String.valueOf(record.get("CLASS_ROOM_ID"));
|
|
|
cellString = getCellString(classRoomId,jsonArray,day,section,parameterType);
|
|
|
}
|
|
|
return cellString;
|
|
|
}
|
|
|
/**
|
|
|
* @description 获取班级对应的课程信息
|
|
|
* @author Mr.zms
|
|
|
* @date 2019/5/6
|
|
|
* @return java.lang.String
|
|
|
*/
|
|
|
private String getCellString(String baseClassId,String baseClassType ,JSONArray jsonArray,int day,int section,String parameterType){
|
|
|
StringBuilder cellString = new StringBuilder();
|
|
|
for (int i = 0; i < jsonArray.size(); i++) {
|
|
|
JSONObject json = jsonArray.getJSONObject(i);
|
|
|
String classId = String.valueOf(json.get("baseClassId"));
|
|
|
String classType = String.valueOf(json.get("baseClassType"));
|
|
|
int day1 = json.getIntValue("day");
|
|
|
int section1 = json.getIntValue("section");
|
|
|
if(baseClassId.equals(classId)&&baseClassType.equals(classType)&&day == day1 && section == section1 ){
|
|
|
String [] valueArray = analysisParameterType(parameterType);
|
|
|
if(!COMMON.isEmpty(cellString.toString())){
|
|
|
cellString.append("\r\n");
|
|
|
}
|
|
|
cellString.append(getAddCellValue(json,valueArray));
|
|
|
}
|
|
|
}
|
|
|
return cellString.toString();
|
|
|
}
|
|
|
/**
|
|
|
* @description 创建表头
|
|
|
* @author Mr.zms
|
|
|
* @date 2019/5/6
|
|
|
* @return void
|
|
|
*/
|
|
|
private void createLine(HSSFSheet sheet,short maxHeight,HSSFCellStyle cellStyle,List<Record> classList,int type){
|
|
|
HSSFRow row = sheet.createRow(0);
|
|
|
row.setHeight(maxHeight);
|
|
|
for (int i = 0; i < classList.size()+3; i++) {
|
|
|
int index = i - 3 ;
|
|
|
HSSFCell cell = row.createCell(i);
|
|
|
if(index>=0){
|
|
|
sheet.setColumnWidth(i, 3766);
|
|
|
Record record = classList.get(index);
|
|
|
String key = "CLASS_NAME";
|
|
|
if(2 == type ){
|
|
|
key = "CLASS_ROOM_NAME";
|
|
|
}
|
|
|
String className = record.getStr(key);
|
|
|
cell.setCellValue(className);
|
|
|
}else{
|
|
|
sheet.setColumnWidth(i, 1800);
|
|
|
cell.setCellValue(" ");
|
|
|
}
|
|
|
cell.setCellStyle(cellStyle);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* @description 导出学生课表
|
|
|
* @author Mr.zms
|
|
|
* @date 2019/5/6
|
|
|
* @return java.io.File
|
|
|
*/
|
|
|
public HSSFWorkbook exportStudentCourseTable(String uuid, String week,String baseClassId,String parameterType) {
|
|
|
HSSFWorkbook wb;
|
|
|
if(COMMON.isEmpty(week)){
|
|
|
wb = exportStudentCourseTable(uuid,baseClassId,parameterType);
|
|
|
}else {
|
|
|
wb = exportStudentCourseTableWeek(uuid,week,baseClassId,parameterType);
|
|
|
}
|
|
|
return wb;
|
|
|
}
|
|
|
private HSSFWorkbook exportStudentCourseTable(String uuid,String baseClassId,String parameterType){
|
|
|
List<Record> list = CourseSelectTimeModel.dao.getCourseTableByUuid(uuid, "", "", "", "", "0", "", "", "");
|
|
|
//获取学生的所在班级
|
|
|
List<Record> studentClassList = CourseSelectTimeModel.dao.getStudentClassList(baseClassId);
|
|
|
return getStudentCourseTableSheet(uuid,list,studentClassList,"",parameterType);
|
|
|
}
|
|
|
private HSSFWorkbook exportStudentCourseTableWeek(String uuid,String week ,String baseClassId,String parameterType){
|
|
|
List<Record> list = CourseSelectTimeModel.dao.getCourseTableByUuidWeek(uuid, week,"", "", "", "", "0", "", "", "");
|
|
|
//获取学生的所在班级
|
|
|
List<Record> studentClassList = CourseSelectTimeModel.dao.getStudentClassList(baseClassId);
|
|
|
return getStudentCourseTableSheet(uuid,list,studentClassList,week,parameterType);
|
|
|
}
|
|
|
|
|
|
|
|
|
/**
|
|
|
* @description 学生课表sheet页
|
|
|
* @author Mr.zms
|
|
|
* @date 2019/5/6
|
|
|
* @return org.apache.poi.hssf.usermodel.HSSFWorkbook
|
|
|
*/
|
|
|
private HSSFWorkbook getStudentCourseTableSheet(String uuid,List<Record>list,List<Record> studentClassList,String week,String parameterType){
|
|
|
HSSFWorkbook wb = new HSSFWorkbook();
|
|
|
HSSFCellStyle cellStyle=getCellStyle(wb) ;
|
|
|
//获取天数
|
|
|
JSONObject dayJson = getCourseTableTimeByUuid(uuid);
|
|
|
//获取课表
|
|
|
JSONObject resultJson = new JSONObject() ;
|
|
|
JSONArray jsonArr = getDaySectionArray(list, resultJson);
|
|
|
// 学生新合班规则
|
|
|
int weekInt = 1 ;
|
|
|
if(!COMMON.isEmpty(week)){
|
|
|
weekInt = Integer.parseInt(week);
|
|
|
}
|
|
|
List<Record> mergingStudentList = CourseSelectTimeModel.dao.getMergingStudentList(uuid,weekInt);
|
|
|
for (int i = 0; i < studentClassList.size(); i++) {
|
|
|
Record student = studentClassList.get(i);
|
|
|
String personId = String.valueOf(student.get("student_id"));
|
|
|
String sheetValue = student.getStr("student_name");
|
|
|
int classId = Integer.parseInt(String.valueOf(student.get("class_id")));
|
|
|
String teacherClassIds = String.valueOf(student.get("teaching_class_ids")) ;
|
|
|
String sheetName = sheetValue + "的课表("+(i+1)+")";
|
|
|
HSSFSheet sheet = wb.createSheet(sheetName);
|
|
|
Map<Integer,Short> maxHeight = new HashMap<>();
|
|
|
createCourseTable(sheet,sheetName,0,dayJson,cellStyle,maxHeight);
|
|
|
for (int j = 0; j < jsonArr.size(); j++) {
|
|
|
JSONObject jsonObject = jsonArr.getJSONObject(j);
|
|
|
String baseClassId = String.valueOf(jsonObject.get("baseClassId"));
|
|
|
String baseClassType = String.valueOf(jsonObject.get("baseClassType"));
|
|
|
String courseId = String.valueOf(jsonObject.get("courseId"));
|
|
|
boolean flag = (checkMerging(mergingStudentList,Integer.parseInt(baseClassId),Integer.parseInt(baseClassType),Integer.parseInt(courseId),personId,classId));
|
|
|
boolean flag1 = "2".equals(baseClassType)&&ToolsUtil.arrayIncludeStr(teacherClassIds,baseClassId);
|
|
|
if (flag || flag1) {
|
|
|
String [] value = analysisParameterType(parameterType);
|
|
|
setCellValue(jsonObject,sheet,value,maxHeight);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
return wb ;
|
|
|
}
|
|
|
/**
|
|
|
* @description 设置单元格数据
|
|
|
* @author Mr.zms
|
|
|
* @date 2019/5/7
|
|
|
* @return void
|
|
|
*/
|
|
|
void setCellValue(JSONObject jsonObject,HSSFSheet sheet,String [] value,Map<Integer,Short> maxHeight){
|
|
|
int day = jsonObject.getIntValue("day");
|
|
|
int section = jsonObject.getIntValue("section") + 1;
|
|
|
HSSFRow row = getRow(sheet,section);
|
|
|
HSSFCell cell = getCell(row,day);
|
|
|
String addValue = getAddCellValue(jsonObject,value);
|
|
|
String cellValue = cell.toString();
|
|
|
if(!COMMON.isEmpty(cellValue)){
|
|
|
cellValue += "\r\n";
|
|
|
}
|
|
|
cellValue += addValue ;
|
|
|
int rwsTemp = cellValue.split("\r\n").length+1 ;
|
|
|
short height = (short)(rwsTemp * 228 );
|
|
|
if (!COMMON.isEmpty(maxHeight.get(section))) {
|
|
|
if(height > maxHeight.get(section) ){
|
|
|
row.setHeight(height);
|
|
|
maxHeight.put(section,height);
|
|
|
}
|
|
|
}
|
|
|
cell.setCellValue(cellValue);
|
|
|
}
|
|
|
/**
|
|
|
* @description 获取新增的单元格内容
|
|
|
* @author Mr.zms
|
|
|
* @date 2019/5/7
|
|
|
* @return java.lang.String
|
|
|
*/
|
|
|
String getAddCellValue(JSONObject jsonObject,String [] valueArray){
|
|
|
StringBuilder addValue = new StringBuilder(String.valueOf(jsonObject.get(valueArray[0])));
|
|
|
String singleDouble = String.valueOf(jsonObject.get("single_double"));
|
|
|
if("1".equals(singleDouble)){
|
|
|
addValue.append("(单周)");
|
|
|
}else if("2".equals(singleDouble)){
|
|
|
addValue.append("(双周)");
|
|
|
}
|
|
|
for (int i = 1; i < valueArray.length; i++) {
|
|
|
if(!COMMON.isEmpty(jsonObject.get(valueArray[i]))){
|
|
|
addValue.append("\r\n").append(jsonObject.get(valueArray[i]));
|
|
|
}
|
|
|
}
|
|
|
return addValue.toString();
|
|
|
}
|
|
|
|
|
|
|
|
|
HSSFRow getRow(HSSFSheet sheet , int section){
|
|
|
HSSFRow row;
|
|
|
if (!COMMON.isEmpty(sheet.getRow(section))) {
|
|
|
row = sheet.getRow(section);
|
|
|
} else {
|
|
|
row = sheet.createRow(section);
|
|
|
}
|
|
|
return row ;
|
|
|
}
|
|
|
HSSFCell getCell(HSSFRow row ,int day){
|
|
|
HSSFCell cell ;
|
|
|
if (!COMMON.isEmpty(row.getCell(day))) {
|
|
|
cell = row.getCell(day);
|
|
|
} else {
|
|
|
cell = row.createCell(day);
|
|
|
}
|
|
|
return cell ;
|
|
|
}
|
|
|
|
|
|
void createCourseTable(HSSFSheet sheet,String handName,int startLine,JSONObject dayJson,HSSFCellStyle cellStyle,Map<Integer,Short> maxHeight){
|
|
|
JSONObject dayInfo = dayJson.getJSONObject("classInfo");
|
|
|
boolean success = dayJson.getBooleanValue("success");
|
|
|
if(success){
|
|
|
int weekCount = dayInfo.getIntValue("week_of_class_count") + 1;
|
|
|
int row2 = Integer.parseInt(String.valueOf(dayInfo.get("morning_of_class_count"))) ;
|
|
|
int row3 = Integer.parseInt(String.valueOf(dayInfo.get("morning_study_count"))) ;
|
|
|
int row4 = Integer.parseInt(String.valueOf(dayInfo.get("afternoon_of_class_count"))) ;
|
|
|
int row5 = Integer.parseInt(String.valueOf(dayInfo.get("night_study_count"))) ;
|
|
|
int sectionCount = row2+row3+row4+row5;
|
|
|
HSSFRow row1 = getRow(sheet, 0);
|
|
|
short height = 1000;
|
|
|
maxHeight.put(0,height);
|
|
|
row1.setHeight(height);
|
|
|
//参数1：起始行 参数2：终止行 参数3：起始列 参数4：终止列
|
|
|
HSSFCell cell1 = row1.createCell(startLine);
|
|
|
cell1.setCellValue(handName);
|
|
|
CellRangeAddress region = new CellRangeAddress(0,0, (short)startLine , (short) (startLine+weekCount-1));
|
|
|
setRegionStyle(sheet,region,cellStyle);
|
|
|
sheet.addMergedRegion(region);
|
|
|
for (int line = 1; line < sectionCount + 2; line++) {
|
|
|
HSSFRow row = getRow(sheet, line);
|
|
|
int week = 1;
|
|
|
row.setHeight(height);
|
|
|
maxHeight.put(line,height);
|
|
|
sheet.setColumnWidth(line, 3766);
|
|
|
for (int rowInt = startLine; rowInt < startLine + weekCount; rowInt++) {
|
|
|
HSSFCell cell = getCell(row, rowInt);
|
|
|
if (line == 1 && rowInt != startLine) {
|
|
|
cell.setCellValue("星期" + week);
|
|
|
week++;
|
|
|
} else if (line != 1 && rowInt == startLine) {
|
|
|
if((line-1)<=row3){
|
|
|
cell.setCellValue("早" + (line - 1));
|
|
|
}else if ((line-1)>(row2+row3+row4)){
|
|
|
cell.setCellValue("晚" + (line - 1-(row2+row3+row4)));
|
|
|
}else {
|
|
|
cell.setCellValue("节数" + (line - 1-row3));
|
|
|
}
|
|
|
}
|
|
|
cell.setCellStyle(cellStyle);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
public void setRegionStyle(HSSFSheet sheet, CellRangeAddress region,HSSFCellStyle cs) {
|
|
|
for (int i = region.getFirstRow(); i <= region.getLastRow(); i++) {
|
|
|
HSSFRow row = getRow(sheet,i);
|
|
|
for (int j = region.getFirstColumn(); j <= region.getLastColumn(); j++) {
|
|
|
HSSFCell cell = getCell(row,j);
|
|
|
cell.setCellStyle(cs);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* @description 校验新合班规则 行政班
|
|
|
* @author Mr.zms
|
|
|
* @date 2019/5/7
|
|
|
* @return boolean
|
|
|
*/
|
|
|
private boolean checkMerging(List<Record> mergingStudentList,int baseClassId,int baseClassType,int courseId,String personId,int classId){
|
|
|
boolean flag = false ;
|
|
|
if(1==baseClassType){
|
|
|
flag = baseClassId == classId ;
|
|
|
for (Record record : mergingStudentList) {
|
|
|
String studentId = String.valueOf(record.get("student_id"));
|
|
|
if(personId.equals(studentId)){
|
|
|
int sourceClassId = record.get("source_class_id");
|
|
|
int sourceSubjectId = record.get("source_subject_id");
|
|
|
int targetClassId = record.get("target_class_id");
|
|
|
int targetSubjectId = record.get("target_subject_id");
|
|
|
if(baseClassId == sourceClassId ){
|
|
|
flag = sourceSubjectId != courseId;
|
|
|
}else if(targetClassId == baseClassId){
|
|
|
flag = targetSubjectId==courseId;
|
|
|
break;
|
|
|
}else{
|
|
|
flag = false;
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
return flag ;
|
|
|
}
|
|
|
/**
|
|
|
* @description 添加走班信息
|
|
|
* @author Mr.zms
|
|
|
* @date 2019/5/6
|
|
|
* @return void
|
|
|
*/
|
|
|
private void getClassCourseTableSheet(String uuid , Record classObj, HSSFSheet sheet,Map<Integer,Short> maxHeight){
|
|
|
String baseClassId = String.valueOf(classObj.get("BASE_CLASS_ID"));
|
|
|
String baseClassType = String.valueOf(classObj.get("BASE_CLASS_TYPE"));
|
|
|
List<Record> list = CourseSelectTimeModel.dao.getZouClassInfo(uuid,baseClassId,baseClassType);
|
|
|
for (Record record : list) {
|
|
|
JSONObject jsonObject = ToolsUtil.Record2Object(record);
|
|
|
String [] valueArray = {"subject_name","person_name","class_name","class_room_name"};
|
|
|
setCellValue(jsonObject,sheet,valueArray,maxHeight);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* @description 根据班级查询id查询所有教师课表
|
|
|
* @author Mr.zms
|
|
|
* @date 2019/5/9
|
|
|
* @return com.alibaba.fastjson.JSONObject
|
|
|
*/
|
|
|
public JSONObject getTeacherTableByClassId(String taskId, String classId, String classType) {
|
|
|
JSONObject returnJson = new JSONObject();
|
|
|
//获取教师LIST
|
|
|
List<Record> teacherList = CourseSelectTimeModel.dao.getTeacherListByClassIdAndRoomId(taskId,classId,classType,"");
|
|
|
//获取全部课程信息
|
|
|
String taskIds = TaskService.service.getStepYearTaskIds(taskId);
|
|
|
List<Record> list = CourseSelectTimeModel.dao.getTaskCourseTable(taskIds,"","");
|
|
|
//获取课节和天数
|
|
|
Record weekOb = TaskModel.dao.getMaxCourseClassInfo(taskIds);
|
|
|
JSONObject dayJson = ToolsUtil.Record2Object(weekOb);
|
|
|
JSONArray teacherArray =getCourseTableArray(teacherList,"teacherId",list,dayJson,classId,classType,"","");
|
|
|
returnJson.put("list",teacherArray);
|
|
|
returnJson.put("table_Time",dayJson);
|
|
|
returnJson.put("success", true);
|
|
|
returnJson.put("info", Constant.SUCCESS_INFO);
|
|
|
return returnJson;
|
|
|
}
|
|
|
|
|
|
|
|
|
public JSONArray getCourseTableArray(List<Record> valueList,String key,List<Record> list,JSONObject dayJson,String classId,String classType,String personId,String roomId){
|
|
|
JSONArray teacherArray = new JSONArray();
|
|
|
for (Record record : valueList) {
|
|
|
JSONObject json = ToolsUtil.Record2Object(record);
|
|
|
//教师list
|
|
|
String value = String.valueOf(record.get(key));
|
|
|
addCourseTableAttribute(json,key);
|
|
|
//班级课表放在arr二维数组里
|
|
|
JSONObject [][] arr = initializationArray(dayJson);
|
|
|
for(Record courseRecord : list ){
|
|
|
String compareValue = String.valueOf(courseRecord.get(key));
|
|
|
// 符合条件 的放入二维数组中
|
|
|
if(value.equals(compareValue)){
|
|
|
int dayClass = courseRecord.getInt("day")-1;
|
|
|
int sectionClass = courseRecord.getInt("section")-1;
|
|
|
int status = MergeCourseTableService.service.addArrAttributeValue(sectionClass, dayClass, arr, courseRecord);
|
|
|
if(1==status){
|
|
|
courseRecordAddPosition(courseRecord,classId,classType,roomId,personId,arr);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
json.put("table_array",arr);
|
|
|
teacherArray.add(json);
|
|
|
}
|
|
|
return teacherArray;
|
|
|
}
|
|
|
/**
|
|
|
* @description 返回前端标志是什么课表
|
|
|
* @author Mr.zms
|
|
|
* @date 2019/7/18
|
|
|
* @return void
|
|
|
*/
|
|
|
private void addCourseTableAttribute(JSONObject jsonObject,String key){
|
|
|
//设置默认值
|
|
|
String attribute = "class_table" ;
|
|
|
if("teacherId".equals(key)){
|
|
|
attribute = "teacher_table" ;
|
|
|
}
|
|
|
if("classId".equals(key)){
|
|
|
attribute = "class_table" ;
|
|
|
}
|
|
|
if("roomId".equals(key)){
|
|
|
attribute = "room_table" ;
|
|
|
}
|
|
|
jsonObject.put("attribute",attribute);
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* @description 根据教师id查询教师课表
|
|
|
* @author Mr.zms
|
|
|
* @date 2019/5/9
|
|
|
* @return void
|
|
|
*/
|
|
|
public JSONObject getTeacherTableByTeacherId(String taskId, String personId) {
|
|
|
JSONObject returnJson = new JSONObject();
|
|
|
//获取全部课程信息
|
|
|
String taskIds = TaskService.service.getStepYearTaskIds(taskId);
|
|
|
|
|
|
//获取教师课节信息
|
|
|
List<Record> list = CourseSelectTimeModel.dao.getTaskCourseTable(taskIds, personId,"");
|
|
|
//获取课节和天数
|
|
|
Record weekOb = TaskModel.dao.getMaxCourseClassInfo(taskIds);
|
|
|
JSONObject dayJson = ToolsUtil.Record2Object(weekOb);
|
|
|
//班级课表放在arr二维数组里
|
|
|
JSONObject[][] arr = getTeacherCourseTable(dayJson,list);
|
|
|
returnJson.put("success", true);
|
|
|
returnJson.put("info", Constant.SUCCESS_INFO);
|
|
|
returnJson.put("table_array",arr);
|
|
|
returnJson.put("table_Time",dayJson);
|
|
|
return returnJson;
|
|
|
}
|
|
|
/**
|
|
|
* @description 根据教师id,查询所有执教班级课表
|
|
|
* @author Mr.zms
|
|
|
* @date 2019/5/9
|
|
|
* @return void
|
|
|
*/
|
|
|
public JSONObject getCourseTableByTeacherId(String taskId, String personId) {
|
|
|
JSONObject returnJson = new JSONObject();
|
|
|
List<Record> classList = CourseSelectTimeModel.dao.getClassListByTeacherId(taskId,personId,"");
|
|
|
//获取课节和天数
|
|
|
Record weekOb = TaskService.service.getMaxDayJson(taskId);
|
|
|
JSONObject dayJson = ToolsUtil.Record2Object(weekOb);
|
|
|
//获取全部课程信息
|
|
|
List<Record> list = CourseSelectTimeModel.dao.getTaskCourseTable(taskId,"","");
|
|
|
JSONArray teacherArray = getClassCourseList(classList,list,dayJson,personId,"");
|
|
|
returnJson.put("success", true);
|
|
|
returnJson.put("info", Constant.SUCCESS_INFO);
|
|
|
returnJson.put("list",teacherArray);
|
|
|
returnJson.put("table_Time",dayJson);
|
|
|
return returnJson;
|
|
|
}
|
|
|
/**
|
|
|
* @description 班级课表List
|
|
|
* @author Mr.zms
|
|
|
* @date 2019/5/9
|
|
|
* @return com.alibaba.fastjson.JSONArray
|
|
|
*/
|
|
|
public JSONArray getClassCourseList(List<Record> classList,List<Record> list,JSONObject dayJson,String personId,String roomId){
|
|
|
JSONArray teacherArray = new JSONArray();
|
|
|
for (Record classObj : classList) {
|
|
|
JSONObject json = ToolsUtil.Record2Object(classObj);
|
|
|
addCourseTableAttribute(json,"classId");
|
|
|
//班级课表放在arr二维数组里
|
|
|
JSONObject [][] arr = initializationArray(dayJson);
|
|
|
int classId = classObj.get("class_id");
|
|
|
int classType = classObj.get("class_type");
|
|
|
for (Record courseRecord : list) {
|
|
|
int courseClassId = courseRecord.get("classId");
|
|
|
int courseClassType = courseRecord.get("classType");
|
|
|
if(classId == courseClassId && classType == courseClassType){
|
|
|
int dayClass = courseRecord.get("day");
|
|
|
int sectionClass = courseRecord.get("section");
|
|
|
courseRecordAddPosition(courseRecord,"","",roomId,personId,arr);
|
|
|
MergeCourseTableService.service.addArrAttributeValue(sectionClass-1, dayClass-1, arr, courseRecord);
|
|
|
}
|
|
|
}
|
|
|
json.put("table_array",arr);
|
|
|
teacherArray.add(json);
|
|
|
}
|
|
|
return teacherArray ;
|
|
|
}
|
|
|
private int compareValue(String value ,String key,Record courseRecord){
|
|
|
String compareValue = String.valueOf(courseRecord.get(key));
|
|
|
if(value.equals(compareValue)){
|
|
|
return 1 ;
|
|
|
}
|
|
|
return 0 ;
|
|
|
}
|
|
|
private void courseRecordAddPosition(Record courseRecord,String classId,String classType,String roomId,String personId,JSONObject [][] arr){
|
|
|
int position = 0 ;
|
|
|
int x = courseRecord.getInt("section")-1;
|
|
|
int y = courseRecord.getInt("day")-1;
|
|
|
if(!COMMON.isEmpty(classId)&&!COMMON.isEmpty(classType)){
|
|
|
String teacherClassId = String.valueOf(courseRecord.get("classId"));
|
|
|
String teacherClassType = String.valueOf(courseRecord.get("classType"));
|
|
|
if(teacherClassId.equals(classId)&&classType.equals(teacherClassType)){
|
|
|
position = 1 ;
|
|
|
}
|
|
|
}
|
|
|
if(!COMMON.isEmpty(personId)){
|
|
|
position = compareValue(personId,"teacherId",courseRecord);
|
|
|
}
|
|
|
if(!COMMON.isEmpty(roomId)){
|
|
|
position = compareValue(roomId,"roomId",courseRecord);
|
|
|
}
|
|
|
if(0==arr[x][y].getIntValue("position_type")&&0!=position){
|
|
|
arr[x][y].put("position_type", position);
|
|
|
}
|
|
|
}
|
|
|
/**
|
|
|
* @description 获取教师课表
|
|
|
* @author Mr.zms
|
|
|
* @date 2019/5/10
|
|
|
* @return com.alibaba.fastjson.JSONObject[][]
|
|
|
*/
|
|
|
public JSONObject[][] getTeacherCourseTable(JSONObject dayJson,List<Record> list){
|
|
|
JSONObject[][] arr = initializationArray(dayJson);
|
|
|
for (Record courseRecord : list) {
|
|
|
int section = courseRecord.getInt("section")-1;
|
|
|
int day = courseRecord.getInt("day")-1;
|
|
|
int status = MergeCourseTableService.service.addArrAttributeValue(section, day, arr, courseRecord);
|
|
|
if(1==status){
|
|
|
arr[section][day].put("section_type", 0);
|
|
|
}
|
|
|
}
|
|
|
return arr ;
|
|
|
}
|
|
|
public JSONObject getTeacherList(String taskId) {
|
|
|
JSONObject returnJson = new JSONObject();
|
|
|
List<Record> classList = CourseSelectTimeModel.dao.getTeacherList(taskId);
|
|
|
returnJson.put("list", COMMON.convertListRecord2(classList));
|
|
|
returnJson.put("success",Constant.TRUE);
|
|
|
return returnJson;
|
|
|
}
|
|
|
|
|
|
public JSONObject getRoomTableByClassId(String taskId, String classId, String classType) {
|
|
|
JSONObject returnJson = new JSONObject();
|
|
|
//获取教室LIST
|
|
|
List<Record> roomList = CourseSelectTimeModel.dao.getRoomList(taskId,classId,classType,"");
|
|
|
//获取全部课程信息
|
|
|
List<Record> list = CourseSelectTimeModel.dao.getTaskCourseTable(taskId,"","");
|
|
|
//获取课节和天数
|
|
|
Record weekOb = TaskService.service.getMaxDayJson(taskId);
|
|
|
JSONObject dayJson = ToolsUtil.Record2Object(weekOb);
|
|
|
JSONArray jsonArray = getCourseTableArray(roomList,"roomId",list,dayJson,classId,classType,"","");
|
|
|
returnJson.put("list",jsonArray);
|
|
|
returnJson.put("table_Time",dayJson);
|
|
|
returnJson.put("success", true);
|
|
|
returnJson.put("info", Constant.SUCCESS_INFO);
|
|
|
return returnJson;
|
|
|
}
|
|
|
|
|
|
public String getRoomListByTaskId(String taskId) {
|
|
|
List<Record> list = CourseSelectTimeModel.dao.getRoomList(taskId,"","","");
|
|
|
return COMMON.convert2JsonStr(list);
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* @description 根据教师ID 获取教室课表
|
|
|
* @author Mr.zms
|
|
|
* @date 2019/7/5
|
|
|
* @return com.alibaba.fastjson.JSONObject
|
|
|
*/
|
|
|
public JSONObject getRoomTableByTeacherId(String taskId, String personId) {
|
|
|
JSONObject returnJson = new JSONObject();
|
|
|
//教室列表
|
|
|
List<Record> roomList = CourseSelectTimeModel.dao.getRoomList(taskId,"","",personId);
|
|
|
//获取课节和天数
|
|
|
Record weekOb = TaskService.service.getMaxDayJson(taskId);
|
|
|
JSONObject dayJson = ToolsUtil.Record2Object(weekOb);
|
|
|
//获取全部课程信息
|
|
|
List<Record> list = CourseSelectTimeModel.dao.getTaskCourseTable(taskId,"","");
|
|
|
JSONArray teacherArray = getCourseTableArray(roomList,"roomId",list,dayJson,"","",personId,"");
|
|
|
returnJson.put("success", true);
|
|
|
returnJson.put("info", Constant.SUCCESS_INFO);
|
|
|
returnJson.put("list",teacherArray);
|
|
|
returnJson.put("table_Time",dayJson);
|
|
|
return returnJson;
|
|
|
}
|
|
|
|
|
|
public JSONObject getRoomTableByRoomId(String taskId, String roomId) {
|
|
|
JSONObject returnJson = new JSONObject();
|
|
|
//获取教师课节信息
|
|
|
List<Record> list = CourseSelectTimeModel.dao.getTaskCourseTable(taskId, "",roomId);
|
|
|
//获取课节和天数
|
|
|
Record weekOb = TaskService.service.getMaxDayJson(taskId);
|
|
|
JSONObject dayJson = ToolsUtil.Record2Object(weekOb);
|
|
|
//班级课表放在arr二维数组里
|
|
|
JSONObject[][] arr = getTeacherCourseTable(dayJson,list);
|
|
|
returnJson.put("success", true);
|
|
|
returnJson.put("info", Constant.SUCCESS_INFO);
|
|
|
returnJson.put("table_array",arr);
|
|
|
returnJson.put("table_Time",dayJson);
|
|
|
return returnJson;
|
|
|
}
|
|
|
|
|
|
public JSONObject getCourseTableByRoomId(String taskId, String roomId) {
|
|
|
JSONObject returnJson = new JSONObject();
|
|
|
List<Record> classList = CourseSelectTimeModel.dao.getClassListByTeacherId(taskId,"",roomId);
|
|
|
//获取课节和天数
|
|
|
Record weekOb = TaskService.service.getMaxDayJson(taskId);
|
|
|
JSONObject dayJson = ToolsUtil.Record2Object(weekOb);
|
|
|
//获取全部课程信息
|
|
|
List<Record> list = CourseSelectTimeModel.dao.getTaskCourseTable(taskId,"","");
|
|
|
JSONArray teacherArray = getClassCourseList(classList,list,dayJson,"",roomId);
|
|
|
returnJson.put("success", true);
|
|
|
returnJson.put("info", Constant.SUCCESS_INFO);
|
|
|
returnJson.put("list",teacherArray);
|
|
|
returnJson.put("table_Time",dayJson);
|
|
|
return returnJson;
|
|
|
}
|
|
|
|
|
|
public JSONObject getTeacherTableByRoomId(String taskId, String roomId) {
|
|
|
JSONObject returnJson = new JSONObject();
|
|
|
//获取教师LIST
|
|
|
List<Record> teacherList = CourseSelectTimeModel.dao.getTeacherListByClassIdAndRoomId(taskId,"","",roomId);
|
|
|
//获取全部课程信息
|
|
|
List<Record> list = CourseSelectTimeModel.dao.getTaskCourseTable(taskId,"","");
|
|
|
//获取课节和天数
|
|
|
Record weekOb = TaskService.service.getMaxDayJson(taskId);
|
|
|
JSONObject dayJson = ToolsUtil.Record2Object(weekOb);
|
|
|
JSONArray teacherArray =getCourseTableArray(teacherList,"teacherId",list,dayJson,"","","",roomId);
|
|
|
returnJson.put("list",teacherArray);
|
|
|
returnJson.put("table_Time",dayJson);
|
|
|
returnJson.put("success", true);
|
|
|
returnJson.put("info", Constant.SUCCESS_INFO);
|
|
|
return returnJson;
|
|
|
}
|
|
|
|
|
|
public JSONObject getTeacherCourseTable(String bureauId ,String week,String personId) {
|
|
|
JSONObject resultJson=new JSONObject();
|
|
|
resultJson.put("success", false);
|
|
|
resultJson.put("info", "暂无课表");
|
|
|
/*获取当前学期*/
|
|
|
JSONObject xqOb=BorrowUtil.getCurrentTerm();
|
|
|
String xqId=String.valueOf(xqOb.get("XQ_ID")) ;
|
|
|
List<Record> list = CourseSelectTimeModel.dao.getTeacherCourseTableWeek(bureauId,xqId,week,personId);
|
|
|
if(COMMON.isEmpty(list)){
|
|
|
return resultJson ;
|
|
|
}
|
|
|
/*拼接返回值*/
|
|
|
JSONArray jsonArr = getDaySectionArray(list, resultJson);
|
|
|
/*获取课节和天数（取最大值）*/
|
|
|
Record dayRecord = new Record().set("bureau_id",bureauId).set("xq_id",xqId);
|
|
|
Record record =TimetableAdjustModel.DAO.getCourseTableMaxTime(dayRecord);
|
|
|
JSONObject dayJson = ToolsUtil.Record2Object(record);
|
|
|
JSONObject dayJsonResult = new JSONObject();
|
|
|
if(!COMMON.isEmpty(dayJson)){
|
|
|
JSONObject [][] arr = initializationArray(dayJson);
|
|
|
courseTableAddToArray(jsonArr,arr);
|
|
|
if(!COMMON.isEmpty(arr)){
|
|
|
dayJsonResult.put("classInfo",dayJson);
|
|
|
resultJson.put("table_Time",dayJsonResult);
|
|
|
resultJson.put("table_arry", arr);
|
|
|
resultJson.put("success", true);
|
|
|
resultJson.put("info", Constant.SUCCESS_INFO);
|
|
|
return resultJson;
|
|
|
}
|
|
|
}
|
|
|
return resultJson;
|
|
|
}
|
|
|
|
|
|
public HSSFWorkbook exportTeacherCourseTableByTaskIds(String taskIds) {
|
|
|
List<Record> teacherList = CourseSelectTimeModel.dao.getTeacherListByTaskIds(taskIds); ;
|
|
|
List<Record> list = CourseSelectTimeModel.dao.getCourseTableByTaskIds(taskIds,"0");
|
|
|
HSSFWorkbook wb = new HSSFWorkbook();
|
|
|
//单元格样式
|
|
|
HSSFCellStyle cellStyle=getCellStyle(wb) ;
|
|
|
String [] taskIdArray = taskIds.split("，");
|
|
|
//获取天数
|
|
|
Record dayRecord = MergeCourseTableModel.dao.getWeekOfClassByTaskId(taskIdArray[0]);
|
|
|
JSONObject classInfo = ToolsUtil.Record2Object(dayRecord);
|
|
|
JSONObject dayJson = new JSONObject();
|
|
|
dayJson.put("success",true);
|
|
|
dayJson.put("classInfo",classInfo);
|
|
|
//获取课表
|
|
|
for (int i = 0; i < teacherList.size(); i++) {
|
|
|
Record teacher = teacherList.get(i);
|
|
|
String sheetValue = teacher.getStr("person_name");
|
|
|
String compareValue = String.valueOf(teacher.get("person_id"));
|
|
|
String sheetName = sheetValue + "的课表"+i;
|
|
|
HSSFSheet sheet = wb.createSheet(sheetName);
|
|
|
Map<Integer,Short> maxHeight = new HashMap<>();
|
|
|
createCourseTable(sheet,sheetName,0,dayJson,cellStyle,maxHeight);
|
|
|
for (Record record : list) {
|
|
|
JSONObject jsonObject = ToolsUtil.Record2Object(record);
|
|
|
String compareValue1 = String.valueOf(jsonObject.get("person_id"));
|
|
|
if (compareValue.equals(compareValue1)) {
|
|
|
String[] valueArray = {"subject_name", "room_name", "class_name", "teacher_name"};
|
|
|
setCellValue(jsonObject, sheet, valueArray, maxHeight);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
return wb;
|
|
|
}
|
|
|
|
|
|
public JSONObject getTeacherCourseWeekList(String bureauId,String stageId) throws ParseException {
|
|
|
return TimetableAdjustWeekService.service.getAdjustWeekList( bureauId, stageId, "", "");
|
|
|
}
|
|
|
|
|
|
public HSSFWorkbook exportYearCourseTableByTaskIds(String taskIds,String type,String parameterType) {
|
|
|
// 获取所有班级
|
|
|
List<Record> classList = CourseSelectTimeModel.dao.getClassListByTaskIds(taskIds);
|
|
|
//所有课节信息
|
|
|
List<Record> list = CourseSelectTimeModel.dao.getCourseTableByTaskIds(taskIds,"");
|
|
|
HSSFWorkbook wb = new HSSFWorkbook();
|
|
|
//获取课表
|
|
|
JSONArray jsonArray = getDaySectionArray(list, new JSONObject());
|
|
|
HSSFCellStyle cellStyle = getCellStyle(wb) ;
|
|
|
//获取天数
|
|
|
String [] taskIdArray = taskIds.split("，");
|
|
|
Record dayRecord = MergeCourseTableModel.dao.getWeekOfClassByTaskId(taskIdArray[0]);
|
|
|
JSONObject classInfo = ToolsUtil.Record2Object(dayRecord);
|
|
|
//导出班级-年级课表 {"subject_name", "room_name", "class_name", "teacher_name"};
|
|
|
createSheet(wb,cellStyle,classList,jsonArray,classInfo,1,parameterType,type);
|
|
|
return wb;
|
|
|
}
|
|
|
|
|
|
public HSSFWorkbook downloadTeacherCourseTable(String bureauId, String week, String personId,String personName,String parameterType) {
|
|
|
/*获取当前学期*/
|
|
|
JSONObject xqOb=BorrowUtil.getCurrentTerm();
|
|
|
String xqId=String.valueOf(xqOb.get("XQ_ID")) ;
|
|
|
List<Record> list = CourseSelectTimeModel.dao.getTeacherCourseTableWeek(bureauId,xqId,week,personId);
|
|
|
if(COMMON.isEmpty(list)){
|
|
|
return new HSSFWorkbook() ;
|
|
|
}
|
|
|
/*获取课节和天数（取最大值）*/
|
|
|
Record dayRecord = CourseSelectTimeModel.dao.getCourseTableMaxTime(bureauId,xqId);
|
|
|
JSONObject dayJson = new JSONObject();
|
|
|
dayJson.put("classInfo", ToolsUtil.Record2Object(dayRecord));
|
|
|
dayJson.put("success",true);
|
|
|
List<Record> teacherList = new ArrayList<>();
|
|
|
Record record = new Record().set("person_id",personId).set("person_name",personName);
|
|
|
teacherList.add(record);
|
|
|
String[] value = {"person_name", "person_id", "teacherId"};
|
|
|
return getHSSFWorkbook(dayJson,list,teacherList,value,parameterType);
|
|
|
|
|
|
}
|
|
|
|
|
|
public HSSFWorkbook downloadTeacherClassCourseTable(String bureauId, String week, String stagId,String personId, String parameterType) {
|
|
|
/*获取当前学期*/
|
|
|
JSONObject xqOb=BorrowUtil.getCurrentTerm();
|
|
|
String xqId=String.valueOf(xqOb.get("XQ_ID")) ;
|
|
|
//获取教师授课班级
|
|
|
List<Record> classList = CourseSelectTimeModel.dao.getClassListByStepTeacherId( bureauId,stagId, xqId,week,personId);
|
|
|
// 获取所有课节信息
|
|
|
List<Record> list = CourseSelectTimeModel.dao.getStepCourseTable(bureauId,stagId, xqId,week,"");
|
|
|
String[] value = {"CLASS_NAME", "BASE_CLASS_ID", "baseClassId", "BASE_CLASS_TYPE","baseClassType"};
|
|
|
/*获取课节和天数（取最大值）*/
|
|
|
Record dayRecord = CourseSelectTimeModel.dao.getCourseTableMaxTime(bureauId,xqId);
|
|
|
JSONObject dayJson = new JSONObject();
|
|
|
dayJson.put("classInfo", ToolsUtil.Record2Object(dayRecord));
|
|
|
dayJson.put("success",true);
|
|
|
return getHSSFWorkbook(dayJson,list,classList,value,parameterType);
|
|
|
}
|
|
|
|
|
|
public HSSFWorkbook downloadAllTeacherCourseTable(String bureauId, String week, String stagId, String xqId, String parameterType) {
|
|
|
HSSFWorkbook wb = new HSSFWorkbook();
|
|
|
List<Record> teacherList = CourseSelectTimeModel.dao.getStepTeacherList(bureauId,stagId,xqId,week);
|
|
|
// 获取所有课节信息
|
|
|
List<Record> list = CourseSelectTimeModel.dao.getStepCourseTable(bureauId,stagId, xqId,week,"");
|
|
|
Record dayRecord = CourseSelectTimeModel.dao.getCourseTableMaxTime(bureauId,xqId);
|
|
|
JSONArray jsonArr = getDaySectionArray(list, new JSONObject());
|
|
|
//单元格样式
|
|
|
HSSFCellStyle cellStyle=getCellStyle(wb) ;
|
|
|
int startRow = 0 ;
|
|
|
Map<Integer,HSSFSheet> sheetMap = new HashMap<>();
|
|
|
for (Record teacher : teacherList) {
|
|
|
int courseId= teacher.get("course_id");
|
|
|
String compareValue = String.valueOf(teacher.get("teacher_id"));
|
|
|
String className = teacher.getStr("class_name");
|
|
|
String teacherName = String.valueOf(teacher.get("person_name"));
|
|
|
teacherName = teacherName+"("+className+")";
|
|
|
Map<Integer,Short> maxHeight = new HashMap<>();
|
|
|
HSSFSheet sheet = null ;
|
|
|
if(COMMON.isEmpty(sheetMap.get(courseId))){
|
|
|
String sheetValue = teacher.getStr("subject_name");
|
|
|
String sheetName = sheetValue+ "的课表";
|
|
|
sheet = wb.createSheet(sheetName);
|
|
|
sheetMap.put(courseId,sheet);
|
|
|
startRow =0 ;
|
|
|
}else {
|
|
|
sheet = sheetMap.get(courseId);
|
|
|
}
|
|
|
int rowNUmber = createTable(sheet,dayRecord,teacherName,cellStyle,startRow,maxHeight);
|
|
|
for (Object obj : jsonArr) {
|
|
|
JSONObject jsonObject = (JSONObject)obj ;
|
|
|
String compareValue1 = String.valueOf(jsonObject.get("teacherId"));
|
|
|
if (compareValue.equals(compareValue1)) {
|
|
|
String [] valueArray = analysisParameterType(parameterType);
|
|
|
jsonObject.put("section",jsonObject.getIntValue("section")+startRow);
|
|
|
setCellValue(jsonObject,sheet,valueArray,maxHeight);
|
|
|
jsonObject.put("section",jsonObject.getIntValue("section")-startRow);
|
|
|
}
|
|
|
}
|
|
|
startRow= rowNUmber;
|
|
|
}
|
|
|
return wb;
|
|
|
}
|
|
|
|
|
|
private int createTable(HSSFSheet sheet ,Record dayRecord,String teacherName ,HSSFCellStyle cellStyle,int startRow, Map<Integer,Short> maxHeight){
|
|
|
int weekCount = dayRecord.getInt("week_of_class_count") + 1;
|
|
|
int row2 = Integer.parseInt(String.valueOf(dayRecord.get("morning_of_class_count"))) ;
|
|
|
int row3 = Integer.parseInt(String.valueOf(dayRecord.get("morning_study_count"))) ;
|
|
|
int row4 = Integer.parseInt(String.valueOf(dayRecord.get("afternoon_of_class_count"))) ;
|
|
|
int row5 = Integer.parseInt(String.valueOf(dayRecord.get("night_study_count"))) ;
|
|
|
int sectionCount = row2+row3+row4+row5;
|
|
|
HSSFRow row1 = getRow(sheet, startRow);
|
|
|
short height = 1000;
|
|
|
maxHeight.put(0,height);
|
|
|
row1.setHeight(height);
|
|
|
//参数1：起始行 参数2：终止行 参数3：起始列 参数4：终止列
|
|
|
HSSFCell cell1 = row1.createCell(0);
|
|
|
cell1.setCellValue(teacherName);
|
|
|
CellRangeAddress region = new CellRangeAddress(startRow,startRow, 0 , (short) (weekCount-1));
|
|
|
setRegionStyle(sheet,region,cellStyle);
|
|
|
sheet.addMergedRegion(region);
|
|
|
for (int line = 1; line < sectionCount + 2; line++) {
|
|
|
HSSFRow row = getRow(sheet, line+startRow);
|
|
|
int week = 1;
|
|
|
row.setHeight(height);
|
|
|
maxHeight.put(line,height);
|
|
|
sheet.setColumnWidth(line, 3766);
|
|
|
for (int rowInt = 0; rowInt < weekCount; rowInt++) {
|
|
|
HSSFCell cell = getCell(row, rowInt);
|
|
|
if (line == 1 && rowInt != 0) {
|
|
|
cell.setCellValue(getWeekDetail(week));
|
|
|
week++;
|
|
|
} else if (line != 1 && rowInt == 0) {
|
|
|
cell.setCellValue( (line - 1));
|
|
|
}
|
|
|
cell.setCellStyle(cellStyle);
|
|
|
}
|
|
|
}
|
|
|
return startRow+sectionCount+2;
|
|
|
}
|
|
|
public Map<Integer,String> getWeek(){
|
|
|
Map<Integer,String> map = new HashMap<>(7);
|
|
|
map.put(1,"星期一");
|
|
|
map.put(2,"星期二");
|
|
|
map.put(3,"星期三");
|
|
|
map.put(4,"星期四");
|
|
|
map.put(5,"星期五");
|
|
|
map.put(6,"星期六");
|
|
|
map.put(7,"星期日");
|
|
|
return map;
|
|
|
}
|
|
|
public String getWeekDetail(int week){
|
|
|
return getWeek().get(week);
|
|
|
}
|
|
|
|
|
|
public HSSFWorkbook downloadAllClassCourseTable(String bureauId, String week, String stagId, String xqId, String parameterType) {
|
|
|
HSSFWorkbook wb = new HSSFWorkbook();
|
|
|
List<Record> classList = CourseSelectTimeModel.dao.getStepClassList(bureauId,stagId,xqId,week);
|
|
|
// 获取所有课节信息
|
|
|
List<Record> list = CourseSelectTimeModel.dao.getStepCourseTable(bureauId,stagId, xqId,week,"");
|
|
|
Record dayRecord = CourseSelectTimeModel.dao.getCourseTableMaxTime(bureauId,xqId);
|
|
|
JSONArray jsonArr = getDaySectionArray(list, new JSONObject());
|
|
|
//单元格样式
|
|
|
HSSFCellStyle cellStyle=getCellStyle(wb) ;
|
|
|
int startRow = 0 ;
|
|
|
Map<Integer,HSSFSheet> sheetMap = new HashMap<>();
|
|
|
for (Record teacher : classList) {
|
|
|
int year= teacher.get("year");
|
|
|
String classId = String.valueOf(teacher.get("class_id"));
|
|
|
String baseClassType = String.valueOf(teacher.get("base_class_type"));
|
|
|
String className = String.valueOf(teacher.get("class_name"));
|
|
|
Map<Integer,Short> maxHeight = new HashMap<>();
|
|
|
HSSFSheet sheet = null ;
|
|
|
if(COMMON.isEmpty(sheetMap.get(year))){
|
|
|
String sheetName = year+ "年级的课表";
|
|
|
sheet = wb.createSheet(sheetName);
|
|
|
sheetMap.put(year,sheet);
|
|
|
startRow =0 ;
|
|
|
}else {
|
|
|
sheet = sheetMap.get(year);
|
|
|
}
|
|
|
int rowNUmber = createTable(sheet,dayRecord,className,cellStyle,startRow,maxHeight);
|
|
|
for (Object obj : jsonArr) {
|
|
|
JSONObject jsonObject = (JSONObject)obj ;
|
|
|
String compareValue1 = String.valueOf(jsonObject.get("baseClassId"));
|
|
|
String compareValue2 = String.valueOf(jsonObject.get("baseClassType"));
|
|
|
if (classId.equals(compareValue1)&&baseClassType.equals(compareValue2)) {
|
|
|
String [] valueArray = analysisParameterType(parameterType);
|
|
|
int day = jsonObject.getIntValue("day");
|
|
|
int section = jsonObject.getIntValue("section") + 1+startRow;
|
|
|
HSSFRow row = getRow(sheet,section);
|
|
|
HSSFCell cell = getCell(row,day);
|
|
|
|
|
|
StringBuilder addValue = new StringBuilder(String.valueOf(jsonObject.get(valueArray[0])));
|
|
|
String singleDouble = String.valueOf(jsonObject.get("single_double"));
|
|
|
if("1".equals(singleDouble)){
|
|
|
addValue.append("-单");
|
|
|
}else if("2".equals(singleDouble)){
|
|
|
addValue.append("-双");
|
|
|
}
|
|
|
for (int i = 1; i < valueArray.length; i++) {
|
|
|
if(!COMMON.isEmpty(jsonObject.get(valueArray[i]))){
|
|
|
addValue.append("(").append(jsonObject.get(valueArray[i])).append(")");
|
|
|
}
|
|
|
}
|
|
|
String cellValue= cell.toString();
|
|
|
if(!COMMON.isEmpty(cellValue)){
|
|
|
cellValue += "\r\n";
|
|
|
}
|
|
|
cellValue += addValue ;
|
|
|
cell.setCellValue(cellValue);
|
|
|
}
|
|
|
}
|
|
|
startRow= rowNUmber;
|
|
|
}
|
|
|
return wb;
|
|
|
}
|
|
|
}
|
