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.MngPermission;
|
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.repository.UserDepartmentRepository;
|
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.condition.WidgetCondition;
|
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 UserDepartmentRepository userDepartmentRepository;
|
|
@Autowired
|
private ProjectRoleService projectRoleService;
|
|
@Autowired
|
private WorkflowStatusService workflowStatusService;
|
|
@Autowired
|
private WorkspaceService workspaceService;
|
|
@Autowired
|
private UserWorkspaceService userWorkspaceService;
|
|
@Autowired
|
private UserLevelService userLevelService;
|
|
@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));
|
}
|
}
|
|
void SetMyDepartmentId(ProjectCondition projectCondition){
|
Long loginId = projectCondition.getLoginUserId();
|
List<Long> myDepartmentIds = Lists.newArrayList();
|
List<UserDepartment> myDepartments = this.userDepartmentRepository.findByUserId(loginId);
|
|
if(myDepartments != null && myDepartments.size() > 0){
|
for(UserDepartment myDepartment : myDepartments){
|
myDepartmentIds.add(myDepartment.getDepartmentId());
|
}
|
}
|
projectCondition.setMyDepartmentIds(myDepartmentIds);
|
}
|
|
// 프로젝트 목록을 조회한다.
|
@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;
|
|
User user = this.webAppUtil.getLoginUserObject();
|
|
if (condition.getWorkspaceManager()) {
|
// 업무공간 관리자일 경우 모든 프로젝트가 표시되어야 한다.
|
// 관리자일 때
|
UserLevel userLevel = this.userLevelService.getUserLevel(user.getUserLevel().getId());
|
if (this.userWorkspaceService.checkWorkspaceManager(user)
|
|| MngPermission.checkMngPermission(userLevel.getPermission(), MngPermission.USER_PERMISSION_MNG_PROJECT)) {
|
results = this.projectMapper.findByWorkspaceManager(condition);
|
totalCount = this.projectMapper.countByWorkspaceManager(condition);
|
}
|
else {
|
this.SetMyDepartmentId(condition);
|
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, user);
|
this.setChildrenProject(projectVos, user);
|
|
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, User user) {
|
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, user);
|
projectVo.setChildProjects(childrenVo);
|
setChildrenProject(childrenVo, user);
|
}
|
}
|
}
|
|
|
// 프로젝트 조회 결과를 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, User user) {
|
List<ProjectVo> projectVos = Lists.newArrayList();
|
UserLevel userLevel = this.userLevelService.getUserLevel(user.getUserLevel().getId());
|
|
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(user)
|
|| MngPermission.checkMngPermission(userLevel.getPermission(), MngPermission.USER_PERMISSION_MNG_PROJECT)) {
|
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);
|
|
User user = this.webAppUtil.getLoginUserObject();
|
|
// 워크스페이스에서 기본으로 제공되는 프로젝트에 대한 체크
|
this.checkDefaultProject(project, projectForm);
|
// 수정 권한 체크
|
this.checkModifyPermission(project.getId(), user);
|
// 관리자 변경
|
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, User user) {
|
Boolean hasPermission = Boolean.FALSE;
|
|
// 해당 업무 공간의 관리자일 경우 권한 체크를 하지 않는다.
|
if (this.userWorkspaceService.checkWorkspaceManager(user)) {
|
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);
|
UserLevel userLevel = this.userLevelService.getUserLevel(user.getUserLevel().getId());
|
// 현재 로그인 사용자가 관리자인지 확인
|
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())
|
|| MngPermission.checkMngPermission(userLevel.getPermission(), MngPermission.USER_PERMISSION_MNG_PROJECT)) {
|
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(), this.webAppUtil.getLoginUserObject());
|
|
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) {
|
User user = this.webAppUtil.getLoginUserObject();
|
UserLevel userLevel = this.userLevelService.getUserLevel(user.getUserLevel().getId());
|
|
ProjectCondition projectCondition = new ProjectCondition();
|
projectCondition.setLoginUserId(user.getId());
|
projectCondition.setWorkspaceId(user.getLastWorkspaceId());
|
projectCondition.setProjectType(projectType);
|
projectCondition.setStatuses(statuses);
|
|
List<Map<String, Object>> results;
|
|
if (this.userWorkspaceService.checkWorkspaceManager(user)
|
|| MngPermission.checkMngPermission(userLevel.getPermission(), MngPermission.USER_PERMISSION_MNG_PROJECT)) {
|
results = this.projectMapper.findByWorkspaceManager(projectCondition);
|
} else {
|
results = this.projectMapper.findByWorkspaceIdAndIncludeProject(projectCondition);
|
}
|
List<ProjectVo> projectVos = this.makeProjectByVos(results);
|
this.setChildrenProject(projectVos, user);
|
|
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());
|
|
User user = this.webAppUtil.getLoginUserObject();
|
List<Map<String, Object>> results;
|
UserLevel userLevel = this.userLevelService.getUserLevel(user.getUserLevel().getId());
|
|
if (this.userWorkspaceService.checkWorkspaceManager(user)
|
|| MngPermission.checkMngPermission(userLevel.getPermission(), MngPermission.USER_PERMISSION_MNG_PROJECT)) {
|
results = this.projectMapper.findByWorkspaceManager(projectCondition);
|
}
|
else {
|
this.SetMyDepartmentId(projectCondition);
|
results = this.projectMapper.find(projectCondition);
|
}
|
// 프로젝트 조회 결과를 ProjectVos 로 변환한다. - 관리자, 일반 사용자 정보 추가
|
List<ProjectVo> projectVos = this.makeProjectVos(results, this.webAppUtil.getLoginUserObject());
|
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("departments", this.messageAccessor.message("common.teamDepartment"), 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("departments", CommonUtil.convertDepartmentVosToString(projectVo.getProjectDepartmentVos()));
|
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));
|
}
|
|
}
|
