pkservice.java

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

package edu.yinhe.mis.services;

import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.List;

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.common.AppException;
import edu.yinhe.system.model.IBaseDAO;
import edu.yinhe.system.services.Service;

/**
 * 
 * @author 张启悟
 *
 */
public class PKservice extends Service {



	/**
	 * @author 张启悟
	 * 查询课程资源
	 * @param clvo    ClassesVO (班级VO)作为课程的条件
	 * @return 符合条件的课程集合Object[]
	 */
	private Object exportCourse(Object clvo){
		IBaseDAO pkdao = null;
		pkdao = DAOFactory.getPKDAO(conn);
		List listCourse = null;
		try {
			listCourse = (List) pkdao.find(clvo);
		} catch (SQLException e) {
			e.printStackTrace();
		}
		return listCourse;	
	}
	/**
	 * @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;
	}
	/**
	 * @author 张启悟
	 * 查询班级资源
	 * @param arrayClasses
	 * @return 符合条件的班级集合Object[]
	 */
	private Object exportClasses(Object arrayClasses){
		IBaseDAO pkdao = null;
		pkdao = DAOFactory.getPKDAO(conn);
		Object[] d = null;
		try {
			d = (Object[]) pkdao.findById(arrayClasses);
		} catch (SQLException e) {
			e.printStackTrace();
		}
		return d;
	}
	/**
	 * @author 张启悟
	 * 获取校区资源 该资源是调用别人的!
	 * @param obj
	 * @return 符合条件的校区集合List
	 */
	private List getSchools(Object obj){
		IBaseDAO pkdao = null;
		pkdao = DAOFactory.getSchoolDAO(conn);
		List m =null;
		try {
			Object[] arraySchool = (Object[]) 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);
				if(outvo.getId()==ovo.getId()){
					flag=true;
				}
			}
		}
		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;
		for(int i = 0;i<listClasses.size();i++){
			clvo = (ClassesVO) listClasses.get(i);
			if(Integer.parseInt(clvo.getStuNum())>Integer.parseInt(cvo.getStuNum()) && clvo.getSchoolNo().equals(cvo.getSchoolNo())){

				if(!check_Classes_Overlap(listClasses ,cvo)){
					listClasses.add(cvo);
				}
			}
		}
		return listClasses;

	}
	/**
	 * 教室冲突 并且判断是否符合条件
	 * @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<list.size();i++){
			roomvo = (RoomVO) list.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;
	}

	@Override
	public Object alllist(Object obj) throws AppException {
		IBaseDAO pkdao = null;
		pkdao = DAOFactory.getPKDAO(conn);
		Object p=null;
		Object ob=null;
		try {
			p = pkdao.findAll(ob);
		} catch (SQLException e) {

			e.printStackTrace();
		}
		return p;
	}

	@Override
	public Object create(Object obj) throws AppException {
	
		
		IBaseDAO pkdao = null;
		pkdao = DAOFactory.getSchoolDAO(conn);
		List listInsert=null;
		List exportClassesList = null;
		List exportCourseList = null;
		List exportTeacherList = null;
		List list4 = null;
		List list5 = null;
		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.set(String.valueOf(month));
		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=0;i<=3;i++){//校区循环
				schoolsVO = (SchoolVO) schoolList.get(i);
				pkdto.setSchool_no(schoolsVO.getSchoolName());
				for(int j=0;j<=5;i++){
					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();j++){
							courseList.remove(0);
						}
						for(int k = 1;k<teacherList.size();j++){
							teacherList.remove(0);
						}
						for(int k = 1;k<classroomList.size();j++){
							classroomList.remove(0);
						}	
						pkdto.setHour_date(String.valueOf(h));
						Object[] Classes = (Object[]) this.exportClasses(null);
						exportClassesList = (List) Classes[0];
						ClassesVO clvo = new ClassesVO();

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

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

							Object[] Course = (Object[]) this.exportCourse(clvo);
							exportCourseList = (List) Course[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.setObject_name(lvo.getObjectName());
										courseList.add(lvo);
										break;
									}
								}
							}
							Object[] Teacher = (Object[]) this.exportTeacher(lvo);
							if(Teacher==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.setTeacher_name(tvo.getTeacher_name());
										pkdto.setTeacher_state(tvo.getTeacher_states());
										pkdto.setDepartment_no(tvo.getDepartment_no());
										pkdto.setTeacher_no(tvo.getTeacher_no());
										teacherList.add(tvo);
										break;
									}
								}
							}else{
								continue;
							}
							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.setClass_name(rvo.getClassroomNo());
										pkdto.setSchool_no(rvo.getClassroomNo());
										classroomList.add(rvo);
										break;
									}
								}
							}
							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.getHour_date()+ 
									"   周次："+ pkdto.getPkweeks()+ 
									"   时间：" + pkdto.getTeachtime() +
									"   班级："+ pkdto.getClass_name()+
									"   课程："+ pkdto.getObject_name()+ 
									"   教师名称："+ pkdto.getTeacher_name()+ 
									"   教室名称：" + pkdto.getClassRoom_no()+
									"   教研组 " + pkdto.getDepartment_no()+
									"   教师工号 " + pkdto.getTeacher_no()+ 
									"   授课教室 " + pkdto.getClass_no() + 
									"   教师状态" + pkdto.getTeacher_state()
							);
							listInsert = (List) pkdao.insert(pkdto);
						}
					}
				}
			}
		} catch (SQLException e) {
			e.printStackTrace();
		}

		
		return obj;
	}

	@Override
	public Object findAll() throws AppException {

		return super.findAll();
	}

	@Override
	public Object findAll(Object obj) throws AppException {
		return super.findAll(obj);
	}

	@Override
	public Object findById(Object obj) throws AppException {
		return super.findById(obj);
	}

	@Override
	public Object findByObject(Object obj) throws AppException {
		return super.findByObject(obj);
	}

	@Override
	public int getcount() throws AppException {
		return super.getcount();
	}

	@Override
	public int getcount(Object obj) throws AppException {
		return super.getcount(obj);
	}

	@Override
	public Object list() throws AppException {
		return super.list();
	}

	@Override
	public Object list(Object obj) throws AppException {
		return super.list(obj);
	}

	@Override
	public Object load(Object obj) throws AppException {
		return super.load(obj);
	}

	@Override
	public Object modify(Object obj) throws AppException {
		return super.modify(obj);
	}

	@Override
	public Object remove(Object obj) throws AppException {
		return super.remove(obj);
	}
}