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

소스 이동

Browse Source
main
이범준 2 months ago
parent 6ed603fb81
commit a6cdc65951
34 changed files with 7694 additions and 0 deletions
Show Stats Download Patch File Download Diff File

400
src/main/java/cokr/xit/fims/crdn/Crdn.java
Unescape Escape View File

@ -0,0 +1,400 @@
package cokr.xit.fims.crdn;
import cokr.xit.foundation.AbstractEntity;
import lombok.Getter;
import lombok.Setter;
/**단속 자료 정보
* @author leebj
*/
@Getter
@Setter
public class Crdn extends AbstractEntity {
public static String INF_TYPE = "100";
/**
* 단속 ID
*/
private String crdnId;
/**
* 시군구 코드
*/
private String sggCd;
/**
* 업무 구분 코드
*/
private String taskSeCd;
/**
* 단속 등록 구분 코드
*/
private String crdnRegSeCd;
/**
* 단속 입력 구분 코드
*/
private String crdnInptSeCd;
/**
* 연계 ID
*/
private String linkId;
/**
* 단속 구분 코드
*/
private String crdnSeCd;
/**
* 납부자 ID
*/
private String rtpyrId;
/**
* 주소 일련번호
*/
private String addrSn;
/**
* 단속 일자
*/
private String crdnYmd;
/**
* 단속 시각
*/
private String crdnTm;
/**
* 차량번호
*/
private String vhrno;
/**
* 단속 법정동 명
*/
private String crdnStdgNm;
/**
* 단속 도로 명
*/
private String crdnRoadNm;
/**
* 단속 장소
*/
private String crdnPlc;
/**
* 상세 단속 장소
*/
private String dtlCrdnPlc;
/**
* 조 ID
*/
private String teamId;
/**
* 위반 ID
*/
private String vltnId;
/**
* 단속 특별구역 코드
*/
private String crdnSpareaCd;
/**
* 단속 시작 시각
*/
private String crdnBgngTm;
/**
* 단속 종료 시간
*/
private String crdnEndTm;
/**
* 단속 일련번호
*/
private String crdnSn;
/**
* GPS X
*/
private String gpsX;
/**
* GPS Y
*/
private String gpsY;
/**
* 모자이크 X
*/
private String moscX;
/**
* 모자이크 Y
*/
private String moscY;
/**
* 견인 여부
*/
private String towngYn;
/**
* 첨부 파일 수
*/
private Integer atchFileCnt;
/**
* 차대번호
*/
private String vin;
/**
* 말소등록일자
*/
private String ersrRegYmd;
/**
* 차량 명
*/
private String vhclNm;
/**
* 차량 색상
*/
private String vhclColr;
/**
* 사용 연료 코드
*/
private String useFuelCd;
/**
* 과태료 차종 코드
*/
private String ffnlgCarmdlCd;
/**
* 주차 가능 결과 코드
*/
private String prkPsbltyRsltCd;
/**
* 위반 횟수
*/
private String vltnNmtm;
/**
* 시간외 여부
*/
private String ovtmYn;
/**
* 시간외 분할 여부
*/
private String ovtmPrttnYn;
/**
* 과태료 단속 금액
*/
private Integer ffnlgCrdnAmt;
/**
* 과태료 감경율
*/
private String ffnlgRdcrt;
/**
* 과태료 금액
*/
private Integer ffnlgAmt;
/**
* 사전통지 시작 일자
*/
private String advntceBgngYmd;
/**
* 사전통지 납기 일자
*/
private String advntceDudtYmd;
/**
* 사전통지 금액
*/
private Integer advntceAmt;
/**
* 의견 제출 여부
*/
private String opnnSbmsnYn;
/**
* 기타 내용
*/
private String etcCn;
/**
* 부과 ID
*/
private String levyId;
/**
* 단속 상태 코드
*/
private String crdnSttsCd;
/**
* 단속 상태 변경 일시
*/
private String crdnSttsChgDt;
/**
* 가산 금액
*/
private Integer adtnAmt;
/**
* 감경 금액
*/
private Integer minusAmt;
/**
* 수납 금액
*/
private Integer rcvmtAmt;
/**
* 이전 단속 ID
*/
private String bfrCrdnId;
/**
* 세외수입 단속 연계 여부
*/
private String nxrpCrdnLinkYn;
/**
* 세외수입 단속 연계 사용자 ID
*/
private String nxrpCrdnLinkUserId;
/**
* 세외수입 단속 연계 일시
*/
private String nxrpCrdnLinkDt;
/**
* 세외수입 대장 키
*/
private String nxrpAcbKey;
/**
* 삭제 여부
*/
private String delYn;
/**
* 삭제 일시
*/
private String delDt;
/**
* 삭제자
*/
private String dltr;
/**
* 삭제 사유
*/
private String delRsn;
/**
* 연계 테이블 명
*/
private String linkTblNm;
/**
* 민원 연계 여부
*/
private String cvlcptLinkYn;
/**
* 위반코드
*/
private String vltnCd;
/**
* 납부자 구분 코드
*/
private String rtpyrSeCd;
/**
* 납부자 명
*/
private String rtpyrNm;
/**
* 납부자 번호
*/
private String rtpyrNo;
/**
* 납부자 우편번호
*/
private String zip;
/**
* 납부자 주소
*/
private String addr;
/**
* 납부자 상세주소
*/
private String dtlAddr;
/**
* 부과 제외 구분 코드
*/
private String levyExclSeCd;
/**
* 부과 제외 사유 코드
*/
private String levyExclRsnCd;
/**
* 부과 제외 일자
*/
private String levyExclYmd;
/**
* 조원1
*/
private String teamer1;
/**
* 조원2
*/
private String teamer2;
/**
* 조원3
*/
private String teamer3;
/**
* 조원4
*/
private String teamer4;
}

447
src/main/java/cokr/xit/fims/crdn/CrdnQuery.java
Unescape Escape View File

@ -0,0 +1,447 @@
package cokr.xit.fims.crdn;
import cokr.xit.fims.cmmn.CmmnQuery;
/**단속 대장 정보 조회 요청
*
* <p>상세 설명:
*
* <pre>
* ============ 변경 이력 ============
* 2023-06-23 leebj 최초 작성
* ================================
* </pre>
*/
public class CrdnQuery extends CmmnQuery {
private static final long serialVersionUID = 1L;
//조회유형
private String gridType;
private String inspectionDataType;
//현재정보
private String currentUserId;
private String currentUserAcnt;
private String currentInstitute;
//ID
private String crdnId;
private String[] crdnIds;
private String amtDcsnCdGroupId;
private String dtlAmtDcsnGroupId;
private String fileLayoutId;
//날짜
private String aplcnYmd;
private String schCvlcptRcptYmdFrom;
private String schCvlcptRcptYmdTo;
private String schCvlcptPrcsPrnmntDtFrom;
private String schCvlcptPrcsPrnmntDtTo;
private String schRdctYmdFrom;
private String schRdctYmdTo;
private String crdnYmd;
private String schCrdnYmdFrom;
private String schCrdnYmdTo;
private String schDmndYmdFrom;
private String schDmndYmdTo;
//from, to
private Integer schCrdnCntFrom;
private Integer schCrdnCntTo;
//코드
private String amtDcsnCd;
private String dtlAmtDcsnCd;
private String crdnInptSeCd;
private String cvlcptPrcsCd;
private String crdnSttsCd;
private String ansSeCd;
private String ansRsnCd;
//포함, 제외, 특정 자료
private String schOnlySamePlace;
private String schOnlyUnpay;
private String schExclEnd;
private String schExclOvtime;
//YN
private String dstrbncYn;
private String towngYn;
//기타
private String vhrno;
private String cvlcptPrcsPicNm;
private String teamNm;
private String nxrpSendStts;
public String getGridType() {
return ifEmpty(gridType, () -> null);
}
public <T extends CrdnQuery> T setGridType(String gridType) {
this.gridType = gridType;
return self();
}
public String getCurrentUserId() {
return ifEmpty(currentUserId, () -> null);
}
public <T extends CrdnQuery> T setCurrentUserId(String currentUserId) {
this.currentUserId = currentUserId;
return self();
}
public String getCurrentUserAcnt() {
return ifEmpty(currentUserAcnt, () -> null);
}
public <T extends CrdnQuery> T setCurrentUserAcnt(String currentUserAcnt) {
this.currentUserAcnt = currentUserAcnt;
return self();
}
public String getCurrentInstitute() {
return ifEmpty(currentInstitute, () -> null);
}
public <T extends CrdnQuery> T setCurrentInstitute(String currentInstitute) {
this.currentInstitute = currentInstitute;
return self();
}
public String getInspectionDataType() {
return ifEmpty(inspectionDataType, () -> null);
}
public <T extends CrdnQuery> T setInspectionDataType(String inspectionDataType) {
this.inspectionDataType = inspectionDataType;
return self();
}
public String getCrdnId() {
return ifEmpty(crdnId, () -> null);
}
public <T extends CrdnQuery> T setCrdnId(String crdnId) {
this.crdnId = crdnId;
return self();
}
public String[] getCrdnIds() {
return ifEmpty(crdnIds, () -> null);
}
public <T extends CrdnQuery> T setCrdnIds(String... crdnIds) {
this.crdnIds = crdnIds;
return self();
}
public String getDstrbncYn() {
return ifEmpty(dstrbncYn, () -> null);
}
public <T extends CrdnQuery> T setDstrbncYn(String dstrbncYn) {
this.dstrbncYn = dstrbncYn;
return self();
}
public String getTowngYn() {
return ifEmpty(towngYn, () -> null);
}
public <T extends CrdnQuery> T setTowngYn(String towngYn) {
this.towngYn = towngYn;
return self();
}
public String getVhrno() {
return ifEmpty(vhrno, () -> null);
}
public <T extends CrdnQuery> T setVhrno(String vhrno) {
this.vhrno = vhrno;
return self();
}
public String getCvlcptPrcsPicNm() {
return ifEmpty(cvlcptPrcsPicNm, () -> null);
}
public <T extends CrdnQuery> T setCvlcptPrcsPicNm(String cvlcptPrcsPicNm) {
this.cvlcptPrcsPicNm = cvlcptPrcsPicNm;
return self();
}
public String getTeamNm() {
return ifEmpty(teamNm, () -> null);
}
public <T extends CrdnQuery> T setTeamNm(String teamNm) {
this.teamNm = teamNm;
return self();
}
public String getSchCvlcptRcptYmdFrom() {
return ifEmpty(schCvlcptRcptYmdFrom, () -> null);
}
public <T extends CrdnQuery> T setSchCvlcptRcptYmdFrom(String schCvlcptRcptYmdFrom) {
this.schCvlcptRcptYmdFrom = schCvlcptRcptYmdFrom;
return self();
}
public String getSchCvlcptRcptYmdTo() {
return ifEmpty(schCvlcptRcptYmdTo, () -> null);
}
public <T extends CrdnQuery> T setSchCvlcptRcptYmdTo(String schCvlcptRcptYmdTo) {
this.schCvlcptRcptYmdTo = schCvlcptRcptYmdTo;
return self();
}
public String getSchCvlcptPrcsPrnmntDtFrom() {
return ifEmpty(schCvlcptPrcsPrnmntDtFrom, () -> null);
}
public <T extends CrdnQuery> T setSchCvlcptPrcsPrnmntDtFrom(String schCvlcptPrcsPrnmntDtFrom) {
this.schCvlcptPrcsPrnmntDtFrom = schCvlcptPrcsPrnmntDtFrom;
return self();
}
public String getSchCvlcptPrcsPrnmntDtTo() {
return ifEmpty(schCvlcptPrcsPrnmntDtTo, () -> null);
}
public <T extends CrdnQuery> T setSchCvlcptPrcsPrnmntDtTo(String schCvlcptPrcsPrnmntDtTo) {
this.schCvlcptPrcsPrnmntDtTo = schCvlcptPrcsPrnmntDtTo;
return self();
}
public String getSchRdctYmdFrom() {
return ifEmpty(schRdctYmdFrom, () -> null);
}
public <T extends CrdnQuery> T setSchRdctYmdFrom(String schRdctYmdFrom) {
this.schRdctYmdFrom = schRdctYmdFrom;
return self();
}
public String getSchRdctYmdTo() {
return ifEmpty(schRdctYmdTo, () -> null);
}
public <T extends CrdnQuery> T setSchRdctYmdTo(String schRdctYmdTo) {
this.schRdctYmdTo = schRdctYmdTo;
return self();
}
public String getCrdnYmd() {
return ifEmpty(crdnYmd, () -> null);
}
public <T extends CrdnQuery> T setCrdnYmd(String crdnYmd) {
this.crdnYmd = crdnYmd;
return self();
}
public String getSchCrdnYmdFrom() {
return ifEmpty(schCrdnYmdFrom, () -> null);
}
public <T extends CrdnQuery> T setSchCrdnYmdFrom(String schCrdnYmdFrom) {
this.schCrdnYmdFrom = schCrdnYmdFrom;
return self();
}
public String getSchCrdnYmdTo() {
return ifEmpty(schCrdnYmdTo, () -> null);
}
public <T extends CrdnQuery> T setSchCrdnYmdTo(String schCrdnYmdTo) {
this.schCrdnYmdTo = schCrdnYmdTo;
return self();
}
public String getSchDmndYmdFrom() {
return ifEmpty(schDmndYmdFrom, () -> null);
}
public <T extends CrdnQuery> T setSchDmndYmdFrom(String schDmndYmdFrom) {
this.schDmndYmdFrom = schDmndYmdFrom;
return self();
}
public String getSchDmndYmdTo() {
return ifEmpty(schDmndYmdTo, () -> null);
}
public <T extends CrdnQuery> T setSchDmndYmdTo(String schDmndYmdTo) {
this.schDmndYmdTo = schDmndYmdTo;
return self();
}
public Integer getSchCrdnCntFrom() {
return ifEmpty(schCrdnCntFrom, () -> null);
}
public <T extends CrdnQuery> T setSchCrdnCntFrom(Integer schCrdnCntFrom) {
this.schCrdnCntFrom = schCrdnCntFrom;
return self();
}
public Integer getSchCrdnCntTo() {
return ifEmpty(schCrdnCntTo, () -> null);
}
public <T extends CrdnQuery> T setSchCrdnCntTo(Integer schCrdnCntTo) {
this.schCrdnCntTo = schCrdnCntTo;
return self();
}
public String getSchOnlySamePlace() {
return ifEmpty(schOnlySamePlace, () -> null);
}
public <T extends CrdnQuery> T setSchOnlySamePlace(String schOnlySamePlace) {
this.schOnlySamePlace = schOnlySamePlace;
return self();
}
public String getSchOnlyUnpay() {
return ifEmpty(schOnlyUnpay, () -> null);
}
public <T extends CrdnQuery> T setSchOnlyUnpay(String schOnlyUnpay) {
this.schOnlyUnpay = schOnlyUnpay;
return self();
}
public String getSchExclEnd() {
return ifEmpty(schExclEnd, () -> null);
}
public <T extends CrdnQuery> T setSchExclEnd(String schExclEnd) {
this.schExclEnd = schExclEnd;
return self();
}
public String getSchExclOvtime() {
return ifEmpty(schExclOvtime, () -> null);
}
public <T extends CrdnQuery> T setSchExclOvtime(String schExclOvtime) {
this.schExclOvtime = schExclOvtime;
return self();
}
public String getCrdnInptSeCd() {
return ifEmpty(crdnInptSeCd, () -> null);
}
public <T extends CrdnQuery> T setCrdnInptSeCd(String crdnInptSeCd) {
this.crdnInptSeCd = crdnInptSeCd;
return self();
}
public String getCvlcptPrcsCd() {
return ifEmpty(cvlcptPrcsCd, () -> null);
}
public <T extends CrdnQuery> T setCvlcptPrcsCd(String cvlcptPrcsCd) {
this.cvlcptPrcsCd = cvlcptPrcsCd;
return self();
}
public String getCrdnSttsCd() {
return ifEmpty(crdnSttsCd, () -> null);
}
public <T extends CrdnQuery> T setCrdnSttsCd(String crdnSttsCd) {
this.crdnSttsCd = crdnSttsCd;
return self();
}
public String getAnsSeCd() {
return ifEmpty(ansSeCd, () -> null);
}
public <T extends CrdnQuery> T setAnsSeCd(String ansSeCd) {
this.ansSeCd = ansSeCd;
return self();
}
public String getAnsRsnCd() {
return ifEmpty(ansRsnCd, () -> null);
}
public <T extends CrdnQuery> T setAnsRsnCd(String ansRsnCd) {
this.ansRsnCd = ansRsnCd;
return self();
}
public String getAplcnYmd() {
return ifEmpty(aplcnYmd, () -> null);
}
public <T extends CrdnQuery> T setAplcnYmd(String aplcnYmd) {
this.aplcnYmd = aplcnYmd;
return self();
}
public String getAmtDcsnCdGroupId() {
return ifEmpty(amtDcsnCdGroupId, () -> null);
}
public <T extends CrdnQuery> T setAmtDcsnCdGroupId(String amtDcsnCdGroupId) {
this.amtDcsnCdGroupId = amtDcsnCdGroupId;
return self();
}
public String getAmtDcsnCd() {
return ifEmpty(amtDcsnCd, () -> null);
}
public <T extends CrdnQuery> T setAmtDcsnCd(String amtDcsnCd) {
this.amtDcsnCd = amtDcsnCd;
return self();
}
public String getDtlAmtDcsnGroupId() {
return ifEmpty(dtlAmtDcsnGroupId, () -> null);
}
public <T extends CrdnQuery> T setDtlAmtDcsnGroupId(String dtlAmtDcsnGroupId) {
this.dtlAmtDcsnGroupId = dtlAmtDcsnGroupId;
return self();
}
public String getFileLayoutId() {
return ifEmpty(fileLayoutId, () -> null);
}
public <T extends CrdnQuery> T setFileLayoutId(String fileLayoutId) {
this.fileLayoutId = fileLayoutId;
return self();
}
public String getDtlAmtDcsnCd() {
return ifEmpty(dtlAmtDcsnCd, () -> null);
}
public <T extends CrdnQuery> T setDtlAmtDcsnCd(String dtlAmtDcsnCd) {
this.dtlAmtDcsnCd = dtlAmtDcsnCd;
return self();
}
public String getNxrpSendStts() {
return ifEmpty(nxrpSendStts, () -> null);
}
public <T extends CrdnQuery> T setNxrpSendStts(String nxrpSendStts) {
this.nxrpSendStts = nxrpSendStts;
return self();
}
}

99
src/main/java/cokr/xit/fims/crdn/ExmptnVhcl.java
Unescape Escape View File

@ -0,0 +1,99 @@
package cokr.xit.fims.crdn;
import cokr.xit.foundation.AbstractEntity;
import lombok.Getter;
import lombok.Setter;
/**면제차량 정보
* @author leebj
*/
@Getter
@Setter
public class ExmptnVhcl extends AbstractEntity {
/**
* 면제차량 ID
*/
private String exmptnVhclId;
/**
* 이력 일련번호
*/
private String hstrySn;
/**
* 시군구 코드
*/
private String sggCd;
/**
* 차량번호
*/
private String vhrno;
/**
* 면제 사유
*/
private String exmptnRsn;
/**
* 문서 번호
*/
private String docNo;
/**
* 소유자 명
*/
private String ownrNm;
/**
* 면제 시작 일자
*/
private String exmptnBgngYmd;
/**
* 면제 종료 일자
*/
private String exmptnEndYmd;
/**
* 삭제 여부
*/
private String delYn;
/**
* 등록 일시
*/
private String regDt;
/**
* 등록자
*/
private String rgtr;
/**
* 수정 일시
*/
private String mdfcnDt;
/**
* 수정자
*/
private String mdfr;
/**
* 삭제 일시
*/
private String delDt;
/**
* 삭제자
*/
private String dltr;
/**
* 삭제 사유
*/
private String delRsn;
}

88
src/main/java/cokr/xit/fims/crdn/Team.java
Unescape Escape View File

@ -0,0 +1,88 @@
package cokr.xit.fims.crdn;
import cokr.xit.foundation.AbstractEntity;
import lombok.Getter;
import lombok.Setter;
/**단속팀 정보
* @author leebj
*/
@Getter
@Setter
public class Team extends AbstractEntity {
/**
* 단속팀 ID
*/
private String teamId;
/**
* 시군구 코드
*/
private String sggCd;
/**
* 업무 구분 코드
*/
private String taskSeCd;
/**
* 단속 구분 코드
*/
private String crdnSeCd;
/**
* 조 명
*/
private String teamNm;
/**
* 조원1
*/
private String teamer1;
/**
* 조원2
*/
private String teamer2;
/**
* 조원3
*/
private String teamer3;
/**
* 조원4
*/
private String teamer4;
/**
* 기타 내용
*/
private String etcCn;
/**
* 사용 여부
*/
private String useYn;
/**
* 등록일시
*/
private String regDt;
/**
* 등록자
*/
private String rgtr;
/**
* 수정일시
*/
private String mdfcnDt;
/**
* 수정자
*/
private String mdfr;
}

20
src/main/java/cokr/xit/fims/crdn/dao/CrdnInfoMapper.java
Unescape Escape View File

@ -0,0 +1,20 @@
package cokr.xit.fims.crdn.dao;
import org.egovframe.rte.psl.dataaccess.mapper.Mapper;
import cokr.xit.foundation.component.AbstractMapper;
import cokr.xit.foundation.data.DataObject;
/**단속 정보 조회 DAO
* @author leebj
*/
@Mapper("crdnInfoMapper")
public interface CrdnInfoMapper extends AbstractMapper {
/**단속 대장 정보를 조회한다.
* @param crdnId 단속 아이디
* @return 단속 정보
*/
DataObject selectCrdnInfo(String crdnId);
}

32
src/main/java/cokr/xit/fims/crdn/dao/CrdnInstMapper.java
Unescape Escape View File

@ -0,0 +1,32 @@
package cokr.xit.fims.crdn.dao;
import org.egovframe.rte.psl.dataaccess.mapper.Mapper;
import cokr.xit.fims.crdn.Crdn;
import cokr.xit.foundation.component.AbstractMapper;
/**단속 자료 등록 DAO
* @author leebj
*/
@Mapper("crdnInstMapper")
public interface CrdnInstMapper extends AbstractMapper {
/**단속 대장 정보를 등록한다.
* @param params 파라미터
* <ul><li>"crdn" - 단속 대장</li>
* <li>"currentUser" - 현재 접속한 사용자</li>
* </ul>
* @return 저장된 정보수
*/
int insertCrdn(Crdn crdn);
/**단속 부가 정보를 등록한다.
* @param params 파라미터
* <ul><li>"crdn" - 단속 부가 정보</li>
* <li>"currentUser" - 현재 접속한 사용자</li>
* </ul>
* @return 저장된 정보수
*/
int insertCrdnAddition(Crdn crdn);
}

65
src/main/java/cokr/xit/fims/crdn/dao/CrdnListMapper.java
Unescape Escape View File

@ -0,0 +1,65 @@
package cokr.xit.fims.crdn.dao;
import java.util.List;
import org.egovframe.rte.psl.dataaccess.mapper.Mapper;
import cokr.xit.fims.crdn.CrdnQuery;
import cokr.xit.foundation.component.AbstractMapper;
import cokr.xit.foundation.data.DataObject;
/**단속 대장 목록 조회 DAO
* @author leebj
*/
@Mapper("crdnListMapper")
public interface CrdnListMapper extends AbstractMapper {
/**금일 등록한 단속자료 목록을 조회한다.<br />
* {@link cokr.xit.fims.crdn.service.bean.CrdnService#getCrackdownList(CrdnQuery)} 참고
* @param query 단속자료 목록 조회 조건
* @return 단속자료 목록
*/
List<DataObject> selectTodayCrackdownList(CrdnQuery query);
/**단속자료 목록을 조회한다.<br />
* {@link cokr.xit.fims.crdn.service.bean.CrdnService#getCrackdownList(CrdnQuery)} 참고
* @param query 단속자료 목록 조회 조건
* @return 단속자료 목록
*/
List<DataObject> selectCrackdownList(CrdnQuery query);
/**단속사진 검사 자료 목록을 조회한다.<br />
* {@link cokr.xit.fims.crdn.service.bean.CrdnService#getCrackdownList(CrdnQuery)} 참고
* @param query 단속사진 검사 자료 목록 조회 조건
* @return 단속사진 검사 자료 목록
*/
List<DataObject> selectPhotoInspectionDataList(CrdnQuery query);
/**동일 차량 단속 그룹 목록을 조회한다.<br />
* {@link cokr.xit.fims.crdn.service.bean.CrdnService#getCrackdownList(CrdnQuery)} 참고
* @param query 동일 차량 단속 그룹 목록 조회 조건
* @return 동일 차량 단속 그룹 목록
*/
List<DataObject> selectSameVehicleMainList(CrdnQuery query);
/**동일 차량 단속 자료 목록을 조회한다.<br />
* {@link cokr.xit.fims.crdn.service.bean.CrdnService#getCrackdownList(CrdnQuery)} 참고
* @param query 동일 차량 단속 자료 목록 조회 조건
* @return 동일 차량 단속 자료 목록
*/
List<DataObject> selectSameVehicleSubList(CrdnQuery query);
/**표지정보 미확인 자료 목록을 조회한다.<br />
* {@link cokr.xit.fims.crdn.service.bean.CrdnService#getCrackdownList(CrdnQuery)} 참고
* @param query 표지정보 미확인 자료 목록 조회 조건
* @return 표지정보 미확인 자료 목록
*/
List<DataObject> selectTagInformationUndefinedDataList(CrdnQuery query);
/**단속 건수를 반환한다.
* @param crdnQuery 조회조건
* @return 단속 건수
*/
int countCrdn(CrdnQuery crdnQuery);
}

35
src/main/java/cokr/xit/fims/crdn/dao/CrdnStngMapper.java
Unescape Escape View File

@ -0,0 +1,35 @@
package cokr.xit.fims.crdn.dao;
import java.util.List;
import java.util.Map;
import org.egovframe.rte.psl.dataaccess.mapper.Mapper;
import cokr.xit.fims.crdn.CrdnQuery;
import cokr.xit.foundation.component.AbstractMapper;
@Mapper("crdnStngMapper")
public interface CrdnStngMapper extends AbstractMapper {
/**기본금액을 조회한다.<br />
* {@link cokr.xit.fims.crdn.service.bean.CrdnStngBean#getBasicAmt(CrdnQuery)} 참고
* @param query 단속자료 정보
* @return 기본금액
*/
String selectBasicAmt(CrdnQuery query);
/**시군구코드에 따른 법정동명 목록을 조회한다.<br />
* @param sggCd 시군구코드
* @return 법정동 목록
*/
List<String> selectStdgNmList(String sggCd);
/**법정동명으로 법정동코드를 조회한다.<br />
* @param map 시군구코드 및 법정동명
* @return 법정동코드 목록
*/
List<String> selectStdgCdListByStdgNm(Map<String, Object> map);
}

57
src/main/java/cokr/xit/fims/crdn/dao/CrdnTeamMapper.java
Unescape Escape View File

@ -0,0 +1,57 @@
package cokr.xit.fims.crdn.dao;
import java.util.List;
import org.egovframe.rte.psl.dataaccess.mapper.Mapper;
import cokr.xit.fims.crdn.CrdnQuery;
import cokr.xit.fims.crdn.Team;
import cokr.xit.foundation.component.AbstractMapper;
import cokr.xit.foundation.data.DataObject;
@Mapper("crdnTeamMapper")
public interface CrdnTeamMapper extends AbstractMapper {
/**단속팀 목록을 조회한다.<br />
* @param query 단속팀 목록 조회 조건
* @return 단속팀 목록
*/
List<DataObject> selectTeamList(CrdnQuery query);
/**비사용 단속팀 목록을 조회한다.<br />
* @param query 비사용 단속팀 목록 조회 조건
* @return 비사용 단속팀 목록
*/
List<DataObject> selectRemovedTeamList(CrdnQuery query);
/**단속팀 정보를 삭제한다.<br />
* @param team 단속팀 정보
* @return 저장된 정보 수
*/
int deleteTeamInfo(Team team);
/**단속팀 정보를 등록한다.<br />
* @param team 단속팀 정보
* @return 저장된 정보 수
*/
int insertTeamInfo(Team team);
/**단속팀 정보를 수정한다.<br />
* @param team 단속팀 정보
* @return 저장된 정보 수
*/
int updateTeamInfo(Team team);
/**단속팀명으로 단속팀 정보를 조회한다.<br />
* @param team 단속팀 정보
* @return 단속팀 정보
*/
DataObject selectTeamInfoByName(Team team);
/**단속팀 정보를 조회한다.<br />
* @param teamId 단속팀 ID
* @return 단속팀 정보
*/
DataObject selectTeamInfo(String teamId);
}

95
src/main/java/cokr/xit/fims/crdn/dao/CrdnUpdtMapper.java
Unescape Escape View File

@ -0,0 +1,95 @@
package cokr.xit.fims.crdn.dao;
import java.util.Map;
import org.egovframe.rte.psl.dataaccess.mapper.Mapper;
import cokr.xit.fims.crdn.Crdn;
import cokr.xit.foundation.component.AbstractMapper;
/**단속 관리 DAO
* @author leebj
*/
@Mapper("crdnUpdtMapper")
public interface CrdnUpdtMapper extends AbstractMapper {
/**단속 상태를 변경한다.
* @param crdn 단속 대장
* @return 저장된 정보수
*/
int updateCrdnStatus(Crdn crdn);
/**표지정보 미확인 자료를 확인 자료로 수정한다.
* @param crdn 단속 대장
* @return 저장된 정보수
*/
int updateTagInfo(Crdn crdn);
/** 2시간 초과 여부를 변경한다.
* @param crdn 단속 대장
* @return 저장된 정보수
*/
int updateOverTimeInfo(Crdn crdn);
/** 단속 자료의 금액을 변경한다.
* @param crdn 단속 대장
* @return 저장된 정보수
*/
int updateCrdnAmt(Crdn crdn);
/** 단속 자료의 기타사항을 변경한다.
* @param crdn 단속 대장
* @return 저장된 정보수
*/
int updateEtcCn(Crdn crdn);
/**단속정보를 변경한다.<br />
* {@link cokr.xit.fims.crdn.service.bean.CrdnBean#update(Crdn)} 참고
* @param crdn 단속정보
* @return 저장된 정보수
*/
int updateCrdn(Crdn crdn);
/**단속 부가 정보를 변경한다.<br />
* {@link cokr.xit.fims.crdn.service.bean.CrdnBean#update(Crdn)} 참고
* @param crdn 단속정보
* @return 저장된 정보수
*/
int updateCrdnAddition(Crdn crdn);
/**단속 정보를 변경한다.<br />
* @param crdn 단속정보
* @return 저장된 정보수
*/
int updateEditCrdn(Crdn crdn);
/** 단속 정보를 삭제한다.
* @param map 삭제 요청 파라미터
* @return 저장된 정보수
*/
int deleteCrdn(Map<String, Object> map);
/** 단속 부가 정보를 삭제한다.
* @param map 삭제 요청 파라미터
* @return 저장된 정보수
*/
int deleteCrdnAdi(Map<String, Object> map);
/** 단속 정보의 납부자 ID를 삭제한다.
* @param map 삭제 요청 파라미터
* @return 저장된 정보수
*/
int deleteCrdnPayer(Crdn crdn);
/**
* @param
* @return 저장된 정보수
*/
int updateNxrpCrdnLinkYn(Crdn crdn);
/** 단속 정보의 사전통지 일자를 변경한다.
* @param crdn 단속 대장
* @return 저장된 정보수
*/
int updateAdvntceYmd(Crdn crdn);
}

57
src/main/java/cokr/xit/fims/crdn/dao/ExmptnVhclMapper.java
Unescape Escape View File

@ -0,0 +1,57 @@
package cokr.xit.fims.crdn.dao;
import java.util.List;
import org.egovframe.rte.psl.dataaccess.mapper.Mapper;
import cokr.xit.fims.crdn.CrdnQuery;
import cokr.xit.fims.crdn.ExmptnVhcl;
import cokr.xit.foundation.component.AbstractMapper;
import cokr.xit.foundation.data.DataObject;
@Mapper("exmptnVhclMapper")
public interface ExmptnVhclMapper extends AbstractMapper {
/**면제차량 목록을 조회한다.<br />
* @param query 면제차량 목록 조회 조건
* @return 면제차량 목록
*/
List<DataObject> selectExemptionVehicleList(CrdnQuery query);
/**면제차량 정보를 조회한다.<br />
* @param exemptionVehicleId 면제차량 ID
* @return 면제차량 정보
*/
DataObject selectExemptionVehicleInfo(String exemptionVehicleId);
/**면제차량 정보를 등록한다.
* @param exmptnVhcl 면제차량 정보
* return 저장된 정보 수
*/
int insertExemptionVehicleInfo(ExmptnVhcl exmptnVhcl);
/**면제차량 정보를 수정한다.
* @param exmptnVhcl 면제차량 정보
* return 저장된 정보 수
*/
int updateExemptionVehicleInfo(ExmptnVhcl exmptnVhcl);
/**면제차량 정보를 삭제한다.
* @param exmptnVhcl 면제차량 정보
* return 저장된 정보 수
*/
int deleteExemptionVehicleInfo(ExmptnVhcl exmptnVhcl);
/**면제차량 이력을 등록한다.
* @param exmptnVhcl 면제차량 정보
* return 저장된 정보 수
*/
int insertExemptionVehicleHistory(ExmptnVhcl exmptnVhcl);
/**면제차량 이력을 조회한다.<br />
* @param exemptionVehicleId 면제차량 ID
* @return 면제차량 이력
*/
List<DataObject> selectExemptionVehicleHistoryList(String exmptnVhclId);
}

412
src/main/java/cokr/xit/fims/crdn/service/bean/CrdnBean.java
Unescape Escape View File

@ -0,0 +1,412 @@
package cokr.xit.fims.crdn.service.bean;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
import java.util.stream.Stream;
import javax.annotation.Resource;
import org.springframework.stereotype.Component;
import cokr.xit.base.file.FileInfo;
import cokr.xit.base.file.service.bean.FileBean;
import cokr.xit.fims.cmmn.CmmnUtil;
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.crdn.Crdn;
import cokr.xit.fims.crdn.Team;
import cokr.xit.fims.crdn.dao.CrdnInfoMapper;
import cokr.xit.fims.crdn.dao.CrdnInstMapper;
import cokr.xit.fims.crdn.dao.CrdnTeamMapper;
import cokr.xit.fims.crdn.dao.CrdnUpdtMapper;
import cokr.xit.fims.excl.LevyExcl;
import cokr.xit.fims.excl.service.bean.LevyExclBean;
import cokr.xit.foundation.UserInfo;
import cokr.xit.foundation.component.AbstractBean;
import cokr.xit.foundation.data.DataObject;
/** 단속 관리 Bean
* @author leebj
*/
@Component("crdnBean")
public class CrdnBean extends AbstractBean {
@Resource(name = "crdnSttsHstryBean")
private CrdnSttsHstryBean crdnSttsHstryBean;
@Resource(name = "crdnPayerHstryBean")
private CrdnPayerHstryBean crdnPayerHstryBean;
@Resource(name = "fileBean")
private FileBean fileBean;
@Resource(name = "crdnStngBean")
private CrdnStngBean crdnStngBean;
@Resource(name = "crdnInfoMapper")
private CrdnInfoMapper crdnInfoMapper;
@Resource(name = "crdnInstMapper")
private CrdnInstMapper crdnInstMapper;
@Resource(name = "crdnUpdtMapper")
private CrdnUpdtMapper crdnUpdtMapper;
@Resource(name = "crdnTeamMapper")
private CrdnTeamMapper crdnTeamMapper;
@Resource(name = "levyExclBean")
protected LevyExclBean levyExclBean;
public boolean create(Map<String, Object> nonQueryRequest, Crdn crdn, List<FileInfo> fileInfoList) {
if(fileInfoList != null && !fileInfoList.isEmpty()) {
crdn.setAtchFileCnt(fileInfoList.size());
} else {
crdn.setAtchFileCnt(0);
}
//금액 계산
int[] basicAmt = crdnStngBean.getBasicAmt(crdn);
crdn.setFfnlgCrdnAmt(basicAmt[0]);
crdn.setFfnlgAmt(basicAmt[0]);
crdn.setAdvntceAmt(basicAmt[1]);
//단속팀 정보 갱신
if(!ifEmpty(crdn.getTeamId(), () -> "").equals("")) {
DataObject teamInfo = crdnTeamMapper.selectTeamInfo(crdn.getTeamId());
Team team = new Team();
team.setTaskSeCd(crdn.getTaskSeCd());
team.setSggCd(crdn.getSggCd());
team.setTeamNm(teamInfo.string("TEAM_NM"));
team.setCrdnSeCd(crdn.getCrdnSeCd());
team.setTeamer1(crdn.getTeamer1());
team.setTeamer2(crdn.getTeamer2());
team.setTeamer3(crdn.getTeamer3());
team.setTeamer4(crdn.getTeamer4());
crdnStngBean.saveTeamInfo(true, team);
}
//상태코드 설정
SimpleDateFormat dateFormat = new SimpleDateFormat("yyyyMMddHHmmss");
if(ifEmpty(crdn.getCrdnSttsCd(), () -> "").equals("")){ //상태코드가 없을경우
if(ifEmpty(crdn.getCvlcptLinkYn(), () -> "").equals("Y")) { //민원연계자료일 경우
crdn.setCrdnSttsCd("01"); //초기상태
crdn.setCrdnSttsChgDt(dateFormat.format(System.currentTimeMillis()));
} else { //민원연계자료가 아닐 경우
if(ifEmpty(crdn.getRtpyrId(), () -> "").equals("")) { //납부자가 정보가 없을 경우
crdn.setCrdnSttsCd("01"); //초기상태
crdn.setCrdnSttsChgDt(dateFormat.format(System.currentTimeMillis()));
} else {
crdn.setCrdnSttsCd("21"); //납부자등록완료
crdn.setCrdnSttsChgDt(dateFormat.format(System.currentTimeMillis()));
}
}
}
//단속 대장 등록
boolean result = this.createLedger(crdn);
if (!result) {
throw new RuntimeException("단속자료 등록 중 단속자료 등록에 실패하였습니다.");
}
SimpleDateFormat yyyyMMdd = new SimpleDateFormat("yyyyMMdd");
Date curTime = new Date();
String strCurrentDate = yyyyMMdd.format(curTime);
String taskDtlId = crdn.getCrdnId();
if(crdn.getCrdnSttsCd().equals("83")) {
// 부과제외(TB_LEVY_EXCL) 대장 등록
LevyExcl excl01 = new LevyExcl();
excl01.setCrdnId(crdn.getCrdnId());
excl01.setLevyExclYmd(strCurrentDate);
excl01.setLevyExclSeCd("2");
excl01.setLevyExclRsnCd("192");
excl01.setEtcCn("");
String rtnScs = levyExclBean.createLevyExcl(excl01);
if (rtnScs.contains("[F]")) {
throw new RuntimeException("단속자료 등록 중 부과제외 자료 등록에 실패하였습니다.");
}
taskDtlId = excl01.getLevyExclId();
}
// 단속상태이력(TB_CRDN_STTS_HSTRY) 대장 등록
CrdnSttsHstry crdnSttsHstry = new CrdnSttsHstry();
crdnSttsHstry.setCrdnId(crdn.getCrdnId());
crdnSttsHstry.setBfrSttsCd("");
crdnSttsHstry.setBfrSttsChgDt("");
crdnSttsHstry.setCrdnSttsCd(crdn.getCrdnSttsCd());
crdnSttsHstry.setTaskDtlId(taskDtlId);
crdnSttsHstry.setEtcCn("");
result = crdnSttsHstryBean.create(crdnSttsHstry);
if (!result) {
throw new RuntimeException("단속자료 등록 중 단속상태 이력 등록에 실패하였습니다.");
}
//단속납부자이력(TB_CRDN_PAYER_HSTRY) 대장 등록
if(!ifEmpty(crdn.getRtpyrId(), () -> "").equals("")) {
CrdnPayerHstry crdnPayerHstry = new CrdnPayerHstry();
crdnPayerHstry.setCrdnId(crdn.getCrdnId());
crdnPayerHstry.setRtpyrId(crdn.getRtpyrId());
crdnPayerHstry.setAddrSn(crdn.getAddrSn());
result = crdnPayerHstryBean.createCrdnPayerHstry(crdnPayerHstry);
if (!result) {
throw new RuntimeException("단속자료 등록 중 단속 납부자 이력 등록에 실패하였습니다.");
}
// 단속 대장의 납부자ID 수정 및 단속 납부자 이력(TB_CRDN_PAYER_HSTRY) 대장에 등록한다.
result = crdnPayerHstryBean.createCrdnPayerAddrHstry(crdnPayerHstry);
if (!result) {
throw new RuntimeException("단속자료 등록 중 단속 납부자주소 이력 등록에 실패하였습니다.");
}
}
//파일 등록
if(fileInfoList != null && !fileInfoList.isEmpty()) {
fileInfoList.forEach(fileInfo -> fileInfo.setInfoType(Crdn.INF_TYPE).setInfoKey(crdn.getCrdnId()));
int effected = fileBean.create(fileInfoList);
if(effected == 0) {
throw new RuntimeException("단속자료 등록 중 파일 등록에 실패하였습니다.");
}
}
return result;
}
/**단속 대장 정보를 등록한다.
* @param crdn 단속 대장
* @return 저장 여부
* <ul><li>저장됐으면 true</li>
* <li>그렇지 않으면 false</li>
* </ul>
*/
public boolean createLedger(Crdn crdn) {
int effected = crdnInstMapper.insertCrdn(crdn);
if(effected != 1) {
return false;
}
effected = crdnInstMapper.insertCrdnAddition(crdn);
if(effected != 1) {
return false;
}
return true;
}
/**단속 대장 정보를 수정한다.
* @param nonQueryRequest 수정 요청, crdn 단속 대장
* @return 저장 여부
* <ul><li>저장됐으면 true</li>
* <li>그렇지 않으면 false</li>
* </ul>
*/
public boolean updateLedger(Map<String,Object> nonQueryRequest, Crdn crdn) {
String updateInfomationType = (String)ifEmpty(nonQueryRequest.get("updateInfomationType"), "") ;
switch (ifEmpty(updateInfomationType, () -> "")) {
default:
if(crdnUpdtMapper.updateCrdnAddition(crdn) != 1) {
return false;
}
return crdnUpdtMapper.updateCrdn(crdn) == 1 ? true : false;
}
}
/**단속 정보를 삭제한다.
* @param crdnIds 단속아이디 목록
* @return 저장 여부
* <ul><li>저장됐으면 true</li>
* <li>그렇지 않으면 false</li>
* </ul>
*/
public boolean remove(String... crdnIds) {
if (isEmpty(crdnIds)) return false;
Map<String, Object> paramMap = new HashMap<String, Object>();
List<String> crdnIdList = Arrays.asList(crdnIds);
paramMap.put("crdnIds", crdnIdList);
paramMap.put("removedBy", UserInfo.current().getId());
return crdnUpdtMapper.deleteCrdn(paramMap) >= 1 ? true : false;
}
/**단속 자료를 수정한다.
* @param crdn 단속
* @return 저장 여부
* <ul><li>저장됐으면 true</li>
* <li>그렇지 않으면 false</li>
* </ul>
*/
public String updateCrackdown(Crdn crdn) {
// 변수 선언
int effected = 0; // DB 처리 결과
//금액 계산
int[] basicAmt = crdnStngBean.getBasicAmt(crdn);
crdn.setFfnlgCrdnAmt(basicAmt[0]);
crdn.setFfnlgAmt(basicAmt[0]);
crdn.setAdvntceAmt(basicAmt[1]);
// 단속(TB_CRDN) 대장을 수정한다.
effected = crdnUpdtMapper.updateEditCrdn(crdn);
if (effected != 1) {
throw new RuntimeException("단속 대장 수정에 실패하였습니다."); // 예외를 발생시켜서 DB Rollback
}
// 단속 부가 정보(TB_CRDN_ADI) 대장을 수정한다.
effected = crdnUpdtMapper.updateCrdnAddition(crdn);
if (effected != 1) {
throw new RuntimeException("단속 부가 정보 수정에 실패하였습니다."); // 예외를 발생시켜서 DB Rollback
}
return "[S] 작업이 정상 처리 되었습니다.";
}
/**단속 자료를 삭제한다.
* @param crdn 단속
* @return 저장 여부
* <ul><li>저장됐으면 true</li>
* <li>그렇지 않으면 false</li>
* </ul>
*/
public String removeCrackdown(Crdn crdn) {
// 변수 선언
boolean rtnScs = false; // DB 처리 결과
int effected = 0;
// 단속 ID로 단속 정보 조회
DataObject infoCrdn = crdnInfoMapper.selectCrdnInfo(crdn.getCrdnId());
// 단속상태이력(TB_CRDN_STTS_HSTRY)
CrdnSttsHstry crdnSttsHstry = new CrdnSttsHstry();
crdnSttsHstry.setCrdnId(infoCrdn.string("CRDN_ID"));
crdnSttsHstry.setBfrSttsCd(infoCrdn.string("CRDN_STTS_CD"));
crdnSttsHstry.setBfrSttsChgDt(infoCrdn.string("CRDN_STTS_CHG_DT"));
crdnSttsHstry.setCrdnSttsCd("99");
// 단속 상태 이력(TB_CRDN_STTS_HSTRY) 대장에 등록한다.
rtnScs = crdnSttsHstryBean.createHstryUpdateCrdnSttsCd(crdnSttsHstry);
if (!rtnScs) {
throw new RuntimeException("단속 삭제 중 단속 대장의 단속상태코드 변경에 실패하였습니다."); // 예외를 발생시켜서 DB Rollback
}
Map<String, Object> paramMap = new HashMap<String, Object>();
List<String> crdnIdList = Arrays.asList(crdn.getCrdnId());
paramMap.put("crdnIds", crdnIdList);
paramMap.put("removedBy", UserInfo.current().getId());
paramMap.put("delRsn", crdn.getDelRsn());
// 단속(TB_CRDN) 대장을 삭제한다.
effected = crdnUpdtMapper.deleteCrdn(paramMap);
if (effected != 1) {
throw new RuntimeException("단속 대장 삭제에 실패하였습니다."); // 예외를 발생시켜서 DB Rollback
}
// 단속(TB_CRDN) 대장을 삭제한다.
effected = crdnUpdtMapper.deleteCrdnAdi(paramMap);
if (effected != 1) {
throw new RuntimeException("단속 부가 정보 삭제에 실패하였습니다."); // 예외를 발생시켜서 DB Rollback
}
return "[S] 작업이 정상 처리 되었습니다.";
}
/**단속 자료의 납부자 ID를 삭제한다.
* @param crdn 단속
* @return 저장 여부
* <ul><li>저장됐으면 true</li>
* <li>그렇지 않으면 false</li>
* </ul>
*/
public String removeCrackdownPayer(Crdn crdn) {
// 단속(TB_CRDN) 대장에 납부자 ID를 삭제한다.
int effected = crdnUpdtMapper.deleteCrdnPayer(crdn);
if (effected != 1) {
throw new RuntimeException("단속 자료의 납부자 정보가 없습니다."); // 예외를 발생시켜서 DB Rollback
}
return "[S] 작업이 정상 처리 되었습니다.";
}
/**단속 자료의 처리 상태 코드를 수정한다.
* @param crdn 단속
* @return 저장 여부
* <ul><li>저장됐으면 true</li>
* <li>그렇지 않으면 false</li>
* </ul>
*/
public String updateCrackdownStatus(Crdn crdn) {
// 단속 ID로 단속 정보 조회
DataObject infoCrdn = crdnInfoMapper.selectCrdnInfo(crdn.getCrdnId());
// 단속상태이력(TB_CRDN_STTS_HSTRY)
CrdnSttsHstry crdnSttsHstry = new CrdnSttsHstry();
crdnSttsHstry.setCrdnId(infoCrdn.string("CRDN_ID"));
crdnSttsHstry.setBfrSttsCd(infoCrdn.string("CRDN_STTS_CD"));
crdnSttsHstry.setBfrSttsChgDt(infoCrdn.string("CRDN_STTS_CHG_DT"));
crdnSttsHstry.setEtcCn("[개별총정보-단속상태변경] " + crdn.getEtcCn());
crdnSttsHstry.setCrdnSttsCd(crdn.getCrdnSttsCd());
// 단속 상태 이력(TB_CRDN_STTS_HSTRY) 대장에 등록한다.
boolean rtnScs = crdnSttsHstryBean.createHstryUpdateCrdnSttsCd(crdnSttsHstry);
if (!rtnScs) {
throw new RuntimeException("단속 대장의 단속상태코드 변경에 실패하였습니다."); // 예외를 발생시켜서 DB Rollback
}
return "[S] 작업이 정상 처리 되었습니다.";
}
/** 장비 연계파일을 삭제한다.
* @param workPath 작업 디렉토리, fileName 파일명
* @return 저장 여부
*/
public boolean removeEquipmentLinkFile(String workPath, String fileName) {
boolean saved = false;
try {
Stream<Path> walk = Files.walk(Paths.get(workPath));
List<String> deleteFilePaths = new ArrayList<String>();
walk.filter(Files::isRegularFile)
.filter(p -> p.toFile().getName().equalsIgnoreCase(fileName))
.collect(Collectors.toList())
.forEach(item -> deleteFilePaths.add(item.toFile().getPath()));
for(String deleteFilePath : deleteFilePaths) {
saved = (new File(deleteFilePath)).delete();
}
//빈 디렉토리 삭제
CmmnUtil.deleteEmptyDir(new File(workPath), false);
walk.close();
} catch (Exception e) {
throw new RuntimeException(e);
}
return saved;
}
}

560
src/main/java/cokr/xit/fims/crdn/service/bean/CrdnStngBean.java
Unescape Escape View File

@ -0,0 +1,560 @@
package cokr.xit.fims.crdn.service.bean;
import java.util.List;
import javax.annotation.Resource;
import org.assertj.core.util.Arrays;
import org.springframework.stereotype.Component;
import cokr.xit.fims.cmmn.CmmnUtil;
import cokr.xit.fims.crdn.Crdn;
import cokr.xit.fims.crdn.CrdnQuery;
import cokr.xit.fims.crdn.ExmptnVhcl;
import cokr.xit.fims.crdn.Team;
import cokr.xit.fims.crdn.dao.CrdnStngMapper;
import cokr.xit.fims.crdn.dao.CrdnTeamMapper;
import cokr.xit.fims.crdn.dao.ExmptnVhclMapper;
import cokr.xit.foundation.component.AbstractBean;
import cokr.xit.foundation.data.DataObject;
/** 단속 설정 Bean
* @author leebj
*/
@Component("crdnStngBean")
public class CrdnStngBean extends AbstractBean {
public static String[] SAFE_TAG_AREA = {"03","06","07"}; //안전표지구역
public static String[] CAR_GROUP1 = {"12","14","15","21"}; //승합자동차등
public static String[] CAR_GROUP2 = {"11","13"}; //승용자동차등
public static String[] CAR_GROUP3 = {"31"}; //이륜자동차등
@Resource(name = "crdnStngMapper")
private CrdnStngMapper crdnStngMapper;
@Resource(name = "crdnTeamMapper")
private CrdnTeamMapper crdnTeamMapper;
@Resource(name = "exmptnVhclMapper")
private ExmptnVhclMapper exmptnVhclMapper;
/**잔액을 계산한다.
* @param state 대장 자료 상태
* @param advntceAmt 사전통지금액
* @param ffnlgAmt 과태료금액
* @param minusAmt 감경금액
* @param adtnAmt 가산금액
* @param rcvmtAmt 수납금액
* @return 잔액
*/
public int getBalance(String state, int advntceAmt, int ffnlgAmt, int minusAmt, int adtnAmt, int rcvmtAmt) {
int result = 0;
if(Integer.parseInt(state) < Integer.parseInt("51")) {
result = advntceAmt - rcvmtAmt - minusAmt;
} else if(state.equals("71") ||
state.equals("72") ||
state.equals("73") ||
state.equals("74") ||
state.equals("75") ||
state.equals("76") ||
state.equals("80") ||
state.equals("81") ||
state.equals("82") ||
state.equals("83") ||
state.equals("84") ||
state.equals("85")) {
} else {
result = ffnlgAmt - rcvmtAmt - minusAmt + adtnAmt;
}
return result;
}
/**기본금액을 계산한다.
* @param crdn 단속 정보
* @return 최초금액, 사전통지금액
*/
public int[] getBasicAmt(Crdn crdn) {
int[] amt = {0, 0};
String taskSeCd = crdn.getTaskSeCd();
CrdnQuery query = new CrdnQuery();
query.setTaskSeCd(crdn.getTaskSeCd());
query.setAplcnYmd(crdn.getCrdnYmd());
String ffnlgCarmdlCd = crdn.getFfnlgCarmdlCd();
if(taskSeCd.equals("PVS") || taskSeCd.equals("BPV") || taskSeCd.equals("PES")) {
if(ifEmpty(ffnlgCarmdlCd, () -> "").equals("")) {
return amt;
}
}
if(taskSeCd.equals("PVS")) {
query.setAmtDcsnCdGroupId("FIM055");
String crdnSpareaCd = crdn.getCrdnSpareaCd();
if(Arrays.asList(SAFE_TAG_AREA).contains(crdnSpareaCd)) {
query.setAmtDcsnCd("02");
} else {
String crdnTm = crdn.getCrdnTm();
boolean workTimeYn = Integer.parseInt(crdnTm) >= 80000 && Integer.parseInt(crdnTm) <= 200000;
if(crdnSpareaCd.equals("01") && workTimeYn) {
query.setAmtDcsnCd("03");
} else if((crdnSpareaCd.equals("02") || crdnSpareaCd.equals("05")) && workTimeYn) {
query.setAmtDcsnCd("04");
} else {
query.setAmtDcsnCd("01");
}
}
query.setDtlAmtDcsnGroupId("FIM056");
if(Arrays.asList(CAR_GROUP1).contains(ffnlgCarmdlCd)) {
query.setDtlAmtDcsnCd("01");
}
if(Arrays.asList(CAR_GROUP2).contains(ffnlgCarmdlCd)) {
query.setDtlAmtDcsnCd("02");
}
int ffnlgCrdnAmt = Integer.parseInt(ifEmpty(crdnStngMapper.selectBasicAmt(query), () -> "0"));
if(ffnlgCrdnAmt > 0 && ifEmpty(crdn.getOvtmYn(), ()-> "").equals("Y")) {
ffnlgCrdnAmt += 10000;
}
amt[0] = ffnlgCrdnAmt;
amt[1] = (int)(ffnlgCrdnAmt * 0.8);
} else if(taskSeCd.equals("BPV")) {
query.setAmtDcsnCdGroupId("FIM056");
if(Arrays.asList(CAR_GROUP1).contains(ffnlgCarmdlCd)) {
query.setAmtDcsnCd("01");
}
if(Arrays.asList(CAR_GROUP2).contains(ffnlgCarmdlCd)) {
query.setAmtDcsnCd("02");
}
if(Arrays.asList(CAR_GROUP3).contains(ffnlgCarmdlCd)) {
query.setAmtDcsnCd("03");
}
int ffnlgCrdnAmt = Integer.parseInt(ifEmpty(crdnStngMapper.selectBasicAmt(query), () -> "0"));
amt[0] = ffnlgCrdnAmt;
amt[1] = ffnlgCrdnAmt;
} else if(taskSeCd.equals("DPV")) {
query.setAmtDcsnCdGroupId("FIM006");
query.setAmtDcsnCd(crdn.getVltnCd());
int ffnlgCrdnAmt = Integer.parseInt(ifEmpty(crdnStngMapper.selectBasicAmt(query), () -> "0"));
amt[0] = ffnlgCrdnAmt;
amt[1] = (int)(ffnlgCrdnAmt * 0.8);
} else if(taskSeCd.equals("ECA")) {
query.setAmtDcsnCdGroupId("FIM061");
query.setAmtDcsnCd(crdn.getVltnCd());
int ffnlgCrdnAmt = Integer.parseInt(ifEmpty(crdnStngMapper.selectBasicAmt(query), () -> "0"));
amt[0] = ffnlgCrdnAmt;
amt[1] = (int)(ffnlgCrdnAmt * 0.8);
} else if(taskSeCd.equals("PES")) {
query.setAmtDcsnCdGroupId("FIM057");
if(ffnlgCarmdlCd.equals("21")) {
query.setAmtDcsnCd("01");
query.setDtlAmtDcsnGroupId("FIM059");
String vltnNmtm = crdn.getVltnNmtm();
if(vltnNmtm == null || vltnNmtm.equals("") || vltnNmtm.equals("0") || vltnNmtm.equals("1")) {
query.setDtlAmtDcsnCd("01");
} else if(vltnNmtm.equals("2")) {
query.setDtlAmtDcsnCd("02");
} else {
query.setDtlAmtDcsnCd("03");
}
}
if(ffnlgCarmdlCd.equals("13") || ffnlgCarmdlCd.equals("14")) {
query.setAmtDcsnCd("02");
query.setDtlAmtDcsnGroupId("FIM058");
//query.setDtlAmtDcsnCd(업종); // TODO : 차주 업종
}
;
int ffnlgCrdnAmt = Integer.parseInt(ifEmpty(crdnStngMapper.selectBasicAmt(query), () -> "0"));
amt[0] = ffnlgCrdnAmt;
boolean isPenaltyAmt = (crdn.getFfnlgCarmdlCd().equals("13") || crdn.getFfnlgCarmdlCd().equals("14")); //과징금
if(isPenaltyAmt) {
amt[1] = (ffnlgCrdnAmt);
} else {
amt[1] = (int)(ffnlgCrdnAmt * 0.8);
}
}
return amt;
}
/** 차량번호로 렌트카 여부를 확인한다.
* @param vhrno 차량번호
* @return 렌트카 여부
*/
public boolean isRent(String vhrno) {
int len = vhrno.length();
if(len >= 7) {
String fifthFromLast = vhrno.substring(len-5, len-4);
if(fifthFromLast.equals("하")
|| fifthFromLast.equals("허")
|| fifthFromLast.equals("호")
|| fifthFromLast.equals("후")) {
return true;
}
}
return false;
}
/** 차종과 차량번호로 영업용 차량 여부를 확인한다.
* @param ffnlgCarmdlCd 차종, vhrno 차량번호
* @return 영업용 차량 여부 판단 결과
*/
public String getBusinessYnOfCar(String ffnlgCarmdlCd, String vhrno) {
if(vhrno.equals("")) {
return "차량번호없음";
}
if(ffnlgCarmdlCd.equals("") || ffnlgCarmdlCd.equals("31")) {
return "판단불가";
}
if(vhrno.contains("바") || vhrno.contains("사") || vhrno.contains("아") || vhrno.contains("자")) {
return "영업용";
} else {
return "비영업용";
}
}
/** 차량번호로 차량구분을 판단한다.
* @param vhrno 차량번호
* @return 영업용 차량 여부 판단 결과
*/
public String getCarGb(String vhrno) {
if(vhrno.equals("")) {
return "차량번호 없음";
}
boolean first3isNumber = CmmnUtil.isNumeric(vhrno.substring(0, 3));
if(first3isNumber) {
int first3 = Integer.parseInt(vhrno.substring(0, 3));
if(first3 >= 0 && first3 <= 99) {
return "중기";
} else if(first3 >= 100 && first3 <= 997) {
return "일반";
} else if(first3 >= 998 && first3 <= 999) {
return "기타";
}
}
if(!(this.getHeavyEquipmentCarkind(vhrno).equals(""))) {
return "중기";
}
if(vhrno.contains("외교")) {
return "외교";
}
if(vhrno.contains("준외")) {
return "준외";
}
if(vhrno.contains("영사")) {
return "영사";
}
if(vhrno.contains("준영")) {
return "준영";
}
if(vhrno.contains("국기") || vhrno.contains("협정") || vhrno.contains("대표") || vhrno.contains("외빈")) {
return "국제";
}
if(vhrno.substring(0,1).equals("임")) {
return "임시";
}
if(vhrno.length() == 7
&& vhrno.substring(0, 3).equals("16다")
&& CmmnUtil.isNumeric(vhrno.substring(3, 7))) {
return "미군";
}
if(vhrno.length() == 10
&& this.isBiefSidoName(vhrno.substring(0, 2))
&& CmmnUtil.isNumeric(vhrno.substring(2, 5))
&& vhrno.substring(5, 6).equals("-")
&& CmmnUtil.isNumeric(vhrno.substring(6, 10))) {
return "미군";
}
int vhrnoLength = vhrno.length();
if(this.isBiefSidoName(vhrno.substring(0, 2))) {
//서울 0 가 0000
//서울 00 가 0000
//서울 중 가 0000
//서울 마포 가 0000
//서울 영등포 가 0000
if(vhrnoLength >= 8 && vhrnoLength <= 10) {
String suffix1 = vhrno.substring(vhrnoLength-5, vhrnoLength-4);
String suffix2 = vhrno.substring(vhrnoLength-4);
String middle = vhrno.substring(2, vhrnoLength-5);
if(CmmnUtil.isKorean(suffix1) && CmmnUtil.isNumeric(suffix2)) {
if(CmmnUtil.isNumeric(middle) && (middle.length() == 1 || middle.length() == 2)) {
return "일반";
}
if(CmmnUtil.isKorean(middle) && (middle.length() >= 1 && middle.length() <= 3)) {
return "일반";
}
}
}
} else {
//00가0000
if(vhrnoLength == 7
&& CmmnUtil.isNumeric(vhrno.substring(0, 2))
&& CmmnUtil.isKorean(vhrno.substring(2, 3))
&& CmmnUtil.isNumeric(vhrno.substring(3, 7))) {
return "일반";
}
}
return "판단불가";
}
public String getHeavyEquipmentCarkind(String vhrno) {
if(this.isBiefSidoName(vhrno.substring(0, 2))
&& CmmnUtil.isKorean(vhrno.substring(4, 5))
&& CmmnUtil.isNumeric(vhrno.substring(5, 9))
) {
switch(vhrno.substring(2, 4)) {
case "01" : return "불도저";
case "02" : return "굴삭기";
case "03" : return "로더";
case "04" : return "지게차";
case "05" : return "스크레이퍼";
case "06" : return "덤프트럭";
case "07" : return "기중기";
case "08" : return "콘크리트믹서트럭";
case "14" :
if(!vhrno.substring(4,5).equals("허")) {
return "콘크리트믹서트럭";
}
}
switch(vhrno.substring(2, 5)) {
case "26거" : return "도로보수트럭";
case "26너" : return "노면파쇄기";
case "26버" : return "터널고소용자동차";
case "26어" : return "수목이식기";
}
}
return "";
}
public boolean isBiefSidoName(String str) {
String[] sidoNames = {
"서울","대전","대구","부산","광주","인천","울산","세종",
"경기","강원","충북","충남","전북","전남","경북","경남","제주"
};
if(Arrays.asList(sidoNames).contains(str)) {
return true;
} else {
return false;
}
}
/**단속팀 목록을 조회한다.
* @param query 단속팀 목록 조회조건
* @return 단속팀 목록
*/
public List<DataObject> selectTeamList(CrdnQuery query){
return crdnTeamMapper.selectTeamList(query);
}
/**비사용 단속팀 목록을 조회한다.
* @param query 비사용 단속팀 목록 조회조건
* @return 비사용 단속팀 목록
*/
public List<DataObject> selectRemovedTeamList(CrdnQuery query) {
return crdnTeamMapper.selectRemovedTeamList(query);
}
/**단속팀 정보를 삭제한다.
* @param teamId 단속팀 ID
* @return 저장 여부
* <ul><li>저장됐으면 true</li>
* <li>그렇지 않으면 false</li>
* </ul>
*/
public boolean removeTeamInfo(String teamId) {
Team team = new Team();
team.setTeamId(teamId);
team.setRemovedBy(currentUser().getId());
return crdnTeamMapper.deleteTeamInfo(team) == 1 ? true : false;
}
/**단속팀 정보를 저장한다.
* @param fromInsertCrdn 단속정보 입력 프로세스에서 호출하였는지 여부, teamId 단속팀 ID
* @return 저장 여부
* <ul><li>저장됐으면 true</li>
* <li>그렇지 않으면 false</li>
* </ul>
*/
public boolean saveTeamInfo(boolean fromInsertCrdn, Team team) {
DataObject teamInfo = crdnTeamMapper.selectTeamInfoByName(team);
boolean result = false;
if(teamInfo != null) {
boolean differ = false;
if(!ifEmpty(team.getCrdnSeCd(), () -> "").equals(teamInfo.string("CRDN_SE_CD"))) {
differ = true;
}
if(!ifEmpty(team.getTeamer1(), () -> "").equals(teamInfo.string("TEAMER_1"))) {
differ = true;
}
if(!ifEmpty(team.getTeamer2(), () -> "").equals(teamInfo.string("TEAMER_2"))) {
differ = true;
}
if(!ifEmpty(team.getTeamer3(), () -> "").equals(teamInfo.string("TEAMER_3"))) {
differ = true;
}
if(!ifEmpty(team.getTeamer4(), () -> "").equals(teamInfo.string("TEAMER_4"))) {
differ = true;
}
if(differ) {
Team del = new Team();
del.setTeamId(teamInfo.string("TEAM_ID"));
del.setRemovedBy(currentUser().getId());
crdnTeamMapper.deleteTeamInfo(del);
result = crdnTeamMapper.insertTeamInfo(team) == 1 ? true : false;
} else {
if(!fromInsertCrdn) {
team.setTeamId(teamInfo.string("TEAM_ID"));
result = crdnTeamMapper.updateTeamInfo(team) == 1 ? true : false;
}
}
} else {
result = crdnTeamMapper.insertTeamInfo(team) == 1 ? true : false;
}
return result;
}
/**단속팀 정보를 조회한다.
* @param teamId 단속팀 ID
* @return 단속팀 정보
*/
public DataObject selectTeamInfo(String teamId) {
return crdnTeamMapper.selectTeamInfo(teamId);
}
/**면제차량 목록을 조회한다.
* @param query 면제차량 목록 조회조건
* @return 면제차량 목록
*/
public List<DataObject> selectExemptionVehicleList(CrdnQuery query) {
return exmptnVhclMapper.selectExemptionVehicleList(query);
}
/**면제차량 정보를 조회한다.
* @param exemptionVehicleId 면제차량 ID
* @return 면제차량 정보
*/
public DataObject getExemptionVehicleInfo(String exemptionVehicleId) {
return exmptnVhclMapper.selectExemptionVehicleInfo(exemptionVehicleId);
}
/**면제차량 정보를 등록한다.
* @param exmptnVhcl 면제차량 정보
* @return 저장 여부
* <ul><li>저장됐으면 true</li>
* <li>그렇지 않으면 false</li>
* </ul>
*/
public boolean createExemptionVehicleInfo(ExmptnVhcl exmptnVhcl) {
if(exmptnVhclMapper.insertExemptionVehicleInfo(exmptnVhcl) != 1) {
return false;
}
return exmptnVhclMapper.insertExemptionVehicleHistory(exmptnVhcl) == 1 ? true : false;
}
/**면제차량 정보를 수정한다.
* @param exmptnVhcl 면제차량 정보
* @return 저장 여부
* <ul><li>저장됐으면 true</li>
* <li>그렇지 않으면 false</li>
* </ul>
*/
public boolean updateExemptionVehicleInfo(ExmptnVhcl exmptnVhcl) {
if(exmptnVhclMapper.updateExemptionVehicleInfo(exmptnVhcl) != 1) {
return false;
}
return exmptnVhclMapper.insertExemptionVehicleHistory(exmptnVhcl) == 1 ? true : false;
}
/**면제차량 정보를 삭제한다.
* @param exmptnVhcl 면제차량 정보
* @return 저장 여부
* <ul><li>저장됐으면 true</li>
* <li>그렇지 않으면 false</li>
* </ul>
*/
public boolean removeExemptionVehicleInfo(ExmptnVhcl exmptnVhcl) {
exmptnVhcl.setRemovedBy(currentUser().getId());
if(exmptnVhclMapper.deleteExemptionVehicleInfo(exmptnVhcl) != 1) {
return false;
}
return exmptnVhclMapper.insertExemptionVehicleHistory(exmptnVhcl) == 1 ? true : false;
}
public List<DataObject> getExemptionVehicleHistoryList(String exmptnVhclId) {
return exmptnVhclMapper.selectExemptionVehicleHistoryList(exmptnVhclId);
}
}

66
src/main/java/cokr/xit/fims/excl/LevyExcl.java
Unescape Escape View File

@ -0,0 +1,66 @@
package cokr.xit.fims.excl;
import cokr.xit.foundation.AbstractEntity;
import lombok.Getter;
import lombok.Setter;
/**
* 부과 제외 대장
* @author JoJH
*/
@Getter
@Setter
public class LevyExcl extends AbstractEntity {
/**
* 부과 제외 ID
*/
private String levyExclId;
/**
* 단속 ID
*/
private String crdnId;
/**
* 부과 제외 일자
*/
private String levyExclYmd;
/**
* 부과 제외 구분 코드
*/
private String levyExclSeCd;
/**
* 부과 제외 사유 코드
*/
private String levyExclRsnCd;
/**
* 기타 내용
*/
private String etcCn;
/**
* 삭제 여부
*/
private String delYn;
/**
* 삭제 사유
*/
private String delRsn;
// 추가 /////////////////////////////////////////////////////////////////////
/**
* 부과제외 Ids
*/
private String[] levyExclIds;
/**
* 시군구 코드
*/
private String sggCd;
}

345
src/main/java/cokr/xit/fims/excl/LevyExclQuery.java
Unescape Escape View File

@ -0,0 +1,345 @@
package cokr.xit.fims.excl;
import cokr.xit.fims.cmmn.CmmnQuery;
/**부과제외 대장 정보 조회 요청
*
* <p>상세 설명:
*
* <pre>
* ============ 변경 이력 ============
* 2023-06-23 JoJH 최초 작성
* ================================
* </pre>
*/
public class LevyExclQuery extends CmmnQuery {
private static final long serialVersionUID = 1L;
// ID
private String crdnId; // 단속 ID
private String[] levyExclIds; // 부과제외 Ids
private String levyExclId; // 부과제외 ID
private String[] opnnIds; // 의견제출 Ids
private String opnnId; // 의견제출 ID
private String mngId; // 의견제출 심의 회원 ID
private String[] reRegIds; // 재등록 Ids
private String reRegId; // 재등록 ID
// 검색 조건
private String schLevyExclYmdFrom; // 부과제외_부과제외 일자 시작
private String schLevyExclYmdTo; // 부과제외_부과제외 일자 종료
private String schLevyExclSeCd; // 부과제외_부과제외 구분 코드
private String schLevyExclRsnCd; // 부과제외_부과제외 구분 코드
private String schRcptYmdFrom; // 의견제출_접수 일자 시작
private String schRcptYmdTo; // 의견제출_접수 일자 종료
private String schAnsYmdFrom; // 의견제출_답변 일자 시작
private String schAnsYmdTo; // 의견제출_답변 일자 종료
private String schOpnnSbmsnSttsCd; // 의견제출_의견 제출 상태 코드
private String schOpnnSbmsnSeCd; // 의견제출_의견 제출 구분 코드
private String schNtfctnSeCd; // 의견제출_통보 구분 코드
private String schSttrNm; // 의견제출_진술자 명
private String schReRegYmdFrom; // 단속재등록_재등록 일자 시작
private String schReRegYmdTo; // 단속재등록_재등록 일자 종료
// 상세 검색 조건
private String schCrdnYmdFrom; // 단속(TB_CRDN)_단속 일자 시작
private String schCrdnYmdTo; // 단속(TB_CRDN)_단속 일자 종료
private String schVhrno; // 단속(TB_CRDN)_차량번호
private String schRtpyrNo; // 납부자(TB_PAYER)_납부자 번호
private String schRtpyrNm; // 납부자(TB_PAYER)_납부자 명
// ETC
private String callPurpose; // infoDialog 호출 용도(view 조회(편집불가), create 등록, update 수정, refresh 재조회).
private String delRsn; // 삭제 사유
private String levyExclSeCd; // 부과제외_부과 제외 구분 코드
private String ansRsnCd; // 민원 답변 문구(TB_CVLCPT_ANS_WORDS) - 답변 사유 코드
private String sndngRcvmtCd; // 발송 수납 코드
public String getCrdnId() {
return ifEmpty(crdnId, () -> null);
}
public <T extends LevyExclQuery> T setCrdnId(String crdnId) {
this.crdnId = crdnId;
return self();
}
public String[] getLevyExclIds() {
return ifEmpty(levyExclIds, () -> null);
}
public <T extends LevyExclQuery> T setLevyExclIds(String... levyExclIds) {
this.levyExclIds = levyExclIds;
return self();
}
public String getLevyExclId() {
return ifEmpty(levyExclId, () -> null);
}
public <T extends LevyExclQuery> T setLevyExclId(String levyExclId) {
this.levyExclId = levyExclId;
return self();
}
public String[] getOpnnIds() {
return ifEmpty(opnnIds, () -> null);
}
public <T extends LevyExclQuery> T setOpnnIds(String... opnnIds) {
this.opnnIds = opnnIds;
return self();
}
public String getOpnnId() {
return ifEmpty(opnnId, () -> null);
}
public <T extends LevyExclQuery> T setOpnnId(String opnnId) {
this.opnnId = opnnId;
return self();
}
public String getMngId() {
return ifEmpty(mngId, () -> null);
}
public <T extends LevyExclQuery> T setMngId(String mngId) {
this.mngId = mngId;
return self();
}
public String[] getReRegIds() {
return ifEmpty(reRegIds, () -> null);
}
public <T extends LevyExclQuery> T setReRegIds(String... reRegIds) {
this.reRegIds = reRegIds;
return self();
}
public String getReRegId() {
return ifEmpty(reRegId, () -> null);
}
public <T extends LevyExclQuery> T setReRegId(String reRegId) {
this.reRegId = reRegId;
return self();
}
public String getSchLevyExclYmdFrom() {
return ifEmpty(schLevyExclYmdFrom, () -> null);
}
public <T extends LevyExclQuery> T setSchLevyExclYmdFrom(String schLevyExclYmdFrom) {
this.schLevyExclYmdFrom = schLevyExclYmdFrom;
return self();
}
public String getSchLevyExclYmdTo() {
return ifEmpty(schLevyExclYmdTo, () -> null);
}
public <T extends LevyExclQuery> T setSchLevyExclYmdTo(String schLevyExclYmdTo) {
this.schLevyExclYmdTo = schLevyExclYmdTo;
return self();
}
public String getSchLevyExclSeCd() {
return ifEmpty(schLevyExclSeCd, () -> null);
}
public <T extends LevyExclQuery> T setSchLevyExclSeCd(String schLevyExclSeCd) {
this.schLevyExclSeCd = schLevyExclSeCd;
return self();
}
public String getSchLevyExclRsnCd() {
return ifEmpty(schLevyExclRsnCd, () -> null);
}
public <T extends LevyExclQuery> T setSchLevyExclRsnCd(String schLevyExclRsnCd) {
this.schLevyExclRsnCd = schLevyExclRsnCd;
return self();
}
public String getSchRcptYmdFrom() {
return ifEmpty(schRcptYmdFrom, () -> null);
}
public <T extends LevyExclQuery> T setSchRcptYmdFrom(String schRcptYmdFrom) {
this.schRcptYmdFrom = schRcptYmdFrom;
return self();
}
public String getSchRcptYmdTo() {
return ifEmpty(schRcptYmdTo, () -> null);
}
public <T extends LevyExclQuery> T setSchRcptYmdTo(String schRcptYmdTo) {
this.schRcptYmdTo = schRcptYmdTo;
return self();
}
public String getSchAnsYmdFrom() {
return ifEmpty(schAnsYmdFrom, () -> null);
}
public <T extends LevyExclQuery> T setSchAnsYmdFrom(String schAnsYmdFrom) {
this.schAnsYmdFrom = schAnsYmdFrom;
return self();
}
public String getSchAnsYmdTo() {
return ifEmpty(schAnsYmdTo, () -> null);
}
public <T extends LevyExclQuery> T setSchAnsYmdTo(String schAnsYmdTo) {
this.schAnsYmdTo = schAnsYmdTo;
return self();
}
public String getSchOpnnSbmsnSttsCd() {
return ifEmpty(schOpnnSbmsnSttsCd, () -> null);
}
public <T extends LevyExclQuery> T setSchOpnnSbmsnSttsCd(String schOpnnSbmsnSttsCd) {
this.schOpnnSbmsnSttsCd = schOpnnSbmsnSttsCd;
return self();
}
public String getSchOpnnSbmsnSeCd() {
return ifEmpty(schOpnnSbmsnSeCd, () -> null);
}
public <T extends LevyExclQuery> T setSchOpnnSbmsnSeCd(String schOpnnSbmsnSeCd) {
this.schOpnnSbmsnSeCd = schOpnnSbmsnSeCd;
return self();
}
public String getSchNtfctnSeCd() {
return ifEmpty(schNtfctnSeCd, () -> null);
}
public <T extends LevyExclQuery> T setSchNtfctnSeCd(String schNtfctnSeCd) {
this.schNtfctnSeCd = schNtfctnSeCd;
return self();
}
public String getSchSttrNm() {
return ifEmpty(schSttrNm, () -> null);
}
public <T extends LevyExclQuery> T setSchSttrNm(String schSttrNm) {
this.schSttrNm = schSttrNm;
return self();
}
public String getSchReRegYmdFrom() {
return ifEmpty(schReRegYmdFrom, () -> null);
}
public <T extends LevyExclQuery> T setSchReRegYmdFrom(String schReRegYmdFrom) {
this.schReRegYmdFrom = schReRegYmdFrom;
return self();
}
public String getSchReRegYmdTo() {
return ifEmpty(schReRegYmdTo, () -> null);
}
public <T extends LevyExclQuery> T setSchReRegYmdTo(String schReRegYmdTo) {
this.schReRegYmdTo = schReRegYmdTo;
return self();
}
// 상세 검색 조건 ///////////////////////////////////////////////////////////////
public String getSchCrdnYmdFrom() {
return ifEmpty(schCrdnYmdFrom, () -> null);
}
public void setSchCrdnYmdFrom(String schCrdnYmdFrom) {
this.schCrdnYmdFrom = schCrdnYmdFrom;
}
public String getSchCrdnYmdTo() {
return ifEmpty(schCrdnYmdTo, () -> null);
}
public void setSchCrdnYmdTo(String schCrdnYmdTo) {
this.schCrdnYmdTo = schCrdnYmdTo;
}
public String getSchVhrno() {
return ifEmpty(schVhrno, () -> null);
}
public void setSchVhrno(String schVhrno) {
this.schVhrno = schVhrno;
}
public String getSchRtpyrNo() {
return ifEmpty(schRtpyrNo, () -> null);
}
public void setSchRtpyrNo(String schRtpyrNo) {
this.schRtpyrNo = schRtpyrNo;
}
public String getSchRtpyrNm() {
return ifEmpty(schRtpyrNm, () -> null);
}
public void setSchRtpyrNm(String schRtpyrNm) {
this.schRtpyrNm = schRtpyrNm;
}
// 상세 검색 조건 ///////////////////////////////////////////////////////////////
// ETC /////////////////////////////////////////////////////////////////////
public String getCallPurpose() {
return ifEmpty(callPurpose, () -> null);
}
public <T extends LevyExclQuery> T setCallPurpose(String callPurpose) {
this.callPurpose = callPurpose;
return self();
}
public String getDelRsn() {
return ifEmpty(delRsn, () -> null);
}
public <T extends LevyExclQuery> T setDelRsn(String delRsn) {
this.delRsn = delRsn;
return self();
}
public String getLevyExclSeCd() {
return ifEmpty(levyExclSeCd, () -> null);
}
public <T extends LevyExclQuery> T setLevyExclSeCd(String levyExclSeCd) {
this.levyExclSeCd = levyExclSeCd;
return self();
}
public String getAnsRsnCd() {
return ifEmpty(ansRsnCd, () -> null);
}
public <T extends LevyExclQuery> T setAnsRsnCd(String ansRsnCd) {
this.ansRsnCd = ansRsnCd;
return self();
}
public String getSndngRcvmtCd() {
return ifEmpty(sndngRcvmtCd, () -> null);
}
public <T extends LevyExclQuery> T setSndngRcvmtCd(String sndngRcvmtCd) {
this.sndngRcvmtCd = sndngRcvmtCd;
return self();
}
// ETC /////////////////////////////////////////////////////////////////////
}

90
src/main/java/cokr/xit/fims/excl/dao/LevyExclMapper.java
Unescape Escape View File

@ -0,0 +1,90 @@
package cokr.xit.fims.excl.dao;
import java.util.List;
import org.egovframe.rte.psl.dataaccess.mapper.Mapper;
import cokr.xit.fims.crdn.Crdn;
import cokr.xit.fims.excl.LevyExcl;
import cokr.xit.fims.excl.LevyExclQuery;
import cokr.xit.foundation.component.AbstractMapper;
import cokr.xit.foundation.data.DataObject;
/** 부과제외 대장 정보 DAO
*
* <p>상세 설명: 부과제외 대장 테이블에 접근하여 데이터를 조회하고 저장한다.
*
* <pre>
* ============ 변경 이력 ============
* 2023-06-23 JoJH 최초 작성
* ================================
* </pre>
*/
@Mapper("levyExclMapper")
public interface LevyExclMapper extends AbstractMapper {
/**지정한 조건에 따라 부과제외 대장 목록을 조회하여 반환한다.
* @param req 부과제외 대장 조회 조건
* @return 부과제외 대장 목록
*/
List<DataObject> selectLevyExclList(LevyExclQuery req);
/**지정한 조건에 따라 부과제외 대장 객체들을 조회하여 반환한다.
* @param req 부과제외 대장 조회 조건
* @return 부과제외 대장 객체 정보
*/
List<DataObject> selectLevyExcls(LevyExclQuery req);
/**지정한 조건에 따라 부과제외 대장 정보를 조회하여 반환한다.
* @param req 부과제외 대장 조회 조건
* @return 부과제외 대장 정보
*/
default DataObject selectLevyExclInfo(LevyExclQuery req) {
// 삭제 여부 확인
if (req.getDelYn() == null) {
req.setDelYn("N");
}
// 기본 정렬
if (req.getOrderBy() == null) {
req.setOrderBy("LE.LEVY_EXCL_ID DESC");
}
List<DataObject> levyExcls = selectLevyExcls(req);
return !levyExcls.isEmpty() ? levyExcls.get(0) : null;
}
/**부과제외 대장 정보를 등록한다.
* @param params 파라미터
* <ul><li>"levyExcl" - 부과제외 대장</li>
* <li>"currentUser" - 현재 접속한 사용자</li>
* </ul>
* @return 저장된 정보수
*/
int insertLevyExcl(LevyExcl levyExcl);
/**부과제외 대장 정보를 수정한다.
* @param params 파라미터
* <ul><li>"levyExcl" - 부과제외 대장</li>
* <li>"currentUser" - 현재 접속한 사용자</li>
* </ul>
* @return 저장된 정보수
*/
int updateLevyExcl(LevyExcl levyExcl);
/**부과제외 대장 정보를 삭제한다.
* @param params 파라미터
* <ul><li>"levyExcl" - 부과제외 대장</li>
* <li>"currentUser" - 현재 접속한 사용자</li>
* </ul>
* @return 저장된 정보수
*/
int deleteLevyExcl(LevyExcl levyExcl);
/**단속(TB_CRDN) 대장의 주차가능결과코드를 수정한다.
* @param crdn 단속 대장
* @return 저장된 정보수
*/
int updatePrkPsbltyRsltCd(Crdn crdn);
}

288
src/main/java/cokr/xit/fims/excl/service/bean/LevyExclBean.java
Unescape Escape View File

@ -0,0 +1,288 @@
package cokr.xit.fims.excl.service.bean;
import java.util.List;
import javax.annotation.Resource;
import org.springframework.stereotype.Component;
import cokr.xit.fims.cmmn.CmmnUtil;
import cokr.xit.fims.cmmn.CrdnSttsHstry;
import cokr.xit.fims.cmmn.service.bean.CrdnSttsHstryBean;
import cokr.xit.fims.crdn.Crdn;
import cokr.xit.fims.excl.LevyExcl;
import cokr.xit.fims.excl.LevyExclQuery;
import cokr.xit.fims.excl.dao.LevyExclMapper;
import cokr.xit.fims.rdca.Rdamt;
import cokr.xit.fims.rdca.service.bean.RdamtBean;
import cokr.xit.foundation.component.AbstractBean;
import cokr.xit.foundation.data.DataObject;
/**부과제외 대장 정보 관리 Bean
*
* <p>상세 설명: 부과제외 대장 DAO(Excl01Mapper)를 사용해 업무 기능을 구현한 클래스
*
* <pre>
* ============ 변경 이력 ============
* 2023-06-23 JoJH 최초 작성
* ================================
* </pre>
*/
@Component("levyExclBean")
public class LevyExclBean extends AbstractBean {
/** 부과제외 대장 정보 DAO */
@Resource(name="levyExclMapper")
private LevyExclMapper levyExclMapper;
/** 단속 상태 이력 정보 Bean */
@Resource(name="crdnSttsHstryBean")
private CrdnSttsHstryBean crdnSttsHstryBean;
/** 감액 대장 정보 Bean */
@Resource(name="rdamtBean")
private RdamtBean rdamtBean;
/**지정한 조건에 따라 부과제외 대장 목록을 조회하여 반환한다.
* @param req 부과제외 조회 조건
* @return 부과제외 대장 목록
*/
public List<DataObject> getLevyExclList(LevyExclQuery req) {
// 삭제 여부 확인
if (req.getDelYn() == null) {
req.setDelYn("N");
}
// 정렬 확인
if (req.getOrderBy() == null) {
if (req.getBy() == null) {
req.setOrderBy("REG_DT");
} else {
req.setOrderBy(CmmnUtil.convertCamelCaseToSnakeCase(req.getBy()));
}
}
return levyExclMapper.selectLevyExclList(req);
}
/**지정한 조건에 따라 부과제외 이력 객체들을 반환한다.
* @param req 부과제외 조회 조건
* @return 부과제외 객체 목록
*/
public List<DataObject> getLevyExcls(LevyExclQuery req) {
// 삭제 여부 확인
if (req.getDelYn() == null) {
req.setDelYn("N");
}
// 정렬 확인
if (req.getOrderBy() == null) {
req.setOrderBy("LE.LEVY_EXCL_ID DESC");
}
return levyExclMapper.selectLevyExcls(req);
}
/**지정한 부과제외 ID의 부과제외 정보를 반환한다.
* @param req 부과제외 조회 조건
* @return 부과제외 정보
*/
public DataObject getLevyExclInfo(LevyExclQuery req) {
DataObject info = levyExclMapper.selectLevyExclInfo(req);
// 신규 부과제외 등록일 경우 부과제외 구분코드를 입력한다.
if (req.getCallPurpose().equals("create")) {
info.set("LEVY_EXCL_SE_CD", req.getLevyExclSeCd());
}
return info;
}
/**부과제외 대장 정보를 등록한다.
* @param excl 부과제외 대장
* @return 저장 여부
* <ul><li>저장됐으면 true</li>
* <li>그렇지 않으면 false</li>
* </ul>
*/
public String createLevyExcl(LevyExcl levyExcl) {
// 변수 선언
int rtnNocs = -1; // 처리 결과 건수
String rtnMsg = ""; // 처리 결과 메시지
// 단속 ID로 단속, 부과제외 정보 조회
DataObject levyExclInfo = levyExclMapper.selectLevyExclInfo(new LevyExclQuery().setCrdnId(levyExcl.getCrdnId()));
// 등록 대상 자료 검증
if (!levyExclInfo.string("LEVY_EXCL_ID").equals("")) { // 부과제외 ID가 있다면 이미 부과제외 자료가 존재하므로 종료..
rtnMsg = "[F] 작업중 이미 등록된 부과제외 자료가 존재합니다.";
return rtnMsg;
}
if (!levyExclInfo.string("CVLCPT_LINK_ID").equals("")) { // 민원 ID
if (levyExclInfo.string("CVLCPT_PRCS_CD").equals("00")) { // 민원 처리상태 확인
rtnMsg = "[F] 작업중 단속 민원 자료가 처리 되지 않았습니다.<br>단속 민원 업무를 먼저 처리 하시기 바랍니다.";
return rtnMsg;
}
}
if (levyExcl.getLevyExclSeCd().contains("1,2")) { // 비부과(서손), 계고
if (levyExclInfo.number("CRDN_STTS_CD").intValue() >= 51) { // 단속상태코드가 부과(51) 보다 크다면, 비부과 또는 계고 등록을 할 수 없다.
rtnMsg = "[F] 작업중 오류가 발생하였습니다.<br>현재 자료의 단속상태가 " + levyExclInfo.string("CRDN_STTS_NM") + " 상태 입니다.";
return rtnMsg;
}
} else if (levyExcl.getLevyExclSeCd().equals("3")) { // 부과취소
if (levyExclInfo.number("CRDN_STTS_CD").intValue() < 51) { // 단속상태코드가 부과(51) 보다 작다면, 전액감액 등록 할 수 없다.
rtnMsg = "[F] 작업중 오류가 발생하였습니다.<br>현재 자료의 단속상태가 " + levyExclInfo.string("CRDN_STTS_NM") + " 상태 입니다.";
return rtnMsg;
}
if (levyExclInfo.string("LEVY_ID").equals("")) { // 부과(TB_LEVY) 정보 확인
rtnMsg = "[F] 작업 중 부과 자료가 존재하지 않습니다.<br>비부과로 처리 하시기 바랍니다.";
return rtnMsg;
}
}
// 부과취소(전액감액)일 경우 부과(TB_LEVY)에 감액금액 입력이 필요..
if (levyExcl.getLevyExclSeCd().equals("3")) {
// 감액(TB_RDAMT) 등록
Rdamt rdamt = new Rdamt();
rdamt.setLevyId(levyExclInfo.string("LEVY_ID")); // 부과 ID
rdamt.setRdamtYmd(levyExcl.getLevyExclYmd()); // 감액 일자
rdamt.setRdamtSeCd("02"); // 감액 구분 코드 FIM085 - 02:부과취소
rdamt.setRdamtRsnCd(levyExcl.getLevyExclRsnCd()); // 감액 사유 코드
rtnMsg = rdamtBean.createRdamt(rdamt);
if (!rtnMsg.contains("[S]")) {
throw new RuntimeException(rtnMsg.replace("[F]", "")); // 예외를 발생시켜서 DB Rollback
}
}
// 부과제외(TB_LEVY_EXCL) 대장을 등록한다.
rtnNocs = levyExclMapper.insertLevyExcl(levyExcl);
if (rtnNocs != 1) {
throw new RuntimeException("부과제외 정보 등록에 실패하였습니다."); // 예외를 발생시켜서 DB Rollback
}
// 표지정보 확인여부가 미확인(0)이면 -> 조회미대상(9) 으로
if (levyExclInfo.string("PRK_PSBLTY_RSLT_CD").equals("0")) { // 주차 가능 결과 코드(FIM034) - 0: 미확인
Crdn crdn = new Crdn();
crdn.setCrdnId(levyExclInfo.string("CRDN_ID")); // 단속 ID
crdn.setPrkPsbltyRsltCd("9"); // 주차 가능 결과 코드(FIM034) 9: 조회미대상
rtnNocs = levyExclMapper.updatePrkPsbltyRsltCd(crdn);
if (rtnNocs != 1) {
throw new RuntimeException("부과제외 삭제 작업 중 단속 대장의 표지정보 수정에 실패하였습니다."); // 예외를 발생시켜서 DB Rollback
}
}
// 단속 상태 이력(TB_CRDN_STTS_HSTRY) 대장에 등록하고, 단속(TB_CRDN) 대장을 수정한다.
String newCrdnSttsCd = ""; // 신규 단속 상태 코드(CRDN_STTS_CD)
if (levyExcl.getLevyExclSeCd().equals("1")) { // 비부과
newCrdnSttsCd = "81"; // 비부과(서손)
} else if (levyExcl.getLevyExclSeCd().equals("2")) { // 계고
newCrdnSttsCd = "83"; // 계고
} else if (levyExcl.getLevyExclSeCd().equals("3")) { // 부과취소(전액감액)
newCrdnSttsCd = "80"; // 부과취소
}
// 단속상태이력(TB_CRDN_STTS_HSTRY)
CrdnSttsHstry crdnSttsHstry = new CrdnSttsHstry();
crdnSttsHstry.setCrdnId(levyExclInfo.string("CRDN_ID"));
crdnSttsHstry.setBfrSttsCd(levyExclInfo.string("CRDN_STTS_CD"));
crdnSttsHstry.setBfrSttsChgDt(levyExclInfo.string("CRDN_STTS_CHG_DT"));
crdnSttsHstry.setCrdnSttsCd(newCrdnSttsCd);
crdnSttsHstry.setTaskDtlId(levyExcl.getLevyExclId());
boolean rtnScs = crdnSttsHstryBean.createHstryUpdateCrdnSttsCd(crdnSttsHstry);
if (!rtnScs) {
throw new RuntimeException("부과제외 등록 작업 중 단속상태 변경에 실패하였습니다."); // 예외를 발생시켜서 DB Rollback
}
return "[S] 작업이 정상 처리 되었습니다.";
}
/**부과제외 대장 정보를 수정한다.
* @param excl 부과제외 대장
* @return 저장 여부
* <ul><li>저장됐으면 true</li>
* <li>그렇지 않으면 false</li>
* </ul>
*/
public String updateLevyExcl(LevyExcl levyExcl) {
// 부과제외(TB_LEVY_EXCL) 대장을 수정한다.
int rtnNocs = levyExclMapper.updateLevyExcl(levyExcl);
if (rtnNocs != 1) {
throw new RuntimeException("부과제외 정보 수정에 실패하였습니다."); // 예외를 발생시켜서 DB Rollback
}
return "[S] 작업이 정상 처리 되었습니다.";
}
/**부과제외 대장 정보를 삭제한다.
* @param excl 부과제외 대장
* @return 저장 여부
* <ul><li>저장됐으면 true</li>
* <li>그렇지 않으면 false</li>
* </ul>
*/
public String removeLevyExcl(LevyExcl levyExcl) {
// 변수 선언
int rtnNocs = -1; // 처리 결과 건수
String rtnMsg = ""; // 처리 결과 메시지
// 부과제외(TB_LEVY_EXCL) 정보를 조회한다.
DataObject levyExclInfo = levyExclMapper.selectLevyExclInfo(new LevyExclQuery().setLevyExclId(levyExcl.getLevyExclId()));
// 삭제 대상 자료 검증
if (levyExclInfo.string("LEVY_EXCL_ID").equals("")) {
rtnMsg = "[F] 작업 중 오류가 발생하였습니다.<br>부과제외 자료가 존재하지 않습니다.";
return rtnMsg;
}
if (levyExclInfo.string("LEVY_EXCL_SE_CD").equals("1") && !levyExclInfo.string("CRDN_STTS_CD").equals("81")) { // 비부과(서손)
rtnMsg = "[F] 작업 중 오류가 발생하였습니다.<br>현재 자료의 단속 상태가 " + levyExclInfo.string("CRDN_STTS_NM") + " 이(가) 아닙니다.";
return rtnMsg;
} else if (levyExclInfo.string("LEVY_EXCL_SE_CD").equals("2") && !("83,84").contains(levyExclInfo.string("CRDN_STTS_CD"))) { // 계고
rtnMsg = "[F] 작업 중 오류가 발생하였습니다.<br>현재 자료의 단속 상태가 " + levyExclInfo.string("CRDN_STTS_NM") + " 이(가) 아닙니다.";
return rtnMsg;
} else if (levyExclInfo.string("LEVY_EXCL_SE_CD").equals("3") && !levyExclInfo.string("CRDN_STTS_CD").equals("80")) { // 부과취소
rtnMsg = "[F] 작업 중 오류가 발생하였습니다.<br>현재 자료의 단속 상태가 " + levyExclInfo.string("CRDN_STTS_NM") + " 이(가) 아닙니다.";
return rtnMsg;
}
// 부과제외(TB_LEVY_EXCL) 대장을 삭제한다.
rtnNocs = levyExclMapper.deleteLevyExcl(levyExcl);
if (rtnNocs != 1) {
throw new RuntimeException("부과제외 정보 삭제에 실패하였습니다."); // 예외를 발생시켜서 DB Rollback
}
// 단속상태이력(TB_CRDN_STTS_HSTRY) 대장에 부과제외 이력삭제 및 부과제외삭제 이력을 등록한다.
String deltCrdnSttsCd = "";
if (levyExclInfo.string("CRDN_STTS_CD").equals("80")) { // 임시
throw new RuntimeException("부과취소는 부과제외 삭제에 실패하였습니다."); // 예외를 발생시켜서 DB Rollback
} else if (levyExclInfo.string("CRDN_STTS_CD").equals("81")) {
deltCrdnSttsCd = "91"; // 비부과(서손) 삭제
} else if (("83,84").contains(levyExclInfo.string("CRDN_STTS_CD"))) {
deltCrdnSttsCd = "93"; // 계고 삭제
}
boolean rtnScs = crdnSttsHstryBean.removeHstryUpdateCrdnSttsCd(levyExclInfo.string("CRDN_ID"), levyExclInfo.string("CRDN_STTS_CD"), deltCrdnSttsCd, levyExcl.getDelRsn(), true);
if (!rtnScs) {
throw new RuntimeException("부과제외 삭제 작업 중 단속상태이력 삭제 및 등록에 실패하였습니다."); // 예외를 발생시켜서 DB Rollback
}
// 부과제외 구분이 비부과(서손)일 경우
if (levyExclInfo.string("LEVY_EXCL_SE_CD").equals("1")) {
// 표지정보 확인여부가 조회미대상이면 -> 미확인 으로
// 혹시 차적조회가 안되었으면? 놔두자 차적조회되면 그 때 표지정보 BJ_Send가 처리할테니
if (levyExclInfo.string("PRK_PSBLTY_RSLT_CD").equals("9")) { // 주차 가능 결과 코드 - 9 조회 미대상
Crdn crdn = new Crdn();
crdn.setCrdnId(levyExclInfo.string("CRDN_ID")); // 단속 ID
crdn.setPrkPsbltyRsltCd("0"); // 주차 가능 결과 코드 - 0 미확인
rtnNocs = levyExclMapper.updatePrkPsbltyRsltCd(crdn);
if (rtnNocs != 1) {
throw new RuntimeException("부과제외 삭제 작업 중 단속 대장의 표지정보 수정에 실패하였습니다."); // 예외를 발생시켜서 DB Rollback
}
}
}
return "[S] 작업이 정상 처리 되었습니다.";
}
}

466
src/main/java/cokr/xit/fims/levy/Levy.java
Unescape Escape View File

@ -0,0 +1,466 @@
package cokr.xit.fims.levy;
import cokr.xit.foundation.AbstractEntity;
import lombok.Getter;
import lombok.Setter;
/**
* 부과 대장
* @author JoJH
*/
@Getter
@Setter
public class Levy extends AbstractEntity {
/**
* 부과 ID
*/
private String levyId;
/**
* 시군구 코드
*/
private String sggCd;
/**
* 업무 구분 코드
*/
private String taskSeCd;
/**
* 단속 ID
*/
private String crdnId;
/**
* 기관 코드
*/
private String instCd;
/**
* 부서 코드
*/
private String deptCd;
/**
* 회계 연도
*/
private String fyr;
/**
* 회계 구분 코드
*/
private String acntgSeCd;
/**
* 세목 코드
*/
private String txitmCd;
/**
* 운영 항목 코드
*/
private String operItemCd;
/**
* 특별회계 사업 코드
*/
private String spclBizCd;
/**
* 부과 번호
*/
private String levyNo;
/**
* 분납 일련번호
*/
private String ispySn;
/**
* 부과 구분 코드
*/
private String levySeCd;
/**
* 통합 구분 코드
*/
private String untySeCd;
/**
* 감경 구분 코드
*/
private String rdctSeCd;
/**
* 분납 구분 명
*/
private String ispySeNm;
/**
* 부과 일자
*/
private String levyYmd;
/**
* 최초 납기 일자
*/
private String frstDudtYmd;
/**
* 납기 일자
*/
private String dudtYmd;
/**
* 과태료 금액
*/
private Integer ffnlgAmt;
/**
* 부과 본세
*/
private Integer levyPcptax;
/**
* 부과 가산금
*/
private Integer levyAdamt;
/**
* 분납 이자
*/
private Integer ispyInt;
/**
* 수납 본세
*/
private Integer rcvmtPcptax;
/**
* 수납 가산금
*/
private Integer rcvmtAdamt;
/**
* 감액 본세
*/
private Integer rdamtPcptax;
/**
* 감액 가산금
*/
private Integer rdamtAdamt;
/**
* 합계 금액
*/
private Integer sumAmt;
/**
* 납기 후 일자
*/
private String dudtAftrYmd;
/**
* 납기 후 금액
*/
private Integer dudtAftrAmt;
/**
* 과세 물건
*/
private String txtnThing;
/**
* 관리 아이템1
*/
private String mngItem1;
/**
* 관리 아이템2
*/
private String mngItem2;
/**
* 관리 아이템3
*/
private String mngItem3;
/**
* 관리 아이템4
*/
private String mngItem4;
/**
* 관리 아이템5
*/
private String mngItem5;
/**
* 관리 아이템6
*/
private String mngItem6;
/**
* 체납 사유 코드
*/
private String npmntRsnCd;
/**
* 수납 일자
*/
private String rcvmtYmd;
/**
* 납부 방법 구분 코드
*/
private String payMthdSeCd;
/**
* 압류 일자
*/
private String szrYmd;
/**
* 압류 물건
*/
private String szrThing;
/**
* 대체 압류 자동차등록번호
*/
private String rpmSzrVhrno;
/**
* 압류 해제 일자
*/
private String szrRmvYmd;
/**
* 압류 해제 사유
*/
private String szrRmvRsn;
/**
* 기타 내용
*/
private String etcCn;
/**
* 전자납부번호
*/
private String epayno;
/**
* 은행 명
*/
private String bankNm;
/**
* 가상 계좌번호
*/
private String vrActno;
/**
* 은행 명 2
*/
private String bankNm2;
/**
* 가상 계좌번호 2
*/
private String vrActno2;
/**
* 은행 명 3
*/
private String bankNm3;
/**
* 가상 계좌번호 3
*/
private String vrActno3;
/**
* 은행 명 4
*/
private String bankNm4;
/**
* 가상 계좌번호 4
*/
private String vrActno4;
/**
* 은행 명 5
*/
private String bankNm5;
/**
* 가상 계좌번호 5
*/
private String vrActno5;
/**
* 은행 명 6
*/
private String bankNm6;
/**
* 가상 계좌번호 6
*/
private String vrActno6;
/**
* 은행 명 7
*/
private String bankNm7;
/**
* 가상 계좌번호 7
*/
private String vrActno7;
/**
* 은행 명 8
*/
private String bankNm8;
/**
* 가상 계좌번호 8
*/
private String vrActno8;
/**
* 은행 명 9
*/
private String bankNm9;
/**
* 가상 계좌번호 9
*/
private String vrActno9;
/**
* 은행 명 10
*/
private String bankNm10;
/**
* 가상 계좌번호 10
*/
private String vrActno10;
/**
* 은행 명 11
*/
private String bankNm11;
/**
* 가상 계좌번호 11
*/
private String vrActno11;
/**
* 은행 명 12
*/
private String bankNm12;
/**
* 가상 계좌번호 12
*/
private String vrActno12;
/**
* 은행 명 13
*/
private String bankNm13;
/**
* 가상 계좌번호 13
*/
private String vrActno13;
/**
* 은행 명 14
*/
private String bankNm14;
/**
* 가상 계좌번호 14
*/
private String vrActno14;
/**
* 은행 명 15
*/
private String bankNm15;
/**
* 가상 계좌번호 15
*/
private String vrActno15;
/**
* 은행 명 16
*/
private String bankNm16;
/**
* 가상 계좌번호 16
*/
private String vrActno16;
/**
* 은행 명 17
*/
private String bankNm17;
/**
* 가상 계좌번호 17
*/
private String vrActno17;
/**
* 은행 명 18
*/
private String bankNm18;
/**
* 가상 계좌번호 18
*/
private String vrActno18;
/**
* 은행 명 19
*/
private String bankNm19;
/**
* 가상 계좌번호 19
*/
private String vrActno19;
/**
* 은행 명 20
*/
private String bankNm20;
/**
* 가상 계좌번호 20
*/
private String vrActno20;
/**
* 세외수입 부과 키
*/
private String nxrpLevyKey;
/**
* 삭제 여부
*/
private String delYn;
/**
* 삭제 사유
*/
private String delRsn;
/**
* 단속 Ids
*/
private String[] crdnIds;
}

428
src/main/java/cokr/xit/fims/levy/LevyQuery.java
Unescape Escape View File

@ -0,0 +1,428 @@
package cokr.xit.fims.levy;
import cokr.xit.fims.cmmn.CmmnQuery;
/**과태료 부과 대장 정보 조회 요청
*
* <p>상세 설명:
*
* <pre>
* ============ 변경 이력 ============
* 2023-08-30 JoJH 최초 작성
* ================================
* </pre>
*/
public class LevyQuery extends CmmnQuery {
private static final long serialVersionUID = 1L;
// ID
private String[] crdnIds; // 단속 Ids
private String crdnId; // 단속 ID
private String[] levyIds; // 부과 Ids
private String levyId; // 부과 ID
private String[] rdctIds; // 감경 Ids
private String rdctId; // 감경 ID
// 검색 조건
private String schFyr; // 회계연도
private String schLevyNoFrom; // 부과 번호 시작
private String schLevyNoTo; // 부과 번호 종료
private String schRdctSeCd; // 감경 구분 코드
private String schLevyYmdFrom; // 부과 일자 시작
private String schLevyYmdTo; // 부과 일자 종료
private String schRdctYmdFrom; // 감경 일자 시작
private String schRdctYmdTo; // 감경 일자 종료
private String schRdctRsnCd; // 감경 사유 코드
private String schCrdnYmdFrom; // 단속 일자 시작
private String schCrdnYmdTo; // 단속 일자 종료
private String schVhrno; // 차량번호
private String schCrdnSttsCd; // 단속 상태 코드
private String schVltnCd; // 위반 코드
private String schCvlcptRcptYmdFrom; // 민원 접수 일자 시작
private String schCvlcptRcptYmdTo; // 민원 접수 일자 종료
private String schCvlcptPrcsCmptnDtFrom; // 민원 처리 완료 일시 시작
private String schCvlcptPrcsCmptnDtTo; // 민원 처리 완료 일시 종료
private String schCvlcptPrcsPic; // 민원 처리 담당자
private String schRtpyrNo; // 납부자 번호
private String schRtpyrNm; // 납부자 명
// 상세 검색 조건
// ETC
private String callPurpose; // infoDialog 호출 용도(view 조회(편집불가), create 등록, update 수정, refresh 재조회).
private String delRsn; // 삭제 사유
private String tnocs; // 총 건수
private String gramtFfnlgAmt; // 총 금액
private String gramtAdvntceAmt; // 총 감경부과 금액
// 부과 등록
private String fyr; // 회계연도
private String acntgSeCd; // 회계 구분 코드
private String txitmCd; // 세목 코드
private String operItemCd; // 운영 항목 코드
private String levyYmd; // 부과 일자
private String dudtYmd; // 납기 일자
private String crdnSttsCd; // 단속 상태 코드
// ID
public String[] getCrdnIds() {
return ifEmpty(crdnIds, () -> null);
}
public <T extends LevyQuery> T setCrdnIds(String... crdnIds) {
this.crdnIds = crdnIds;
return self();
}
public String getCrdnId() {
return ifEmpty(crdnId, () -> null);
}
public <T extends LevyQuery> T setCrdnId(String crdnId) {
this.crdnId = crdnId;
return self();
}
public String[] getLevyIds() {
return ifEmpty(levyIds, () -> null);
}
public <T extends LevyQuery> T setLevyIds(String... levyIds) {
this.levyIds = levyIds;
return self();
}
public String getLevyId() {
return ifEmpty(levyId, () -> null);
}
public <T extends LevyQuery> T setLevyId(String levyId) {
this.levyId = levyId;
return self();
}
public String[] getRdctIds() {
return ifEmpty(rdctIds, () -> null);
}
public <T extends LevyQuery> T setRdctIds(String... rdctIds) {
this.rdctIds = rdctIds;
return self();
}
public String getRdctId() {
return ifEmpty(rdctId, () -> null);
}
public <T extends LevyQuery> T setRdctId(String rdctId) {
this.rdctId = rdctId;
return self();
}
// 검색 조건 //////////////////////////////////////////////////////////////////
public String getSchRdctYmdFrom() {
return ifEmpty(schRdctYmdFrom, () -> null);
}
public <T extends LevyQuery> T setSchRdctYmdFrom(String schRdctYmdFrom) {
this.schRdctYmdFrom = schRdctYmdFrom;
return self();
}
public String getSchRdctYmdTo() {
return ifEmpty(schRdctYmdTo, () -> null);
}
public <T extends LevyQuery> T setSchRdctYmdTo(String schRdctYmdTo) {
this.schRdctYmdTo = schRdctYmdTo;
return self();
}
public String getSchRdctRsnCd() {
return ifEmpty(schRdctRsnCd, () -> null);
}
public <T extends LevyQuery> T setSchRdctRsnCd(String schRdctRsnCd) {
this.schRdctRsnCd = schRdctRsnCd;
return self();
}
public String getSchFyr() {
return ifEmpty(schFyr, () -> null);
}
public <T extends LevyQuery> T setSchFyr(String schFyr) {
this.schFyr = schFyr;
return self();
}
public String getSchLevyNoFrom() {
return ifEmpty(schLevyNoFrom, () -> null);
}
public <T extends LevyQuery> T setSchLevyNoFrom(String schLevyNoFrom) {
this.schLevyNoFrom = schLevyNoFrom;
return self();
}
public String getSchLevyNoTo() {
return ifEmpty(schLevyNoTo, () -> null);
}
public <T extends LevyQuery> T setSchLevyNoTo(String schLevyNoTo) {
this.schLevyNoTo = schLevyNoTo;
return self();
}
public String getSchRdctSeCd() {
return ifEmpty(schRdctSeCd, () -> null);
}
public <T extends LevyQuery> T setSchRdctSeCd(String schRdctSeCd) {
this.schRdctSeCd = schRdctSeCd;
return self();
}
public String getSchLevyYmdFrom() {
return ifEmpty(schLevyYmdFrom, () -> null);
}
public <T extends LevyQuery> T setSchLevyYmdFrom(String schLevyYmdFrom) {
this.schLevyYmdFrom = schLevyYmdFrom;
return self();
}
public String getSchLevyYmdTo() {
return ifEmpty(schLevyYmdTo, () -> null);
}
public <T extends LevyQuery> T setSchLevyYmdTo(String schLevyYmdTo) {
this.schLevyYmdTo = schLevyYmdTo;
return self();
}
public String getSchCrdnYmdFrom() {
return ifEmpty(schCrdnYmdFrom, () -> null);
}
public <T extends LevyQuery> T setSchCrdnYmdFrom(String schCrdnYmdFrom) {
this.schCrdnYmdFrom = schCrdnYmdFrom;
return self();
}
public String getSchCrdnYmdTo() {
return ifEmpty(schCrdnYmdTo, () -> null);
}
public <T extends LevyQuery> T setSchCrdnYmdTo(String schCrdnYmdTo) {
this.schCrdnYmdTo = schCrdnYmdTo;
return self();
}
public String getSchVhrno() {
return ifEmpty(schVhrno, () -> null);
}
public <T extends LevyQuery> T setSchVhrno(String schVhrno) {
this.schVhrno = schVhrno;
return self();
}
public String getSchCrdnSttsCd() {
return ifEmpty(schCrdnSttsCd, () -> null);
}
public <T extends LevyQuery> T setSchCrdnSttsCd(String schCrdnSttsCd) {
this.schCrdnSttsCd = schCrdnSttsCd;
return self();
}
public String getSchVltnCd() {
return ifEmpty(schVltnCd, () -> null);
}
public <T extends LevyQuery> T setSchVltnCd(String schVltnCd) {
this.schVltnCd = schVltnCd;
return self();
}
public String getSchCvlcptRcptYmdFrom() {
return ifEmpty(schCvlcptRcptYmdFrom, () -> null);
}
public <T extends LevyQuery> T setSchCvlcptRcptYmdFrom(String schCvlcptRcptYmdFrom) {
this.schCvlcptRcptYmdFrom = schCvlcptRcptYmdFrom;
return self();
}
public String getSchCvlcptRcptYmdTo() {
return ifEmpty(schCvlcptRcptYmdTo, () -> null);
}
public <T extends LevyQuery> T setSchCvlcptRcptYmdTo(String schCvlcptRcptYmdTo) {
this.schCvlcptRcptYmdTo = schCvlcptRcptYmdTo;
return self();
}
public String getSchCvlcptPrcsCmptnDtFrom() {
return ifEmpty(schCvlcptPrcsCmptnDtFrom, () -> null);
}
public <T extends LevyQuery> T setSchCvlcptPrcsCmptnDtFrom(String schCvlcptPrcsCmptnDtFrom) {
this.schCvlcptPrcsCmptnDtFrom = schCvlcptPrcsCmptnDtFrom;
return self();
}
public String getSchCvlcptPrcsCmptnDtTo() {
return ifEmpty(schCvlcptPrcsCmptnDtTo, () -> null);
}
public <T extends LevyQuery> T setSchCvlcptPrcsCmptnDtTo(String schCvlcptPrcsCmptnDtTo) {
this.schCvlcptPrcsCmptnDtTo = schCvlcptPrcsCmptnDtTo;
return self();
}
public String getSchCvlcptPrcsPic() {
return ifEmpty(schCvlcptPrcsPic, () -> null);
}
public <T extends LevyQuery> T setSchCvlcptPrcsPic(String schCvlcptPrcsPic) {
this.schCvlcptPrcsPic = schCvlcptPrcsPic;
return self();
}
public String getSchRtpyrNo() {
return ifEmpty(schRtpyrNo, () -> null);
}
public <T extends LevyQuery> T setSchRtpyrNo(String schRtpyrNo) {
this.schRtpyrNo = schRtpyrNo;
return self();
}
public String getSchRtpyrNm() {
return ifEmpty(schRtpyrNm, () -> null);
}
public <T extends LevyQuery> T setSchRtpyrNm(String schRtpyrNm) {
this.schRtpyrNm = schRtpyrNm;
return self();
}
// 검색 조건 //////////////////////////////////////////////////////////////////
// 상세 검색 조건 ///////////////////////////////////////////////////////////////
// 상세 검색 조건 ///////////////////////////////////////////////////////////////
// ETC ////////////////////////////////////////////////////////////////////
public String getCallPurpose() {
return ifEmpty(callPurpose, () -> null);
}
public <T extends LevyQuery> T setCallPurpose(String callPurpose) {
this.callPurpose = callPurpose;
return self();
}
public String getDelRsn() {
return ifEmpty(delRsn, () -> null);
}
public <T extends LevyQuery> T setDelRsn(String delRsn) {
this.delRsn = delRsn;
return self();
}
// ETC /////////////////////////////////////////////////////////////////////
public String getTnocs() {
return ifEmpty(tnocs, () -> null);
}
public <T extends LevyQuery> T setTnocs(String tnocs) {
this.tnocs = tnocs;
return self();
}
public String getGramtFfnlgAmt() {
return ifEmpty(gramtFfnlgAmt, () -> null);
}
public <T extends LevyQuery> T setGramtFfnlgAmt(String gramtFfnlgAmt) {
this.gramtFfnlgAmt = gramtFfnlgAmt;
return self();
}
public String getGramtAdvntceAmt() {
return ifEmpty(gramtAdvntceAmt, () -> null);
}
public <T extends LevyQuery> T setGramtAdvntceAmt(String gramtAdvntceAmt) {
this.gramtAdvntceAmt = gramtAdvntceAmt;
return self();
}
// ETC ////////////////////////////////////////////////////////////////////
// 부과 등록 //////////////////////////////////////////////////////////////////
public String getFyr() {
return ifEmpty(fyr, () -> null);
}
public <T extends LevyQuery> T setFyr(String fyr) {
this.fyr = fyr;
return self();
}
public String getAcntgSeCd() {
return ifEmpty(acntgSeCd, () -> null);
}
public <T extends LevyQuery> T setAcntgSeCd(String acntgSeCd) {
this.acntgSeCd = acntgSeCd;
return self();
}
public String getTxitmCd() {
return ifEmpty(txitmCd, () -> null);
}
public <T extends LevyQuery> T setTxitmCd(String txitmCd) {
this.txitmCd = txitmCd;
return self();
}
public String getOperItemCd() {
return ifEmpty(operItemCd, () -> null);
}
public <T extends LevyQuery> T setOperItemCd(String operItemCd) {
this.operItemCd = operItemCd;
return self();
}
public String getLevyYmd() {
return ifEmpty(levyYmd, () -> null);
}
public <T extends LevyQuery> T setLevyYmd(String levyYmd) {
this.levyYmd = levyYmd;
return self();
}
public String getDudtYmd() {
return ifEmpty(dudtYmd, () -> null);
}
public <T extends LevyQuery> T setDudtYmd(String dudtYmd) {
this.dudtYmd = dudtYmd;
return self();
}
public String getCrdnSttsCd() {
return ifEmpty(crdnSttsCd, () -> null);
}
public <T extends LevyQuery> T setCrdnSttsCd(String crdnSttsCd) {
this.crdnSttsCd = crdnSttsCd;
return self();
}
// 부과 등록 //////////////////////////////////////////////////////////////////
}

140
src/main/java/cokr/xit/fims/levy/dao/LevyMapper.java
Unescape Escape View File

@ -0,0 +1,140 @@
package cokr.xit.fims.levy.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.levy.Levy;
import cokr.xit.fims.levy.LevyQuery;
/** 부과 대장 정보 DAO
*
* <p>상세 설명:
*
* <pre>
* ============ 변경 이력 ============
* 2023-08-30 JoJH 최초 작성
* ================================
* </pre>
*/
@Mapper("levyMapper")
public interface LevyMapper extends AbstractMapper {
/**지정한 조건에 따라 감경부과 대상 목록을 조회하여 반환한다.<br />
* @param req 부과 대장 조회 조건
* @return 부과 대장 목록
*/
List<DataObject> selectRdctLevyTrgtList(LevyQuery req);
/**지정한 조건에 따라 감경부과 대상 단속ID 목록을 조회하여 반환한다.<br />
* @param req 부과 대장 조회 조건
* @return 단속 ID 목록
*/
List<DataObject> selectRdctLevyTrgtIds(LevyQuery req);
/**지정한 조건에 따라 부과 대장 목록을 조회하여 반환한다.<br />
* @param req 부과 대장 조회 조건
* @return 부과 대장 목록
*/
List<DataObject> selectLevyList(LevyQuery req);
/**지정한 조건에 따라 부과 대장 객체들을 반환한다.
* @param req 부과 대장 조회 조건
* @return 부과 대장 객체 목록
*/
List<DataObject> selectLevys(LevyQuery req);
/**지정한 부과 ID에 따라 부과 대장 객체를 반환한다.
* @param levyId 부과 ID
* @return 부과 대장 객체
*/
default DataObject selectLevyInfo(LevyQuery req) {
// 삭제 여부 확인
if (req.getDelYn() == null) {
req.setDelYn("N");
}
// 기본 정렬
if (req.getOrderBy() == null) {
req.setOrderBy("L.LEVY_ID DESC");
}
List<DataObject> levys = selectLevys(req);
return !levys.isEmpty() ? levys.get(0) : null;
}
/**지정한 단속 ID에 따라 단속 대장 객체를 반환한다.
* @param crdnId 단속 ID
* @return 고지 번호
*/
String selectMaxLevyNo(LevyQuery req);
/**부과 대장 정보를 등록한다.
* @param params 파라미터
* <ul><li>"levy" - 부과 대장</li>
* <li>"currentUser" - 현재 접속한 사용자</li>
* </ul>
* @return 저장된 정보수
*/
int insertLevy(Levy levy);
/**부과 대장 정보를 수정한다.
* @param params 파라미터
* <ul><li>"levy" - 부과 대장</li>
* <li>"currentUser" - 현재 접속한 사용자</li>
* </ul>
* @return 저장된 정보수
*/
int updateLevy(Levy levy);
/**부과 대장에 부과일자, 최초납기일자, 납기일자 정보를 수정한다.
* @param levy 부과 대장
* @return 저장 여부
* <ul><li>저장됐으면 true</li>
* <li>그렇지 않으면 false</li>
* </ul>
*/
int updateRdctLevyYmd(Levy levy);
/**부과 대장에 수납 금액 정보를 수정한다.
* @param levy 부과 대장
* @return 저장 여부
* <ul><li>저장됐으면 true</li>
* <li>그렇지 않으면 false</li>
* </ul>
*/
int updateRcvmt(Levy levy);
/**부과 대장에 감액 금액 정보를 수정한다.
* @param levy 부과 대장
* @return 저장 여부
* <ul><li>저장됐으면 true</li>
* <li>그렇지 않으면 false</li>
* </ul>
*/
int updateRdamt(Levy levy);
/**지정한 부과 대장을 삭제한다.
* @param params 파라미터
* <ul><li>"levy" - 부과 대장</li>
* <li>"currentUser" - 현재 접속한 사용자</li>
* </ul>
* @return 저장된 정보수
*/
int deleteLevy(Levy levy);
/**지정한 단속 ID로 단속 대장 객체를 반환한다.
* @param crdnId 단속 ID
* @return 단속 대장 객체
*/
DataObject selectCrdn(String crdnId);
/**지정한 조건에 따라 부과 대장 객체들을 반환한다.
* @param req 부과 대장 조회 조건
* @return 부과 대장 객체 목록
*/
DataObject selectLevyAmt(LevyQuery req);
}

96
src/main/java/cokr/xit/fims/rdca/Rdamt.java
Unescape Escape View File

@ -0,0 +1,96 @@
package cokr.xit.fims.rdca;
import lombok.Getter;
import lombok.Setter;
import cokr.xit.foundation.AbstractEntity;
/**
* 감액 대장
* @author JoJH
*/
@Getter
@Setter
public class Rdamt extends AbstractEntity {
/**
* 감액 ID
*/
private String rdamtId;
/**
* 부과 ID
*/
private String levyId;
/**
* 최종 본세
*/
private Integer lastPcptax;
/**
* 최종 가산금
*/
private Integer lastAdamt;
/**
* 감액 일자
*/
private String rdamtYmd;
/**
* 감액 구분 코드
*/
private String rdamtSeCd;
/**
* 감액 사유 코드
*/
private String rdamtRsnCd;
/**
* 감액 본세
*/
private Integer rdamtPcptax;
/**
* 감액 가산금
*/
private Integer rdamtAdamt;
/**
* 감액 취소 여부
*/
private String rdamtRtrcnYn;
/**
* 감액 취소 일자
*/
private String rdamtRtrcnYmd;
/**
* 감액 취소 사유
*/
private String rdamtRtrcnRsn;
/**
* 삭제 여부
*/
private String delYn;
/**
* 삭제 사유
*/
private String delRsn;
// 추가 /////////////////////////////////////////////////////////////////////
/**
* 부과 Ids
*/
private String[] levyIds;
/**
* 시군구 코드
*/
private String sggCd;
}

110
src/main/java/cokr/xit/fims/rdca/RdamtQuery.java
Unescape Escape View File

@ -0,0 +1,110 @@
package cokr.xit.fims.rdca;
import cokr.xit.fims.cmmn.CmmnQuery;
/**감액 대장 정보 조회 요청
*
* <p>상세 설명:
*
* <pre>
* ============ 변경 이력 ============
* 2024-02-01 JoJH 최초 작성
* ================================
* </pre>
*/
public class RdamtQuery extends CmmnQuery {
private static final long serialVersionUID = 1L;
// ID
private String[] rdamtIds; // 감액 Ids
private String rdamtId; // 감액 ID
private String[] levyIds; // 부과 Ids
private String levyId; // 부과 ID
// 검색 조건
private String schLevyExclYmdFrom; // 부과제외_부과제외 일자 시작
private String schLevyExclYmdTo; // 부과제외_부과제외 일자 종료
// 상세 검색 조건
// 동적 검색 조건
// ETC
private String callPurpose; // infoDialog 호출 용도(view 조회(편집불가), create 등록, update 수정, refresh 재조회).
private String delRsn; // 삭제 사유
public String[] getRdamtIds() {
return ifEmpty(rdamtIds, () -> null);
}
public <T extends RdamtQuery> T setRdamtIds(String... rdamtIds) {
this.rdamtIds = rdamtIds;
return self();
}
public String getRdamtId() {
return ifEmpty(rdamtId, () -> null);
}
public <T extends RdamtQuery> T setRdamtId(String rdamtId) {
this.rdamtId = rdamtId;
return self();
}
public String[] getLevyIds() {
return ifEmpty(levyIds, () -> null);
}
public <T extends RdamtQuery> T setLevyIds(String... levyIds) {
this.levyIds = levyIds;
return self();
}
public String getLevyId() {
return ifEmpty(levyId, () -> null);
}
public <T extends RdamtQuery> T setLevyId(String levyId) {
this.levyId = levyId;
return self();
}
public String getSchLevyExclYmdFrom() {
return ifEmpty(schLevyExclYmdFrom, () -> null);
}
public <T extends RdamtQuery> T setSchLevyExclYmdFrom(String schLevyExclYmdFrom) {
this.schLevyExclYmdFrom = schLevyExclYmdFrom;
return self();
}
public String getSchLevyExclYmdTo() {
return ifEmpty(schLevyExclYmdTo, () -> null);
}
public <T extends RdamtQuery> T setSchLevyExclYmdTo(String schLevyExclYmdTo) {
this.schLevyExclYmdTo = schLevyExclYmdTo;
return self();
}
// ETC /////////////////////////////////////////////////////////////////////
public String getCallPurpose() {
return ifEmpty(callPurpose, () -> null);
}
public <T extends RdamtQuery> T setCallPurpose(String callPurpose) {
this.callPurpose = callPurpose;
return self();
}
public String getDelRsn() {
return ifEmpty(delRsn, () -> null);
}
public <T extends RdamtQuery> T setDelRsn(String delRsn) {
this.delRsn = delRsn;
return self();
}
// ETC /////////////////////////////////////////////////////////////////////
}

117
src/main/java/cokr/xit/fims/rdca/dao/RdamtMapper.java
Unescape Escape View File

@ -0,0 +1,117 @@
package cokr.xit.fims.rdca.dao;
import java.util.List;
import java.util.Map;
import org.egovframe.rte.psl.dataaccess.mapper.Mapper;
import cokr.xit.foundation.component.AbstractMapper;
import cokr.xit.foundation.data.DataObject;
import cokr.xit.fims.rdca.Rdamt;
import cokr.xit.fims.rdca.RdamtQuery;
/** 감액 대장 정보 DAO
*
* <p>상세 설명:
*
* <pre>
* ============ 변경 이력 ============
* 2024-02-01 JoJH 최초 작성
* ================================
* </pre>
*/
@Mapper("rdamtMapper")
public interface RdamtMapper extends AbstractMapper {
/**지정한 조건에 따라 감액 대장 목록을 조회하여 반환한다.<br />
* @param req 감액 대장 조회 조건
* @return 감액 대장 목록
*/
List<DataObject> selectRdamtList(RdamtQuery req);
/**지정한 조건에 따라 감액 대장 객체들을 반환한다.
* @param req 감액 대장 조회 조건
* @return 감액 대장 객체 목록
*/
List<DataObject> selectRdamts(RdamtQuery req);
/**지정한 조건에 따라 감액 대장 객체 1건을 반환한다.
* @param req 감액 대장 조회 조건
* @return 감액 대장 객체
*/
default DataObject selectRdamtInfo(RdamtQuery req) {
// 삭제 여부 확인
if (req.getDelYn() == null) {
req.setDelYn("N");
}
// 기본 정렬
if (req.getOrderBy() == null) {
req.setOrderBy("R.RDAMT_ID DESC");
}
List<DataObject> rdcamts = selectRdamts(req);
return !rdcamts.isEmpty() ? rdcamts.get(0) : null;
}
/**감액 대장 정보를 등록한다.
* @param params 파라미터
* <ul><li>"rdcamt" - 감액 대장</li>
* <li>"currentUser" - 현재 접속한 사용자</li>
* </ul>
* @return 저장된 정보수
*/
int insertRdamt(Map<String, Object> params);
/**감액 대장 정보를 등록한다.
* @param rdamt 감액 대장
* @return 저장 여부
* <ul><li>저장됐으면 true</li>
* <li>그렇지 않으면 false</li>
* </ul>
*/
default boolean insert(Rdamt rdamt) {
return rdamt != null && insertRdamt(params().set("rdamt", rdamt)) == 1;
}
/**감액 대장 정보를 수정한다.
* @param params 파라미터
* <ul><li>"rdamt" - 감액 대장</li>
* <li>"currentUser" - 현재 접속한 사용자</li>
* </ul>
* @return 저장된 정보수
*/
int updateRdamt(Map<String, Object> params);
/**감액 대장 정보를 수정한다.
* @param rdamt 감액 대장
* @return 저장 여부
* <ul><li>저장됐으면 true</li>
* <li>그렇지 않으면 false</li>
* </ul>
*/
default boolean update(Rdamt rdamt) {
return rdamt != null && updateRdamt(params().set("rdamt", rdamt)) == 1;
}
/**지정한 감액 대장을 삭제한다.
* @param params 파라미터
* <ul><li>"rdcamt" - 감액 대장</li>
* <li>"currentUser" - 현재 접속한 사용자</li>
* </ul>
* @return 저장된 정보수
*/
int deleteRdamt(Map<String, ?> params);
/**감액 대장 정보를 삭제한다.
* @param rdamt 감액 대장
* @return 저장 여부
* <ul><li>저장됐으면 true</li>
* <li>그렇지 않으면 false</li>
* </ul>
*/
default boolean delete(Rdamt rdamt) {
return rdamt != null && deleteRdamt(params().set("rdamt", rdamt)) == 1;
}
}

207
src/main/java/cokr/xit/fims/rdca/service/bean/RdamtBean.java
Unescape Escape View File

@ -0,0 +1,207 @@
package cokr.xit.fims.rdca.service.bean;
import java.util.List;
import javax.annotation.Resource;
import org.springframework.stereotype.Component;
import cokr.xit.fims.cmmn.CmmnUtil;
import cokr.xit.fims.levy.Levy;
import cokr.xit.fims.levy.LevyQuery;
import cokr.xit.fims.levy.dao.LevyMapper;
import cokr.xit.fims.rdca.Rdamt;
import cokr.xit.fims.rdca.RdamtQuery;
import cokr.xit.fims.rdca.dao.RdamtMapper;
import cokr.xit.foundation.component.AbstractBean;
import cokr.xit.foundation.data.DataObject;
/**감액 대장 정보 관리 Bean
*
* <p>상세 설명:
*
* <pre>
* ============ 변경 이력 ============
* 2024-02-01 JoJH 최초 작성
* ================================
* </pre>
*/
@Component("rdamtBean")
public class RdamtBean extends AbstractBean {
/** 감액 대장 정보 DAO */
@Resource(name = "rdamtMapper")
private RdamtMapper rdamtMapper;
/** 부과 대장 정보 DAO */
@Resource(name = "levyMapper")
private LevyMapper levyMapper;
/**지정한 조건에 따라 감액 대장 목록을 조회하여 반환한다.
* @param req 감액 대장 조회 조건
* @return 감액 대장 목록
*/
public List<DataObject> getRdamtList(RdamtQuery req) {
// 삭제 여부 확인
if (req.getDelYn() == null) {
req.setDelYn("N");
}
// 정렬 확인
if (req.getOrderBy() == null) {
if (req.getBy() == null) {
req.setOrderBy("REG_DT");
} else {
req.setOrderBy(CmmnUtil.convertCamelCaseToSnakeCase(req.getBy()));
}
}
return rdamtMapper.selectRdamtList(req);
}
/**지정한 조건에 따라 감액 대장 객체들을 반환한다.
* @param req 감액 대장 조회 조건
* @return 감액 대장 객체 목록
*/
public List<DataObject> getRdamts(RdamtQuery req) {
// 삭제 여부 확인
if (req.getDelYn() == null) {
req.setDelYn("N");
}
if (req.getOrderBy() == null) {
req.setOrderBy("R.RDAMT_ID DESC");
}
return rdamtMapper.selectRdamts(req);
}
/**지정한 조건에 따라 감액 대장 객체 1건을 반환한다.
* @param req 감액 대장 조회 조건
* @return 감액 대장 객체
*/
public DataObject getRdamtInfo(RdamtQuery req) {
DataObject rdamtInfo = new DataObject();
// if (req.getCallPurpose().equals("create")) {
// rdcamtInfo = rdcamtMapper.selectCrdnInfo(req);
// } else {
rdamtInfo = rdamtMapper.selectRdamtInfo(req);
// }
return rdamtInfo;
}
/**감액 대장 정보를 등록한다.
* @param rdcamt 감액 대장
* @return 저장 여부
* <ul><li>저장됐으면 true</li>
* <li>그렇지 않으면 false</li>
* </ul>
*/
public String createRdamt(Rdamt rdamt) {
// 변수 선언
boolean rtnScs = false; // DB 처리 결과
int rtnNocs = -1; // 처리 결과 건수
String rtnMsg = ""; // 처리 결과 메시지
// 부과 ID로 부과 정보 조회
DataObject levyInfo = levyMapper.selectLevyAmt(new LevyQuery().setLevyId(rdamt.getLevyId()));
// 부과(TB_LEVY) 대장 정보를 수정한다.
Levy levy = new Levy();
levy.setLevyId(levyInfo.string("LEVY_ID")); // 부과 ID
if ("02,03,04".contains(rdamt.getRdamtSeCd())) { // 02:부과취소, 03:이의신청수용, 04:법원이송
// 수납금액이 있으면 오류 발생
if (levyInfo.number("RCVMT_PCPTAX").intValue() + levyInfo.number("RCVMT_ADAMT").intValue() > 0) {
rtnMsg = "[F] 수납금액이 존재합니다.<br>부분 감액으로 진행하시기 바랍니다."; // 예외를 발생시켜서 DB Rollback
return rtnMsg;
}
levy.setRdamtPcptax(levyInfo.number("LEVY_PCPTAX").intValue()); // 감액 본세
levy.setRdamtAdamt(levyInfo.number("LEVY_ADAMT").intValue()); // 감액 가산금
levy.setSumAmt(0); // 합계 금액
levy.setDudtAftrAmt(0); // 납기 후 금액
} else {
levy.setRdamtPcptax(levyInfo.number("RDAMT_PCPTAX").intValue() + rdamt.getRdamtPcptax()); // 감액 본세
levy.setRdamtAdamt(levyInfo.number("RDAMT_ADAMT").intValue() + rdamt.getRdamtAdamt()); // 감액 가산금
levy.setSumAmt(levyInfo.number("SUM_AMT").intValue() - rdamt.getRdamtPcptax() - rdamt.getRdamtAdamt()); // 합계 금액
if (levy.getSumAmt() > 0) {
levy.setDudtAftrAmt(levyInfo.number("DUDT_AFTR_AMT").intValue() - rdamt.getRdamtPcptax() - rdamt.getRdamtAdamt()); // 납기 후 금액
} else {
levy.setDudtAftrAmt(0);
}
}
rtnNocs = levyMapper.updateRdamt(levy);
if (rtnNocs != 1) {
throw new RuntimeException("부과 대장의 감액 금액 수정에 실패하였습니다."); // 예외를 발생시켜서 DB Rollback
}
// 감액(TB_RDAMT) 대장 정보를 등록한다.
if ("02,03,04".contains(rdamt.getRdamtSeCd())) { // 02:부과취소, 03:이의신청수용, 04:법원이송
rdamt.setLastPcptax(levyInfo.number("LEVY_PCPTAX").intValue());
rdamt.setLastAdamt(levyInfo.number("LEVY_ADAMT").intValue());
rdamt.setRdamtPcptax(levyInfo.number("LEVY_PCPTAX").intValue());
rdamt.setRdamtAdamt(levyInfo.number("LEVY_ADAMT").intValue());
} else {
rdamt.setLastPcptax(levyInfo.number("LAST_PCPTAX").intValue());
rdamt.setLastAdamt(levyInfo.number("LAST_ADAMT").intValue());
rdamt.setRdamtPcptax(rdamt.getRdamtPcptax());
rdamt.setRdamtAdamt(rdamt.getRdamtAdamt());
}
rtnScs = rdamtMapper.insert(rdamt);
if (!rtnScs) {
throw new RuntimeException("감액 대장 등록에 실패하였습니다."); // 예외를 발생시켜서 DB Rollback
}
return "[S] 작업이 정상 처리 되었습니다.";
}
/**감액 대장 정보를 수정한다.
* @param rdcamt 감액 대장
* @return 저장 여부
* <ul><li>저장됐으면 true</li>
* <li>그렇지 않으면 false</li>
* </ul>
*/
public String updateRdamt(Rdamt rdamt) {
// 변수 선언
boolean rtnScs = false; // DB 처리 결과
String rtnMsg = "[F] "; // 처리 결과 메시지
// 감액(TB_RDAMT) 대장 정보를 수정한다.
rtnScs = rdamtMapper.update(rdamt);
if (!rtnScs) {
throw new RuntimeException("감액 대장 수정에 실패하였습니다."); // 예외를 발생시켜서 DB Rollback
}
rtnMsg = "[S] 작업이 정상 처리 되었습니다.";
return rtnMsg;
}
/**감액 대장 정보를 삭제한다.
* @param rdcamt 감액 대장
* @return 저장 여부
* <ul><li>저장됐으면 true</li>
* <li>그렇지 않으면 false</li>
* </ul>
*/
public String removeRdamt(Rdamt rdamt) {
// 변수 선언
boolean rtnScs = false; // DB 처리 결과
String rtnMsg = "[F] "; // 처리 결과 메시지
// 감액(TB_RDAMT) 대장 정보를 삭제한다.
rtnScs = rdamtMapper.delete(rdamt);
if (!rtnScs) {
throw new RuntimeException("감액 정보 삭제에 실패하였습니다."); // 예외를 발생시켜서 DB Rollback
}
rtnMsg = "[S] 작업이 정상 처리 되었습니다.";
return rtnMsg;
}
}

159
src/main/resources/sql/mapper/fims/crdn/crdn-info-mapper.xml
Unescape Escape View File

@ -0,0 +1,159 @@
<?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.crdn.dao.CrdnInfoMapper">
<resultMap id="crdnRow" type="cokr.xit.fims.crdn.Crdn">
<result property="crdnId" column="CRDN_ID" /> <!-- 단속 ID -->
<result property="sggCd" column="SGG_CD" /> <!-- 시군구 코드 -->
<result property="taskSeCd" column="TASK_SE_CD" /> <!-- 업무 구분 코드 -->
<result property="crdnRegSeCd" column="CRDN_REG_SE_CD" /> <!-- 단속 등록 구분 코드 -->
<result property="crdnInptSeCd" column="CRDN_INPT_SE_CD" /> <!-- 단속 입력 구분 코드 -->
<result property="linkId" column="LINK_ID" /> <!-- 연계 ID -->
<result property="crdnSeCd" column="CRDN_SE_CD" /> <!-- 단속 구분 코드 -->
<result property="rtpyrId" column="RTPYR_ID" /> <!-- 납부자 ID -->
<result property="crdnYmd" column="CRDN_YMD" /> <!-- 단속 일자 -->
<result property="crdnTm" column="CRDN_TM" /> <!-- 단속 시각 -->
<result property="vhrno" column="VHRNO" /> <!-- 차량번호 -->
<result property="crdnStdgNm" column="CRDN_STDG_NM" /> <!-- 단속 법정동 명 -->
<result property="crdnRoadNm" column="CRDN_ROAD_NM" /> <!-- 단속 도로 명 -->
<result property="crdnPlc" column="CRDN_PLC" /> <!-- 단속 장소 -->
<result property="dtlCrdnPlc" column="DTL_CRDN_PLC" /> <!-- 상세 단속 장소 -->
<result property="teamId" column="TEAM_ID" /> <!-- 조 ID -->
<result property="vltnId" column="VLTN_ID" /> <!-- 위반 ID -->
<result property="crdnSpareaCd" column="CRDN_SPAREA_CD" /> <!-- 단속 특별구역 코드 -->
<result property="crdnBgngTm" column="CRDN_BGNG_TM" /> <!-- 단속 시작 시각 -->
<result property="crdnEndTm" column="CRDN_END_TM" /> <!-- 단속 종료 시간 -->
<result property="crdnSn" column="CRDN_SN" /> <!-- 단속 일련번호 -->
<result property="gpsX" column="GPS_X" /> <!-- GPS X -->
<result property="gpsY" column="GPS_Y" /> <!-- GPS Y -->
<result property="moscX" column="MOSC_X" /> <!-- 모자이크 X -->
<result property="moscY" column="MOSC_Y" /> <!-- 모자이크 Y -->
<result property="towngYn" column="TOWNG_YN" /> <!-- 견인 여부 -->
<result property="atchFileCnt" column="ATCH_FILE_CNT" /> <!-- 첨부 파일 수 -->
<result property="vin" column="VIN" /> <!-- 차대번호 -->
<result property="vhclNm" column="VHCL_NM" /> <!-- 차량 명 -->
<result property="vhclColr" column="VHCL_COLR" /> <!-- 차량 색상 -->
<result property="useFuelCd" column="USE_FUEL_CD" /> <!-- 사용 연료 코드 -->
<result property="ffnlgCarmdlCd" column="FFNLG_CARMDL_CD" /> <!-- 과태료 차종 코드 -->
<result property="prkPsbltyRsltCd" column="PRK_PSBLTY_RSLT_CD" /> <!-- 주차 가능 결과 코드 -->
<result property="vltnNmtm" column="VLTN_NMTM" /> <!-- 위반 횟수 -->
<result property="ovtmYn" column="OVTM_YN" /> <!-- 시간외 여부 -->
<result property="ffnlgCrdnAmt" column="FFNLG_CRDN_AMT" /> <!-- 과태료 단속 금액 -->
<result property="ffnlgRdcrt" column="FFNLG_RDCRT" /> <!-- 과태료 감경 율 -->
<result property="ffnlgAmt" column="FFNLG_AMT" /> <!-- 과태료 금액 -->
<result property="advntceBgngYmd" column="ADVNTCE_BGNG_YMD" /> <!-- 사전통지 시작 일자 -->
<result property="advntceDudtYmd" column="ADVNTCE_DUDT_YMD" /> <!-- 사전통지 납기 일자 -->
<result property="advntceAmt" column="ADVNTCE_AMT" /> <!-- 사전통지 금액 -->
<result property="opnnSbmsnYn" column="OPNN_SBMSN_YN" /> <!-- 의견 제출 여부 -->
<result property="etcCn" column="ETC_CN" /> <!-- 기타 내용 -->
<result property="levyId" column="LEVY_ID" /> <!-- 부과 ID -->
<result property="crdnSttsCd" column="CRDN_STTS_CD" /> <!-- 단속 상태 코드 -->
<result property="crdnSttsChgDt" column="CRDN_STTS_CHG_DT" /> <!-- 단속 상태 변경 일시 -->
<result property="adtnAmt" column="ADTN_AMT" /> <!-- 가산 금액 -->
<result property="minusAmt" column="MINUS_AMT" /> <!-- 감경 금액 -->
<result property="rcvmtAmt" column="RCVMT_AMT" /> <!-- 수납 금액 -->
<result property="bfrCrdnId" column="BFR_CRDN_ID" /> <!-- 이전 단속 ID -->
<result property="nxrpCrdnLinkYn" column="NXRP_CRDN_LINK_YN" /> <!-- 세외수입 단속 연계 여부 -->
<result property="nxrpCrdnLinkUserId" column="NXRP_CRDN_LINK_USER_ID" /><!-- 세외수입 단속 연계 사용자 ID -->
<result property="nxrpCrdnLinkDt" column="NXRP_CRDN_LINK_DT" /> <!-- 세외수입 단속 연계 일시 -->
<result property="nxrpAcbKey" column="NXRP_ACB_KEY" /> <!-- 세외수입 대장 키 -->
<result property="cvlcptLinkId" column="CVLCPT_LINK_ID" /> <!-- 민원 연계 ID -->
<result property="dstrbncYn" column="DSTRBNC_YN" /> <!-- 방해 여부 -->
<result property="cvlcptRcptYmd" column="CVLCPT_RCPT_YMD" /> <!-- 민원 접수 일자 -->
<result property="cvlcptAplySeCd" column="CVLCPT_APLY_SE_CD" /> <!-- 민원 신청 구분 코드 -->
<result property="cvlcptAplyNo" column="CVLCPT_APLY_NO" /> <!-- 민원 신청 번호 -->
<result property="cvlcptRcptNo" column="CVLCPT_RCPT_NO" /> <!-- 민원 접수 번호 -->
<result property="cvlcptListNo" column="CVLCPT_LIST_NO" /> <!-- 민원 목록 번호 -->
<result property="cvlcptAplcntNm" column="CVLCPT_APLCNT_NM" /> <!-- 민원 신청인 명 -->
<result property="cvlcptAplyDt" column="CVLCPT_APLY_DT" /> <!-- 민원 신청 일시 -->
<result property="cvlcptAplyTtlNm" column="CVLCPT_APLY_TTL_NM" /> <!-- 민원 신청 제목 명 -->
<result property="cvlcptAplyCn" column="CVLCPT_APLY_CN" /> <!-- 민원 신청 내용 -->
<result property="cvlcptGist" column="CVLCPT_GIST" /> <!-- 민원 요지 -->
<result property="cvlcptPrcsPicNm" column="CVLCPT_PRCS_PIC_NM" /> <!-- 민원 처리 담당자 명 -->
<result property="cvlcptPrcsPrnmntDt" column="CVLCPT_PRCS_PRNMNT_DT" /> <!-- 민원 처리 예정 일시 -->
<result property="cvlcptPrcsCd" column="CVLCPT_PRCS_CD" /> <!-- 민원 처리 코드 -->
<result property="cvlcptPrcsSmry" column="CVLCPT_PRCS_SMRY" /> <!-- 민원 처리 요약 -->
<result property="cvlcptPrcsRsltCn" column="CVLCPT_PRCS_RSLT_CN" /> <!-- 민원 처리 결과 내용 -->
<result property="cvlcptPrcsCmptnDt" column="CVLCPT_PRCS_CMPTN_DT" /> <!-- 민원 처리 완료 일시 -->
<result property="cvlcptPrcsPic" column="CVLCPT_PRCS_PIC" /> <!-- 민원 처리 담당자 -->
<result property="cvlcptTrsmDt" column="CVLCPT_TRSM_DT" /> <!-- 민원 전송 일시 -->
<result property="cvlcptTrsmCd" column="CVLCPT_TRSM_CD" /> <!-- 민원 전송 코드 -->
<result property="cvlcptTrsmMsg" column="CVLCPT_TRSM_MSG" /> <!-- 민원 전송 메시지 -->
<result property="delYn" column="DEL_YN" /> <!-- 삭제 여부 -->
<result property="createdAt" column="REG_DT" /> <!-- 등록 일시 -->
<result property="createdBy" column="RGTR" /> <!-- 등록자 -->
<result property="lastModified" column="MDFCN_DT" /> <!-- 수정 일시 -->
<result property="modifiedBy" column="MDFR" /> <!-- 수정자 -->
<result property="delDt" column="DEL_DT" /> <!-- 삭제 일시 -->
<result property="dltr" column="DLTR" /> <!-- 삭제자 -->
<result property="delRsn" column="DEL_RSN" /> <!-- 삭제 사유 -->
</resultMap>
<select id="selectCrdnInfo" parameterType="string">/* 단속정보 조회(crdnInfoMapper.selectCrdnInfo) */
SELECT C.CRDN_ID <!-- 단속 ID -->
, C.SGG_CD <!-- 시군구 코드 -->
, C.TASK_SE_CD <!-- 업무 구분 코드 -->
, C.CRDN_REG_SE_CD <!-- 단속 등록 구분 코드 -->
, C.CRDN_YMD <!-- 단속 일자 -->
, C.CRDN_TM <!-- 단속 시간 -->
, C.VHRNO <!-- 차량번호 -->
, C.CRDN_STDG_NM <!-- 단속 법정동 명 -->
, C.CRDN_ROAD_NM <!-- 단속 도로 명 -->
, C.CRDN_PLC <!-- 단속 장소 -->
, C.VLTN_ID <!-- 위반 ID -->
, C.VIN VIN <!-- 차대번호 -->
, C.VHCL_NM <!-- 차량 명 -->
, C.VHCL_COLR <!-- 차량 색상 -->
, C.FFNLG_CRDN_AMT <!-- 과태료 단속 금액 -->
, C.ETC_CN <!-- 기타 내용 -->
, C.ATCH_FILE_CNT <!-- 첨부 파일 건수 -->
, C.CRDN_STTS_CD <!-- 단속 상태 코드 -->
, C.CRDN_STTS_CHG_DT <!-- 단속 상태 변경 일시 -->
, C.NXRP_CRDN_LINK_YN <!-- 세외수입 단속 연계 여부 -->
, C.NXRP_CRDN_LINK_USER_ID <!-- 세외수입 단속 연계 사용자 ID -->
, C.NXRP_CRDN_LINK_DT <!-- 세외수입 단속 연계 일시 -->
, C.LINK_TBL_NM <!-- 연계 테이블 명 -->
, C.LINK_ID <!-- 연계 ID -->
, C.GPS_X <!-- GPS X -->
, C.GPS_Y <!-- GPS Y -->
, V.VLTN_CD <!-- 위반 코드 -->
, V.VLTN_ARTCL <!-- 위반 항목 -->
, V.VLTN_LAW_NM <!-- 위반 법 명 -->
, V.VLTN_LAW1 <!-- 위반 법1 -->
, V.VLTN_LAW2 <!-- 위반 법2 -->
, CA.CRDN_SE_CD <!-- 단속 구분 코드 -->
, CA.TEAM_ID <!-- 조 ID -->
, CA.DTL_CRDN_PLC <!-- 상세 단속 장소 -->
, CA.CRDN_SPAREA_CD <!-- 단속 특별구역 코드 -->
, CA.CRDN_BGNG_TM <!-- 단속 시작 시각 -->
, CA.CRDN_END_TM <!-- 단속 종료 시각 -->
, CA.CRDN_SN <!-- 단속 순번 -->
, CA.MOSC_X <!-- 모자이크 X -->
, CA.MOSC_Y <!-- 모자이크 Y -->
, CA.TOWNG_YN <!-- 견인 여부 -->
, CA.USE_FUEL_CD <!-- 사용 연료 코드 -->
, CA.FFNLG_CARMDL_CD <!-- 과태료 차종 코드 -->
, CA.PRK_PSBLTY_RSLT_CD <!-- 주차 가능 결과 코드 -->
, CA.VLTN_NMTM <!-- 위반 횟수 -->
, CA.OVTM_YN <!-- 시간외 여부 -->
, CA.OVTM_PRTTN_YN <!-- 시간외 분할 여부 -->
, P.RTPYR_ID <!-- 납부자 ID -->
, PA.ADDR_SN <!-- 주소 일련번호 -->
, CC.CVLCPT_LINK_ID <!-- 민원 연계 ID -->
, CC.CVLCPT_TRSM_CD <!-- 민원 전송 코드 -->
, CC.CVLCPT_PRCS_CD <!-- 민원 처리 코드 -->
, CC.DSTRBNC_YN <!-- 방해 여부 -->
, LE.LEVY_EXCL_SE_CD <!-- 부과 제외 구분 코드 -->
, LE.LEVY_EXCL_RSN_CD <!-- 부과 제외 사유 코드 -->
FROM TB_CRDN C
INNER JOIN TB_CRDN_ADI CA ON (C.CRDN_ID = CA.CRDN_ID)
INNER JOIN TB_VLTN V ON (C.VLTN_ID = V.VLTN_ID)
LEFT OUTER JOIN TB_CRDN_CVLCPT CC ON (C.CVLCPT_LINK_YN = 'Y' AND C.LINK_ID = CC.CVLCPT_LINK_ID)
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)
LEFT OUTER JOIN TB_LEVY_EXCL LE ON (C.CRDN_ID = LE.CRDN_ID AND LE.DEL_YN = 'N')
WHERE C.DEL_YN = 'N'
AND C.CRDN_ID = #{crdnId}
</select>
</mapper>

170
src/main/resources/sql/mapper/fims/crdn/crdn-inst-mapper.xml
Unescape Escape View File

@ -0,0 +1,170 @@
<?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.crdn.dao.CrdnInstMapper">
<insert id="insertCrdn" parameterType="cokr.xit.fims.crdn.Crdn">
/* 단속 대장 등록(crdnInstMapper.insertCrdn) */
<selectKey resultType="string" keyProperty="crdnId" keyColumn="NEW_ID" order="BEFORE">
<include refid="numbering.keyByYear">
<property name="TABLE_NAME" value="TB_CRDN" />
<property name="TABLE_KEY" value="CRDN_ID" />
<property name="pad" value="20" />
</include>
</selectKey>
INSERT INTO TB_CRDN (
CRDN_ID <!-- 단속 ID -->
, SGG_CD <!-- 시군구 코드 -->
, CRDN_REG_SE_CD <!-- 단속 등록 구분 코드 -->
, CRDN_INPT_SE_CD <!-- 단속 입력 구분 코드 -->
, TASK_SE_CD <!-- 업무 구분 코드 -->
, CVLCPT_LINK_YN <!-- 민원연계여부 -->
, LINK_TBL_NM <!-- 연계 테이블 명 -->
, LINK_ID <!-- 연계 ID -->
, RTPYR_ID <!-- 납부자 ID -->
, ADDR_SN <!-- 주소 일련번호 -->
, CRDN_YMD <!-- 단속 일자 -->
, CRDN_TM <!-- 단속 시각 -->
, VHRNO <!-- 차량번호 -->
, CRDN_STDG_NM <!-- 단속 법정동 명 -->
, CRDN_ROAD_NM <!-- 단속 도로 명 -->
, CRDN_PLC <!-- 단속 장소 -->
, VLTN_ID <!-- 위반 ID -->
, GPS_X <!-- GPS X -->
, GPS_Y <!-- GPS Y -->
, ATCH_FILE_CNT <!-- 첨부 파일 수 -->
, VIN <!-- 차대번호 -->
, VHCL_NM <!-- 차량 명 -->
, VHCL_COLR <!-- 차량 색상 -->
, FFNLG_CRDN_AMT <!-- 과태료 단속 금액 -->
, FFNLG_RDCRT <!-- 과태료 감경 율 -->
, FFNLG_AMT <!-- 과태료 금액 -->
, ADVNTCE_BGNG_YMD <!-- 사전통지 시작 일자 -->
, ADVNTCE_DUDT_YMD <!-- 사전통지 납기 일자 -->
, ADVNTCE_AMT <!-- 사전통지 금액 -->
, OPNN_SBMSN_YN <!-- 의견 제출 여부 -->
, ETC_CN <!-- 기타 내용 -->
, CRDN_STTS_CD <!-- 단속 상태 코드 -->
, CRDN_STTS_CHG_DT <!-- 단속 상태 변경 일시 -->
, ADTN_AMT <!-- 가산 금액 -->
, MINUS_AMT <!-- 감경 금액 -->
, RCVMT_AMT <!-- 수납 금액 -->
, BFR_CRDN_ID <!-- 이전 단속 ID -->
, DEL_YN <!-- 삭제 여부 -->
, REG_DT <!-- 등록 일시 -->
, RGTR <!-- 등록자 -->
, MDFCN_DT <!-- 수정 일시 -->
, MDFR <!-- 수정자 -->
, DEL_DT <!-- 삭제 일시 -->
, DLTR <!-- 삭제자 -->
, DEL_RSN <!-- 삭제 사유 -->
) VALUES (
#{crdnId} <!-- 단속 ID -->
, #{sggCd} <!-- 시군구 코드 -->
, #{crdnRegSeCd} <!-- 단속 등록 구분 코드 -->
, #{crdnInptSeCd} <!-- 단속 입력 구분 코드 -->
, #{taskSeCd} <!-- 업무 구분 코드 -->
, #{cvlcptLinkYn} <!-- 민원 연계 여부 -->
, #{linkTblNm} <!-- 연계 테이블 명 -->
, #{linkId} <!-- 연계 ID -->
, #{rtpyrId} <!-- 납부자 ID -->
, #{addrSn} <!-- 주소 일련번호 -->
, #{crdnYmd} <!-- 단속 일자 -->
, #{crdnTm} <!-- 단속 시각 -->
, #{vhrno} <!-- 차량번호 -->
, #{crdnStdgNm} <!-- 단속 법정동 명 -->
, #{crdnRoadNm} <!-- 단속 도로 명 -->
, #{crdnPlc} <!-- 단속 장소 -->
, (SELECT A.VLTN_ID
FROM TB_VLTN A
WHERE A.SGG_CD = #{sggCd}
AND A.TASK_SE_CD = #{taskSeCd}
AND A.VLTN_CD = #{vltnCd}) <!-- 위반 ID -->
, #{gpsX} <!-- GPS X -->
, #{gpsY} <!-- GPS Y -->
, #{atchFileCnt} <!-- 첨부 파일 수 -->
, #{vin} <!-- 차대번호 -->
, #{vhclNm} <!-- 차량 명 -->
, #{vhclColr} <!-- 차량 색상 -->
, #{ffnlgCrdnAmt} <!-- 과태료 금액 -->
, #{ffnlgRdcrt} <!-- 과태료 감경 율 -->
, #{ffnlgAmt} <!-- 부과 금액 -->
, #{advntceBgngYmd} <!-- 사전통지 시작 일자 -->
, #{advntceDudtYmd} <!-- 사전통지 납기 일자 -->
, #{advntceAmt} <!-- 사전통지 금액 -->
, #{opnnSbmsnYn} <!-- 의견 제출 여부 -->
, #{etcCn} <!-- 기타 내용 -->
, #{crdnSttsCd} <!-- 단속 상태 코드 -->
, #{crdnSttsChgDt} <!-- 단속 상태 변경 일시 -->
, #{adtnAmt} <!-- 가산 금액 -->
, #{minusAmt} <!-- 감경 금액 -->
, #{rcvmtAmt} <!-- 수납 금액 -->
, #{bfrCrdnId} <!-- 이전 단속 ID -->
, 'N' <!-- 삭제 여부 -->
, #{createdAt} <!-- 등록 일시 -->
, #{createdBy} <!-- 등록자 -->
, #{lastModified} <!-- 수정 일시 -->
, #{modifiedBy} <!-- 수정자 -->
, #{removedAt} <!-- 삭제 일시 -->
, #{removedBy} <!-- 삭제자 -->
, #{delRsn} <!-- 삭제 사유 -->
)
</insert>
<insert id="insertCrdnAddition" parameterType="cokr.xit.fims.crdn.Crdn">
/* 단속 부가 정보 등록(crdnInstMapper.insertCrdnAddition) */
INSERT INTO TB_CRDN_ADI (
CRDN_ID <!-- 단속 ID -->
, CRDN_SE_CD <!-- 단속 구분 코드 -->
, DTL_CRDN_PLC <!-- 상세 단속 장소 -->
, CRDN_SPAREA_CD <!-- 단속 특별구역 코드 -->
, CRDN_BGNG_TM <!-- 단속 시작 시각 -->
, CRDN_END_TM <!-- 단속 종료 시간 -->
, CRDN_SN <!-- 단속 일련번호 -->
, MOSC_X <!-- 모자이크 X -->
, MOSC_Y <!-- 모자이크 Y -->
, TOWNG_YN <!-- 견인 여부 -->
, USE_FUEL_CD <!-- 사용 연료 코드 -->
, FFNLG_CARMDL_CD <!-- 과태료 차종 코드 -->
, PRK_PSBLTY_RSLT_CD <!-- 주차 가능 결과 코드 -->
, VLTN_NMTM <!-- 위반 횟수 -->
, OVTM_YN <!-- 시간외 여부 -->
, OVTM_PRTTN_YN <!-- 시간외 분할 여부 -->
, TEAM_ID <!-- 조 ID -->
, DEL_YN <!-- 삭제 여부 -->
, REG_DT <!-- 등록 일시 -->
, RGTR <!-- 등록자 -->
, MDFCN_DT <!-- 수정 일시 -->
, MDFR <!-- 수정자 -->
, DEL_DT <!-- 삭제 일시 -->
, DLTR <!-- 삭제자 -->
, DEL_RSN <!-- 삭제 사유 -->
) VALUES (
#{crdnId} <!-- 단속 ID -->
, #{crdnSeCd} <!-- 단속 구분 코드 -->
, #{dtlCrdnPlc} <!-- 상세 단속 장소 -->
, #{crdnSpareaCd} <!-- 단속 특별구역 코드 -->
, #{crdnBgngTm} <!-- 단속 시작 시각 -->
, #{crdnEndTm} <!-- 단속 종료 시간 -->
, #{crdnSn} <!-- 단속 일련번호 -->
, #{moscX} <!-- 모자이크 X -->
, #{moscY} <!-- 모자이크 Y -->
, #{towngYn} <!-- 견인 여부 -->
, #{useFuelCd} <!-- 사용 연료 코드 -->
, #{ffnlgCarmdlCd} <!-- 과태료 차종 코드 -->
, #{prkPsbltyRsltCd} <!-- 주차 가능 결과 코드 -->
, #{vltnNmtm} <!-- 위반 횟수 -->
, IFNULL(#{ovtmYn},'N') <!-- 시간외 여부 -->
, 'N' <!-- 시간외 분할 여부 -->
, #{teamId} <!-- 조 ID -->
, 'N' <!-- 삭제 여부 -->
, #{createdAt} <!-- 등록 일시 -->
, #{createdBy} <!-- 등록자 -->
, #{lastModified} <!-- 수정 일시 -->
, #{modifiedBy} <!-- 수정자 -->
, #{removedAt} <!-- 삭제 일시 -->
, #{removedBy} <!-- 삭제자 -->
, #{delRsn} <!-- 삭제 사유 -->
)
</insert>
</mapper>

497
src/main/resources/sql/mapper/fims/crdn/crdn-list-mapper.xml
Unescape Escape View File

@ -0,0 +1,497 @@
<?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.crdn.dao.CrdnListMapper">
<select id="selectCrackdownList" parameterType="map" resultType="dataobject">
/* 단속자료 목록 조회(crdnListMapper.selectCrackdownList) */
<include refid="utility.paging-prefix"/>
SELECT C.CRDN_ID <!-- 단속 ID -->
, C.SGG_CD <!-- 시군구 코드 -->
, (SELECT SGG_NM FROM TB_SGG WHERE SGG_CD = C.SGG_CD) AS SGG_NM
, C.TASK_SE_CD <!-- 업무 구분 코드 -->
, (SELECT GET_CODE_NM('FIM054', C.TASK_SE_CD) FROM DUAL) AS TASK_SE_NM
, C.CRDN_REG_SE_CD <!-- 단속 등록 구분 코드 -->
, GET_CODE_NM('FIM026', C.CRDN_REG_SE_CD) AS CRDN_REG_SE_NM
, C.CRDN_INPT_SE_CD <!-- 단속 입력 구분 코드 -->
, (SELECT GET_CODE_NM('FIM003', C.CRDN_INPT_SE_CD) FROM DUAL) AS CRDN_INPT_SE_NM
, C.LINK_TBL_NM <!-- 연계 테이블 명 -->
, C.LINK_ID <!-- 연계 ID -->
, C.RTPYR_ID <!-- 납부자 ID -->
, C.CRDN_YMD <!-- 단속 일자 -->
, C.CRDN_TM <!-- 단속 시각 -->
, CONCAT(C.CRDN_YMD,'',C.CRDN_TM) AS CRDN_YMD_TM <!-- 단속 일시 -->
, C.VHRNO <!-- 차량번호 -->
, L.RPM_SZR_VHRNO <!-- 대체차량번호 -->
, C.CRDN_STDG_NM <!-- 단속 법정동 명 -->
, C.CRDN_ROAD_NM <!-- 단속 도로 명 -->
, C.CRDN_PLC <!-- 단속 장소 -->
, C.VLTN_ID <!-- 위반 ID -->
, (SELECT VLTN_ARTCL FROM TB_VLTN WHERE VLTN_ID = C.VLTN_ID) AS VLTN_ARTCL
, C.GPS_X <!-- GPS X -->
, C.GPS_Y <!-- GPS Y -->
, C.ATCH_FILE_CNT <!-- 첨부 파일 수 -->
, C.VIN <!-- 차대번호 -->
, C.VHCL_NM <!-- 차량 명 -->
, C.VHCL_COLR <!-- 차량 색상 -->
, C.FFNLG_CRDN_AMT <!-- 과태료 단속 금액 -->
, C.FFNLG_RDCRT <!-- 과태료 감경율 -->
, C.FFNLG_AMT <!-- 과태료 금액 -->
, C.ADVNTCE_BGNG_YMD <!-- 사전통지 시작 일자 -->
, C.ADVNTCE_DUDT_YMD <!-- 사전통지 납기 일자 -->
, C.ADVNTCE_AMT <!-- 사전통지 금액 -->
, C.OPNN_SBMSN_YN <!-- 의견 제출 여부 -->
, L.LEVY_ID <!-- 부과 ID -->
, (CONCAT(L.FYR, '-', L.LEVY_NO)) AS GOJI_NO <!-- 고지 번호 -->
, L.EPAYNO <!-- 전자납부번호 -->
, L.VR_ACTNO <!-- 가상계좌번호 -->
, (L.LEVY_PCPTAX + L.LEVY_ADAMT) AS LEVY_AMT <!-- 부과 금액 -->
, L.DUDT_YMD
, L.RCVMT_YMD
, C.CRDN_STTS_CD <!-- 단속 상태 코드 -->
, (SELECT GET_CODE_NM('FIM010', C.CRDN_STTS_CD) FROM DUAL) AS CRDN_STTS_NM
, C.CRDN_STTS_CHG_DT <!-- 단속 상태 변경 일시 -->
, C.ADTN_AMT <!-- 가산 금액 -->
, C.MINUS_AMT <!-- 감경 금액 -->
, C.RCVMT_AMT <!-- 수납 금액 -->
, C.BFR_CRDN_ID <!-- 이전 단속 ID -->
, CA.CRDN_SE_CD <!-- 단속 구분 코드 -->
, GET_CODE_NM('FIM002', CA.CRDN_SE_CD) AS CRDN_SE_NM
, CA.DTL_CRDN_PLC <!-- 상세 단속 장소 -->
, CA.TEAM_ID <!-- 조 ID -->
, T.TEAM_NM <!-- 조 명 -->
, CA.CRDN_SPAREA_CD <!-- 단속 특별구역 코드 -->
, (SELECT GET_CODE_NM('FIM007', CA.CRDN_SPAREA_CD) FROM DUAL) AS CRDN_SPAREA_NM
, CA.CRDN_BGNG_TM <!-- 단속 시작 시각 -->
, CA.CRDN_END_TM <!-- 단속 종료 시간 -->
, CA.CRDN_SN <!-- 단속 일련번호 -->
, CA.MOSC_X <!-- 모자이크 X -->
, CA.MOSC_Y <!-- 모자이크 Y -->
, CA.TOWNG_YN <!-- 견인 여부 -->
, CA.USE_FUEL_CD <!-- 사용 연료 코드 -->
, CA.FFNLG_CARMDL_CD <!-- 과태료 차종 코드 -->
, CA.PRK_PSBLTY_RSLT_CD <!-- 주차 가능 결과 코드 -->
, (SELECT GET_CODE_NM('FIM034', CA.PRK_PSBLTY_RSLT_CD) FROM DUAL) AS PRK_PSBLTY_RSLT_NM
, CA.VLTN_NMTM <!-- 위반 횟수 -->
, CA.OVTM_YN <!-- 시간외 여부 -->
, CC.CVLCPT_LINK_ID <!-- 민원 연계 ID -->
, CC.DSTRBNC_YN <!-- 방해 여부 -->
, CC.CVLCPT_RCPT_YMD <!-- 민원 접수 일자 -->
, CC.CVLCPT_APLY_SE_CD <!-- 민원 신청 구분 코드 -->
, CC.CVLCPT_APLY_NO <!-- 민원 신청 번호 -->
, CC.CVLCPT_RCPT_NO <!-- 민원 접수 번호 -->
, CC.CVLCPT_LIST_NO <!-- 민원 목록 번호 -->
, CC.CVLCPT_APLCNT_NM <!-- 민원 신청인 명 -->
, CC.CVLCPT_APLY_DT <!-- 민원 신청 일시 -->
, CC.CVLCPT_PRCS_PIC_NM <!-- 민원 처리 담당자 명 -->
, CC.CVLCPT_PRCS_PRNMNT_DT <!-- 민원 처리 예정 일시 -->
, CC.CVLCPT_PRCS_CD <!-- 민원 처리 코드 -->
, CC.CVLCPT_PRCS_SMRY <!-- 민원 처리 요약 -->
, CC.CVLCPT_PRCS_CMPTN_DT <!-- 민원 처리 완료 일시 -->
, CC.CVLCPT_PRCS_PIC <!-- 민원 처리 담당자 -->
, CC.CVLCPT_TRSM_DT <!-- 민원 전송 일시 -->
, CC.CVLCPT_TRSM_CD <!-- 민원 전송 코드 -->
, LE.LEVY_EXCL_RSN_CD <!-- 부과 제외 사유 코드 -->
, (SELECT GET_CODE_NM('FIM022', LE.LEVY_EXCL_RSN_CD) FROM DUAL) AS LEVY_EXCL_RSN_NM
, LE.LEVY_EXCL_YMD <!-- 부과 제외 일자 -->
, LE.ETC_CN AS LEVY_EXCL_ETC_CN <!-- 부과 제외 기타 내용 -->
, P.RTPYR_NM <!-- 납부자명 -->
, P.RTPYR_NO <!-- 납부자번호 -->
, PA.WHOL_ADDR AS RTPYR_FULL_ADDR <!-- 납부자주소 -->
, PA.ZIP AS RTPYR_ZIP <!-- 납부자우편번호 -->
, C.DEL_YN
, C.RGTR
, C.REG_DT
, C.MDFR
, C.MDFCN_DT
, C.DLTR
, C.DEL_DT
FROM TB_CRDN C
INNER JOIN TB_CRDN_ADI CA ON (C.CRDN_ID = CA.CRDN_ID)
LEFT OUTER JOIN TB_TEAM T ON (CA.TEAM_ID = T.TEAM_ID)
LEFT OUTER JOIN TB_CRDN_CVLCPT CC ON (C.CVLCPT_LINK_YN = 'Y' AND C.LINK_ID = CC.CVLCPT_LINK_ID)
LEFT OUTER JOIN TB_LEVY_EXCL LE ON (C.CRDN_ID = LE.CRDN_ID AND LE.DEL_YN = 'N')
LEFT OUTER JOIN TB_LEVY L ON (C.CRDN_ID = L.CRDN_ID)
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.DEL_YN = 'N'
<if test="sggCd != null">
AND C.SGG_CD = #{sggCd}
</if>
<if test="crdnId != null">AND C.CRDN_ID = #{crdnId}</if>
<if test="crdnIds != null">
AND C.CRDN_ID IN (<foreach collection="crdnIds" item="CRDN_ID" separator=",">#{CRDN_ID}</foreach>)
</if>
<if test="taskSeCd != null">AND C.TASK_SE_CD = #{taskSeCd}</if>
<if test="vhrno != null">AND C.VHRNO LIKE CONCAT('%', #{vhrno}, '%')</if>
<if test="crdnInptSeCd != null">AND C.CRDN_INPT_SE_CD = #{crdnInptSeCd}</if>
<if test="schCrdnYmdFrom != null or schCrdnYmdTo != null">
<if test="schCrdnYmdFrom != null">AND C.CRDN_YMD <![CDATA[ >= ]]> #{schCrdnYmdFrom} </if>
<if test="schCrdnYmdTo != null">AND C.CRDN_YMD <![CDATA[ <= ]]> #{schCrdnYmdTo} </if>
</if>
<if test="crdnSttsCd != null">
AND C.CRDN_STTS_CD = #{crdnSttsCd}
</if>
<if test="towngYn != null">
AND CA.TOWNG_YN = #{towngYn}
</if>
<if test="schRegDateFrom != null or schRegDateTo != null">
<if test="schRegDateOpt == 'regDt'">
<if test="schRegDateFrom != null"> AND C.REG_DT <![CDATA[>=]]> CONCAT(#{schRegDateFrom},'000000') </if>
<if test="schRegDateTo != null"> AND C.REG_DT <![CDATA[<=]]> CONCAT(#{schRegDateTo},'235959') </if>
</if>
<if test="schRegDateOpt == 'mdfcnDt'">
<if test="schRegDateFrom != null"> AND C.MDFCN_DT <![CDATA[ >= ]]> CONCAT(#{schRegDateFrom},'000000') </if>
<if test="schRegDateTo != null"> AND C.MDFCN_DT <![CDATA[ <= ]]> CONCAT(#{schRegDateTo},'235959') </if>
</if>
</if>
<if test="schRgtrCd != null">
<if test="schRgtrOpt == 'rgtr'">
<if test="schRgtrCd != null"> AND C.RGTR = #{schRgtrCd} </if>
</if>
<if test="schRgtrOpt == 'mdfr'">
<if test="schRgtrCd != null"> AND C.MDFR = #{schRgtrCd} </if>
</if>
</if>
<if test="nxrpSendStts != null">
<if test="nxrpSendStts == '01'">
AND C.NXRP_CRDN_LINK_YN = 'N' AND C.ATCH_FILE_CNT != 0 AND C.ATCH_FILE_CNT IS NOT NULL
</if>
<if test="nxrpSendStts == '02'">
AND C.NXRP_CRDN_LINK_YN = 'Y'
</if>
<if test="nxrpSendStts == '03'">
AND C.NXRP_CRDN_LINK_YN = 'N' AND (C.ATCH_FILE_CNT = 0 OR C.ATCH_FILE_CNT IS NULL)
</if>
</if>
<if test="@org.egovframe.rte.fdl.string.EgovStringUtil@isNotEmpty(by) and @org.egovframe.rte.fdl.string.EgovStringUtil@isNotEmpty(term)">
<choose>
<when test="mainOption == 'codeValue' or mainOption == 'match' or mainOption == 'ymd'">
<include refid="dynamicSearch.start" />
<choose>
<when test="by == 'crdnInptSeCd'">C.CRDN_INPT_SE_CD</when>
<when test="by == 'vhrno'">C.VHRNO</when>
<when test="by == 'crdnYmd'">C.CRDN_YMD</when>
<when test="by == 'crdnPlc'">C.CRDN_PLC</when>
<when test="by == 'atchFileCnt'">C.ATCH_FILE_CNT</when>
<when test="by == 'crdnSn'">CA.CRDN_SN</when>
<when test="by == 'prkPsbltyRsltCd'">CA.PRK_PSBLTY_RSLT_CD</when>
<when test="by == 'crdnSttsCd'">C.CRDN_STTS_CD</when>
<when test="by == 'levyExclRsnCd'">LE.LEVY_EXCL_RSN_CD</when>
<when test="by == 'levyExclYmd'">LE.LEVY_EXCL_YMD</when>
<when test="by == 'levyExclEtcCn'">LE.ETC_CN</when>
</choose>
<include refid="dynamicSearch.center" />#{term}<include refid="dynamicSearch.end" />
</when>
<otherwise>
</otherwise>
</choose>
</if>
<include refid="utility.sortBy" />
<include refid="utility.paging-suffix"/>
</select>
<select id="selectTodayCrackdownList" parameterType="map" resultType="dataobject">
/* 금일 단속자료 목록 조회(crdnListMapper.selectTodayCrackdownList) */
<include refid="utility.paging-prefix"/>
SELECT C.CRDN_ID <!-- 단속 ID -->
, C.SGG_CD <!-- 시군구 코드 -->
, C.TASK_SE_CD <!-- 업무 구분 코드 -->
, C.CRDN_REG_SE_CD <!-- 단속 등록 구분 코드 -->
, GET_CODE_NM('FIM026', C.CRDN_REG_SE_CD) AS CRDN_REG_SE_NM
, C.CRDN_INPT_SE_CD <!-- 단속 입력 구분 코드 -->
, GET_CODE_NM('FIM003', C.CRDN_INPT_SE_CD) AS CRDN_INPT_SE_NM
, CONCAT(C.CRDN_YMD,'', C.CRDN_TM) AS CRDN_YMD_TM <!-- 단속 일시 -->
, C.VHRNO <!-- 차량번호 -->
, C.CRDN_PLC <!-- 단속 장소 -->
, (SELECT VLTN_ARTCL FROM TB_VLTN WHERE VLTN_ID = C.VLTN_ID) AS VLTN_ARTCL
, C.DEL_YN
, C.RGTR
, C.REG_DT
, C.MDFR
, C.MDFCN_DT
, C.DLTR
, C.DEL_DT
FROM TB_CRDN C
WHERE C.DEL_YN = 'N'
AND C.SGG_CD = #{sggCd}
AND C.TASK_SE_CD = #{taskSeCd}
AND C.RGTR = #{currentUserId}
AND SUBSTR(C.REG_DT,1,8) = <include refid="utility.today" />
<include refid="utility.sortBy" />
<include refid="utility.paging-suffix"/>
</select>
<select id="selectPhotoInspectionDataList" parameterType="map" resultType="dataobject">
/* 단속사진 검사 자료 목록 조회(crdnListMapper.selectPhotoInspectionDataList) */
<include refid="utility.paging-prefix"/>
SELECT C.CRDN_ID <!-- 단속 ID -->
, C.SGG_CD <!-- 시군구 코드 -->
, C.TASK_SE_CD <!-- 업무 구분 코드 -->
, CONCAT(C.CRDN_YMD,'',C.CRDN_TM) AS CRDN_YMD_TM <!-- 단속 일시 -->
, C.VHRNO <!-- 차량번호 -->
, COUNT(*) OVER (PARTITION BY C.VHRNO, C.CRDN_PLC) AS CRDN_CNT <!-- 위반건수 -->
, '' AS INSP_RSLT
, '' AS PRCS_MTHD
, C.CRDN_STDG_NM <!-- 단속 법정동 명 -->
, C.CRDN_PLC
, C.ATCH_FILE_CNT <!-- 사진건수 -->
, C.CRDN_STTS_CD <!-- 단속 상태 코드 -->
, (SELECT GET_CODE_NM('FIM010', C.CRDN_STTS_CD) FROM DUAL) AS CRDN_STTS_NM
, C.FFNLG_CRDN_AMT <!-- 원금액 -->
, C.ADVNTCE_AMT <!-- 감경금액 -->
, C.CRDN_INPT_SE_CD <!-- 자료출처 -->
, (SELECT GET_CODE_NM('FIM003', C.CRDN_INPT_SE_CD) FROM DUAL) AS CRDN_INPT_SE_NM <!-- 자료출처 -->
FROM TB_CRDN C
INNER JOIN TB_CRDN_ADI CA ON (C.CRDN_ID = CA.CRDN_ID)
WHERE C.DEL_YN = 'N'
AND C.SGG_CD = #{sggCd}
AND C.TASK_SE_CD = #{taskSeCd}
<if test="schCrdnYmdFrom != null or schCrdnYmdTo != null">
<if test="schCrdnYmdFrom != null">AND C.CRDN_YMD <![CDATA[ >= ]]> #{schCrdnYmdFrom} </if>
<if test="schCrdnYmdTo != null">AND C.CRDN_YMD <![CDATA[ <= ]]> #{schCrdnYmdTo} </if>
</if>
<if test="crdnInptSeCd != null">AND C.CRDN_INPT_SE_CD = #{crdnInptSeCd}</if>
<if test="vhrno != null">AND C.VHRNO = #{vhrno}</if>
<if test="schExclEnd == 'on'">AND C.CRDN_STTS_CD != '81'</if>
<if test="schOnlyUnpay == 'on'">
<!-- TODO : 미납만 조회 -->
</if>
<if test="taskSeCd == 'PVS'">
<if test="schExclOvtime == 'on'">
AND IFNULL(CA.OVTM_YN,'N') = 'N'
AND IFNULL(CA.OVTM_PRTTN_YN,'N') = 'N'
</if>
</if>
<if test="schRegDateFrom != null or schRegDateTo != null">
<if test="schRegDateOpt == 'regDt'">
<if test="schRegDateFrom != null"> AND C.REG_DT <![CDATA[>=]]> CONCAT(#{schRegDateFrom},'000000') </if>
<if test="schRegDateTo != null"> AND C.REG_DT <![CDATA[<=]]> CONCAT(#{schRegDateTo},'235959') </if>
</if>
<if test="schRegDateOpt == 'mdfcnDt'">
<if test="schRegDateFrom != null"> AND C.MDFCN_DT <![CDATA[ >= ]]> CONCAT(#{schRegDateFrom},'000000') </if>
<if test="schRegDateTo != null"> AND C.MDFCN_DT <![CDATA[ <= ]]> CONCAT(#{schRegDateTo},'235959') </if>
</if>
</if>
<if test="schRgtrCd != null">
<if test="schRgtrOpt == 'rgtr'">
<if test="schRgtrCd != null"> AND C.RGTR = #{schRgtrCd} </if>
</if>
<if test="schRgtrOpt == 'mdfr'">
<if test="schRgtrCd != null"> AND C.MDFR = #{schRgtrCd} </if>
</if>
</if>
<if test="@org.egovframe.rte.fdl.string.EgovStringUtil@isNotEmpty(by) and @org.egovframe.rte.fdl.string.EgovStringUtil@isNotEmpty(term)">
<choose>
<when test="mainOption == 'codeValue' or mainOption == 'match' or mainOption == 'ymd'">
<include refid="dynamicSearch.start" />
<choose>
<when test="by == 'crdnYmd'">C.CRDN_YMD</when>
<when test="by == 'vhrno'">C.VHRNO</when>
<when test="by == 'crdnStdgNm'">C.CRDN_STDG_NM</when>
<when test="by == 'crdnPlc'">C.CRDN_PLC</when>
<when test="by == 'atchFileCnt'">C.ATCH_FILE_CNT</when>
<when test="by == 'crdnSttsCd'">C.CRDN_STTS_CD</when>
<when test="by == 'ffnlgCrdnAmt'">C.FFNLG_CRDN_AMT</when>
<when test="by == 'advntceAmt'">C.ADVNTCE_AMT</when>
<when test="by == 'crdnInptSeCd'">C.CRDN_INPT_SE_CD</when>
</choose>
<include refid="dynamicSearch.center" />#{term}<include refid="dynamicSearch.end" />
</when>
<otherwise>
</otherwise>
</choose>
</if>
<if test="crdnSttsCd != null">
AND C.CRDN_STTS_CD = #{crdnSttsCd}
</if>
<if test="schDateFrom != null or schDateTo != null">
<if test="schDateOpt == 'regDt'">
<if test="schDateFrom != null">AND SUBSTR(C.REG_DT,1,8) <![CDATA[ >= ]]> #{schDateFrom} </if>
<if test="schDateTo != null">AND SUBSTR(C.REG_DT,1,8) <![CDATA[ <= ]]> #{schDateTo} </if>
</if>
<if test="schDateOpt == 'mdfcnDt'">
<if test="schDateFrom != null">AND SUBSTR(C.MDFCN_DT,1,8) <![CDATA[ >= ]]> #{schDateFrom} </if>
<if test="schDateTo != null">AND SUBSTR(C.MDFCN_DT,1,8) <![CDATA[ <= ]]> #{schDateTo} </if>
</if>
</if>
<include refid="utility.sortBy" />
<include refid="utility.paging-suffix"/>
</select>
<select id="selectSameVehicleMainList" parameterType="map" resultType="dataobject">
/* 동일 차량 단속 그룹 목록 조회(crdnListMapper.selectSameVehicleMainList) */
<include refid="utility.paging-prefix"/>
SELECT GROUP_CONCAT(C.CRDN_ID) AS CRDN_ID_LIST <!-- 단속 ID -->
, C.VHRNO <!-- 차량번호 -->
<choose>
<when test="schOnlySamePlace == 'on'">
, C.CRDN_STDG_NM <!-- 단속 법정동 명 -->
</when>
<otherwise>
, '' AS CRDN_STDG_NM
</otherwise>
</choose>
, COUNT(*) AS CRDN_CNT <!-- 단속건수 -->
FROM TB_CRDN C
INNER JOIN TB_CRDN_ADI CA ON (C.CRDN_ID = CA.CRDN_ID)
LEFT OUTER JOIN TB_TEAM T ON (CA.TEAM_ID = T.TEAM_ID)
LEFT OUTER JOIN TB_PAYER P ON (C.RTPYR_ID = P.RTPYR_ID)
WHERE C.DEL_YN = 'N'
AND C.SGG_CD = #{sggCd}
AND C.TASK_SE_CD = #{taskSeCd}
AND C.VHRNO != ''
<if test="schOnlySamePlace == 'on'">
AND C.CRDN_STDG_NM != ''
</if>
<if test="schCrdnYmdFrom != null or schCrdnYmdTo != null">
<if test="schCrdnYmdFrom != null">AND C.CRDN_YMD <![CDATA[ >= ]]> #{schCrdnYmdFrom} </if>
<if test="schCrdnYmdTo != null">AND C.CRDN_YMD <![CDATA[ <= ]]> #{schCrdnYmdTo} </if>
</if>
<if test="crdnInptSeCd != null">AND C.CRDN_INPT_SE_CD = #{crdnInptSeCd}</if>
<if test="vhrno != null">AND C.VHRNO = #{vhrno}</if>
<if test="schExclEnd == 'on'">AND C.CRDN_STTS_CD != '81'</if>
<if test="@org.egovframe.rte.fdl.string.EgovStringUtil@isNotEmpty(by) and @org.egovframe.rte.fdl.string.EgovStringUtil@isNotEmpty(term)">
<choose>
<when test="mainOption == 'codeValue' or mainOption == 'match' or mainOption == 'ymd'">
<include refid="dynamicSearch.start" />
<choose>
<when test="by == 'crdnYmd'">C.CRDN_YMD</when>
<when test="by == 'crdnInptSeCd'">C.CRDN_INPT_SE_CD</when>
<when test="by == 'teamNm'">T.TEAM_NM</when>
<when test="by == 'vhrno'">C.VHRNO</when>
<when test="by == 'crdnStdgNm'">C.CRDN_STDG_NM</when>
<when test="by == 'crdnPlc'">C.CRDN_PLC</when>
<when test="by == 'crdnSttsCd'">C.CRDN_STTS_CD</when>
<when test="by == 'ffnlgCrdnAmt'">C.FFNLG_CRDN_AMT</when>
<when test="by == 'rtpyrNm'">P.RTPYR_NM</when>
</choose>
<include refid="dynamicSearch.center" />#{term}<include refid="dynamicSearch.end" />
</when>
<otherwise>
</otherwise>
</choose>
</if>
<if test="crdnSttsCd != null">
AND C.CRDN_STTS_CD = #{crdnSttsCd}
</if>
<if test="schDateFrom != null or schDateTo != null">
<if test="schDateOpt == 'regDt'">
<if test="schDateFrom != null">AND SUBSTR(C.REG_DT,1,8) <![CDATA[ >= ]]> #{schDateFrom} </if>
<if test="schDateTo != null">AND SUBSTR(C.REG_DT,1,8) <![CDATA[ <= ]]> #{schDateTo} </if>
</if>
<if test="schDateOpt == 'mdfcnDt'">
<if test="schDateFrom != null">AND SUBSTR(C.MDFCN_DT,1,8) <![CDATA[ >= ]]> #{schDateFrom} </if>
<if test="schDateTo != null">AND SUBSTR(C.MDFCN_DT,1,8) <![CDATA[ <= ]]> #{schDateTo} </if>
</if>
</if>
GROUP BY C.VHRNO<if test="schOnlySamePlace == 'on'">, C.CRDN_STDG_NM </if>
HAVING COUNT(*) <![CDATA[ >= ]]>
<choose>
<when test="schCrdnCntFrom != null"> #{schCrdnCntFrom} </when>
<otherwise> 2 </otherwise>
</choose>
<if test="schCrdnCntTo != null"> AND COUNT(*) <![CDATA[ <= ]]> #{schCrdnCntTo} </if>
<include refid="utility.sortBy" />
<include refid="utility.paging-suffix"/>
</select>
<select id="selectSameVehicleSubList" parameterType="map" resultType="dataobject">
/* 동일 차량 단속 자료 목록 조회(crdnListMapper.selectSameVehicleSubList) */
SELECT C.CRDN_ID <!-- 단속 ID -->
, C.SGG_CD <!-- 시군구 코드 -->
, C.TASK_SE_CD <!-- 업무 구분 코드 -->
, CONCAT(C.CRDN_YMD,'',C.CRDN_TM) AS CRDN_YMD_TM <!-- 단속일시 -->
, C.CRDN_INPT_SE_CD <!-- 자료출처 -->
, (SELECT GET_CODE_NM('FIM003', C.CRDN_INPT_SE_CD) FROM DUAL) AS CRDN_INPT_SE_NM
, T.TEAM_NM <!-- 단속조 -->
, C.VHRNO <!-- 차량번호 -->
, C.CRDN_STDG_NM <!-- 단속 법정동 명 -->
, C.CRDN_PLC <!-- 단속장소 -->
, C.CRDN_STTS_CD <!-- 처리상태 -->
, (SELECT GET_CODE_NM('FIM010', C.CRDN_STTS_CD) FROM DUAL) AS CRDN_STTS_NM
, C.FFNLG_CRDN_AMT <!-- 금액 -->
, P.RTPYR_NM <!-- 성명 -->
, P.RTPYR_NO <!-- 주민번호 -->
FROM TB_CRDN C
INNER JOIN TB_CRDN_ADI CA ON (C.CRDN_ID = CA.CRDN_ID)
LEFT OUTER JOIN TB_TEAM T ON (CA.TEAM_ID = T.TEAM_ID)
LEFT OUTER JOIN TB_PAYER P ON (C.RTPYR_ID = P.RTPYR_ID)
WHERE C.DEL_YN = 'N'
AND C.SGG_CD = #{sggCd}
AND C.TASK_SE_CD = #{taskSeCd}
AND C.CRDN_ID IN (<foreach collection="crdnIds" item="CRDN_ID" separator=",">#{CRDN_ID}</foreach>)
<include refid="utility.sortBy" />
</select>
<select id="selectTagInformationUndefinedDataList" parameterType="map" resultType="dataobject">
/* 표지정보 미확인 자료 목록 조회(crdnListMapper.selectTagInformationUndefinedDataList) */
<include refid="utility.paging-prefix"/>
SELECT C.CRDN_ID <!-- 단속 ID -->
, C.SGG_CD <!-- 시군구 코드 -->
, C.TASK_SE_CD <!-- 업무 구분 코드 -->
, C.CRDN_INPT_SE_CD <!-- 단속 입력 구분 코드 -->
, (SELECT GET_CODE_NM('FIM003', C.CRDN_INPT_SE_CD) FROM DUAL) AS CRDN_INPT_SE_NM
, CONCAT(C.CRDN_YMD,'',C.CRDN_TM) AS CRDN_YMD_TM <!-- 단속 일시 -->
, C.VHRNO <!-- 차량번호 -->
, C.CRDN_STDG_NM <!-- 단속 법정동 명 -->
, C.CRDN_STTS_CD <!-- 처리상태 -->
, C.FFNLG_AMT <!-- 과태료금액 -->
, C.ADVNTCE_AMT <!-- 사전통지금액 -->
, C.MINUS_AMT <!-- 감경금액 -->
, C.ADTN_AMT <!-- 가산금액 -->
, C.RCVMT_AMT <!-- 수납금액 -->
, C.ATCH_FILE_CNT <!-- 사진건수 -->
, CA.CRDN_SN <!-- 단속 일련번호 -->
, 0 AS BLNC <!-- 잔액 -->
FROM TB_CRDN C
INNER JOIN TB_CRDN_ADI CA ON (C.CRDN_ID = CA.CRDN_ID)
LEFT OUTER JOIN TB_TEAM T ON (CA.TEAM_ID = T.TEAM_ID)
LEFT OUTER JOIN TB_CRDN_CVLCPT CC ON (C.CVLCPT_LINK_YN = 'Y' AND C.LINK_ID = CC.CVLCPT_LINK_ID)
WHERE C.DEL_YN = 'N'
AND C.SGG_CD = #{sggCd}
AND C.TASK_SE_CD = 'DPV'
AND CA.PRK_PSBLTY_RSLT_CD = '0'
AND C.CRDN_STTS_CD = '21'
<if test="@org.egovframe.rte.fdl.string.EgovStringUtil@isNotEmpty(by) and @org.egovframe.rte.fdl.string.EgovStringUtil@isNotEmpty(term)">
<choose>
<when test="mainOption == 'codeValue' or mainOption == 'match' or mainOption == 'ymd'">
<include refid="dynamicSearch.start" />
<choose>
<when test="by == 'crdnInptSeCd'">C.CRDN_INPT_SE_CD</when>
<when test="by == 'crdnYmd'">C.CRDN_YMD</when>
<when test="by == 'vhrno'">C.VHRNO</when>
<when test="by == 'crdnStdgNm'">C.CRDN_STDG_NM</when>
<when test="by == 'atchFileCnt'">C.ATCH_FILE_CNT</when>
<when test="by == 'crdnSn'">CA.CRDN_SN</when>
</choose>
<include refid="dynamicSearch.center" />#{term}<include refid="dynamicSearch.end" />
</when>
<otherwise>
</otherwise>
</choose>
</if>
<if test="crdnId != null">AND C.CRDN_ID = #{crdnId}</if>
<if test="schCrdnYmdFrom != null or schCrdnYmdTo != null">
<if test="schCrdnYmdFrom != null">AND C.CRDN_YMD <![CDATA[ >= ]]> #{schCrdnYmdFrom} </if>
<if test="schCrdnYmdTo != null">AND C.CRDN_YMD <![CDATA[ <= ]]> #{schCrdnYmdTo} </if>
</if>
<include refid="utility.sortBy" />
<include refid="utility.paging-suffix"/>
</select>
<select id="countCrdn" parameterType="map" resultType="int">
/* 단속 건수 조회(crdnListMapper.countCrdn) */
SELECT COUNT(*)
FROM TB_CRDN C
LEFT OUTER JOIN TB_PAYER P ON (C.RTPYR_ID = P.RTPYR_ID)
WHERE C.DEL_YN = 'N'
AND C.SGG_CD = #{sggCd}
AND C.CRDN_STTS_CD != '01'
AND C.TASK_SE_CD = #{taskSeCd}
AND C.VHRNO = #{vhrno}
</select>
</mapper>

52
src/main/resources/sql/mapper/fims/crdn/crdn-stng-mapper.xml
Unescape Escape View File

@ -0,0 +1,52 @@
<?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.crdn.dao.CrdnStngMapper">
<select id="selectBasicAmt" parameterType="cokr.xit.fims.crdn.CrdnQuery" resultType="string">
/* 기본금액 조회(crdnStngMapper.selectBasicAmt) */
SELECT AMT
FROM TB_AMT
WHERE USE_YN = 'Y'
AND TASK_SE_CD = #{taskSeCd}
AND BGNG_YMD <![CDATA[ <= ]]> #{aplcnYmd}
AND END_YMD <![CDATA[ >= ]]> #{aplcnYmd}
<if test="amtDcsnCdGroupId != null">
AND AMT_DCSN_CD_GROUP_ID = #{amtDcsnCdGroupId}
AND AMT_DCSN_CD = #{amtDcsnCd}
</if>
<if test="dtlAmtDcsnGroupId != null">
AND DTL_AMT_DCSN_GROUP_ID = #{dtlAmtDcsnGroupId}
AND DTL_AMT_DCSN_CD = #{dtlAmtDcsnCd}
</if>
</select>
<select id="selectStdgNmList" parameterType="string" resultType="string">
/* 법정동코드 목록 조회(crdnStngMapper.selectStdgNmList) */
SELECT CONCAT(A.EMD_NM,
CASE WHEN A.LI_NM = ''
THEN ''
ELSE CONCAT(' ', A.LI_NM)
END) AS STDG_NM
FROM TB_STDG A
WHERE A.STDG_CD LIKE CONCAT(#{sggCd},'%')
AND A.STDG_CD != CONCAT(#{sggCd},'00000')
ORDER BY A.EMD_NM, A.LI_NM
</select>
<select id="selectStdgCdListByStdgNm" parameterType="map" resultType="string">
/* 법정동명으로 법정동코드 조회(crdnStngMapper.selectStdgCdListByStdgNm) */
SELECT STDG_CD
FROM TB_STDG
WHERE EMD_NM IS NOT NULL
AND EMD_NM != ''
AND USE_YN = 'Y'
AND EMD_NM = #{emdNm}
AND SUBSTR(STDG_CD,1,5) = #{sggCd}
</select>
</mapper>

143
src/main/resources/sql/mapper/fims/crdn/crdn-team-mapper.xml
Unescape Escape View File

@ -0,0 +1,143 @@
<?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.crdn.dao.CrdnTeamMapper">
<select id="selectTeamList" parameterType="cokr.xit.fims.crdn.CrdnQuery" resultType="dataobject">
/* 단속팀 목록 조회(crdnTeamMapper.selectTeamList) */
SELECT A.TEAM_ID
, A.TEAM_NM
, A.CRDN_SE_CD
, GET_CODE_NM('FIM002', A.CRDN_SE_CD) AS CRDN_SE_NM
, A.TEAMER_1
, A.TEAMER_2
, A.TEAMER_3
, A.TEAMER_4
, A.ETC_CN
, A.REG_DT
FROM TB_TEAM A
WHERE A.USE_YN = 'Y'
AND A.SGG_CD = #{sggCd}
AND A.TASK_SE_CD = #{taskSeCd}
ORDER BY A.TEAM_NM
</select>
<select id="selectRemovedTeamList" parameterType="cokr.xit.fims.crdn.CrdnQuery" resultType="dataobject">
/* 비사용 단속팀 목록 조회(crdnTeamMapper.selectRemovedTeamList) */
SELECT A.TEAM_ID
, A.TEAM_NM
, A.CRDN_SE_CD
, GET_CODE_NM('FIM002', A.CRDN_SE_CD) AS CRDN_SE_NM
, A.TEAMER_1
, A.TEAMER_2
, A.TEAMER_3
, A.TEAMER_4
, A.ETC_CN
, A.REG_DT
, A.MDFCN_DT
FROM TB_TEAM A
WHERE A.USE_YN = 'N'
AND A.SGG_CD = #{sggCd}
AND A.TASK_SE_CD = #{taskSeCd}
AND A.TEAM_NM = #{teamNm}
ORDER BY A.MDFCN_DT
</select>
<update id="deleteTeamInfo" parameterType="cokr.xit.fims.crdn.Team">
/* 단속팀 정보 삭제(crdnTeamMapper.deleteTeamInfo) */
UPDATE TB_TEAM
SET USE_YN = 'N'
, MDFCN_DT = <include refid="utility.now" />
, MDFR = #{removedBy}
WHERE TEAM_ID = #{teamId}
</update>
<insert id="insertTeamInfo" parameterType="cokr.xit.fims.crdn.Team">
/* 단속팀 정보 등록(crdnTeamMapper.insertTeamInfo) */
<selectKey resultType="string" keyProperty="teamId" keyColumn="NEW_ID" order="BEFORE">
<include refid="numbering.key">
<property name="TABLE_NAME" value="TB_TEAM" />
<property name="TABLE_KEY" value="TEAM_ID" />
<property name="pad" value="10" />
</include>
</selectKey>
INSERT
INTO TB_TEAM (
TEAM_ID
, SGG_CD
, TASK_SE_CD
, TEAM_NM
, CRDN_SE_CD
, TEAMER_1
, TEAMER_2
, TEAMER_3
, TEAMER_4
, ETC_CN
, USE_YN
, REG_DT
, RGTR
, MDFCN_DT
, MDFR
) VALUES (
#{teamId}
, #{sggCd}
, #{taskSeCd}
, #{teamNm}
, #{crdnSeCd}
, #{teamer1}
, #{teamer2}
, #{teamer3}
, #{teamer4}
, #{etcCn}
, 'Y'
, <include refid="utility.now" />
, #{createdBy}
, <include refid="utility.now" />
, #{modifiedBy}
)
</insert>
<update id="updateTeamInfo" parameterType="cokr.xit.fims.crdn.Team">
/* 단속팀 정보 수정(crdnTeamMapper.updateTeamInfo) */
UPDATE TB_TEAM
SET ETC_CN = #{etcCn}
, MDFCN_DT = <include refid="utility.now" />
, MDFR = #{modifiedBy}
WHERE TEAM_ID = #{teamId}
</update>
<select id="selectTeamInfoByName" parameterType="cokr.xit.fims.crdn.Team" resultType="dataobject">
/* 단속팀명으로 단속팀 정보 조회(crdnTeamMapper.selectTeamInfoByName) */
SELECT TEAM_ID
, SGG_CD
, TASK_SE_CD
, TEAM_NM
, CRDN_SE_CD
, TEAMER_1
, TEAMER_2
, TEAMER_3
, TEAMER_4
, ETC_CN
FROM TB_TEAM
WHERE TEAM_NM = #{teamNm}
AND SGG_CD = #{sggCd}
AND TASK_SE_CD = #{taskSeCd}
AND USE_YN = 'Y'
</select>
<select id="selectTeamInfo" parameterType="string" resultType="dataobject">
/* 단속팀 정보 조회(crdnTeamMapper.selectTeamInfo) */
SELECT TEAM_ID
, SGG_CD
, TASK_SE_CD
, TEAM_NM
, CRDN_SE_CD
, TEAMER_1
, TEAMER_2
, TEAMER_3
, TEAMER_4
, ETC_CN
FROM TB_TEAM
WHERE TEAM_ID = #{teamId}
</select>
</mapper>

207
src/main/resources/sql/mapper/fims/crdn/crdn-updt-mapper.xml
Unescape Escape View File

@ -0,0 +1,207 @@
<?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.crdn.dao.CrdnUpdtMapper">
<update id="updateCrdnStatus" parameterType="cokr.xit.fims.crdn.Crdn">/* 단속 상태 수정(crdnUpdtMapper.updateCrdnStatus) */
UPDATE TB_CRDN
SET CRDN_STTS_CD = #{crdnSttsCd} /* 단속 상태 */
, CRDN_STTS_CHG_DT = <include refid="utility.now" /> /* 단속 상태 변경 일시 */
, MDFCN_DT = <include refid="utility.now" /> /* 수정일시 */
, MDFR = #{modifiedBy} /* 수정자 */
WHERE CRDN_ID = #{crdnId} /* 단속 ID */
AND DEL_YN = 'N' /* 삭제 여부 */
</update>
<update id="updateCrdn" parameterType="cokr.xit.fims.crdn.Crdn">
/* 단속정보 수정(crdnUpdtMapper.updateCrdn) */
UPDATE TB_CRDN
SET MDFCN_DT = <include refid="utility.now" /> /* 수정일시 */
, MDFR = #{modifiedBy} /* 수정자 */
, ATCH_FILE_CNT = ATCH_FILE_CNT + (#{changeFileCnt})
, RTPYR_ID = #{rtpyrId} <!-- 납부자 ID -->
, CRDN_YMD = #{crdnYmd} <!-- 단속 일자 -->
, CRDN_TM = #{crdnTm} <!-- 단속 시각 -->
, VHRNO = #{vhrno} <!-- 차량번호 -->
, CRDN_STDG_NM = #{crdnStdgNm} <!-- 단속 법정동 명 -->
, CRDN_ROAD_NM = #{crdnRoadNm} <!-- 단속 도로 명 -->
, CRDN_PLC = #{crdnPlc} <!-- 단속 장소 -->
, VLTN_ID = (SELECT A.VLTN_ID
FROM TB_VLTN A
WHERE A.SGG_CD = #{sggCd}
AND A.TASK_SE_CD = #{taskSeCd}
AND A.VLTN_CD = #{vltnCd}) <!-- 위반 ID -->
, GPS_X = #{gpsX} <!-- GPS X -->
, GPS_Y = #{gpsY} <!-- GPS Y -->
, VIN = #{vin} <!-- 차대번호 -->
, VHCL_NM = #{vhclNm} <!-- 차량 명 -->
, VHCL_COLR = #{vhclColr} <!-- 차량 색상 -->
, ETC_CN = #{etcCn} <!-- 기타 내용 -->
, FFNLG_CRDN_AMT = #{ffnlgCrdnAmt} <!-- 과태료 단속 금액 -->
, FFNLG_AMT = #{ffnlgAmt} <!-- 과태료 금액 -->
, FFNLG_RDCRT = #{ffnlgRdcrt} <!-- 과태료 감경율 -->
, ADVNTCE_AMT = #{advntceAmt} <!-- 사전통지 금액 -->
<if test="crdnSttsCd != ''">
, CRDN_STTS_CD = #{crdnSttsCd} <!-- 단속 상태 코드 -->
, CRDN_STTS_CHG_DT = <include refid="utility.now" /> <!-- 단속 상태 변경 일시 -->
</if>
WHERE CRDN_ID = #{crdnId} /* 단속 ID */
</update>
<update id="updateCrdnAddition" parameterType="cokr.xit.fims.crdn.Crdn">
/* 단속 부가정보 수정(crdnUpdtMapper.updateCrdnAddition) */
UPDATE TB_CRDN_ADI
SET MDFCN_DT = <include refid="utility.now" /> /* 수정일시 */
, MDFR = #{modifiedBy} /* 수정자 */
<if test="taskSeCd == 'PVS'">
, OVTM_YN = #{ovtmYn} <!-- 시간외 여부 -->
, CRDN_SPAREA_CD = #{crdnSpareaCd} <!-- 단속 특별구역 코드 -->
</if>
<if test="taskSeCd == 'BPV'">
, DTL_CRDN_PLC = #{dtlCrdnPlc} <!-- 상세 단속 장소 -->
, MOSC_X = #{moscX} <!-- 모자이크 X -->
, MOSC_Y = #{moscY} <!-- 모자이크 Y -->
</if>
<if test="taskSeCd == 'ECA'">
, USE_FUEL_CD = #{useFuelCd} <!-- 사용 연료 코드 -->
</if>
<if test="taskSeCd == 'DPV'">
, PRK_PSBLTY_RSLT_CD = #{prkPsbltyRsltCd} <!-- 주차 가능 결과 코드 -->
</if>
<if test="taskSeCd == 'PES'">
, VLTN_NMTM = #{vltnNmtm} <!-- 위반 횟수 -->
</if>
<if test="taskSeCd == 'PVS' or taskSeCd == 'BPV'">
, CRDN_SE_CD = #{crdnSeCd} <!-- 단속 구분 코드 -->
, CRDN_BGNG_TM = #{crdnBgngTm} <!-- 단속 시작 시각 -->
, CRDN_END_TM = #{crdnEndTm} <!-- 단속 종료 시간 -->
, FFNLG_CARMDL_CD = #{ffnlgCarmdlCd} <!-- 과태료 차종 코드 -->
</if>
<if test="taskSeCd == 'DPV' or taskSeCd == 'ECA' or taskSeCd == 'PVS'">
, CRDN_SN = #{crdnSn} <!-- 단속 일련번호 -->
, TOWNG_YN = #{towngYn} <!-- 견인 여부 -->
</if>
WHERE CRDN_ID = #{crdnId} <!-- 단속 ID -->
</update>
<update id="updateTagInfo" parameterType="cokr.xit.fims.crdn.Crdn">
/* 표지정보확인 수정(crdnUpdtMapper.updateTagInfo) */
UPDATE TB_CRDN_ADI
SET PRK_PSBLTY_RSLT_CD = '1'
, MDFCN_DT = <include refid="utility.now" /> /* 수정일시 */
, MDFR = #{modifiedBy} /* 수정자 */
WHERE CRDN_ID = #{crdnId} /* 단속 ID */
</update>
<update id="updateOverTimeInfo" parameterType="cokr.xit.fims.crdn.Crdn">
/* 시간초과 여부 수정(crdnUpdtMapper.overTimeInfo) */
UPDATE TB_CRDN_ADI
SET OVTM_YN = #{ovtmYn}
, MDFCN_DT = <include refid="utility.now" /> /* 수정일시 */
, MDFR = #{modifiedBy} /* 수정자 */
WHERE CRDN_ID = #{crdnId} /* 단속 ID */
</update>
<update id="updateCrdnAmt" parameterType="cokr.xit.fims.crdn.Crdn">
/* 단속 금액 수정(crdnUpdtMapper.updateCrdnAmt) */
UPDATE TB_CRDN
SET MDFCN_DT = <include refid="utility.now" /> /* 수정일시 */
, MDFR = #{modifiedBy} /* 수정자 */
, FFNLG_CRDN_AMT = #{ffnlgCrdnAmt}
, FFNLG_AMT = #{ffnlgAmt}
, ADVNTCE_AMT = #{advntceAmt}
WHERE CRDN_ID = #{crdnId} /* 단속 ID */
</update>
<update id="updateEtcCn" parameterType="cokr.xit.fims.crdn.Crdn">
/* 단속 기타사항 수정(crdnUpdtMapper.updateEtcCn) */
UPDATE TB_CRDN
SET MDFCN_DT = <include refid="utility.now" /> /* 수정일시 */
, MDFR = #{modifiedBy} /* 수정자 */
, ETC_CN = #{etcCn}
WHERE CRDN_ID = #{crdnId} /* 단속 ID */
</update>
<update id="updateEditCrdn" parameterType="cokr.xit.fims.crdn.Crdn">/* 단속 정보 수정(crdnUpdtMapper.updateEditCrdn) */
UPDATE TB_CRDN
SET CRDN_YMD = #{crdnYmd} <!-- 단속 일자 -->
, CRDN_TM = #{crdnTm} <!-- 단속 시각 -->
, VHRNO = #{vhrno} <!-- 차량번호 -->
, CRDN_STDG_NM = #{crdnStdgNm} <!-- 단속 법정동 명 -->
, CRDN_ROAD_NM = #{crdnRoadNm} <!-- 단속 도로 명 -->
, CRDN_PLC = #{crdnPlc} <!-- 단속 장소 -->
, VLTN_ID = (SELECT X.VLTN_ID
FROM TB_VLTN X
WHERE X.SGG_CD = #{sggCd} AND X.TASK_SE_CD = #{taskSeCd}
AND X.VLTN_CD = #{vltnCd}) <!-- 위반 ID -->
, GPS_X = #{gpsX} <!-- GPS X -->
, GPS_Y = #{gpsY} <!-- GPS Y -->
, VIN = #{vin} <!-- 차대번호 -->
, VHCL_NM = #{vhclNm} <!-- 차량 명 -->
, VHCL_COLR = #{vhclColr} <!-- 차량 색상 -->
, FFNLG_CRDN_AMT = #{ffnlgCrdnAmt} <!-- 과태료 단속 금액 -->
, FFNLG_AMT = #{ffnlgAmt} <!-- 과태료 금액 -->
, ADVNTCE_AMT = #{advntceAmt} <!-- 사전통지 금액 -->
, ETC_CN = #{etcCn} <!-- 기타 내용 -->
, MDFCN_DT = <include refid="utility.now" /> <!-- 수정일시 -->
, MDFR = #{modifiedBy} <!-- 수정자 -->
WHERE CRDN_ID = #{crdnId} <!-- 단속 ID -->
AND DEL_YN = 'N' <!-- 삭제 여부 -->
</update>
<update id="deleteCrdn" parameterType="map">/* 단속 정보 삭제(crdnUpdtMapper.deleteCrdn) */
UPDATE TB_CRDN
SET DEL_YN = 'Y'
, DEL_DT = <include refid="utility.now" /> <!-- 삭제일시 -->
, DLTR = #{removedBy} <!-- 삭제자 -->
, DEL_RSN = #{delRsn} <!-- 삭제 사유 -->
WHERE CRDN_ID IN (
<foreach collection="crdnIds" item="crdnId" separator=",">#{crdnId}</foreach>
)
AND DEL_YN = 'N' <!-- 삭제 여부 -->
</update>
<update id="deleteCrdnAdi" parameterType="map">/* 단속 부가 정보 삭제(crdnUpdtMapper.deleteCrdnAdi) */
UPDATE TB_CRDN_ADI
SET DEL_YN = 'Y'
, DEL_DT = <include refid="utility.now" /> <!-- 삭제일시 -->
, DLTR = #{removedBy} <!-- 삭제자 -->
, DEL_RSN = #{delRsn} <!-- 삭제 사유 -->
WHERE CRDN_ID IN (
<foreach collection="crdnIds" item="crdnId" separator=",">#{crdnId}</foreach>
)
AND DEL_YN = 'N' <!-- 삭제 여부 -->
</update>
<update id="deleteCrdnPayer" parameterType="map">/* 단속 납부자 ID 삭제(crdnUpdtMapper.deleteCrdnPayer) */
UPDATE TB_CRDN
SET RTPYR_ID = NULL <!-- 납부자 ID -->
, MDFCN_DT = <include refid="utility.now" /> <!-- 수정일시 -->
, MDFR = #{modifiedBy} <!-- 수정자 -->
WHERE CRDN_ID = #{crdnId} <!-- 단속 ID -->
AND RTPYR_ID = #{rtpyrId} <!-- 납부자 ID -->
AND DEL_YN = 'N' <!-- 삭제 여부 -->
</update>
<update id="updateNxrpCrdnLinkYn" parameterType="cokr.xit.fims.crdn.Crdn">
/* 세외수입 단속 연계 여부 변경(crdnUpdtMapper.updateNxrpCrdnLinkYn) */
UPDATE TB_CRDN
SET NXRP_CRDN_LINK_YN = 'Y' <!-- 세외수입 단속 연계 여부 -->
, NXRP_CRDN_LINK_DT = <include refid="utility.now" /> <!-- 세외수입 단속 연계 일시 -->
, NXRP_CRDN_LINK_USER_ID = #{modifiedBy} <!-- 세외수입 단속 연계 사용자 ID -->
, MDFCN_DT = <include refid="utility.now" /> <!-- 수정일시 -->
, MDFR = #{modifiedBy} <!-- 수정자 -->
WHERE CRDN_ID = #{crdnId} <!-- 단속 ID -->
AND DEL_YN = 'N' <!-- 삭제 여부 -->
</update>
<update id="updateAdvntceYmd" parameterType="map">/* 사전통지 일자 수정(crdnUpdtMapper.updateAdvntceYmd) */
UPDATE TB_CRDN
SET ADVNTCE_BGNG_YMD = #{advntceBgngYmd} <!-- 사전통지 시작 일자 -->
, ADVNTCE_DUDT_YMD = #{advntceDudtYmd} <!-- 사전통지 납기 일자 -->
, MDFCN_DT = <include refid="utility.now" /> <!-- 수정일시 -->
, MDFR = #{modifiedBy} <!-- 수정자 -->
WHERE CRDN_ID = #{crdnId} <!-- 단속 ID -->
AND DEL_YN = 'N' <!-- 삭제 여부 -->
</update>
</mapper>

188
src/main/resources/sql/mapper/fims/crdn/exmptn-vhcl-mapper.xml
Unescape Escape View File

@ -0,0 +1,188 @@
<?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.crdn.dao.ExmptnVhclMapper">
<select id="selectExemptionVehicleList" parameterType="cokr.xit.fims.crdn.CrdnQuery" resultType="dataobject">
/* 면제차량 목록 조회(exmptnVhclMapper.selectExemptionVehicleList) */
<include refid="utility.paging-prefix"/>
SELECT A.EXMPTN_VHCL_ID
, A.VHRNO
, A.EXMPTN_RSN
, A.DOC_NO
, A.OWNR_NM
, A.EXMPTN_BGNG_YMD
, A.EXMPTN_END_YMD
, (SELECT USER_NM FROM TB_USER X WHERE X.USER_ID = A.RGTR) AS RGTR_NM
, A.REG_DT
, (SELECT USER_NM FROM TB_USER X WHERE X.USER_ID = A.MDFR) AS MDFR_NM
, A.MDFCN_DT
, (SELECT USER_NM FROM TB_USER X WHERE X.USER_ID = A.DLTR) AS DLTR_NM
, A.DEL_RSN
, A.DEL_DT
, A.DEL_YN
FROM TB_EXMPTN_VHCL A
WHERE A.SGG_CD = #{sggCd}
<if test="vhrno != null and vhrno != ''">
AND A.VHRNO = #{vhrno}
</if>
<if test="delYn != null and delYn != ''">
AND A.DEL_YN = #{delYn}
</if>
<if test="crdnYmd != null and crdnYmd !=''">
AND A.EXMPTN_BGNG_YMD <![CDATA[ <= ]]> #{crdnYmd}
AND A.EXMPTN_END_YMD <![CDATA[ >= ]]> #{crdnYmd}
</if>
<include refid="utility.sortBy" />
<include refid="utility.paging-suffix"/>
</select>
<select id="selectExemptionVehicleInfo" parameterType="string" resultType="dataobject">
/* 면제차량 정보 조회(exmptnVhclMapper.selectExemptionVehicleInfo) */
SELECT A.EXMPTN_VHCL_ID
, A.SGG_CD
, A.VHRNO
, A.EXMPTN_RSN
, A.DOC_NO
, A.OWNR_NM
, A.EXMPTN_BGNG_YMD
, A.EXMPTN_END_YMD
FROM TB_EXMPTN_VHCL A
WHERE A.EXMPTN_VHCL_ID = #{exmptnVhclId}
</select>
<insert id="insertExemptionVehicleInfo" parameterType="cokr.xit.fims.crdn.ExmptnVhcl">
/* 면제차량 정보 등록(exmptnVhclMapper.insertExemptionVehicleInfo) */
<selectKey resultType="string" keyProperty="exmptnVhclId" keyColumn="NEW_ID" order="BEFORE">
<include refid="numbering.key">
<property name="TABLE_NAME" value="TB_EXMPTN_VHCL" />
<property name="TABLE_KEY" value="EXMPTN_VHCL_ID" />
<property name="pad" value="10" />
</include>
</selectKey>
INSERT INTO TB_EXMPTN_VHCL (
EXMPTN_VHCL_ID <!-- 면제 차량 ID -->
, SGG_CD <!-- 시군구 코드 -->
, VHRNO <!-- 차량 번호 -->
, EXMPTN_RSN <!-- 면제 사유 -->
, DOC_NO <!-- 문서번호 -->
, OWNR_NM <!-- 소유자명 -->
, EXMPTN_BGNG_YMD <!-- 면제 시작 일자-->
, EXMPTN_END_YMD <!-- 면제 종료 일자 -->
, DEL_YN <!-- 삭제 여부 -->
, REG_DT <!-- 등록 일시 -->
, RGTR <!-- 등록자 -->
, MDFCN_DT <!-- 수정 일시 -->
, MDFR <!-- 수정자 -->
) VALUES (
#{exmptnVhclId} <!-- 면제 차량 ID -->
, #{sggCd} <!-- 시군구 코드 -->
, #{vhrno} <!-- 차량 번호 -->
, #{exmptnRsn} <!-- 면제 사유 -->
, #{docNo} <!-- 문서번호 -->
, #{ownrNm} <!-- 소유자명 -->
, #{exmptnBgngYmd} <!-- 면제 시작 일자-->
, #{exmptnEndYmd} <!-- 면제 종료 일자 -->
, 'N' <!-- 삭제 여부 -->
, <include refid="utility.now" /> <!-- 등록 일시 -->
, #{createdBy} <!-- 등록자 -->
, <include refid="utility.now" /> <!-- 수정 일시 -->
, #{modifiedBy} <!-- 수정자 -->
)
</insert>
<update id="updateExemptionVehicleInfo" parameterType="cokr.xit.fims.crdn.ExmptnVhcl">
/* 면제차량 정보 수정(exmptnVhclMapper.updateExemptionVehicleInfo) */
UPDATE TB_EXMPTN_VHCL
SET EXMPTN_RSN = #{exmptnRsn} <!-- 면제 사유 -->
, DOC_NO = #{docNo} <!-- 문서번호 -->
, OWNR_NM = #{ownrNm} <!-- 소유자명 -->
, EXMPTN_BGNG_YMD = #{exmptnBgngYmd} <!-- 면제 시작 일자 -->
, EXMPTN_END_YMD = #{exmptnEndYmd} <!-- 면제 종료 일자 -->
, MDFCN_DT = <include refid="utility.now" /> <!-- 수정 일시 -->
, MDFR = #{modifiedBy} <!-- 수정자 -->
WHERE EXMPTN_VHCL_ID = #{exmptnVhclId}
</update>
<update id="deleteExemptionVehicleInfo" parameterType="cokr.xit.fims.crdn.ExmptnVhcl">
/* 면제차량 정보 삭제(exmptnVhclMapper.deleteExemptionVehicleInfo) */
UPDATE TB_EXMPTN_VHCL
SET DEL_YN = 'Y'
, DEL_RSN = #{delRsn} <!-- 삭제 사유 -->
, DEL_DT = <include refid="utility.now" /> <!-- 삭제 일시 -->
, DLTR = #{removedBy} <!-- 삭제자 -->
WHERE EXMPTN_VHCL_ID = #{exmptnVhclId}
</update>
<insert id="insertExemptionVehicleHistory" parameterType="cokr.xit.fims.crdn.ExmptnVhcl">
/* 면제차량 정보 등록(exmptnVhclMapper.insertExemptionVehicleHistory) */
<selectKey resultType="string" keyProperty="hstrySn" keyColumn="NEW_ID" order="BEFORE">
SELECT
LPAD(CAST(IFNULL(MAX(HSTRY_SN) + 1, 1) AS INT), 5, '0')
AS NEW_ID
FROM TB_EXMPTN_VHCL_HSTRY WHERE EXMPTN_VHCL_ID = #{exmptnVhclId}
</selectKey>
INSERT INTO TB_EXMPTN_VHCL_HSTRY (
EXMPTN_VHCL_ID <!-- 면제 차량 ID -->
, HSTRY_SN <!-- 이력 일련번호 -->
, SGG_CD <!-- 시군구 코드 -->
, VHRNO <!-- 차량 번호 -->
, EXMPTN_RSN <!-- 면제 사유 -->
, DOC_NO <!-- 문서번호 -->
, OWNR_NM <!-- 소유자명 -->
, EXMPTN_BGNG_YMD <!-- 면제 시작 일자-->
, EXMPTN_END_YMD <!-- 면제 종료 일자 -->
, DEL_YN <!-- 삭제 여부 -->
, REG_DT <!-- 등록 일시 -->
, RGTR <!-- 등록자 -->
, MDFCN_DT <!-- 수정 일시 -->
, MDFR <!-- 수정자 -->
, DEL_DT <!-- 삭제 일시 -->
, DLTR <!-- 삭제자 -->
, DEL_RSN <!-- 삭제 사유 -->
) SELECT
EXMPTN_VHCL_ID <!-- 면제 차량 ID -->
, #{hstrySn} <!-- 이력 일련번호 -->
, SGG_CD <!-- 시군구 코드 -->
, VHRNO <!-- 차량 번호 -->
, EXMPTN_RSN <!-- 면제 사유 -->
, DOC_NO <!-- 문서번호 -->
, OWNR_NM <!-- 소유자명 -->
, EXMPTN_BGNG_YMD <!-- 면제 시작 일자-->
, EXMPTN_END_YMD <!-- 면제 종료 일자 -->
, DEL_YN <!-- 삭제 여부 -->
, REG_DT <!-- 등록 일시 -->
, RGTR <!-- 등록자 -->
, MDFCN_DT <!-- 수정 일시 -->
, MDFR <!-- 수정자 -->
, DEL_DT <!-- 삭제 일시 -->
, DLTR <!-- 삭제자 -->
, DEL_RSN <!-- 삭제 사유 -->
FROM TB_EXMPTN_VHCL
WHERE EXMPTN_VHCL_ID = #{exmptnVhclId}
</insert>
<select id="selectExemptionVehicleHistoryList" parameterType="string" resultType="dataobject">
/* 면제차량 이력 정보 조회(exmptnVhclMapper.selectExemptionVehicleHistoryList) */
SELECT A.EXMPTN_VHCL_ID
, A.HSTRY_SN
, A.SGG_CD
, A.VHRNO
, A.EXMPTN_RSN
, A.DOC_NO
, A.OWNR_NM
, A.EXMPTN_BGNG_YMD
, A.EXMPTN_END_YMD
, A.DEL_YN <!-- 삭제 여부 -->
, (SELECT USER_NM FROM TB_USER X WHERE X.USER_ID = A.RGTR) AS RGTR_NM
, A.REG_DT
, (SELECT USER_NM FROM TB_USER X WHERE X.USER_ID = A.MDFR) AS MDFR_NM
, A.MDFCN_DT
, (SELECT USER_NM FROM TB_USER X WHERE X.USER_ID = A.DLTR) AS DLTR_NM
, A.DEL_DT
, A.DEL_RSN <!-- 삭제 사유 -->
FROM TB_EXMPTN_VHCL_HSTRY A
WHERE A.EXMPTN_VHCL_ID = #{exmptnVhclId}
ORDER BY A.HSTRY_SN
</select>
</mapper>

327
src/main/resources/sql/mapper/fims/excl/levyExcl-mapper.xml
Unescape Escape View File

@ -0,0 +1,327 @@
<?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.excl.dao.LevyExclMapper">
<!-- 부과제외 대장 정보 매퍼
========== 변경 이력 ==========
2023-06-23 JoJH 최초 작성
============================ -->
<resultMap id="levyExclRow" type="cokr.xit.fims.excl.LevyExcl"> <!-- 부과제외 대장 -->
<result property="levyExclId" column="LEVY_EXCL_ID" /> <!-- 부과 제외 ID -->
<result property="crdnId" column="CRDN_ID" /> <!-- 단속 ID -->
<result property="rdamtId" column="RDAMT_ID" /> <!-- 감액 ID -->
<result property="levyExclYmd" column="LEVY_EXCL_YMD" /> <!-- 부과제외 일자 -->
<result property="levyExclSeCd" column="LEVY_EXCL_SE_CD" /> <!-- 부과제외 구분 코드 -->
<result property="levyExclSeNm" column="LEVY_EXCL_SE_NM" /> <!-- 부과제외 구분 명 -->
<result property="levyExclRsnCd" column="LEVY_EXCL_RSN_CD" /> <!-- 부과제외 사유 코드 -->
<result property="levyExclRsnNm" column="LEVY_EXCL_RSN_NM" /> <!-- 부과제외 사유 명 -->
<result property="etcCn" column="ETC_CN" /> <!-- 기타 내용 -->
<result property="delYn" column="DEL_YN" /> <!-- 삭제 여부 -->
<result property="createdAt" column="REG_DT" /> <!-- 등록 일시 -->
<result property="createdBy" column="RGTR" /> <!-- 등록자 -->
<result property="lastModified" column="MDFCN_DT" /> <!-- 수정 일시 -->
<result property="modifiedBy" column="MDFR" /> <!-- 수정자 -->
<result property="removedAt" column="DEL_DT" /> <!-- 삭제 일시 -->
<result property="removedBy" column="DLTR" /> <!-- 삭제자 -->
<result property="delRsn" column="DEL_RSN" /> <!-- 삭제 사유 -->
</resultMap>
<sql id="selectList">
SELECT LE.LEVY_EXCL_ID <!-- 부과제외 ID -->
, LE.LEVY_EXCL_YMD <!-- 부과제외 일자 -->
, LE.LEVY_EXCL_SE_CD <!-- 부과 제외 구분 코드 -->
, (SELECT GET_CODE_NM('FIM021', LE.LEVY_EXCL_SE_CD) FROM DUAL) AS LEVY_EXCL_SE_NM <!-- 부과 제외 구분 명 -->
, LE.LEVY_EXCL_RSN_CD <!-- 부과 제외 사유 코드 -->
, (SELECT GET_CODE_NM('FIM022', LE.LEVY_EXCL_RSN_CD) FROM DUAL) AS LEVY_EXCL_RSN_NM <!-- 부과 제외 사유 명 -->
, LE.ETC_CN <!-- 기타 내용 -->
, LE.DEL_YN <!-- 삭제 여부 -->
, LE.REG_DT <!-- 등록 일시 -->
, LE.RGTR <!-- 등록자 -->
, (SELECT USER_NM FROM TB_USER X WHERE X.USER_ID = LE.RGTR) AS RGTR_NM <!-- 등록자 명 -->
, LE.MDFCN_DT <!-- 수정 일시 -->
, LE.MDFR <!-- 수정자 -->
, (SELECT USER_NM FROM TB_USER X WHERE X.USER_ID = LE.MDFR) AS MDFR_NM <!-- 수정자 명 -->
, C.CRDN_ID <!-- 단속 ID -->
, C.SGG_CD <!-- 시군구 코드 -->
, C.TASK_SE_CD <!-- 업무 구분 코드 -->
, (SELECT GET_CODE_NM('FIM054', C.TASK_SE_CD) FROM DUAL) AS TASK_SE_NM <!-- 업무 구분 명 -->
, C.CRDN_YMD <!-- 단속 일자 -->
, (CONCAT(C.CRDN_YMD, C.CRDN_TM)) AS CRDN_YMD_TM <!-- 단속 일시 -->
, C.VHRNO <!-- 차량번호 -->
, C.CRDN_STDG_NM <!-- 단속 법정동 명 -->
, C.CRDN_ROAD_NM <!-- 단속 도로 명 -->
, C.CRDN_PLC <!-- 단속 장소 -->
, C.FFNLG_CRDN_AMT <!-- 과태료 단속 금액 -->
, C.CRDN_STTS_CD <!-- 단속 상태 코드 -->
, (SELECT GET_CODE_NM('FIM010', C.CRDN_STTS_CD) FROM DUAL) AS CRDN_STTS_NM <!-- 단속 상태 명 -->
, (SELECT GET_CODE_NM('FIM002', CA.CRDN_SE_CD) FROM DUAL) AS CRDN_SE_NM <!-- 단속 구분 명 -->
, (SELECT GET_CODE_NM('FIM007', CA.CRDN_SPAREA_CD) FROM DUAL) AS CRDN_SPAREA_NM <!-- 단속 특별구역 명 -->
, (SELECT GET_CODE_NM('LVS005', CA.USE_FUEL_CD) FROM DUAL) AS USE_FUEL_NM <!-- 사용 연료 명 -->
, (SELECT GET_CODE_NM('FIM034', CA.PRK_PSBLTY_RSLT_CD) FROM DUAL) AS PRK_PSBLTY_RSLT_NM <!-- 주차 가능 결과 명 -->
, V.VLTN_ID <!-- 위반 ID -->
, V.VLTN_CD <!-- 위반 코드 -->
, V.VLTN_ARTCL <!-- 위반 항목 -->
, P.RTPYR_ID <!-- 납부자 ID -->
, 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 <!-- 납부자 명 -->
, PA.ADDR_SN <!-- 주소 일련번호 -->
, PA.ZIP <!-- 우편번호 -->
, PA.ADDR <!-- 주소 -->
, PA.DTL_ADDR <!-- 상세 주소 -->
, CC.CVLCPT_LINK_ID <!-- 민원 연계 ID -->
, CC.CVLCPT_RCPT_YMD <!-- 민원 접수 일자 -->
, CC.CVLCPT_APLY_NO <!-- 민원 신청 번호 -->
, CC.CVLCPT_RCPT_NO <!-- 민원 접수 번호 -->
, CC.CVLCPT_PRCS_CD <!-- 민원 처리 코드 -->
, (SELECT GET_CODE_NM('FIM017', CC.CVLCPT_PRCS_CD) FROM DUAL) AS CVLCPT_PRCS_NM <!-- 민원 처리 명 -->
FROM TB_LEVY_EXCL LE
INNER JOIN TB_CRDN C ON (LE.CRDN_ID = C.CRDN_ID)
INNER JOIN TB_CRDN_ADI CA ON (C.CRDN_ID = CA.CRDN_ID)
LEFT OUTER JOIN TB_VLTN V ON (C.VLTN_ID = V.VLTN_ID)
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)
LEFT OUTER JOIN TB_CRDN_CVLCPT CC ON (C.LINK_ID = CC.CVLCPT_LINK_ID AND C.CVLCPT_LINK_YN = 'Y' AND CC.DEL_YN = 'N')
</sql>
<select id="selectLevyExclList" parameterType="map" resultType="dataobject">/* 부과제외 대장 목록 조회(levyExclMapper.selectLevyExclList) */
<include refid="utility.paging-prefix" />
<include refid="selectList" />
<where>
<if test="schLevyExclYmdFrom != null">
AND LE.LEVY_EXCL_YMD <![CDATA[>=]]> #{schLevyExclYmdFrom} <!-- 부과제외 일자 시작 -->
</if>
<if test="schLevyExclYmdTo != null">
AND LE.LEVY_EXCL_YMD <![CDATA[<=]]> #{schLevyExclYmdTo} <!-- 부과제외 일자 종료 -->
</if>
<if test="schLevyExclSeCd != null">
AND LE.LEVY_EXCL_SE_CD = #{schLevyExclSeCd} <!-- 부과 제외 구분 코드 -->
</if>
<if test="schLevyExclRsnCd != null">
AND LE.LEVY_EXCL_RSN_CD = #{schLevyExclRsnCd} <!-- 부과 제외 사유 코드 -->
</if>
<if test="delYn != null">
AND LE.DEL_YN = #{delYn} <!-- 삭제 여부 -->
</if>
<if test="schCrdnYmdFrom != null">
AND C.CRDN_YMD <![CDATA[>=]]> #{schCrdnYmdFrom} <!-- 단속 일자 시작 -->
</if>
<if test="schCrdnYmdTo != null">
AND C.CRDN_YMD <![CDATA[<=]]> #{schCrdnYmdTo} <!-- 단속 일자 종료 -->
</if>
<if test="schVhrno != null">
AND C.VHRNO = #{schVhrno} <!-- 차량번호 -->
</if>
<if test="schRtpyrNo != null">
AND P.RTPYR_NO = #{schRtpyrNo} <!-- 납부자 번호 -->
</if>
<if test="rtpyrNo != null">
AND P.RTPYR_NO = #{rtpyrNo} <!-- 납부자 번호 -->
</if>
<if test="schRtpyrNm != null">
AND P.RTPYR_NM = #{schRtpyrNm} <!-- 납부자 명 -->
</if>
<if test="sggCd != null">
AND C.SGG_CD = #{sggCd} <!-- 시군구 코드 -->
</if>
<if test="taskSeCd != null">
AND C.TASK_SE_CD = #{taskSeCd} <!-- 업무 구분 코드 -->
</if>
AND C.DEL_YN = 'N' <!-- 단속 삭제 여부 -->
<choose>
<when test="schRegDateOpt == 'regDt'">
<if test="schRegDateFrom != null">
AND LE.REG_DT <![CDATA[>=]]> CONCAT(#{schRegDateFrom},'000000') <!-- 등록 일자 시작 -->
</if>
<if test="schRegDateTo != null">
AND LE.REG_DT <![CDATA[<=]]> CONCAT(#{schRegDateTo},'235959') <!-- 등록 일자 종료 -->
</if>
</when>
<when test="schRegDateOpt == 'mdfcnDt'">
<if test="schRegDateFrom != null">
AND LE.MDFCN_DT <![CDATA[>=]]> CONCAT(#{schRegDateFrom},'000000') <!-- 수정 일자 시작 -->
</if>
<if test="schRegDateTo != null">
AND LE.MDFCN_DT <![CDATA[<=]]> CONCAT(#{schRegDateTo},'235959') <!-- 수정 일자 종료 -->
</if>
</when>
<otherwise>
</otherwise>
</choose>
<choose>
<when test="schRgtrOpt == 'rgtr'">
<if test="schRgtrCd != null">
AND LE.RGTR = #{schRgtrCd} <!-- 등록자 코드 -->
</if>
</when>
<when test="schRgtrOpt == 'mdfr'">
<if test="schRgtrCd != null">
AND LE.MDFR = #{schRgtrCd} <!-- 수정자 코드 -->
</if>
</when>
<otherwise>
</otherwise>
</choose>
<if test="@org.egovframe.rte.fdl.string.EgovStringUtil@isNotEmpty(by) and @org.egovframe.rte.fdl.string.EgovStringUtil@isNotEmpty(term)">
<choose>
<when test="mainOption == 'codeValue' or mainOption == 'match' or mainOption == 'ymd'">
<include refid="dynamicSearch.start" />
<choose>
<when test="by == 'levyExclYmd'"> LE.LEVY_EXCL_YMD </when>
<when test="by == 'levyExclSeCd'"> LE.LEVY_EXCL_SE_CD </when>
<when test="by == 'levyExclRsnCd'"> LE.LEVY_EXCL_RSN_CD </when>
<when test="by == 'etcCn'"> LE.ETC_CN </when>
<when test="by == 'crdnYmd'"> C.CRDN_YMD </when>
<when test="by == 'vhrno'"> C.VHRNO </when>
<when test="by == 'crdnStdgNm'"> C.CRDN_STDG_NM </when>
<when test="by == 'crdnPlc'"> C.CRDN_PLC </when>
<when test="by == 'ffnlgCrdnAmt'"> C.FFNLG_CRDN_AMT </when>
<when test="by == 'ffnlgAmt'"> C.FFNLG_AMT </when>
<when test="by == 'advntceAmt'"> C.ADVNTCE_AMT </when>
<when test="by == 'crdnSttsCd'"> C.CRDN_STTS_CD </when>
<when test="by == 'rtpyrSeCd'"> P.RTPYR_SE_CD </when>
<when test="by == 'rtpyrNo'"> P.RTPYR_NO </when>
<when test="by == 'rtpyrNm'"> P.RTPYR_NM </when>
<when test="by == 'zip'"> PA.ZIP </when>
<when test="by == 'addr'"> PA.ADDR </when>
<when test="by == 'dtlAddr'"> PA.DTL_ADDR </when>
<when test="by == 'vltnArtcl'"> V.VLTN_ARTCL </when>
<when test="by == 'cvlcptRcptYmd'"> CC.CVLCPT_RCPT_YMD </when>
<when test="by == 'cvlcptAplyNo'"> CC.CVLCPT_APLY_NO </when>
<when test="by == 'cvlcptRcptNo'"> CC.CVLCPT_RCPT_NO </when>
<when test="by == 'cvlcptPrcsCd'"> CC.CVLCPT_PRCS_CD </when>
<when test="by == 'cvlcptPrcsCmptnDt'"> CC.CVLCPT_PRCS_CMPTN_DT </when>
</choose>
<include refid="dynamicSearch.center" />#{term}<include refid="dynamicSearch.end" />
</when>
<otherwise>
</otherwise>
</choose>
</if>
</where>
<include refid="utility.orderBy" />
<include refid="utility.paging-suffix" />
</select>
<sql id="select">
SELECT C.CRDN_ID <!-- 단속 ID -->
, C.SGG_CD <!-- 시군구 코드 -->
, C.TASK_SE_CD <!-- 업무 구분 코드 -->
, (CONCAT(C.CRDN_YMD, C.CRDN_TM)) AS CRDN_YMD_TM <!-- 단속 일시 -->
, C.VHRNO <!-- 차량번호 -->
, C.CRDN_STDG_NM <!-- 단속 법정동 명 -->
, C.CRDN_PLC <!-- 단속 장소 -->
, C.CRDN_STTS_CD <!-- 단속 상태 코드 -->
, (SELECT GET_CODE_NM('FIM010', C.CRDN_STTS_CD) FROM DUAL) AS CRDN_STTS_NM <!-- 단속 상태 명 -->
, CA.PRK_PSBLTY_RSLT_CD <!-- 주차 가능 결과 코드 -->
, CC.CVLCPT_LINK_ID <!-- 민원 연계 ID -->
, CC.CVLCPT_PRCS_CD <!-- 민원 처리 코드 -->
, L.LEVY_ID <!-- 부과 ID -->
, LE.LEVY_EXCL_ID <!-- 부과제외 ID -->
, LE.LEVY_EXCL_YMD <!-- 부과제외 일자 -->
, LE.LEVY_EXCL_SE_CD <!-- 부과제외 구분 코드 -->
, (SELECT GET_CODE_NM('FIM021', LE.LEVY_EXCL_SE_CD) FROM DUAL) AS LEVY_EXCL_SE_NM <!-- 부과 제외 구분 명 -->
, LE.LEVY_EXCL_RSN_CD <!-- 부과제외 사유 코드 -->
, (SELECT GET_CODE_NM('FIM022', LE.LEVY_EXCL_RSN_CD) FROM DUAL) AS LEVY_EXCL_RSN_NM <!-- 부과 제외 사유 명 -->
, LE.ETC_CN <!-- 기타 내용 -->
, LE.REG_DT <!-- 등록 일시 -->
, (SELECT USER_NM FROM TB_USER X WHERE X.USER_ID = LE.RGTR) AS RGTR_NM <!-- 등록자 명 -->
, LE.MDFCN_DT <!-- 수정 일시 -->
, (SELECT USER_NM FROM TB_USER X WHERE X.USER_ID = LE.MDFR) AS MDFR_NM <!-- 수정자 명 -->
FROM TB_CRDN C
INNER JOIN TB_CRDN_ADI CA ON (C.CRDN_ID = CA.CRDN_ID)
LEFT OUTER JOIN TB_CRDN_CVLCPT CC ON (C.LINK_ID = CC.CVLCPT_LINK_ID AND C.CVLCPT_LINK_YN = 'Y' AND CC.DEL_YN = 'N')
LEFT OUTER JOIN TB_LEVY L ON (C.CRDN_ID = L.CRDN_ID AND L.DEL_YN = 'N')
LEFT OUTER JOIN TB_LEVY_EXCL LE ON (C.CRDN_ID = LE.CRDN_ID AND LE.DEL_YN = 'N')
</sql>
<select id="selectLevyExcls" parameterType="map" resultType="dataobject">/* 부과제외 대장 객체 가져오기(levyExclMapper.selectLevyExcls) */
<include refid="select" />
<where>
<if test="levyExclIds != null">
AND LE.LEVY_EXCL_ID IN ( <!-- 부과 제외 Ids -->
<foreach collection="levyExclIds" item="levyExclId" separator=","> #{levyExclId} </foreach>
)
</if>
<if test="levyExclId != null">
AND LE.LEVY_EXCL_ID = #{levyExclId} <!-- 부과 제외 ID -->
</if>
<if test="crdnId != null">
AND C.CRDN_ID = #{crdnId} <!-- 단속 ID -->
AND C.DEL_YN = 'N' <!-- 단속 삭제 여부 -->
</if>
</where>
<include refid="utility.orderBy" />
</select>
<insert id="insertLevyExcl" parameterType="cokr.xit.fims.excl.LevyExcl">/* 부과제외 대장 등록(levyExclMapper.insertLevyExcl) */
<selectKey resultType="string" keyProperty="levyExclId" keyColumn="NEW_ID" order="BEFORE">
<include refid="numbering.keyBySggAndYear">
<property name="TABLE_NAME" value="TB_LEVY_EXCL" />
<property name="TABLE_KEY" value="LEVY_EXCL_ID" />
<property name="sggCd" value="#{sggCd}" />
<property name="pad" value="20" />
</include>
</selectKey>
INSERT
INTO TB_LEVY_EXCL (
LEVY_EXCL_ID <!-- 부과 제외 ID -->
, CRDN_ID <!-- 단속 ID -->
, LEVY_EXCL_YMD <!-- 부과 제외 일자 -->
, LEVY_EXCL_SE_CD <!-- 부과 제외 구분 코드 -->
, LEVY_EXCL_RSN_CD <!-- 부과 제외 사유 코드 -->
, ETC_CN <!-- 기타 내용 -->
, DEL_YN <!-- 삭제 여부 -->
, REG_DT <!-- 등록 일시 -->
, RGTR <!-- 등록자 -->
, MDFCN_DT <!-- 수정 일시 -->
, MDFR <!-- 수정자 -->
)
VALUES (
#{levyExclId} <!-- 부과 제외 ID -->
, #{crdnId} <!-- 단속 ID -->
, #{levyExclYmd} <!-- 부과 제외 일자 -->
, #{levyExclSeCd} <!-- 부과 제외 구분 코드 -->
, #{levyExclRsnCd} <!-- 부과 제외 사유 코드 -->
, #{etcCn} <!-- 기타 내용 -->
, 'N' <!-- 삭제 여부 -->
, <include refid="utility.now" /> <!-- 등록 일시 -->
, #{createdBy} <!-- 등록자 -->
, <include refid="utility.now" /> <!-- 수정 일시 -->
, #{modifiedBy} <!-- 수정자 -->
)
</insert>
<update id="updateLevyExcl" parameterType="cokr.xit.fims.excl.LevyExcl">/* 부과제외 대장 수정(levyExclMapper.updateLevyExcl) */
UPDATE TB_LEVY_EXCL
SET LEVY_EXCL_YMD = #{levyExclYmd} <!-- 부과 제외 일자 -->
, LEVY_EXCL_RSN_CD = #{levyExclRsnCd} <!-- 부과 제외 사유 코드 -->
, ETC_CN = #{etcCn} <!-- 기타 내용 -->
, MDFCN_DT = <include refid="utility.now" /> <!-- 수정 일시 -->
, MDFR = #{modifiedBy} <!-- 수정자 -->
WHERE LEVY_EXCL_ID = #{levyExclId} <!-- 부과 제외 ID -->
AND DEL_YN = 'N'
</update>
<update id="deleteLevyExcl" parameterType="cokr.xit.fims.excl.LevyExcl">/* 부과제외 대장 삭제(levyExclMapper.deleteLevyExcl) */
UPDATE TB_LEVY_EXCL
SET DEL_YN = 'Y'
, DEL_DT = <include refid="utility.now" /> <!-- 삭제 일시 -->
, DLTR = #{modifiedBy} <!-- 삭제자 -->
, DEL_RSN = #{delRsn} <!-- 삭제 사유 -->
WHERE LEVY_EXCL_ID = #{levyExclId} <!-- 부과 제외 ID -->
AND DEL_YN = 'N'
</update>
<update id="updatePrkPsbltyRsltCd" parameterType="cokr.xit.fims.crdn.Crdn">/* 단속 대장 주차가능결과코드를 수정(levyExclMapper.updatePrkPsbltyRsltCd) */
UPDATE TB_CRDN_ADI
SET PRK_PSBLTY_RSLT_CD = #{prkPsbltyRsltCd} <!-- 주차 가능 결과 코드 -->
, MDFCN_DT = <include refid="utility.now" /> <!-- 수정 일시 -->
, MDFR = #{modifiedBy} <!-- 수정자 -->
WHERE CRDN_ID = #{crdnId} <!-- 단속 ID -->
AND DEL_YN = 'N'
</update>
</mapper>

1055
src/main/resources/sql/mapper/fims/levy/levy-mapper.xml
View File

File diff suppressed because it is too large Load Diff

176
src/main/resources/sql/mapper/fims/rdca/rdcamt-mapper.xml
Unescape Escape View File

@ -0,0 +1,176 @@
<?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.rdca.dao.RdamtMapper">
<!-- 감액 대장 정보 매퍼
========== 변경 이력 ==========
2024-02-01 JoJH 최초 작성
============================ -->
<resultMap id="rdamtRow" type="cokr.xit.fims.rdca.Rdamt"> <!-- 감액 대장 -->
<result property="rdamtId" column="RDAMT_ID" /> <!-- 감액 ID -->
<result property="levyId" column="LEVY_ID" /> <!-- 부과 ID -->
<result property="lastPcptax" column="LAST_PCPTAX" /> <!-- 최종 본세 -->
<result property="lastAdamt" column="LAST_ADAMT" /> <!-- 최종 가산금 -->
<result property="rdamtYmd" column="RDAMT_YMD" /> <!-- 감액 일자 -->
<result property="rdamtSeCd" column="RDAMT_SE_CD" /> <!-- 감액 구분 코드 -->
<result property="rdamtRsnCd" column="RDAMT_RSN_CD" /> <!-- 감액 사유 코드 -->
<result property="rdamtPcptax" column="RDAMT_PCPTAX" /> <!-- 감액 본세 -->
<result property="rdamtAdamt" column="RDAMT_ADAMT" /> <!-- 감액 가산금 -->
<result property="rdamtRtrcnYn" column="RDAMT_RTRCN_YN" /> <!-- 감액 취소 여부 -->
<result property="rdamtRtrcnYmd" column="RDAMT_RTRCN_YMD" /> <!-- 감액 취소 일자 -->
<result property="rdamtRtrcnRsn" column="RDAMT_RTRCN_RSN" /> <!-- 감액 취소 사유 -->
<result property="delYn" column="DEL_YN" /> <!-- 삭제 여부 -->
<result property="createdAt" column="REG_DT" /> <!-- 등록 일시 -->
<result property="createdBy" column="RGTR" /> <!-- 등록자 -->
<result property="lastModified" column="MDFCN_DT" /> <!-- 수정 일시 -->
<result property="modifiedBy" column="MDFR" /> <!-- 수정자 -->
<result property="removedAt" column="DEL_DT" /> <!-- 삭제 일시 -->
<result property="removedBy" column="DLTR" /> <!-- 삭제자 -->
<result property="delRsn" column="DEL_RSN" /> <!-- 삭제 사유 -->
</resultMap>
<sql id="selectList">
SELECT R.RDAMT_ID <!-- 감액 ID -->
, R.LEVY_ID <!-- 부과 ID -->
, R.LAST_PCPTAX <!-- 최종 본세 -->
, R.LAST_ADAMT <!-- 최종 가산금 -->
, R.RDAMT_YMD <!-- 감액 일자 -->
, R.RDAMT_SE_CD <!-- 감액 구분 코드 -->
, R.RDAMT_RSN_CD <!-- 감액 사유 코드 -->
, R.RDAMT_PCPTAX <!-- 감액 본세 -->
, R.RDAMT_ADAMT <!-- 감액 가산금 -->
, R.RDAMT_RTRCN_YN <!-- 감액 취소 여부 -->
, R.RDAMT_RTRCN_YMD <!-- 감액 취소 일자 -->
, R.RDAMT_RTRCN_RSN <!-- 감액 취소 사유 -->
, R.DEL_YN <!-- 삭제 여부 -->
, R.REG_DT <!-- 등록 일시 -->
, R.RGTR <!-- 등록자 -->
, R.MDFCN_DT <!-- 수정 일시 -->
, R.MDFR <!-- 수정자 -->
, R.DEL_DT <!-- 삭제 일시 -->
, R.DLTR <!-- 삭제자 -->
, (SELECT USER_NM FROM TB_USER X WHERE X.USER_ID = L.RGTR) AS RGTR_NM <!-- 등록자 명 -->
, (SELECT USER_NM FROM TB_USER X WHERE X.USER_ID = L.MDFR) AS MDFR_NM <!-- 수정자 명 -->
, (SELECT USER_NM FROM TB_USER X WHERE X.USER_ID = L.DLTR) AS DLTR_NM <!-- 삭제자 명 -->
FROM TB_RDAMT R
INNER JOIN TB_LEVY L ON (R.LEVY_ID = L.LEVY_ID)
</sql>
<sql id="select">
SELECT R.RDAMT_ID <!-- 감액 ID -->
, R.LEVY_ID <!-- 부과 ID -->
, R.LAST_PCPTAX <!-- 최종 본세 -->
, R.LAST_ADAMT <!-- 최종 가산금 -->
, R.RDAMT_YMD <!-- 감액 일자 -->
, R.RDAMT_SE_CD <!-- 감액 구분 코드 -->
, R.RDAMT_RSN_CD <!-- 감액 사유 코드 -->
, R.RDAMT_PCPTAX <!-- 감액 본세 -->
, R.RDAMT_ADAMT <!-- 감액 가산금 -->
, R.RDAMT_RTRCN_YN <!-- 감액 취소 여부 -->
, R.RDAMT_RTRCN_YMD <!-- 감액 취소 일자 -->
, R.RDAMT_RTRCN_RSN <!-- 감액 취소 사유 -->
, R.DEL_YN <!-- 삭제 여부 -->
, R.REG_DT <!-- 등록 일시 -->
, R.RGTR <!-- 등록자 -->
, R.MDFCN_DT <!-- 수정 일시 -->
, R.MDFR <!-- 수정자 -->
, R.DEL_DT <!-- 삭제 일시 -->
, R.DLTR <!-- 삭제자 -->
, R.DEL_RSN <!-- 삭제 사유 -->
, (SELECT USER_NM FROM TB_USER X WHERE X.USER_ID = L.RGTR) AS RGTR_NM <!-- 등록자 명 -->
, (SELECT USER_NM FROM TB_USER X WHERE X.USER_ID = L.MDFR) AS MDFR_NM <!-- 수정자 명 -->
, (SELECT USER_NM FROM TB_USER X WHERE X.USER_ID = L.DLTR) AS DLTR_NM <!-- 삭제자 명 -->
FROM TB_RDAMT
</sql>
<select id="selectRdamtList" parameterType="map" resultType="dataobject">/* 감액 대장 목록 조회(rdcamtMapper.selectRdamtList) */
<include refid="utility.paging-prefix" />
<include refid="selectList" />
<where></where>
<include refid="utility.orderBy" />
<include refid="utility.paging-suffix" />
</select>
<select id="selectRdamts" parameterType="map" resultType="dataobject">/* 감액 대장 객체 가져오기(rdcamtMapper.selectRdamts) */
<include refid="select" />
<where></where>
<include refid="utility.orderBy" />
</select>
<insert id="insertRdamt" parameterType="map">/* 감액 대장 등록(rdcamtMapper.insertRdamt) */
<selectKey resultType="string" keyProperty="rdamt.rdamtId" keyColumn="NEW_ID" order="BEFORE">
SELECT CONCAT(#{rdamt.sggCd}, DATE_FORMAT(CURRENT_DATE, '%Y'), LPAD(CAST(IFNULL(MAX(SUBSTRING(RDAMT_ID, 10)) + 1, 1) AS INT), 11, '0')) AS NEW_ID
FROM TB_RDAMT
WHERE RDAMT_ID LIKE CONCAT(#{rdamt.sggCd}, DATE_FORMAT(CURRENT_DATE, '%Y'), '%')
</selectKey>
INSERT
INTO TB_RDAMT (
RDAMT_ID <!-- 감액 ID -->
, LEVY_ID <!-- 부과 ID -->
, LAST_PCPTAX <!-- 최종 본세 -->
, LAST_ADAMT <!-- 최종 가산금 -->
, RDAMT_YMD <!-- 감액 일자 -->
, RDAMT_SE_CD <!-- 감액 구분 코드 -->
, RDAMT_RSN_CD <!-- 감액 사유 코드 -->
, RDAMT_PCPTAX <!-- 감액 본세 -->
, RDAMT_ADAMT <!-- 감액 가산금 -->
, RDAMT_RTRCN_YN <!-- 감액 취소 여부 -->
, RDAMT_RTRCN_YMD <!-- 감액 취소 일자 -->
, RDAMT_RTRCN_RSN <!-- 감액 취소 사유 -->
, DEL_YN <!-- 삭제 여부 -->
, REG_DT <!-- 등록 일시 -->
, RGTR <!-- 등록자 -->
, MDFCN_DT <!-- 수정 일시 -->
, MDFR <!-- 수정자 -->
)
VALUES (
#{rdamt.rdamtId} <!-- 감액 ID -->
, #{rdamt.levyId} <!-- 부과 ID -->
, #{rdamt.lastPcptax} <!-- 최종 본세 -->
, #{rdamt.lastAdamt} <!-- 최종 가산금 -->
, #{rdamt.rdamtYmd} <!-- 감액 일자 -->
, #{rdamt.rdamtSeCd} <!-- 감액 구분 코드 -->
, #{rdamt.rdamtRsnCd} <!-- 감액 사유 코드 -->
, #{rdamt.rdamtPcptax} <!-- 감액 본세 -->
, #{rdamt.rdamtAdamt} <!-- 감액 가산금 -->
, 'N' <!-- 감액 취소 여부 -->
, #{rdamt.rdamtRtrcnYmd} <!-- 감액 취소 일자 -->
, #{rdamt.rdamtRtrcnRsn} <!-- 감액 취소 사유 -->
, 'N' <!-- 삭제 여부 -->
, <include refid="utility.now" /> <!-- 등록 일시 -->
, #{rdamt.createdBy} <!-- 등록자 -->
, <include refid="utility.now" /> <!-- 수정 일시 -->
, #{rdamt.modifiedBy} <!-- 수정자 -->
)
</insert>
<update id="updateRdamt" parameterType="map">/* 감액 대장 수정(rdamtMapper.updateRdamt) */
UPDATE TB_RDAMT
SET LAST_PCPTAX = #{rdamt.lastPcptax} <!-- 최종 본세 -->
, LAST_ADAMT = #{rdamt.lastAdamt} <!-- 최종 가산금 -->
, RDAMT_YMD = #{rdamt.rdamtYmd} <!-- 감액 일자 -->
, RDAMT_SE_CD = #{rdamt.rdamtSeCd} <!-- 감액 구분 코드 -->
, RDAMT_RSN_CD = #{rdamt.rdamtRsnCd} <!-- 감액 사유 코드 -->
, RDAMT_PCPTAX = #{rdamt.rdamtPcptax} <!-- 감액 본세 -->
, RDAMT_ADAMT = #{rdamt.rdamtAdamt} <!-- 감액 가산금 -->
, RDAMT_RTRCN_YN = #{rdamt.rdamtRtrcnYn} <!-- 감액 취소 여부 -->
, RDAMT_RTRCN_YMD = #{rdamt.rdamtRtrcnYmd} <!-- 감액 취소 일자 -->
, RDAMT_RTRCN_RSN = #{rdamt.rdamtRtrcnRsn} <!-- 감액 취소 사유 -->
, MDFCN_DT = <include refid="utility.now" /> <!-- 수정 일시 -->
, MDFR = #{rdamt.modifiedBy} <!-- 수정자 -->
WHERE RDAMT_ID = #{rdamt.rdamtId} <!-- 감액 ID -->
AND DEL_YN = 'N' <!-- 삭제 여부 -->
</update>
<update id="deleteRdamt" parameterType="map">/* 감액 대장 삭제(rdamtMapper.deleteRdamt) */
UPDATE TB_RDAMT
SET DEL_YN = 'Y'
, DEL_DT = <include refid="utility.now" /> <!-- 삭제 일시 -->
, DLTR = #{rdamt.modifiedBy} <!-- 삭제자 -->
, DEL_RSN = #{rdamt.delRsn} <!-- 삭제 사유 -->
WHERE RDAMT_ID = #{rdamt.rdamtId} <!-- 감액 ID -->
AND DEL_YN = 'N'
</update>
</mapper>
Write Preview
Loading…
Cancel
Save