ExamManageServiceImpl

package com.iflytek.edu.zx.exammng.service;

import java.util.ArrayList;
import java.util.Date;
import java.util.List;

import javax.annotation.Resource;

import org.apache.commons.lang3.StringUtils;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.Assert;

import com.iflytek.edu.elp.common.dto.page.PageParam;
import com.iflytek.edu.elp.common.dto.page.Pager;
import com.iflytek.edu.elp.common.exception.ELPSysException;
import com.iflytek.edu.elp.common.util.KeyHolder;
import com.iflytek.edu.zx.exammng.dao.ExamClazzDao;
import com.iflytek.edu.zx.exammng.dao.ExamDao;
import com.iflytek.edu.zx.exammng.dao.ExamResDao;
import com.iflytek.edu.zx.exammng.dao.ExamSubjectDao;
import com.iflytek.edu.zx.exammng.model.Exam;
import com.iflytek.edu.zx.exammng.model.ExamStatus;
import com.iflytek.edu.zx.exammng.model.ExamSubject;
import com.iflytek.edu.zx.exammng.model.agent.AnswerSheet;
import com.iflytek.edu.zx.exammng.model.agent.Clazz;
import com.iflytek.edu.zx.exammng.model.agent.Paper;
import com.iflytek.edu.zx.exammng.model.agent.School;
import com.iflytek.edu.zx.exammng.util.ExamResStatusUtil;
import com.iflytek.edu.zx.exammng.util.ExamResStatusUtil.ExamResOP;
import com.iflytek.edu.zx.exammng.util.ExamStatusUtil;
import com.iflytek.edu.zx.exammng.util.ExamStatusUtil.ExamOP;

/**
 * 考试管理服务实现。
 * 
 * @author znyin
 * 
 */
@Service("examManageService")
public class ExamManageServiceImpl implements ExamManageService {

	/**
	 * ExamDao
	 */
	@Resource
	private ExamDao examDao;

	/**
	 * ExamClazzDao
	 */
	@Resource
	private ExamClazzDao examClazzDao;

	/**
	 * ExamSubjectDao
	 */
	@Resource
	private ExamSubjectDao examSubjectDao;

	/**
	 * ExamResDao
	 */
	@Resource
	private ExamResDao examResDao;

	@Override
	@Transactional("transactionManagerExammng")
	public void createExam(Exam exam) {
		checkExam4Create(exam);

		exam.setId(KeyHolder.getKey());
		exam.setCreateTime(new Date());
		examDao.insert(exam);
		for (Clazz clazz : exam.getClazzs()) {
			examClazzDao.insert(KeyHolder.getKey(), exam, clazz);
		}
		for (ExamSubject examSubject : exam.getSubjects()) {
			examSubject.setId(KeyHolder.getKey());
			examSubject.setExam(exam);
			examSubjectDao.insert(examSubject);
		}

		examDao.updateStatus(exam.getId(), ExamStatusUtil.getNextStatus(ExamOP.create));
	}

	/**
	 * 对考试进行检查。
	 * <p>
	 * 适用于创建考试。
	 * 
	 * @param exam
	 *            考试
	 */
	private void checkExam4Create(Exam exam) {
		Assert.notNull(exam, "exam must not be null.");
		Assert.notNull(exam.getCreator(), "exam.creator must not be null.");
		Assert.hasLength(exam.getCreator().getId(), "exam.creator.code must has length.");
		Assert.hasLength(exam.getName(), "exam.name must has length.");
		Assert.notNull(exam.getPhase(), "exam.phase must not be null.");
		Assert.hasLength(exam.getPhase().getCode(), "exam.phase.code must has length.");
		Assert.hasLength(exam.getPhase().getName(), "exam.phase.name must has length.");
		Assert.notNull(exam.getGrade(), "exam.grade must not be null.");
		Assert.hasLength(exam.getGrade().getCode(), "exam.grade.code must has length.");
		Assert.hasLength(exam.getGrade().getName(), "exam.grade.name must has length.");
		Assert.notNull(exam.getExamTime(), "exam.examTime must not be null.");
		Assert.notEmpty(exam.getClazzs(), "exam.clazzs must not be empty.");
		for (Clazz clazz : exam.getClazzs()) {
			Assert.notNull(clazz, "clazz must not be null.");
			Assert.hasLength(clazz.getCode(), "clazz.code must has length.");
			Assert.hasLength(clazz.getName(), "clazz.name must has length.");
			Assert.notNull(clazz.getSchool(), "clazz.school must not be null.");
			Assert.hasLength(clazz.getSchool().getCode(), "clazz.school.code must has length.");
			Assert.hasLength(clazz.getSchool().getName(), "clazz.school.name must has length.");
		}
		Assert.notEmpty(exam.getSubjects(), "exam.subjects must not be empty.");
		for (ExamSubject examSubject : exam.getSubjects()) {
			Assert.notNull(examSubject, "examSubject must not be null.");
			Assert.notNull(examSubject.getSubject(), "examSubject.subject must not be null.");
			Assert.hasLength(examSubject.getSubject().getCode(), "examSubject.subject.code must has length.");
			Assert.hasLength(examSubject.getSubject().getName(), "examSubject.subject.name must has length.");
		}
	}

	@Override
	@Transactional("transactionManagerExammng")
	public void modifyExam(Exam exam, List<ExamSubject> toDelSubjects, List<ExamSubject> toAddSubjects, List<ExamSubject> unModifySubjects) {
		checkExam4Modify(exam, toDelSubjects, toAddSubjects, unModifySubjects);

		examDao.update(exam.getId(), exam.getName(), exam.getExamTime());

		examClazzDao.deleteByExam(exam.getId());
		for (Clazz clazz : exam.getClazzs()) {
			examClazzDao.insert(KeyHolder.getKey(), exam, clazz);
		}

		for (ExamSubject examSubject : toDelSubjects) {
			examSubject.setExam(exam);
			examSubjectDao.delete(examSubject.getExam().getId(), examSubject.getSubject().getCode());
		}
		for (ExamSubject examSubject : toAddSubjects) {
			examSubject.setId(KeyHolder.getKey());
			examSubject.setExam(exam);
			examSubjectDao.insert(examSubject);
		}
	}

	/**
	 * 对考试进行检查。
	 * <p>
	 * 适用于修改考试。
	 * 
	 * @param exam
	 *            考试
	 * @param toDelSubjects
	 *            待删除学科
	 * @param toAddSubjects
	 *            待添加学科
	 * @param unModifySubjects
	 *            未修改学科
	 */
	private void checkExam4Modify(Exam exam, List<ExamSubject> toDelSubjects, List<ExamSubject> toAddSubjects, List<ExamSubject> unModifySubjects) {
		Assert.notNull(exam, "exam must not be null.");
		Assert.notNull(exam.getId(), "exam.id must not be null.");
		Assert.hasLength(exam.getName(), "exam.name must has length.");
		Assert.notNull(exam.getExamTime(), "exam.examTime must not be null.");
		Assert.notEmpty(exam.getClazzs(), "exam.clazzs must not be empty.");
		for (Clazz clazz : exam.getClazzs()) {
			Assert.notNull(clazz, "clazz must not be null.");
			Assert.hasLength(clazz.getCode(), "clazz.code must has length.");
			Assert.hasLength(clazz.getName(), "clazz.name must has length.");
			Assert.notNull(clazz.getSchool(), "clazz.school must not be null.");
			Assert.hasLength(clazz.getSchool().getCode(), "clazz.school.code must has length.");
			Assert.hasLength(clazz.getSchool().getName(), "clazz.school.name must has length.");
		}

		if (toDelSubjects != null && !toDelSubjects.isEmpty()) {
			for (ExamSubject examSubject : toDelSubjects) {
				Assert.notNull(examSubject, "examSubject must not be null.");
				Assert.notNull(examSubject.getSubject(), "examSubject.subject must not be null.");
				Assert.hasLength(examSubject.getSubject().getCode(), "examSubject.subject.code must has length.");
			}
		}

		List<ExamSubject> examSubjects = new ArrayList<ExamSubject>();
		examSubjects.addAll(unModifySubjects);
		examSubjects.addAll(toAddSubjects);
		Assert.notEmpty(examSubjects, "toAddSubjects and unModifySubjects must not be empty.");
		for (ExamSubject examSubject : examSubjects) {
			Assert.notNull(examSubject, "examSubject must not be null.");
			Assert.notNull(examSubject.getSubject(), "examSubject.subject must not be null.");
			Assert.hasLength(examSubject.getSubject().getCode(), "examSubject.subject.code must has length.");
			Assert.hasLength(examSubject.getSubject().getName(), "examSubject.subject.name must has length.");
		}
	}

	@Override
	@Transactional("transactionManagerExammng")
	public void deleteExam(String examId) {
		Assert.hasLength(examId, "examId must has length.");

		examDao.updateIsDelete(examId, true);
	}

	@Override
	public Exam getExam(String examId) {
		Assert.hasLength(examId, "examId must has length.");

		Exam exam = examDao.find(examId);

		List<ExamSubject> subjects = examSubjectDao.findByExam(examId);
		exam.setSubjects(subjects);

		List<Clazz> clazzs = examClazzDao.findClazzs(examId);
		exam.setClazzs(clazzs);

		return exam;
	}

	@Override
	@Transactional("transactionManagerExammng")
	public void relate(String examId, String subjectCode, String examResId, Paper paper, AnswerSheet answerSheet) {
		Assert.hasLength(examId, "examId must has length.");
		Assert.hasLength(subjectCode, "subjectCode must has length.");

		String examSubjectId=examSubjectDao.findExamSubjectId(examId, subjectCode);
		relate(examSubjectId, examResId, paper, answerSheet);		
	}
	
	@Override
	@Transactional("transactionManagerExammng")
	public void relate(String examSubjectId, String examResId, Paper paper, AnswerSheet answerSheet) {
		Assert.hasLength(examSubjectId, "examSubjectId must has length.");
		
		if (StringUtils.isEmpty(examResId) && paper == null && answerSheet == null) {
			throw new IllegalArgumentException("examResId、paper、answerSheet must not be all null.");
		}

		if (paper != null) {
			Assert.hasLength(paper.getId(), "paper.id must has length.");
			Assert.notNull(paper.getSource(), "paper.source must not be null.");
		}
		if (answerSheet != null) {
			Assert.hasLength(answerSheet.getId(), "answerSheet.id must has length.");
		}
		
		if(!StringUtils.isEmpty(examResId)){
			examSubjectDao.updateRes(examSubjectId, examResId);
		}
		if(paper!=null){
			examSubjectDao.updatePaper(examSubjectId, paper);
		}
		if(answerSheet!=null){
			examSubjectDao.updateAS(examSubjectId, answerSheet);
		}

		if (paper != null || answerSheet != null) {
			String resId = StringUtils.isEmpty(examResId) ? examSubjectDao.findExamResId(examSubjectId) : examResId;
			examResDao.updateStatus(resId, ExamResStatusUtil.getNextStatus(ExamResOP.auditPass));	
		}
	}

	@Override
	public List<ExamSubject> getSubjects(String examId) {
		Assert.hasLength(examId, "examId must has length.");

		return examSubjectDao.findByExam(examId);
	}
	
	@Override
	public List<ExamSubject> getHaveASSubjects(String examId) {
		Assert.hasLength(examId, "examId must has length.");
		
		return examSubjectDao.findHaveAS(examId);
	}

	@Override
	public Pager<Exam> getCompleteExams(String creatorId, PageParam pageParam) {
		Assert.hasLength(creatorId, "creatorId must has length.");
		Assert.notNull(pageParam, "pageParam must not be null.");
		if (pageParam.getStartIndex() < 0) {
			throw new IllegalArgumentException("pageParam.startIndex < 0.");
		}
		if (pageParam.getPageSize() <= 0) {
			throw new IllegalArgumentException("pageParam.pageSize <= 0.");
		}
		if (pageParam.getPageSize() > 1000) {
			throw new IllegalArgumentException("pageParam.pageSize > 1000.");
		}

		List<ExamStatus> statusList=ExamStatusUtil.getCompleteList();
		int totalCount = examDao.findCount(creatorId, statusList);
		List<Exam> list = examDao.findExams(creatorId, statusList, pageParam);
		Pager<Exam> pager = new Pager<Exam>(totalCount, list);

		return pager;
	}
	
	@Override
	public Pager<Exam> getUnCompleteExams(String creatorId, PageParam pageParam) {
		Assert.hasLength(creatorId, "creatorId must has length.");
		Assert.notNull(pageParam, "pageParam must not be null.");
		if (pageParam.getStartIndex() < 0) {
			throw new IllegalArgumentException("pageParam.startIndex < 0.");
		}
		if (pageParam.getPageSize() <= 0) {
			throw new IllegalArgumentException("pageParam.pageSize <= 0.");
		}
		if (pageParam.getPageSize() > 1000) {
			throw new IllegalArgumentException("pageParam.pageSize > 1000.");
		}

		List<ExamStatus> statusList=ExamStatusUtil.getUnCompleteList();
		int totalCount = examDao.findCount(creatorId, statusList);
		List<Exam> list = examDao.findExams(creatorId, statusList, pageParam);
		Pager<Exam> pager = new Pager<Exam>(totalCount, list);

		return pager;
	}

	@Override
	public String getExamCreatorId(String examId) {
		Assert.hasLength(examId, "examId must has length.");

		return examDao.findCreatorCode(examId);
	}

	@Override
	@Transactional("transactionManagerExammng")
	public void completeExam(String examId) {
		Assert.hasLength(examId, "examId must has length.");

		examDao.updateStatus(examId, ExamStatusUtil.getNextStatus(ExamOP.end));
	}

	@Override
	@Transactional("transactionManagerExammng")
	public void remarkExam(String examId) {
		Assert.hasLength(examId, "examId must has length.");

		ExamStatus status = examDao.findStatus(examId);
		if (status == ExamStatus.archived) {
			throw new ELPSysException("已归档的考试不能重阅。");
		}

		examDao.updateStatus(examId, ExamStatusUtil.getNextStatus(ExamOP.remark));
	}

	@Override
	public List<Clazz> getClazzs(String examId,String schoolCode) {
		Assert.hasLength(examId, "examId must has length.");
		Assert.hasLength(schoolCode, "schoolCode must has length.");
		
		return examClazzDao.findClazzs(examId, schoolCode);
	}

	@Override
	public List<School> getSchools(String examId) {
		Assert.hasLength(examId, "examId must has length.");
		
		return examClazzDao.findSchools(examId);
	}

	@Override
	public ExamSubject getSubject(String examSubjectId) {
		Assert.hasLength(examSubjectId, "examSubjectId must has length.");
		
		return examSubjectDao.find(examSubjectId);
	}

	@Override
	public List<Clazz> getClazzs(String examId) {
		Assert.hasLength(examId, "examId must has length.");
		
		return examClazzDao.findClazzs(examId);
	}

}