/**
 * 查詢單個(gè)學(xué)生信息（一個(gè)學(xué)生對(duì)應(yīng)一個(gè)部門(mén)）
 */
public UserVo getOneUser(Integer userId) {
    LambdaQueryWrapper<User> wrapper = Wrappers.lambdaQuery(User.class)
        .eq(User::getUserId, userId);
    // 先查詢用戶信息
    User user = userMapper.selectOne(wrapper);
    // 轉(zhuǎn)化為Vo
    UserVo userVo = Optional.ofNullable(user).map(UserVo::new).orElse(null);
    // 從其它表查詢信息再封裝到Vo
    Optional.ofNullable(userVo).ifPresent(this::addDetpNameInfo);
    return userVo;
}

/**
 * 補(bǔ)充部門(mén)名稱信息
 */
private void addDetpNameInfo(UserVo userVo) {
    LambdaQueryWrapper<Dept> wrapper = Wrappers.lambdaQuery(Dept.class)
        .eq(Dept::getDeptId, userVo.getDeptId());
    Dept dept = deptMapper.selectOne(wrapper);
    Optional.ofNullable(dept).ifPresent(e -> userVo.setDeptName(e.getDeptName()));
}

/**
 * 批量查詢學(xué)生信息（一個(gè)學(xué)生對(duì)應(yīng)一個(gè)部門(mén)）
 */
public List<UserVo> getUserByList() {
    // 先查詢用戶信息（表現(xiàn)形式為列表）
    List<User> user = userMapper.selectList(Wrappers.emptyWrapper());
    List<UserVo> userVos = user.stream().map(UserVo::new).collect(toList());
    // 此步驟可以有多個(gè)
    addDeptNameInfo(userVos);
    return userVos;
}

private void addDeptNameInfo(List<UserVo> userVos) {
    // 提取用戶userId，方便批量查詢
    Set<Integer> deptIds = userVos.stream().map(User::getDeptId).collect(toSet());
    // 根據(jù)deptId查詢deptName（查詢前，先做非空判斷）
    List<Dept> dept = deptMapper.selectList(Wrappers.lambdaQuery(Dept.class).in(Dept::getDeptId, deptIds));
    // 構(gòu)造映射關(guān)系，方便匹配deptId與deptName
    Map<Integer, String> hashMap = dept.stream().collect(toMap(Dept::getDeptId, Dept::getDeptName));
    // 封裝Vo，并添加到集合中(關(guān)鍵內(nèi)容)
    userVos.forEach(e -> e.setDeptName(hashMap.get(e.getDeptId())));
}

/**
 * 查詢單個(gè)部門(mén)（其中一個(gè)部門(mén)有多個(gè)用戶）
 */
public DeptVo getOneDept(Integer deptId) {
    // 查詢部門(mén)基礎(chǔ)信息
    LambdaQueryWrapper<Dept> wrapper = Wrappers.lambdaQuery(Dept.class).eq(Dept::getDeptId, deptId);
    DeptVo deptVo = Optional.ofNullable(deptMapper.selectOne(wrapper)).map(DeptVo::new).orElse(null);
    Optional.ofNullable(deptVo).ifPresent(this::addUserInfo);
    return deptVo;
}

private void addUserInfo(DeptVo deptVo) {
    // 根據(jù)部門(mén)deptId查詢學(xué)生列表
    LambdaQueryWrapper<User> wrapper = Wrappers.lambdaQuery(User.class).eq(User::getDeptId, deptVo.getDeptId());
    List<User> users = userMapper.selectList(wrapper);
    deptVo.setUsers(users);
}

/**
 * 查詢多個(gè)部門(mén)（其中一個(gè)部門(mén)有多個(gè)用戶）
 */
public List<DeptVo> getDeptByList() {
    // 按條件查詢部門(mén)信息
    List<Dept> deptList = deptMapper.selectList(Wrappers.emptyWrapper());
    List<DeptVo> deptVos = deptList.stream().map(DeptVo::new).collect(toList());
    if (deptVos.size() > 0) {
        addUserInfo(deptVos);
    }
    return deptVos;
}

private void addUserInfo(List<DeptVo> deptVos) {
    // 準(zhǔn)備deptId方便批量查詢用戶信息
    Set<Integer> deptIds = deptVos.stream().map(Dept::getDeptId).collect(toSet());
    // 用批量deptId查詢用戶信息
    List<User> users = userMapper.selectList(Wrappers.lambdaQuery(User.class).in(User::getDeptId, deptIds));
    // 重點(diǎn)：將用戶按照deptId分組
    Map<Integer, List<User>> hashMap = users.stream().collect(groupingBy(User::getDeptId));
    // 合并結(jié)果，構(gòu)造Vo，添加集合列表
    deptVos.forEach(e -> e.setUsers(hashMap.get(e.getDeptId())));
}

public StudentVo getStudent(Integer stuId) {
    // 通過(guò)主鍵查詢學(xué)生信息
    StudentVo studentVo = ConvertUtils.convertObj(getById(stuId), StudentVo::new);
    LambdaQueryWrapper<StuSubRelation> wrapper = Wrappers.lambdaQuery(StuSubRelation.class).eq(StuSubRelation::getStuId, stuId);
    // 查詢匹配關(guān)系
    List<StuSubRelation> stuSubRelations = stuSubRelationMapper.selectList(wrapper);
    Set<Integer> subIds = stuSubRelations.stream().map(StuSubRelation::getSubId).collect(toSet());
    if (studentVo != null && subIds.size() > 0) {
        List<Subject> subList = subjectMapper.selectList(Wrappers.lambdaQuery(Subject.class).in(Subject::getId, subIds));
        List<SubjectBo> subBoList = EntityUtils.toList(subList, SubjectBo::new);
        HashBasedTable<Integer, Integer, Integer> table = getHashBasedTable(stuSubRelations);
        subBoList.forEach(e -> e.setScore(table.get(stuId, e.getId())));
        studentVo.setSubList(subBoList);
    }
    return studentVo;
}

public List<StudentVo> getStudentList() {
    // 通過(guò)主鍵查詢學(xué)生信息
    List<StudentVo> studentVoList = EntityUtils.toList(list(), StudentVo::new);
    // 批量查詢學(xué)生ID
    Set<Integer> stuIds = studentVoList.stream().map(Student::getId).collect(toSet());
    LambdaQueryWrapper<StuSubRelation> wrapper = Wrappers.lambdaQuery(StuSubRelation.class).in(StuSubRelation::getStuId, stuIds);
    List<StuSubRelation> stuSubRelations = stuSubRelationMapper.selectList(wrapper);
    // 批量查詢課程ID
    Set<Integer> subIds = stuSubRelations.stream().map(StuSubRelation::getSubId).collect(toSet());
    if (stuIds.size() > 0 && subIds.size() > 0) {
        HashBasedTable<Integer, Integer, Integer> table = getHashBasedTable(stuSubRelations);
        List<Subject> subList = subjectMapper.selectList(Wrappers.lambdaQuery(Subject.class).in(Subject::getId, subIds));
        List<SubjectBo> subjectBoList = EntityUtils.toList(subList, SubjectBo::new);
        Map<Integer, List<Integer>> map = stuSubRelations.stream().collect(groupingBy(StuSubRelation::getStuId, mapping(StuSubRelation::getSubId, toList())));
        for (StudentVo studentVo : studentVoList) {
            // 獲取課程列表
            List<SubjectBo> list = ListUtils.select(subjectBoList, e -> emptyIfNull(map.get(studentVo.getId())).contains(e.getId()));
            // 填充分?jǐn)?shù)
            list.forEach(e -> e.setScore(table.get(studentVo.getId(), e.getId())));
            studentVo.setSubList(list);
        }
    }
    return studentVoList;
}