first commit

This commit is contained in:
2026-01-09 14:13:05 +09:00
commit 9fd3911db8
79 changed files with 6568 additions and 0 deletions

View File

@@ -0,0 +1,251 @@
package com.kri.notihub.server.service;
import com.kri.notihub.server.common.consts.NotihubConst;
import com.kri.notihub.server.common.enums.SendType;
import com.kri.notihub.server.dto.send.EmailPollQueueItemDto;
import com.kri.notihub.server.dto.send.EmailPollQueueResponseDto;
import com.kri.notihub.server.persistence.entity.TSendEntity;
import com.kri.notihub.server.persistence.repository.SendRepository;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.event.EventListener;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.domain.Pageable;
import org.springframework.boot.context.event.ApplicationReadyEvent;
import org.springframework.stereotype.Component;
import jakarta.annotation.PostConstruct;
import jakarta.annotation.PreDestroy;
import java.time.LocalDateTime;
import java.util.Comparator;
import java.util.List;
import java.util.Objects;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.DelayQueue;
import java.util.concurrent.Delayed;
import java.util.concurrent.TimeUnit;
/**
* Pringo는 발송요청/결과조회가 "1건씩"만 가능하므로, 동기(요청 스레드)에서 json_return을
* 반복 호출하지 않고 Poller에서 비동기로 1회만 조회해 DB를 갱신한다.
*
* - 단건/벌크 공통: 발송요청 성공(return_key 수신) -> Poller enqueue -> (지연 후) json_return 1회 조회
* - 서비스 재기동 시: STANDBY_EMAIL + RESULT_CODE_PENDING 인 레코드를 DB에서 스캔하여 재등록
*
* 운영 정책(딜레이/재시도 횟수)은 설정으로 조정 가능(기본: 재시도 0회).
*/
@Slf4j
@Component
@RequiredArgsConstructor
public class EmailResultPoller {
private final DelayQueue<PollTask> queue = new DelayQueue<>();
private final EmailResultUpdater emailResultUpdater;
private final SendRepository sendRepository;
/** 런타임 중 중복 enqueue 방지(같은 returnKey를 여러 번 등록하지 않기 위함) */
private final Set<String> scheduledKeys = ConcurrentHashMap.newKeySet();
private volatile boolean running = true;
private Thread worker;
/**
* 운영 권장값은 '최종 상태가 나올 가능성이 높은 지연'이다.
* 즉시성보다 '1회 조회로 최종 상태 반영'을 우선하면 60~180초 수준이 실무적으로 안정적이다.
*/
@Value("${kri.email.result-poll.initial-delay-ms:60000}")
private long initialDelayMs;
/**
* 사용자는 json_return을 여러 번 호출하지 않을 예정이라고 했으므로 기본은 0(재시도 없음).
* 필요 시 설정으로 1~2 정도만 허용하는 것을 권장.
*/
@Value("${kri.email.result-poll.max-attempts:0}")
private int maxAttempts;
@Value("${kri.email.result-poll.max-delay-ms:1800000}")
private long maxDelayMs;
@Value("${kri.email.result-poll.recover-days:3}")
private int recoverDays;
@Value("${kri.email.result-poll.recover-page-size:1000}")
private int recoverPageSize;
public void enqueue(String returnKey) {
if (returnKey == null || returnKey.isBlank()) return;
enqueueInternal(returnKey.trim(), initialDelayMs, 0);
}
public EmailPollQueueResponseDto snapshotQueue() {
final long nowNanos = System.nanoTime(); // queue 내부 기준(상대시간)
final long nowEpochMs = System.currentTimeMillis(); // 출력용 기준(절대시간)
List<EmailPollQueueItemDto> items = queue.stream()
.filter(Objects::nonNull)
.map(t -> {
long remainingNanos = t.triggerAtNanos - nowNanos;
long remainingMs = Math.max(0L, TimeUnit.NANOSECONDS.toMillis(remainingNanos));
// nanoTime은 epoch로 직접 변환 불가 → "현재 epoch + remainingMs"로 예상 시각 구성
long triggerAtEpochMs = nowEpochMs + remainingMs;
return EmailPollQueueItemDto.of(
t.returnKey,
t.attempt,
remainingMs,
triggerAtEpochMs
);
})
.sorted(Comparator.comparingLong(i ->
i.getRemainingMs() != null ? i.getRemainingMs() : Long.MAX_VALUE
))
.toList();
return EmailPollQueueResponseDto.of(items);
}
/**
* 서비스 재기동 시 유실된 PollTask를 복구한다.
* - DB(t_send)에 STANDBY_EMAIL로 남아 있는 Pringo 이메일 중, cmid가 return_key(숫자)인 레코드를 재등록
* - in-memory 큐를 신뢰하지 않고, DB를 단일 소스 오브 트루스로 본다
*/
@EventListener(ApplicationReadyEvent.class)
public void recoverFromDbOnStartup() {
try {
LocalDateTime from = LocalDateTime.now().minusDays(Math.max(1, recoverDays));
int page = 0;
Pageable pageable = PageRequest.of(page, Math.max(100, recoverPageSize));
while (true) {
Page<TSendEntity> p = sendRepository.findBySendTyAndResultCodeAndSendDtAfterOrderBySendDtAsc(
SendType.EMAIL.getCode(),
NotihubConst.EMAIL_PENDING, // ★ STANDBY_EMAIL(100) 같은 값이 아니라 PENDING(111)을 복구 대상으로
from,
pageable
);
if (!p.hasContent()) break;
for (TSendEntity e : p.getContent()) {
if (isNumeric(e.getCmid())) {
// 재기동 복구는 '가능한 빨리' 한 번 조회하도록 짧은 딜레이로 등록
enqueueInternal(e.getCmid(), 1000L, 0);
}
}
if (!p.hasNext()) break;
pageable = p.nextPageable();
}
} catch (Exception ex) {
// 복구 실패가 서비스 기동을 막지 않도록
log.warn("EmailResultPoller recovery skipped due to error", ex);
}
}
@PostConstruct
public void start() {
worker = new Thread(() -> {
while (running) {
try {
if(queue.isEmpty()){
Thread.sleep(5000);
continue;
}
PollTask task = queue.take();
scheduledKeys.remove(task.returnKey);
boolean done = emailResultUpdater.tryUpdateEmailResult(task.returnKey);
if (!done && task.attempt < maxAttempts) {
long nextDelay = Math.min((long) (initialDelayMs * Math.pow(2, task.attempt + 1)), maxDelayMs);
enqueueInternal(task.returnKey, nextDelay, task.attempt + 1);
} else if (!done) {
// 더 이상 재시도하지 않는 경우: 재기동 복구/중복 조회를 막기 위해 '조회 실패'로 마킹
markQueryFailIfPending(task.returnKey);
}
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
} catch (Exception e) {
// Poller 자체는 죽지 않도록 방어
log.debug("EmailResultPoller worker error", e);
}
}
}, "email-result-poller");
worker.setDaemon(true);
worker.start();
}
@PreDestroy
public void stop() {
running = false;
if (worker != null) worker.interrupt();
}
private void enqueueInternal(String returnKey, long delayMs, int attempt) {
if (!scheduledKeys.add(returnKey)) return;
queue.offer(new PollTask(returnKey, attempt, delayMs));
}
private boolean isNumeric(String s) {
if (s == null || s.isBlank()) return false;
for (int i = 0; i < s.length(); i++) {
char c = s.charAt(i);
if (c < '0' || c > '9') return false;
}
return true;
}
private void markQueryFailIfPending(String returnKey) {
try {
sendRepository.findByCmid(returnKey).ifPresent(e -> {
if (e.getResultCode() != null && e.getResultCode() == NotihubConst.EMAIL_PENDING) {
e.setResultCode(NotihubConst.EMAIL_NOT_RESULT);
sendRepository.save(e);
}
});
} catch (Exception ex) {
log.debug("markQueryFailIfPending ignored. returnKey={}...", returnKey, ex);
}
}
static final class PollTask implements Delayed {
final String returnKey;
final int attempt;
final long triggerAtNanos;
PollTask(String returnKey, int attempt, long delayMs) {
this.returnKey = returnKey;
this.attempt = attempt;
long delayNanos = TimeUnit.MILLISECONDS.toNanos(Math.max(0, delayMs));
this.triggerAtNanos = System.nanoTime() + delayNanos;
}
@Override
public long getDelay(TimeUnit unit) {
long diffNanos = triggerAtNanos - System.nanoTime();
return unit.convert(diffNanos, TimeUnit.NANOSECONDS);
}
@Override
public int compareTo(Delayed o) {
if (o == this) return 0;
PollTask other = (PollTask) o;
return Long.compare(this.triggerAtNanos, other.triggerAtNanos);
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (!(o instanceof PollTask)) return false;
PollTask pollTask = (PollTask) o;
return attempt == pollTask.attempt && Objects.equals(returnKey, pollTask.returnKey) && triggerAtNanos == pollTask.triggerAtNanos;
}
@Override
public int hashCode() {
return Objects.hash(returnKey, attempt, triggerAtNanos);
}
}
}

View File

@@ -0,0 +1,89 @@
package com.kri.notihub.server.service;
import com.kri.common.datetime.DateTimeUtil;
import com.kri.common.util.CommonUtil;
import com.kri.notihub.server.common.consts.NotihubConst;
import com.kri.notihub.server.common.enums.SendStatusType;
import com.kri.notihub.server.common.external.pringo.PringoApiClient;
import com.kri.notihub.server.common.external.pringo.dto.PringoJsonReturnItemDto;
import com.kri.notihub.server.common.external.pringo.dto.PringoJsonReturnResponseDto;
import com.kri.notihub.server.persistence.entity.TSendEntity;
import com.kri.notihub.server.persistence.repository.BulkSendRepository;
import com.kri.notihub.server.persistence.repository.SendRepository;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;
import java.time.LocalDateTime;
import java.util.Optional;
@Slf4j
@Component
@RequiredArgsConstructor
class EmailResultUpdater {
private final PringoApiClient pringoApiClient;
private final SendRepository sendRepository;
private final BulkSendRepository bulkSendRepository;
/**
* Pringo 결과 조회 후 t_send 갱신
* @return true: 결과 조회 성공 및 갱신 완료, false: 아직 결과 없음/조회 실패
*/
public boolean tryUpdateEmailResult(String returnKey) {
Optional<TSendEntity> opt = sendRepository.findByCmid(returnKey);
if (opt.isEmpty()) return false;
LocalDateTime now = LocalDateTime.now();
TSendEntity e = opt.get();
try {
PringoJsonReturnResponseDto resp = pringoApiClient.jsonReturn(Long.valueOf(returnKey));
if (resp == null || !resp.isSuccess() || resp.getItemList() == null || resp.getItemList().isEmpty()) {
e.setResultCode(NotihubConst.EMAIL_NOT_RESULT);
e.setReportDt(now);
sendRepository.save(e);
return true;
}
PringoJsonReturnItemDto item = resp.getItemList().get(0);
if (item == null || item.getStatus() == null || item.getStatus().isBlank()) {
e.setResultCode(NotihubConst.EMAIL_NOT_RESULT);
e.setReportDt(now);
sendRepository.save(e);
return true;
}
short resultCode = CommonUtil.safeParseShort(item.getStatus(), NotihubConst.EMAIL_NOT_RESULT);
//resultCode를 대상으로 Success인지 아닌지 판별 필요
SendStatusType sendStatus = resultCode == NotihubConst.EMAIL_SUCCESS? SendStatusType.SUCCESS : SendStatusType.FAIL;
e.setSendStatus(sendStatus.getCode());
e.setResultCode(resultCode);
e.setReportDt(DateTimeUtil.parseLocalDateTime(item.getSendTime()));
sendRepository.save(e);
if(e.getBulkSendKey() != null && !e.getBulkSendKey().isBlank()){
bulkSendRepository.findByBulkSendKey(e.getBulkSendKey()).ifPresent(bulk -> {
if(sendStatus == SendStatusType.SUCCESS) {
bulk.setSuccesCnt(bulk.getSuccesCnt() + 1);
}
else{
bulk.setFailCnt(bulk.getFailCnt() + 1);
}
if(bulk.getSendCnt() <= bulk.getSuccesCnt() + bulk.getFailCnt()) {
bulk.setCompleteDt(now);
}
bulkSendRepository.save(bulk);
});
}
return true;
} catch (Exception ex) {
log.warn("Pringo return polling failed. returnKey={}", returnKey, ex);
return false;
}
}
}

View File

@@ -0,0 +1,168 @@
package com.kri.notihub.server.service;
import com.kri.common.file.FileUtil;
import com.kri.common.util.CommonUtil;
import org.jsoup.Jsoup;
import org.jsoup.nodes.Document;
import org.jsoup.nodes.Element;
import org.jsoup.select.Elements;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;
import org.springframework.web.multipart.MultipartFile;
import java.io.IOException;
import java.nio.file.*;
import java.util.HashSet;
import java.util.Optional;
import java.util.Set;
@Service
public class FileService {
private static final Logger log = LoggerFactory.getLogger(FileService.class);
private final Path uploadBaseDir; // ex) /data/upload-file/body-image
private final String publicBaseUrlPrefix; // ex) /upload-file/body-image
public FileService(
@Value("${kri.body-image.upload-base-dir}") String uploadBaseDir,
@Value("${kri.body-image.public-base-url}") String publicBaseUrlPrefix
) {
this.uploadBaseDir = Paths.get(uploadBaseDir).toAbsolutePath().normalize();
this.publicBaseUrlPrefix = publicBaseUrlPrefix.endsWith("/")
? publicBaseUrlPrefix.substring(0, publicBaseUrlPrefix.length() - 1)
: publicBaseUrlPrefix;
}
/**
* Temp에 파일 저장 후, public URL 반환
*/
public String storeTempFile(String itrntPrjctCd, MultipartFile file) {
try {
String original = Optional.ofNullable(file.getOriginalFilename()).orElse("file");
String ext = "";
int dot = original.lastIndexOf('.');
if (dot > 0 && dot < original.length() - 1) {
ext = original.substring(dot);
}
String newName = CommonUtil.uuid32() + ext;
Path tempDir = getTempDir(itrntPrjctCd);
Files.createDirectories(tempDir);
Path target = tempDir.resolve(newName);
file.transferTo(target.toFile());
// 브라우저에서 사용할 URL
return publicBaseUrlPrefix + "/" + itrntPrjctCd + "/Temp/" + newName;
} catch (IOException e) {
throw new RuntimeException("파일 저장 실패", e);
}
}
/**
* 컨택 시나리오 저장 시:
* 1) HTML 내 Temp 이미지 -> Asset으로 이동 & src 수정
* 2) Asset 디렉토리에서 더 이상 사용되지 않는 파일 삭제
* 3) 정리된 HTML 반환
*/
public String syncOnSave(String prjctCd, String rawHtml) {
if (rawHtml == null) rawHtml = "";
String returnHtml = rawHtml;
try{
// body fragment로 파싱 (KriEditor가 body 없이 <p>...</p> 형태 저장하므로)
Document doc = Jsoup.parseBodyFragment(rawHtml);
Elements imgs = doc.select("img[src]");
Set<String> assetFileNamesToKeep = new HashSet<>();
for (Element img : imgs) {
String src = img.attr("src");
if (src == null || src.isBlank()) continue;
if (!src.contains("/" + prjctCd + "/")) continue;
if (src.contains("/" + prjctCd + "/Temp/")) {
// Temp → Asset 이동
String fileName = FileUtil.extractFileNameFromPath(src);
moveTempToAsset(prjctCd, fileName);
String assetSrc = src.replace("/Temp/", "/Asset/");
img.attr("src", assetSrc);
assetFileNamesToKeep.add(fileName);
} else if (src.contains("/" + prjctCd + "/Asset/")) {
String fileName = FileUtil.extractFileNameFromPath(src);
assetFileNamesToKeep.add(fileName);
}
}
// Asset 디렉토리 정리 (본문에 없는 파일 삭제)
cleanupAssetDir(prjctCd, assetFileNamesToKeep);
// body 안의 HTML만 반환 (불필요한 <html><body> wrapper 제거)
returnHtml = doc.body().html();
}
catch (IOException e) {
log.warn("temp 파일 이동 실패: {}", rawHtml, e);
}
return returnHtml;
}
/***************************private************************************/
private String normalizeBaseUrl(String url) {
if (url.endsWith("/")) {
return url.substring(0, url.length() - 1);
}
return url;
}
private Path getTempDir(String prjctCd) {
return uploadBaseDir.resolve(prjctCd).resolve("Temp");
}
private Path getAssetDir(String prjctCd) {
return uploadBaseDir.resolve(prjctCd).resolve("Asset");
}
private void moveTempToAsset(String prjctCd, String fileName) throws IOException {
if (fileName == null || fileName.isBlank()) return;
Path tempDir = getTempDir(prjctCd);
Path assetDir = getAssetDir(prjctCd);
Files.createDirectories(assetDir);
Path source = tempDir.resolve(fileName).normalize();
Path target = assetDir.resolve(fileName).normalize();
if (!source.startsWith(tempDir) || !target.startsWith(assetDir)) {
// 안전 체크
return;
}
if (!Files.exists(source)) {
return;
}
Files.move(source, target, StandardCopyOption.REPLACE_EXISTING);
}
private void cleanupAssetDir(String prjctCd, Set<String> keepFileNames) throws IOException {
Path assetDir = getAssetDir(prjctCd);
if (!Files.exists(assetDir)) return;
try (DirectoryStream<Path> stream = Files.newDirectoryStream(assetDir)) {
for (Path path : stream) {
if (!Files.isRegularFile(path)) continue;
String fileName = path.getFileName().toString();
if (!keepFileNames.contains(fileName)) {
Files.deleteIfExists(path);
}
}
}
}
}

View File

@@ -0,0 +1,46 @@
package com.kri.notihub.server.service;
import com.kri.common.webmvc.page.PageRequestDto;
import com.kri.common.webmvc.page.PageResponseDto;
import com.kri.common.webmvc.page.Pageables;
import com.kri.notihub.server.common.enums.SendType;
import com.kri.notihub.server.dto.report.BulkSendInfoDto;
import com.kri.notihub.server.dto.report.SendInfoDto;
import com.kri.notihub.server.persistence.entity.TSendEntity;
import com.kri.notihub.server.persistence.repository.BulkSendRepository;
import com.kri.notihub.server.persistence.repository.SendRepository;
import lombok.RequiredArgsConstructor;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;
import org.springframework.stereotype.Service;
import java.util.List;
@Service
@RequiredArgsConstructor
public class ReportService {
private final BulkSendRepository bulkSendRepository;
private final SendRepository sendRepository;
public List<BulkSendInfoDto> getBulkSendList(SendType sendTy, String reqstSvc, String prjctCd, String regCmpn){
List<Short> sendTyList = sendTy == SendType.EMAIL ? List.of(SendType.EMAIL.getCode()) : List.of(SendType.SMS.getCode(), SendType.LMS_MMS.getCode());
if(regCmpn == null){
return bulkSendRepository.findBySendTyInAndReqstSvcAndPrjctCd(sendTyList, reqstSvc, prjctCd)
.stream().map(BulkSendInfoDto::from).toList();
}
else{
return bulkSendRepository.findBySendTyInAndReqstSvcAndPrjctCdAndRegCmpn(sendTyList, reqstSvc, prjctCd, regCmpn)
.stream().map(BulkSendInfoDto::from).toList();
}
}
public PageResponseDto<SendInfoDto> getBulkSendDetail(String bulkSendKey, PageRequestDto pageReq){
Pageable pageable = Pageables.of(pageReq, TSendEntity.class);
Page<SendInfoDto> page = sendRepository.findByBulkSendKey(bulkSendKey, pageable)
.map(SendInfoDto::from);
return PageResponseDto.from(page);
}
}

View File

@@ -0,0 +1,157 @@
package com.kri.notihub.server.service;
import com.kri.common.datetime.DateTimeUtil;
import com.kri.common.util.CommonUtil;
import com.kri.notihub.server.common.consts.NotihubConst;
import com.kri.notihub.server.common.enums.SendStatusType;
import com.kri.notihub.server.common.enums.SendType;
import com.kri.notihub.server.common.external.pringo.PringoApiClient;
import com.kri.notihub.server.common.external.pringo.dto.PringoJsonSendRequestDto;
import com.kri.notihub.server.common.external.pringo.dto.PringoJsonSendResponseDto;
import com.kri.notihub.server.dto.send.DestInfoDto;
import com.kri.notihub.server.dto.send.SendInternalResultDto;
import com.kri.notihub.server.persistence.entity.TSendEntity;
import com.kri.notihub.server.persistence.repository.BulkSendRepository;
import com.kri.notihub.server.persistence.repository.SendRepository;
import com.kri.notihub.server.persistence.repository.TemplateRepository;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import java.time.format.DateTimeFormatter;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.concurrent.ThreadLocalRandom;
@Slf4j
@Service
public class SendEmailService extends SendService {
private final PringoApiClient pringoApiClient;
private final EmailResultPoller emailResultPoller;
private final EmailResultUpdater emailResultUpdater;
public SendEmailService(
TemplateRepository templateRepository,
BulkSendRepository bulkSendRepository,
SendRepository sendRepository,
TemplateService templateService,
PringoApiClient pringoApiClient,
EmailResultPoller emailResultPoller,
EmailResultUpdater emailResultUpdater
) {
super(templateRepository, bulkSendRepository, sendRepository, templateService);
this.pringoApiClient = pringoApiClient;
this.emailResultPoller = emailResultPoller;
this.emailResultUpdater = emailResultUpdater;
}
@Override
protected SendType getSendType() {
return SendType.EMAIL;
}
@Override
protected SendInternalResultDto doSendInternal(
Boolean isResve,
String bulkSendKey,
SendType sendType, //Sms에서 사용 Email에서는 의미 없음
String sendEml,
String sendNm,
String msgTitle,
String msgBody,
DestInfoDto dest
){
if(Boolean.TRUE.equals(isResve)){
//예약 용 cmid 생성 추후 실제 발송 후 갱신
String ts = DateTimeUtil.nowKstLocalDateTime()
.format(DateTimeFormatter.ofPattern("yyyyMMddHHmmssSSS"));
int r = ThreadLocalRandom.current().nextInt(36 * 36 * 36);
String suffix = String.format("%3s", Integer.toString(r, 36)).replace(' ', '0');
String cmid = NotihubConst.EMAIL_RESERVATION_PREFIX + ts + suffix;
return SendInternalResultDto.of(cmid, SendStatusType.STANDBY, NotihubConst.EMAIL_STANDBY);
}
else {
PringoJsonSendRequestDto pringoReq = buildPringoSendRequest(sendEml, sendNm, msgTitle, msgBody, dest);
return sendPringoEmail(pringoReq);
}
}
public SendInternalResultDto sendPringoEmail(PringoJsonSendRequestDto pringoReq){
PringoJsonSendResponseDto pringoRes = null;
try {
pringoRes = pringoApiClient.jsonSend(pringoReq);
} catch (Exception e) {
log.warn("Pringo json-send failed (pringoReq={})", pringoReq, e);
}
String cmid = resolveEmailCmid(pringoRes);
SendStatusType sendStatus;
short resultCode;
if (pringoRes != null && pringoRes.isSuccess() && pringoRes.getReturnKey() != null) {
//발송 요청에 성공한 것이지 발송이 성공이 아니므로 STANDBY 유지
//sendStatus = SendStatusType.SUCCESS;
sendStatus = SendStatusType.STANDBY;
resultCode = NotihubConst.EMAIL_PENDING;
} else {
sendStatus = SendStatusType.FAIL;
resultCode = NotihubConst.EMAIL_SEND_FAIL;
}
return SendInternalResultDto.of(cmid, sendStatus, resultCode);
}
@Override
public void afterPersistSendEntities(List<TSendEntity> persisted) {
if (persisted == null || persisted.isEmpty()) return;
for (TSendEntity e : persisted) {
if (e == null) continue;
// Pringo return polling이 필요한 상태만
if (e.getResultCode() == null || e.getResultCode() != NotihubConst.EMAIL_PENDING) continue;
//예약은 갱신용 큐에 넣지 않음
if(e.getCmid().startsWith(NotihubConst.EMAIL_RESERVATION_PREFIX)) continue;
// return_key(숫자)인 경우만
if (!CommonUtil.isNumeric(e.getCmid())) continue;
emailResultPoller.enqueue(e.getCmid());
}
}
public PringoJsonSendRequestDto buildPringoSendRequest(
String sendEml,
String sendNm,
String msgTitle,
String msgBody,
DestInfoDto dest
) {
Map<String, Object> vars = new HashMap<>();
if (dest.getMsgParam() != null) vars.putAll(dest.getMsgParam());
return PringoJsonSendRequestDto.builder()
.sender(sendEml)
.senderName(Optional.ofNullable(sendNm).orElse(""))
.recipient(dest.getDestEml())
.recipientName(Optional.ofNullable(dest.getDestNm()).orElse(""))
.subject(Optional.ofNullable(msgTitle).orElse(""))
.body(Optional.ofNullable(msgBody).orElse(""))
.vars(vars)
.build();
}
private String resolveEmailCmid(PringoJsonSendResponseDto pringoRes) {
if (pringoRes != null && pringoRes.isSuccess() && pringoRes.getReturnKey() != null) {
return String.valueOf(pringoRes.getReturnKey());
}
// return_key 미수신 케이스는 SendFau
return CommonUtil.uuid32();
}
}

View File

@@ -0,0 +1,350 @@
package com.kri.notihub.server.service;
import com.kri.common.datetime.DateTimeUtil;
import com.kri.common.web.BusinessException;
import com.kri.notihub.server.common.consts.NotihubConst;
import com.kri.notihub.server.common.enums.SendStatusType;
import com.kri.notihub.server.common.enums.SendType;
import com.kri.notihub.server.dto.send.*;
import com.kri.notihub.server.dto.template.TemplateDto;
import com.kri.notihub.server.persistence.entity.TBulkSendEntity;
import com.kri.notihub.server.persistence.entity.TSendEntity;
import com.kri.notihub.server.persistence.repository.BulkSendRepository;
import com.kri.notihub.server.persistence.repository.SendRepository;
import com.kri.notihub.server.persistence.repository.TemplateRepository;
import lombok.RequiredArgsConstructor;
import java.time.LocalDateTime;
import java.util.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import static org.apache.commons.lang3.StringUtils.firstNonBlank;
@RequiredArgsConstructor
public abstract class SendService {
protected final TemplateRepository templateRepository;
protected final BulkSendRepository bulkSendRepository;
protected final SendRepository sendRepository;
protected final TemplateService templateService;
public String issueBulkKey(BulkSendCreateRequestDto req) {
LocalDateTime now = DateTimeUtil.nowKstLocalDateTime();
if (req == null || req.getTmplatIdx() == null) {
throw BusinessException.badRequest("BULK_CREATE_INVALID", "tmplatIdx은 필수 입니다.");
}
if (req.getTrgtCnt() == null || req.getTrgtCnt() <= 0) {
throw BusinessException.badRequest("BULK_CREATE_INVALID", "trgtCnt는 0보다 커야 합니다.");
}
if (req.getResve()) {
if (req.getSendDt() == null) {
throw BusinessException.badRequest("BULK_CREATE_INVALID", "예약 발송의 경우 희망 발송일시가 필수 입니다.");
}
if (!req.getSendDt().isAfter(now)) { // now보다 커야 함(같으면 불가)
throw BusinessException.badRequest("BULK_CREATE_INVALID", "예약 발송의 경우 희망 발송일시는 현재시간 이후여야 합니다.");
}
}
TemplateDto tmplat = templateService.getTemplate(req.getTmplatIdx());
validateTemplateType(tmplat, getSendType());
TBulkSendEntity bulk = TBulkSendEntity.from(req, now);
TBulkSendEntity saved = bulkSendRepository.save(bulk);
return saved.getBulkSendKey();
}
protected void validateTemplateType(TemplateDto tmplat, SendType requiredType) {
if (tmplat == null || requiredType == null) return;
int tmplatTy = tmplat.getTmplatTy().getCode()/10;
int required = requiredType.getCode()/10;
if (tmplat.getTmplatTy() == null || tmplatTy != required) {
throw BusinessException.badRequest("WRONG_TEMPLATE_TYPE","템플릿 타입이 잘 못 됐습니다.")
.with("tmplatIdx", tmplat.getTmplatIdx())
.with("required", requiredType)
.with("tmplatTy", tmplat.getTmplatTy());
}
}
public final void doSendSingle(SendRequestSingleDto req, String regCmpn, String regUser) {
LocalDateTime now = DateTimeUtil.nowKstLocalDateTime();
if (req == null || req.getDestInfo() == null) {
throw BusinessException.badRequest("DEST_INFO_REQUIRED", "destInfo 는 필수입니다.");
}
if (req.getResve()) {
if (req.getSendDt() == null) {
throw BusinessException.badRequest("SEND_SINGLE_INVALID", "예약 발송의 경우 희망 발송일시가 필수 입니다.");
}
if (!req.getSendDt().isAfter(now)) { // now보다 커야 함(같으면 불가)
throw BusinessException.badRequest("SEND_SINGLE_INVALID", "예약 발송의 경우 희망 발송일시는 현재시간 이후여야 합니다.");
}
}
TemplateDto tmplat = templateService.getTemplate(req.getTmplatIdx());
validateTemplateType(tmplat, getSendType());
LocalDateTime sendDt = req.getSendDt() != null ? req.getSendDt() : now;
String sendTel = firstNonBlank(req.getSendTel(), tmplat.getSendTel());
String sendEml = firstNonBlank(req.getSendEml(), tmplat.getSendEml());
String sendFrom = getSendType() == SendType.EMAIL ? sendEml : sendTel;
String sendNm = firstNonBlank(req.getSendNm(), tmplat.getSendNm());
if (sendFrom == null || sendFrom.isBlank()) {
if (getSendType() == SendType.EMAIL) {
throw BusinessException.badRequest("SEND_EMAIL_REQUIRED", "sendEml은 필수 입니다.");
} else {
throw BusinessException.badRequest("SEND_TEL_REQUIRED", "sendTel은 필수 입니다.");
}
}
DestInfoDto dest = req.getDestInfo();
String sendTo = getSendType() == SendType.EMAIL ? dest.getDestEml() : dest.getDestTel();
if (sendTo == null || sendTo.isBlank()) {
if (getSendType() == SendType.EMAIL) {
throw BusinessException.badRequest("DEST_EMAIL_REQUIRED", "destEml은 필수 입니다.");
} else {
throw BusinessException.badRequest("DEST_TEL_REQUIRED", "destTel은 필수 입니다.");
}
}
String msgTitle = replacePlaceholder(tmplat.getTmplatTitle(), dest.getMsgParam());
String msgBody = replacePlaceholder(tmplat.getTmplatBody(), dest.getMsgParam());
SendInternalResultDto sendResult = doSendInternal(
req.getResve(),
null,
tmplat.getTmplatTy(),
sendFrom,
sendNm,
msgTitle,
msgBody,
dest
);
req.setSendEml(sendEml);
req.setSendTel(sendTel);
req.setSendNm(sendNm);
List<TSendEntity> sendInfo = new ArrayList<>(List.of(
TSendEntity.from(
req,
tmplat.getTmplatTy(),
sendResult,
tmplat.getItrntPrjctCd(),
msgTitle,
msgBody,
regCmpn,
regUser,
req.getResve(),
sendDt,
now
)
));
sendRepository.saveAll(sendInfo);
sendRepository.flush();
afterPersistSendEntities(sendInfo);
}
public final BulkSendResponseDto doSendBulk(SendRequestBulkDto req) {
LocalDateTime now = DateTimeUtil.nowKstLocalDateTime();
String bulkSendKey = req.getBulkSendKey();
if (bulkSendKey.isBlank()) throw BusinessException.badRequest("BULK_SEND_KEY_REQUIRED", "bulkSendKey는 필수입니다.");
if (req == null || req.getDestInfoList() == null || req.getDestInfoList().isEmpty()) {
throw BusinessException.badRequest("DEST_LIST_REQUIRED", "수신 정보가 없습니다.");
}
TBulkSendEntity bulk = bulkSendRepository.findById(bulkSendKey)
.orElseThrow(() ->
BusinessException.badRequest("BULK_SEND_KEY_NOT_FOUND", "bulkSendKey가 잘 못 됐습니다.")
.with("bulkSendKey", bulkSendKey)
);
if(bulk.getTrgtCnt() <= bulk.getSendCnt()){
BusinessException.badRequest("OVERFLOW_SEND_CNT", "해당 bulkSendKey로 발송할 수 있는 한도를 초과 했습니다.")
.with("bulkSendKey", bulkSendKey)
.with("trgtCnt", bulk.getTrgtCnt())
.with("sendCnt", bulk.getSendCnt());
}
TemplateDto tmplat = templateService.getTemplate(bulk.getTmplatIdx());
validateTemplateType(tmplat, getSendType());
Boolean isResve = bulk.getResve();
LocalDateTime sendDt = bulk.getSendDt() != null ? bulk.getSendDt() : now;
String sendTel = firstNonBlank(req.getSendTel(), tmplat.getSendTel());
String sendEml = firstNonBlank(req.getSendEml(), tmplat.getSendEml());
String sendFrom = getSendType() == SendType.EMAIL ? sendEml : sendTel;
String sendNm = firstNonBlank(req.getSendNm(), tmplat.getSendNm());
if (sendFrom == null || sendFrom.isBlank()) {
if (getSendType() == SendType.EMAIL) {
throw BusinessException.badRequest("SENDER_EMAIL_REQUIRED", "sendEml은 필수 입니다.");
} else {
throw BusinessException.badRequest("SENDER_TEL_REQUIRED", "sendTel은 필수 입니다.");
}
}
req.setSendEml(sendEml);
req.setSendTel(sendTel);
req.setSendNm(sendNm);
int requestCnt = req.getDestInfoList().size();
int acceptCnt = 0;
int failCnt = 0;
List<TSendEntity> buffer = new ArrayList<>(Math.min(requestCnt, NotihubConst.INSERT_CHUNK_SIZE));
for (int offset = 0; offset < requestCnt; offset += NotihubConst.CHUNK_SIZE) {
int end = Math.min(offset + NotihubConst.CHUNK_SIZE, requestCnt);
List<DestInfoDto> chunk = req.getDestInfoList().subList(offset, end);
for (DestInfoDto dest : chunk) {
String sendTo = getSendType() == SendType.EMAIL ? dest.getDestEml() : dest.getDestTel();
if (dest == null || sendTo.isBlank()) {
failCnt++;
continue;
}
String msgTitle = replacePlaceholder(tmplat.getTmplatTitle(), dest.getMsgParam());
String msgBody = replacePlaceholder(tmplat.getTmplatBody(), dest.getMsgParam());
SendInternalResultDto sendResult = doSendInternal(
isResve,
bulkSendKey,
tmplat.getTmplatTy(),
sendFrom,
sendNm,
msgTitle,
msgBody,
dest
);
if (sendResult.getStatus() == SendStatusType.SUCCESS) {
acceptCnt++;
} else if(sendResult.getStatus() == SendStatusType.FAIL) {
failCnt++;
}
buffer.add(
TSendEntity.from(
req,
dest,
tmplat.getTmplatTy(),
sendResult,
tmplat.getItrntPrjctCd(),
bulk.getReqstSvc(),
bulk.getPrjctCd(),
bulk.getTmplatIdx(),
msgTitle,
msgBody,
bulk.getRegCmpn(),
bulk.getRegUser(),
isResve,
sendDt,
bulkSendKey,
now
)
);
if(getSendType() == SendType.EMAIL) {
// 발송 간 딜레이(Pringo rate-limit 대응)
long delay = Math.max(tmplat.getDelayTime(), NotihubConst.EMAIL_DELAY);
sleepSilently(delay);
}
}
}
if (!buffer.isEmpty()) {
saveSendEntitiesChunked(buffer);
buffer.clear();
}
// bulk 집계 업데이트(요청/성공/실패 카운트)
bulk.setSendCnt(Optional.ofNullable(bulk.getSendCnt()).orElse(0) + requestCnt);
bulk.setSuccesCnt(Optional.ofNullable(bulk.getSuccesCnt()).orElse(0) + acceptCnt);
bulk.setFailCnt(Optional.ofNullable(bulk.getFailCnt()).orElse(0) + failCnt);
bulkSendRepository.save(bulk);
return BulkSendResponseDto.of(bulkSendKey, requestCnt, acceptCnt, failCnt);
}
protected String replacePlaceholder(String text, Map<String, String> msgParam){
if (text == null || text.isEmpty() || msgParam == null || msgParam.isEmpty()) {
return text;
}
Pattern pattern = Pattern.compile("\\[\\$([^\\]]+)]");
Matcher matcher = pattern.matcher(text);
StringBuilder sb = new StringBuilder();
while (matcher.find()) {
String varName = matcher.group(1);
String value = msgParam.get(varName);
if (value == null) {
// 값이 없으면 원문 유지
matcher.appendReplacement(sb, Matcher.quoteReplacement(matcher.group(0)));
} else {
// 값 치환 (정규식 replacement 안전 처리)
matcher.appendReplacement(sb, Matcher.quoteReplacement(value));
}
}
matcher.appendTail(sb);
return sb.toString();
}
/** 자식 클래스가 구현: 실제 발송 수행 */
protected abstract SendInternalResultDto doSendInternal(
Boolean isResve,
String bulkSendKey,
SendType sendType,
String sendFrom,
String sendNm,
String msgTitle,
String msgBody,
DestInfoDto dest
);
public abstract void afterPersistSendEntities(List<TSendEntity> persisted);
protected void saveSendEntitiesChunked(List<TSendEntity> entityList) {
if (entityList == null || entityList.isEmpty()) return;
int size = entityList.size();
for (int i = 0; i < size; i += NotihubConst.INSERT_CHUNK_SIZE) {
int end = Math.min(size, i + NotihubConst.INSERT_CHUNK_SIZE);
List<TSendEntity> sub = entityList.subList(i, end);
sendRepository.saveAll(sub);
sendRepository.flush();
afterPersistSendEntities(sub);
}
}
protected static void sleepSilently(long ms) {
if (ms <= 0) return;
try {
Thread.sleep(ms);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
}
protected abstract SendType getSendType();
}

View File

@@ -0,0 +1,86 @@
package com.kri.notihub.server.service;
import com.kri.common.util.CommonUtil;
import com.kri.notihub.server.common.consts.NotihubConst;
import com.kri.notihub.server.common.enums.SendStatusType;
import com.kri.notihub.server.common.enums.SendType;
import com.kri.notihub.server.dto.send.DestInfoDto;
import com.kri.notihub.server.dto.send.SendInternalResultDto;
import com.kri.notihub.server.persistence.entity.BizMsgEntity;
import com.kri.notihub.server.persistence.entity.TSendEntity;
import com.kri.notihub.server.persistence.repository.BizMsgRepository;
import com.kri.notihub.server.persistence.repository.BulkSendRepository;
import com.kri.notihub.server.persistence.repository.SendRepository;
import com.kri.notihub.server.persistence.repository.TemplateRepository;
import org.springframework.stereotype.Service;
import java.util.ArrayList;
import java.util.List;
@Service
public class SendSmsService extends SendService {
private final BizMsgRepository bizMsgRepository;
public SendSmsService(
BizMsgRepository bizMsgRepository,
TemplateRepository templateRepository,
BulkSendRepository bulkSendRepository,
SendRepository sendRepository,
TemplateService templateService
){
super(templateRepository, bulkSendRepository, sendRepository, templateService);
this.bizMsgRepository = bizMsgRepository;
}
@Override
protected SendType getSendType() {
//일단 SMS로 내보내고 발송시에 Template의 SendType 또는 MessageBody, 제목여부로 강화 필요
return SendType.SMS; // 프로젝트 enum 기준
}
@Override
protected SendInternalResultDto doSendInternal(
Boolean isResve,
String bulkSendKey,
SendType sendType,
String sendTel,
String sendNm,
String msgTitle,
String msgBody,
DestInfoDto dest
) {
//문자는 비즈 뿌리오가 발송을 해주기 때문에 예약도 따로 처리할 필요 없음
String cmid = CommonUtil.uuid32();
SendStatusType sendStatus = SendStatusType.STANDBY;
short resultCode = sendType == SendType.LMS_MMS ? NotihubConst.LMS_MMS_STANDBY : NotihubConst.SMS_STANDBY;
return SendInternalResultDto.of(
cmid,
sendStatus,
resultCode
);
}
@Override
public void afterPersistSendEntities(List<TSendEntity> persisted) {
if (persisted == null || persisted.isEmpty()) return;
List<BizMsgEntity> msgList = new ArrayList<>(persisted.size());
for (TSendEntity s : persisted) {
if (s == null) continue;
if (NotihubConst.MOBILE_TYPE_LIST.contains(s.getSendTy())) continue;
BizMsgEntity m = BizMsgEntity.fromSend(s);
msgList.add(m);
}
if (!msgList.isEmpty()) {
bizMsgRepository.saveAll(msgList);
bizMsgRepository.flush();
}
}
}

View File

@@ -0,0 +1,32 @@
package com.kri.notihub.server.service;
import com.kri.notihub.server.common.enums.SendType;
import com.kri.notihub.server.persistence.repository.SendRepository;
import jakarta.annotation.PostConstruct;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Component;
@Component
@RequiredArgsConstructor
public class SmsSendCursorStore {
private final SendRepository sendRepository;
// 프로세스 전역 커서(스레드 세이프)
private static final java.util.concurrent.atomic.AtomicLong CURSOR = new java.util.concurrent.atomic.AtomicLong(0L);
// 서비스 기동 시: t_send에서 sendTy=SMS의 max(send_idx)로 초기화
@PostConstruct
public void init() {
long maxSendIdx = sendRepository.findMinSendIdxBySendTy(SendType.SMS.getCode());
CURSOR.set(maxSendIdx);
}
public long get() {
return CURSOR.get();
}
public void set(long sendIdx) {
CURSOR.set(sendIdx);
}
}

View File

@@ -0,0 +1,171 @@
package com.kri.notihub.server.service;
import com.kri.common.datetime.DateTimeUtil;
import com.kri.common.web.BusinessException;
import com.kri.notihub.server.common.consts.NotihubConst;
import com.kri.notihub.server.common.enums.SendType;
import com.kri.notihub.server.common.enums.TemplateEventType;
import com.kri.notihub.server.common.util.TemplateContentSanitizer;
import com.kri.notihub.server.dto.template.TemplateBasicDto;
import com.kri.notihub.server.dto.template.TemplateDto;
import com.kri.notihub.server.dto.template.TemplateSummaryDto;
import com.kri.notihub.server.persistence.entity.TTmplatEntity;
import com.kri.notihub.server.persistence.entity.TTmplatEventLogEntity;
import com.kri.notihub.server.persistence.repository.TemplateEventLogRepository;
import com.kri.notihub.server.persistence.repository.TemplateRepository;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.time.LocalDateTime;
import java.util.List;
@Service
@RequiredArgsConstructor
public class TemplateService {
private final TemplateRepository templateRepository;
private final TemplateEventLogRepository templateEventLogRepository;
@Transactional
public long createTemplate(String itrntPrjctCd, TemplateBasicDto template, String regUser) {
final LocalDateTime now = DateTimeUtil.nowKstLocalDateTime();
validateBySendType(template);
//제목, 본문 정규화
TemplateContentSanitizer.sanitizeAndNormalizeInPlace(template);
// 엔티티 생성은 엔티티 팩토리(내부 builder)로 위임
TTmplatEntity entity = TTmplatEntity.create(itrntPrjctCd, template, regUser, now);
TTmplatEntity saved = templateRepository.save(entity);
saveLog(saved.getTmplatIdx(), TemplateEventType.CREATE_TEMPLATE, null, template, regUser, now);
return saved.getTmplatIdx();
}
public List<TemplateSummaryDto> getTemplateList(String itrntPrjctCd) {
return templateRepository.findAllByItrntPrjctCdAndDelFalse(itrntPrjctCd).stream()
.map(TemplateSummaryDto::from)
.toList();
}
public TemplateDto getTemplate(long tmplatIdx) {
return templateRepository.findByTmplatIdxAndDelFalse(tmplatIdx)
.map(TemplateDto::from)
.orElseThrow(() ->
BusinessException.notFound("TEMPLATE_NOT_FOUND", "템플릿을 찾을 수 없습니다.")
.with("tmplatIdx", tmplatIdx)
);
}
@Transactional
public TemplateDto updateTemplate(TemplateDto template, String modUser) {
long tmplatIdx = template.getTmplatIdx();
final LocalDateTime now = DateTimeUtil.nowKstLocalDateTime();
TTmplatEntity entity = templateRepository.findByTmplatIdxAndDelFalse(tmplatIdx).orElseThrow(() ->
BusinessException.notFound("TEMPLATE_NOT_FOUND", "템플릿을 찾을 수 없습니다.")
.with("tmplatIdx", tmplatIdx)
);
validateBySendType(template);
//제목, 본문 정규화
TemplateContentSanitizer.sanitizeAndNormalizeInPlace(template);
TemplateBasicDto before = TemplateDto.from(entity);
entity.updateFrom(template, modUser, now);
templateRepository.save(entity);
saveLog(tmplatIdx, TemplateEventType.UPDATE_TEMPLATE, before, template, modUser, now);
return template;
}
@Transactional
public void deleteTemplate(long tmplatIdx, String delUser) {
final LocalDateTime now = DateTimeUtil.nowKstLocalDateTime();
templateRepository.softDeleteByTmplatIdx(tmplatIdx, delUser, now);
saveLog(tmplatIdx, TemplateEventType.DELETE_TEMPLATE, null, null, delUser, now);
}
private void saveLog(
long tmplatIdx,
TemplateEventType eventType,
TemplateBasicDto beforeTmplat,
TemplateBasicDto afterTmplat,
String regUser,
LocalDateTime regDt
) {
TTmplatEventLogEntity log = TTmplatEventLogEntity.of(
tmplatIdx,
eventType,
beforeTmplat,
afterTmplat,
regUser,
regDt
);
templateEventLogRepository.save(log);
}
private void validateBySendType(TemplateBasicDto template) {
//공통 검증
if (template.getTmplatTy() == null) {
throw BusinessException.badRequest("NULL TYPE", "템플릿 타입은 필수입니다.");
}
if (template.getTmplatNm() == null || template.getTmplatNm().isBlank()) {
throw BusinessException.badRequest("EMPTY_NAME", "템플릿 명은 필수입니다.");
}
if (template.getTmplatBody() == null || template.getTmplatBody().isBlank()) {
throw BusinessException.badRequest("EMPTY_BODY", "내용은 필수입니다.");
}
if(template.getSendNm() == null || template.getSendNm().isBlank()) {
throw BusinessException.badRequest("EMPTY_SEND_NAME", "발신자 명은 필수입니다.");
}
if (template.getDelayTime() != null) {
if (template.getDelayTime() < 0) {
template.setDelayTime((short) 0);
}
if (template.getDelayTime() > NotihubConst.DELAY_MAX_MS) {
template.setDelayTime(NotihubConst.DELAY_MAX_MS);
}
}
SendType ty = template.getTmplatTy();
if (ty == SendType.EMAIL) {
if (template.getSendEml() == null || template.getSendEml().isBlank()) {
throw BusinessException.badRequest("EMPTY_EMAIL", "이메일은 필수입니다.");
}
if (template.getTmplatTitle() == null || template.getTmplatTitle().isBlank()) {
throw BusinessException.badRequest("EMPTY_TITLE", "제목은 필수입니다.");
}
template.setSendTel(null);
}
else if (NotihubConst.MOBILE_TYPE_LIST.contains(ty)) {
if (template.getSendTel() == null || template.getSendTel().isBlank()) {
throw BusinessException.badRequest("EMPTY_TEL", "발송번호는 필수입니다.");
}
if (ty == SendType.SMS) {
template.setTmplatTitle(null);
}
template.setSendEml(null);
}
else {
// 혹시 enum 확장 대비
throw BusinessException.badRequest("INVALID_TYPE", "지원하지 않는 템플릿 타입입니다.")
.with("tmplatTy", ty);
}
}
}