package kr.wisestone.owl.service.impl;

import com.google.common.collect.Lists;
import kr.wisestone.owl.common.ExcelConditionCheck;
import kr.wisestone.owl.constant.Constants;
import kr.wisestone.owl.constant.MsgConstants;
import kr.wisestone.owl.domain.*;
import kr.wisestone.owl.domain.enumType.EmailType;
import kr.wisestone.owl.domain.enumType.ProjectType;
import kr.wisestone.owl.exception.OwlRuntimeException;
import kr.wisestone.owl.mapper.ProjectMapper;
import kr.wisestone.owl.repository.ProjectClosureRepository;
import kr.wisestone.owl.repository.ProjectRepository;
import kr.wisestone.owl.service.*;
import kr.wisestone.owl.util.CommonUtil;
import kr.wisestone.owl.util.ConvertUtil;
import kr.wisestone.owl.util.DateUtil;
import kr.wisestone.owl.vo.*;
import kr.wisestone.owl.web.condition.ProjectCondition;
import kr.wisestone.owl.web.form.ProjectForm;
import kr.wisestone.owl.web.view.ExcelView;
import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Pageable;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.ui.Model;
import org.springframework.web.servlet.ModelAndView;

import javax.servlet.http.HttpServletRequest;
import java.util.*;

@Service
public class ProjectServiceImpl extends AbstractServiceImpl<Project, Long, JpaRepository<Project, Long>> implements ProjectService {

    private static final Logger log = LoggerFactory.getLogger(ProjectServiceImpl.class);

    @Autowired
    private ProjectRepository projectRepository;

    @Autowired
    private UserService userService;

    @Autowired
    private DepartmentService departmentService;

    @Autowired
    private UserDepartmentService userDepartmentService;

    @Autowired
    private ProjectRoleService projectRoleService;

    @Autowired
    private WorkflowStatusService workflowStatusService;

    @Autowired
    private WorkspaceService workspaceService;

    @Autowired
    private UserWorkspaceService userWorkspaceService;

    @Autowired
    private SystemEmailService systemEmailService;

    @Autowired
    private ProjectRoleUserService projectRoleUserService;

    @Autowired
    private ProjectRoleDepartmentService projectRoleDepartmentService;

    @Autowired
    private AttachedFileService attachedFileService;

    @Autowired
    private IssueService issueService;

    @Autowired
    private IssueUserService issueUserService;

    @Autowired
    private IssueDepartmentService issueDepartmentService;

    @Autowired
    private IssueNumberGeneratorService issueNumberGeneratorService;

    @Autowired
    private ProjectClosureRepository projectClosureRepository;

    @Autowired
    private ProjectMapper projectMapper;

    @Autowired
    private ExcelView excelView;

    @Autowired
    private ExcelConditionCheck excelConditionCheck;

    @Override
    protected JpaRepository<Project, Long> getRepository() {
        return this.projectRepository;
    }

    //  기본으로 제공되는 프로젝트를 생성한다.
    @Override
    @Transactional
    public Project addDefaultProject(User user, Workspace workspace) {
        Project project = new Project();
        project.setName(this.messageAccessor.message("common.issueManagementProject")); // 이슈 관리 프로젝트
        project.setProjectKey("BTS");
        project.setStatus(Project.PROJECT_OPEN);
        project.setDescription(this.messageAccessor.message("common.intoTheSystemIssueManagementProject")); // 시스템에서 기본으로 제공되는 이슈 관리 프로젝트입니다.
        project.setStartDate(DateUtil.convertDateToYYYYMMDD(new Date()));
        project.setEndDate(DateUtil.convertDateToYYYYMMDD(DateUtil.addDays(new Date(), 3650)));
        //  기본으로 생성되는 프로젝트의 유형은 BTS
        project.setProjectType(ProjectType.BTS_PROJECT);
        project.setWorkspace(workspace);
        project.setDefaultYn(true);
        this.projectRepository.saveAndFlush(project);
        //  프로젝트 기본 역할과 관리자 역할을 생성한다. 관리자는 생성한 사용자
        this.projectRoleService.addDefaultProjectRoleUser(project, Lists.newArrayList(user), Lists.newArrayList());
        //  각 프로젝트의 이슈 번호를 자동으로 생성한다.
        this.issueNumberGeneratorService.generateIssueNumber(project);

        //  기본으로 생성되는 프로젝트의 유형은 개발 프로젝트
        this.workflowStatusService.addDefaultWorkflowStatus(project, ProjectType.RMS_PROJECT);

        return project;
    }

    //  프로젝트를 사용자가 생성한다.
    @Transactional
    @Override
    public Project addProject(ProjectForm projectForm) {
        //  사용하고 있는 업무 공간이 활성 상태인지 확인한다. 사용 공간에서 로그인한 사용자가 비활성인지 확인한다.
        this.workspaceService.checkUseWorkspace();
        //  이름 유효성 체크
        this.verifyName(projectForm.getName(), null);
        //  키 유효성 체크
        this.checkDuplicateProjectKey(projectForm.getProjectKey());
        //  상태 체크
        this.verifyProjectStatus(projectForm.getStatus());
        //  날짜 유효성 체크
        //this.checkStartEndDate(projectForm.getStartDate(), projectForm.getEndDate());
        //  관리자 유효성 체크
        this.verifyManager(projectForm.getManagerIds());

        Project project = ConvertUtil.copyProperties(projectForm, Project.class, "projectType");
        project.setProjectType(ProjectType.valueOf(projectForm.getProjectType()));
        Workspace workspace = this.workspaceService.getWorkspace(this.userService.getUser(this.webAppUtil.getLoginId()).getLastWorkspaceId());
        project.setWorkspace(workspace);

        this.projectRepository.saveAndFlush(project);
        // 상위프로젝트 넣기
        SetParentProject(projectForm.getParentProjectId(), project);

        //  각 프로젝트의 이슈 번호를 자동으로 생성한다.
        this.issueNumberGeneratorService.generateIssueNumber(project);
        //  일반 사용자 및 관리자를 등록하고 사용자들에게 해당 역할을 배정한다.
        //this.registerManagerAndUser(projectForm, project);
        this.registerManagerAndDepartment(projectForm, project);

        //  프로젝트 유형에 따른 워크플로우 생성
        this.workflowStatusService.addDefaultWorkflowStatus(project, ProjectType.valueOf(projectForm.getProjectType()));

        return project;
    }

    //  일반 사용자 및 관리자를 등록하고 사용자들에게 해당 역할을 배정한다.
    private void registerManagerAndUser(ProjectForm projectForm, Project project) {
        List<User> managers = Lists.newArrayList();
        //  관리자 등록
        for (Long managerId : projectForm.getManagerIds()) {
            User user = this.userService.getUser(managerId);
            managers.add(user);
        }
        List<User> users = Lists.newArrayList();
        List<String> sendEmails = Lists.newArrayList(); //  메일 대상자

        //  일반 사용자 등록
        for (Long userId : projectForm.getUserIds()) {
            User user = this.userService.getUser(userId);
            users.add(user);
            sendEmails.add(user.getAccount());
        }

        //  기본, 관리자 프로젝트 역할을 생성하고 사용자를 해당 역할에 배정한다.
        this.projectRoleService.addDefaultProjectRoleUser(project, managers, users);

        //  프로젝트 참여자들에게 이메일 발송을 예약한다.
        Map<String, Object> projectMap = new HashMap<>();
        projectMap.put("workspaceName", project.getWorkspace().getName());
        projectMap.put("projectName", project.getName());
        projectMap.put("registerDate", DateUtil.convertDateToStr(new Date()));

        StringBuilder stringBuilder = new StringBuilder();
        stringBuilder.append(managers.get(0).getName());
        stringBuilder.append("(");
        stringBuilder.append(CommonUtil.decryptAES128(managers.get(0).getAccount()));
        stringBuilder.append(")");

        projectMap.put("projectManagerName", stringBuilder.toString());
        //  프로젝트 일반 참여 메일 발송 예약
        this.systemEmailService.reservationEmail(sendEmails.toArray(new String[sendEmails.size()]), EmailType.PROJECT_DEFAULT_INCLUDE, projectMap);
    }

    private void registerManagerAndDepartment(ProjectForm projectForm, Project project) {
        List<User> managers = Lists.newArrayList();
        //  관리자 등록
        for (Long managerId : projectForm.getManagerIds()) {
            User user = this.userService.getUser(managerId);
            managers.add(user);
        }

        List<Department> departments = Lists.newArrayList();
        List<String> sendEmails = Lists.newArrayList(); //  메일 대상자
        //  부서 등록
        for (Long departmentId : projectForm.getDepartmentIds()) {
            Department department = this.departmentService.getDepartment(departmentId);
            /*List<UserDepartment> userDepartments = this.userDepartmentService.getUserDepartments(departmentId);
            if(userDepartments != null){
                for (UserDepartment userDepartment : userDepartments){
                    User user = this.userService.getUser(userDepartment.getUserId());
                    sendEmails.add(user.getAccount());
                }
            }*/
            departments.add(department);
        }

        //  기본, 관리자 프로젝트 역할을 생성하고 담당부서를 해당 역할에 배정한다.
        this.projectRoleService.addDefaultProjectRoleDepartment(project, managers, departments);

        //  프로젝트 참여자들에게 이메일 발송을 예약한다.
        Map<String, Object> projectMap = new HashMap<>();
        projectMap.put("workspaceName", project.getWorkspace().getName());
        projectMap.put("projectName", project.getName());
        projectMap.put("registerDate", DateUtil.convertDateToStr(new Date()));

        StringBuilder stringBuilder = new StringBuilder();
        stringBuilder.append(managers.get(0).getName());
        stringBuilder.append("(");
        stringBuilder.append(CommonUtil.decryptAES128(managers.get(0).getAccount()));
        stringBuilder.append(")");

        projectMap.put("projectManagerName", stringBuilder.toString());
        //  프로젝트 담당부서 메일 발송 예약
        this.systemEmailService.reservationEmail(sendEmails.toArray(new String[sendEmails.size()]), EmailType.PROJECT_DEFAULT_INCLUDE, projectMap);
    }


    //  이름 유효성 체크
    private void verifyName(String name, Long id) {
        if (StringUtils.isEmpty(name)) {
            throw new OwlRuntimeException(
                    this.messageAccessor.getMessage(MsgConstants.PROJECT_NOT_NAME));
        }

        if (name.length() > 50) {
            throw new OwlRuntimeException(
                    this.messageAccessor.getMessage(MsgConstants.PROJECT_NAME_MAX_LENGTH_OUT));
        }

        Project project;

        Long workspaceId = this.userService.getUser(this.webAppUtil.getLoginId()).getLastWorkspaceId();

        if (id == null) {
            project = this.projectRepository.findByNameAndWorkspaceId(name, workspaceId);
        }
        else {
            project = this.projectRepository.findByNameAndWorkspaceIdAndIdNot(name, workspaceId, id);
        }

        if (project != null) {
            throw new OwlRuntimeException(
                    this.messageAccessor.getMessage(MsgConstants.PROJECT_USED_NAME));
        }
    }

    //  키 유효성 체크
    private void checkDuplicateProjectKey(String projectKey) {
        if (StringUtils.isEmpty(projectKey)) {
            throw new OwlRuntimeException(this.messageAccessor.getMessage(MsgConstants.PROJECT_KEY_NOT_EXIST));
        }


        if (projectKey.length() > 10) {
            throw new OwlRuntimeException(this.messageAccessor.getMessage(MsgConstants.PROJECT_OVER_LENGTH_PROJECT_KEY));
        }

        Project project = this.findByProjectKey(projectKey);

        if (project != null) {
            throw new OwlRuntimeException(this.messageAccessor.getMessage(MsgConstants.PROJECT_USED_PROJECT_KEY));
        }
    }

    //  날짜 유효성 체크
    private void checkStartEndDate(String startDate, String endDate) {
        if (StringUtils.isEmpty(startDate) || StringUtils.isEmpty(endDate)) {
            throw new OwlRuntimeException(
                    this.messageAccessor.getMessage(MsgConstants.DATE_NOT_EXIST));
        }

        Date start = DateUtil.convertStrToDate(startDate, "yyyy-MM-dd");
        Date end = DateUtil.convertStrToDate(endDate, "yyyy-MM-dd");
        if (start.getTime() > end.getTime()) {
            throw new OwlRuntimeException(
                    this.messageAccessor.getMessage(MsgConstants.DATE_PICKER_NOT_AVAILABLE));
        }
    }

    //  관리자 유효성 체크
    private void verifyManager(List<Long> managerIds) {
        if (managerIds.isEmpty()) {
            throw new OwlRuntimeException(
                    this.messageAccessor.getMessage(MsgConstants.PROJECT_NOT_MANAGER));
        }
    }

    //  상태 체크
    private void verifyProjectStatus(String projectStatus) {
        if (StringUtils.isEmpty(projectStatus)) {
            throw new OwlRuntimeException(
                    this.messageAccessor.getMessage(MsgConstants.PROJECT_NOT_STATUS));
        }
    }

    //  프로젝트 목록을 조회한다.
    @Override
    @Transactional(readOnly = true)
    public List<ProjectVo> findProject(Map<String, Object> resJsonData,
                                       ProjectCondition condition, Pageable pageable) {

        condition.setPage(pageable.getPageNumber() * pageable.getPageSize());
        condition.setPageSize(pageable.getPageSize());
        condition.setLoginUserId(this.webAppUtil.getLoginId());
        condition.setWorkspaceId(this.userService.getUser(this.webAppUtil.getLoginId()).getLastWorkspaceId());

        List<Map<String, Object>> results;
        Long totalCount;

        if (condition.getWorkspaceManager()) {
            //  업무공간 관리자일 경우 모든 프로젝트가 표시되어야 한다.
            //  관리자일 때
            if (this.userWorkspaceService.checkWorkspaceManager()) {
                results = this.projectMapper.findByWorkspaceManager(condition);
                totalCount = this.projectMapper.countByWorkspaceManager(condition);
            }
            else {
                results = this.projectMapper.find(condition);
                totalCount = this.projectMapper.count(condition);
            }
        }
        else {
            results = this.projectMapper.find(condition);
            totalCount = this.projectMapper.count(condition);
        }

        int totalPage = (int) Math.ceil((totalCount - 1) / pageable.getPageSize()) + 1;
        //  프로젝트 조회 결과를 ProjectVos 로 변환한다. - 관리자, 일반 사용자 정보 추가
        List<ProjectVo> projectVos = this.makeProjectVos(results);
        this.setChildrenProject(projectVos);

        resJsonData.put(Constants.RES_KEY_CONTENTS, projectVos);
        resJsonData.put(Constants.REQ_KEY_PAGE_VO, new ResPage(pageable.getPageNumber(), pageable.getPageSize(),
                totalPage, totalCount));

        return projectVos;
    }

    void setChildrenProject(List<ProjectVo> projectVos) {
        int projectCount = projectVos.size();
        for (int i=0; i< projectCount; i++) {
            ProjectVo projectVo = projectVos.get(i);
            List<Map<String, Object>> children = this.projectMapper.findChildrenProject(projectVo.getId());

            if (children != null && children.size() > 0) {
                List<ProjectVo> childrenVo = this.makeProjectVos(children);
                projectVo.setChildProjects(childrenVo);
                setChildrenProject(childrenVo);
            }
        }
    }


    //  프로젝트 조회 결과를 ProjectVos 로 변환한다.
    private List<ProjectVo> makeProjectByVos(List<Map<String, Object>> results) {
        List<ProjectVo> projectVos = Lists.newArrayList();

        for (Map<String, Object> result : results) {
            ProjectVo projectVo = ConvertUtil.convertMapToClass(result, ProjectVo.class);
            projectVos.add(projectVo);
        }

        return projectVos;
    }


    //  프로젝트 조회 결과를 ProjectVos 로 변환한다. - 관리자, 일반 사용자 정보 추가
    private List<ProjectVo> makeProjectVos(List<Map<String, Object>> results) {
        List<ProjectVo> projectVos = Lists.newArrayList();

        for (Map<String, Object> result : results) {
            ProjectVo projectVo = ConvertUtil.convertMapToClass(result, ProjectVo.class);
            //  프로젝트에 참여하는 사용자를 셋팅한다. - 관리자 / 일반 사용자
            this.setProjectUser(projectVo, true);
            this.setProjectUser(projectVo, false);
            
            //  프로젝트에 참여하는 부서 세팅
            this.setProjectDepartment(projectVo);

            //  업무공간 담당자는 모든 프로젝트를 수정/삭제할 수 있어야 한다.
            if (this.userWorkspaceService.checkWorkspaceManager()) {
                projectVo.setModifyPermissionCheck(true);
            }
            projectVos.add(projectVo);
        }

        return projectVos;
    }

    //  관리자, 일반 사용자를 조건에 따라 찾아준다.
    private void setProjectUser(ProjectVo projectVo, Boolean findProjectManager) {
        Map<String, Object> projectRoleUserMap = new HashMap<>();
        projectRoleUserMap.put("id", projectVo.getId());

        if (findProjectManager) {
            projectRoleUserMap.put("statuses", Lists.newArrayList("02"));   //  관리자 셋팅
        }
        else {
            projectRoleUserMap.put("statuses", Lists.newArrayList("01"));   //  일반 사용자 셋팅
        }

        //  사용자 정보 셋팅
        List<Map<String, Object>> projectRoleUsers = this.projectRoleUserService.findProjectRoleUser(projectRoleUserMap);

        if (projectRoleUsers != null && !projectRoleUsers.isEmpty()) {
            List<UserVo> userVos = Lists.newArrayList();

            for (Map<String, Object> projectRoleUser : projectRoleUsers) {
                UserVo userVo = ConvertUtil.convertMapToClass(projectRoleUser, UserVo.class);
                userVo.setByName(userVo.getName() + "(" + CommonUtil.decryptAES128(userVo.getAccount()) + ")");
                userVo.setAccount(CommonUtil.decryptAES128(userVo.getAccount()));
                //  현재 로그인한 사용자가 담당자일 경우 수정 권한을 준다.
                if (userVo.getId().equals(this.webAppUtil.getLoginId()) && findProjectManager) {
                    projectVo.setModifyPermissionCheck(Boolean.TRUE);
                }
                userVos.add(userVo);
            }

            if (findProjectManager) {
                projectVo.setProjectManagerVos(userVos);
            }
            else {
                projectVo.setProjectUserVos(userVos);
            }
        }
    }

    //  담당부서를 조건에 따라 찾아준다.
    private void setProjectDepartment(ProjectVo projectVo) {
        Map<String, Object> projectRoleDepartmentMap = new HashMap<>();
        projectRoleDepartmentMap.put("id", projectVo.getId());

        //  부서 정보 셋팅
        List<Map<String, Object>> projectRoleDepartments = this.projectRoleDepartmentService.findProjectRoleDepartment(projectRoleDepartmentMap);

        if (projectRoleDepartments != null && !projectRoleDepartments.isEmpty()) {
            List<DepartmentVo> departmentVos = Lists.newArrayList();

            for (Map<String, Object> projectRoleDepartment : projectRoleDepartments) {
                DepartmentVo departmentVo = ConvertUtil.convertMapToClass(projectRoleDepartment, DepartmentVo.class);
                departmentVo.setByName(departmentVo.getDepartmentName());
                departmentVos.add(departmentVo);
            }
            projectVo.setProjectDepartmentVos(departmentVos);
        }
    }


    //  프로젝트 상세 정보를 조회한다.
    @Override
    @Transactional(readOnly = true)
    public void detailProject(Map<String, Object> resJsonData, ProjectCondition projectCondition) {
        ProjectVo projectVo = new ProjectVo();

        if (projectCondition.getId() != null) {
            Project project = this.getProject(projectCondition.getId());
            projectVo = ConvertUtil.copyProperties(project, ProjectVo.class);
            projectVo.setProjectType(project.getProjectType().toString());

            // 상위 프로젝트 정보 가져오기
            ProjectClosure closure = project.getParentProjectClosure();
            if (closure != null) {
                ProjectVo parentProjectVo = ConvertUtil.copyProperties(closure.getParentProject(), ProjectVo.class);
                projectVo.setParentProjectVo(parentProjectVo);
            }

            switch (projectCondition.getDeep()) {
                case "01": //  프로젝트에 참여하는 사용자, 관리자 정보를 셋팅한다.
                    this.setProjectUser(projectVo, true);
                    this.setProjectUser(projectVo, false);
                    this.setProjectDepartment(projectVo); //부서 정보 세팅
                    break;
            }
        }

        resJsonData.put(Constants.RES_KEY_CONTENTS, projectVo);
    }

    //  프로젝트 정보를 수정한다.
    @Transactional
    @Override
    public Project modifyProject(ProjectForm projectForm) {
        //  사용하고 있는 업무 공간이 활성 상태인지 확인한다. 사용 공간에서 로그인한 사용자가 비활성인지 확인한다.
        this.workspaceService.checkUseWorkspace();
        //  이름 유효성 체크
        this.verifyName(projectForm.getName(), projectForm.getId());
        //  상태 체크
        this.verifyProjectStatus(projectForm.getStatus());
        //  날짜 유효성 체크
        //this.checkStartEndDate(projectForm.getStartDate(), projectForm.getEndDate());
        //  관리자 유효성 체크
        this.verifyManager(projectForm.getManagerIds());

        Project project = this.getProject(projectForm.getId());
        //  프로젝트 참여 사용자
        List<Long> existUserIds = this.getIncludeProjectUser(project);
        //  프로젝트 참여 부서
        List<Long> existDepartmentIds = this.getIncludeProjectDepartment(project);

        //  워크스페이스에서 기본으로 제공되는 프로젝트에 대한 체크
        this.checkDefaultProject(project, projectForm);
        //  수정 권한 체크
        this.checkModifyPermission(project.getId());
        //  관리자 변경
        Map<String, Object> changeProjectManagerNotifications = this.modifyProjectManagers(project, projectForm, ProjectRole.TYPE_MANAGER);
        //  일반 사용자 변경
        Map<String, Object> changeProjectUserNotifications = this.modifyProjectManagers(project, projectForm, ProjectRole.TYPE_DEFAULT);
        Map<String, Object> changeProjectDepartmentNotifications = this.modifyProjectDepartments(project, projectForm);
        ConvertUtil.copyProperties(projectForm, project, "id", "projectType");

        this.projectRepository.saveAndFlush(project);

        // 상위 프로젝트 정보 저장
        SetParentProject(projectForm.getParentProjectId(), project);

        //  프로젝트에서 참여가 제외된 사용자는 이슈 담당자에서 제외한다.
        //  해당 프로젝트에 참여하는 모든 사용자 조회
        //  빠진 사람이 관리하는 이슈 전체 조회 후 데이터 삭제
        List<Long> changeUserIds = this.getIncludeProjectUser(project);
        List<Long> changeDepartmentIds = this.getIncludeProjectDepartment(project);

        //  참여에서 제외된 사용자를 찾고 담당하고 있던 이슈에서 제외한다.
        this.checkExcludeUserAndRemoveIssueAssignee(project, existUserIds, changeUserIds);
        this.checkExcludeDepartmentAndRemoveIssueDepartment(project, existDepartmentIds, changeDepartmentIds);

        //  관리자/일반 사용자 변경 내역을 통지한다.
        //this.notificationProjectRoleUser(changeProjectManagerNotifications, changeProjectUserNotifications, project);
        //  관리자/담당부서 변경 내역을 통지한다.
        this.notificationProjectRoleDepartment(changeProjectManagerNotifications, changeProjectDepartmentNotifications, project);

        return project;
    }

    void SetParentProject(Long parentProjectId, Project project) {
        ProjectClosure projectClosure = this.projectClosureRepository.findByProjectId(project.getId());
        if (parentProjectId != null && parentProjectId > -1) {
            Project parentProject = this.getProject(parentProjectId);
            if (projectClosure != null) {
                projectClosure.setParentProject(parentProject);
            } else {
                projectClosure = new ProjectClosure(project, parentProject);
            }
            this.projectClosureRepository.saveAndFlush(projectClosure);
        } else {
            if (projectClosure != null) {
                this.projectClosureRepository.delete(projectClosure);
            }
        }
    }


    //  프로젝트 참여 사용자
    private List<Long> getIncludeProjectUser(Project project) {
        Set<Long> includeUserIds = new HashSet<>();

        for (ProjectRole projectRole : project.getProjectRoles()) {
            List<ProjectRoleUser> projectRoleUsers =  this.projectRoleUserService.findByProjectRoleId(projectRole.getId());

            for (ProjectRoleUser projectRoleUser : projectRoleUsers) {
                includeUserIds.add(projectRoleUser.getUser().getId());
            }
        }

        return Lists.newArrayList(includeUserIds);
    }

    //  프로젝트 참여 부서
    private List<Long> getIncludeProjectDepartment(Project project) {
        Set<Long> includeDepartmentIds = new HashSet<>();

        for (ProjectRole projectRole : project.getProjectRoles()) {
            List<ProjectRoleDepartment> projectRoleDepartments =  this.projectRoleDepartmentService.findByProjectRoleId(projectRole.getId());

            for (ProjectRoleDepartment projectRoleDepartment : projectRoleDepartments) {
                includeDepartmentIds.add(projectRoleDepartment.getDepartment().getId());
            }
        }
        return Lists.newArrayList(includeDepartmentIds);
    }

    //  참여에서 제외된 사용자를 찾고 담당하고 있던 이슈에서 제외한다.
    private void checkExcludeUserAndRemoveIssueAssignee(Project project, List<Long> existUserIds, List<Long> changeUserIds) {
        List<Long> excludeUserIds = CommonUtil.searchChangeList(changeUserIds, existUserIds);

        if (excludeUserIds.size() > 0) {
            this.issueUserService.removeIssueUser(project.getId(), excludeUserIds);
        }
    }

    //  참여에서 제외된 부서를 찾고 담당하고 있던 이슈에서 제외한다.
    private void checkExcludeDepartmentAndRemoveIssueDepartment(Project project, List<Long> existDepartmentIds, List<Long> changeDepartmentIds) {
        List<Long> excludeDepartmentIds = CommonUtil.searchChangeList(changeDepartmentIds, existDepartmentIds);

        if (excludeDepartmentIds.size() > 0) {
            this.issueDepartmentService.removeIssueDepartment(project.getId(), excludeDepartmentIds);
        }
    }

    //  기본 제공되는 프로젝트의 관리자는 워크스페이스 관리자가 포함되어 있어야 한다.
    private void checkDefaultProject(Project project, ProjectForm projectForm) {
        if (project.getDefaultYn()) {
            //  해당 프로젝트의 워크스페이스의 관리자를 찾는다.
            //  기본 프로젝트는 워크스페이스 관리자가 무조건 프로젝트 관리자로 들어가 있어야 한다.
            Workspace workspace = project.getWorkspace();
            List<UserWorkspace> userWorkspaces = this.userWorkspaceService.findByWorkspaceIdAndManagerYn(workspace.getId(), true);

            for (UserWorkspace userWorkspace : userWorkspaces) {
                User workspaceManager = userWorkspace.getUser();
                boolean checkDefaultManager = false;

                for (Long managerId : projectForm.getManagerIds()) {
                    if (managerId.equals(workspaceManager.getId())) {
                        checkDefaultManager = true;
                        break;
                    }
                }

                if (!checkDefaultManager) {
                    throw new OwlRuntimeException(
                            this.messageAccessor.getMessage(MsgConstants.DEFAULT_PROJECT_MANAGER_NOT_CHANGE));
                }
            }
        }
    }

    //  로그인한 사용자가 관리자 역할에 소속되어 있는지 확인한다.
    private void checkModifyPermission(Long projectId) {
        Boolean hasPermission = Boolean.FALSE;

        //  해당 업무 공간의 관리자일 경우 권한 체크를 하지 않는다.
        if (this.userWorkspaceService.checkWorkspaceManager()) {
            return;
        }

        //  관리자 역할 조회
        Map<String, Object> projectRoleUserMap = new HashMap<>();
        projectRoleUserMap.put("id", projectId);
        projectRoleUserMap.put("statuses", Lists.newArrayList("02"));   //  관리자 조회

        List<Map<String, Object>> projectUsers = this.projectRoleUserService.findProjectRoleUser(projectRoleUserMap);
        //  현재 로그인 사용자가 관리자인지 확인
        if (projectUsers != null && !projectUsers.isEmpty()) {
            for (Map<String, Object> projectUser : projectUsers) {
                UserVo userVo = ConvertUtil.convertMapToClass(projectUser, UserVo.class);
                if (userVo.getId().equals(this.webAppUtil.getLoginId())) {
                    hasPermission = true;
                    break;
                }
            }
        }

        if (!hasPermission) {
            throw new OwlRuntimeException(
                    this.messageAccessor.getMessage(MsgConstants.PROJECT_NOT_MODIFY_PERMISSION));
        }
    }

    //  관리자를 변경한다.
    private Map<String, Object> modifyProjectManagers(Project project, ProjectForm projectForm, String roleType) {
        ProjectRole projectRole = this.projectRoleService.findByProjectIdAndRoleType(project.getId(), roleType);
        List<User> oldManager = Lists.newArrayList();
        List<User> newManager = Lists.newArrayList();
        Map<String, Object> results = new HashMap<>();

        for (ProjectRoleUser projectRoleUser : projectRole.getProjectRoleUsers()) {
            User user = projectRoleUser.getUser();
            oldManager.add(user);
            user.removeProjectRole(projectRole);
        }

        projectRole.getProjectRoleUsers().clear();

        //  관리자일 경우
        if (roleType.equals(ProjectRole.TYPE_MANAGER)) {
            for (Long managerId : projectForm.getManagerIds()) {
                User user = this.userService.getUser(managerId);
                newManager.add(user);
                user.addProjectRole(projectRole);
            }
        }
        else if (roleType.equals(ProjectRole.TYPE_DEFAULT)) {
            //  일반 사용자일 경우
            for (Long userId : projectForm.getUserIds()) {
                User user = this.userService.getUser(userId);
                newManager.add(user);
                user.addProjectRole(projectRole);
            }
        }

        //  제외 대상자 찾기, oldManager 에는 있는데 newManager 에 없으면 제외 대상
        List<String> excludeUsers = this.systemEmailService.notificationUserChange(oldManager, newManager);
        //  참여 대상자 찾기, newManager 에는 있는데 oldManager 에 없으면 초대받은 대상
        List<String> includeUsers = this.systemEmailService.notificationUserChange(newManager, oldManager);

        results.put("excludeUsers", excludeUsers);
        results.put("includeUsers", includeUsers);

        return results;

    }

    //  담당부서를 변경한다.
    private Map<String, Object> modifyProjectDepartments(Project project, ProjectForm projectForm) {
        ProjectRole projectRole = this.projectRoleService.findByProjectIdAndRoleType(project.getId(), ProjectRole.TYPE_DEFAULT);
        List<Department> oldDepartment = Lists.newArrayList();
        List<Department> newDepartment = Lists.newArrayList();
        Map<String, Object> results = new HashMap<>();

        for (ProjectRoleDepartment projectRoleDepartment : projectRole.getProjectRoleDepartments()) {
            Department department = projectRoleDepartment.getDepartment();
            oldDepartment.add(department);
            department.removeProjectRole(projectRole);
        }
        projectRole.getProjectRoleDepartments().clear();

        for (Long departmentId : projectForm.getDepartmentIds()) {
            Department department = this.departmentService.getDepartment(departmentId);
            department.addProjectRole(projectRole);
        }

        //  제외 대상자 찾기, oldDepartment 에는 있는데 newDepartment 에 없으면 제외 대상
        List<String> excludeDepartments = this.systemEmailService.notificationDepartmentChange(oldDepartment, newDepartment);
        //  참여 대상자 찾기, newDepartment 에는 있는데 oldDepartment 에 없으면 초대받은 대상
        List<String> includeDepartments = this.systemEmailService.notificationDepartmentChange(newDepartment, oldDepartment);

        results.put("excludeDepartments", excludeDepartments);
        results.put("includeDepartments", includeDepartments);

        return results;

    }

    //  프로젝트 참여, 제외 통지 정보를 중복으로 나가지 않도록 체크한다.
    private void notificationProjectRoleUser(Map<String, Object> changeProjectManagerNotifications, Map<String, Object> changeProjectUserNotifications, Project project) {
        List<String> projectManagerExcludeUsers = (List<String>) changeProjectManagerNotifications.get("excludeUsers");  //  관리자 제외 사용자
        List<String> projectManagerIncludeUsers = (List<String>) changeProjectManagerNotifications.get("includeUsers");  //  관리자 참여 사용자
        List<String> projectUserExcludeUsers = (List<String>) changeProjectUserNotifications.get("excludeUsers");    //  제외된 일반 사용자
        List<String> projectUserIncludeUsers = (List<String>) changeProjectUserNotifications.get("includeUsers");    //  참여된 일반 사용자
        Map<String, Object> projectMap = new HashMap<>();
        projectMap.put("workspaceName", project.getWorkspace().getName());
        projectMap.put("projectName", project.getName());
        projectMap.put("registerDate", DateUtil.convertDateToStr(new Date()));

        Map<String, Object> projectRoleUserMap = new HashMap<>();
        projectRoleUserMap.put("id", project.getId());
        projectRoleUserMap.put("statuses", Lists.newArrayList("02"));   //  관리자 조회

        //  관리자 정보 셋팅
        List<Map<String, Object>> projectRoleUsers = this.projectRoleUserService.findProjectRoleUser(projectRoleUserMap);

        if (projectRoleUsers != null && !projectRoleUsers.isEmpty()) {
            for (Map<String, Object> projectRoleUser : projectRoleUsers) {
                UserVo userVo = ConvertUtil.convertMapToClass(projectRoleUser, UserVo.class);
                StringBuilder stringBuilder = new StringBuilder();
                stringBuilder.append(userVo.getName());
                stringBuilder.append("(");
                stringBuilder.append(CommonUtil.decryptAES128(userVo.getAccount()));
                stringBuilder.append(")");

                projectMap.put("projectManagerName", stringBuilder.toString());
            }
        }

        // 프로젝트 관리자에서 제외되었으면서 프로젝트 일반 사용자로 들어간 경우
        List<String> excludeManagerAndIncludeUser = Lists.newArrayList();

        for (String projectManagerExcludeUserEmail : projectManagerExcludeUsers) {
            for (String projectUserIncludeUserEmail : projectUserIncludeUsers) {
                if (projectManagerExcludeUserEmail.equals(projectUserIncludeUserEmail)) {
                    excludeManagerAndIncludeUser.add(projectManagerExcludeUserEmail);
                }
            }
        }

        //  일반 사용자에서 제외되었으면서 프로젝트 관리자로 들어간 경우
        List<String> excludeUserAndIncludeManager = Lists.newArrayList();

        for (String projectUserExcludeUserEmail : projectUserExcludeUsers) {
            for (String projectManagerIncludeUserEmail : projectManagerIncludeUsers) {
                if (projectUserExcludeUserEmail.equals(projectManagerIncludeUserEmail)) {
                    excludeUserAndIncludeManager.add(projectManagerIncludeUserEmail);
                }
            }
        }

        // 프로젝트 관리자에서 제외되었으면서 프로젝트 일반 사용자로 들어간 경우
        this.sendEmailProjectRoleChange(excludeManagerAndIncludeUser, EmailType.PROJECT_MANAGER_EXCLUDE_AND_PROJECT_DEFAULT_INCLUDE, projectMap);
        //  일반 사용자에서 제외되었으면서 프로젝트 관리자로 들어간 경우
        this.sendEmailProjectRoleChange(excludeUserAndIncludeManager, EmailType.PROJECT_DEFAULT_EXCLUDE_AND_PROJECT_MANAGER_INCLUDE, projectMap);
        //  관리자 제외 메일 최종
        this.sendEmailProjectRoleChange(this.checkDuplicationEmails(projectManagerExcludeUsers, excludeManagerAndIncludeUser, excludeUserAndIncludeManager), EmailType.PROJECT_MANAGER_EXCLUDE, projectMap);
        //  관리차 참여 메일 최종
        this.sendEmailProjectRoleChange(this.checkDuplicationEmails(projectManagerIncludeUsers, excludeManagerAndIncludeUser, excludeUserAndIncludeManager), EmailType.PROJECT_MANAGER_INCLUDE, projectMap);
        //  일반 사용자 제외 메일 최종
        this.sendEmailProjectRoleChange(this.checkDuplicationEmails(projectUserExcludeUsers, excludeManagerAndIncludeUser, excludeUserAndIncludeManager), EmailType.PROJECT_DEFAULT_EXCLUDE, projectMap);
        //  일반 사용자 참여 메일 최종
        this.sendEmailProjectRoleChange(this.checkDuplicationEmails(projectUserIncludeUsers, excludeManagerAndIncludeUser, excludeUserAndIncludeManager), EmailType.PROJECT_DEFAULT_INCLUDE, projectMap);
    }

    //  프로젝트 참여, 제외 통지 정보 체크
    private void notificationProjectRoleDepartment(Map<String, Object> changeProjectManagerNotifications, Map<String, Object> changeProjectDepartmentNotifications, Project project) {
        List<String> projectManagerExcludeUsers = (List<String>) changeProjectManagerNotifications.get("excludeUsers");  //  관리자 제외 사용자
        List<String> projectManagerIncludeUsers = (List<String>) changeProjectManagerNotifications.get("includeUsers");  //  관리자 참여 사용자
        List<String> projectDepartmentExcludeDepartments = (List<String>) changeProjectDepartmentNotifications.get("excludeDepartments");    //  제외된 담당 부서
        List<String> projectDepartmentIncludeDepartments = (List<String>) changeProjectDepartmentNotifications.get("includeDepartments");    //  참여된 담당 부서
        Map<String, Object> projectMap = new HashMap<>();
        projectMap.put("workspaceName", project.getWorkspace().getName());
        projectMap.put("projectName", project.getName());
        projectMap.put("registerDate", DateUtil.convertDateToStr(new Date()));

        Map<String, Object> projectRoleManagerMap = new HashMap<>();
        projectRoleManagerMap.put("id", project.getId());
        projectRoleManagerMap.put("statuses", Lists.newArrayList("02"));   //  관리자 조회

        //  관리자 정보 셋팅
        List<Map<String, Object>> projectRoleManagers = this.projectRoleUserService.findProjectRoleUser(projectRoleManagerMap);

        if (projectRoleManagers != null && !projectRoleManagers.isEmpty()) {
            for (Map<String, Object> projectRoleManager : projectRoleManagers) {
                UserVo userVo = ConvertUtil.convertMapToClass(projectRoleManager, UserVo.class);
                StringBuilder stringBuilder = new StringBuilder();
                stringBuilder.append(userVo.getName());
                stringBuilder.append("(");
                stringBuilder.append(CommonUtil.decryptAES128(userVo.getAccount()));
                stringBuilder.append(")");

                projectMap.put("projectManagerName", stringBuilder.toString());
            }
        }

        //  관리자 제외 메일
        this.sendEmailProjectRoleChange(projectManagerExcludeUsers, EmailType.PROJECT_MANAGER_EXCLUDE, projectMap);
        //  관리차 참여 메일
        this.sendEmailProjectRoleChange(projectManagerIncludeUsers, EmailType.PROJECT_MANAGER_INCLUDE, projectMap);
        //  담당 부서 제외 메일
        this.sendEmailProjectRoleChange(projectDepartmentExcludeDepartments, EmailType.PROJECT_DEFAULT_EXCLUDE, projectMap);
        //  담당 부서 참여 메일
        this.sendEmailProjectRoleChange(projectDepartmentIncludeDepartments, EmailType.PROJECT_DEFAULT_INCLUDE, projectMap);
    }

    //  중복으로 나가는 메일이 있는지 체크한다.
    private List<String> checkDuplicationEmails(List<String> checkEmails, List<String> excludeManagerAndIncludeUser, List<String> excludeUserAndIncludeManager) {
        List<String> sendProjectManagerExcludeUserEmails = Lists.newArrayList();

        for (String projectManagerExcludeUserEmail : checkEmails) {
            boolean sendEmail = true;
            //  관리자 제외 메일을 보내려는데 중복되는 메일이 나갈지 판단한다.
            for (String excludeManagerAndIncludeUserEmail : excludeManagerAndIncludeUser) {
                if (excludeManagerAndIncludeUserEmail.equals(projectManagerExcludeUserEmail)) {
                    sendEmail = false;
                    break;
                }
            }

            //  관리자 제외 메일을 보내려는데 중복되는 메일이 나갈지 판단한다.
            for (String excludeUserAndIncludeManagerEmail : excludeUserAndIncludeManager) {
                if (excludeUserAndIncludeManagerEmail.equals(projectManagerExcludeUserEmail)) {
                    sendEmail = false;
                    break;
                }
            }

            if (sendEmail) {
                sendProjectManagerExcludeUserEmails.add(projectManagerExcludeUserEmail);
            }
        }

        return sendProjectManagerExcludeUserEmails;
    }

    //  프로젝트 참여가 변경된 대상자에게 이메일을 보낸다.
    private void sendEmailProjectRoleChange(List<String> sendEmails, EmailType emailType, Map<String, Object> params) {
        String[] sendUsers = sendEmails.toArray(new String[sendEmails.size()]);

        if (sendUsers.length > 0) {
            //  마지막 접근 프로젝트에서 제외되었을 때 화면 새로고침을 한다.
            switch (emailType) {
                case PROJECT_DEFAULT_EXCLUDE:
                case PROJECT_MANAGER_EXCLUDE:
                    this.updateProjectExcludeUserLastWorkspaceId(sendUsers, params);
                    break;
            }

            this.systemEmailService.reservationEmail(sendUsers, emailType, params);
        }
    }

    //  접속중인 사용자중 제외당한 사용자가 해당 프로젝트를 보고있으면 경고창을 표시하고 화면을 새로고침해준다.
    private void updateProjectExcludeUserLastWorkspaceId(String[] sendUsers, Map<String, Object> params) {
       /* List<UserVo> activeLoginUserVos = this.webSocketSessionService.getActiveUserVos();
        Long projectId = MapUtil.getLong(params, "projectId");*/

        /*for (String email : sendUsers) {
            //  접속중이 아니어도 마지막 정보는 업데이트한다.
            User user = this.userService.findByAccount(email);

            if (user != null && projectId != null) {
                //  해당 사용자가 마지막으로 접근한 프로젝트가 제외당한 프로젝트라면 워크스페이스 정보를 초기화한다.
                if (projectId.equals(user.getLastProjectId())) {
                    //  자신의 마지막 접근 workspace & project 정보를 본인이 관리하는 워크스페이스의 기본 프로젝트로 초기화한다.
                    this.userService.initLastWorkspaceIdAndLastProjectId(user);

                    for (UserVo userVo : activeLoginUserVos) {
                        //  접속중인 사용자에게만 웹 소켓 업데이트 시작.
                        if (userVo.getAccount().equals(email)) {
                            this.simpMessagingTemplate.convertAndSendToUser(email, "/notification/project-exclude", this.messageAccessor.getMessage(MsgConstants.PROJECT_EXCLUDE), params);
                        }
                    }
                }
            }
        }*/
    }

    //  프로젝트 키로 프로젝트를 조회한다.
    @Override
    @Transactional(readOnly = true)
    public Project findByProjectKey(String projectKey) {
        return this.projectRepository.findByProjectKeyAndWorkspaceId(projectKey, this.userService.getUser(this.webAppUtil.getLoginId()).getLastWorkspaceId());
    }

    //  프로젝트 아이디로 프로젝트를 조회한다.
    @Override
    @Transactional(readOnly = true)
    public Project getProject(Long id) {
        if (id == null) {
            throw new OwlRuntimeException(
                    this.messageAccessor.getMessage(MsgConstants.PROJECT_NOT_EXIST));
        }

        Project project = this.findOne(id);

        if (project == null) {
            throw new OwlRuntimeException(
                    this.messageAccessor.getMessage(MsgConstants.PROJECT_NOT_EXIST));
        }

        return project;
    }

    //  프로젝트를 삭제한다.
    @Override
    @Transactional
    public void removeProjects(ProjectForm projectForm) {
        //  사용하고 있는 업무 공간이 활성 상태인지 확인한다. 사용 공간에서 로그인한 사용자가 비활성인지 확인한다.
        this.workspaceService.checkUseWorkspace();

        if (projectForm.getRemoveIds().size() < 1) {
            throw new OwlRuntimeException(
                    this.messageAccessor.getMessage(MsgConstants.PROJECT_REMOVE_NOT_SELECT));
        }

        for (Long projectId : projectForm.getRemoveIds()) {
            this.removeProjects(projectId);
        }

        this.projectRepository.flush();
    }

    private void removeProjects(Long projectId) {
        Project project = this.getProject(projectId);
        //  기본 프로젝트는 삭제 금지
        if (project.getDefaultYn()) {
            throw new OwlRuntimeException(
                    this.messageAccessor.getMessage(MsgConstants.DEFAULT_PROJECT_NOT_REMOVE));
        }

        //  로그인한 사용자가 관리자 역할에 소속되어 있는지 확인한다.
        this.checkModifyPermission(project.getId());

        List<String> sendEmails = Lists.newArrayList();
        Map<String, Object> params = new HashMap<>();
        params.put("projectId", projectId);

        //  해당 프로젝트에 참여하고 있는 사용자는 모두 프로젝트 제외 알림 메일을 해준다.
        for (ProjectRole projectRole : project.getProjectRoles()) {
            for (ProjectRoleUser projectRoleUser : projectRole.getProjectRoleUsers()) {
                sendEmails.add(projectRoleUser.getUser().getAccount());
            }
        }

        String[] sendUsers = sendEmails.toArray(new String[sendEmails.size()]);
        this.updateProjectExcludeUserLastWorkspaceId(sendUsers, params);

        //  프로젝트에 있는 모든 이슈 정보를 조회한다.
        List<Long> issueIds = this.issueService.findByProjectId(projectId);
        List<Long> projectRoleIds = Lists.newArrayList();
        for (ProjectRole projectRole : project.getProjectRoles()) {
            projectRoleIds.add(projectRole.getId());
        }

        params.put("issueIds", issueIds);
        params.put("projectRoleIds", projectRoleIds);

        //  프로젝트에 있는 모든 정보를 삭제한다.
        this.projectMapper.deleteProject(params);

        //  프로젝트 삭제시 이슈에 첨부된 파일을 시스템에서 삭제한다.
        this.attachedFileService.deleteIssueCascadeAttachedFile(issueIds, project.getWorkspace());
        this.projectRepository.flush();

        //  this.projectRepository.delete(project.getId());
    }

    //  워크스페이스에 있는 모든 프로젝트를 조회한다. 이슈 엑셀 import 에서 사용
    @Override
    @Transactional(readOnly = true)
    public List<Project> findByWorkspaceId() {
        return this.projectRepository.findByWorkspaceId(this.userService.getUser(this.webAppUtil.getLoginId()).getLastWorkspaceId());
    }

    //  현재 접근한 업무공간에서 참여하고 있는 프로젝트를 조회한다. - 대시보드, 이슈 목록에서 사용
    @Override
    @Transactional(readOnly = true)
    public List<Map<String, Object>> findByWorkspaceIdAndIncludeProject(List<String> statuses, String projectType) {
        ProjectCondition projectCondition = new ProjectCondition();
        projectCondition.setLoginUserId(this.webAppUtil.getLoginId());
        projectCondition.setWorkspaceId(this.userService.getUser(this.webAppUtil.getLoginId()).getLastWorkspaceId());
        projectCondition.setProjectType(projectType);
        projectCondition.setStatuses(statuses);

        return this.projectMapper.findByWorkspaceIdAndIncludeProject(projectCondition);
    }

    // 현재 접근한 업구공간에서 참여하고 있는 프로젝트를 조회한다(하위프로젝트 미포함)
    @Override
    public List<Map<String, Object>> findByWorkspaceIdAndIncludeProject(ProjectCondition projectCondition) {
        projectCondition.setLoginUserId(this.webAppUtil.getLoginId());
        projectCondition.setWorkspaceId(this.userService.getUser(this.webAppUtil.getLoginId()).getLastWorkspaceId());
        return this.projectMapper.findByWorkspaceIdAndIncludeProject(projectCondition);
    }

    @Override
    public List<Map<String, Object>> findByWorkspaceIdAndIncludeProjectAll(List<String> statuses, String projectType) {
        ProjectCondition projectCondition = new ProjectCondition();
        projectCondition.setLoginUserId(this.webAppUtil.getLoginId());
        projectCondition.setWorkspaceId(this.userService.getUser(this.webAppUtil.getLoginId()).getLastWorkspaceId());
        projectCondition.setProjectType(projectType);
        projectCondition.setStatuses(statuses);

        return this.projectMapper.findByWorkspaceIdAndIncludeProjectAll(projectCondition);
    }

    @Override
    public List<Map<String, Object>> findByWorkspaceManagerAll() {
        ProjectCondition projectCondition = new ProjectCondition();
        projectCondition.setWorkspaceId(this.userService.getUser(this.webAppUtil.getLoginId()).getLastWorkspaceId());
        return this.projectMapper.findByWorkspaceManagerAll(projectCondition);
    }

    // 현재 접근한 업구공간에서 참여하고 있는 프로젝트를 조회한다(하위프로젝트 포함)
    @Override
    public List<Map<String, Object>> findByWorkspaceIdAndIncludeProjectAll(ProjectCondition projectCondition) {
        projectCondition.setLoginUserId(this.webAppUtil.getLoginId());
        projectCondition.setWorkspaceId(this.userService.getUser(this.webAppUtil.getLoginId()).getLastWorkspaceId());
        return this.projectMapper.findByWorkspaceIdAndIncludeProjectAll(projectCondition);
    }

    //  현재 접근한 업무공간에서 참여하고 있는 프로젝트를 조회한다. - 상단 프로젝트 목록에서 사용
    @Override
    @Transactional(readOnly = true)
    public List<ProjectVo> findByIncludeProject(List<String> statuses, String projectType) {
        ProjectCondition projectCondition = new ProjectCondition();
        projectCondition.setLoginUserId(this.webAppUtil.getLoginId());
        projectCondition.setWorkspaceId(this.userService.getUser(this.webAppUtil.getLoginId()).getLastWorkspaceId());
        projectCondition.setProjectType(projectType);
        projectCondition.setStatuses(statuses);

        List<Map<String, Object>> results;

        if (this.userWorkspaceService.checkWorkspaceManager()) {
            results = this.projectMapper.findByWorkspaceManager(projectCondition);
        } else {
            results = this.projectMapper.findByWorkspaceIdAndIncludeProject(projectCondition);
        }
        List<ProjectVo> projectVos = this.makeProjectByVos(results);
        this.setChildrenProject(projectVos);

        return  projectVos;
    }

    //  프로젝트 목록을 엑셀로 다운로드 한다.
    @Override
    @Transactional
    public ModelAndView downloadExcel(HttpServletRequest request, Model model) {
        //  사용 공간에서 로그인한 사용자가 비활성인지 확인하고 비활성일 경우 엑셀 다운로드를 금지한다.
        ModelAndView modelAndView = this.workspaceService.checkUseExcelDownload(model);
        if (modelAndView != null) {
            return modelAndView;
        }

        Map<String, Object> conditions = new HashMap<>();
        //  엑셀 다운로드에 필요한 검색 조건 정보를 추출하고 검색 조건 추출에 오류가 발생하면 경고를 표시해준다.
        modelAndView = this.excelConditionCheck.checkCondition(conditions, request, model);
        if (modelAndView != null) {
            return modelAndView;
        }

        ProjectCondition projectCondition = ProjectCondition.make(conditions);
        projectCondition.setLoginUserId(this.webAppUtil.getLoginId());
        projectCondition.setWorkspaceId(this.userService.getUser(this.webAppUtil.getLoginId()).getLastWorkspaceId());
        List<Map<String, Object>> results = this.projectMapper.find(projectCondition);
        //  프로젝트 조회 결과를 ProjectVos 로 변환한다. - 관리자, 일반 사용자 정보 추가
        List<ProjectVo> projectVos = this.makeProjectVos(results);
        ExportExcelVo excelInfo = new ExportExcelVo();
        excelInfo.setFileName(this.messageAccessor.message("common.projectList")); // 프로젝트 목록
        excelInfo.addAttrInfos(new ExportExcelAttrVo("statusName", this.messageAccessor.message("common.status"), 6, ExportExcelAttrVo.ALIGN_CENTER)); // 상태
        excelInfo.addAttrInfos(new ExportExcelAttrVo("name", this.messageAccessor.message("common.project"), 40, ExportExcelAttrVo.ALIGN_LEFT)); // 프로젝트
        excelInfo.addAttrInfos(new ExportExcelAttrVo("manager", this.messageAccessor.message("common.admin"), 20, ExportExcelAttrVo.ALIGN_CENTER)); // 관리자
        excelInfo.addAttrInfos(new ExportExcelAttrVo("members", this.messageAccessor.message("common.teamMember"), 20, ExportExcelAttrVo.ALIGN_CENTER)); // 팀원
        excelInfo.addAttrInfos(new ExportExcelAttrVo("period", this.messageAccessor.message("common.period"), 20, ExportExcelAttrVo.ALIGN_CENTER)); // 기간
        excelInfo.addAttrInfos(new ExportExcelAttrVo("projectKey", this.messageAccessor.message("common.projectKey"), 6, ExportExcelAttrVo.ALIGN_CENTER)); // 프로젝트 키
        //  엑셀에 넣을 데이터 - ProjectVos 데이터를 엑셀에서 표시할 수 있는 데이터로 변경한다.
        excelInfo.setDatas(this.convertExcelViewToProjectVos(projectVos));

        model.addAttribute(Constants.EXCEL, excelInfo);
        return new ModelAndView(this.excelView);
    }

    //  ProjectVo 데이터를 엑셀에서 표시할 수 있는 데이터로 변경한다.
    private List<Map<String, String>> convertExcelViewToProjectVos(List<ProjectVo> projectVos) {
        List<Map<String, String>> results = Lists.newArrayList();

        for (ProjectVo projectVo : projectVos) {
            Map<String, String> result = new HashMap<>();

            String projectStatusName = "";

            switch (projectVo.getStatus()) {
                case Project.PROJECT_READY:
                    projectStatusName = this.messageAccessor.message("common.wait"); // 대기
                    break;
                case Project.PROJECT_OPEN:
                    projectStatusName = this.messageAccessor.message("common.progress"); // 진행
                    break;
                case Project.PROJECT_CLOSE:
                    projectStatusName = this.messageAccessor.message("common.end"); // 종료
                    break;
            }

            result.put("statusName", projectStatusName);
            result.put("name", projectVo.getName());

            StringBuilder stringBuilderManager = new StringBuilder();

            if (projectVo.getProjectManagerVos().size() > 0) {
                stringBuilderManager.append(projectVo.getProjectManagerVos().get(0).getName());
                stringBuilderManager.append("(");
                stringBuilderManager.append(projectVo.getProjectManagerVos().get(0).getAccount());
                stringBuilderManager.append(")");
            }

            result.put("manager", stringBuilderManager.toString());
            result.put("members", CommonUtil.convertUserVosToString(projectVo.getProjectUserVos()));
            result.put("projectKey", projectVo.getProjectKey());
            result.put("period", projectVo.getStartDate() + " - " + projectVo.getEndDate());
            results.add(result);
        }

        return results;
    }


    @Override
    @Transactional
    public void findLastUseProject(Map<String, Object> resJsonData) {
        UserVo loginUser = this.webAppUtil.getLoginUser();
        Project project = null;

        if (loginUser.getLastProjectId() != null) {
            project = this.projectRepository.getOne(loginUser.getLastProjectId());
        }

        if (project == null) {
            project = this.projectRepository.findByWorkspaceIdAndDefaultYn(loginUser.getLastWorkspaceId(), true);
        }

        if (project == null) {
            throw new OwlRuntimeException(
                    this.messageAccessor.getMessage(MsgConstants.PROJECT_NOT_EXIST));
        }

        resJsonData.put(Constants.RES_KEY_CONTENTS, ConvertUtil.copyProperties(project, ProjectVo.class));
    }

}