1544 lines
65 KiB
Java
1544 lines
65 KiB
Java
package com.pms.service;
|
|
|
|
import java.util.ArrayList;
|
|
import java.util.HashMap;
|
|
import java.util.List;
|
|
import java.util.Map;
|
|
|
|
import jakarta.servlet.http.HttpServletRequest;
|
|
import jakarta.servlet.http.HttpSession;
|
|
|
|
import org.springframework.stereotype.Service;
|
|
import org.springframework.transaction.annotation.Transactional;
|
|
import org.mybatis.spring.SqlSessionTemplate;
|
|
|
|
|
|
import com.pms.common.bean.PersonBean;
|
|
import com.pms.common.utils.CommonUtils;
|
|
import com.pms.common.utils.Constants;
|
|
import com.pms.common.utils.EncryptUtil;
|
|
import com.pms.common.Message;
|
|
import lombok.RequiredArgsConstructor;
|
|
import lombok.extern.slf4j.Slf4j;
|
|
|
|
@Slf4j
|
|
@Service
|
|
@RequiredArgsConstructor
|
|
public class AdminService {
|
|
|
|
private final SqlSessionTemplate sqlSessionTemplate;
|
|
|
|
/**
|
|
* 회사 데이터 테스트 조회
|
|
* @return
|
|
*/
|
|
public List<Map<String, Object>> getCompanyTest() {
|
|
try {
|
|
List<Map<String, Object>> result = sqlSessionTemplate.selectList("admin.selectCompanyTest");
|
|
log.info("회사 데이터 테스트 조회 결과: {}개", result.size());
|
|
if (!result.isEmpty()) {
|
|
log.info("첫 번째 회사 데이터: {}", result.get(0));
|
|
}
|
|
return result;
|
|
} catch (Exception e) {
|
|
log.error("회사 데이터 테스트 조회 오류", e);
|
|
return new ArrayList<>();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 관리자 메뉴 목록 조회
|
|
* @param request
|
|
* @param paramMap
|
|
* @return
|
|
*/
|
|
public List<Map<String, Object>> getAdminMenuList(HttpServletRequest request, Map<String, Object> paramMap) {
|
|
try {
|
|
paramMap.put("SYSTEM_NAME", Constants.SYSTEM_NAME);
|
|
|
|
// userLang 파라미터가 없으면 기본값 설정
|
|
if (!paramMap.containsKey("userLang") || paramMap.get("userLang") == null) {
|
|
paramMap.put("userLang", "ko"); // 기본값으로 한국어 설정
|
|
}
|
|
|
|
log.info("AdminService.getAdminMenuList - 파라미터: {}", paramMap);
|
|
|
|
List<Map<String, Object>> result = sqlSessionTemplate.selectList("admin.selectAdminMenuList", paramMap);
|
|
log.info("관리자 메뉴 목록 조회 결과: {}개", result.size());
|
|
if (!result.isEmpty()) {
|
|
Map<String, Object> firstMenu = result.get(0);
|
|
log.info("첫 번째 메뉴 데이터: {}", firstMenu);
|
|
log.info("첫 번째 메뉴의 번역 정보: LANG_KEY={}, LANG_KEY_DESC={}, TRANSLATED_NAME={}, TRANSLATED_DESC={}",
|
|
firstMenu.get("LANG_KEY"), firstMenu.get("LANG_KEY_DESC"),
|
|
firstMenu.get("TRANSLATED_NAME"), firstMenu.get("TRANSLATED_DESC"));
|
|
log.info("첫 번째 메뉴의 회사 정보: COMPANY_CODE={}, COMPANY_NAME={}",
|
|
firstMenu.get("COMPANY_CODE"), firstMenu.get("COMPANY_NAME"));
|
|
|
|
// 모든 메뉴의 번역 정보 로깅
|
|
for (int i = 0; i < Math.min(5, result.size()); i++) {
|
|
Map<String, Object> menu = result.get(i);
|
|
log.info("메뉴 {}: MENU_NAME_KOR={}, LANG_KEY={}, TRANSLATED_NAME={}",
|
|
i + 1, menu.get("MENU_NAME_KOR"), menu.get("LANG_KEY"), menu.get("TRANSLATED_NAME"));
|
|
}
|
|
}
|
|
return result;
|
|
} catch (Exception e) {
|
|
log.error("관리자 메뉴 목록 조회 오류", e);
|
|
return new ArrayList<>();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 사용자 메뉴 목록 조회
|
|
* @param request
|
|
* @param paramMap
|
|
* @return
|
|
*/
|
|
public List<Map<String, Object>> getUserMenuList(HttpServletRequest request, Map<String, Object> paramMap) {
|
|
try {
|
|
log.info("AdminService.getUserMenuList 시작 - 파라미터: {}", paramMap);
|
|
|
|
paramMap.put("SYSTEM_NAME", Constants.SYSTEM_NAME);
|
|
|
|
log.info("AdminService.getUserMenuList - SYSTEM_NAME 추가 후 파라미터: {}", paramMap);
|
|
|
|
// 메뉴관리에서는 모든 사용자 메뉴를 보여줘야 하므로 selectUserMenuList 사용
|
|
List<Map<String, Object>> result = sqlSessionTemplate.selectList("admin.selectUserMenuList", paramMap);
|
|
|
|
log.info("AdminService.getUserMenuList - 쿼리 결과 개수: {}", result.size());
|
|
if (!result.isEmpty()) {
|
|
log.info("AdminService.getUserMenuList - 첫 번째 결과: {}", result.get(0));
|
|
|
|
// 모든 메뉴의 회사 정보 로깅
|
|
for (int i = 0; i < Math.min(5, result.size()); i++) {
|
|
Map<String, Object> menu = result.get(i);
|
|
log.info("AdminService.getUserMenuList - 메뉴 {}: COMPANY_CODE={}, COMPANY_NAME={}",
|
|
i + 1, menu.get("COMPANY_CODE"), menu.get("COMPANY_NAME"));
|
|
}
|
|
}
|
|
return result;
|
|
} catch (Exception e) {
|
|
log.error("AdminService.getUserMenuList 오류", e);
|
|
return new ArrayList<>();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 사용자 View 메뉴 조회
|
|
* @param request
|
|
* @param paramMap
|
|
* @return
|
|
*/
|
|
public List<Map<String, Object>> getUserViewMenuList(HttpServletRequest request, Map<String, Object> paramMap) {
|
|
try {
|
|
paramMap.put("SYSTEM_NAME", Constants.SYSTEM_NAME);
|
|
return sqlSessionTemplate.selectList("admin.selectUserViewMenuList", paramMap);
|
|
} catch (Exception e) {
|
|
e.printStackTrace();
|
|
return new ArrayList<>();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 파라미터 기반 사용자 View 메뉴 조회
|
|
* @param request
|
|
* @param paramMap
|
|
* @return
|
|
*/
|
|
public List<Map<String, Object>> getParamUserViewMenuList(HttpServletRequest request, Map<String, Object> paramMap) {
|
|
try {
|
|
paramMap.put("SYSTEM_NAME", Constants.SYSTEM_NAME);
|
|
|
|
PersonBean person = (PersonBean)request.getSession().getAttribute(Constants.PERSON_BEAN);
|
|
String userId = CommonUtils.checkNull(person.getUserId());
|
|
paramMap.put("userId", userId);
|
|
|
|
return sqlSessionTemplate.selectList("admin.getParamUserViewMenuList", paramMap);
|
|
} catch (Exception e) {
|
|
e.printStackTrace();
|
|
return new ArrayList<>();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 메뉴 조회(상위 트리로 역전개)
|
|
* @param request
|
|
* @param paramMap
|
|
* @return
|
|
*/
|
|
public List<Map<String, Object>> getMenuUp(HttpServletRequest request, Map<String, Object> paramMap) {
|
|
try {
|
|
paramMap.put("SYSTEM_NAME", Constants.SYSTEM_NAME);
|
|
PersonBean person = (PersonBean)request.getSession().getAttribute(Constants.PERSON_BEAN);
|
|
String userId = CommonUtils.checkNull(person.getUserId());
|
|
paramMap.put("userId", userId);
|
|
return sqlSessionTemplate.selectList("admin.getmenuUp", paramMap);
|
|
} catch (Exception e) {
|
|
e.printStackTrace();
|
|
return new ArrayList<>();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 메뉴 등록
|
|
* @param request
|
|
* @param paramMap
|
|
* @return
|
|
*/
|
|
public Map<String, Object> insertMenu(HttpServletRequest request, Map<String, Object> paramMap) {
|
|
Map<String, Object> resultMap = new HashMap<>();
|
|
try {
|
|
// OBJID 생성 (현재 시간 기반으로 고유 ID 생성)
|
|
long currentTime = System.currentTimeMillis();
|
|
java.math.BigDecimal objid = new java.math.BigDecimal(currentTime);
|
|
|
|
// 프론트엔드에서 오는 키를 백엔드에서 기대하는 키로 변환
|
|
Map<String, Object> convertedParams = new HashMap<>();
|
|
convertedParams.put("OBJID", objid.toString());
|
|
convertedParams.put("SYSTEM_NAME", "PLM");
|
|
convertedParams.put("STATUS", paramMap.get("status") != null ? paramMap.get("status").toString().toLowerCase() : "active");
|
|
convertedParams.put("REGDATE", new java.util.Date());
|
|
|
|
// 메뉴 타입 변환 (문자열로 처리)
|
|
String menuType = (String) paramMap.get("menuType");
|
|
if ("0".equals(menuType) || "admin".equals(menuType)) {
|
|
convertedParams.put("MENU_TYPE", "0");
|
|
} else {
|
|
convertedParams.put("MENU_TYPE", "1");
|
|
}
|
|
|
|
// 필수 필드 검증 및 변환
|
|
if (paramMap.get("menuNameKor") == null || paramMap.get("menuNameKor").toString().trim().isEmpty()) {
|
|
throw new IllegalArgumentException("메뉴명은 필수입니다.");
|
|
}
|
|
|
|
convertedParams.put("MENU_NAME_KOR", paramMap.get("menuNameKor"));
|
|
convertedParams.put("MENU_NAME_ENG", paramMap.get("menuNameEng") != null ? paramMap.get("menuNameEng") : "");
|
|
convertedParams.put("MENU_URL", paramMap.get("menuUrl") != null ? paramMap.get("menuUrl") : "");
|
|
convertedParams.put("MENU_DESC", paramMap.get("menuDesc") != null ? paramMap.get("menuDesc") : "");
|
|
|
|
// 다국어 키 처리
|
|
Object langKeyObj = paramMap.get("langKey");
|
|
if (langKeyObj != null && !langKeyObj.toString().trim().isEmpty()) {
|
|
convertedParams.put("LANG_KEY", langKeyObj.toString().trim());
|
|
} else {
|
|
convertedParams.put("LANG_KEY", null);
|
|
}
|
|
|
|
// 회사 코드 처리 (빈 문자열이면 null로 설정, "none"이면 "*"로 설정)
|
|
Object companyCodeObj = paramMap.get("companyCode");
|
|
if (companyCodeObj == null || companyCodeObj.toString().trim().isEmpty()) {
|
|
convertedParams.put("COMPANY_CODE", null);
|
|
} else if ("none".equals(companyCodeObj.toString())) {
|
|
convertedParams.put("COMPANY_CODE", "*");
|
|
} else {
|
|
convertedParams.put("COMPANY_CODE", companyCodeObj.toString());
|
|
}
|
|
|
|
// SEQ 값 설정 (null이면 1로 기본값 설정)
|
|
Object seqValue = paramMap.get("seq");
|
|
if (seqValue == null) {
|
|
convertedParams.put("SEQ", "1");
|
|
} else {
|
|
try {
|
|
java.math.BigDecimal seq = new java.math.BigDecimal(seqValue.toString());
|
|
convertedParams.put("SEQ", seq.toString());
|
|
} catch (NumberFormatException e) {
|
|
convertedParams.put("SEQ", "1");
|
|
}
|
|
}
|
|
|
|
// PARENT_OBJ_ID 설정 (문자열로 변환)
|
|
Object parentObjIdValue = paramMap.get("parentObjId");
|
|
if (parentObjIdValue == null || parentObjIdValue.toString().trim().isEmpty()) {
|
|
convertedParams.put("PARENT_OBJ_ID", "0");
|
|
} else {
|
|
try {
|
|
java.math.BigDecimal parentObjId = new java.math.BigDecimal(parentObjIdValue.toString());
|
|
convertedParams.put("PARENT_OBJ_ID", parentObjId.toString());
|
|
} catch (NumberFormatException e) {
|
|
convertedParams.put("PARENT_OBJ_ID", "0");
|
|
}
|
|
}
|
|
convertedParams.put("WRITER", "admin"); // 기본 작성자
|
|
|
|
log.info("메뉴 등록 파라미터: {}", convertedParams);
|
|
|
|
// 메뉴 등록
|
|
int result = sqlSessionTemplate.insert("admin.insertMenu", convertedParams);
|
|
resultMap.put("success", result > 0);
|
|
resultMap.put("message", result > 0 ? "메뉴가 등록되었습니다." : "메뉴 등록에 실패했습니다.");
|
|
resultMap.put("objid", objid);
|
|
} catch (Exception e) {
|
|
log.error("메뉴 등록 중 오류 발생", e);
|
|
resultMap.put("success", false);
|
|
resultMap.put("message", "메뉴 등록 중 오류가 발생했습니다: " + e.getMessage());
|
|
}
|
|
return resultMap;
|
|
}
|
|
|
|
/**
|
|
* 메뉴 정보 조회
|
|
* @param request
|
|
* @param paramMap
|
|
* @return
|
|
*/
|
|
public Map<String, Object> getMenuInfo(HttpServletRequest request, Map<String, Object> paramMap) {
|
|
try {
|
|
log.info("getMenuInfo 호출 - 파라미터: {}", paramMap);
|
|
Map<String, Object> result = sqlSessionTemplate.selectOne("admin.selectMenuInfo", paramMap);
|
|
log.info("getMenuInfo 결과: {}", result);
|
|
return result;
|
|
} catch (Exception e) {
|
|
log.error("getMenuInfo 오류", e);
|
|
return new HashMap<>();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 메뉴 활성/비활성 토글
|
|
* @param menuId
|
|
* @return
|
|
*/
|
|
@Transactional
|
|
public String toggleMenuStatus(String menuId) {
|
|
try {
|
|
log.info("메뉴 상태 토글 시작: menuId = {}", menuId);
|
|
|
|
// 현재 상태 조회
|
|
Map<String, Object> params = new HashMap<>();
|
|
// OBJID를 문자열로 변환
|
|
try {
|
|
java.math.BigDecimal objid = new java.math.BigDecimal(menuId);
|
|
params.put("OBJID", objid.toString());
|
|
} catch (NumberFormatException e) {
|
|
throw new IllegalArgumentException("메뉴 ID는 숫자여야 합니다.");
|
|
}
|
|
Map<String, Object> currentMenu = sqlSessionTemplate.selectOne("admin.selectMenuInfo", params);
|
|
|
|
if (currentMenu == null) {
|
|
throw new RuntimeException("메뉴를 찾을 수 없습니다: " + menuId);
|
|
}
|
|
|
|
String currentStatus = (String) currentMenu.get("STATUS");
|
|
String newStatus = "active".equals(currentStatus) ? "inactive" : "active";
|
|
|
|
// 상태 업데이트
|
|
params.put("status", newStatus);
|
|
// objid를 문자열로 변환
|
|
try {
|
|
java.math.BigDecimal objid = new java.math.BigDecimal(menuId);
|
|
params.put("objid", objid.toString());
|
|
} catch (NumberFormatException e) {
|
|
throw new IllegalArgumentException("메뉴 ID는 숫자여야 합니다.");
|
|
}
|
|
sqlSessionTemplate.update("admin.updateMenuStatus", params);
|
|
|
|
String result = "active".equals(newStatus) ? "활성화" : "비활성화";
|
|
log.info("메뉴 상태 토글 완료: menuId = {}, 상태 = {}", menuId, result);
|
|
return result;
|
|
} catch (Exception e) {
|
|
log.error("메뉴 상태 토글 중 오류 발생", e);
|
|
throw e;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
* 메뉴 수정
|
|
* @param request
|
|
* @param paramMap
|
|
* @return
|
|
*/
|
|
public Map<String, Object> updateMenu(HttpServletRequest request, Map<String, Object> paramMap) {
|
|
log.info("updateMenu 호출 - 원본 파라미터: {}", paramMap);
|
|
Map<String, Object> resultMap = new HashMap<>();
|
|
try {
|
|
// 프론트엔드에서 오는 키를 백엔드에서 기대하는 키로 변환
|
|
Map<String, Object> convertedParams = new HashMap<>();
|
|
|
|
// OBJID는 수정 시 필수
|
|
Object objidObj = paramMap.get("objid");
|
|
log.info("objid 원본 값: {} (타입: {})", objidObj, objidObj != null ? objidObj.getClass().getSimpleName() : "null");
|
|
|
|
if (objidObj == null) {
|
|
throw new IllegalArgumentException("메뉴 ID는 필수입니다.");
|
|
}
|
|
// OBJID를 문자열로 변환 (PostgreSQL ::numeric 캐스팅용)
|
|
try {
|
|
java.math.BigDecimal objid = new java.math.BigDecimal(objidObj.toString());
|
|
convertedParams.put("OBJID", objid.toString());
|
|
log.info("objid 변환 완료: {}", objid);
|
|
} catch (NumberFormatException e) {
|
|
log.error("objid 숫자 변환 실패: {}", objidObj, e);
|
|
throw new IllegalArgumentException("메뉴 ID는 숫자여야 합니다.");
|
|
}
|
|
|
|
// 필수 필드 검증 및 변환
|
|
if (paramMap.get("menuNameKor") == null || paramMap.get("menuNameKor").toString().trim().isEmpty()) {
|
|
throw new IllegalArgumentException("메뉴명은 필수입니다.");
|
|
}
|
|
|
|
convertedParams.put("MENU_NAME_KOR", paramMap.get("menuNameKor"));
|
|
convertedParams.put("MENU_NAME_ENG", paramMap.get("menuNameEng") != null ? paramMap.get("menuNameEng") : "");
|
|
convertedParams.put("MENU_URL", paramMap.get("menuUrl") != null ? paramMap.get("menuUrl") : "");
|
|
convertedParams.put("MENU_DESC", paramMap.get("menuDesc") != null ? paramMap.get("menuDesc") : "");
|
|
|
|
// 다국어 키 처리
|
|
Object langKeyObj = paramMap.get("langKey");
|
|
if (langKeyObj != null && !langKeyObj.toString().trim().isEmpty()) {
|
|
convertedParams.put("LANG_KEY", langKeyObj.toString().trim());
|
|
} else {
|
|
convertedParams.put("LANG_KEY", null);
|
|
}
|
|
|
|
// 회사 코드 처리 (빈 문자열이면 null로 설정, "none"이면 "*"로 설정)
|
|
Object companyCodeObj = paramMap.get("companyCode");
|
|
if (companyCodeObj == null || companyCodeObj.toString().trim().isEmpty()) {
|
|
convertedParams.put("COMPANY_CODE", null);
|
|
} else if ("none".equals(companyCodeObj.toString())) {
|
|
convertedParams.put("COMPANY_CODE", "*");
|
|
} else {
|
|
convertedParams.put("COMPANY_CODE", companyCodeObj.toString());
|
|
}
|
|
|
|
// PARENT_OBJ_ID 설정 (문자열로 변환)
|
|
Object parentObjIdValue = paramMap.get("parentObjId");
|
|
if (parentObjIdValue == null || parentObjIdValue.toString().trim().isEmpty()) {
|
|
convertedParams.put("PARENT_OBJ_ID", "0");
|
|
} else {
|
|
try {
|
|
java.math.BigDecimal parentObjId = new java.math.BigDecimal(parentObjIdValue.toString());
|
|
convertedParams.put("PARENT_OBJ_ID", parentObjId.toString());
|
|
} catch (NumberFormatException e) {
|
|
convertedParams.put("PARENT_OBJ_ID", "0");
|
|
}
|
|
}
|
|
|
|
// SEQ 값 설정 (null이면 1로 기본값 설정)
|
|
Object seqValue = paramMap.get("seq");
|
|
if (seqValue == null) {
|
|
convertedParams.put("SEQ", "1");
|
|
} else {
|
|
try {
|
|
java.math.BigDecimal seq = new java.math.BigDecimal(seqValue.toString());
|
|
convertedParams.put("SEQ", seq.toString());
|
|
} catch (NumberFormatException e) {
|
|
convertedParams.put("SEQ", "1");
|
|
}
|
|
}
|
|
|
|
// STATUS 값 정규화 (inActive -> inactive, active -> active)
|
|
String statusValue = paramMap.get("status") != null ? paramMap.get("status").toString().toLowerCase() : "active";
|
|
if ("inactive".equals(statusValue) || "inactive".equals(statusValue)) {
|
|
statusValue = "inactive";
|
|
} else {
|
|
statusValue = "active";
|
|
}
|
|
convertedParams.put("STATUS", statusValue);
|
|
|
|
log.info("메뉴 수정 파라미터: {}", convertedParams);
|
|
|
|
int result = sqlSessionTemplate.update("admin.updateMenu", convertedParams);
|
|
resultMap.put("success", result > 0);
|
|
resultMap.put("message", result > 0 ? "메뉴가 수정되었습니다." : "메뉴 수정에 실패했습니다.");
|
|
} catch (Exception e) {
|
|
log.error("메뉴 수정 중 오류 발생", e);
|
|
resultMap.put("success", false);
|
|
resultMap.put("message", "메뉴 수정 중 오류가 발생했습니다: " + e.getMessage());
|
|
}
|
|
return resultMap;
|
|
}
|
|
|
|
/**
|
|
* 메뉴 삭제 (계층 구조 고려)
|
|
* @param request
|
|
* @param paramMap
|
|
* @return
|
|
*/
|
|
public Map<String, Object> deleteMenu(HttpServletRequest request, Map<String, Object> paramMap) {
|
|
Map<String, Object> resultMap = new HashMap<>();
|
|
try {
|
|
// OBJID 파라미터 변환
|
|
Map<String, Object> convertedParams = new HashMap<>();
|
|
// OBJID를 문자열로 변환
|
|
try {
|
|
java.math.BigDecimal objid = new java.math.BigDecimal(paramMap.get("objid").toString());
|
|
convertedParams.put("OBJID", objid.toString());
|
|
} catch (NumberFormatException e) {
|
|
throw new IllegalArgumentException("메뉴 ID는 숫자여야 합니다.");
|
|
}
|
|
|
|
log.info("메뉴 삭제 파라미터: {}", convertedParams);
|
|
|
|
// 계층 구조를 고려한 삭제 (메뉴와 하위 메뉴들 모두 삭제)
|
|
int result = sqlSessionTemplate.delete("admin.deleteMenuWithChildren", convertedParams);
|
|
resultMap.put("success", result > 0);
|
|
resultMap.put("message", result > 0 ? "메뉴와 하위 메뉴들이 삭제되었습니다." : "메뉴 삭제에 실패했습니다.");
|
|
resultMap.put("deletedCount", result);
|
|
} catch (Exception e) {
|
|
log.error("메뉴 삭제 중 오류 발생", e);
|
|
resultMap.put("success", false);
|
|
resultMap.put("message", "메뉴 삭제 중 오류가 발생했습니다: " + e.getMessage());
|
|
}
|
|
return resultMap;
|
|
}
|
|
|
|
/**
|
|
* 메뉴 일괄 삭제
|
|
* @param request
|
|
* @param menuIds
|
|
* @return
|
|
*/
|
|
@Transactional
|
|
public Map<String, Object> deleteMenusBatch(HttpServletRequest request, List<String> menuIds) {
|
|
Map<String, Object> resultMap = new HashMap<>();
|
|
int deletedCount = 0;
|
|
int failedCount = 0;
|
|
List<String> failedMenuIds = new ArrayList<>();
|
|
|
|
try {
|
|
log.info("메뉴 일괄 삭제 시작: {}개의 메뉴", menuIds.size());
|
|
|
|
for (String menuId : menuIds) {
|
|
try {
|
|
// OBJID 파라미터 변환
|
|
Map<String, Object> convertedParams = new HashMap<>();
|
|
try {
|
|
java.math.BigDecimal objid = new java.math.BigDecimal(menuId);
|
|
convertedParams.put("OBJID", objid.toString());
|
|
} catch (NumberFormatException e) {
|
|
log.warn("잘못된 메뉴 ID 형식: {}", menuId);
|
|
failedCount++;
|
|
failedMenuIds.add(menuId);
|
|
continue;
|
|
}
|
|
|
|
log.info("메뉴 삭제 시도: {}", menuId);
|
|
|
|
// 계층 구조를 고려한 삭제 (메뉴와 하위 메뉴들 모두 삭제)
|
|
int result = sqlSessionTemplate.delete("admin.deleteMenuWithChildren", convertedParams);
|
|
if (result > 0) {
|
|
deletedCount++;
|
|
log.info("메뉴 및 하위 메뉴 삭제 성공: {} (총 {}개 삭제)", menuId, result);
|
|
} else {
|
|
failedCount++;
|
|
failedMenuIds.add(menuId);
|
|
log.warn("메뉴 삭제 실패 (존재하지 않음): {}", menuId);
|
|
}
|
|
|
|
} catch (Exception e) {
|
|
failedCount++;
|
|
failedMenuIds.add(menuId);
|
|
log.error("메뉴 삭제 중 오류 발생: menuId = {}, error = {}", menuId, e.getMessage());
|
|
}
|
|
}
|
|
|
|
// 결과 설정 - 하나라도 성공하면 success로 처리
|
|
boolean hasSuccess = deletedCount > 0;
|
|
resultMap.put("success", hasSuccess);
|
|
resultMap.put("deletedCount", deletedCount);
|
|
resultMap.put("failedCount", failedCount);
|
|
resultMap.put("failedMenuIds", failedMenuIds);
|
|
|
|
if (failedCount == 0) {
|
|
resultMap.put("message", String.format("%d개의 메뉴가 성공적으로 삭제되었습니다.", deletedCount));
|
|
} else if (deletedCount > 0) {
|
|
resultMap.put("message", String.format("%d개 삭제 성공, %d개 삭제 실패", deletedCount, failedCount));
|
|
} else {
|
|
resultMap.put("message", "모든 메뉴 삭제에 실패했습니다.");
|
|
}
|
|
|
|
log.info("메뉴 일괄 삭제 완료: 성공 {}개, 실패 {}개", deletedCount, failedCount);
|
|
|
|
} catch (Exception e) {
|
|
log.error("메뉴 일괄 삭제 중 전체 오류 발생", e);
|
|
resultMap.put("success", false);
|
|
resultMap.put("message", "메뉴 일괄 삭제 중 오류가 발생했습니다: " + e.getMessage());
|
|
resultMap.put("deletedCount", deletedCount);
|
|
resultMap.put("failedCount", failedCount);
|
|
resultMap.put("failedMenuIds", failedMenuIds);
|
|
}
|
|
|
|
return resultMap;
|
|
}
|
|
|
|
/**
|
|
* 메뉴 권한 그룹 목록 조회
|
|
* @param request
|
|
* @param paramMap
|
|
* @return
|
|
*/
|
|
public List<Map<String, Object>> getMenuAuthGroupList(HttpServletRequest request, Map<String, Object> paramMap) {
|
|
try {
|
|
return sqlSessionTemplate.selectList("admin.selectMenuAuthGroupList", paramMap);
|
|
} catch (Exception e) {
|
|
e.printStackTrace();
|
|
return new ArrayList<>();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 사용자 메뉴 권한 체크
|
|
* @param request
|
|
* @param paramMap
|
|
* @return
|
|
*/
|
|
public Map<String, Object> checkUserMenuAuth(HttpServletRequest request, Map<String, Object> paramMap) {
|
|
try {
|
|
HttpSession session = request.getSession();
|
|
PersonBean person = (PersonBean)session.getAttribute(Constants.PERSON_BEAN);
|
|
String accessUser = CommonUtils.checkNull(person.getUserId());
|
|
|
|
paramMap.put("USER_ID", accessUser);
|
|
return sqlSessionTemplate.selectOne("admin.checkUserMenuAuth", paramMap);
|
|
} catch (Exception e) {
|
|
e.printStackTrace();
|
|
return null;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 권한 관리 목록 조회
|
|
* @param request
|
|
* @param paramMap
|
|
* @return
|
|
*/
|
|
public List<Map<String, Object>> getAuthMngList(HttpServletRequest request, Map<String, Object> paramMap) {
|
|
try {
|
|
return sqlSessionTemplate.selectList("admin.selectAuthMngList", paramMap);
|
|
} catch (Exception e) {
|
|
e.printStackTrace();
|
|
return new ArrayList<>();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 권한 그룹 정보 조회
|
|
* @param request
|
|
* @param paramMap
|
|
* @return
|
|
*/
|
|
public Map<String, Object> getAuthGroupInfo(HttpServletRequest request, Map<String, Object> paramMap) {
|
|
try {
|
|
return sqlSessionTemplate.selectOne("admin.selectAuthGroupInfo", paramMap);
|
|
} catch (Exception e) {
|
|
e.printStackTrace();
|
|
return null;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 권한 그룹 멤버 목록 조회
|
|
* @param request
|
|
* @param paramMap
|
|
* @return
|
|
*/
|
|
public List<Map<String, Object>> getAuthGroupMemberList(HttpServletRequest request, Map<String, Object> paramMap) {
|
|
try {
|
|
return sqlSessionTemplate.selectList("admin.selectAuthGroupMemberList", paramMap);
|
|
} catch (Exception e) {
|
|
e.printStackTrace();
|
|
return new ArrayList<>();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 메뉴 권한 목록 조회
|
|
* @param request
|
|
* @param paramMap
|
|
* @return
|
|
*/
|
|
public List<Map<String, Object>> getMenuAuthList(HttpServletRequest request, Map<String, Object> paramMap) {
|
|
try {
|
|
return sqlSessionTemplate.selectList("admin.selectMenuAuthList", paramMap);
|
|
} catch (Exception e) {
|
|
e.printStackTrace();
|
|
return new ArrayList<>();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 사용자 정보 조회
|
|
* @param request
|
|
* @param paramMap
|
|
* @return
|
|
*/
|
|
public Map<String, Object> getUserInfo(HttpServletRequest request, Map<String, Object> paramMap) {
|
|
try {
|
|
return sqlSessionTemplate.selectOne("admin.selectUserInfo", paramMap);
|
|
} catch (Exception e) {
|
|
e.printStackTrace();
|
|
return null;
|
|
}
|
|
}
|
|
/**
|
|
* 사용자 정보 저장 (기존 시스템 호환)
|
|
* @param request
|
|
* @param paramMap
|
|
* @return
|
|
*/
|
|
@SuppressWarnings({"rawtypes", "unchecked"})
|
|
public Map saveEtcUserInfo(HttpServletRequest request, Map paramMap) {
|
|
Map resultMap = new HashMap();
|
|
|
|
try {
|
|
HttpSession session = request.getSession();
|
|
PersonBean person = (PersonBean) session.getAttribute(Constants.PERSON_BEAN);
|
|
String writer = CommonUtils.checkNull(person.getUserId());
|
|
String userId = CommonUtils.checkNull(paramMap.get("userId"));
|
|
|
|
// 현재 로그인한 사용자 ID와 저장하려는 사용자 ID가 같은지 확인 (프로필 수정인지 판단)
|
|
boolean isProfileUpdate = userId.equals(writer);
|
|
|
|
int cnt = 0;
|
|
|
|
if (isProfileUpdate) {
|
|
// 프로필 수정의 경우 - 기존 사용자 정보 업데이트
|
|
log.info("프로필 수정 요청 - 사용자 ID: {}", userId);
|
|
|
|
// 패스워드가 포함된 경우에만 암호화
|
|
String password = CommonUtils.checkNull(paramMap.get("password"));
|
|
if (password != null && !password.isEmpty()) {
|
|
password = new EncryptUtil().encrypt(password);
|
|
paramMap.put("password", password);
|
|
}
|
|
|
|
// 사용자 정보 업데이트
|
|
cnt = sqlSessionTemplate.update("admin.saveEtcUserInfo", paramMap);
|
|
|
|
// 히스토리 저장을 위한 파라미터 설정
|
|
paramMap.put("history_type", "사용자 정보 수정");
|
|
|
|
} else {
|
|
// 신규 사용자 등록의 경우 - 중복 검사 후 생성
|
|
log.info("신규 사용자 등록 요청 - 사용자 ID: {}", userId);
|
|
|
|
// 해당 ID가 이미 존재하는지 체크
|
|
Map<String, Object> duplicateCheckMap = new HashMap<>();
|
|
duplicateCheckMap.put("userId", userId);
|
|
|
|
Map<String, Object> duplicateResult = sqlSessionTemplate.selectOne("admin.checkDuplicateEtcUserId", duplicateCheckMap);
|
|
if (duplicateResult != null) {
|
|
Object cntObj = duplicateResult.get("cnt");
|
|
if (cntObj == null) {
|
|
cntObj = duplicateResult.get("CNT");
|
|
}
|
|
int existingCnt = Integer.parseInt(CommonUtils.checkNull(cntObj, "0"));
|
|
|
|
if (existingCnt > 0) {
|
|
log.warn("사용자 생성 거부 - 이미 존재하는 ID: {}", userId);
|
|
resultMap.put("result", false);
|
|
resultMap.put("msg", "이미 존재하는 사용자 ID입니다. 다른 ID를 사용해주세요.");
|
|
return resultMap;
|
|
}
|
|
}
|
|
|
|
// 패스워드 암호화 (신규 등록시 필수)
|
|
String password = CommonUtils.checkNull(paramMap.get("password"));
|
|
if (password != null && !password.isEmpty()) {
|
|
password = new EncryptUtil().encrypt(password);
|
|
paramMap.put("password", password);
|
|
}
|
|
|
|
// 신규 사용자 정보 생성
|
|
cnt = sqlSessionTemplate.insert("admin.insertEtcUserInfo", paramMap);
|
|
|
|
// 히스토리 저장을 위한 파라미터 설정
|
|
paramMap.put("history_type", "사용자 정보 생성");
|
|
}
|
|
|
|
paramMap.put("writer", writer);
|
|
|
|
// 사용자 정보 변경 히스토리 저장
|
|
sqlSessionTemplate.update("admin.InsertUserInfoHistory", paramMap);
|
|
|
|
if (cnt > 0) {
|
|
// 저장 성공 시 프로필 수정인 경우 세션의 사용자 정보도 업데이트
|
|
if (isProfileUpdate) {
|
|
updateSessionUserInfo(request, paramMap);
|
|
}
|
|
|
|
resultMap.put("result", true);
|
|
resultMap.put("msg", Message.SAVE_SUCCESS);
|
|
} else {
|
|
resultMap.put("result", false);
|
|
resultMap.put("msg", Message.SAVE_FAILED);
|
|
}
|
|
|
|
} catch (Exception e) {
|
|
resultMap.put("result", false);
|
|
if (e.getMessage() != null && (e.getMessage().contains("duplicate key") || e.getMessage().contains("중복"))) {
|
|
resultMap.put("msg", "이미 존재하는 사용자 ID입니다.");
|
|
log.warn("사용자 처리 실패 - 중복 ID: {}", paramMap.get("userId"));
|
|
} else {
|
|
resultMap.put("msg", Message.SYSTEM_ERROR);
|
|
}
|
|
log.error("saveEtcUserInfo 처리 중 오류 발생: " + e.getMessage(), e);
|
|
}
|
|
|
|
return resultMap;
|
|
}
|
|
|
|
// ========== 사용자 관리 CRUD 메서드들 시작 ==========
|
|
|
|
/**
|
|
* 기타사용자목록 조회 (페이징 포함)
|
|
* @param request
|
|
* @param paramMap
|
|
* @return
|
|
*/
|
|
public List<Map<String, Object>> getEtcUserList(HttpServletRequest request, Map<String, Object> paramMap) {
|
|
try {
|
|
// 페이징 처리를 위한 기본 파라미터 설정
|
|
String page = CommonUtils.checkNull(String.valueOf(paramMap.get("page")), "1");
|
|
String countPerPage = CommonUtils.checkNull(String.valueOf(paramMap.get("countPerPage")), String.valueOf(Constants.ADMIN_COUNT_PER_PAGE));
|
|
|
|
paramMap.put("COUNT_PER_PAGE", Integer.parseInt(countPerPage));
|
|
paramMap.put("page", page);
|
|
|
|
// 총 개수 조회 (원본 패턴 따라서)
|
|
Map<String, Object> pageMap = sqlSessionTemplate.selectOne("admin.getEtcUserListCnt", paramMap);
|
|
if (pageMap == null) {
|
|
pageMap = new HashMap<>();
|
|
pageMap.put("TOTAL_CNT", 0);
|
|
}
|
|
|
|
// 원본처럼 파라미터 병합 후 페이징 정보 계산
|
|
pageMap.putAll(paramMap);
|
|
@SuppressWarnings("unchecked")
|
|
Map<String, Object> paging = (Map<String, Object>) CommonUtils.setPagingInfo(request, pageMap);
|
|
pageMap = paging;
|
|
|
|
paramMap.put("PAGE_START", CommonUtils.checkNull(pageMap.get("PAGE_START")));
|
|
paramMap.put("PAGE_END", CommonUtils.checkNull(pageMap.get("PAGE_END")));
|
|
|
|
// 사용자 목록 조회
|
|
List<Map<String, Object>> resultList = sqlSessionTemplate.selectList("admin.getEtcUserList", paramMap);
|
|
|
|
// 소문자 키로 프론트엔드 친화적으로 반환
|
|
return resultList != null ? resultList : new ArrayList<>();
|
|
|
|
} catch (Exception e) {
|
|
log.error("사용자 목록 조회 중 오류 발생", e);
|
|
return new ArrayList<>();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 기타사용자 상세 조회
|
|
* @param paramMap
|
|
* @return
|
|
*/
|
|
public Map<String, Object> getEtcUserInfo(Map<String, Object> paramMap) {
|
|
try {
|
|
Map<String, Object> userInfo = sqlSessionTemplate.selectOne("admin.getEtcUserInfo", paramMap);
|
|
return userInfo != null ? userInfo : new HashMap<>();
|
|
} catch (Exception e) {
|
|
log.error("사용자 상세 조회 중 오류 발생", e);
|
|
return new HashMap<>();
|
|
}
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
* 기타사용자ID 중복 체크 (Spring Boot + MyBatis 방식)
|
|
* @param paramMap
|
|
* @return
|
|
*/
|
|
public Map<String, Object> checkDuplicateEtcUserId(Map<String, Object> paramMap) {
|
|
Map<String, Object> resultMap = new HashMap<>();
|
|
|
|
try {
|
|
// Spring Boot 환경에서는 SqlSessionTemplate 사용 (자동 세션 관리)
|
|
Map<String, Object> queryResult = sqlSessionTemplate.selectOne("admin.checkDuplicateEtcUserId", paramMap);
|
|
|
|
if (queryResult != null) {
|
|
// PostgreSQL은 대문자로 컬럼명을 반환하므로 CNT와 cnt 둘 다 확인
|
|
Object cntObj = queryResult.get("cnt");
|
|
if (cntObj == null) {
|
|
cntObj = queryResult.get("CNT");
|
|
}
|
|
|
|
int cnt = Integer.parseInt(CommonUtils.checkNull(cntObj, "0"));
|
|
|
|
if (cnt > 0) {
|
|
resultMap.put("result", false);
|
|
resultMap.put("msg", "이미 등록된 ID입니다.");
|
|
} else {
|
|
resultMap.put("result", true);
|
|
resultMap.put("msg", "사용 가능한 ID입니다.");
|
|
}
|
|
} else {
|
|
// 쿼리 결과가 null인 경우 (사용 가능)
|
|
resultMap.put("result", true);
|
|
resultMap.put("msg", "사용 가능한 ID입니다.");
|
|
}
|
|
} catch (Exception e) {
|
|
resultMap.put("result", false);
|
|
resultMap.put("msg", "시스템 오류가 발생했습니다."); // Message.SYSTEM_ERROR
|
|
log.error("사용자 ID 중복 체크 중 오류 발생", e);
|
|
}
|
|
|
|
return resultMap;
|
|
}
|
|
|
|
/**
|
|
* 부서 목록 조회
|
|
* @param request
|
|
* @param paramMap
|
|
* @return
|
|
*/
|
|
public List<Map<String, Object>> getDepartmentList(HttpServletRequest request, Map<String, Object> paramMap) {
|
|
try {
|
|
// admin.xml에 새로 추가한 부서 조회 쿼리 사용
|
|
List<Map<String, Object>> departmentList = sqlSessionTemplate.selectList("admin.getDepartmentList", paramMap);
|
|
return departmentList != null ? departmentList : new ArrayList<>();
|
|
} catch (Exception e) {
|
|
log.error("부서 목록 조회 중 오류 발생", e);
|
|
return new ArrayList<>();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 사용자 상태 변경
|
|
* @param paramMap
|
|
* @return
|
|
*/
|
|
public Map<String, Object> changeUserStatus(Map<String, Object> paramMap) {
|
|
Map<String, Object> resultMap = new HashMap<>();
|
|
|
|
try {
|
|
int cnt = sqlSessionTemplate.update("admin.changeUserStatus", paramMap);
|
|
// sqlSessionTemplate.insert("admin.saveUserHistoryInfo", paramMap);
|
|
|
|
if (cnt > 0) {
|
|
resultMap.put("result", true);
|
|
resultMap.put("msg", "상태가 변경되었습니다.");
|
|
} else {
|
|
resultMap.put("result", false);
|
|
resultMap.put("msg", "상태 변경에 실패했습니다.");
|
|
}
|
|
|
|
} catch (Exception e) {
|
|
log.error("사용자 상태 변경 중 오류 발생", e);
|
|
resultMap.put("result", false);
|
|
resultMap.put("msg", "시스템 오류가 발생했습니다: " + e.getMessage());
|
|
}
|
|
|
|
return resultMap;
|
|
}
|
|
|
|
/**
|
|
* 사용자 목록 총 개수 조회
|
|
* @param paramMap 검색 조건
|
|
* @return 총 개수
|
|
*/
|
|
public int getEtcUserListCnt(Map<String, Object> paramMap) {
|
|
try {
|
|
log.info("사용자 총 개수 조회 시작 - 파라미터: {}", paramMap);
|
|
|
|
// 단순 카운트 쿼리 사용
|
|
Integer count = sqlSessionTemplate.selectOne("admin.getEtcUserListCount", paramMap);
|
|
|
|
log.info("사용자 총 개수 조회 결과: {}", count);
|
|
|
|
return count != null ? count : 0;
|
|
} catch (Exception e) {
|
|
log.error("사용자 목록 총 개수 조회 중 오류 발생", e);
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
// ========== 사용자 관리 CRUD 메서드들 끝 ==========
|
|
|
|
// ========== 회사 관리 CRUD 메서드들 시작 ==========
|
|
|
|
/**
|
|
* 회사 등록
|
|
* @param request
|
|
* @param paramMap
|
|
* @return
|
|
*/
|
|
public Map<String, Object> insertCompany(HttpServletRequest request, Map<String, Object> paramMap) {
|
|
Map<String, Object> resultMap = new HashMap<>();
|
|
|
|
try {
|
|
// 현재 로그인 사용자 정보 가져오기
|
|
HttpSession session = request.getSession();
|
|
PersonBean person = (PersonBean) session.getAttribute(Constants.PERSON_BEAN);
|
|
|
|
if (person == null) {
|
|
resultMap.put("success", false);
|
|
resultMap.put("message", "로그인이 필요합니다.");
|
|
return resultMap;
|
|
}
|
|
|
|
// 필수 입력값 검증
|
|
String companyName = CommonUtils.checkNull(paramMap.get("company_name"));
|
|
if (companyName.isEmpty()) {
|
|
resultMap.put("success", false);
|
|
resultMap.put("message", "회사명을 입력해주세요.");
|
|
return resultMap;
|
|
}
|
|
|
|
// 회사명 중복 체크 (시퀀스 생성 전에 먼저 체크!)
|
|
Map<String, Object> duplicateCheckParam = new HashMap<>();
|
|
duplicateCheckParam.put("COMPANY_NAME", companyName);
|
|
int duplicateCount = sqlSessionTemplate.selectOne("admin.checkCompanyNameDuplicate", duplicateCheckParam);
|
|
|
|
if (duplicateCount > 0) {
|
|
resultMap.put("success", false);
|
|
resultMap.put("message", "이미 등록된 회사명입니다.");
|
|
return resultMap;
|
|
}
|
|
|
|
// 모든 유효성 검증 통과 후 회사 코드 생성 (COMPANY_1, COMPANY_2, ...)
|
|
String companyCode = generateSequentialCompanyCode();
|
|
|
|
// 회사 정보 저장용 파라미터 설정
|
|
Map<String, Object> insertParam = new HashMap<>();
|
|
insertParam.put("COMPANY_CODE", companyCode);
|
|
insertParam.put("COMPANY_NAME", companyName);
|
|
insertParam.put("WRITER", person.getUserName() + "(" + person.getUserId() + ")");
|
|
insertParam.put("STATUS", "active"); // 기본 상태: 활성
|
|
|
|
|
|
// 데이터베이스에 회사 정보 저장
|
|
int insertResult = sqlSessionTemplate.insert("admin.insertCompany", insertParam);
|
|
|
|
if (insertResult > 0) {
|
|
resultMap.put("success", true);
|
|
resultMap.put("message", "회사가 성공적으로 등록되었습니다.");
|
|
resultMap.put("data", insertParam);
|
|
} else {
|
|
resultMap.put("success", false);
|
|
resultMap.put("message", "회사 등록에 실패했습니다.");
|
|
}
|
|
|
|
} catch (Exception e) {
|
|
log.error("회사 등록 중 오류 발생", e);
|
|
resultMap.put("success", false);
|
|
resultMap.put("message", "회사 등록 중 오류가 발생했습니다: " + e.getMessage());
|
|
}
|
|
|
|
return resultMap;
|
|
}
|
|
|
|
/**
|
|
* 회사 목록 조회
|
|
* @param request
|
|
* @param paramMap
|
|
* @return
|
|
*/
|
|
public List<Map<String, Object>> getCompanyList(HttpServletRequest request, Map<String, Object> paramMap) {
|
|
try {
|
|
// 현재 사용자 정보 조회
|
|
PersonBean person = (PersonBean) request.getSession().getAttribute(Constants.PERSON_BEAN);
|
|
if (person == null) {
|
|
log.warn("로그인되지 않은 사용자의 회사 목록 조회 시도");
|
|
return new ArrayList<>();
|
|
}
|
|
|
|
// 검색 조건 설정
|
|
Map<String, Object> searchParam = new HashMap<>();
|
|
|
|
|
|
// 회사명 검색
|
|
String companyName = CommonUtils.checkNull(paramMap.get("company_name"));
|
|
if (!companyName.isEmpty()) {
|
|
searchParam.put("COMPANY_NAME", companyName);
|
|
}
|
|
|
|
// 상태 필터
|
|
String status = CommonUtils.checkNull(paramMap.get("status"));
|
|
if (!status.isEmpty() && !"all".equals(status)) {
|
|
searchParam.put("STATUS", status);
|
|
}
|
|
|
|
// 회사 목록 조회 (현재 유저의 locale과 일치하는 회사만)
|
|
return sqlSessionTemplate.selectList("admin.selectCompanyList", searchParam);
|
|
|
|
} catch (Exception e) {
|
|
log.error("회사 목록 조회 중 오류 발생", e);
|
|
return new ArrayList<>();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 회사 정보 단건 조회
|
|
* @param request
|
|
* @param paramMap
|
|
* @return
|
|
*/
|
|
public Map<String, Object> getCompanyInfo(HttpServletRequest request, Map<String, Object> paramMap) {
|
|
try {
|
|
String companyCode = CommonUtils.checkNull(paramMap.get("company_code"));
|
|
if (companyCode.isEmpty()) {
|
|
Map<String, Object> errorMap = new HashMap<>();
|
|
errorMap.put("success", false);
|
|
errorMap.put("message", "회사 코드가 필요합니다.");
|
|
return errorMap;
|
|
}
|
|
|
|
|
|
Map<String, Object> queryParam = new HashMap<>();
|
|
queryParam.put("COMPANY_CODE", companyCode);
|
|
|
|
Map<String, Object> companyInfo = sqlSessionTemplate.selectOne("admin.selectCompanyInfo", queryParam);
|
|
|
|
Map<String, Object> resultMap = new HashMap<>();
|
|
if (companyInfo != null) {
|
|
resultMap.put("success", true);
|
|
resultMap.put("data", companyInfo);
|
|
} else {
|
|
resultMap.put("success", false);
|
|
resultMap.put("message", "회사 정보를 찾을 수 없습니다.");
|
|
}
|
|
|
|
return resultMap;
|
|
|
|
} catch (Exception e) {
|
|
log.error("회사 정보 조회 중 오류 발생", e);
|
|
Map<String, Object> errorMap = new HashMap<>();
|
|
errorMap.put("success", false);
|
|
errorMap.put("message", "회사 정보 조회 중 오류가 발생했습니다: " + e.getMessage());
|
|
return errorMap;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 회사 정보 수정
|
|
* @param request
|
|
* @param paramMap
|
|
* @return
|
|
*/
|
|
public Map<String, Object> updateCompany(HttpServletRequest request, Map<String, Object> paramMap) {
|
|
Map<String, Object> resultMap = new HashMap<>();
|
|
|
|
try {
|
|
// 필수 입력값 검증
|
|
String companyCode = CommonUtils.checkNull(paramMap.get("company_code"));
|
|
String companyName = CommonUtils.checkNull(paramMap.get("company_name"));
|
|
|
|
if (companyCode.isEmpty()) {
|
|
resultMap.put("success", false);
|
|
resultMap.put("message", "회사 코드가 필요합니다.");
|
|
return resultMap;
|
|
}
|
|
|
|
if (companyName.isEmpty()) {
|
|
resultMap.put("success", false);
|
|
resultMap.put("message", "회사명을 입력해주세요.");
|
|
return resultMap;
|
|
}
|
|
|
|
// 회사명 중복 체크 (자기 자신 제외)
|
|
Map<String, Object> duplicateCheckParam = new HashMap<>();
|
|
duplicateCheckParam.put("COMPANY_NAME", companyName);
|
|
duplicateCheckParam.put("EXCLUDE_COMPANY_CODE", companyCode);
|
|
int duplicateCount = sqlSessionTemplate.selectOne("admin.checkCompanyNameDuplicate", duplicateCheckParam);
|
|
|
|
if (duplicateCount > 0) {
|
|
resultMap.put("success", false);
|
|
resultMap.put("message", "이미 등록된 회사명입니다.");
|
|
return resultMap;
|
|
}
|
|
|
|
// 회사 정보 수정용 파라미터 설정
|
|
Map<String, Object> updateParam = new HashMap<>();
|
|
updateParam.put("COMPANY_CODE", companyCode);
|
|
updateParam.put("COMPANY_NAME", companyName);
|
|
updateParam.put("STATUS", CommonUtils.checkNull(paramMap.get("status"), "active"));
|
|
|
|
// 데이터베이스에서 회사 정보 수정
|
|
int updateResult = sqlSessionTemplate.update("admin.updateCompany", updateParam);
|
|
|
|
if (updateResult > 0) {
|
|
resultMap.put("success", true);
|
|
resultMap.put("message", "회사 정보가 성공적으로 수정되었습니다.");
|
|
resultMap.put("data", updateParam);
|
|
} else {
|
|
resultMap.put("success", false);
|
|
resultMap.put("message", "회사 정보 수정에 실패했습니다.");
|
|
}
|
|
|
|
} catch (Exception e) {
|
|
log.error("회사 정보 수정 중 오류 발생", e);
|
|
resultMap.put("success", false);
|
|
resultMap.put("message", "회사 정보 수정 중 오류가 발생했습니다: " + e.getMessage());
|
|
}
|
|
|
|
return resultMap;
|
|
}
|
|
|
|
/**
|
|
* 회사 삭제
|
|
* @param request
|
|
* @param paramMap
|
|
* @return
|
|
*/
|
|
public Map<String, Object> deleteCompany(HttpServletRequest request, Map<String, Object> paramMap) {
|
|
Map<String, Object> resultMap = new HashMap<>();
|
|
|
|
try {
|
|
String companyCode = CommonUtils.checkNull(paramMap.get("company_code"));
|
|
|
|
if (companyCode.isEmpty()) {
|
|
resultMap.put("success", false);
|
|
resultMap.put("message", "회사 코드가 필요합니다.");
|
|
return resultMap;
|
|
}
|
|
|
|
|
|
// 회사 정보 존재 여부 확인
|
|
Map<String, Object> queryParam = new HashMap<>();
|
|
queryParam.put("COMPANY_CODE", companyCode);
|
|
Map<String, Object> companyInfo = sqlSessionTemplate.selectOne("admin.selectCompanyInfo", queryParam);
|
|
|
|
if (companyInfo == null) {
|
|
resultMap.put("success", false);
|
|
resultMap.put("message", "삭제할 회사 정보를 찾을 수 없습니다.");
|
|
return resultMap;
|
|
}
|
|
|
|
// 데이터베이스에서 회사 정보 삭제
|
|
int deleteResult = sqlSessionTemplate.delete("admin.deleteCompany", queryParam);
|
|
|
|
if (deleteResult > 0) {
|
|
resultMap.put("success", true);
|
|
resultMap.put("message", "회사가 성공적으로 삭제되었습니다.");
|
|
} else {
|
|
resultMap.put("success", false);
|
|
resultMap.put("message", "회사 삭제에 실패했습니다.");
|
|
}
|
|
|
|
} catch (Exception e) {
|
|
log.error("회사 삭제 중 오류 발생", e);
|
|
resultMap.put("success", false);
|
|
resultMap.put("message", "회사 삭제 중 오류가 발생했습니다: " + e.getMessage());
|
|
}
|
|
|
|
return resultMap;
|
|
}
|
|
|
|
/**
|
|
* 순차적인 회사 코드 자동 생성 (COMPANY_1, COMPANY_2, ...)
|
|
* 삭제된 번호는 재사용하지 않고 계속 증가
|
|
* @return 생성된 회사 코드
|
|
*/
|
|
private String generateSequentialCompanyCode() {
|
|
try {
|
|
// 시퀀스 테이블이 없으면 생성 및 기존 데이터 기반 초기화
|
|
initializeCompanyCodeSequence();
|
|
|
|
// 시퀀스 테이블에서 다음 번호 조회 (자동 증가)
|
|
Integer nextSequence = sqlSessionTemplate.selectOne("admin.getNextCompanyCodeSequence");
|
|
|
|
return "COMPANY_" + nextSequence;
|
|
|
|
} catch (Exception e) {
|
|
log.warn("회사 코드 생성 중 오류 발생, 기본값 사용", e);
|
|
// 오류 발생 시 현재 시간을 이용한 기본값
|
|
return "COMPANY_" + System.currentTimeMillis() % 10000;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 회사 코드 시퀀스 테이블 초기화
|
|
* 기존 데이터를 고려하여 시퀀스 값 설정
|
|
*/
|
|
private void initializeCompanyCodeSequence() {
|
|
try {
|
|
// 1. 시퀀스 테이블 생성 (IF NOT EXISTS로 안전)
|
|
sqlSessionTemplate.update("admin.createCompanyCodeSequenceTable");
|
|
|
|
// 2. 기존 데이터 기반으로 시퀀스 초기화 (이미 존재하면 스킵)
|
|
sqlSessionTemplate.selectOne("admin.initializeCompanyCodeSequence");
|
|
|
|
} catch (Exception e) {
|
|
log.warn("시퀀스 테이블 초기화 중 오류 발생", e);
|
|
}
|
|
}
|
|
|
|
|
|
|
|
// ========== 회사 관리 CRUD 메서드들 종료 ==========
|
|
|
|
/**
|
|
* 세션의 사용자 정보 업데이트
|
|
* @param request
|
|
* @param paramMap
|
|
*/
|
|
private void updateSessionUserInfo(HttpServletRequest request, Map<String, Object> paramMap) {
|
|
try {
|
|
HttpSession session = request.getSession();
|
|
PersonBean currentUser = (PersonBean) session.getAttribute(Constants.PERSON_BEAN);
|
|
|
|
if (currentUser != null) {
|
|
String userId = CommonUtils.checkNull(paramMap.get("userId"));
|
|
|
|
// 현재 로그인한 사용자의 정보를 업데이트하는 경우에만 세션 갱신
|
|
if (userId.equals(currentUser.getUserId())) {
|
|
// 데이터베이스에서 최신 사용자 정보 조회
|
|
Map<String, Object> userQueryParam = new HashMap<>();
|
|
userQueryParam.put("userId", userId);
|
|
|
|
Map<String, Object> updatedUserInfo = sqlSessionTemplate.selectOne("user.getUserInfo", userQueryParam);
|
|
|
|
if (updatedUserInfo != null) {
|
|
// PersonBean 업데이트
|
|
currentUser.setUserName((String) updatedUserInfo.get("USER_NAME"));
|
|
currentUser.setEmail((String) updatedUserInfo.get("EMAIL"));
|
|
currentUser.setDeptCode((String) updatedUserInfo.get("DEPT_CODE"));
|
|
currentUser.setDeptName((String) updatedUserInfo.get("DEPT_NAME"));
|
|
currentUser.setPositionCode((String) updatedUserInfo.get("POSITION_CODE"));
|
|
currentUser.setPositionName((String) updatedUserInfo.get("POSITION_NAME"));
|
|
currentUser.setLocale((String) updatedUserInfo.get("LOCALE"));
|
|
|
|
// photo 데이터 업데이트 (중요!)
|
|
Object photoObj = updatedUserInfo.get("PHOTO");
|
|
if (photoObj != null && photoObj instanceof byte[]) {
|
|
currentUser.setPhoto((byte[]) photoObj);
|
|
}
|
|
|
|
// 업데이트된 PersonBean을 세션에 저장
|
|
session.setAttribute(Constants.PERSON_BEAN, currentUser);
|
|
}
|
|
}
|
|
}
|
|
} catch (Exception e) {
|
|
// 세션 업데이트 실패는 로그만 남기고 계속 진행
|
|
e.printStackTrace();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 회사 데이터 디버깅용 메서드
|
|
*/
|
|
public void debugCompanyData() {
|
|
try {
|
|
log.info("=== 회사 데이터 디버깅 시작 ===");
|
|
|
|
// COMPANY_MNG 테이블의 모든 데이터 조회
|
|
List<Map<String, Object>> companyList = sqlSessionTemplate.selectList("admin.selectCompanyList", new HashMap<>());
|
|
log.info("COMPANY_MNG 테이블 데이터 개수: {}", companyList.size());
|
|
|
|
for (Map<String, Object> company : companyList) {
|
|
log.info("회사 데이터: COMPANY_CODE={}, COMPANY_NAME={}",
|
|
company.get("COMPANY_CODE"), company.get("COMPANY_NAME"));
|
|
}
|
|
|
|
// MENU_INFO 테이블의 회사 코드 분포 확인
|
|
List<Map<String, Object>> menuCompanyStats = sqlSessionTemplate.selectList("admin.selectMenuCompanyStats");
|
|
log.info("메뉴별 회사 코드 분포:");
|
|
for (Map<String, Object> stat : menuCompanyStats) {
|
|
log.info(" COMPANY_CODE={}, COUNT={}",
|
|
stat.get("COMPANY_CODE"), stat.get("COUNT"));
|
|
}
|
|
|
|
log.info("=== 회사 데이터 디버깅 완료 ===");
|
|
|
|
} catch (Exception e) {
|
|
log.error("회사 데이터 디버깅 중 오류 발생", e);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 사용자 변경이력 목록 조회 (원본 JSP 로직 기반)
|
|
*/
|
|
public List<Map<String, Object>> getUserHistoryList(HttpServletRequest request, Map<String, Object> paramMap) {
|
|
List<Map<String, Object>> resultList = new ArrayList<>();
|
|
|
|
try {
|
|
// 컨트롤러에서 전달받은 파라미터 사용
|
|
String page = paramMap.get("page") != null ? paramMap.get("page").toString() : "1";
|
|
String countPerPage = paramMap.get("countPerPage") != null ? paramMap.get("countPerPage").toString() : "10";
|
|
|
|
paramMap.put("COUNT_PER_PAGE", Integer.parseInt(countPerPage));
|
|
|
|
// 페이징 정보 계산 (원본 방식)
|
|
Map<String, Object> pageMap = sqlSessionTemplate.selectOne("admin.getUserHistoryListCnt", paramMap);
|
|
|
|
if (pageMap != null) {
|
|
// setPagingInfo 로직을 여기서 직접 구현
|
|
int totalCnt = 0;
|
|
if (pageMap.get("TOTAL_CNT") != null) {
|
|
totalCnt = ((Number) pageMap.get("TOTAL_CNT")).intValue();
|
|
}
|
|
|
|
int currentPage = Integer.parseInt(page);
|
|
int pageSize = Integer.parseInt(countPerPage);
|
|
int pageStart = (currentPage - 1) * pageSize + 1;
|
|
int pageEnd = currentPage * pageSize;
|
|
|
|
paramMap.put("PAGE_START", String.valueOf(pageStart));
|
|
paramMap.put("PAGE_END", String.valueOf(pageEnd));
|
|
|
|
// JSP에서 사용하는 추가 정보들도 request에 설정
|
|
request.setAttribute("TOTAL_COUNT", totalCnt);
|
|
request.setAttribute("MAX_PAGE_SIZE", pageMap.get("MAX_PAGE_SIZE"));
|
|
|
|
log.info("사용자 변경이력 페이징 정보 - 총건수: {}, 현재페이지: {}, PAGE_START: {}, PAGE_END: {}, maxPageSize: {}",
|
|
totalCnt, currentPage, pageStart, pageEnd, pageMap.get("MAX_PAGE_SIZE"));
|
|
log.info("전달할 paramMap: {}", paramMap);
|
|
}
|
|
|
|
// 데이터 조회
|
|
resultList = sqlSessionTemplate.selectList("admin.getUserHistoryList", paramMap);
|
|
|
|
log.info("사용자 변경이력 조회 결과: {} 건", resultList.size());
|
|
|
|
} catch (Exception e) {
|
|
log.error("사용자 변경이력 목록 조회 중 오류 발생", e);
|
|
e.printStackTrace();
|
|
}
|
|
|
|
return resultList;
|
|
}
|
|
|
|
/**
|
|
* 사용자 변경이력 총 개수 조회 (원본 로직 기반)
|
|
*/
|
|
public int getUserHistoryListCnt(HttpServletRequest request, Map<String, Object> paramMap) {
|
|
try {
|
|
Map<String, Object> result = sqlSessionTemplate.selectOne("admin.getUserHistoryListCnt", paramMap);
|
|
if (result != null && result.get("TOTAL_CNT") != null) {
|
|
Object totalCntObj = result.get("TOTAL_CNT");
|
|
if (totalCntObj instanceof Number) {
|
|
return ((Number) totalCntObj).intValue();
|
|
} else {
|
|
return Integer.parseInt(totalCntObj.toString());
|
|
}
|
|
}
|
|
return 0;
|
|
} catch (Exception e) {
|
|
log.error("사용자 변경이력 총 개수 조회 중 오류 발생", e);
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 사용자 비밀번호 초기화 (원본 JSP 로직 기반)
|
|
* @param request
|
|
* @param paramMap
|
|
* @return
|
|
*/
|
|
public Map<String, Object> resetUserPassword(HttpServletRequest request, Map<String, Object> paramMap) {
|
|
Map<String, Object> resultMap = new HashMap<>();
|
|
|
|
try {
|
|
String userId = String.valueOf(paramMap.get("USER_ID"));
|
|
String newPassword = String.valueOf(paramMap.get("NEW_PASSWORD"));
|
|
|
|
log.info("비밀번호 초기화 처리 시작 - userId: {}", userId);
|
|
|
|
// 입력값 검증
|
|
if (userId == null || userId.trim().isEmpty()) {
|
|
resultMap.put("result", "false");
|
|
resultMap.put("msg", "사용자 ID가 필요합니다.");
|
|
return resultMap;
|
|
}
|
|
|
|
if (newPassword == null || newPassword.trim().isEmpty()) {
|
|
resultMap.put("result", "false");
|
|
resultMap.put("msg", "새 비밀번호가 필요합니다.");
|
|
return resultMap;
|
|
}
|
|
|
|
// 비밀번호 암호화 (원본 로직과 동일)
|
|
EncryptUtil encryptUtil = new EncryptUtil();
|
|
String encryptedPassword;
|
|
try {
|
|
encryptedPassword = encryptUtil.encrypt(newPassword);
|
|
} catch (Exception e) {
|
|
log.error("비밀번호 암호화 중 오류 발생", e);
|
|
resultMap.put("result", "false");
|
|
resultMap.put("msg", "비밀번호 암호화 중 오류가 발생했습니다.");
|
|
return resultMap;
|
|
}
|
|
|
|
// 업데이트용 파라미터 설정
|
|
Map<String, Object> updateParam = new HashMap<>();
|
|
updateParam.put("USER_ID", userId);
|
|
updateParam.put("USER_PWD", encryptedPassword);
|
|
|
|
// 비밀번호 업데이트 실행
|
|
int updateCount = sqlSessionTemplate.update("admin.updateUserPassword", updateParam);
|
|
|
|
if (updateCount > 0) {
|
|
// 성공 시 이력 저장
|
|
HttpSession session = request.getSession();
|
|
PersonBean person = (PersonBean) session.getAttribute(Constants.PERSON_BEAN);
|
|
String writer = person != null ? person.getUserId() : "system";
|
|
|
|
Map<String, Object> historyParam = new HashMap<>();
|
|
historyParam.put("user_id", userId);
|
|
historyParam.put("history_type", "비밀번호 초기화");
|
|
historyParam.put("writer", writer);
|
|
historyParam.put("reg_date", new java.util.Date());
|
|
|
|
try {
|
|
sqlSessionTemplate.insert("admin.InsertUserInfoHistory", historyParam);
|
|
} catch (Exception e) {
|
|
log.warn("비밀번호 초기화 이력 저장 실패", e);
|
|
// 이력 저장 실패해도 비밀번호 초기화는 성공으로 처리
|
|
}
|
|
|
|
resultMap.put("result", "true");
|
|
resultMap.put("msg", "비밀번호가 성공적으로 초기화되었습니다.");
|
|
log.info("비밀번호 초기화 성공 - userId: {}", userId);
|
|
} else {
|
|
resultMap.put("result", "false");
|
|
resultMap.put("msg", "사용자 정보를 찾을 수 없거나 비밀번호 변경에 실패했습니다.");
|
|
log.warn("비밀번호 초기화 실패 - 업데이트된 행 없음. userId: {}", userId);
|
|
}
|
|
|
|
} catch (Exception e) {
|
|
log.error("비밀번호 초기화 중 오류 발생", e);
|
|
resultMap.put("result", "false");
|
|
resultMap.put("msg", "비밀번호 초기화 중 시스템 오류가 발생했습니다.");
|
|
}
|
|
|
|
return resultMap;
|
|
}
|
|
|
|
/**
|
|
* 회사 목록 조회 (하드코딩 방식 - 기존 시스템 구조 반영)
|
|
* @param request
|
|
* @return
|
|
*/
|
|
public List<Map<String, Object>> getCompanyList(HttpServletRequest request) {
|
|
List<Map<String, Object>> companyList = new ArrayList<>();
|
|
|
|
log.info("회사 목록 생성 시작");
|
|
|
|
// 기존 시스템에서 사용하는 회사 코드들을 반영
|
|
companyList.add(createCompanyMap("ILSHIN", "일신자동차부품"));
|
|
companyList.add(createCompanyMap("HUTECH", "휴테크"));
|
|
companyList.add(createCompanyMap("DAIN", "다인"));
|
|
companyList.add(createCompanyMap("KUMHO", "금호"));
|
|
|
|
log.info("회사 목록 생성 완료 - 총 {}개", companyList.size());
|
|
|
|
return companyList;
|
|
}
|
|
|
|
/**
|
|
* 회사 정보 Map 생성 헬퍼 메서드
|
|
* @param code
|
|
* @param name
|
|
* @return
|
|
*/
|
|
private Map<String, Object> createCompanyMap(String code, String name) {
|
|
Map<String, Object> company = new HashMap<>();
|
|
company.put("code", code);
|
|
company.put("name", name);
|
|
company.put("value", code); // 셀렉트박스 value용
|
|
company.put("label", name); // 셀렉트박스 label용
|
|
return company;
|
|
}
|
|
|
|
} |