pktimer.java

中应用程序的访问权限对Java Web Console 中应用程序的访问权限 成功登录 Web 控制台后,可能无法自动访问在该控制台中注册的所有应用程序。通常,必须安装应用程序,才能让所有的用户在控制

package edu.yinhe.mis.util;

import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.List;
import java.util.Timer;
import java.util.TimerTask;


import java.sql.Connection;

import edu.yinhe.mis.dto.PKDTO;
import edu.yinhe.mis.model.DAOFactory;
import edu.yinhe.mis.vo.ClassesVO;
import edu.yinhe.mis.vo.OutlineVO;
import edu.yinhe.mis.vo.RoomVO;
import edu.yinhe.mis.vo.SchoolVO;
import edu.yinhe.mis.vo.TeacherVO;
import edu.yinhe.system.model.IBaseDAO;

public class PKTimer extends Timer {


	public PKTimer(Connection conn) {

		new Timer().schedule(new Task(conn), 20*1000, 60*60*1000);

	}
}
//内部类Task
class Task extends TimerTask{	
	private Connection conn=null;

	public Task(Connection conn){
		this.conn=conn;
	}
	public void run() {	
		this.pk();
		try {
			Thread.sleep(10000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println("++++++++++++++++   你好！课已经排好！  +++++++++++++++++");
	}

	private void pk(){

		IBaseDAO pkdao = null;
		pkdao = DAOFactory.getPKDAO(conn);


		List listAll=new ArrayList();

		List listInsert=null;
		List exportClassesList = null;
		List exportCourseList = null;
		List exportTeacherList = null;
		List list4 = null;
		List list5 = null;
		Object[] Classes = new Object[1];
		List schoolList = (List) getSchools(null);
		List ClassesList1 = null;
		PKDTO pkdto = new PKDTO();

		Calendar calendar = Calendar.getInstance();

		int month = calendar.get(Calendar.MONTH);
		int year = calendar.get(Calendar.YEAR);
		int day = calendar.get(Calendar.WEEK_OF_MONTH);
		int date = calendar.get(calendar.DATE);

		pkdto.setHour_date(String.valueOf(date));
		pkdto.setPkweek(String.valueOf(day));

		SchoolVO schoolsVO = null;


		// 用于保存合格数据的对象
		List courseList = new ArrayList();// 保存合格课程的对象courseList
		List teacherList = new ArrayList();// 保存合格教师的对象teacherList
		List classroomList = new ArrayList();// 保存合格教室的对象classroomList



		try {
			for(int i=1;i<schoolList.size();i++){//校区循环

				schoolsVO = (SchoolVO) schoolList.get(i-1);

				pkdto.setSchool_no(schoolsVO.getSchoolNo());
				pkdto.setSchool_name(schoolsVO.getSchoolName());

				for(int j=1;j<=5;j++){//一周中的5天循环
					if(day<=30){
						day=day+1;
					}else{
						month = month+1;
						day = 1;
					}
					pkdto.setPkweek(String.valueOf(j));

					for(int h = 1;h <= 3;h++){//循环时间(上午,下午,晚上)

						for(int k = 1;k<courseList.size();k++){
							courseList.remove(0);
						}
						for(int k = 1;k<teacherList.size();k++){
							teacherList.remove(0);
						}
						for(int k = 1;k<classroomList.size();k++){
							classroomList.remove(0);
						}	
						pkdto.setTeachtime(String.valueOf(h));

						exportClassesList = (List) this.exportClasses(null);

						ClassesVO clvo = new ClassesVO();
						clvo.setSchoolNo(schoolsVO.getSchoolNo());
						clvo.setStuNum("10");
						ClassesList1 = Check_Classes_Clash(exportClassesList,clvo);


						for(int m = 1;m<=ClassesList1.size();m++){//循环班级

							clvo = (ClassesVO) ClassesList1.get(m-1);

							pkdto.setClass_name(clvo.getClassName());
							pkdto.setClass_no(clvo.getClassNo());

							// 将该循环下的班级对象（clvo）传给exportCourse方法里作为条件查询触该班要上的合格课程
							Object[] objCourse = (Object[]) this.exportCourse(clvo);

							if(objCourse==null||objCourse[0]==null){
								continue ;
							}
							exportCourseList=(List)objCourse[0];
							OutlineVO lvo=null;

							if(exportCourseList!= null && exportCourseList.size()>0){

								for(int n = 0;n<exportCourseList.size();n++){//课程循环
									lvo=(OutlineVO) exportCourseList.get(n);
									if(this.check_Course_Overlap(courseList, lvo)){
										pkdto.setClasstimes(String.valueOf(lvo.getPlanperiod()));//计划课时

										if(lvo.getFactperiod()<lvo.getPlanperiod()){
											
											int a = lvo.getFactperiod();
											a++;
											
											pkdto.setClass_times(String.valueOf(a));//实际课次
										}
										pkdto.setObject_name(lvo.getObjectName());//课程名称
										pkdto.setObject_no(lvo.getObjectNo());//课程编号

										courseList.add(lvo);
									}
								}
							}
							// 将课程传给方法里作为条件查询出合格的老师
							Object[] Teacher = (Object[]) this.exportTeacher(lvo);
							// 如果得到的合格老师为空，就安排下次的课程，重新从班级开始循环
							if(Teacher==null||Teacher[0]==null){
								continue;
							}
							exportTeacherList = (List) Teacher[0];
							TeacherVO tvo = new TeacherVO();
							if(exportTeacherList!= null && exportTeacherList.size()>0){

								for(int t=0;t<exportTeacherList.size();t++){//循环教师

									tvo = (TeacherVO) exportTeacherList.get(t);

									if(this.check_Teacher_Overlap(teacherList, tvo)){

										pkdto.setDepartment_no(tvo.getTeacher_no());//部门编号
										pkdto.setTeacher_name(tvo.getTeacher_name());//教师编号
										pkdto.setTeacher_no(tvo.getTeacher_no());//教师编号

									if(Integer.parseInt(tvo.getTeacher_states()) == 0){
										
										pkdto.setTeacher_state(tvo.getTeacher_states());
										
										
										}

										teacherList.add(tvo);
									}
								}
							}else{
								continue;
							}
							// 将班级对象传给exportClassRoom方法作为查询符合条件的教室
							Object[] classroom = (Object[]) this.exportClassRoom(clvo);

							list4 =(List) classroom[0];
							RoomVO rvo = null;
							if(list4!=null&&list4.size()>0){
								for(int g= 0;g<list4.size();g++){//教室循环
									rvo = (RoomVO) list4.get(g);
									if(this.check_ClassRoom_Overlap(classroomList, rvo)){
										pkdto.setClassRoom_no(rvo.getClassroomNo());//教室名称
										if(Integer.parseInt(rvo.getStatues())== 0){
											pkdto.setClassroom_state(rvo.getStatues());//教室状态	 
										}

										classroomList.add(rvo);
									}
								}
							}
							if(h==1){
								pkdto.setHour_date(year + "-" + month + "-" + day);
							}
							if(h==2){
								pkdto.setHour_date(year + "-" + month + "-" + day);
							}
							if(h==3){
								pkdto.setHour_date(year + "-" + month + "-" + day);
							}
							System.out.println("校区编号： "+ pkdto.getSchool_no() + 
									"   校区地址: "+ pkdto.getSchool_name()+ 
									"   授课日期: "+ pkdto.getHour_date()+ 
									"   授课时间：" + pkdto.getTeachtime() +
									"   班级名称："+ pkdto.getClass_name()+
									"   课程名称："+ pkdto.getObject_name()+ 
									"   授课次数："+ pkdto.getClass_times()+ 
									"   课程编号: "+pkdto.getObject_no()+
									"   教师状态："+ pkdto.getTeacher_state()+
									"   教师名称："+ pkdto.getTeacher_name()+
									"   教师工号: "+pkdto.getTeacher_no()+
									"   教室名称：" + pkdto.getClassRoom_no()+
									"   教研组:  " + pkdto.getDepartment_no()+
									"   教师工号： " + pkdto.getTeacher_no()+ 
									"   教室状态： " + pkdto.getClassroom_state()
							);

							listAll.add(pkdto);
							System.out.println("+++++++++++++++++++"+listAll.size()+"+++++++++++++++++++++");
							try {
								pkdao.insert(listAll);
							} catch (SQLException e) {
								e.printStackTrace();
							}

						}
					}
				}
			}

		}finally{
			try {
				if(conn!=null)conn.close();
			} catch (SQLException e) {
				e.printStackTrace();
			}

			conn=null;
		}
	}



	/**
	 * @author 张启悟
	 * 查询班级资源
	 * @param arrayClasses
	 * @return 符合条件的班级集合Object[]
	 */
	private Object exportClasses(Object arrayClasses){
		IBaseDAO pkdao = null;
		pkdao = DAOFactory.getPKDAO(conn);
		List d = null;
		try {
			d = (List) pkdao.findById(arrayClasses);
		} catch (SQLException e) {
			e.printStackTrace();
		}
		return d;
	}

	/**
	 * @author 张启悟
	 * 查询课程资源
	 * @param clvo    ClassesVO (班级VO)作为课程的条件
	 * @return 符合条件的课程集合Object[]
	 */
	private Object exportCourse(Object clvo){
		IBaseDAO pkdao = null;
		pkdao = DAOFactory.getPKDAO(conn);
		Object[] listCourse = null;
		try {
			listCourse = (Object[]) pkdao.find(clvo);
		} catch (SQLException e) {
			e.printStackTrace();
		}
		return listCourse;	
	}

	/**
	 * @author 张启悟
	 * 获取校区资源 
	 * @param obj
	 * @return 符合条件的校区集合List
	 */
	private List getSchools(Object obj){
		IBaseDAO pkdao = null;
		pkdao = DAOFactory.getSchoolDAO(conn);
		List m =null;
		Object[] arraySchool = new Object[1];
		try {
			arraySchool[0] = pkdao.findAll();
			if(arraySchool[0]!= null){
				m = (List) arraySchool[0];
			}
		} catch (SQLException e) {
			e.printStackTrace();
		}
		return m;
	}

	/**
	 * @author 张启悟
	 * 教师冲突
	 * 检测第一个参数 returnListTeacher里是否存在第二个参数tvo
	 * @param returnListTeacher
	 * @param tvo
	 * @return true表示returnListTeacher中存在tvo，false表示returnListTeacher中不存在tvo
	 */
	private boolean check_Course_Overlap(List returnListCourser,OutlineVO ovo){
		boolean flag=true;
		OutlineVO outvo = null;
		if(returnListCourser != null && returnListCourser.size()>0 &&ovo != null){
			for(int i = 0;i<returnListCourser.size();i++){

				outvo = (OutlineVO) returnListCourser.get(i);

				int classtimes = outvo.getPlanperiod();//得到计划课时
				int class_times = ovo.getFactperiod();//得到实际课时

				if(outvo.getId()==ovo.getId() && class_times<=classtimes){
					class_times++;//实际课时自增
					flag=true;
				}else if(classtimes<class_times){
					flag=false;
				}
			}
		}
		return flag;

	}
	/**
	 * @author 张启悟
	 * 教师冲突
	 * 检测第一个参数 returnListTeacher里是否存在第二个参数tvo
	 * @param returnListTeacher
	 * @param tvo
	 * @return true表示returnListTeacher中存在tvo，false表示returnListTeacher中不存在tvo
	 */
	private boolean check_Teacher_Overlap(List returnListTeacher,TeacherVO tvo){
		boolean flag=true;
		TeacherVO teavo = null;
		if(returnListTeacher != null && returnListTeacher.size()>0 &&tvo != null){
			for(int i = 0;i<returnListTeacher.size();i++){
				teavo = (TeacherVO) returnListTeacher.get(i);
				if(teavo.getId()==tvo.getId()){
					flag=true;
				}
			}
		}
		return flag;

	}
	/**
	 * @author 张启悟
	 * 班级冲突
	 * @param returnListTeacher
	 * @param 
	 * 检测第一个参数 returnListTeacher里是否存在第二个参数cvo
	 * @return true表示returnListTeacher中存在tvo，false表示returnListTeacher中不存在cvo
	 */
	private boolean check_Classes_Overlap(List returnListClasses,ClassesVO cvo){
		boolean flag=true;
		ClassesVO clvo=null;
		if(returnListClasses != null && returnListClasses.size()>0 && cvo!=null){
			for(int i = 0;i<returnListClasses.size();i++){
				clvo = (ClassesVO) returnListClasses.get(i);
				if(clvo.getId()==cvo.getId()){
					flag = false;
					break;
				}
			}

		}
		return flag;

	}
	/**
	 * @author 张启悟
	 * 教室冲突
	 * @param returnListTeachervo
	 * 检测第一个参数 returnListTeacher里是否存在第二个参数rvo
	 * @return true表示returnListTeacher中存在rvo，false表示returnListTeacher中不存在rvo
	 */
	private boolean check_ClassRoom_Overlap(List returnListClassRoom,RoomVO rvo){
		boolean flag=true;
		RoomVO roomvo=null;
		if(returnListClassRoom != null && returnListClassRoom.size()>0 && rvo != null){
			for(int i = 0 ;i<returnListClassRoom.size();i++){
				roomvo = (RoomVO) returnListClassRoom.get(i);
				if(roomvo.getId()==rvo.getId()){
					flag = true;
					break;
				}
			}
		}
		return flag;

	}
	/**
	 * 班级冲突 并且判断是否符合条件
	 * @param listClasses 被检测的对象
	 * @param cvo 要匹配的目标对象
	 * @return listClasses  符合匹配条件的对象
	 */
	private List Check_Classes_Clash(List listClasses,ClassesVO cvo){

		ClassesVO clvo=null;
		List list = new ArrayList();

		for(int i = 0;i<listClasses.size();i++){

			clvo = (ClassesVO) listClasses.get(i);
			if(clvo.getStuNum()!=null&&cvo.getStuNum()!=null){

				if(Integer.parseInt(clvo.getStuNum())>Integer.parseInt(cvo.getStuNum()) && clvo.getSchoolNo().equals(cvo.getSchoolNo())){

					if(check_Classes_Overlap(list ,clvo)){// 如果clvo和listClasses的值相匹配，则将clvo  add（）到listClasses中

						list.add(clvo);
					}
				}
			}
		}
		return list;

	}
	/**
	 * 教室冲突 并且判断是否符合条件
	 * @param listClasses 被检测的对象
	 * @param cvo 要匹配的目标对象
	 * @return listClassRoom  符合匹配条件的对象
	 */
	private List check_ClassRoom_Clash(List listClassRoom,RoomVO rvo){

		List list = new ArrayList();
		RoomVO roomvo=null;
		for(int i = 0;i<listClassRoom.size();i++){
			roomvo = (RoomVO) listClassRoom.get(i);
			if(String.valueOf(roomvo.getClassroomContent())!=null
					&&"".equals(roomvo.getClassroomContent())
					&& String.valueOf(rvo.getClassroomContent())!= null
					&&"".equals(rvo.getClassroomContent())){

				if(roomvo.getClassroomContent()>rvo.getClassroomContent()
						&& roomvo.getSchoolNo().equals(rvo.getSchoolNo())
						&&roomvo.getClassroomType().equals(rvo.getClassroomType())
						&&!check_ClassRoom_Overlap(list, roomvo)){
					list.add(roomvo);
				} 
			}
		}
		return list;
	}

	/**
	 * @author 张启悟
	 * 查询教师资源
	 * @param arrayTeacher
	 * @return 符合条件的教师集合Object[]
	 */
	private Object exportTeacher(Object arrayTeacher){
		IBaseDAO pkdao = null;
		pkdao = DAOFactory.getPKDAO(conn);
		Object[] b = null;
		try {
			b = (Object[]) pkdao.find(arrayTeacher);
		} catch (SQLException e) {

			e.printStackTrace();
		}

		return b;
	}

	/**
	 * @author 张启悟
	 * 查询教室资源
	 * @param arrayClassRoom
	 * @return 符合条件的教室集合Object[]
	 */
	private Object exportClassRoom(Object arrayClassRoom){
		IBaseDAO pkdao = null;
		pkdao = DAOFactory.getPKDAO(conn);
		Object[] c = null;
		try {
			c = (Object[]) pkdao.findById(arrayClassRoom);
		} catch (SQLException e) {

			e.printStackTrace();
		}
		return c;
	}
}