后端代码实现

2022SC@SDUSC

package org.jeecg.modules.demo.atupai.controller;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import liquibase.pro.packaged.S;
import lombok.extern.slf4j.Slf4j;
import org.jeecg.common.api.vo.Result;
import org.jeecg.common.aspect.annotation.AutoLog;
import org.jeecg.common.system.base.controller.JeecgController;
import org.jeecg.common.system.query.QueryGenerator;
import org.jeecg.modules.demo.atupai.entity.*;
import org.jeecg.modules.demo.atupai.service.*;
import org.jeecg.modules.flowable.apithird.entity.SysUser;
import org.jeecg.modules.flowable.apithird.service.IFlowThirdService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.servlet.ModelAndView;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.util.*;

/**
 * @Description: 自动排考
 * @Author: jeecg-boot
 * @Date:   2022-04-02
 * @Version: V1.0
 */
@Api(tags="自动排考")
@RestController
@RequestMapping("/atupai/arrangement")
@Slf4j
public class ArrangementController extends JeecgController<Arrangement, IArrangementService> {
	@Autowired
	private IArrangementService arrangementService;
	 @Autowired
	 private IClassroominfoService classroominfoService;
	@Autowired
	private IRoomService roomService;
	@Autowired
	private ITimetableService timetableService;
	@Autowired
	private ISelectstudentService selectstudentService;
	@Autowired
	private IExamSeatInfoService examSeatInfoService;
	@Autowired
	private IStuInfoService stuInfoService;
	@Autowired
	private ISitService sitService;
	@Autowired
	IFlowThirdService iFlowThirdService;
	/**
	 * 分页列表查询
	 *
	 * @param arrangement
	 * @param pageNo
	 * @param pageSize
	 * @param req
	 * @return
	 */
	//@AutoLog(value = "自动排考-分页列表查询")
	@ApiOperation(value="自动排考-分页列表查询", notes="自动排考-分页列表查询")
	@GetMapping(value = "/list")
	public Result<IPage<Arrangement>> queryPageList(Arrangement arrangement,
													@RequestParam(name="pageNo", defaultValue="1") Integer pageNo,
													@RequestParam(name="pageSize", defaultValue="10") Integer pageSize,
													HttpServletRequest req) {
		QueryWrapper<Arrangement> queryWrapper = QueryGenerator.initQueryWrapper(arrangement, req.getParameterMap());
		Page<Arrangement> page = new Page<Arrangement>(pageNo, pageSize);
		IPage<Arrangement> pageList = arrangementService.page(page, queryWrapper);
		return Result.OK(pageList);
	}


	/**
	 * 教师申请进度
	 *
	 * @param arrangement
	 * @param pageNo
	 * @param pageSize
	 * @param req
	 * @return
	 */
	//@AutoLog(value = "自动排考-分页列表查询")
	@ApiOperation(value="自动排考-分页列表查询", notes="自动排考-分页列表查询")
	@GetMapping(value = "/list0")
	public Result<IPage<Arrangement>> queryPageList0(Arrangement arrangement,
													@RequestParam(name="pageNo", defaultValue="1") Integer pageNo,
													@RequestParam(name="pageSize", defaultValue="10") Integer pageSize,
													HttpServletRequest req) {
		SysUser sysUser = iFlowThirdService.getLoginUser();
		String tid = sysUser.getUsername();
		String name=sysUser.getRealname();
		QueryWrapper<Arrangement> queryWrapper = QueryGenerator.initQueryWrapper(arrangement, req.getParameterMap());
		Page<Arrangement> page = new Page<Arrangement>(pageNo, pageSize);
		queryWrapper.eq("teachername",name);
		queryWrapper.eq("notice","已通知");
		IPage<Arrangement> pageList = arrangementService.page(page, queryWrapper);
		return Result.OK(pageList);
	}


	/**
	 * 教师申请列表
	 *
	 * @param arrangement
	 * @param pageNo
	 * @param pageSize
	 * @param req
	 * @return
	 */
	//@AutoLog(value = "自动排考-分页列表查询")
	@ApiOperation(value="自动排考-分页列表查询", notes="自动排考-分页列表查询")
	@GetMapping(value = "/list1")
	public Result<IPage<Arrangement>> queryPageList1(Arrangement arrangement,
													 @RequestParam(name="pageNo", defaultValue="1") Integer pageNo,
													 @RequestParam(name="pageSize", defaultValue="10") Integer pageSize,
													 HttpServletRequest req) {
		SysUser sysUser = iFlowThirdService.getLoginUser();
		String tid = sysUser.getUsername();
		String name=sysUser.getRealname();
		QueryWrapper<Arrangement> queryWrapper = QueryGenerator.initQueryWrapper(arrangement, req.getParameterMap());
		Page<Arrangement> page = new Page<Arrangement>(pageNo, pageSize);
		queryWrapper.eq("teachername",name);
		IPage<Arrangement> pageList = arrangementService.page(page, queryWrapper);
		return Result.OK(pageList);
	}


	/**
	 *   添加
	 *
	 * @param arrangement
	 * @return
	 */
	@AutoLog(value = "自动排考-添加")
	@ApiOperation(value="自动排考-添加", notes="自动排考-添加")
	@PostMapping(value = "/add")
	public Result<String> add(@RequestBody Arrangement arrangement) throws Exception {

		if(arrangementService.courseidexist(arrangement.getCourseid(),arrangement.getCourseord()))
		{arrangementService.save(arrangement);
		return Result.OK("添加成功！");}
		else
			return Result.error("课程已申请");
	}

	 /**
	  *   安排考场
	  *
	  * @param id
	  * @return
	  */
	 @GetMapping(value = "/anpaikaochang")
	 public Result<String> anpaikaochang( @RequestParam(name="id",required=true) String id) throws Exception {
		 Arrangement arrangement = arrangementService.getById(id);
		 		 //逻辑顺序，安排后变成已安排
		 if(arrangement.getArrange()!=null&&arrangement.getArrange().equals("已排"))
		 {return Result.error("已安排");}
		 else
		 { arrangement.setArrange("已排");
		 	//取属性
		 String testtime=arrangement.getTesttimehope();//申请考试时间，如：17/星期一/1-2
		 String []testtimeset=testtime.split("/");
		 String weektime=testtimeset[0];
		 int week=Integer.parseInt(weektime);//考试周
		 String weekday=testtimeset[1];//考试星期
		 String weekdaytime=testtimeset[2];//考试节次
		 int selectstudents=arrangement.getCoursepeoplesum();
		 //取出所有可用教室
		 List<Classroominfo> allclassroom=classroominfoService.selectAllkeyong();
		 //排序，大教室优先
		 allclassroom.sort((b,a)->a.getTestsit().compareTo(b.getTestsit()));
		 String classroom = arrangement.getCourseposition();
		 //转换班级，将大范围的班级转换为每个班级
		 String classes=arrangement.getCourseclass();
		 List <String>classessearch = getclass(classes);
		 //取出上课教室的座位数
		 Classroominfo classsit = classroominfoService.selectByClassroomName(classroom);
		 if(classsit==null)
			 return Result.error("暂未有该教室信息，不能随堂");
		 else{
		 int sit=0;
		 if(classsit.getTestsit()!=null)
		 	sit = Integer.parseInt(classsit.getTestsit());
		 //如果随堂考，则不用考虑班级时间冲突，只考虑空间冲突（找可使用的教室）。
		 if(arrangement.getChapel()!=null&&arrangement.getChapel().equals("是"))
		 {      //可使用教室去掉上课教室
		 	     allclassroom.remove(classsit);
		 	     //如果上课教室座位数>选课人数，考场一为上课教室，考场二为“空”，必须为空，不能不写
			 	if (arrangement.getCoursepeoplesum() < sit)
				 {     arrangement.setTestpositionfirst(classroom);
					   arrangement.setTestpositionsecond("空");
				 }//<，找申请时间的空教室
			 	else
				  {
					 arrangement.setTestpositionfirst(classroom);
					 //第二个教室排考人数改变
					 int less=arrangement.getCoursepeoplesum()-sit;
					 //去掉可用座位数小于排考人数的教室
					 for(int i=0;i<allclassroom.size();i++)
					 {  if(allclassroom.get(i).getTestsit()==null)
                         System.out.println(allclassroom.get(i));
					 	else
					 	{if(Integer.parseInt(allclassroom.get(i).getTestsit())<less)
					 	    allclassroom.remove(i);
					    }
					 }
					 //找到一个申请时间可用的教室，停止,判断并更新教室的使用状态
					 for(Classroominfo second:allclassroom)
					  {   Room secjiaoshi=roomService.selectByClassroomAndWeek(second.getClassroomname(),week);
					 	if(roomupdate(secjiaoshi,weekday,weekdaytime))
					 	{   arrangement.setTestpositionsecond(secjiaoshi.getClassroom());
							break;
					 	}
					  }
				  }
		 } //不随堂，考虑申请时间与班级上课时间的冲突，需要参考课表信息
		 else
		 {  //冲突标志，初始化为0，有冲突变为1
		 	int sign=0;
		 	//冲突班级，冲突课程，需要返回冲突信息
		 	//遍历班级列表，从课表中拿出申请星期，节次与申请时间的课程的周数，
			 // 不冲突1：取出数据为空
			 // 不冲突2：取出数据不为空，但申请周数不包含在课程周数
		 	for (String classtime:classessearch)
		     {  String conclass="";
				 String concourse="";
				 List<String> timeset=timetableService.selectWeek(classtime,weekday,weekdaytime);
		     	if (timeset!=null)
				{ //考虑之后发现形势与政策应该不会比安排时间早，所以不考虑
					for(String eveweektime:timeset)
					{  if (!eveweektime.contains(","))
					    {String[] range=eveweektime.split("-");
							System.out.println(range[0]);
							System.out.println(week);
							System.out.println(classtime);
							System.out.println(timetableService.selectName(classtime,weekday,weekdaytime).get(0));
							System.out.println(range[1]);
							Boolean temp1=week>Integer.parseInt(range[0])&&week<Integer.parseInt(range[1]);
							Boolean temp2=week==Integer.parseInt(range[1]);
							System.out.println((week>Integer.parseInt(range[0])&&week<Integer.parseInt(range[1])));
							System.out.println(week==Integer.parseInt(range[1]));
					      if (temp1||temp2) {
								System.out.println("oadeugusu");
								conclass=classtime;
								concourse=timetableService.selectName(classtime,weekday,weekdaytime).get(0);
								sign=1;
								break;
							}
				        }
					}
				}
				 if (sign==1)
					 return Result.error("与"+conclass+concourse+"时间冲突");

		     }
		 	//返回冲突信息
		 	//不冲突继续执行，时间解决，解决空间，找空教室
			 //遍历可用教室（允许笔试）
		 	List<String>classroomlist= new ArrayList();
		 	for(Classroominfo classroom0:allclassroom)
			{ if(classroom0.getTestsit()!=null&&!classroom0.getTestsit().equals("0"))
				{ 	int classroomsit=Integer.parseInt(classroom0.getTestsit());
			      	Room roomsec=roomService.selectByClassroomAndWeek(classroom0.getClassroomname(),week);
				    if(roomupdate(roomsec,weekday,weekdaytime))
				      {  //需要安排考试人数<教室有效座位数，停止
				      	if(selectstudents<classroomsit)
				           { classroomlist.add(roomsec.getClassroom());
                              break; }
					    else
					    //更新需要安排考试人数
				          {   classroomlist.add(roomsec.getClassroom());
				    	      selectstudents=selectstudents-classroomsit; }
				      }
			      }
			}
			 int size=classroomlist.size();
		 	//只需要一个教室
		 	if(size==1)
			{arrangement.setTestpositionfirst(classroomlist.get(0));
		 	arrangement.setTestpositionsecond("空");}
		 	//需要两个教室
		 	if(size==2) {arrangement.setTestpositionfirst(classroomlist.get(0));
				  arrangement.setTestpositionsecond(classroomlist.get(1));}
		 }
		 //更新排考信息，返回成功提示
			 arrangementService.updateById(arrangement);
		 return Result.OK("安排成功");}
	 }}


	/**
	 *   取消排考
	 *
	 * @param id
	 * @return
	 */

	@GetMapping(value = "/cancelpaikao")
	public Result<String> cancelpaikao( @RequestParam(name="id",required=true) String id) throws Exception {
		Arrangement arrangement = arrangementService.getById(id);
		//取属性
		String testtime = arrangement.getTesttimehope();
		String[] testtimeset = testtime.split("/");
		String weektime = testtimeset[0];
		int week = Integer.parseInt(weektime);
		String weekday = testtimeset[1];
		String weekdaytime = testti