xit-app
/
fims-java-all
20
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

납부자 관련 소스 이동

Browse Source
main
이범준 2 months ago
parent 4c6603f750
commit 87df5e184f
17 changed files with 0 additions and 2621 deletions
Show Stats Download Patch File Download Diff File

35
src/main/java/cokr/xit/fims/cmmn/CrdnPayerHstry.java
Unescape Escape View File

@ -1,35 +0,0 @@
package cokr.xit.fims.cmmn;
import cokr.xit.foundation.AbstractEntity;
import lombok.Getter;
import lombok.Setter;
/**
* 단속 납부자 이력
* @author leebj
*/
@Getter
@Setter
public class CrdnPayerHstry extends AbstractEntity {
/**
* 변경 이력 ID
*/
private String chgHstryId;
/**
* 단속 ID
*/
private String crdnId;
/**
* 납부자 ID
*/
private String rtpyrId;
/**
* 주소 일련번호
*/
private String addrSn;
}

48
src/main/java/cokr/xit/fims/cmmn/CrdnPayerHstryQuery.java
Unescape Escape View File

@ -1,48 +0,0 @@
package cokr.xit.fims.cmmn;
/**단속 납부자 이력 정보 조회 요청
*
* <p>상세 설명:
*
* <pre>
* ============ 변경 이력 ============
* 2023-08-16 leebj 최초 작성
* ================================
* </pre>
*/
public class CrdnPayerHstryQuery extends CmmnQuery {
private static final long serialVersionUID = 1L;
private String crdnId; // 단속 ID
private String rtpyrId; // 납부자 ID
private String addrSn; // 주소 일련번호
public String getCrdnId() {
return ifEmpty(crdnId, () -> null);
}
public <T extends CrdnPayerHstryQuery> T setCrdnId(String crdnId) {
this.crdnId = crdnId;
return self();
}
public String getRtpyrId() {
return ifEmpty(rtpyrId, () -> null);
}
public <T extends CrdnPayerHstryQuery> T setRtpyrId(String rtpyrId) {
this.rtpyrId = rtpyrId;
return self();
}
public String getAddrSn() {
return ifEmpty(addrSn, () -> null);
}
public <T extends CrdnPayerHstryQuery> T setAddrSn(String addrSn) {
this.rtpyrId = addrSn;
return self();
}
}

87
src/main/java/cokr/xit/fims/cmmn/CrdnSttsHstry.java
Unescape Escape View File

@ -1,87 +0,0 @@
package cokr.xit.fims.cmmn;
import cokr.xit.foundation.AbstractEntity;
import lombok.Getter;
import lombok.Setter;
/**단속 상태 이력
*
* <p>상세 설명: 단속 상태 이력 엔티티를 데이터베이스에 저장하는 클래스다.
*
* <pre>
* ============ 변경 이력 ============
* 2023-07-19 JoJH 최초 작성
* ================================
* </pre>
*/
@Getter
@Setter
public class CrdnSttsHstry extends AbstractEntity {
/**
* 상태 이력 ID
*/
private String sttsHstryId;
/**
* 단속 ID
*/
private String crdnId;
/**
* 이전 상태 코드
*/
private String bfrSttsCd;
/**
* 이전 상태 변경 일시
*/
private String bfrSttsChgDt;
/**
* 단속 상태 코드
*/
private String crdnSttsCd;
/**
* 업무 상세 ID
*/
private String taskDtlId;
/**
* 기타 내용
*/
private String etcCn;
/**
* 사용 여부
*/
private String useYn;
/**
* 등록 일시
*/
private String regDt;
/**
* 등록자
*/
private String rgtr;
/**
* 수정 일시
*/
private String mdfcnDt;
/**
* 수정자
*/
private String mdfr;
/**
* 단속 상태 변경 일시 - TB_CRDN(단속)
*/
private String crdnSttsChgDt;
}

62
src/main/java/cokr/xit/fims/cmmn/CrdnSttsHstryQuery.java
Unescape Escape View File

@ -1,62 +0,0 @@
package cokr.xit.fims.cmmn;
/**단속 상태 이력 정보 조회 요청
*
* <p>상세 설명:
*
* <pre>
* ============ 변경 이력 ============
* 2023-07-19 JoJH 최초 작성
* ================================
* </pre>
*/
public class CrdnSttsHstryQuery extends CmmnQuery {
private static final long serialVersionUID = 1L;
private String sttsHstryId; // 상태 이력 ID
private String crdnId; // 단속 ID
private String crdnSttsCd; // 단속 상태 코드
private String taskDtlId; // 업무 상세 ID
public String getSttsHstryId() {
return ifEmpty(sttsHstryId, () -> null);
}
public <T extends CrdnSttsHstryQuery> T setSttsHstryId(String sttsHstryId) {
this.sttsHstryId = sttsHstryId;
return self();
}
public String getCrdnId() {
return ifEmpty(crdnId, () -> null);
}
public <T extends CrdnSttsHstryQuery> T setCrdnId(String crdnId) {
this.crdnId = crdnId;
return self();
}
public String getCrdnSttsCd() {
return ifEmpty(crdnSttsCd, () -> null);
}
public <T extends CrdnSttsHstryQuery> T setCrdnSttsCd(String crdnSttsCd) {
this.crdnSttsCd = crdnSttsCd;
return self();
}
public String getTaskDtlId() {
return ifEmpty(taskDtlId, () -> null);
}
public <T extends CrdnSttsHstryQuery> T setTaskDtlId(String taskDtlId) {
this.taskDtlId = taskDtlId;
return self();
}
}

98
src/main/java/cokr/xit/fims/cmmn/dao/CrdnPayerHstryMapper.java
Unescape Escape View File

@ -1,98 +0,0 @@
package cokr.xit.fims.cmmn.dao;
import java.util.List;
import java.util.Map;
import org.egovframe.rte.psl.dataaccess.mapper.Mapper;
import cokr.xit.fims.cmmn.CrdnPayerHstry;
import cokr.xit.fims.cmmn.CrdnPayerHstryQuery;
import cokr.xit.foundation.component.AbstractMapper;
import cokr.xit.foundation.data.DataObject;
/** 단속 납부자 이력 정보 DAO
*
* <p>상세 설명:
*
* <pre>
* ============ 변경 이력 ============
* 2023-08-16 leebj 최초 작성
* ================================
* </pre>
*/
@Mapper("crdnPayerHstryMapper")
public interface CrdnPayerHstryMapper extends AbstractMapper {
/**지정한 조건에 따라 단속 납부자 이력 목록을 조회하여 반환한다.<br />
* @param req 단속 납부자 이력 조회 조건
* @return 단속 납부자 이력 목록
*/
List<DataObject> selectCrdnPayerHstryList(CrdnPayerHstryQuery req);
/**지정한 조건에 따라 단속 납부자 이력 객체들을 반환한다.
* @param req 단속 납부자 이력 조회 조건
* @return 단속 납부자 이력 객체 목록
*/
List<CrdnPayerHstry> selectCrdnPayerHstrys(CrdnPayerHstryQuery req);
/**단속 납부자 이력 정보를 등록한다.
* @param params 파라미터
* <ul><li>"crdnPayerHstry" - 단속 납부자 이력</li>
* <li>"currentUser" - 현재 접속한 사용자</li>
* </ul>
* @return 저장된 정보수
*/
int insertCrdnPayerHstry(Map<String, Object> params);
/**단속 납부자 이력 정보를 등록한다.
* @param crdnPayerHstry 단속 납부자 이력
* @return 저장 여부
* <ul><li>저장됐으면 true</li>
* <li>그렇지 않으면 false</li>
* </ul>
*/
default boolean insertCrdnPayerHstry(CrdnPayerHstry crdnPayerHstry) {
return crdnPayerHstry != null && insertCrdnPayerHstry(params().set("crdnPayerHstry", crdnPayerHstry)) == 1;
}
/**단속 납부자 주소 이력 정보를 등록한다.
* @param params 파라미터
* <ul><li>"crdnPayerHstry" - 단속 납부자 이력</li>
* <li>"currentUser" - 현재 접속한 사용자</li>
* </ul>
* @return 저장된 정보수
*/
int insertCrdnPayerAddrHstry(Map<String, Object> params);
/**단속 납부자 주소 이력 정보를 등록한다.
* @param crdnPayerHstry 단속 납부자 이력
* @return 저장 여부
* <ul><li>저장됐으면 true</li>
* <li>그렇지 않으면 false</li>
* </ul>
*/
default boolean insertCrdnPayerAddrHstry(CrdnPayerHstry crdnPayerHstry) {
return crdnPayerHstry != null && insertCrdnPayerAddrHstry(params().set("crdnPayerAddrHstry", crdnPayerHstry)) == 1;
}
/**단속(TB_CRDN) 대장의 납부자 ID를 수정한다.
* @param params 파라미터
* <ul><li>"crdnPayerHstry" - 단속 납부자 이력</li>
* <li>"currentUser" - 현재 접속한 사용자</li>
* </ul>
* @return 저장된 정보수
*/
int updateCrdnRtpyrId(Map<String, Object> params);
/**단속(TB_CRDN) 대장의 납부자 ID를 수정한다.
* @param crdnPayerHstry 단속 납부자 이력
* @return 저장 여부
* <ul><li>저장됐으면 true</li>
* <li>그렇지 않으면 false</li>
* </ul>
*/
default boolean updateCrdnPayer(CrdnPayerHstry crdnPayerHstry) {
return crdnPayerHstry != null && updateCrdnRtpyrId(params().set("crdnPayerHstry", crdnPayerHstry)) == 1;
}
}

89
src/main/java/cokr/xit/fims/cmmn/dao/CrdnSttsHstryMapper.java
Unescape Escape View File

@ -1,89 +0,0 @@
package cokr.xit.fims.cmmn.dao;
import java.util.List;
import org.egovframe.rte.psl.dataaccess.mapper.Mapper;
import cokr.xit.foundation.component.AbstractMapper;
import cokr.xit.foundation.data.DataObject;
import cokr.xit.fims.cmmn.CrdnSttsHstry;
import cokr.xit.fims.cmmn.CrdnSttsHstryQuery;
/** 단속 상태 이력 정보 DAO
*
* <p>상세 설명:
*
* <pre>
* ============ 변경 이력 ============
* 2023-07-19 JoJH 최초 작성
* ================================
* </pre>
*/
@Mapper("crdnSttsHstryMapper")
public interface CrdnSttsHstryMapper extends AbstractMapper {
/**지정한 조건에 따라 단속 상태 이력 목록을 조회하여 반환한다.<br />
* @param req 단속 상태 이력 조회 조건
* @return 단속 상태 이력 목록
*/
List<DataObject> selectCrdnSttsHstryList(CrdnSttsHstryQuery req);
/**지정한 조건에 따라 단속 상태 이력 객체들을 반환한다.
* @param req 단속 상태 이력 조회 조건
* @return 단속 상태 이력 객체 목록
*/
List<DataObject> selectCrdnSttsHstrys(CrdnSttsHstryQuery req);
/**지정한 조건에 따라 단속 상태 이력 객체의 마지막 1개를 반환한다.
* @param crdnId 단속 ID
* @return 지정한 단속 ID의 단속 상태 이력 객체
*/
default DataObject selectCrdnSttsHstryInfo(String crdnId, String crdnSttsCd, String useYn) {
CrdnSttsHstryQuery req = new CrdnSttsHstryQuery();
req.setCrdnId(crdnId);
req.setCrdnSttsCd(crdnSttsCd);
req.setUseYn(useYn);
req.setOrderBy("STTS_HSTRY_ID DESC");
List<DataObject> crdnSttsHstrys = selectCrdnSttsHstrys(req);
return !crdnSttsHstrys.isEmpty() ? crdnSttsHstrys.get(0) : null;
}
/**단속 상태 이력 정보를 등록한다.
* @param params 파라미터
* <ul><li>"crdnSttsHstry" - 단속 상태 이력</li>
* <li>"currentUser" - 현재 접속한 사용자</li>
* </ul>
* @return 저장된 정보수
*/
int insertCrdnSttsHstry(CrdnSttsHstry crdnSttsHstry);
/**단속 상태 이력 정보를 수정한다.
* @param params 파라미터
* <ul><li>"crdnSttsHstry" - 단속 상태 이력</li>
* <li>"currentUser" - 현재 접속한 사용자</li>
* </ul>
* @return 저장된 정보수
*/
int updateCrdnSttsHstry(CrdnSttsHstry crdnSttsHstry);
/**지정한 단속 상태 이력을 삭제한다.
* @param params 파라미터
* <ul><li>"crdnSttsHstry" - 단속 상태 이력</li>
* <li>"currentUser" - 현재 접속한 사용자</li>
* </ul>
* @return 저장된 정보수
*/
int deleteCrdnSttsHstry(CrdnSttsHstry crdnSttsHstry);
/**단속(TB_CRDN) 대장의 단속 상태 코드를 수정한다.
* @param params 파라미터
* <ul><li>"excl01" - 부과 제외 대장</li>
* <li>"currentUser" - 현재 접속한 사용자</li>
* </ul>
* @return 저장된 정보수
*/
int updateCrdnSttsCd(CrdnSttsHstry crdnSttsHstry);
}

137
src/main/java/cokr/xit/fims/cmmn/service/bean/CrdnPayerHstryBean.java
Unescape Escape View File

@ -1,137 +0,0 @@
package cokr.xit.fims.cmmn.service.bean;
import java.util.List;
import javax.annotation.Resource;
import org.springframework.stereotype.Component;
import cokr.xit.fims.cmmn.CrdnPayerHstry;
import cokr.xit.fims.cmmn.CrdnPayerHstryQuery;
import cokr.xit.fims.cmmn.dao.CrdnPayerHstryMapper;
import cokr.xit.foundation.component.AbstractBean;
import cokr.xit.foundation.data.DataObject;
/**단속 납부자 이력 정보 관리 Bean
*
* <p>상세 설명:
*
* <pre>
* ============ 변경 이력 ============
* 2023-08-16 leebj 최초 작성
* ================================
* </pre>
*/
@Component("crdnPayerHstryBean")
public class CrdnPayerHstryBean extends AbstractBean {
/** 단속 납부자 이력 정보 DAO */
@Resource(name = "crdnPayerHstryMapper")
private CrdnPayerHstryMapper crdnPayerHstryMapper;
/**지정한 조건에 따라 단속 납부자 이력 목록을 조회하여 반환한다.
* @param req 단속 납부자 이력 조회 조건
* @return 단속 납부자 이력 목록
*/
public List<DataObject> getCrdnPayerHstryList(CrdnPayerHstryQuery req) {
return crdnPayerHstryMapper.selectCrdnPayerHstryList(req);
}
/**지정한 조건에 따라 단속 납부자 이력 객체들을 반환한다.
* @param req 단속 납부자 이력 조회 조건
* @return 단속 납부자 이력 객체 목록
*/
public List<CrdnPayerHstry> getCrdnPayerHstrys(CrdnPayerHstryQuery req) {
return crdnPayerHstryMapper.selectCrdnPayerHstrys(req);
}
/**단속 납부자 이력 정보를 등록한다.
* @param crdnPayerHstry 단속 납부자 이력
* @return 저장 여부
* <ul><li>저장됐으면 true</li>
* <li>그렇지 않으면 false</li>
* </ul>
*/
public boolean createCrdnPayerHstry(CrdnPayerHstry crdnPayerHstry) {
return crdnPayerHstryMapper.insertCrdnPayerHstry(crdnPayerHstry);
}
/**단속 납부자 주소 이력 정보를 등록한다.
* @param crdnPayerHstry 단속 납부자 이력
* @return 저장 여부
* <ul><li>저장됐으면 true</li>
* <li>그렇지 않으면 false</li>
* </ul>
*/
public boolean createCrdnPayerAddrHstry(CrdnPayerHstry crdnPayerHstry) {
return crdnPayerHstryMapper.insertCrdnPayerAddrHstry(crdnPayerHstry);
}
/**단속 납부자 이력 정보를 등록하고, 단속 대장의 납부자 정보를 수정한다.
* @param crdnPayerHstry 단속 납부자 이력
* @return 저장 여부
* <ul><li>저장됐으면 true</li>
* <li>그렇지 않으면 false</li>
* </ul>
*/
public boolean updateCrdnPayer(CrdnPayerHstry crdnPayerHstry) {
return crdnPayerHstryMapper.updateCrdnPayer(crdnPayerHstry);
}
/**단속 납부자 이력 및 주소 이력 정보를 등록하고, 단속 대장의 납부자 정보를 수정한다.
* @param crdnPayerHstry 단속 납부자 이력
* @return 저장 여부
* <ul><li>저장됐으면 true</li>
* <li>그렇지 않으면 false</li>
* </ul>
*/
public boolean createHstryUpdateCrdnPayer(CrdnPayerHstry crdnPayerHstry) {
boolean rtnScs = false; // DB 처리 결과
// 단속 납부자 이력 정보를 등록한다.
rtnScs = createCrdnPayerHstry(crdnPayerHstry);
if (!rtnScs) {
throw new RuntimeException("단속 납부자 이력 정보를 등록 중 오류가 발생하였습니다."); // 예외를 발생시켜서 DB Rollback
}
// 단속 납부자 주소 이력 정보를 등록한다.
rtnScs = createCrdnPayerAddrHstry(crdnPayerHstry);
if (!rtnScs) {
throw new RuntimeException("단속 납부자 이력 정보를 등록 중 오류가 발생하였습니다."); // 예외를 발생시켜서 DB Rollback
}
// 단속 대장의 납부자 ID, 주소 일련번호를 변경한다.
rtnScs = updateCrdnPayer(crdnPayerHstry);
if (!rtnScs) {
throw new RuntimeException("단속 납부자 이력 정보를 등록 중 오류가 발생하였습니다."); // 예외를 발생시켜서 DB Rollback
}
return rtnScs;
}
/**단속 납부자 주소 이력 정보를 등록하고, 단속 대장의 납부자 정보를 수정한다.
* @param crdnPayerHstry 단속 납부자 이력
* @return 저장 여부
* <ul><li>저장됐으면 true</li>
* <li>그렇지 않으면 false</li>
* </ul>
*/
public boolean createHstryUpdateCrdnPayerAddr(CrdnPayerHstry crdnPayerHstry) {
boolean rtnScs = false; // DB 처리 결과
// 단속 납부자 주소 이력 정보를 등록한다.
rtnScs = createCrdnPayerAddrHstry(crdnPayerHstry);
if (!rtnScs) {
throw new RuntimeException("단속 납부자 이력 정보를 등록 중 오류가 발생하였습니다."); // 예외를 발생시켜서 DB Rollback
}
// 단속 대장의 납부자 ID, 주소 일련번호를 변경한다.
rtnScs = updateCrdnPayer(crdnPayerHstry);
if (!rtnScs) {
throw new RuntimeException("단속 납부자 이력 정보를 등록 중 오류가 발생하였습니다."); // 예외를 발생시켜서 DB Rollback
}
return rtnScs;
}
}

224
src/main/java/cokr/xit/fims/cmmn/service/bean/CrdnSttsHstryBean.java
Unescape Escape View File

@ -1,224 +0,0 @@
package cokr.xit.fims.cmmn.service.bean;
import java.text.SimpleDateFormat;
import java.util.List;
import javax.annotation.Resource;
import org.springframework.stereotype.Component;
import cokr.xit.fims.cmmn.CrdnSttsHstry;
import cokr.xit.fims.cmmn.CrdnSttsHstryQuery;
import cokr.xit.fims.cmmn.dao.CrdnSttsHstryMapper;
import cokr.xit.foundation.component.AbstractBean;
import cokr.xit.foundation.data.DataObject;
/**단속 상태 이력 정보 관리 Bean
*
* <p>상세 설명:
*
* <pre>
* ============ 변경 이력 ============
* 2023-07-19 JoJH 최초 작성
* ================================
* </pre>
*/
@Component("crdnSttsHstryBean")
public class CrdnSttsHstryBean extends AbstractBean {
/** 단속 상태 이력 정보 DAO */
@Resource(name = "crdnSttsHstryMapper")
private CrdnSttsHstryMapper crdnSttsHstryMapper;
/**지정한 조건에 따라 단속 상태 이력 목록을 조회하여 반환한다.
* @param req 단속 상태 이력 조회 조건
* @return 단속 상태 이력 목록
*/
public List<DataObject> getCrdnSttsHstryList(CrdnSttsHstryQuery req) {
return crdnSttsHstryMapper.selectCrdnSttsHstryList(req);
}
/**지정한 조건에 따라 단속 상태 이력 객체들을 반환한다.
* @param req 단속 상태 이력 조회 조건
* @return 단속 상태 이력 객체 목록
*/
public List<DataObject> getCrdnSttsHstrys(CrdnSttsHstryQuery req) {
return crdnSttsHstryMapper.selectCrdnSttsHstrys(req);
}
/**단속 ID에 따라 마지막 단속 상태 이력 객체를 반환한다.
* @param crdnId 단속 ID
* @return 단속 상태 이력 객체 목록
*/
public DataObject getCrdnSttsHstryInfo(String crdnId, String crdnSttsCd, String useYn) {
return crdnSttsHstryMapper.selectCrdnSttsHstryInfo(crdnId, crdnSttsCd, useYn);
}
/**단속 상태 이력 정보를 등록한다.
* @param crdnSttsHstry 단속 상태 이력
* @return 저장 여부
* <ul><li>저장됐으면 true</li>
* <li>그렇지 않으면 false</li>
* </ul>
*/
public boolean create(CrdnSttsHstry crdnSttsHstry) {
if (crdnSttsHstry.getUseYn() == null) {
crdnSttsHstry.setUseYn("Y");
}
return crdnSttsHstryMapper.insertCrdnSttsHstry(crdnSttsHstry) == 1;
}
/**단속 상태 이력 정보를 수정한다.
* @param crdnSttsHstry 단속 상태 이력
* @return 저장 여부
* <ul><li>저장됐으면 true</li>
* <li>그렇지 않으면 false</li>
* </ul>
*/
public boolean update(CrdnSttsHstry crdnSttsHstry) {
return crdnSttsHstryMapper.updateCrdnSttsHstry(crdnSttsHstry) == 1;
}
/**단속 상태 이력 정보를 삭제한다. 단속ID로 입력되면 여러건이 삭제가 가능하다.
* @param crdnSttsHstry 단속 상태 이력
* @return 저장 여부
* <ul><li>저장됐으면 true</li>
* <li>그렇지 않으면 false</li>
* </ul>
*/
public boolean remove(CrdnSttsHstry crdnSttsHstry) {
return crdnSttsHstryMapper.deleteCrdnSttsHstry(crdnSttsHstry) >= 1;
}
/**단속 대장의 상태 정보를 수정한다.
* @param excl 부과제외 대장
* @return 저장 여부
* <ul><li>저장됐으면 true</li>
* <li>그렇지 않으면 false</li>
* </ul>
*/
public boolean updateCrdn(CrdnSttsHstry crdnSttsHstry) {
return crdnSttsHstryMapper.updateCrdnSttsCd(crdnSttsHstry) == 1;
}
/**단속 상태 이력 정보를 등록하고, 단속 대장의 단속상태 정보를 수정한다.
* @param crdnSttsHstry 단속 상태 이력
* @return 저장 여부
* <ul><li>저장됐으면 true</li>
* <li>그렇지 않으면 false</li>
* </ul>
*/
public boolean createHstryUpdateCrdnSttsCd(CrdnSttsHstry crdnSttsHstry) {
// 변수 선언
int rtnNocs = -1;
// 사용 여부
if (crdnSttsHstry.getUseYn() == null) {
crdnSttsHstry.setUseYn("Y");
}
// 단속 상태 변경 일시
if (crdnSttsHstry.getCrdnSttsChgDt() == null || crdnSttsHstry.getCrdnSttsChgDt().equals("")) {
// 현재 날짜 구하기
SimpleDateFormat dateFormat = new SimpleDateFormat("yyyyMMddHHmmss");
crdnSttsHstry.setCrdnSttsChgDt(dateFormat.format(System.currentTimeMillis()));
}
// 단속상태이력(TB_CRDN_STTS_HSTRY) 대장을 등록한다.
rtnNocs = crdnSttsHstryMapper.insertCrdnSttsHstry(crdnSttsHstry);
if (rtnNocs != 1) {
throw new RuntimeException("단속상태이력 대장 등록에 실패하였습니다."); // 예외를 발생시켜서 DB Rollback
}
// 단속(TB_CRDN) 대장을 수정한다.
rtnNocs = crdnSttsHstryMapper.updateCrdnSttsCd(crdnSttsHstry);
if (rtnNocs != 1) {
throw new RuntimeException("단속상태이력 정보 등록 중 오류가 발생하였습니다."); // 예외를 발생시켜서 DB Rollback
}
return true;
}
/**단속 상태 이력 정보를 삭제하고, 하고 단속 대장의 단속상태 정보를 수정한다.
* @param crdnSttsHstry 단속 상태 이력
* @return 저장 여부
* <ul><li>저장됐으면 true</li>
* <li>그렇지 않으면 false</li>
* </ul>
*/
public boolean removeHstryUpdateCrdnSttsCd(String crdnId, String crdnSttsCd, String deltSttsCd, String deltEtcCn, boolean insertBfrSttsYn) {
// 변수 선언
int rtnNocs = -1;
// 단속 ID에 해당하는 단속상태코드의 단속상태이력(TB_CRDN_STTS_HSTRY) 대장을 조회 한다.
DataObject crdnSttsHstryInfo = crdnSttsHstryMapper.selectCrdnSttsHstryInfo(crdnId, crdnSttsCd, "Y");
if (crdnSttsHstryInfo == null) {
throw new RuntimeException("단속상태이력 자료가 존재하지 않습니다."); // 예외를 발생시켜서 DB Rollback
}
if (!crdnSttsCd.equals("")) {
CrdnSttsHstry crdnSttsHstry = new CrdnSttsHstry();
crdnSttsHstry.setSttsHstryId(crdnSttsHstryInfo.string("STTS_HSTRY_ID"));
crdnSttsHstry.setUseYn("N");
rtnNocs = crdnSttsHstryMapper.updateCrdnSttsHstry(crdnSttsHstry);
if (rtnNocs != 1) {
throw new RuntimeException("단속상태이력 대장에 이력 수정에 실패하였습니다."); // 예외를 발생시켜서 DB Rollback
}
}
// 삭제 단속상태코드가 있다면.. 단속상태이력(TB_CRDN_STTS_HSTRY) 대장을 등록한다.
if (!deltSttsCd.equals("")) {
// 단속상태가 의견제출접수(31)가 아니면서, 삭제상태코드가 의견제출삭제(92)나 경찰서이첩삭제(97) 일 경우
if (!crdnSttsCd.equals("31") && "92,97".contains(deltSttsCd)) {
// 단속상태이력(TB_CRDN_STTS_HSTRY) 대장에서 의견제출접수(31) 이력을 조회후 사용여부를 미사용("N")으로 수정.
crdnSttsHstryInfo = crdnSttsHstryMapper.selectCrdnSttsHstryInfo(crdnId, "31", "Y");
if (crdnSttsHstryInfo == null) {
throw new RuntimeException("단속상태이력에 의견제출 접수 이력이 존재하지 않습니다."); // 예외를 발생시켜서 DB Rollback
}
CrdnSttsHstry opnnSttsHstry = new CrdnSttsHstry();
opnnSttsHstry.setSttsHstryId(crdnSttsHstryInfo.string("STTS_HSTRY_ID"));
opnnSttsHstry.setUseYn("N");
rtnNocs = crdnSttsHstryMapper.updateCrdnSttsHstry(opnnSttsHstry);
if (rtnNocs != 1) {
throw new RuntimeException("단속상태이력 대장에 의견제출접수 이력 수정에 실패하였습니다."); // 예외를 발생시켜서 DB Rollback
}
}
CrdnSttsHstry deleteSttsHstry = new CrdnSttsHstry();
deleteSttsHstry.setCrdnId(crdnSttsHstryInfo.string("CRDN_ID"));
deleteSttsHstry.setBfrSttsCd(crdnSttsHstryInfo.string("CRDN_STTS_CD"));
deleteSttsHstry.setBfrSttsChgDt(crdnSttsHstryInfo.string("REG_DT"));
deleteSttsHstry.setCrdnSttsCd(deltSttsCd);
deleteSttsHstry.setEtcCn(deltEtcCn);
deleteSttsHstry.setUseYn("N");
rtnNocs = crdnSttsHstryMapper.insertCrdnSttsHstry(deleteSttsHstry);
if (rtnNocs != 1) {
throw new RuntimeException("삭제 단속상태이력 정보 등록 중 오류가 발생하였습니다."); // 예외를 발생시켜서 DB Rollback
}
}
if (insertBfrSttsYn) {
// 단속상태이력(TB_CRDN_STTS_HSTRY) 대장을 등록한다.
CrdnSttsHstry crdnSttsHstry = new CrdnSttsHstry();
crdnSttsHstry.setCrdnId(crdnSttsHstryInfo.string("CRDN_ID"));
crdnSttsHstry.setBfrSttsCd(deltSttsCd);
crdnSttsHstry.setBfrSttsChgDt(crdnSttsHstry.getCreatedAt());
crdnSttsHstry.setCrdnSttsCd(crdnSttsHstryInfo.string("BFR_STTS_CD"));
crdnSttsHstry.setCrdnSttsChgDt(crdnSttsHstryInfo.string("BFR_STTS_CHG_DT"));
crdnSttsHstry.setUseYn("Y");
boolean rtnScs = createHstryUpdateCrdnSttsCd(crdnSttsHstry);
if (!rtnScs) {
throw new RuntimeException("단속상태이력 정보 등록 중 오류가 발생하였습니다."); // 예외를 발생시켜서 DB Rollback
}
}
return true;
}
}

191
src/main/java/cokr/xit/fims/payer/Payer.java
Unescape Escape View File

@ -1,191 +0,0 @@
package cokr.xit.fims.payer;
import cokr.xit.foundation.AbstractEntity;
import cokr.xit.interfaces.lvis.service.reg.BasicInfoResponse;
import lombok.Getter;
import lombok.Setter;
/**
* 납부자 대장
* @author mjkhan
*/
@Getter
@Setter
public class Payer extends AbstractEntity {
/**
* 납부자 ID
*/
private String rtpyrId;
/**
* 시군구 코드
*/
private String sggCd;
/**
* 차량번호
*/
private String vhrno;
/**
* 납부자 입력 구분 코드
*/
private String rtpyrInptSeCd;
/**
* 납부자 구분 코드
*/
private String rtpyrSeCd;
/**
* 납부자 번호
*/
private String rtpyrNo;
/**
* 납부자 명
*/
private String rtpyrNm;
/**
* 납부자 전화번호
*/
private String rtpyrTelno;
/**
* 납부자 휴대 전화번호
*/
private String rtpyrMblTelno;
/**
* 납부자 이메일
*/
private String rtpyrEml;
/**
* 납부자 생년월일
*/
private String rtpyrBrdt;
/**
* 납부자 상태 코드
*/
private String rtpyrSttsCd;
/**
* 주소 일련번호
*/
private String addrSn;
/**
* 주소 입력 구분 코드
*/
private String addrInptSeCd;
/**
* 주소 구분 코드
*/
private String addrSeCd;
/**
* 우편번호
*/
private String zip;
/**
* 주소
*/
private String addr;
/**
* 상세 주소
*/
private String dtlAddr;
/**
* 도로 명 코드
*/
private String roadNmCd;
/**
* 지하 구분 코드
*/
private String udgdSeCd;
/**
* 건물본번
*/
private Integer bmno;
/**
* 건물부번
*/
private Integer bsno;
/**
* 건물 관리 번호
*/
private String bldgMngNo;
/**
* 법정동 코드
*/
private String stdgCd;
/**
* 행정동 코드
*/
private String dongCd;
/**
* 산 구분 코드
*/
private String mtnSeCd;
/**
* 본번
*/
private Integer mno;
/**
* 부번
*/
private Integer sno;
/**
* 특수 동
*/
private String spclDong;
/**
* 특수 호
*/
private String spclHo;
/**
* 특수 주소
*/
private String spclAddr;
/**
* 전체 주소
*/
private String wholAddr;
/** 차량 기본정보 */
private BasicInfoResponse.BasicInfo vehicleInfo;
/**"차량번호-납부자번호"를 반환한다.
* @return "차량번호-납부자번호"
*/
public String getKey() {
return String.format("%s-%s", vhrno, rtpyrNo);
}
/**
* 단속 ID
*/
private String crdnId;
}

233
src/main/java/cokr/xit/fims/payer/PayerQuery.java
Unescape Escape View File

@ -1,233 +0,0 @@
package cokr.xit.fims.payer;
import cokr.xit.foundation.component.QueryRequest;
/**납부자 대장 정보 조회 요청
*
* <p>상세 설명:
*
* <pre>
* ============ 변경 이력 ============
* 2023-08-18 mjkhan 최초 작성
* ================================
* </pre>
*/
public class PayerQuery extends QueryRequest {
private static final long serialVersionUID = 1L;
/** 납부자 Ids */
private String[] rtpyrIds;
/** 차량번호 */
private String vhrno;
/** 납부자 구분 코드 */
private String rtpyrSeCd;
/** 납부자번호 */
private String rtpyrNo;
/** 납부자 ID */
private String rtpyrId;
/** 주소 일련번호 */
private String addrSn;
/** 이력 일련번호 */
private String hstrySn;
/** 주소 입력 구분 코드 */
private String addrInptSeCd;
/** 도로명 코드 */
private String roadNmCd;
/** 주소 */
private String addr;
/** 상세 주소 */
private String dtlAddr;
/** 단속 ID */
private String crdnId;
/** 호출 용도 */
private String callPurpose; // infoDialog 호출 용도(view 조회(편집불가), create 등록, update 수정, refresh 재조회).
/**납부자 Ids를 반환한다.
* @return 납부자 Ids
*/
public String[] getRtpyrIds() {
return ifEmpty(rtpyrIds, () -> null);
}
/**납부자 Ids를 설정한다.
* @param rtpyrIds 납부자 Ids
* @return 현재 PayerQuery
*/
public PayerQuery setRtpyrIds(String... rtpyrIds) {
this.rtpyrIds = rtpyrIds;
return this;
}
/**납부자 ID를 반환한다.
* @return 납부자 ID
*/
public String getRtpyrId() {
return !isEmpty(rtpyrIds) ? rtpyrIds[0] : rtpyrId;
}
/**납부자 ID를 설정한다.
* @param rtpyrId 납부자 ID
* @return 현재 PayerQuery
*/
public PayerQuery setRtpyrId(String rtpyrId) {
this.rtpyrId = rtpyrId;
return this;
}
/**주소 일련번호를 반환한다.
* @return 주소 일련번호
*/
public String getAddrSn() {
return ifEmpty(addrSn, () -> null);
}
/**주소 일련번호를 설정한다.
* @param addrSn 주소 일련번호
* @return 현재 PayerQuery
*/
public PayerQuery setAddrSn(String addrSn) {
this.addrSn = addrSn;
return self();
}
/**이력 일련번호를 반환한다.
* @return 이력 일련번호
*/
public String getHstrySn() {
return hstrySn;
}
/**이력 일련번호를 설정한다.
* @param hstrySn 이력 일련번호
* @return 현재 PayerQuery
*/
public PayerQuery setHstrySn(String hstrySn) {
this.hstrySn = hstrySn;
return this;
}
/**차량번호를 반환한다.
* @return 차량번호
*/
public String getVhrno() {
return vhrno;
}
/**차량번호를 설정한다.
* @param vhrno 차량번호
* @return 현재 PayerQuery
*/
public PayerQuery setVhrno(String vhrno) {
this.vhrno = vhrno;
return this;
}
/**납부자 구분 코드를 반환한다.
* @return 납부자 구분 코드
*/
public String getRtpyrSeCd() {
return rtpyrSeCd;
}
/**납부자 구분 코드를 설정한다.
* @param rtpyrSeCd 납부자 구분 코드
* @return 현재 PayerQuery
*/
public void setRtpyrSeCd(String rtpyrSeCd) {
this.rtpyrSeCd = rtpyrSeCd;
}
/**납부자 번호를 반환한다.
* @return 납부자 번호
*/
public String getRtpyrNo() {
return rtpyrNo;
}
/**납부자 번호를 설정한다.
* @param rtpyrNo 납부자 번호
* @return 현재 PayerQuery
*/
public void setRtpyrNo(String rtpyrNo) {
this.rtpyrNo = rtpyrNo;
}
/**주소 입력 구분 코드를 반환한다.
* @return 주소 입력 구분 코드
*/
public String getAddrInptSeCd() {
return addrInptSeCd;
}
/**주소 입력 구분 코드를 설정한다.
* @param addrInptSeCd 주소 입력 구분 코드
* @return 현재 PayerQuery
*/
public void setAddrInptSeCd(String addrInptSeCd) {
this.addrInptSeCd = addrInptSeCd;
}
/**도로명 코드를 반환한다.
* @return 도로명 코드
*/
public String getRoadNmCd() {
return roadNmCd;
}
/**도로명 코드를 설정한다.
* @param roadNmCd 도로명 코드
* @return 현재 PayerQuery
*/
public void setRoadNmCd(String roadNmCd) {
this.roadNmCd = roadNmCd;
}
/**주소를 반환한다.
* @return 주소
*/
public String getAddr() {
return addr;
}
/**주소를 설정한다.
* @param addr 주소
* @return 현재 PayerQuery
*/
public void setAddr(String addr) {
this.addr = addr;
}
/**상세 주소를 반환한다.
* @return 상세 주소
*/
public String getDtlAddr() {
return dtlAddr;
}
/**상세 주소를 설정한다.
* @param dtlAddr 상세 주소
* @return 현재 PayerQuery
*/
public void setDtlAddr(String dtlAddr) {
this.dtlAddr = dtlAddr;
}
public String getCrdnId() {
return ifEmpty(crdnId, () -> null);
}
public <T extends PayerQuery> T setCrdnId(String crdnId) {
this.crdnId = crdnId;
return self();
}
public String getCallPurpose() {
return ifEmpty(callPurpose, () -> null);
}
public <T extends PayerQuery> T setCallPurpose(String callPurpose) {
this.callPurpose = callPurpose;
return self();
}
}

67
src/main/java/cokr/xit/fims/payer/dao/PayerAddrMapper.java
Unescape Escape View File

@ -1,67 +0,0 @@
package cokr.xit.fims.payer.dao;
import java.util.List;
import org.egovframe.rte.psl.dataaccess.mapper.Mapper;
import cokr.xit.foundation.component.AbstractMapper;
import cokr.xit.foundation.data.DataObject;
import cokr.xit.fims.payer.Payer;
import cokr.xit.fims.payer.PayerQuery;
/** 납부자 주소 정보 DAO
*
* <p>상세 설명:
*
* <pre>
* ============ 변경 이력 ============
* 2024-05-23 JoJH 최초 작성
* ================================
* </pre>
*/
@Mapper("payerAddrMapper")
public interface PayerAddrMapper extends AbstractMapper {
/**지정한 조건에 따라 납부자 주소 목록을 조회하여 반환한다.<br />
* @param req 납부자 주소 조회 조건
* @return 납부자 주소 목록
*/
List<DataObject> selectPayerAddrList(PayerQuery req);
/**지정한 조건에 따라 납부자 주소 객체들을 반환한다.
* @param req 납부자 주소 조회 조건
* @return 납부자 주소 객체 목록
*/
List<Payer> selectPayerAddrs(PayerQuery req);
/**지정한 조건에 따라 납부자 주소 정보를 반환한다.
* @param req 부과제외 조회 조건
* @return 납부자 주소 정보
*/
List<Payer> selectPayerAddrInfo(PayerQuery req);
/**납부자 주소 정보를 등록한다.
* @param params 파라미터
* <ul><li>"payerAddr" - 납부자 주소</li>
* <li>"currentUser" - 현재 접속한 사용자</li>
* </ul>
* @return 저장된 정보수
*/
int insertPayerAddr(Payer payer);
/**납부자 주소 정보를 수정한다.
* @param params 파라미터
* <ul><li>"payerAddr" - 납부자 주소</li>
* <li>"currentUser" - 현재 접속한 사용자</li>
* </ul>
* @return 저장된 정보수
*/
int updatePayerAddr(Payer payer);
/**지정한 조건에 따라 납부자 주소 변경 이력 객체들을 반환한다.
* @param req 납부자 대장 조회 조건
* @return 납부자 대장 객체 목록
*/
List<DataObject> selectPayerAddrHstrys(PayerQuery req);
}

117
src/main/java/cokr/xit/fims/payer/dao/PayerMapper.java
Unescape Escape View File

@ -1,117 +0,0 @@
package cokr.xit.fims.payer.dao;
import java.util.List;
import java.util.Map;
import org.egovframe.rte.psl.dataaccess.mapper.Mapper;
import cokr.xit.fims.payer.Payer;
import cokr.xit.fims.payer.PayerQuery;
import cokr.xit.foundation.component.AbstractMapper;
import cokr.xit.foundation.data.DataObject;
/** 납부자 대장 정보 DAO
*
* <p>상세 설명:
*
* <pre>
* ============ 변경 이력 ============
* 2023-08-18 mjkhan 최초 작성
* ================================
* </pre>
*/
@Mapper("payerMapper")
public interface PayerMapper extends AbstractMapper {
/**지정한 조건에 따라 납부자 대장 목록을 조회하여 반환한다.<br />
* @param req 납부자 대장 조회 조건
* @return 납부자 대장 목록
*/
List<DataObject> selectPayerList(PayerQuery req);
/**지정한 조건에 따라 납부자 대장 객체들을 반환한다.
* @param req 납부자 대장 조회 조건
* @return 납부자 대장 객체 목록
*/
List<Payer> selectPayers(PayerQuery req);
/**납부자 대장 정보를 등록한다.
* @param payer 납부자 대장
* @return 저장된 정보수
*/
int insertPayer(Map<String, Object> params);
/**납부자 대장 정보를 등록한다.
* @param payer 납부자 대장
* @return 저장 여부
* <ul><li>저장됐으면 true</li>
* <li>그렇지 않으면 false</li>
* </ul>
*/
default boolean insert(Payer payer) {
return payer != null && insertPayer(params().set("payer", payer)) == 1;
}
/**납부자 대장 정보를 수정한다.
* @param params 파라미터
* <ul><li>"payer" - 납부자 대장</li>
* <li>"currentUser" - 현재 접속한 사용자</li>
* </ul>
* @return 저장된 정보수
*/
int updatePayer(Map<String, Object> params);
/**납부자 대장 정보를 수정한다.
* @param payer 납부자 대장
* @return 저장 여부
* <ul><li>저장됐으면 true</li>
* <li>그렇지 않으면 false</li>
* </ul>
*/
default boolean update(Payer payer) {
return payer != null && updatePayer(params().set("payer", payer)) == 1;
}
/**납부자 도로명 주소의 우편번호, 건물관리번호를 조회한다. 도로망 주소 연계 구현 시 이동
* @param params 파라미터
* <ul><li>roadNmCd - 도로명 코드</li>
* <li>udgdSeCd - 지하 구분코드</li>
* <li>bmno - 건물본번</li>
* <li>bsno - 건물부번</li>
* </ul>
* @return 납부자 도로명 주소의 우편번호, 건물관리번호
*/
DataObject selectAddrInfo(Map<String, Object> params);
/**지정한 조건에 따라 납부자 대장 객체의 마지막 1개를 반환한다.
* @param levyExclId 부과제외 ID
* @return 부과제외 대장 객체
*/
List<DataObject> selectCrdnPayers(PayerQuery req);
default DataObject selectPayerInfo(PayerQuery req) {
if (req.getOrderBy() == null) {
req.setOrderBy("P.RTPYR_ID DESC");
}
List<DataObject> crdnPayers = selectCrdnPayers(req);
return !crdnPayers.isEmpty() ? crdnPayers.get(0) : null;
}
/**지정한 조건에 따라 단속 정보를 반환한다.
* @param crdnId 단속 ID
* @return 단속, 부과제외 정보
*/
DataObject selectCrdn(PayerQuery req);
default DataObject selectCrdnInfo(String crdnId) {
return selectCrdn(new PayerQuery().setCrdnId(crdnId));
}
/**지정한 조건에 따라 납부자 변경 이력 객체들을 반환한다.
* @param req 납부자 대장 조회 조건
* @return 납부자 대장 객체 목록
*/
List<DataObject> selectPayerHstrys(PayerQuery req);
}

409
src/main/java/cokr/xit/fims/payer/service/bean/PayerBean.java
Unescape Escape View File

@ -1,409 +0,0 @@
package cokr.xit.fims.payer.service.bean;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
import javax.annotation.Resource;
import org.springframework.stereotype.Component;
import cokr.xit.fims.cmmn.CrdnPayerHstry;
import cokr.xit.fims.cmmn.CrdnSttsHstry;
import cokr.xit.fims.cmmn.service.bean.CrdnPayerHstryBean;
import cokr.xit.fims.cmmn.service.bean.CrdnSttsHstryBean;
import cokr.xit.fims.payer.Payer;
import cokr.xit.fims.payer.PayerQuery;
import cokr.xit.fims.payer.dao.PayerAddrMapper;
import cokr.xit.fims.payer.dao.PayerMapper;
import cokr.xit.foundation.component.AbstractBean;
import cokr.xit.foundation.data.DataObject;
import cokr.xit.interfaces.lvis.service.bean.VehicleInfoBean;
import cokr.xit.interfaces.lvis.service.reg.BasicInfoRequest;
import cokr.xit.interfaces.lvis.service.reg.BasicInfoResponse;
/**납부자 정보 관리 Bean
*
* <p>상세 설명:
*
* <pre>
* ============ 변경 이력 ============
* 2023-08-18 mjkhan 최초 작성
* ================================
* </pre>
*/
@Component("payerBean")
public class PayerBean extends AbstractBean {
/** 납부자 정보 DAO */
@Resource(name = "payerMapper")
private PayerMapper payerMapper;
/** 납부자 주소 정보 DAO */
@Resource(name = "payerAddrMapper")
private PayerAddrMapper payerAddrMapper;
/** 자동차 정보 DAO */
@Resource(name = "vehicleInfoBean")
private VehicleInfoBean vehicleInfoBean;
/** 단속 상태 이력 정보 Bean */
@Resource(name = "crdnSttsHstryBean")
private CrdnSttsHstryBean crdnSttsHstryBean;
/** 단속 납부자 이력 정보 Bean */
@Resource(name = "crdnPayerHstryBean")
private CrdnPayerHstryBean crdnPayerHstryBean;
/**지정한 조건에 따라 납부자 목록을 조회하여 반환한다.
* @param req 납부자 조회 조건
* @return 납부자 목록
*/
public List<DataObject> getPayerList(PayerQuery req) {
return payerMapper.selectPayerList(req);
}
/**지정한 조건에 따라 납부자 객체들을 반환한다.
* @param req 납부자 조회 조건
* @return 납부자 객체 목록
*/
public List<Payer> getPayers(PayerQuery req) {
return payerMapper.selectPayers(req);
}
/**지정한 조건에 따라 납부자 객체를 반환한다.
* @param req 납부자 조회 조건
* @return 납부자 객체
*/
public Payer getPayer(PayerQuery req) {
if (req.getOrderBy() == null) {
req.setOrderBy("P.RTPYR_ID DESC");
}
List<Payer> payers = getPayers(req);
return !payers.isEmpty() ? payers.get(0) : null;
}
/**지정한 조건에 따라 납부자 주소 객체들을 반환한다.
* @param req 납부자 조회 조건
* @return 납부자 주소 객체 목록
*/
public List<Payer> getPayerAddrs(PayerQuery req) {
return payerAddrMapper.selectPayerAddrs(req);
}
/**지정한 조건에 따라 납부자 주소 객체를 반환한다.
* @param req 납부자 조회 조건
* @return 납부자 주소 객체
*/
public Payer getPayerAddr(PayerQuery req) {
if (req.getOrderBy() == null) {
req.setOrderBy("PA.ADDR_SN DESC");
}
List<Payer> payers = getPayerAddrs(req);
return !payers.isEmpty() ? payers.get(0) : null;
}
public Payer getPayerAddrInfo(Payer payer) {
// PayerQuery
PayerQuery req = new PayerQuery();
req.setRtpyrSeCd(payer.getRtpyrSeCd()); // 납부자 구분 코드
req.setRtpyrNo(payer.getRtpyrNo()); // 납부자 번호
req.setAddrInptSeCd(payer.getAddrInptSeCd()); // 주소 입력 구분 코드
req.setRoadNmCd(payer.getRoadNmCd()); // 도로명 코드
req.setAddr(payer.getAddr()); // 주소
req.setDtlAddr(payer.getDtlAddr()); // 상세 주소
// 납부자 정보 조회
req.setOrderBy("P.RTPYR_ID DESC");
List<Payer> payers = getPayers(req);
// 납부자 ID 설정
payer.setRtpyrId(payers.get(0).getRtpyrId());
// 납부자 정보 및 주소 정보를 조회
req.setRtpyrId(payer.getRtpyrId());
req.setOrderBy("PA.ADDR_SN DESC");
payers = payerAddrMapper.selectPayerAddrInfo(req);
if (payers.isEmpty()) {
createPayerAddr(payer); // 주소 신규 등록
} else {
payer.setAddrSn(payers.get(0).getAddrSn()); // 주소 일련번호 설정
updatePayerAddr(payer); // 주소 수정
}
return payer;
}
/**납부자 정보를 등록한다.
* @param payer 납부자
* @return 저장 여부
* <ul><li>저장됐으면 true</li>
* <li>그렇지 않으면 false</li>
* </ul>
*/
public boolean create(Payer payer) {
// 납부자 등록
boolean rtnScs = payerMapper.insert(payer);
// 납부자 주소 등록
if (rtnScs) {
createPayerAddr(payer);
}
return rtnScs;
}
/**납부자 정보를 수정한다.
* @param payer 납부자
* @return 저장 여부
* <ul><li>저장됐으면 true</li>
* <li>그렇지 않으면 false</li>
* </ul>
*/
public boolean update(Payer payer) {
return payerMapper.update(payer);
}
/**납부자 주소 정보를 등록한다.
* @param payer 납부자
* @return 저장 여부
* <ul><li>저장됐으면 true</li>
* <li>그렇지 않으면 false</li>
* </ul>
*/
public boolean createPayerAddr(Payer payer) {
// 납부자 주소 등록
DataObject params = new DataObject()
.set("roadNmCd", payer.getRoadNmCd())
.set("udgdSeCd", payer.getUdgdSeCd())
.set("bmno", payer.getBmno())
.set("bsno", payer.getBsno());
DataObject info = payerMapper.selectAddrInfo(params);
if (info != null) {
payer.setAddrSeCd("02");
payer.setZip(info.string("ZIP"));
payer.setBldgMngNo(info.string("BLDG_MNG_NO"));
payer.setStdgCd(info.string("STDG_CD"));
payer.setDongCd(info.string("DONG_CD"));
}
return payerAddrMapper.insertPayerAddr(payer) == 1 ? true : false;
}
/**납부자 주소 정보를 수정한다.
* @param payer 납부자
* @return 저장 여부
* <ul><li>저장됐으면 true</li>
* <li>그렇지 않으면 false</li>
* </ul>
*/
public boolean updatePayerAddr(Payer payer) {
return payerAddrMapper.updatePayerAddr(payer) == 1 ? true : false;
}
public List<Payer> getVehicleOwners(List<BasicInfoRequest> reqs) {
Map<String, BasicInfoResponse> vehicleMap = vehicleInfoBean.getBasicInfo(reqs).stream()
.collect(Collectors.toMap(resp -> resp.getBasicInfo().getKey(), resp -> resp));
return vehicleMap.values().stream()
.map(resp -> getPayer(resp.getBasicInfo()))
.toList();
}
/**시군구 코드와 차량 기본정보에서 납부자 정보를 생성하거나, 등록정보에서 조회하여 반환한다.(차량번호 / 납부자 번호 / 시군구 기준)
* @param basicInfo 차량 기본정보
* @return 납부자 정보
*/
private Payer getPayer(BasicInfoResponse.BasicInfo basicInfo) {
Payer payer = new Payer();
payer.setSggCd(basicInfo.getSggCd());
payer.setVhrno(basicInfo.getVhrno());
payer.setRtpyrInptSeCd("02");
payer.setAddrInptSeCd("02");
payer.setRtpyrSeCd(
Map.of(
"11", "01",
"12", "02",
"13", "03",
"14", "04",
"15", "05"
).getOrDefault(basicInfo.getMber_se_code(), "05")
);
String rtpyrNo = basicInfo.getMber_se_no();
payer.setRtpyrNo(rtpyrNo);
payer.setRtpyrNm(basicInfo.getMber_nm());
payer.setRtpyrTelno(basicInfo.getTelno());
payer.setRoadNmCd(basicInfo.getUse_strnghld_road_nm_code());
String str = basicInfo.getUsgsrhld_undgrnd_buld_se_code();
if (str.equals(""))
payer.setUdgdSeCd("0");
else
payer.setUdgdSeCd(basicInfo.getUsgsrhld_undgrnd_buld_se_code());
str = basicInfo.getUse_strnghld_buld_main_no();
if (!isEmpty(str))
payer.setBmno(toInt(str));
str = basicInfo.getUse_strnghld_buld_sub_no();
if (!isEmpty(str))
payer.setBsno(toInt(str));
payer.setStdgCd(basicInfo.getUse_strnghld_legaldong_code());
payer.setDongCd(basicInfo.getUse_strnghld_adstrd_code());
payer.setMtnSeCd(basicInfo.getUse_strnghld_mntn());
str = basicInfo.getUse_strnghld_lnbr();
if (!isEmpty(str))
payer.setMno(toInt(str));
str = basicInfo.getUse_strnghld_ho();
if (!isEmpty(str))
payer.setSno(toInt(str));
payer.setAddr(basicInfo.getRoad_nm_adres());
payer.setDtlAddr(basicInfo.getUse_strnghld_adres_nm());
// 전체 주소
str = basicInfo.getUse_strnghld_adres_nm();
if (!isEmpty(str))
payer.setWholAddr(basicInfo.getRoad_nm_adres() + ", " + basicInfo.getUse_strnghld_adres_nm());
else
payer.setWholAddr(basicInfo.getRoad_nm_adres());
Payer result = create(payer) ? payer : getPayerAddrInfo(payer);
if (result != null)
result.setVehicleInfo(basicInfo);
return result;
}
/**지정한 부과제외 ID의 부과제외 정보를 반환한다.<br />
* @param req 납부자 조회 조건
* @return 납부자 정보
*/
public DataObject getPayerInfo(PayerQuery req) {
return payerMapper.selectPayerInfo(req);
}
/**지정한 단속 ID의 단속 정보를 반환한다.<br />
* @param req 납부자 조회 조건
* @return 단속 정보
*/
public DataObject getCrdnInfo(PayerQuery req) {
return payerMapper.selectCrdn(req); // 단속 조회
}
/**납부자 정보를 등록하고, 단속 정보에 납부자 ID를 변경한다.
* @param payer 납부자
* @return 저장 여부
* <ul><li>저장됐으면 true</li>
* <li>그렇지 않으면 false</li>
* </ul>
*/
public String createCrdnPayer(Payer payer) {
// 변수 선언
boolean rtnScs = false; // DB 처리 결과
String strTemp = "";
// 지하 구분 코드
strTemp = payer.getUdgdSeCd();
if (strTemp.equals("")) {
payer.setUdgdSeCd("0");
}
// 전체 주소
strTemp = payer.getWholAddr();
if (strTemp.equals("")) {
payer.setWholAddr(payer.getAddr() + ", " + payer.getDtlAddr());
}
// 단속 ID로 단속, 납부자, 주소 정보 조회
DataObject crdnPayerAddrInfo = payerMapper.selectCrdnInfo(payer.getCrdnId());
// 주민등록번호가 동일하다면..
if (crdnPayerAddrInfo.string("RTPYR_NO").equals(payer.getRtpyrNo())) {
// 납부자 대장(TB_PAYER)에 납부자 정보를 수정한다.
rtnScs = update(payer);
if (!rtnScs) {
throw new RuntimeException("납부자 정보 수정에 실패하였습니다."); // 예외를 발생시켜서 DB Rollback
}
// 주소가 변경되었는지 확인
if (crdnPayerAddrInfo.string("ADDR_INPT_SE_CD").equals(payer.getAddrInptSeCd())
&& crdnPayerAddrInfo.string("ZIP").equals(payer.getZip())
&& crdnPayerAddrInfo.string("ADDR").equals(payer.getAddr())
&& crdnPayerAddrInfo.string("DTL_ADDR").equals(payer.getDtlAddr())
&& crdnPayerAddrInfo.string("ROAD_NM_CD").equals(payer.getRoadNmCd())) {
// 주소 일련번호 설정
payer.setAddrSn(crdnPayerAddrInfo.string("ADDR_SN"));
} else {
Payer result = getPayerAddrInfo(payer);
CrdnPayerHstry crdnPayerAddrHstry = new CrdnPayerHstry();
crdnPayerAddrHstry.setCrdnId(payer.getCrdnId());
crdnPayerAddrHstry.setRtpyrId(result.getRtpyrId());
crdnPayerAddrHstry.setAddrSn(result.getAddrSn());
// 납부자 주소 변경 이력 생성
rtnScs = crdnPayerHstryBean.createHstryUpdateCrdnPayerAddr(crdnPayerAddrHstry);
if (!rtnScs) {
throw new RuntimeException("납부자 등록 실행중 단속 대장에 주소 일련번호 등록에 실패하였습니다."); // 예외를 발생시켜서 DB Rollback
}
}
} else {
Payer result = create(payer) ? payer : getPayerAddrInfo(payer);
// 단속 대장의 납부자ID 수정 및 단속 납부자 이력(TB_CRDN_PAYER_HSTRY) 대장에 등록한다.
CrdnPayerHstry crdnPayerHstry = new CrdnPayerHstry();
crdnPayerHstry.setCrdnId(payer.getCrdnId());
crdnPayerHstry.setRtpyrId(result.getRtpyrId());
crdnPayerHstry.setAddrSn(result.getAddrSn());
rtnScs = crdnPayerHstryBean.createHstryUpdateCrdnPayer(crdnPayerHstry);
if (!rtnScs) {
throw new RuntimeException("납부자 등록 실행중 단속 대장에 납부자 ID 등록에 실패하였습니다."); // 예외를 발생시켜서 DB Rollback
}
}
// 단속 상태 이력(TB_CRDN_STTS_HSTRY) 대장에 등록하고, 단속(TB_CRDN) 대장을 수정한다.
if (crdnPayerAddrInfo.number("CRDN_STTS_CD").intValue() < 21) { // 납부자 등록 완료
CrdnSttsHstry crdnSttsHstry = new CrdnSttsHstry();
crdnSttsHstry.setCrdnId(crdnPayerAddrInfo.string("CRDN_ID"));
crdnSttsHstry.setBfrSttsCd(crdnPayerAddrInfo.string("CRDN_STTS_CD"));
crdnSttsHstry.setBfrSttsChgDt(crdnPayerAddrInfo.string("CRDN_STTS_CHG_DT"));
crdnSttsHstry.setCrdnSttsCd("21");
rtnScs = crdnSttsHstryBean.createHstryUpdateCrdnSttsCd(crdnSttsHstry);
if (!rtnScs) {
throw new RuntimeException("납부자 등록 중 단속 대장의 단속상태 변경에 실패하였습니다."); // 예외를 발생시켜서 DB Rollback
}
}
return "[S] 작업이 정상 처리 되었습니다.";
}
/**지정한 조건에 따라 납부자 이력 목록을 조회하여 반환한다.
* @param req 납부자 조회 조건
* @return 납부자 변경 이력 목록
*/
public List<DataObject> getPayerHstrys(PayerQuery req) {
if (req.getOrderBy() == null) {
req.setOrderBy("CPH.REG_DT DESC");
}
return payerMapper.selectPayerHstrys(req);
}
/**지정한 조건에 따라 납부자 주소 이력 목록을 조회하여 반환한다.
* @param req 납부자 조회 조건
* @return 납부자 변경 이력 목록
*/
public List<DataObject> getPayerAddrHstrys(PayerQuery req) {
if (req.getOrderBy() == null) {
req.setOrderBy("CPAH.REG_DT DESC");
}
return payerAddrMapper.selectPayerAddrHstrys(req);
}
}

111
src/main/resources/sql/mapper/fims/cmmn/crdnPayerHstry-mapper.xml
Unescape Escape View File

@ -1,111 +0,0 @@
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="cokr.xit.fims.cmmn.dao.CrdnPayerHstryMapper">
<!-- 단속 납부자 이력 정보 매퍼
========== 변경 이력 ==========
2023-08-16 leebj 최초 작성
============================ -->
<resultMap id="crdnPayerHstryRow" type="cokr.xit.fims.cmmn.CrdnPayerHstry"> <!-- 단속 납부자 이력 -->
<result property="chgHstryId" column="CHG_HSTRY_ID" /><!-- 변경 이력 ID -->
<result property="crdnId" column="CRDN_ID" /> <!-- 단속 ID -->
<result property="rtpyrId" column="RTPYR_ID" /> <!-- 납부자 ID -->
<result property="addrSn" column="ADDR_SN" /> <!-- 주소 일련번호 -->
<result property="createdAt" column="REG_DT" /> <!-- 등록 일시 -->
<result property="createdBy" column="RGTR" /> <!-- 등록자 -->
</resultMap>
<sql id="select">
SELECT CPH.CHG_HSTRY_ID <!-- 변경 이력 ID -->
, CPH.CRDN_ID /* 단속 ID */
, CPH.RTPYR_ID /* 납부자 ID */
, CPH.REG_DT /* 등록 일시 */
, CPH.RGTR /* 등록자 */
, (SELECT USER_NM FROM TB_USER X WHERE X.USER_ID = CPH.RGTR) AS RGTR_NM /* 등록자 명 */
, PH.RTPYR_NO /* 납부자 번호 */
, PH.RTPYR_NM /* 납부자 명 */
, PH.ZIP /* 우편번호 */
, PH.WHOL_ADDR /* 전체 주소 */
, PH.REG_DT AS PH_REG_DT /* 등록 일시 */
, PH.RGTR AS PH_RGTR /* 등록자 */
, (SELECT USER_NM FROM TB_USER X WHERE X.USER_ID = PH.RGTR) AS PH_RGTR_NM /* 등록자 명 */
FROM TB_CRDN_PAYER_HSTRY CPH
INNER JOIN TB_PAYER_HSTRY PH ON (CPH.RTPYR_ID = PH.RTPYR_ID)
</sql>
<select id="selectCrdnPayerHstryList" parameterType="map" resultType="dataobject">/* 단속 납부자 이력 목록 조회(crdnPayerHstryMapper.selectCrdnPayerHstryList) */
<include refid="utility.paging-prefix" />
<include refid="select" />
<where>
</where>
<include refid="utility.orderBy" />
<include refid="utility.paging-suffix" />
</select>
<select id="selectCrdnPayerHstrys" parameterType="map" resultType="dataobject">/* 단속 납부자 이력 객체 가져오기(crdnPayerHstryMapper.selectCrdnPayerHstrys) */
<include refid="select" />
<where>
<if test="crdnId != null">
AND CPH.CRDN_ID = #{crdnId} /* 단속 ID */
</if>
<if test="rtpyrId != null">
AND CPH.RTPYR_ID = #{rtpyrId} /* 납부자 ID */
</if>
</where>
<include refid="utility.orderBy" />
</select>
<insert id="insertCrdnPayerHstry" parameterType="map">/* 단속 납부자 이력 등록(crdnPayerHstryMapper.insertCrdnPayerHstry) */
<selectKey resultType="string" keyProperty="crdnPayerHstry.chgHstryId" keyColumn="NEW_ID" order="BEFORE">
<include refid="numbering.keyByYear">
<property name="TABLE_NAME" value="TB_CRDN_PAYER_HSTRY" />
<property name="TABLE_KEY" value="CHG_HSTRY_ID" />
<property name="pad" value="20" />
</include>
</selectKey>
INSERT
INTO TB_CRDN_PAYER_HSTRY (
CHG_HSTRY_ID <!-- 변경 이력 ID -->
, CRDN_ID <!-- 단속 ID -->
, RTPYR_ID <!-- 납부자 ID -->
, REG_DT <!-- 등록 일시 -->
, RGTR <!-- 등록자 -->
)
VALUES (
#{crdnPayerHstry.chgHstryId} <!-- 변경 이력 ID -->
, #{crdnPayerHstry.crdnId} <!-- 단속 ID -->
, #{crdnPayerHstry.rtpyrId} <!-- 납부자 ID -->
, #{crdnPayerHstry.createdAt} <!-- 등록 일시 -->
, #{crdnPayerHstry.createdBy} <!-- 등록자 -->
)
</insert>
<insert id="insertCrdnPayerAddrHstry" parameterType="map">/* 단속 납부자 주소 이력 등록(crdnPayerHstryMapper.insertCrdnPayerAddrHstry) */
INSERT
INTO TB_CRDN_PAYER_ADDR_HSTRY (
CRDN_ID <!-- 단속 ID -->
, RTPYR_ID <!-- 납부자 ID -->
, ADDR_SN <!-- 주소 일련번호 -->
, REG_DT <!-- 등록 일시 -->
, RGTR <!-- 등록자 -->
)
VALUES (
#{crdnPayerAddrHstry.crdnId} <!-- 단속 ID -->
, #{crdnPayerAddrHstry.rtpyrId} <!-- 납부자 ID -->
, #{crdnPayerAddrHstry.addrSn} <!-- 주소 일련번호 -->
, #{crdnPayerAddrHstry.createdAt} <!-- 등록 일시 -->
, #{crdnPayerAddrHstry.createdBy} <!-- 등록자 -->
)
</insert>
<update id="updateCrdnRtpyrId" parameterType="map">/* 단속 납부자 수정(crdnPayerHstryMapper.updateCrdnPayer) */
UPDATE TB_CRDN
SET RTPYR_ID = #{crdnPayerHstry.rtpyrId} <!-- 납부자 ID -->
, ADDR_SN = #{crdnPayerHstry.addrSn} <!-- 주소 일련번호 -->
, MDFCN_DT = #{crdnPayerHstry.lastModified} <!-- 수정 일시 -->
, MDFR = #{crdnPayerHstry.modifiedBy} <!-- 수정자 -->
WHERE CRDN_ID = #{crdnPayerHstry.crdnId} <!-- 단속 ID -->
</update>
</mapper>

168
src/main/resources/sql/mapper/fims/cmmn/crdnSttsHstry-mapper.xml
Unescape Escape View File

@ -1,168 +0,0 @@
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="cokr.xit.fims.cmmn.dao.CrdnSttsHstryMapper">
<!-- 단속 상태 이력 정보 매퍼
========== 변경 이력 ==========
2023-07-19 JoJH 최초 작성
============================ -->
<resultMap id="crdnSttsHstryRow" type="cokr.xit.fims.cmmn.CrdnSttsHstry"><!-- 단속 상태 이력 -->
<result property="sttsHstryId" column="STTS_HSTRY_ID" /> <!-- 상태 이력 ID -->
<result property="crdnId" column="CRDN_ID" /> <!-- 단속 ID -->
<result property="bfrSttsCd" column="BFR_STTS_CD" /> <!-- 이전 상태 코드 -->
<result property="bfrSttsChgDt" column="BFR_STTS_CHG_DT" /> <!-- 이전 상태 변경 일시 -->
<result property="crdnSttsCd" column="CRDN_STTS_CD" /> <!-- 단속 상태 코드 -->
<result property="taskDtlId" column="TASK_DTL_ID" /> <!-- 업무 상세 ID -->
<result property="useYn" column="USE_YN" /> <!-- 사용 여부 -->
<result property="etcCn" column="ETC_CN" /> <!-- 기타 내용 -->
<result property="regDt" column="REG_DT" /> <!-- 등록 일시 -->
<result property="rgtr" column="RGTR" /> <!-- 등록자 -->
<result property="mdfcnDt" column="MDFCN_DT" /> <!-- 수정 일시 -->
<result property="mdfr" column="MDFR" /> <!-- 수정자 -->
</resultMap>
<sql id="select">
SELECT CSH.STTS_HSTRY_ID <!-- 상태 이력 ID -->
, CSH.CRDN_ID <!-- 단속 ID -->
, CSH.BFR_STTS_CD <!-- 이전 상태 코드 -->
, (SELECT GET_CODE_NM('FIM010', CSH.BFR_STTS_CD) FROM DUAL) AS BFR_STTS_NM <!-- 이전 상태 명 -->
, CSH.BFR_STTS_CHG_DT <!-- 이전 상태 변경 일시 -->
, CSH.CRDN_STTS_CD <!-- 단속 상태 코드 -->
, (SELECT GET_CODE_NM('FIM010', CSH.CRDN_STTS_CD) FROM DUAL) AS CRDN_STTS_NM <!-- 단속 상태 명 -->
, CSH.TASK_DTL_ID <!-- 업무 상세 ID -->
, CSH.USE_YN <!-- 사용 여부 -->
, (SELECT GET_CODE_NM('CMN003', CSH.USE_YN) FROM DUAL) AS USE_YN_NM <!-- 사용 여부 명 -->
, CSH.ETC_CN <!-- 기타 내용 -->
, CSH.REG_DT <!-- 등록 일시 -->
, CSH.RGTR <!-- 등록자 -->
, (SELECT USER_NM FROM TB_USER X WHERE X.USER_ID = CSH.RGTR) AS RGTR_NM <!-- 등록자 명 -->
, CSH.MDFCN_DT <!-- 수정 일시 -->
, CSH.MDFR <!-- 수정자 -->
, (SELECT USER_NM FROM TB_USER X WHERE X.USER_ID = CSH.MDFR) AS MDFR_NM <!-- 수정자 명 -->
FROM TB_CRDN_STTS_HSTRY CSH
LEFT OUTER JOIN TB_CRDN C ON (CSH.CRDN_ID = C.CRDN_ID)
</sql>
<select id="selectCrdnSttsHstryList" parameterType="map" resultType="dataobject">/* 단속 상태 이력 목록 조회(crdnSttsHstryMapper.selectCrdnSttsHstryList) */
<include refid="utility.paging-prefix" />
<include refid="select" />
<where>
<if test="sggCd != null">
AND C.SGG_CD = #{sggCd}
</if>
<if test="taskSeCd != null">
AND C.TASK_SE_CD = #{taskSeCd}
</if>
<if test="crdnId != null">
AND CSH.CRDN_ID = #{crdnId}
</if>
<if test="useYn != null">
AND CSH.USE_YN = #{useYn}
</if>
<if test="schDateOpt == 'regDt'">
<if test="schDateFrom != null">AND SUBSTR(CSH.REG_DT,1,8) <![CDATA[ >= ]]> #{schDateFrom} </if>
<if test="schDateTo != null">AND SUBSTR(CSH.REG_DT,1,8) <![CDATA[ <= ]]> #{schDateTo} </if>
</if>
</where>
<include refid="utility.orderBy" />
<include refid="utility.paging-suffix" />
</select>
<select id="selectCrdnSttsHstrys" parameterType="map" resultType="dataobject">/* 단속 상태 이력 객체 가져오기(crdnSttsHstryMapper.selectCrdnSttsHstrys) */
<include refid="select" />
<where>
<if test="sttsHstryId != null">
AND CSH.STTS_HSTRY_ID = #{sttsHstryId}
</if>
<if test="crdnId != null">
AND CSH.CRDN_ID = #{crdnId}
</if>
<if test="crdnSttsCd != null">
AND CSH.CRDN_STTS_CD = #{crdnSttsCd}
</if>
<if test="useYn != null">
AND CSH.USE_YN = #{useYn}
</if>
</where>
<include refid="utility.sortBy" />
</select>
<insert id="insertCrdnSttsHstry" parameterType="cokr.xit.fims.cmmn.CrdnSttsHstry">/* 단속 상태 이력 등록(crdnSttsHstryMapper.insertCrdnSttsHstry) */
<selectKey resultType="string" keyProperty="sttsHstryId" keyColumn="NEW_ID" order="BEFORE">
<include refid="numbering.keyByYear">
<property name="TABLE_NAME" value="TB_CRDN_STTS_HSTRY" />
<property name="TABLE_KEY" value="STTS_HSTRY_ID" />
<property name="pad" value="20" />
</include>
</selectKey>
INSERT
INTO TB_CRDN_STTS_HSTRY (
STTS_HSTRY_ID <!-- 상태 이력 ID -->
, CRDN_ID <!-- 단속 ID -->
, BFR_STTS_CD <!-- 이전 상태 코드 -->
, BFR_STTS_CHG_DT <!-- 이전 상태 변경 일시 -->
, CRDN_STTS_CD <!-- 단속 상태 코드 -->
, TASK_DTL_ID <!-- 업무 상세 ID -->
, ETC_CN <!-- 기타 내용 -->
, USE_YN <!-- 사용 여부 -->
, REG_DT <!-- 등록 일시 -->
, RGTR <!-- 등록자 -->
, MDFCN_DT <!-- 수정 일시 -->
, MDFR <!-- 수정자 -->
)
VALUES (
#{sttsHstryId} <!-- 상태 이력 ID -->
, #{crdnId} <!-- 단속 ID -->
, #{bfrSttsCd} <!-- 이전 상태 코드 -->
, #{bfrSttsChgDt} <!-- 이전 상태 변경 일시 -->
, #{crdnSttsCd} <!-- 단속 상태 코드 -->
, #{taskDtlId} <!-- 업무 상세 ID -->
, #{etcCn} <!-- 기타 내용 -->
, #{useYn} <!-- 사용 여부 -->
, <include refid="utility.now" /> <!-- 등록 일시 -->
, #{createdBy} <!-- 등록자 -->
, <include refid="utility.now" /> <!-- 수정 일시 -->
, #{modifiedBy} <!-- 수정자 -->
)
</insert>
<update id="updateCrdnSttsHstry" parameterType="cokr.xit.fims.cmmn.CrdnSttsHstry">/* 단속 상태 이력 수정(crdnSttsHstryMapper.updateCrdnSttsHstry) */
UPDATE TB_CRDN_STTS_HSTRY
SET USE_YN = #{useYn} <!-- 사용 여부 -->
, MDFCN_DT = <include refid="utility.now" /> <!-- 수정 일시 -->
, MDFR = #{modifiedBy} <!-- 수정자 -->
WHERE STTS_HSTRY_ID = #{sttsHstryId} <!-- 상태 이력 ID -->
</update>
<update id="deleteCrdnSttsHstry" parameterType="cokr.xit.fims.cmmn.CrdnSttsHstry">/* 단속 상태 이력 삭제(crdnSttsHstryMapper.deleteCrdnSttsHstry) */
UPDATE TB_CRDN_STTS_HSTRY
SET USE_YN = 'N' <!-- 사용 여부 -->
, MDFCN_DT = <include refid="utility.now" /> <!-- 수정 일시 -->
, MDFR = #{modifiedBy} <!-- 수정자 -->
WHERE USE_YN = 'Y' <!-- 사용 여부 -->
<if test="sttsHstryId != null">
AND STTS_HSTRY_ID = #{sttsHstryId}
</if>
<if test="crdnId != null">
AND CRDN_ID = #{crdnId}
</if>
</update>
<update id="updateCrdnSttsCd" parameterType="cokr.xit.fims.cmmn.CrdnSttsHstry">/* 단속 대장 수정(crdnSttsHstryMapper.updateCrdnSttsCd) */
UPDATE TB_CRDN
SET CRDN_STTS_CD = #{crdnSttsCd} <!-- 단속 상태 코드 -->
<choose>
<when test="crdnSttsChgDt != null">
, CRDN_STTS_CHG_DT = #{crdnSttsChgDt} <!-- 단속 상태 변경 일시 -->
</when>
<otherwise>
, CRDN_STTS_CHG_DT = <include refid="utility.now" /> <!-- 단속 상태 변경 일시 -->
</otherwise>
</choose>
, MDFCN_DT = <include refid="utility.now" /> <!-- 수정 일시 -->
, MDFR = #{modifiedBy} <!-- 수정자 -->
WHERE CRDN_ID = #{crdnId} <!-- 단속 ID -->
</update>
</mapper>

294
src/main/resources/sql/mapper/fims/payer-mapper.xml
Unescape Escape View File

@ -1,294 +0,0 @@
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="cokr.xit.fims.payer.dao.PayerMapper">
<!-- 납부자 대장 정보 매퍼
========== 변경 이력 ==========
2024-05-23 JoJH 납부자, 주소 테이블 분리
2023-08-18 mjkhan 최초 작성
============================ -->
<resultMap id="payerRow" type="cokr.xit.fims.payer.Payer"> <!-- 납부자 대장 -->
<result property="rtpyrId" column="RTPYR_ID" /> <!-- 납부자 ID -->
<result property="sggCd" column="SGG_CD" /> <!-- 시군구 코드 -->
<result property="rtpyrInptSeCd" column="RTPYR_INPT_SE_CD" /> <!-- 납부자 입력 구분 코드 -->
<result property="rtpyrSeCd" column="RTPYR_SE_CD" /> <!-- 납부자 구분 코드 -->
<result property="rtpyrNo" column="RTPYR_NO" /> <!-- 납부자 번호 -->
<result property="rtpyrNm" column="RTPYR_NM" /> <!-- 납부자 명 -->
<result property="rtpyrTelno" column="RTPYR_TELNO" /> <!-- 납부자 전화번호 -->
<result property="rtpyrMblTelno" column="RTPYR_MBL_TELNO" /> <!-- 납부자 휴대 전화번호 -->
<result property="rtpyrEml" column="RTPYR_EML" /> <!-- 납부자 이메일 -->
<result property="rtpyrBrdt" column="RTPYR_BRDT" /> <!-- 납부자 생년월일 -->
<result property="rtpyrSttsCd" column="RTPYR_STTS_CD" /> <!-- 납부자 상태 코드 -->
<result property="addrSn" column="ADDR_SN" /> <!-- 주소 일련번호 -->
<result property="addrInptSeCd" column="ADDR_INPT_SE_CD" /> <!-- 주소 입력 구분 코드 -->
<result property="addrSeCd" column="ADDR_SE_CD" /> <!-- 주소 구분 코드 -->
<result property="zip" column="ZIP" /> <!-- 우편번호 -->
<result property="roadNmCd" column="ROAD_NM_CD" /> <!-- 도로 명 코드 -->
<result property="udgdSeCd" column="UDGD_SE_CD" /> <!-- 지하 구분 코드 -->
<result property="bmno" column="BMNO" /> <!-- 건물본번 -->
<result property="bsno" column="BSNO" /> <!-- 건물부번 -->
<result property="bldgMngNo" column="BLDG_MNG_NO" /> <!-- 건물 관리 번호 -->
<result property="stdgCd" column="STDG_CD" /> <!-- 법정동 코드 -->
<result property="dongCd" column="DONG_CD" /> <!-- 행정동 코드 -->
<result property="mtnSeCd" column="MTN_SE_CD" /> <!-- 산 구분 코드 -->
<result property="mno" column="MNO" /> <!-- 본번 -->
<result property="sno" column="SNO" /> <!-- 부번 -->
<result property="spclDong" column="SPCL_DONG" /> <!-- 특수 동 -->
<result property="spclHo" column="SPCL_HO" /> <!-- 특수 호 -->
<result property="spclAddr" column="SPCL_ADDR" /> <!-- 특수 주소 -->
<result property="addr" column="ADDR" /> <!-- 주소 -->
<result property="dtlAddr" column="DTL_ADDR" /> <!-- 상세 주소 -->
<result property="wholAddr" column="WHOL_ADDR" /> <!-- 전체 주소 -->
<result property="createdAt" column="REG_DT" /> <!-- 등록 일시 -->
<result property="createdBy" column="RGTR" /> <!-- 등록자 -->
<result property="lastModified" column="MDFCN_DT" /> <!-- 수정 일시 -->
<result property="modifiedBy" column="MDFR" /> <!-- 수정자 -->
</resultMap>
<sql id="select">
SELECT P.RTPYR_ID <!-- 납부자 ID -->
, P.SGG_CD <!-- 시군구 코드 -->
, P.RTPYR_INPT_SE_CD <!-- 납부자 입력 구분 코드 -->
, P.RTPYR_SE_CD <!-- 납부자 구분 코드 -->
, P.RTPYR_NO <!-- 납부자 번호 -->
, P.RTPYR_NM <!-- 납부자 명 -->
, P.RTPYR_TELNO <!-- 납부자 전화번호 -->
, P.RTPYR_MBL_TELNO <!-- 납부자 휴대 전화번호 -->
, P.RTPYR_EML <!-- 납부자 이메일 -->
, P.RTPYR_BRDT <!-- 납부자 생년월일 -->
, P.RTPYR_STTS_CD <!-- 납부자 상태 코드 -->
, P.REG_DT <!-- 등록 일시 -->
, P.RGTR <!-- 등록자 -->
, P.MDFCN_DT <!-- 수정 일시 -->
, P.MDFR <!-- 수정자 -->
FROM TB_PAYER P
</sql>
<select id="selectPayerList" parameterType="map" resultType="dataobject">/* 납부자 대장 목록 조회(payerMapper.selectPayerList) */
<include refid="utility.paging-prefix" />
<include refid="select" />
<where>
AND P.RTPYR_ID IN (<foreach collection="rtpyrIds" item="rtpyrId" separator=",">#{rtpyrId}</foreach>)
</where>
<include refid="utility.orderBy" />
<include refid="utility.paging-suffix" />
</select>
<select id="selectPayers" parameterType="map" resultMap="payerRow">/* 납부자 대장 객체 가져오기(payerMapper.selectPayers) */
<include refid="select" />
<where>
<choose>
<when test="rtpyrIds != null">
AND P.RTPYR_ID IN (<foreach collection="rtpyrIds" item="rtpyrId" separator=",">#{rtpyrId}</foreach>)
</when>
<when test="rtpyrId != null">
AND P.RTPYR_ID = #{rtpyrId} <!-- 납부자 ID -->
</when>
<otherwise>
AND P.RTPYR_SE_CD = #{rtpyrSeCd} <!-- 납부자 구분 코드 -->
AND P.RTPYR_NO = #{rtpyrNo} <!-- 납부자 번호 -->
</otherwise>
</choose>
</where>
<include refid="utility.orderBy" />
</select>
<insert id="insertPayer" parameterType="map">/* 납부자 대장 등록(payerMapper.insertPayer) */
<selectKey resultType="string" keyProperty="payer.rtpyrId" keyColumn="NEW_ID" order="BEFORE">
<include refid="numbering.keyByYear">
<property name="TABLE_NAME" value="TB_PAYER" />
<property name="TABLE_KEY" value="RTPYR_ID" />
<property name="pad" value="20" />
</include>
</selectKey>
INSERT
INTO TB_PAYER (
RTPYR_ID <!-- 납부자 ID -->
, SGG_CD <!-- 시군구 코드 -->
, RTPYR_INPT_SE_CD <!-- 납부자 입력 구분 코드 -->
, RTPYR_SE_CD <!-- 납부자 구분 코드 -->
, RTPYR_NO <!-- 납부자 번호 -->
, RTPYR_NM <!-- 납부자 명 -->
, RTPYR_TELNO <!-- 납부자 전화번호 -->
, RTPYR_MBL_TELNO <!-- 납부자 휴대 전화번호 -->
, RTPYR_EML <!-- 납부자 이메일 -->
, RTPYR_BRDT <!-- 납부자 생년월일 -->
, RTPYR_STTS_CD <!-- 납부자 상태 코드 -->
, REG_DT <!-- 등록 일시 -->
, RGTR <!-- 등록자 -->
, MDFCN_DT <!-- 수정 일시 -->
, MDFR <!-- 수정자 -->
)
SELECT #{payer.rtpyrId} <!-- 납부자 ID -->
, #{payer.sggCd} <!-- 시군구 코드 -->
, #{payer.rtpyrInptSeCd} <!-- 납부자 입력 구분 코드 -->
, #{payer.rtpyrSeCd} <!-- 납부자 구분 코드 -->
, #{payer.rtpyrNo} <!-- 납부자 번호 -->
, #{payer.rtpyrNm} <!-- 납부자 명 -->
, #{payer.rtpyrTelno} <!-- 납부자 전화번호 -->
, #{payer.rtpyrMblTelno} <!-- 납부자 휴대 전화번호 -->
, #{payer.rtpyrEml} <!-- 납부자 이메일 -->
, #{payer.rtpyrBrdt} <!-- 납부자 생년월일 -->
, #{payer.rtpyrSttsCd} <!-- 납부자 상태 코드 -->
, <include refid="utility.now" /> <!-- 등록 일시 -->
, #{payer.createdBy} <!-- 등록자 -->
, <include refid="utility.now" /> <!-- 수정 일시 -->
, #{payer.modifiedBy} <!-- 수정자 -->
FROM DUAL
WHERE NOT EXISTS (
SELECT *
FROM TB_PAYER B
WHERE RTPYR_NO = #{payer.rtpyrNo}
AND RTPYR_SE_CD = #{payer.rtpyrSeCd}
AND SGG_CD = #{payer.sggCd}
)
</insert>
<update id="updatePayer" parameterType="cokr.xit.fims.payer.Payer">/* 납부자 대장 수정(payerMapper.updatePayer) */
UPDATE TB_PAYER
SET RTPYR_INPT_SE_CD = #{payer.rtpyrInptSeCd} <!-- 납부자 입력 구분 코드 -->
, RTPYR_SE_CD = #{payer.rtpyrSeCd} <!-- 납부자 구분 코드 -->
, RTPYR_NM = #{payer.rtpyrNm} <!-- 납부자 명 -->
, RTPYR_TELNO = #{payer.rtpyrTelno} <!-- 납부자 전화번호 -->
, RTPYR_MBL_TELNO = #{payer.rtpyrMblTelno} <!-- 납부자 휴대 전화번호 -->
, RTPYR_EML = #{payer.rtpyrEml} <!-- 납부자 이메일 -->
, RTPYR_STTS_CD = #{payer.rtpyrSttsCd} <!-- 납부자 상태 코드 -->
, MDFCN_DT = <include refid="utility.now" /> <!-- 수정 일시 -->
, MDFR = #{payer.modifiedBy} <!-- 수정자 -->
WHERE RTPYR_ID = #{payer.rtpyrId}
</update>
<select id="selectAddrInfo" parameterType="map" resultType="dataobject">/* 우편번호, 건물관리번호 조회(payerMapper.selectAddrInfo) */
SELECT ZIP
, BLDG_MNG_NO
, STDG_CD
, DONG_CD
, CTPV_NM
, SGG_NM
, STDG_NM
, STDG_LI_NM
, ROAD_NM
FROM TB_ROAD_ADDR
WHERE ROAD_NM_CD = #{roadNmCd}
AND UDGD_SE_CD = #{udgdSeCd}
AND BMNO = #{bmno}
AND BSNO = #{bsno}
LIMIT 1
</select>
<sql id="selectCrdnPayer">
SELECT C.CRDN_ID <!-- 단속 ID -->
, C.SGG_CD <!-- 시군구 코드 -->
, C.TASK_SE_CD <!-- 업무 구분 코드 -->
, C.CRDN_YMD <!-- 단속 일자 -->
, (CONCAT(C.CRDN_YMD, C.CRDN_TM)) AS CRDN_YMD_TM <!-- 단속 일시 -->
, C.VHRNO <!-- 차량번호 -->
, C.CRDN_STTS_CD <!-- 단속 상태 코드 -->
, (SELECT GET_CODE_NM('FIM010', C.CRDN_STTS_CD) FROM DUAL) AS CRDN_STTS_NM <!-- 단속 상태 명 -->
, P.RTPYR_ID <!-- 납부자 ID -->
, P.RTPYR_INPT_SE_CD <!-- 납부자 입력 구분 코드 -->
, (SELECT GET_CODE_NM('FIM015', P.RTPYR_INPT_SE_CD) FROM DUAL) AS RTPYR_INPT_SE_NM <!-- 납부자 입력 구분 명 -->
, P.RTPYR_SE_CD <!-- 납부자 구분 코드 -->
, (SELECT GET_CODE_NM('FIM011', P.RTPYR_SE_CD) FROM DUAL) AS RTPYR_SE_NM <!-- 납부자 구분 명 -->
, P.RTPYR_NO <!-- 납부자 번호 -->
, P.RTPYR_NM <!-- 납부자 명 -->
, P.RTPYR_TELNO <!-- 납부자 전화번호 -->
, P.RTPYR_MBL_TELNO <!-- 납부자 휴대 전화번호 -->
, P.RTPYR_EML <!-- 납부자 이메일 -->
, P.RTPYR_BRDT <!-- 납부자 생년월일 -->
, P.RTPYR_STTS_CD <!-- 납부자 상태 코드 -->
, (SELECT GET_CODE_NM('FIM014', P.RTPYR_STTS_CD) FROM DUAL) AS RTPYR_STTS_NM <!-- 납부자 상태 명 -->
, P.REG_DT <!-- 등록 일시 -->
, P.RGTR <!-- 등록자 -->
, P.MDFCN_DT <!-- 수정 일시 -->
, P.MDFR <!-- 수정자 -->
, PA.ADDR_SN <!-- 주소 일련번호' -->
, PA.ADDR_SE_CD <!-- 주소 구분 코드 -->
, PA.ADDR_INPT_SE_CD <!-- 주소 입력 구분 코드 -->
, PA.ZIP <!-- 우편번호 -->
, PA.ROAD_NM_CD <!-- 도로 명 코드 -->
, PA.UDGD_SE_CD <!-- 지하 구분 코드 -->
, PA.BMNO <!-- 건물본번 -->
, PA.BSNO <!-- 건물부번 -->
, PA.BLDG_MNG_NO <!-- 건물 관리 번호 -->
, PA.STDG_CD <!-- 법정동 코드 -->
, PA.DONG_CD <!-- 행정동 코드 -->
, PA.MTN_SE_CD <!-- 산 구분 코드 -->
, PA.MNO <!-- 본번 -->
, PA.SNO <!-- 부번 -->
, PA.SPCL_DONG <!-- 특수 동 -->
, PA.SPCL_HO <!-- 특수 호 -->
, PA.SPCL_ADDR <!-- 특수 주소 -->
, PA.ADDR <!-- 주소 -->
, PA.DTL_ADDR <!-- 상세 주소 -->
, PA.WHOL_ADDR <!-- 전체 주소 -->
FROM TB_CRDN C
LEFT OUTER JOIN TB_PAYER P ON (C.RTPYR_ID = P.RTPYR_ID)
LEFT OUTER JOIN TB_PAYER_ADDR PA ON (C.RTPYR_ID = PA.RTPYR_ID AND C.ADDR_SN = PA.ADDR_SN)
</sql>
<select id="selectCrdnPayers" parameterType="map" resultType="dataobject">/* 납부자 대장 객체 가져오기(payerMapper.selectCrdnPayers) */
<include refid="selectCrdnPayer" />
<where>
<if test="rtpyrId != null">
AND P.RTPYR_ID = #{rtpyrId} <!-- 납부자 ID -->
</if>
<if test="crdnId != null">
AND C.CRDN_ID = #{crdnId} <!-- 단속 ID -->
AND C.DEL_YN = 'N'
</if>
</where>
<include refid="utility.orderBy" />
</select>
<select id="selectCrdn" parameterType="map" resultType="dataobject">/* 단속 대장 객체 가져오기(payerMapper.selectCrdn) */
SELECT C.CRDN_ID <!-- 단속 ID -->
, C.SGG_CD <!-- 시군구 코드 -->
, C.TASK_SE_CD <!-- 업무 구분 코드 -->
, C.RTPYR_ID <!-- 납부자 ID -->
, C.ADDR_SN <!-- 주소 일련번호 -->
, C.CRDN_YMD <!-- 단속 일자 -->
, (CONCAT(C.CRDN_YMD, C.CRDN_TM)) AS CRDN_YMD_TM <!-- 단속 일시 -->
, C.VHRNO <!-- 차량번호 -->
, C.CRDN_STTS_CD <!-- 단속 상태 코드 -->
, (SELECT GET_CODE_NM('FIM010', C.CRDN_STTS_CD) FROM DUAL) AS CRDN_STTS_NM <!-- 단속 상태 명 -->
, P.RTPYR_NO <!-- 납부자 번호 -->
, PA.ADDR_INPT_SE_CD <!-- 주소 입력 구분 코드 -->
, PA.ZIP <!-- 우편번호 -->
, PA.ADDR <!-- 주소 -->
, PA.DTL_ADDR <!-- 상세 주소 -->
, PA.ROAD_NM_CD <!-- 도로 명 코드 -->
FROM TB_CRDN C
LEFT OUTER JOIN TB_PAYER P ON (C.RTPYR_ID = P.RTPYR_ID)
LEFT OUTER JOIN TB_PAYER_ADDR PA ON (C.RTPYR_ID = PA.RTPYR_ID AND C.ADDR_SN = PA.ADDR_SN)
WHERE C.CRDN_ID = #{crdnId} <!-- 단속 ID -->
AND C.DEL_YN = 'N'
</select>
<sql id="selectPayerHstry">
SELECT CPH.CHG_HSTRY_ID <!-- 변경 이력 ID -->
, CPH.CRDN_ID <!-- 단속 ID -->
, CPH.RTPYR_ID <!-- 납부자 ID -->
, CPH.REG_DT <!-- 등록 일시 -->
, (SELECT USER_NM FROM TB_USER X WHERE X.USER_ID = CPH.RGTR) AS RGTR_NM <!-- 등록자 명 -->
, (SELECT GET_CODE_NM('FIM015', P.RTPYR_INPT_SE_CD) FROM DUAL) AS RTPYR_INPT_SE_NM <!-- 납부자 입력 구분 명 -->
, (SELECT GET_CODE_NM('FIM011', P.RTPYR_SE_CD) FROM DUAL) AS RTPYR_SE_NM <!-- 납부자 구분 명 -->
, P.RTPYR_NO <!-- 납부자 번호 -->
, P.RTPYR_NM <!-- 납부자 명 -->
, P.RTPYR_TELNO <!-- 납부자 전화번호 -->
, P.RTPYR_MBL_TELNO <!-- 납부자 휴대 전화번호 -->
, P.RTPYR_EML <!-- 납부자 이메일 -->
, P.RTPYR_BRDT <!-- 납부자 생년월일 -->
, P.RTPYR_STTS_CD <!-- 납부자 상태 코드 -->
FROM TB_CRDN_PAYER_HSTRY CPH
INNER JOIN TB_PAYER P ON (CPH.RTPYR_ID = P.RTPYR_ID)
</sql>
<select id="selectPayerHstrys" parameterType="map" resultType="dataobject">/* 납부자 이력 대장 객체 가져오기(payerMapper.selectPayerHstrys) */
<include refid="selectPayerHstry" />
WHERE CPH.CRDN_ID = #{crdnId} <!-- 단속 ID -->
<include refid="utility.orderBy" />
</select>
</mapper>

251
src/main/resources/sql/mapper/fims/payerAddr-mapper.xml
Unescape Escape View File

@ -1,251 +0,0 @@
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="cokr.xit.fims.payer.dao.PayerAddrMapper">
<!-- 납부자 주소 정보 매퍼
========== 변경 이력 ==========
2024-05-23 JoJH 최초 작성
============================ -->
<resultMap id="payerAddrRow" type="cokr.xit.fims.payer.Payer"> <!-- 납부자 주소 -->
<result property="rtpyrId" column="RTPYR_ID" /> <!-- 납부자 ID -->
<result property="addrSn" column="ADDR_SN" /> <!-- 주소 일련번호 -->
<result property="addrInptSeCd" column="ADDR_INPT_SE_CD" /> <!-- 주소 입력 구분 코드 -->
<result property="addrSeCd" column="ADDR_SE_CD" /> <!-- 주소 구분 코드 -->
<result property="zip" column="ZIP" /> <!-- 우편번호 -->
<result property="addr" column="ADDR" /> <!-- 주소 -->
<result property="dtlAddr" column="DTL_ADDR" /> <!-- 상세 주소 -->
<result property="roadNmCd" column="ROAD_NM_CD" /> <!-- 도로 명 코드 -->
<result property="udgdSeCd" column="UDGD_SE_CD" /> <!-- 지하 구분 코드 -->
<result property="bmno" column="BMNO" /> <!-- 건물본번 -->
<result property="bsno" column="BSNO" /> <!-- 건물부번 -->
<result property="bldgMngNo" column="BLDG_MNG_NO" /> <!-- 건물 관리 번호 -->
<result property="stdgCd" column="STDG_CD" /> <!-- 법정동 코드 -->
<result property="dongCd" column="DONG_CD" /> <!-- 행정동 코드 -->
<result property="mtnSeCd" column="MTN_SE_CD" /> <!-- 산 구분 코드 -->
<result property="mno" column="MNO" /> <!-- 본번 -->
<result property="sno" column="SNO" /> <!-- 부번 -->
<result property="spclDong" column="SPCL_DONG" /> <!-- 특수 동 -->
<result property="spclHo" column="SPCL_HO" /> <!-- 특수 호 -->
<result property="spclAddr" column="SPCL_ADDR" /> <!-- 특수 주소 -->
<result property="wholAddr" column="WHOL_ADDR" /> <!-- 전체 주소 -->
<result property="createdAt" column="REG_DT" /> <!-- 등록 일시 -->
<result property="createdBy" column="RGTR" /> <!-- 등록자 -->
<result property="lastModified" column="MDFCN_DT" /> <!-- 수정 일시 -->
<result property="modifiedBy" column="MDFR" /> <!-- 수정자 -->
</resultMap>
<sql id="select">
SELECT PA.RTPYR_ID <!-- 납부자 ID -->
, PA.ADDR_SN <!-- 주소 일련번호 -->
, PA.ADDR_INPT_SE_CD <!-- 주소 입력 구분 코드 -->
, PA.ADDR_SE_CD <!-- 주소 구분 코드 -->
, PA.ZIP <!-- 우편번호 -->
, PA.ADDR <!-- 주소 -->
, PA.DTL_ADDR <!-- 상세 주소 -->
, PA.ROAD_NM_CD <!-- 도로 명 코드 -->
, PA.UDGD_SE_CD <!-- 지하 구분 코드 -->
, PA.BMNO <!-- 건물본번 -->
, PA.BSNO <!-- 건물부번 -->
, PA.BLDG_MNG_NO <!-- 건물 관리 번호 -->
, PA.STDG_CD <!-- 법정동 코드 -->
, PA.DONG_CD <!-- 행정동 코드 -->
, PA.MTN_SE_CD <!-- 산 구분 코드 -->
, PA.MNO <!-- 본번 -->
, PA.SNO <!-- 부번 -->
, PA.SPCL_DONG <!-- 특수 동 -->
, PA.SPCL_HO <!-- 특수 호 -->
, PA.SPCL_ADDR <!-- 특수 주소 -->
, PA.WHOL_ADDR <!-- 전체 주소 -->
FROM TB_PAYER_ADDR PA
</sql>
<select id="selectPayerAddrList" parameterType="map" resultType="dataobject">/* 납부자 주소 목록 조회(payerAddrMapper.selectPayerAddrList) */
<include refid="utility.paging-prefix" />
<include refid="select" />
WHERE PA.RTPYR_ID = #{rtpyrId}
<if test="addrSn != null">
AND PA.ADDR_SN = #{addrSn}
</if>
<include refid="utility.orderBy" />
<include refid="utility.paging-suffix" />
</select>
<select id="selectPayerAddrs" parameterType="map" resultMap="payerAddrRow">/* 납부자 주소 객체 가져오기(payerAddrMapper.selectPayerAddrs) */
<include refid="select" />
WHERE PA.RTPYR_ID = #{rtpyrId}
<if test="addrSn != null">
AND PA.ADDR_SN = #{addrSn}
</if>
<include refid="utility.orderBy" />
</select>
<select id="selectPayerAddrInfo" parameterType="map" resultMap="payerAddrRow">/* 납부자 주소 객체 가져오기(payerAddrMapper.selectPayerAddrInfo) */
SELECT P.RTPYR_ID <!-- 납부자 ID -->
, P.SGG_CD <!-- 시군구 코드 -->
, P.RTPYR_INPT_SE_CD <!-- 납부자 입력 구분 코드 -->
, P.RTPYR_SE_CD <!-- 납부자 구분 코드 -->
, P.RTPYR_NO <!-- 납부자 번호 -->
, P.RTPYR_NM <!-- 납부자 명 -->
, P.RTPYR_TELNO <!-- 납부자 전화번호 -->
, P.RTPYR_MBL_TELNO <!-- 납부자 휴대 전화번호 -->
, P.RTPYR_EML <!-- 납부자 이메일 -->
, P.RTPYR_BRDT <!-- 납부자 생년월일 -->
, P.RTPYR_STTS_CD <!-- 납부자 상태 코드 -->
, P.REG_DT <!-- 등록 일시 -->
, P.RGTR <!-- 등록자 -->
, P.MDFCN_DT <!-- 수정 일시 -->
, P.MDFR <!-- 수정자 -->
, PA.ADDR_SN <!-- 주소 일련번호 -->
, PA.ADDR_INPT_SE_CD <!-- 주소 입력 구분 코드 -->
, PA.ADDR_SE_CD <!-- 주소 구분 코드 -->
, PA.ZIP <!-- 우편번호 -->
, PA.ADDR <!-- 주소 -->
, PA.DTL_ADDR <!-- 상세 주소 -->
, PA.ROAD_NM_CD <!-- 도로 명 코드 -->
, PA.UDGD_SE_CD <!-- 지하 구분 코드 -->
, PA.BMNO <!-- 건물본번 -->
, PA.BSNO <!-- 건물부번 -->
, PA.BLDG_MNG_NO <!-- 건물 관리 번호 -->
, PA.STDG_CD <!-- 법정동 코드 -->
, PA.DONG_CD <!-- 행정동 코드 -->
, PA.MTN_SE_CD <!-- 산 구분 코드 -->
, PA.MNO <!-- 본번 -->
, PA.SNO <!-- 부번 -->
, PA.SPCL_DONG <!-- 특수 동 -->
, PA.SPCL_HO <!-- 특수 호 -->
, PA.SPCL_ADDR <!-- 특수 주소 -->
, PA.WHOL_ADDR <!-- 전체 주소 -->
FROM TB_PAYER P
LEFT OUTER JOIN TB_PAYER_ADDR PA ON (P.RTPYR_ID = PA.RTPYR_ID)
WHERE P.RTPYR_ID = #{rtpyrId}
<choose>
<when test="addrSn != null">
AND PA.ADDR_SN = #{addrSn}
</when>
<otherwise>
<if test="addrInptSeCd != null">
AND PA.ADDR_INPT_SE_CD= #{addrInptSeCd}
</if>
<if test="roadNmCd != null">
AND PA.ROAD_NM_CD= #{roadNmCd}
</if>
<if test="addr != null">
AND PA.ADDR = #{addr}
</if>
<if test="dtlAddr != null">
AND PA.DTL_ADDR = #{dtlAddr}
</if>
</otherwise>
</choose>
<include refid="utility.orderBy" />
</select>
<insert id="insertPayerAddr" parameterType="cokr.xit.fims.payer.Payer">/* 납부자 주소 등록(payerAddrMapper.insertPayerAddr) */
<selectKey resultType="string" keyProperty="addrSn" keyColumn="NEW_ID" order="BEFORE">
SELECT LPAD(CAST(IFNULL(MAX(ADDR_SN) + 1, 1) AS INT), 5, '0') AS NEW_ID
FROM TB_PAYER_ADDR
WHERE RTPYR_ID = #{rtpyrId}
</selectKey>
INSERT
INTO TB_PAYER_ADDR (
RTPYR_ID <!-- 납부자 ID -->
, ADDR_SN <!-- 주소 일련번호 -->
, ADDR_INPT_SE_CD <!-- 주소 입력 구분 코드 -->
, ADDR_SE_CD <!-- 주소 구분 코드 -->
, ZIP <!-- 우편번호 -->
, ADDR <!-- 주소 -->
, DTL_ADDR <!-- 상세 주소 -->
, ROAD_NM_CD <!-- 도로 명 코드 -->
, UDGD_SE_CD <!-- 지하 구분 코드 -->
, BMNO <!-- 건물본번 -->
, BSNO <!-- 건물부번 -->
, BLDG_MNG_NO <!-- 건물 관리 번호 -->
, STDG_CD <!-- 법정동 코드 -->
, DONG_CD <!-- 행정동 코드 -->
, MTN_SE_CD <!-- 산 구분 코드 -->
, MNO <!-- 본번 -->
, SNO <!-- 부번 -->
, SPCL_DONG <!-- 특수 동 -->
, SPCL_HO <!-- 특수 호 -->
, SPCL_ADDR <!-- 특수 주소 -->
, WHOL_ADDR <!-- 전체 주소 -->
, REG_DT <!-- 등록 일시 -->
, RGTR <!-- 등록자 -->
, MDFCN_DT <!-- 수정 일시 -->
, MDFR <!-- 수정자 -->
)
VALUES (
#{rtpyrId} <!-- 납부자 ID -->
, #{addrSn} <!-- 주소 일련번호 -->
, #{addrInptSeCd} <!-- 주소 입력 구분 코드 -->
, #{addrSeCd} <!-- 주소 구분 코드 -->
, #{zip} <!-- 우편번호 -->
, #{addr} <!-- 주소 -->
, #{dtlAddr} <!-- 상세 주소 -->
, #{roadNmCd} <!-- 도로 명 코드 -->
, #{udgdSeCd} <!-- 지하 구분 코드 -->
, #{bmno} <!-- 건물본번 -->
, #{bsno} <!-- 건물부번 -->
, #{bldgMngNo} <!-- 건물 관리 번호 -->
, #{stdgCd} <!-- 법정동 코드 -->
, #{dongCd} <!-- 행정동 코드 -->
, #{mtnSeCd} <!-- 산 구분 코드 -->
, #{mno} <!-- 본번 -->
, #{sno} <!-- 부번 -->
, #{spclDong} <!-- 특수 동 -->
, #{spclHo} <!-- 특수 호 -->
, #{spclAddr} <!-- 특수 주소 -->
, #{wholAddr} <!-- 전체 주소 -->
, <include refid="utility.now" /> <!-- 등록 일시 -->
, #{createdBy} <!-- 등록자 -->
, <include refid="utility.now" /> <!-- 수정 일시 -->
, #{modifiedBy} <!-- 수정자 -->
)
</insert>
<update id="updatePayerAddr" parameterType="cokr.xit.fims.payer.Payer">/* 납부자 주소 수정(payerAddrMapper.updatePayerAddr) */
UPDATE TB_PAYER_ADDR
SET MDFCN_DT = <include refid="utility.now" /> <!-- 수정 일시 -->
, MDFR = #{modifiedBy} <!-- 수정자 -->
WHERE RTPYR_ID = #{rtpyrId}
AND ADDR_SN = #{addrSn}
</update>
<sql id="selectPayerAddrHstry">
SELECT CPAH.CRDN_ID <!-- 단속 ID -->
, CPAH.RTPYR_ID <!-- 납부자 ID -->
, CPAH.ADDR_SN <!-- 주소 일련번호 -->
, CPAH.REG_DT <!-- 등록 일시 -->
, (SELECT USER_NM FROM TB_USER X WHERE X.USER_ID = CPAH.RGTR) AS RGTR_NM <!-- 등록자 명 -->
, (SELECT GET_CODE_NM('FIM087', PA.ADDR_INPT_SE_CD) FROM DUAL) AS ADDR_INPT_SE_NM <!-- 주소 입력 구분 명 -->
, (SELECT GET_CODE_NM('FIM013', PA.ADDR_SE_CD) FROM DUAL) AS ADDR_SE_NM <!-- 주소 구분 명 -->
, PA.ZIP <!-- 우편번호 -->
, PA.ADDR <!-- 주소 -->
, PA.DTL_ADDR <!-- 상세 주소 -->
, PA.ROAD_NM_CD <!-- 도로 명 코드 -->
, PA.UDGD_SE_CD <!-- 지하 구분 코드 -->
, PA.BMNO <!-- 건물본번 -->
, PA.BSNO <!-- 건물부번 -->
, PA.BLDG_MNG_NO <!-- 건물 관리 번호 -->
, PA.STDG_CD <!-- 법정동 코드 -->
, PA.DONG_CD <!-- 행정동 코드 -->
, PA.MTN_SE_CD <!-- 산 구분 코드 -->
, PA.MNO <!-- 본번 -->
, PA.SNO <!-- 부번 -->
, PA.SPCL_DONG <!-- 특수 동 -->
, PA.SPCL_HO <!-- 특수 호 -->
, PA.SPCL_ADDR <!-- 특수 주소 -->
, PA.WHOL_ADDR <!-- 전체 주소 -->
FROM TB_CRDN_PAYER_ADDR_HSTRY CPAH
INNER JOIN TB_PAYER_ADDR PA ON (CPAH.RTPYR_ID = PA.RTPYR_ID AND CPAH.ADDR_SN = PA.ADDR_SN)
</sql>
<select id="selectPayerAddrHstrys" parameterType="map" resultType="dataobject">/* 납부자 주소 이력 대장 객체 가져오기(payerMapper.selectCrdnPayerAddrHstrys) */
<include refid="selectPayerAddrHstry" />
WHERE CPAH.CRDN_ID = #{crdnId} <!-- 단속 ID -->
AND CPAH.RTPYR_ID = #{rtpyrId} <!-- 납부자 ID -->
<include refid="utility.orderBy" />
</select>
</mapper>
Write Preview
Loading…
Cancel
Save