后台页：预览准考证

oa-app/src/main/java/com/css/oa/exam/assign/controller/AdmissionController.java

@RequestMapping("/admission")
public class AdmissionController extends BaseController {
    @Autowired
    private AssignService mService;
    @ApiOperation(value = "已经分配过考场的考生列表")
    @GetMapping("/queryPage")
    public Result queryPage(@RequestParam String exam_id, int curPage, int pageSize) {
                return setErr("exam_id参数不能为空");
            }
            String token = getToken();
            mService.setToken(token);
            admService.setToken(token);
            AssignQueryReq req = new AssignQueryReq();
            req.condition.exam_id = exam_id;
            req.pageSize = pageSize;
            req.condition.is_gree = BoolState.YES;
            Map map = mService.queryPage(req);
            result = setResult("assigns", map);
            Map map = admService.queryPage(req);
            result = setResult("res", map);
        } catch (Exception e) {
            result = setErr(e.getMessage());
            e.printStackTrace();
                return setErr("req.condition.exam_id参数不能为空");
            }
            String token = getToken();
            mService.setToken(token);
            admService.setToken(token);
            req.condition.is_gree = BoolState.YES;
            Map map = mService.queryCondition(req);
            result = setResult("assigns", map);
            Map map = admService.queryCondition(req);
            result = setResult("res", map);
        } catch (Exception e) {
            result = setErr(e.getMessage());
            e.printStackTrace();

oa-app/src/main/java/com/css/oa/exam/assign/service/AdmService.java

package com.css.oa.exam.assign.service;
import com.css.oa.exam.admin.bean.Admin;
import com.css.oa.exam.assign.bean.AssignQueryReq;
import com.css.oa.exam.assign.bean.Condition;
import com.css.oa.exam.assign.bean.MyAdmWrap;
import com.css.oa.exam.assign.repository.Assign;
import com.css.oa.exam.assign.repository.IAssignRepository;
import com.css.oa.exam.exam.repository.IExamRepository;
import com.css.oa.exam.room.repository.IRoomRepository;
import com.css.oa.exam.room.repository.Room;
import com.css.oa.exam.student.repository.Student;
import com.css.oa.exam.util.CopyObjTool;
import lombok.extern.slf4j.Slf4j;
import org.apache.http.util.TextUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.jpa.domain.Specification;
import org.springframework.stereotype.Service;
import javax.persistence.criteria.*;
import java.util.*;
@Slf4j
@Service
public class AdmService extends BaseAssignService {
    private Specification<Assign> getSpec(Condition condition) {
        Specification<Assign> spec = new Specification<Assign>() {
            @Override
            public Predicate toPredicate(Root<Assign> root, CriteriaQuery<?> criteriaQuery, CriteriaBuilder criteriaBuilder) {
                List<Predicate> predicateList = new ArrayList<>();
                //0.所属考试
                String exam_id = condition.exam_id;
                if (!TextUtils.isEmpty(exam_id)) {
                    predicateList.add(criteriaBuilder.equal(root.get("exam_id").as(String.class), exam_id));
                }
                //学生名、身份证号查询学生信息
                if (condition.studentIds.size() > 0) {
                    Path<String> path = root.get("student_id");//定义查询的字段
                    CriteriaBuilder.In<String> in = criteriaBuilder.in(path);
                    for (String studentId : condition.studentIds) {
                        in.value(studentId);//存入值
                    }
                    predicateList.add(in);
                }
                //我能看到的所有审核
                Admin admin = Admin.getAdminByToken(token);
                if (!TextUtils.isEmpty(admin.my_unit_id)) {
                    //1,如果是我创建的审核
                    Predicate p1 = criteriaBuilder.equal(root.get("create_unit_id").as(String.class), admin.my_unit_id);
                    //2,审核权到了我手里边
                    Predicate p2 = criteriaBuilder.equal(root.get("curr_unit_id").as(String.class), admin.my_unit_id);
                    //3,如果不是我创建的审核，要求审核不是驳回状态
                    Predicate or;
                    //获取room_ids
                    List<String> ids = assignRecord.queryByUnitId(admin.my_unit_id);
                    if (ids.size() > 0) {
                        Path<String> path = root.get("uuid");//定义查询的字段
                        CriteriaBuilder.In<String> in = criteriaBuilder.in(path);
                        for (int i = 0; i < ids.size(); i++) {
                            in.value(ids.get(i));//存入值
                        }
                        Predicate is_reject = criteriaBuilder.notEqual(root.get("is_reject").as(Integer.class), BoolState.YES);
                        Predicate p3 = criteriaBuilder.and(in, is_reject);
                        or = criteriaBuilder.or(p1, p2, p3);
                    } else {
                        or = criteriaBuilder.or(p1, p2);
                    }
                    predicateList.add(or);
                }
                String series_name = condition.series_name;
                if (!TextUtils.isEmpty(series_name)) {
                }
                String room_name = condition.room_name;
                if (!TextUtils.isEmpty(room_name)) {
                    String pattern = "%" + room_name + "%";
                    predicateList.add(criteriaBuilder.like(root.get("room_name").as(String.class), pattern));
                }
                int isAssign = condition.is_assign;
                if (isAssign != BoolState.DEFULT) {
                    Path<String> path = root.get("room_id");//定义查询的字段
                    if (condition.is_assign == BoolState.YES) {
                        predicateList.add(criteriaBuilder.isNotNull(path));
                    } else {
                        predicateList.add(criteriaBuilder.isNull(path));
                    }
                }
                String room_id = condition.room_id;
                if (!TextUtils.isEmpty(room_id)) {
                    predicateList.add(criteriaBuilder.equal(root.get("room_id").as(String.class), room_id));
                }
                String place_id = condition.place_id;
                if (!TextUtils.isEmpty(place_id)) {
                    predicateList.add(criteriaBuilder.equal(root.get("place_id").as(String.class), place_id));
                }
                String area = condition.area;
                if (!TextUtils.isEmpty(area)) {
                    predicateList.add(criteriaBuilder.equal(root.get("area").as(String.class), area));
                }
                //4.审核状态
//                String verify_state = condition.verify_state;
//                if (!TextUtils.isEmpty(verify_state)) {
//                    if (verify_state.equalsIgnoreCase(DropdownVerifyState.WAIT_COMMIT)) {
//                        //待提交
//                        Predicate isInMine = criteriaBuilder.equal(root.get("curr_unit_id").as(String.class), admin.my_unit_id);
//                        Predicate isMeCreate = criteriaBuilder.equal(root.get("create_unit_id").as(String.class), admin.my_unit_id);
//                        Predicate and = criteriaBuilder.and(isInMine, isMeCreate);
//                        predicateList.add(and);
//                    } else if (verify_state.equalsIgnoreCase(DropdownVerifyState.WAIT_VERIFY)) {
//                        //待我审核
//                        Predicate isInMine = criteriaBuilder.equal(root.get("curr_unit_id").as(String.class), admin.my_unit_id);
//                        Predicate isNotMeCreate = criteriaBuilder.notEqual(root.get("create_unit_id").as(String.class), admin.my_unit_id);
//                        Predicate and = criteriaBuilder.and(isInMine, isNotMeCreate);
//                        predicateList.add(and);
//                    } else if (verify_state.equalsIgnoreCase(DropdownVerifyState.ING)) {
//                        //上级审核中
//                        Predicate noInMine = criteriaBuilder.notEqual(root.get("curr_unit_id").as(String.class), admin.my_unit_id);
//                        Predicate isNotGree = criteriaBuilder.notEqual(root.get("curr_unit_id").as(String.class), getTopCode());
//                        Predicate and = criteriaBuilder.and(noInMine, isNotGree);
//                        predicateList.add(and);
//                    } else if (verify_state.equalsIgnoreCase(DropdownVerifyState.ED)) {
//                        //审核通过
//                        predicateList.add(criteriaBuilder.equal(root.get("curr_unit_id").as(String.class), getTopCode()));
//                    }
//                }
                // - - - - - - - - - - - - 下边是准考证查询页面所使用的 - - - - - - - - - - - - -
                String adm_num = condition.adm_num;
                if (!TextUtils.isEmpty(adm_num)) {
                    String pattern = "%" + adm_num + "%";
                    predicateList.add(criteriaBuilder.like(root.get("adm_num").as(String.class), pattern));
                }
                String place_name = condition.place_name;
                if (!TextUtils.isEmpty(place_name)) {
                    String pattern = "%" + place_name + "%";
                    predicateList.add(criteriaBuilder.like(root.get("place_name").as(String.class), pattern));
                }
                int isGenerate = condition.is_generate;
                if (isGenerate == BoolState.NO) {
                    predicateList.add(criteriaBuilder.isNull(root.get("adm_num").as(String.class)));
                } else if (isGenerate == BoolState.YES) {
                    predicateList.add(criteriaBuilder.isNotNull(root.get("adm_num").as(String.class)));
                }
                int is_sended = condition.is_sended;
                if (is_sended != BoolState.DEFULT) {
                    predicateList.add(criteriaBuilder.equal(root.get("is_sended").as(Integer.class), is_sended));
                }
                //分配完毕考场，并一级审核通过，才能查询到准考证
                int isGree = condition.is_gree;
                if (isGree != BoolState.DEFULT) {
                    predicateList.add(criteriaBuilder.equal(root.get("curr_unit_id").as(String.class), getTopCode()));
                }
                Predicate[] pre = new Predicate[predicateList.size()];
                pre = predicateList.toArray(pre);
                return criteriaQuery.where(pre).getRestriction();
            }
        };
        return spec;
    }
    private Specification<Student> getStudentSpec(Condition condition) {
        Specification<Student> spec = new Specification<Student>() {
            @Override
            public Predicate toPredicate(Root<Student> root, CriteriaQuery<?> criteriaQuery, CriteriaBuilder criteriaBuilder) {
                List<Predicate> predicateList = new ArrayList<>();
                //考生名、身份证号、单位名
                String student_name = condition.student_name;
                if (!TextUtils.isEmpty(student_name)) {
                    String pattern = "%" + student_name + "%";
                    predicateList.add(criteriaBuilder.like(root.get("name").as(String.class), pattern));
                }
                String card_num = condition.card_num;
                if (!TextUtils.isEmpty(card_num)) {
                    String pattern = "%" + card_num + "%";
                    predicateList.add(criteriaBuilder.like(root.get("card_num").as(String.class), pattern));
                }
                String unit_name = condition.unit_name;
                if (!TextUtils.isEmpty(unit_name)) {
                    String pattern = "%" + unit_name + "%";
                    predicateList.add(criteriaBuilder.like(root.get("unit_name").as(String.class), pattern));
                }
                Predicate[] pre = new Predicate[predicateList.size()];
                pre = predicateList.toArray(pre);
                return criteriaQuery.where(pre).getRestriction();
            }
        };
        return spec;
    }
    public Map queryPage(AssignQueryReq req) {
        if (req.pageSize == 0) {
            req.pageSize = 20;
        }
        Specification<Assign> spec = getSpec(req.condition);
        PageRequest pageReques = PageRequest.of(req.curPage, req.pageSize);
        Long count = repository.count(spec);
        Page<Assign> pages = repository.findAll(spec, pageReques);
        List<Assign> list = pages.getContent();
        setProperties(list);
        List<MyAdmWrap> wraps = getWraps(list);
        Map map = new LinkedHashMap();
        map.put("total", count);
        map.put("assigns", list);
        map.put("adms", wraps);
        return map;
    }
    public Map queryCondition(AssignQueryReq req) {
        if (req.pageSize == 0) {
            req.pageSize = 20;
        }
        //考生名、身份证号查询考生
        List<Student> students = studentRepository.findAll(getStudentSpec(req.condition));
        if (students.size() == 0) {
            Map map = new LinkedHashMap();
            map.put("total", 0);
            map.put("list", null);
            return map;
        }
        List<String> studentIds = new ArrayList<>();
        for (Student stu : students) {
            studentIds.add(stu.getUuid());
        }
        req.condition.studentIds = studentIds;
        Specification<Assign> spec = getSpec(req.condition);
        PageRequest pageReques = PageRequest.of(req.curPage, req.pageSize);
        Long count = repository.count(spec);
        Page<Assign> pages = repository.findAll(spec, pageReques);
        List<Assign> list = pages.getContent();
        setProperties(list);
        List<MyAdmWrap> wraps = getWraps(list);
        Map map = new LinkedHashMap();
        map.put("total", count);
        map.put("assigns", list);
        map.put("adms", wraps);
        return map;
    }
    @Autowired
    IAssignRepository repository;
        List<Assign> assigns = repository.myAdm(student_id);
        setProperties(assigns);
        List<MyAdmWrap> wraps = getWraps(assigns);
        Map map = new LinkedHashMap();
        map.put("total", wraps.size());
        map.put("list", wraps);
        return map;
    }
    private List<MyAdmWrap> getWraps(List<Assign> assigns) {
        List<MyAdmWrap> wraps = new ArrayList<>();
        for (Assign assign : assigns) {
            MyAdmWrap wrap = new MyAdmWrap();
            CopyObjTool.copyProperties(assign, wrap);
            Exam exam = examRepository.findById(assign.getExam_id()).get();
            wrap.setExam_name("" + exam.getYear() + exam.getExam_name());
            CopyObjTool.copyProperties(exam, wrap);
            wrap.setXilie_jibie(exam.getExam_name() +" "+ exam.getLevel_name());
            
            wrap.setXilie_jibie(exam.getExam_name() + " " + exam.getLevel_name());
            wraps.add(wrap);
        }
        Map map = new LinkedHashMap();
        map.put("total", wraps.size());
        map.put("list", wraps);
        return map;
        return wraps;
    }
}