ProjectMangement/src/main/java/com/yipin/liuwanr/service/ProjectManagementService.java

package com.yipin.liuwanr.service;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;

import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import com.yipin.liuwanr.entity.*;
import org.apache.commons.lang3.StringUtils;
import org.jboss.logging.Logger;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import com.yipin.liuwanr.helper.UserUtil;
import com.yipin.liuwanr.mapper.ProjectManagementMapper;
import com.yipin.liuwanr.mapper.ScoreIndexMapper;

@Service
public class ProjectManagementService {

    private static Logger logger = Logger.getLogger(ProjectManagementService.class);

    @Autowired
    private ProjectManagementMapper mapper;

    @Autowired
    private ScoreIndexMapper indexMapper;


    /**
     * 查询用户角色
     *
     * @param userId
     * @return
     */
    public HashMap<String, Object> queryRole(Integer userId) {
        HashMap<String, Object> resp = new HashMap<String, Object>();
        try {
            Integer roleId = mapper.queryRoleId(userId);
            if (null != roleId) {
                //角色为教师
                if (roleId == 3) {
                    resp.put("retvalue", 1);
                }
                //角色为管理员
                else if (roleId == 1 || roleId == 2) {
                    resp.put("retvalue", 0);
                } else if (roleId == 4) {
                    resp.put("retcode", 300);
                    resp.put("retvalue", "Role does not meet the requirements");
                    return resp;
                }
                resp.put("retcode", 200);
            } else {
                resp.put("retcode", 300);
                resp.put("retvalue", "user does not exist");
            }
        } catch (Exception e) {
            logger.error(e.getMessage());
            resp.put("retcode", 500);
            resp.put("retvalue", "Inquiry Failed");
            return resp;
        }
        return resp;
    }


    /**
     * 条件查询
     *
     * @param vo
     * @return
     */
    public HashMap<String, Object> queryManagements(ProjectManagement vo, Integer pageNo, Integer pageSize) {
        HashMap<String, Object> resp = new HashMap<String, Object>();
        try {
            PageHelper.startPage(pageNo, pageSize);
            //条件查询
            List<ProjectManagement> list = mapper.queryManagementsExport(vo);
//            //获取用户的角色信息
//            String roleId = mapper.queryRoleIds(vo.getUserId());
//            if (null != roleId) {
//                if (roleId.contains("3")) {
//                    vo.setUserId(null);
//                    List<ProjectManagement> projectManagements = mapper.queryManagementsExport(vo);
//                    list.addAll(projectManagements);
//                }
//            }
            PageInfo<ProjectManagement> info = new PageInfo<ProjectManagement>(list);
            resp.put("retvalue", new PageResult(info.getTotal(), list));
            resp.put("retcode", 200);
        } catch (Exception e) {
            logger.error(e.getMessage());
            resp.put("retcode", 500);
            resp.put("retvalue", "Inquiry Failed");
            return resp;
        }
        return resp;
    }
    /**
     * 分页查询+条件查询
     *
     * @param vo
     * @return
     */
    public HashMap<String, Object> queryAllManagements(ProjectManagement vo) {
        HashMap<String, Object> resp = new HashMap<String, Object>();
        try {
            //获取用户的角色信息
//            String roleId = mapper.queryRoleIds(vo.getUserId());
//            if (null != roleId) {
//                //角色不对（学生没有权限）
//                if (roleId.contains("4")) {
//                    resp.put("retcode", 300);
//                    resp.put("retvalue", "抱歉，您的权限不能访问该地址！");
//                    return resp;
//                }
//                //角色等于管理员或者超级管理员
//                else if (roleId.contains("1")) {
//                    vo.setUserId(null);
//                }
//            }
            //条件查询
            List<ProjectManagement> list = mapper.queryManagements(vo);
//            if (vo.getFounder()==null||vo.getFounder()==3){
//                List<ProjectManagement> list2 = mapper.queryUserManagements(vo);
//                list.addAll(list2);
//            }
            resp.put("retvalue",list);
            resp.put("retcode", 200);
        } catch (Exception e) {
            logger.error(e.getMessage());
            resp.put("retcode", 500);
            resp.put("retvalue", "Inquiry Failed");
            return resp;
        }
        return resp;
    }


    /**
     * 批量删除
     *
     * @param projectId：项目管理id
     * @return
     */
    @Transactional
    public HashMap<String, Object> deleteProjectManagement(List<Integer> projectId) {
        HashMap<String, Object> resp = new HashMap<String, Object>();
        try {
            for (Integer po : projectId) {
                //判分点
                List<Judgment_Points> points = mapper.queryProjectIds(po);
                for (int i = 0; i < points.size(); i++) {
                    //判分点
                    Judgment_Points pos = points.get(i);
                    Integer pointId = pos.getJudgmentPointsId();//判分点id
                    String projectIds = pos.getProjectId();//项目id

                    //判分点中删除项目
                    if (!StringUtils.isEmpty(projectIds)) {
                        List<String> lists = Arrays.asList(projectIds.split(","));
                        List<String> obj = new ArrayList<String>(lists);
                        String prijectId = po.toString();
                        if (lists.contains(prijectId)) {
                            obj.remove(prijectId);
                            projectIds = StringUtils.strip(obj.toString(), "[]").replace(" ", "");
                            mapper.updateProject(projectIds, null, pointId);
                        }
                    }
                }
                //删除分数
                indexMapper.removeAllprojectId(po);
                mapper.deleteRole(po);
            }
            int size = projectId.size();
            for (int i = 0;i<size;i++){
                Integer id = projectId.get(i);

                List<Integer> result = mapper.queryproject(id);
                if (result.size()==0){
                    mapper.daleteManegement(id);
                }

                mapper.deleteProjectManagement(id);
            }
            resp.put("retcode", 200);
        } catch (Exception e) {
            logger.error(e.getMessage());
            resp.put("retcode", 500);
            resp.put("retvalue", "Delete  Failed");
            throw new RuntimeException();
        }
        return resp;
    }


    /**
     * 根据项目管理id查询对应信息
     *
     * @param projectId
     * @return
     */
    public HashMap<String, Object> getProjectId(Integer projectId) {
        HashMap<String, Object> resp = new HashMap<String, Object>();
        List<Integer> judgmentPointsId = new ArrayList<Integer>();
        List<Object> obj = new ArrayList<Object>();
        List<Integer> indexs = new ArrayList<Integer>();

        try {
            // 项目信息
            ProjectManagement management = mapper.getProjectId(projectId);

            if (null != management) {
                // 判分点信息
                List<Judgment_Points> points = mapper.getByProjectId(projectId);
                //判分点不为空
                if (null != points && !points.isEmpty()) {
                    //存储判分点id
                    for (int i = 0; i < points.size(); i++) {
                        judgmentPointsId.add(points.get(i).getJudgmentPointsId());
                    }
                    //得到对应判分点的分数
                    List<ScoreIndex> scores = indexMapper.queryScore(judgmentPointsId, projectId, management.getUserId());
                    if (scores.size() > 0 && !scores.isEmpty()) {
                        //为有分数的赋值
                        for (int i = 0; i < points.size(); i++) {
                            Judgment_Points point = points.get(i);
                            for (int j = 0; j < scores.size(); j++) {
                                ScoreIndex score = scores.get(j);
                                if (point.getJudgmentPointsId().equals(score.getJudgmentPointsId())) {
                                    point.setScore(score.getScore());
                                    points.set(i, point);
                                    indexs.add(i);
                                    break;
                                }
                            }
                        }
                        //为没值的赋值
                        for (int i = 0; i < points.size(); i++) {
                            if (!indexs.contains(i)) {
                                Judgment_Points points3 = points.get(i);
                                points3.setScore(0);
                                points.set(i, points3);
                            }
                        }
                    } else {
                        for (int i = 0; i < points.size(); i++) {
                            Judgment_Points point = points.get(i);
                            //给分数赋值
                            point.setScore(0);
                            //修改该判分点
                            points.set(i, point);
                        }
                    }
                }
                // 角色信息
                List<Role> roles = mapper.queryProjectId(projectId);
                // 存数据
                obj.add(management);
                obj.add(points);
                obj.add(roles);
            }
            resp.put("retvalue", obj);
            resp.put("retcode", 200);
        } catch (Exception e) {
            logger.error(e.getMessage());
            resp.put("retcode", 500);
            resp.put("retvalue", "Inquiry Failed");
            return resp;
        }
        return resp;
    }


    /**
     * 添加判分点页面的判分点信息展示
     *
     * @return
     */
    public HashMap<String, Object> queryAllJudgmentPoints(Judgment_Points points) {
        HashMap<String, Object> resp = new HashMap<String, Object>();
        try {
            resp.put("retvalue", mapper.queryAllJudgmentPoints(points));
            resp.put("retcode", 200);
        } catch (Exception e) {
            logger.error(e.getMessage());
            resp.put("retcode", 500);
            resp.put("retvalue", "Add Failed");
            return resp;
        }
        return resp;
    }


    /**
     * 创建项目管理页面的判分点信息展示
     *
     * @param judgmentPointsId 判分点id
     * @return
     */
    public HashMap<String, Object> getByjudgmentPointsId(List<Integer> judgmentPointsId, Integer projectId, Integer userId) {
        HashMap<String, Object> resp = new HashMap<String, Object>();
        try {
            List<Judgment_Points> points = mapper.getByjudgmentPointsIds(judgmentPointsId);
            List<ScoreIndex> scores = indexMapper.queryScore(judgmentPointsId, projectId, userId);
            List<Integer> indexs = new ArrayList<Integer>();
            //为新增项目时勾选判分点赋值
            if (scores.size() <= 0) {
                for (int i = 0; i < points.size(); i++) {
                    Judgment_Points points2 = points.get(i);
                    points2.setScore(0);
                    points.set(i, points2);
                }
            }
            //为修改项目时勾选判分点赋值
            else {
                //为有分数的赋值
                for (int i = 0; i < points.size(); i++) {
                    Judgment_Points point = points.get(i);
                    for (int j = 0; j < scores.size(); j++) {
                        ScoreIndex score = scores.get(j);
                        if (point.getJudgmentPointsId().equals(score.getJudgmentPointsId())) {
                            point.setScore(score.getScore());
                            points.set(i, point);
                            indexs.add(i);
                            break;
                        }
                    }
                }
                //为没值的赋值
                for (int i = 0; i < points.size(); i++) {
                    if (!indexs.contains(i)) {
                        Judgment_Points points3 = points.get(i);
                        points3.setScore(0);
                        points.set(i, points3);
                    }
                }
            }

            resp.put("retvalue", points);
            resp.put("retcode", 200);
        } catch (Exception e) {
            logger.error(e.getMessage());
            resp.put("retcode", 500);
            resp.put("retvalue", "Inquiry Failed");
            return resp;
        }
        return resp;
    }


    /**
     * 平均分配分值
     *
     * @param number
     * @return
     */
    public HashMap<String, Object> avgValues(Integer number) {
        HashMap<String, Object> resp = new HashMap<String, Object>();
        try {
            resp.put("retvalue", UserUtil.averageValue(number));
            resp.put("retcode", 200);
        } catch (Exception e) {
            logger.error(e.getMessage());
            resp.put("retcode", 500);
            resp.put("retvalue", "Calculation ERROR");
            return resp;
        }
        return resp;
    }


    /**
     * 查询单个项目判分点信息，根据项目id
     *
     * @param projectId 项目id
     * @return
     */
    public HashMap<String, Object> getJudgmentPoints(Integer projectId) {
        HashMap<String, Object> resp = new HashMap<String, Object>();
        try {
            resp.put("retvalue", mapper.getJudgmentPoints(projectId));
            resp.put("retcode", 200);
        } catch (Exception e) {
            logger.error(e.getMessage());
            resp.put("retcode", 500);
            resp.put("retvalue", "Inquiry Failed");
            return resp;
        }
        return resp;
    }

    /**
     * 查询单个项目判分点信息
     *
     * @param roleId 角色ID
     * @return
     */
    public HashMap<String, Object> getByRoleId(List<Integer> roleId) {
        HashMap<String, Object> resp = new HashMap<String, Object>();
        try {
            resp.put("retvalue", mapper.getByRoleId(roleId));
            resp.put("retcode", 200);
        } catch (Exception e) {
            logger.error(e.getMessage());
            resp.put("retcode", 500);
            resp.put("retvalue", "Inquiry Failed");
            return resp;
        }
        return resp;
    }


    /**
     * 修改角色信息
     *
     * @param role 角色信息
     * @return
     */
    public HashMap<String, Object> updateRole(Role role) {
        HashMap<String, Object> resp = new HashMap<String, Object>();
        try {
            mapper.updateRole(role);
            resp.put("retcode", 200);
        } catch (Exception e) {
            logger.error(e.getMessage());
            resp.put("retcode", 500);
            resp.put("retvalue", "UPDATE ERROR");
            return resp;
        }
        return resp;
    }


    /**
     * 添加角色信息
     *
     * @param role 角色信息
     * @return
     */
    public HashMap<String, Object> insertRole(Role role) {
        HashMap<String, Object> resp = new HashMap<String, Object>();
        try {
            mapper.insertRole(role);
            Integer roleId = role.getRoleId();
            resp.put("retvalue", roleId);
            resp.put("retcode", 200);
        } catch (Exception e) {
            logger.error(e.getMessage());
            resp.put("retcode", 500);
            resp.put("retvalue", "Add Failed");
            return resp;
        }
        return resp;
    }


    /**
     * 添加项目管理信息
     *
     * @return
     */
    @Transactional
    public HashMap<String, Object> insertProjectManagement(ProjectManagement pro, List<Judgment_Points> points, List<Integer> roles) {
        HashMap<String, Object> resp = new HashMap<String, Object>();
        try {
            //只允许一个Founder
//                if (pro.getFounder()==1){//超管
//                    pro.setFounder(1);
//                }else if (pro.getFounder()==2){//管理员
//                    pro.setFounder(2);
//                }else if (pro.getFounder()==3){//老师
//                    pro.setFounder(3);
//                }
            // 添加项目信息
            mapper.insertProjectManagement(pro);
            // 取出添加的项目信息的id
            Integer projectId = pro.getProjectId();
            for (int i = 0; i < points.size(); i++) {
                //拼接判分点中的项目id
                StringBuffer buff = new StringBuffer();

                //判分点id
                Integer pointId = points.get(i).getJudgmentPointsId();
                //根据该判分点得到数据库存储的对应数据
                Judgment_Points point = mapper.getByjudgmentPointsId(pointId);
                //取出绑定的项目id
                String projectIds = point.getProjectId();
                //取出实验要求
                String experimentalRequirements = point.getExperimentalRequirements();

                //数据库中该判分点已绑定过别的项目id，并且该判分点没有绑定过此时前端传来的项目id
                if (!StringUtils.isEmpty(projectIds)) {
                    List<String> lists = Arrays.asList(projectIds.split(","));
                    if (!lists.contains(projectId.toString())) {
                        buff.append(projectIds);
                        buff.append(",");
                        buff.append(projectId);
                    }
                }
                //数据库中该判分点未绑定任何项目id
                else if (projectIds == null) {
                    buff.append(projectId);
                }
                //数据中实验要求不为空，且数据库中的实验要求与前端传来的实验要求信息一致
                if (experimentalRequirements != null && !experimentalRequirements.equals("")
                        && experimentalRequirements.equals(points.get(i).getExperimentalRequirements())) {
                    mapper.updateProject(new String(buff), null, pointId);
                }
                //数据库中的实验要求与前端传来的实验要求信息不一致
                else if (!experimentalRequirements.equals(points.get(i).getExperimentalRequirements())) {
                    mapper.updateProject(new String(buff), points.get(i).getExperimentalRequirements(), pointId);
                }

                // 得到判分指标信息
                ScoreIndex scoreIndex = new ScoreIndex(points.get(i).getScore(), pointId, projectId, pro.getUserId());
                // 在判分指标中添加对应信息
                indexMapper.addScoreIndex(scoreIndex);
            }
            // 修改角色信息中的项目管理id
            if (roles != null && roles.size() > 0) {
                mapper.updateRoleProjectId(roles, projectId);
            }

            resp.put("retcode", 200);
        } catch (RuntimeException e) {
            logger.error(e.getMessage());
            resp.put("retcode", 500);
            resp.put("retvalue", "Add Failed");
            System.out.println(e.getMessage());
            throw new RuntimeException();
        }
        return resp;
    }


    public HashMap<String, Object>  getByName(String projectName){
        HashMap<String, Object> resp = new HashMap<String, Object>();
        try{
            Integer count = mapper.getByprojectName(projectName);
            if(count>=1){
                resp.put("retcode", 201);
                resp.put("retvalue", "该项目名称已存在");
            }else{
                resp.put("retcode", 200);
            }
        }catch (RuntimeException e){
            logger.error(e.getMessage());
            resp.put("retcode", 500);
            resp.put("retvalue", "QUERY Failed");
            throw new RuntimeException();
        }
        return resp;
    }

    /**
     * 修改项目管理信息
     *
     * @return
     */
    @Transactional
    public HashMap<String, Object> updateProjectManagement(ProjectManagement pro, List<Judgment_Points> points,
                                                           List<Integer> roles) {
        HashMap<String, Object> resp = new HashMap<String, Object>();

        //项目id
        Integer project = pro.getProjectId();
        //用户id
        Integer userId = pro.getUserId();
        try {
            // 取出该项目对应的判分点id
            List<Integer> judgments = mapper.getByPointProjectId(project);
            // 取出该项目对应的角色id
            List<Integer> rolesIds = mapper.getByRoleProjectId(project);

            for (int i = 0; i < points.size(); i++) {
                //拼接判分点中的项目id
                StringBuffer buff = new StringBuffer();

                //前端传来的判分点id
                Integer pointId = points.get(i).getJudgmentPointsId();
                //前端传来的实验要求
                String experimentalRequirements1 = points.get(i).getExperimentalRequirements();
                //前端传来的分数
                Integer score1 = points.get(i).getScore();

                //判分点信息
                Judgment_Points point = mapper.getByjudgmentPointsId(pointId);
                String projectIds = point.getProjectId();
                String experimentalRequirements2 = point.getExperimentalRequirements();

                // 如果数据库中有，则取出分数，进行比较
                if (judgments.contains(pointId)) {
                    //分数
                    Integer score2 = indexMapper.getbyJudgmentPointsIdScore(pointId, project, userId);
                    // 如果分数不一致，则修改分数表中的分数
                    if (score2 != null && score1 != score2) {
                        indexMapper.updateScore(new ScoreIndex(score1, pointId, project, userId));
                    }
                    // 如果数据库中该判分点分数为空，则添加分数
                    else if (score2 == null) {
                        indexMapper.addScoreIndex(new ScoreIndex(score1, pointId, project, pro.getUserId()));
                    }
                    //如果前端传来的实验要求与数据库中不一致，则修改数据库中的判分点信息
                    if (!experimentalRequirements2.equals(experimentalRequirements1)) {
                        mapper.updateProject(point.getProjectId(), experimentalRequirements1, pointId);
                    }
                } else {
                    //数据库中该判分点已绑定过别的项目id，并且该判分点没有绑定过此时前端传来的项目id
                    if (!StringUtils.isEmpty(projectIds)) {
                        List<String> lists = Arrays.asList(projectIds.split(","));
                        if (!lists.contains(project.toString())) {
                            buff.append(projectIds);
                            buff.append(",");
                            buff.append(project);
                        }

                    }
                    //数据库中该判分点未绑定任何项目id
                    else if (StringUtils.isEmpty(projectIds)) {
                        buff.append(project);
                    }
                    //数据中实验要求不为空，且数据库中的实验要求与前端传来的实验要求信息一致
                    if (experimentalRequirements2 != null && !experimentalRequirements2.equals("")
                            && experimentalRequirements2.equals(experimentalRequirements1)) {
                        mapper.updateProject(new String(buff), null, pointId);
                    }
                    //数据库中的实验要求与前端传来的实验要求信息不一致
                    else if (!experimentalRequirements2.equals(experimentalRequirements1)) {
                        mapper.updateProject(new String(buff), experimentalRequirements1, pointId);
                    }
                    // 添加分数
                    indexMapper.addScoreIndex(new ScoreIndex(score1, pointId, project, pro.getUserId()));
                }
                judgments.remove(pointId);
            }

            // 从判分点id中删除该项目的id
            for (int i = 0; i < judgments.size(); i++) {
                Integer judgmentPointsId = judgments.get(i);

                Judgment_Points point = mapper.getByjudgmentPointsId(judgmentPointsId);
                String projectIds = point.getProjectId();
                // 删除分数表中对应的判分点id+项目id数据
                indexMapper.removeScore(judgmentPointsId, project, userId);

                // 对取出的数据，删除该项目的id
                List<String> str3 = Arrays.asList(projectIds.split(","));
                if (str3.contains(project.toString())) {
                    List<String> arrayList = new ArrayList<String>(str3);
                    arrayList.remove(project.toString());
                    // 删除字符中项目id
                    projectIds = StringUtils.strip(arrayList.toString(), "[]").replace(" ", "");
                    // 修改判分点中的项目id
                    mapper.updateProject(projectIds, null, judgments.get(i));
                }
            }

            // 用来存储需要修改的角色id
            List<Integer> roleid = new ArrayList<Integer>();

            // 遍历前端传来的新的角色id
            for (int i = 0; i < roles.size(); i++) {
                // 如果前端传来的数据,在数据库中没有，则存起来
                if (!rolesIds.contains(roles.get(i))) {
                    roleid.add(roles.get(i));
                }
            }

            if (roleid.size() > 0 && !roleid.isEmpty()) {
                // 修改对应角色的项目id
                mapper.updateRoleProjectId(roleid, project);
            }

            //修改项目信息
            mapper.updateProjectManagement(pro);
            resp.put("retcode", 200);
        } catch (RuntimeException e) {
            logger.error(e.getMessage());
            resp.put("retcode", 500);
            resp.put("retvalue", "Update Failed");
            throw new RuntimeException();
        }
        return resp;
    }

}