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

3
.gitattributes vendored Normal file
View File

@@ -0,0 +1,3 @@
/gradlew text eol=lf
*.bat text eol=crlf
*.jar binary

37
.gitignore vendored Normal file
View File

@@ -0,0 +1,37 @@
HELP.md
.gradle
build/
!gradle/wrapper/gradle-wrapper.jar
!**/src/main/**/build/
!**/src/test/**/build/
### STS ###
.apt_generated
.classpath
.factorypath
.project
.settings
.springBeans
.sts4-cache
bin/
!**/src/main/**/bin/
!**/src/test/**/bin/
### IntelliJ IDEA ###
.idea
*.iws
*.iml
*.ipr
out/
!**/src/main/**/out/
!**/src/test/**/out/
### NetBeans ###
/nbproject/private/
/nbbuild/
/dist/
/nbdist/
/.nb-gradle/
### VS Code ###
.vscode/

11
application-dev.yml Normal file
View File

@@ -0,0 +1,11 @@
kri:
api-url:
intranet-extension: "http://localhost:3031"
spring:
datasource:
#private 도메인
url: jdbc:mysql://db-md87m-kr.vpc-pub-cdb.ntruss.com:3306/notice_hub?characterEncoding=UTF-8
username: kri_notihub
password: notihub#51304
driver-class-name: com.mysql.cj.jdbc.Driver

28
application-local.yml Normal file
View File

@@ -0,0 +1,28 @@
kri:
api-url:
intranet-extension: "http://localhost:3031"
email:
result-poll:
initial-delay-ms: 3000
spring:
datasource:
#private 도메인
url: jdbc:mysql://db-md87m-kr.vpc-pub-cdb.ntruss.com:3306/notice_hub?characterEncoding=UTF-8
username: kri_notihub
password: notihub#51304
driver-class-name: com.mysql.cj.jdbc.Driver
jpa:
hibernate:
ddl-auto: none # 필요에 따라 update / validate 등으로 변경
properties:
hibernate:
dialect: org.hibernate.dialect.MySQL8Dialect
format_sql: true
show_sql: true
open-in-view: false
logging:
level:
org.hibernate.SQL: debug
org.hibernate.type.descriptor.sql.BasicBinder: trace

11
application-prod.yml Normal file
View File

@@ -0,0 +1,11 @@
kri:
api-url:
intranet-extension: "http://localhost:3031"
spring:
datasource:
#private 도메인
url: jdbc:mysql://db-md87m-kr.vpc-pub-cdb.ntruss.com:3306/notice_hub?characterEncoding=UTF-8
username: kri_notihub
password: notihub#51304
driver-class-name: com.mysql.cj.jdbc.Driver

90
application.yml Normal file
View File

@@ -0,0 +1,90 @@
server:
port: 4011
spring:
application:
name: KriNoticeHub
jpa:
hibernate:
naming:
physical-strategy: org.hibernate.boot.model.naming.PhysicalNamingStrategyStandardImpl
profiles:
# 아무 설정 없을 때 기본으로 쓸 프로파일
default: local
servlet:
multipart:
max-file-size: 20MB
max-request-size: 20MB
logging:
file:
path: ./logs
kri:
api:
pringo:
url: "https://m1090.pg.eventmail01.com/api/event/v2"
apiKey: "5b2e14c5555479ecb6949ee714422b323b191e7491193ad27266851d7496735f"
template-id: "11"
email:
result-poll:
initial-delay-ms: 3000
max-attempts: 0
max-delay-ms: 30000
recover-days: 3
recover-page-size: 1000
auth:
apikey:
key: "4B726963-4E6F7469487562-53657276696365-402531403136"
header-name: "X-API-Key" # API Key 헤더
enabled: true # API Key 인증 허용 여부
service-code: intranet-extension
preload-on-startup: true
# 내부 운영용(원하면)
admin-api-enabled: true
admin-allow-ips:
- 127.0.0.1/32
- 0:0:0:0:0:0:0:1
# apikey 보관 DB(MySQL)
db:
url: jdbc:mysql://db-md87m-kr.vpc-pub-cdb.ntruss.com:3306/kri_common?characterEncoding=UTF-8
username: kriit
password: it#51304
driver-class-name: com.mysql.cj.jdbc.Driver
security:
enabled: true
public-paths: # 인증 없이 열어둘 URL
- /v3/api-docs/**
- /swagger-ui.html
- /swagger-ui/**
- /ping
- /body-image/**
swagger:
enabled: true
title: "KRI NotiHub API"
description: "KRI 문자/메일 발송 API"
version: "v1.0.0"
base-package: "com.kri.notihub.server"
body-image:
upload-base-dir: ./upload-file/body-image
public-base-url: /body-image
temp-expire-hours: 24
temp-cleanup-cron: "0 0 0 * * *" # 매일 00:00(초 분 시 일 월 요일)
common:
web:
enabled: true # 공통 Web 구성 사용 여부 (기본 true)
webmvc:
enabled: true # 공통 Webmvc 구성 사용 여부 (기본 true)
redis:
enabled: false # RedisQueueHelper 사용 시 true
scheduling:
enabled: true # @Scheduled 사용 시 true

71
build.gradle Normal file
View File

@@ -0,0 +1,71 @@
plugins {
id 'java'
id 'org.springframework.boot' version '3.5.7'
id 'io.spring.dependency-management' version '1.1.7'
}
group = 'com.kri.notihub'
version = '0.0.1-SNAPSHOT'
description = 'notihub-server'
java {
toolchain {
languageVersion = JavaLanguageVersion.of(17)
}
}
configurations {
compileOnly {
extendsFrom annotationProcessor
}
}
def giteaUser = findProperty("giteaUser") ?: ""
def giteaToken = findProperty("giteaToken") ?: ""
repositories {
mavenCentral()
maven {
name = "gitea"
url = uri("https://gitea.kric.com/api/packages/KRi/maven")
//allowInsecureProtocol = true
credentials {
username = giteaUser
password = giteaToken
}
}
}
dependencies {
implementation "com.kri.common:starter:beta.1.0.60"
implementation 'org.springframework.boot:spring-boot-starter-web'
implementation 'org.springframework.boot:spring-boot-starter-security'
implementation 'org.springframework.boot:spring-boot-starter-validation'
implementation "org.springdoc:springdoc-openapi-starter-webmvc-ui:2.8.11"
//Jsoup (HTML 파싱용)
implementation 'org.jsoup:jsoup:1.17.2'
//JPA
implementation "org.springframework.boot:spring-boot-starter-data-jpa"
//MySQL
runtimeOnly "com.mysql:mysql-connector-j"
//Entity Json <-> Class 파싱용
implementation "io.hypersistence:hypersistence-utils-hibernate-62:3.9.4"
compileOnly 'org.projectlombok:lombok'
annotationProcessor 'org.projectlombok:lombok'
developmentOnly 'org.springframework.boot:spring-boot-devtools'
testImplementation 'org.springframework.boot:spring-boot-starter-test'
testImplementation 'org.mybatis.spring.boot:mybatis-spring-boot-starter-test:3.0.5'
testImplementation 'org.springframework.security:spring-security-test'
testRuntimeOnly 'org.junit.platform:junit-platform-launcher'
}
tasks.named('test') {
useJUnitPlatform()
}

BIN
gradle/wrapper/gradle-wrapper.jar vendored Normal file

Binary file not shown.

View File

@@ -0,0 +1,7 @@
distributionBase=GRADLE_USER_HOME
distributionPath=wrapper/dists
distributionUrl=https\://services.gradle.org/distributions/gradle-9.2.1-bin.zip
networkTimeout=10000
validateDistributionUrl=true
zipStoreBase=GRADLE_USER_HOME
zipStorePath=wrapper/dists

248
gradlew vendored Normal file
View File

@@ -0,0 +1,248 @@
#!/bin/sh
#
# Copyright © 2015 the original authors.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# https://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
# SPDX-License-Identifier: Apache-2.0
#
##############################################################################
#
# Gradle start up script for POSIX generated by Gradle.
#
# Important for running:
#
# (1) You need a POSIX-compliant shell to run this script. If your /bin/sh is
# noncompliant, but you have some other compliant shell such as ksh or
# bash, then to run this script, type that shell name before the whole
# command line, like:
#
# ksh Gradle
#
# Busybox and similar reduced shells will NOT work, because this script
# requires all of these POSIX shell features:
# * functions;
# * expansions «$var», «${var}», «${var:-default}», «${var+SET}»,
# «${var#prefix}», «${var%suffix}», and «$( cmd )»;
# * compound commands having a testable exit status, especially «case»;
# * various built-in commands including «command», «set», and «ulimit».
#
# Important for patching:
#
# (2) This script targets any POSIX shell, so it avoids extensions provided
# by Bash, Ksh, etc; in particular arrays are avoided.
#
# The "traditional" practice of packing multiple parameters into a
# space-separated string is a well documented source of bugs and security
# problems, so this is (mostly) avoided, by progressively accumulating
# options in "$@", and eventually passing that to Java.
#
# Where the inherited environment variables (DEFAULT_JVM_OPTS, JAVA_OPTS,
# and GRADLE_OPTS) rely on word-splitting, this is performed explicitly;
# see the in-line comments for details.
#
# There are tweaks for specific operating systems such as AIX, CygWin,
# Darwin, MinGW, and NonStop.
#
# (3) This script is generated from the Groovy template
# https://github.com/gradle/gradle/blob/HEAD/platforms/jvm/plugins-application/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt
# within the Gradle project.
#
# You can find Gradle at https://github.com/gradle/gradle/.
#
##############################################################################
# Attempt to set APP_HOME
# Resolve links: $0 may be a link
app_path=$0
# Need this for daisy-chained symlinks.
while
APP_HOME=${app_path%"${app_path##*/}"} # leaves a trailing /; empty if no leading path
[ -h "$app_path" ]
do
ls=$( ls -ld "$app_path" )
link=${ls#*' -> '}
case $link in #(
/*) app_path=$link ;; #(
*) app_path=$APP_HOME$link ;;
esac
done
# This is normally unused
# shellcheck disable=SC2034
APP_BASE_NAME=${0##*/}
# Discard cd standard output in case $CDPATH is set (https://github.com/gradle/gradle/issues/25036)
APP_HOME=$( cd -P "${APP_HOME:-./}" > /dev/null && printf '%s\n' "$PWD" ) || exit
# Use the maximum available, or set MAX_FD != -1 to use that value.
MAX_FD=maximum
warn () {
echo "$*"
} >&2
die () {
echo
echo "$*"
echo
exit 1
} >&2
# OS specific support (must be 'true' or 'false').
cygwin=false
msys=false
darwin=false
nonstop=false
case "$( uname )" in #(
CYGWIN* ) cygwin=true ;; #(
Darwin* ) darwin=true ;; #(
MSYS* | MINGW* ) msys=true ;; #(
NONSTOP* ) nonstop=true ;;
esac
# Determine the Java command to use to start the JVM.
if [ -n "$JAVA_HOME" ] ; then
if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
# IBM's JDK on AIX uses strange locations for the executables
JAVACMD=$JAVA_HOME/jre/sh/java
else
JAVACMD=$JAVA_HOME/bin/java
fi
if [ ! -x "$JAVACMD" ] ; then
die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
Please set the JAVA_HOME variable in your environment to match the
location of your Java installation."
fi
else
JAVACMD=java
if ! command -v java >/dev/null 2>&1
then
die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
Please set the JAVA_HOME variable in your environment to match the
location of your Java installation."
fi
fi
# Increase the maximum file descriptors if we can.
if ! "$cygwin" && ! "$darwin" && ! "$nonstop" ; then
case $MAX_FD in #(
max*)
# In POSIX sh, ulimit -H is undefined. That's why the result is checked to see if it worked.
# shellcheck disable=SC2039,SC3045
MAX_FD=$( ulimit -H -n ) ||
warn "Could not query maximum file descriptor limit"
esac
case $MAX_FD in #(
'' | soft) :;; #(
*)
# In POSIX sh, ulimit -n is undefined. That's why the result is checked to see if it worked.
# shellcheck disable=SC2039,SC3045
ulimit -n "$MAX_FD" ||
warn "Could not set maximum file descriptor limit to $MAX_FD"
esac
fi
# Collect all arguments for the java command, stacking in reverse order:
# * args from the command line
# * the main class name
# * -classpath
# * -D...appname settings
# * --module-path (only if needed)
# * DEFAULT_JVM_OPTS, JAVA_OPTS, and GRADLE_OPTS environment variables.
# For Cygwin or MSYS, switch paths to Windows format before running java
if "$cygwin" || "$msys" ; then
APP_HOME=$( cygpath --path --mixed "$APP_HOME" )
JAVACMD=$( cygpath --unix "$JAVACMD" )
# Now convert the arguments - kludge to limit ourselves to /bin/sh
for arg do
if
case $arg in #(
-*) false ;; # don't mess with options #(
/?*) t=${arg#/} t=/${t%%/*} # looks like a POSIX filepath
[ -e "$t" ] ;; #(
*) false ;;
esac
then
arg=$( cygpath --path --ignore --mixed "$arg" )
fi
# Roll the args list around exactly as many times as the number of
# args, so each arg winds up back in the position where it started, but
# possibly modified.
#
# NB: a `for` loop captures its iteration list before it begins, so
# changing the positional parameters here affects neither the number of
# iterations, nor the values presented in `arg`.
shift # remove old arg
set -- "$@" "$arg" # push replacement arg
done
fi
# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
# Collect all arguments for the java command:
# * DEFAULT_JVM_OPTS, JAVA_OPTS, and optsEnvironmentVar are not allowed to contain shell fragments,
# and any embedded shellness will be escaped.
# * For example: A user cannot expect ${Hostname} to be expanded, as it is an environment variable and will be
# treated as '${Hostname}' itself on the command line.
set -- \
"-Dorg.gradle.appname=$APP_BASE_NAME" \
-jar "$APP_HOME/gradle/wrapper/gradle-wrapper.jar" \
"$@"
# Stop when "xargs" is not available.
if ! command -v xargs >/dev/null 2>&1
then
die "xargs is not available"
fi
# Use "xargs" to parse quoted args.
#
# With -n1 it outputs one arg per line, with the quotes and backslashes removed.
#
# In Bash we could simply go:
#
# readarray ARGS < <( xargs -n1 <<<"$var" ) &&
# set -- "${ARGS[@]}" "$@"
#
# but POSIX shell has neither arrays nor command substitution, so instead we
# post-process each arg (as a line of input to sed) to backslash-escape any
# character that might be a shell metacharacter, then use eval to reverse
# that process (while maintaining the separation between arguments), and wrap
# the whole thing up as a single "set" statement.
#
# This will of course break if any of these variables contains a newline or
# an unmatched quote.
#
eval "set -- $(
printf '%s\n' "$DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS" |
xargs -n1 |
sed ' s~[^-[:alnum:]+,./:=@_]~\\&~g; ' |
tr '\n' ' '
)" '"$@"'
exec "$JAVACMD" "$@"

93
gradlew.bat vendored Normal file
View File

@@ -0,0 +1,93 @@
@rem
@rem Copyright 2015 the original author or authors.
@rem
@rem Licensed under the Apache License, Version 2.0 (the "License");
@rem you may not use this file except in compliance with the License.
@rem You may obtain a copy of the License at
@rem
@rem https://www.apache.org/licenses/LICENSE-2.0
@rem
@rem Unless required by applicable law or agreed to in writing, software
@rem distributed under the License is distributed on an "AS IS" BASIS,
@rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
@rem See the License for the specific language governing permissions and
@rem limitations under the License.
@rem
@rem SPDX-License-Identifier: Apache-2.0
@rem
@if "%DEBUG%"=="" @echo off
@rem ##########################################################################
@rem
@rem Gradle startup script for Windows
@rem
@rem ##########################################################################
@rem Set local scope for the variables with windows NT shell
if "%OS%"=="Windows_NT" setlocal
set DIRNAME=%~dp0
if "%DIRNAME%"=="" set DIRNAME=.
@rem This is normally unused
set APP_BASE_NAME=%~n0
set APP_HOME=%DIRNAME%
@rem Resolve any "." and ".." in APP_HOME to make it shorter.
for %%i in ("%APP_HOME%") do set APP_HOME=%%~fi
@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m"
@rem Find java.exe
if defined JAVA_HOME goto findJavaFromJavaHome
set JAVA_EXE=java.exe
%JAVA_EXE% -version >NUL 2>&1
if %ERRORLEVEL% equ 0 goto execute
echo. 1>&2
echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. 1>&2
echo. 1>&2
echo Please set the JAVA_HOME variable in your environment to match the 1>&2
echo location of your Java installation. 1>&2
goto fail
:findJavaFromJavaHome
set JAVA_HOME=%JAVA_HOME:"=%
set JAVA_EXE=%JAVA_HOME%/bin/java.exe
if exist "%JAVA_EXE%" goto execute
echo. 1>&2
echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME% 1>&2
echo. 1>&2
echo Please set the JAVA_HOME variable in your environment to match the 1>&2
echo location of your Java installation. 1>&2
goto fail
:execute
@rem Setup the command line
@rem Execute Gradle
"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -jar "%APP_HOME%\gradle\wrapper\gradle-wrapper.jar" %*
:end
@rem End local scope for the variables with windows NT shell
if %ERRORLEVEL% equ 0 goto mainEnd
:fail
rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
rem the _cmd.exe /c_ return code!
set EXIT_CODE=%ERRORLEVEL%
if %EXIT_CODE% equ 0 set EXIT_CODE=1
if not ""=="%GRADLE_EXIT_CONSOLE%" exit %EXIT_CODE%
exit /b %EXIT_CODE%
:mainEnd
if "%OS%"=="Windows_NT" endlocal
:omega

1144
logs/app.log Normal file

File diff suppressed because it is too large Load Diff

1
settings.gradle Normal file
View File

@@ -0,0 +1 @@
rootProject.name = 'notihub-server'

View File

@@ -0,0 +1,33 @@
package com.kri.notihub.server;
import lombok.extern.slf4j.Slf4j;
import org.springframework.boot.ApplicationRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.Bean;
@Slf4j
@SpringBootApplication
public class NotihubServerApplication {
public static void main(String[] args) {
SpringApplication.run(NotihubServerApplication.class, args);
}
@Bean
ApplicationRunner dsCheck(ApplicationContext ctx) {
return args -> {
String[] names = ctx.getBeanNamesForType(javax.sql.DataSource.class);
log.info("DataSource beans = {}", java.util.Arrays.toString(names));
for (String n : names) {
Object ds = ctx.getBean(n);
log.info(" - {} = {}", n, ds.getClass().getName());
if (ds instanceof com.zaxxer.hikari.HikariDataSource hk) {
log.info(" jdbcUrl=" + hk.getJdbcUrl());
log.info(" driver=" + hk.getDriverClassName());
}
}
};
}
}

View File

@@ -0,0 +1,34 @@
package com.kri.notihub.server.common.consts;
import com.kri.notihub.server.common.enums.SendType;
import java.util.List;
public final class NotihubConst {
private NotihubConst() {}
public static final int OUTSOURCE_USER_ROLE = 4000;
public static final int CHUNK_SIZE = 5_000;
public static final int INSERT_CHUNK_SIZE = 1_000;
public static final short EMAIL_RESULT_SEARCH_DELAY = 500;
public static final short EMAIL_DELAY = 500;
public static final short DELAY_MAX_MS = (short)5_000; // 필요시 조정
public static final List<SendType> MOBILE_TYPE_LIST = List.of(SendType.SMS, SendType.LMS_MMS);
public static final String EMAIL_RESERVATION_PREFIX = "RESERVATION_";
public static final short EMAIL_STANDBY = 100;
public static final short EMAIL_PENDING = (short) 111; // 발송요청은 성공했으나 json_return 미조회
public static final short EMAIL_SEND_FAIL = (short) 109; // 발송요청 실패(또는 return_key 미수신)
public static final short EMAIL_NOT_RESULT = (short) 119; // json_return 조회 실패/결과없음(최종상태 확보 실패)
public static final short EMAIL_SUCCESS = 250;
public static final short SMS_STANDBY = 4000;
public static final short SMS_SUCCESS = 4100;
public static final short SMS_NOT_RESULT = 9999;
public static final short LMS_MMS_STANDBY = 6000;
public static final short LMS_MMS_SUCCESS = 6600;
}

View File

@@ -0,0 +1,25 @@
package com.kri.notihub.server.common.enums;
import com.fasterxml.jackson.annotation.JsonCreator;
import com.fasterxml.jackson.annotation.JsonValue;
import com.kri.common.enums.CodeEnum;
import lombok.Getter;
import lombok.RequiredArgsConstructor;
@Getter(onMethod_ = @JsonValue)
@RequiredArgsConstructor
public enum SendCorpType implements CodeEnum<Short> {
PRINGO((short) 1001),
BIZ_PPURIO((short) 2001);
private final Short code;
@JsonCreator(mode = JsonCreator.Mode.DELEGATING)
public static SendCorpType fromCode(Short code) {
if (code == null) return null;
for (SendCorpType s : values()) {
if (s.code == code) return s;
}
throw new IllegalArgumentException("Unknown SendCorpType code: " + code);
}
}

View File

@@ -0,0 +1,24 @@
package com.kri.notihub.server.common.enums;
import com.fasterxml.jackson.annotation.JsonCreator;
import com.fasterxml.jackson.annotation.JsonValue;
import com.kri.common.enums.CodeEnum;
import lombok.Getter;
import lombok.RequiredArgsConstructor;
@Getter(onMethod_ = @JsonValue)
@RequiredArgsConstructor
public enum SendEmailType implements CodeEnum<Short> {
EMAIL((short) 11);
private final Short code;
@JsonCreator(mode = JsonCreator.Mode.DELEGATING)
public static SendEmailType fromCode(Short code) {
if (code == null) return null;
for (SendEmailType s : values()) {
if (s.code == code) return s;
}
throw new IllegalArgumentException("Unknown SendEmailType code: " + code);
}
}

View File

@@ -0,0 +1,25 @@
package com.kri.notihub.server.common.enums;
import com.fasterxml.jackson.annotation.JsonCreator;
import com.fasterxml.jackson.annotation.JsonValue;
import com.kri.common.enums.CodeEnum;
import lombok.Getter;
import lombok.RequiredArgsConstructor;
@Getter(onMethod_ = @JsonValue)
@RequiredArgsConstructor
public enum SendSmsType implements CodeEnum<Short> {
SMS((short) 21),
LMS_MMS((short) 22);
private final Short code;
@JsonCreator(mode = JsonCreator.Mode.DELEGATING)
public static SendSmsType fromCode(Short code) {
if (code == null) return null;
for (SendSmsType s : values()) {
if (s.code == code) return s;
}
throw new IllegalArgumentException("Unknown SendSmsType code: " + code);
}
}

View File

@@ -0,0 +1,31 @@
package com.kri.notihub.server.common.enums;
import com.fasterxml.jackson.annotation.JsonCreator;
import com.fasterxml.jackson.annotation.JsonValue;
import com.kri.common.enums.CodeEnum;
import lombok.Getter;
import lombok.RequiredArgsConstructor;
@Getter(onMethod_ = @JsonValue)
@RequiredArgsConstructor
public enum SendStatusType implements CodeEnum<Short> {
STANDBY((short) 0),
SUCCESS((short) 1),
FAIL((short) 9);
private final Short code;
SendStatusType(CodeEnum<Short> source) {
this.code = source.getCode();
}
@JsonCreator(mode = JsonCreator.Mode.DELEGATING)
public static SendStatusType fromCode(Short code) {
if (code == null) return null;
for (SendStatusType s : values()) {
if (s.code == code) return s;
}
throw new IllegalArgumentException("Unknown SendStatusType code: " + code);
}
}

View File

@@ -0,0 +1,30 @@
package com.kri.notihub.server.common.enums;
import com.fasterxml.jackson.annotation.JsonCreator;
import com.fasterxml.jackson.annotation.JsonValue;
import com.kri.common.enums.CodeEnum;
import lombok.Getter;
import lombok.RequiredArgsConstructor;
@Getter(onMethod_ = @JsonValue)
@RequiredArgsConstructor
public enum SendType implements CodeEnum<Short> {
EMAIL(SendEmailType.EMAIL),
SMS(SendSmsType.SMS),
LMS_MMS(SendSmsType.LMS_MMS);
private final Short code;
SendType(CodeEnum<Short> source) {
this.code = source.getCode();
}
@JsonCreator(mode = JsonCreator.Mode.DELEGATING)
public static SendType fromCode(Short code) {
if (code == null) return null;
for (SendType s : values()) {
if (s.code == code) return s;
}
throw new IllegalArgumentException("Unknown SendType code: " + code);
}
}

View File

@@ -0,0 +1,16 @@
package com.kri.notihub.server.common.enums;
import com.kri.common.enums.CodeEnum;
import lombok.Getter;
import lombok.RequiredArgsConstructor;
@Getter
@RequiredArgsConstructor
public enum TemplateEventType implements CodeEnum<Short> {
CREATE_TEMPLATE((short) 0), // 프로젝트 생성
UPDATE_TEMPLATE((short) 1), // 프로젝트 수정
DELETE_TEMPLATE((short) 2); // 프로젝트 삭제
private final Short code;
}

View File

@@ -0,0 +1,165 @@
package com.kri.notihub.server.common.external.pringo;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.kri.common.http.ExternalApiClient;
import com.kri.common.http.ExternalApiResponse;
import com.kri.notihub.server.common.external.pringo.dto.*;
import lombok.RequiredArgsConstructor;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
@Component
@RequiredArgsConstructor
public class PringoApiClient {
@Value("${kri.api.pringo.url}")
private String pringoBaseUrl;
@Value("${kri.api.pringo.apiKey}")
private String apiKey;
@Value("${kri.api.pringo.template-id}")
private String templateId;
private final ExternalApiClient externalApiClient = new ExternalApiClient();
private final ObjectMapper objectMapper = new ObjectMapper();
/**
* Pringo 자동메일 Json 발송
* POST {pringoBaseUrl}/json-send
*/
public PringoJsonSendResponseDto jsonSend(PringoJsonSendRequestDto request) {
String url = String.format("%s/json-send", pringoBaseUrl);
// defaults 주입
request.applyDefaults(apiKey, templateId);
// 필수값 검증(Pringo 실패 케이스 사전 차단)
request.validateRequired();
Map<String, String> headers = new HashMap<>();
headers.put("Content-Type", "application/json");
headers.put("Accept", "application/json");
try {
String body = objectMapper.writeValueAsString(request);
ExternalApiResponse response = externalApiClient.post(url, headers, body);
return objectMapper.readValue(response.getBody(), PringoJsonSendResponseDto.class);
} catch (JsonProcessingException e) {
// 프로젝트 스타일에 맞게 BusinessException으로 바꿔도 됨
throw new IllegalStateException("Failed to call Pringo json-send API.", e);
}
}
/**
* 편의 메서드: vars 포함해서 바로 발송
*/
public PringoJsonSendResponseDto jsonSend(
String sender,
String senderName,
String recipient,
String recipientName,
String subject,
String htmlBody,
Map<String, Object> vars
) {
PringoJsonSendRequestDto req = PringoJsonSendRequestDto.builder()
.sender(sender)
.senderName(senderName)
.recipient(recipient)
.recipientName(recipientName)
.subject(subject)
.body(htmlBody)
.build();
if (vars != null) {
vars.forEach(req::putVar);
}
return jsonSend(req);
}
/**
* Pringo 자동메일 Json 조회
* POST {pringoBaseUrl}/json-return
*/
public PringoJsonReturnResponseDto jsonReturn(PringoJsonReturnRequestDto request) {
String url = String.format("%s/json-return", pringoBaseUrl);
request.applyDefaults(apiKey, templateId);
request.validateRequired();
Map<String, String> headers = new HashMap<>();
headers.put("Content-Type", "application/json");
headers.put("Accept", "application/json");
try {
String body = objectMapper.writeValueAsString(request);
ExternalApiResponse response = externalApiClient.post(url, headers, body);
// 응답은 항상 배열 형태
JsonNode root = objectMapper.readTree(response.getBody());
if (root == null || !root.isArray() || root.size() == 0) {
// 비정상/빈 응답 방어
return PringoJsonReturnResponseDto.builder()
.itemList(List.of())
.error(PringoJsonReturnErrorDtoBuilder.noResultFallback())
.build();
}
JsonNode first = root.get(0);
// 실패 형태 판별: result/msg가 있으면 오류 DTO로 본다
if (first.has("result") && first.has("msg")) {
PringoJsonReturnErrorDto err = objectMapper.convertValue(first, PringoJsonReturnErrorDto.class);
return PringoJsonReturnResponseDto.builder()
.itemList(List.of())
.error(err)
.build();
}
// 성공 형태: row 리스트
List<PringoJsonReturnItemDto> items = objectMapper.convertValue(
root, new TypeReference<List<PringoJsonReturnItemDto>>() {}
);
return PringoJsonReturnResponseDto.builder()
.itemList(items)
.error(null)
.build();
} catch (JsonProcessingException e) {
throw new IllegalStateException("Failed to call Pringo json-return API.", e);
}
}
/** 편의 메서드: returnKey만으로 조회 */
public PringoJsonReturnResponseDto jsonReturn(String returnKey) {
PringoJsonReturnRequestDto req = PringoJsonReturnRequestDto.builder()
.returnKey(returnKey)
.build();
return jsonReturn(req);
}
/** 편의 메서드: long도 지원 */
public PringoJsonReturnResponseDto jsonReturn(long returnKey) {
return jsonReturn(Long.toString(returnKey));
}
// 내부 fallback builder (원하시면 별도 클래스로 분리)
private static final class PringoJsonReturnErrorDtoBuilder {
static PringoJsonReturnErrorDto noResultFallback() {
PringoJsonReturnErrorDto e = new PringoJsonReturnErrorDto();
e.setResult("0");
e.setMsg("응답이 비어 있습니다.");
return e;
}
}
}

View File

@@ -0,0 +1,24 @@
package com.kri.notihub.server.common.external.pringo.dto;
import com.fasterxml.jackson.annotation.JsonProperty;
import lombok.Getter;
import lombok.Setter;
@Getter
@Setter
public class PringoJsonReturnErrorDto {
private String type;
@JsonProperty("typeAlias")
private String typeAlias;
/** 예: "0" */
private String result;
private String msg;
public boolean isNoResult() {
return "0".equals(result);
}
}

View File

@@ -0,0 +1,36 @@
package com.kri.notihub.server.common.external.pringo.dto;
import com.fasterxml.jackson.annotation.JsonProperty;
import lombok.Getter;
import lombok.Setter;
@Getter
@Setter
public class PringoJsonReturnItemDto {
@JsonProperty("No")
private Integer no;
@JsonProperty("return_key")
private Long returnKey;
@JsonProperty("email")
private String email;
/** "O" / "X" */
@JsonProperty("open")
private String open;
/** "O" / "X" */
@JsonProperty("send_success")
private String sendSuccess;
/** "yyyy-MM-dd HH:mm:ss" (문자열로 보관 권장) */
@JsonProperty("send_time")
private String sendTime;
/** ex) "250" */
@JsonProperty("status")
private String status;
}

View File

@@ -0,0 +1,32 @@
package com.kri.notihub.server.common.external.pringo.dto;
import com.fasterxml.jackson.annotation.JsonProperty;
import lombok.*;
@Getter
@Setter
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class PringoJsonReturnRequestDto {
@JsonProperty("api_key")
private String apiKey;
@JsonProperty("template_id")
private String templateId;
@JsonProperty("return_key")
private String returnKey;
public void applyDefaults(String defaultApiKey, String defaultTemplateId) {
if (this.apiKey == null || this.apiKey.isBlank()) this.apiKey = defaultApiKey;
if (this.templateId == null || this.templateId.isBlank()) this.templateId = defaultTemplateId;
}
public void validateRequired() {
if (apiKey == null || apiKey.isBlank()) throw new IllegalArgumentException("api_key is required.");
if (templateId == null || templateId.isBlank()) throw new IllegalArgumentException("template_id is required.");
if (returnKey == null || returnKey.isBlank()) throw new IllegalArgumentException("return_key is required.");
}
}

View File

@@ -0,0 +1,27 @@
package com.kri.notihub.server.common.external.pringo.dto;
import lombok.*;
import java.util.List;
@Getter
@Setter
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class PringoJsonReturnResponseDto {
/** 조회 결과 row들(성공 시) */
private List<PringoJsonReturnItemDto> itemList;
/** 조회 실패/없음(실패 시) */
private PringoJsonReturnErrorDto error;
public boolean isSuccess() {
return itemList != null && !itemList.isEmpty();
}
public boolean isNoResult() {
return error != null && error.isNoResult();
}
}

View File

@@ -0,0 +1,172 @@
package com.kri.notihub.server.common.external.pringo.dto;
import com.fasterxml.jackson.annotation.JsonAnyGetter;
import com.fasterxml.jackson.annotation.JsonAnySetter;
import com.fasterxml.jackson.annotation.JsonIgnore;
import com.fasterxml.jackson.annotation.JsonProperty;
import com.kri.notihub.server.dto.template.TemplateBasicDto;
import lombok.*;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Objects;
import java.util.Set;
@Getter
@Setter
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class PringoJsonSendRequestDto {
private static final Set<String> RESERVED_KEYS = Set.of(
"api_key", "template_id",
"sender", "sender_name",
"recipient", "recipient_name",
"subject", "body"
);
@JsonProperty("api_key")
private String apiKey;
@JsonProperty("template_id")
private String templateId;
/** sender email */
private String sender;
@JsonProperty("sender_name")
private String senderName;
@JsonProperty("recipient_name")
private String recipientName;
/** recipient email */
private String recipient;
/** subject */
private String subject;
/** html body */
private String body;
/**
* Pringo 템플릿 치환용 동적 변수
* 예) body: "...[$jstest]..."
* vars: {"jstest":"테스트 지롱~"}
*/
@JsonIgnore
@Builder.Default
private Map<String, Object> vars = new LinkedHashMap<>();
@JsonAnyGetter
public Map<String, Object> any() {
return vars;
}
@JsonAnySetter
public void setAny(String key, Object value) {
if (key == null) return;
if (RESERVED_KEYS.contains(key)) {
// 동적 변수로 reserved key를 덮어쓰는 실수를 방지
throw new IllegalArgumentException("Reserved key cannot be used as variable: " + key);
}
vars.put(key, value);
}
public void putVar(String key, Object value) {
setAny(key, value);
}
public PringoJsonSendRequestDto copy() {
return PringoJsonSendRequestDto.builder()
.apiKey(this.apiKey)
.templateId(this.templateId)
.sender(this.sender)
.senderName(this.senderName)
.recipient(this.recipient)
.recipientName(this.recipientName)
.subject(this.subject)
.body(this.body)
.vars(new java.util.LinkedHashMap<>(this.vars))
.build();
}
/**
* TemplateBasicDto -> Pringo 발송 DTO 기본 매핑
* - recipient/recipientName 은 템플릿에 없으므로 여기서는 비워두고 이후 세팅
*/
public static PringoJsonSendRequestDto from(TemplateBasicDto template, String sendName, String sendEmail) {
return from(template, sendName, sendEmail, null, null);
}
public static PringoJsonSendRequestDto from(TemplateBasicDto template, String sendName, String sendEmail, String recipient, String recipientName) {
Objects.requireNonNull(template, "template is required");
String sender = sendEmail != null && !sendEmail.isBlank() ? sendEmail : template.getSendEml();
String senderName = sendName != null && !sendName.isBlank() ? sendName : template.getSendNm();
return PringoJsonSendRequestDto.builder()
.sender(sender)
.senderName(senderName)
.recipient(recipient)
.recipientName(recipientName)
.subject(template.getTmplatTitle())
.body(template.getTmplatBody())
.build();
}
public static PringoJsonSendRequestDto of(
String sender,
String senderName,
String recipient,
String recipientName,
String subject,
String htmlBody
) {
return PringoJsonSendRequestDto.builder()
.sender(sender)
.senderName(senderName)
.recipient(recipient)
.recipientName(recipientName)
.subject(subject)
.body(htmlBody)
.build();
}
/** recipient를 나중에 세팅할 수 있게 체이닝용 */
public PringoJsonSendRequestDto withRecipient(String recipient, String recipientName) {
this.recipient = recipient;
this.recipientName = recipientName;
return this;
}
public void applyDefaults(String defaultApiKey, String defaultTemplateId) {
if (this.apiKey == null || this.apiKey.isBlank()) this.apiKey = defaultApiKey;
if (this.templateId == null || this.templateId.isBlank()) this.templateId = defaultTemplateId;
}
public void validateRequired() {
if (apiKey == null || apiKey.isBlank()) {
throw new IllegalArgumentException("api_key is required.");
}
if (templateId == null || templateId.isBlank()) {
throw new IllegalArgumentException("template_id is required.");
}
if (sender == null || sender.isBlank()) {
throw new IllegalArgumentException("sender is required.");
}
if (senderName == null || senderName.isBlank()) {
throw new IllegalArgumentException("sender_name is required.");
}
if (recipient == null || recipient.isBlank()) {
throw new IllegalArgumentException("recipient is required.");
}
if (subject == null || subject.isBlank()) {
throw new IllegalArgumentException("subject is required.");
}
if (body == null || body.isBlank()) {
throw new IllegalArgumentException("body is required.");
}
}
}

View File

@@ -0,0 +1,34 @@
package com.kri.notihub.server.common.external.pringo.dto;
import com.fasterxml.jackson.annotation.JsonProperty;
import lombok.Getter;
import lombok.Setter;
@Getter
@Setter
public class PringoJsonSendResponseDto {
private String type;
@JsonProperty("typeAlias")
private String typeAlias;
/**
* 성공: 1
* 실패: "-1"
* (API가 숫자/문자 둘 다 줄 수 있으니 String으로 받는 편이 안전)
*/
@JsonProperty("result")
private String result;
@JsonProperty("msg")
private String msg;
/** 응답 JSON 오타 그대로 "retrun_key" */
@JsonProperty("retrun_key")
private Long returnKey;
public boolean isSuccess() {
return "1".equals(result);
}
}

View File

@@ -0,0 +1,150 @@
package com.kri.notihub.server.common.util;
import com.kri.notihub.server.common.enums.SendType;
import com.kri.notihub.server.dto.template.TemplateBasicDto;
import org.jsoup.Jsoup;
import org.jsoup.safety.Safelist;
import org.jsoup.nodes.Document;
import java.nio.charset.StandardCharsets;
public final class TemplateContentSanitizer {
// 필요 시 시스템 정책에 맞게 조정
// (KOR 환경에서 SMS는 바이트 기준으로 제한을 두는 경우가 흔함)
private static final int SMS_MAX_BYTES_UTF8 = 90;
private TemplateContentSanitizer() {}
private static int utf8ByteLength(String s) {
if (s == null) return 0;
return s.getBytes(StandardCharsets.UTF_8).length;
}
private static boolean isBlank(String s) {
return s == null || s.isBlank();
}
/** title은 최대 128자(코드포인트 기준)로 절단 */
private static String truncateTo128CodePoints(String s) {
if (s == null) return null;
String trimmed = s.trim();
int cpCount = trimmed.codePointCount(0, trimmed.length());
if (cpCount <= 128) return trimmed;
int end = trimmed.offsetByCodePoints(0, 128);
return trimmed.substring(0, end);
}
/** 제어문자 제거(개행/탭은 옵션), 줄바꿈은 \n 으로 통일 */
private static String normalizeControls(String s, boolean keepNewlines) {
if (s == null) return null;
String v = s.replace("\r\n", "\n").replace('\r', '\n');
if (keepNewlines) {
v = v.replaceAll("[\\p{Cntrl}&&[^\\n\\t]]", "");
} else {
v = v.replaceAll("\\p{Cntrl}", "");
}
return v;
}
/** EMAIL body: 안전한 HTML만 유지(스크립트/iframe 등 제거) */
private static String sanitizeEmailHtml(String html) {
if (html == null) return null;
Safelist safelist = Safelist.relaxed()
.addProtocols("a", "href", "http", "https", "mailto")
.addProtocols("img", "src", "http", "https");
Document.OutputSettings out = new Document.OutputSettings().prettyPrint(false);
String cleaned = Jsoup.clean(html, "", safelist, out);
cleaned = normalizeControls(cleaned, true);
return cleaned.trim();
}
/** SMS/LMS body: HTML -> 평문(개행 보존) */
private static String htmlToPlainTextPreserveNewlines(String html) {
if (html == null) return null;
String v = html;
v = v.replaceAll("(?i)<\\s*br\\s*/?\\s*>", "\n");
v = v.replaceAll("(?i)<\\s*/\\s*p\\s*>", "\n");
v = v.replaceAll("(?i)<\\s*/\\s*div\\s*>", "\n");
v = v.replaceAll("(?i)<\\s*/\\s*li\\s*>", "\n");
v = v.replaceAll("(?i)<\\s*/\\s*tr\\s*>", "\n");
Document doc = Jsoup.parse(v);
doc.outputSettings(new Document.OutputSettings().prettyPrint(false));
String text = doc.body() != null ? doc.body().wholeText() : doc.wholeText();
text = normalizeControls(text, true);
text = text.replaceAll("[ \\t\\f\\v]+", " ");
text = text.replaceAll("\\n{3,}", "\n\n");
return text.trim();
}
/**
* 1) tmplatTy별 치환/정리
* 2) (SMS/LMS_MMS) 치환 후 길이 기반으로 타입 재결정
* - SMS는 제목 저장 안 함
* - LMS_MMS는 본문 짧아도 제목 있으면 그대로 유지
*/
public static SanitizedTemplate sanitizeAndNormalize(SendType originalType, String title, String body) {
SendType type = originalType;
String outTitle = title;
String outBody = body;
// 1) 치환/정리
switch (originalType) {
case EMAIL -> {
// 제목: 헤더 인젝션 방지(개행 제거) + 128 제한
outTitle = normalizeControls(outTitle, false);
outTitle = outTitle.replace("\n", " ").trim();
outTitle = truncateTo128CodePoints(outTitle);
outBody = sanitizeEmailHtml(outBody);
}
case SMS, LMS_MMS -> {
// 평문화
outTitle = htmlToPlainTextPreserveNewlines(outTitle);
outTitle = truncateTo128CodePoints(outTitle);
outBody = htmlToPlainTextPreserveNewlines(outBody);
}
}
// 2) 타입 재결정(요청사항)
if (type == SendType.SMS) {
// SMS는 제목 저장 안 함
outTitle = null;
// 본문이 SMS 한도 초과면 LMS_MMS로 승격
if (utf8ByteLength(outBody) > SMS_MAX_BYTES_UTF8) {
type = SendType.LMS_MMS;
}
} else if (type == SendType.LMS_MMS) {
boolean hasTitle = !isBlank(outTitle);
// "LMS_MMS인데 본문이 짧으면 SMS로 강등"이 기본인데,
// 단, 제목이 있으면 본문이 짧아도 LMS_MMS 유지
if (!hasTitle && utf8ByteLength(outBody) <= SMS_MAX_BYTES_UTF8) {
type = SendType.SMS;
outTitle = null; // SMS는 제목 저장 안 함
}
}
return new SanitizedTemplate(type, outTitle, outBody);
}
public static void sanitizeAndNormalizeInPlace(TemplateBasicDto dto) {
SanitizedTemplate st = sanitizeAndNormalize(dto.getTmplatTy(), dto.getTmplatTitle(), dto.getTmplatBody());
dto.setTmplatTy(st.type());
dto.setTmplatTitle(st.title());
dto.setTmplatBody(st.body());
}
public record SanitizedTemplate(SendType type, String title, String body) {}
}

View File

@@ -0,0 +1,23 @@
package com.kri.notihub.server.config;
import jakarta.persistence.EntityManagerFactory;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import org.springframework.orm.jpa.JpaTransactionManager;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.annotation.EnableTransactionManagement;
@Configuration
@EnableTransactionManagement
public class DefaultTxConfig {
@Bean(name = "transactionManager")
@Primary
public PlatformTransactionManager transactionManager(
@Qualifier("entityManagerFactory") EntityManagerFactory emf
) {
return new JpaTransactionManager(emf);
}
}

View File

@@ -0,0 +1,47 @@
package com.kri.notihub.server.controller;
import com.kri.common.webmvc.RequestUserContext;
import com.kri.common.webmvc.page.PageRequestDto;
import com.kri.common.webmvc.page.PageResponseDto;
import com.kri.notihub.server.common.consts.NotihubConst;
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.service.ReportService;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.tags.Tag;
import jakarta.validation.Valid;
import lombok.RequiredArgsConstructor;
import org.springframework.web.bind.annotation.*;
import java.util.List;
@RestController
@RequestMapping("/api/v1/report")
@RequiredArgsConstructor
@Tag(name = "Report", description = "발송 정보/결과 조회")
public class ReportController {
private final ReportService reportService;
@Operation(summary = "대량 발송 리스트 조회")
@GetMapping("/bulk-list/{sendTy}/{reqstSvc}/{prjctCd}")
public List<BulkSendInfoDto> getBulkSendList(
@PathVariable SendType sendTy,
@PathVariable String reqstSvc,
@PathVariable String prjctCd,
RequestUserContext ctx
){
String regCmpn = ctx.getUserRole() < NotihubConst.OUTSOURCE_USER_ROLE ? null : ctx.getUserCmpn();
return reportService.getBulkSendList(sendTy, reqstSvc, prjctCd, regCmpn);
}
@Operation(summary = "이메일 발송 리스트 조회")
@PostMapping("/bulk-detail/{bulkSendKey}")
public PageResponseDto<SendInfoDto> getBulkSendDetail(
@PathVariable String bulkSendKey,
@Valid @RequestBody PageRequestDto pageReq
){
return reportService.getBulkSendDetail(bulkSendKey, pageReq);
}
}

View File

@@ -0,0 +1,50 @@
package com.kri.notihub.server.controller;
import com.kri.common.webmvc.RequestUserContext;
import com.kri.notihub.server.dto.send.*;
import com.kri.notihub.server.service.EmailResultPoller;
import com.kri.notihub.server.service.SendEmailService;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.tags.Tag;
import jakarta.validation.Valid;
import lombok.RequiredArgsConstructor;
import org.springframework.web.bind.annotation.*;
@RestController
@RequestMapping("/api/v1/send-email")
@RequiredArgsConstructor
@Tag(name = "Send Email", description = "이메일 발송 API")
public class SendEmailController {
//발송 타입은 템플릿에 있음
private final SendEmailService sendEmailService;
private final EmailResultPoller emailResultPoller;
@Operation(summary = "Email 결과조회 Poller 큐(cmid=return_key) 목록 조회")
@GetMapping("/queue")
public EmailPollQueueResponseDto getQueue() {
return emailResultPoller.snapshotQueue();
}
@Operation(summary = "벌크 발송키 생성")
@PutMapping("/create/bulk")
public String createBulkSendKey(@Valid @RequestBody BulkSendCreateRequestDto req) {
return sendEmailService.issueBulkKey(req);
}
@Operation(summary = "이메일 단건 발송")
@PostMapping("/single")
public void sendSingle(
@Valid @RequestBody SendRequestSingleDto req,
RequestUserContext ctx
) {
sendEmailService.doSendSingle(req, ctx.getUserCmpn(), ctx.getUserId());
}
@Operation(summary = "bulkSendKey 기반 이메일 벌크 발송")
@PostMapping("/bulk")
public BulkSendResponseDto sendBulk(
@Valid @RequestBody SendRequestBulkDto req
) {
return sendEmailService.doSendBulk(req);
}
}

View File

@@ -0,0 +1,50 @@
package com.kri.notihub.server.controller;
import com.kri.common.webmvc.RequestUserContext;
import com.kri.notihub.server.dto.send.*;
import com.kri.notihub.server.service.SendSmsService;
import com.kri.notihub.server.service.SmsSendCursorStore;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.tags.Tag;
import jakarta.validation.Valid;
import lombok.RequiredArgsConstructor;
import org.springframework.web.bind.annotation.*;
@RestController
@RequestMapping("/api/v1/send-sms")
@RequiredArgsConstructor
@Tag(name = "Send SMS", description = "문자 발송 API")
public class SendSmsController {
private final SendSmsService sendSmsService;
private final SmsSendCursorStore cursorStore;
@Operation(summary = "SMS 결과 반영 커서(send_idx) 조회")
@GetMapping("/cursor")
public SmsCursorResponseDto getCursor() {
return SmsCursorResponseDto.of(cursorStore.get());
}
@Operation(summary = "벌크 발송키 생성")
@PutMapping("/create/bulk")
public String createBulkSendKey(@Valid @RequestBody BulkSendCreateRequestDto req) {
return sendSmsService.issueBulkKey(req);
}
@Operation(summary = "문자 단건 발송")
@PostMapping("/single")
public void sendSingle(
@Valid @RequestBody SendRequestSingleDto req,
RequestUserContext ctx
) {
sendSmsService.doSendSingle(req, ctx.getUserCmpn(), ctx.getUserId());
}
@Operation(summary = "bulkSendKey 기반 문자 벌크 발송")
@PostMapping("/bulk")
public BulkSendResponseDto sendBulk(
@Valid @RequestBody SendRequestBulkDto req
) {
return sendSmsService.doSendBulk(req);
}
}

View File

@@ -0,0 +1,81 @@
package com.kri.notihub.server.controller;
import com.kri.common.webmvc.RequestUserContext;
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.service.FileService;
import com.kri.notihub.server.service.TemplateService;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.tags.Tag;
import jakarta.validation.Valid;
import lombok.RequiredArgsConstructor;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;
import java.util.List;
@RestController
@RequestMapping("/api/v1/template")
@RequiredArgsConstructor
@Tag(name = "Template", description = "템플릿 API")
public class TemplateController {
private final TemplateService templateService;
private final FileService fileService;
@Operation(summary = "템플릿 목록 조회")
@GetMapping("/list/{itrntPrjctCd}")
public List<TemplateSummaryDto> getTemplateList(@PathVariable String itrntPrjctCd) {
return templateService.getTemplateList(itrntPrjctCd);
}
@Operation(summary = "템플릿 단건 조회")
@GetMapping("/{tmplatIdx}")
public TemplateDto getTemplate(@PathVariable long tmplatIdx) {
return templateService.getTemplate(tmplatIdx);
}
@Operation(summary = "템플릿 생성")
@PutMapping("/{itrntPrjctCd}")
public long createTemplate(
@PathVariable String itrntPrjctCd,
@Valid @RequestBody TemplateBasicDto template,
RequestUserContext ctx
) {
String newHtml = fileService.syncOnSave(
itrntPrjctCd,
template.getTmplatBody()
);
template.setTmplatBody(newHtml);
return templateService.createTemplate(itrntPrjctCd, template, ctx.getUserId());
}
@Operation(summary = "시나리오 이미지 업로드")
@PutMapping("/body-image/{itrntPrjctCd}")
public String uploadContactSenarioImage(@PathVariable String itrntPrjctCd, @RequestParam("file") MultipartFile file) {
return fileService.storeTempFile(itrntPrjctCd, file);
}
@Operation(summary = "템플릿 수정")
@PatchMapping()
public TemplateDto updateTemplate(
@Valid @RequestBody TemplateDto template,
RequestUserContext ctx
) {
String newHtml = fileService.syncOnSave(
template.getItrntPrjctCd(),
template.getTmplatBody()
);
template.setTmplatBody(newHtml);
return templateService.updateTemplate(template, ctx.getUserId());
}
@Operation(summary = "템플릿 삭제(소프트 삭제)")
@DeleteMapping("/{tmplatIdx}")
public void deleteTemplate(@PathVariable long tmplatIdx, RequestUserContext ctx) {
templateService.deleteTemplate(tmplatIdx, ctx.getUserId());
}
}

View File

@@ -0,0 +1,99 @@
package com.kri.notihub.server.dto.report;
import com.fasterxml.jackson.annotation.JsonProperty;
import com.kri.notihub.server.persistence.entity.TBulkSendEntity;
import io.swagger.v3.oas.annotations.media.Schema;
import jakarta.validation.constraints.NotBlank;
import jakarta.validation.constraints.NotNull;
import jakarta.validation.constraints.Size;
import lombok.*;
import java.time.LocalDateTime;
@Getter
@Setter
@Builder
@NoArgsConstructor
@AllArgsConstructor
@Schema(description = "대량발송 정보")
public class BulkSendInfoDto {
@Size(max = 32)
@NotBlank
@Schema(description = "대량발송 키", accessMode = Schema.AccessMode.READ_ONLY)
@JsonProperty(access = JsonProperty.Access.READ_ONLY)
private String bulkSendKey;
@Size(max = 16)
@NotBlank
@Schema(description = "요청 서비스")
private String reqstSvc;
@Size(max = 32)
@NotBlank
@Schema(description = "프로젝트 코드")
private String prjctCd;
@Schema(description = "템플릿 인덱스")
private Long tmplatIdx;
@NotNull
@Schema(description = "예약 여부")
private Boolean resve;
@NotNull
@Schema(description = "발송일시")
private LocalDateTime sendDt;
@NotNull
@Schema(description = "대상 건수")
private Integer trgtCnt;
@NotNull
@Schema(description = "발송 건수", accessMode = Schema.AccessMode.READ_ONLY)
@JsonProperty(access = JsonProperty.Access.READ_ONLY)
private Integer sendCnt;
@NotNull
@Schema(description = "성공 건수", accessMode = Schema.AccessMode.READ_ONLY)
@JsonProperty(access = JsonProperty.Access.READ_ONLY)
private Integer succesCnt;
@NotNull
@Schema(description = "실패 건수", accessMode = Schema.AccessMode.READ_ONLY)
@JsonProperty(access = JsonProperty.Access.READ_ONLY)
private Integer failCnt;
@Schema(description = "완료일시", accessMode = Schema.AccessMode.READ_ONLY)
@JsonProperty(access = JsonProperty.Access.READ_ONLY)
private LocalDateTime completeDt;
@Size(max = 32)
@Schema(description = "등록자", accessMode = Schema.AccessMode.READ_ONLY)
@JsonProperty(access = JsonProperty.Access.READ_ONLY)
private String regUser;
@Schema(description = "등록일시", accessMode = Schema.AccessMode.READ_ONLY)
@JsonProperty(access = JsonProperty.Access.READ_ONLY)
private LocalDateTime regDt;
public static BulkSendInfoDto from(TBulkSendEntity entity) {
if (entity == null) return null;
return BulkSendInfoDto.builder()
.bulkSendKey(entity.getBulkSendKey())
.reqstSvc(entity.getReqstSvc())
.prjctCd(entity.getPrjctCd())
.tmplatIdx(entity.getTmplatIdx())
.resve(entity.getResve() != null ? entity.getResve() : Boolean.FALSE)
.sendDt(entity.getSendDt())
.trgtCnt(entity.getTrgtCnt())
.sendCnt(entity.getSendCnt())
.succesCnt(entity.getSuccesCnt())
.failCnt(entity.getFailCnt())
.completeDt(entity.getCompleteDt())
.regUser(entity.getRegUser())
.regDt(entity.getRegDt())
.build();
}
}

View File

@@ -0,0 +1,131 @@
package com.kri.notihub.server.dto.report;
import com.kri.notihub.server.common.enums.SendType;
import com.kri.notihub.server.persistence.entity.TSendEntity;
import io.swagger.v3.oas.annotations.media.Schema;
import jakarta.validation.constraints.NotBlank;
import jakarta.validation.constraints.NotNull;
import jakarta.validation.constraints.Size;
import lombok.*;
import java.time.LocalDateTime;
@Getter
@Setter
@Builder
@NoArgsConstructor
@AllArgsConstructor
@Schema(description = "발송 정보")
public class SendInfoDto {
@Size(max = 32)
@NotBlank
@Schema(description = "CMID")
private String cmid;
@Size(max = 32)
@Schema(description = "대량발송 키")
private String bulkSendKey;
@NotNull
@Schema(description = "발송 타입 코드")
private Short sendTy;
@NotNull
@Schema(description = "예약 여부")
private Boolean resve;
@NotNull
@Schema(description = "발송 상태 코드")
private Short sendStatus;
@NotNull
@Schema(description = "결과 코드")
private Short resultCode;
@Size(max = 16)
@NotBlank
@Schema(description = "요청 서비스")
private String reqstSvc;
@Size(max = 32)
@NotBlank
@Schema(description = "프로젝트 코드")
private String prjctCd;
@Schema(description = "템플릿 인덱스")
private Long tmplatIdx;
@Size(max = 64)
@Schema(description = "발신지(EMAIL이면 sendEml, 아니면 sendTel)")
private String sendFrom;
@Size(max = 32)
@Schema(description = "발신자명")
private String sendNm;
@NotNull
@Schema(description = "발송 일시")
private LocalDateTime sendDt;
@Size(max = 128)
@NotBlank
@Schema(description = "SID")
private String sid;
@Size(max = 64)
@Schema(description = "수신지(EMAIL이면 destEml, 아니면 destTel)")
private String destTo;
@Size(max = 32)
@Schema(description = "수신자명")
private String destNm;
@Schema(description = "리포트 일시")
private LocalDateTime reportDt;
@Size(max = 32)
@NotBlank
@Schema(description = "등록 회사")
private String regCmpn;
@Size(max = 32)
@NotBlank
@Schema(description = "등록자")
private String regUser;
@NotNull
@Schema(description = "등록일시")
private LocalDateTime regDt;
public static SendInfoDto from(TSendEntity entity) {
if (entity == null) return null;
boolean isEmail = entity.getSendTy() != null
&& entity.getSendTy().equals(SendType.EMAIL.getCode());
String sendFrom = isEmail ? entity.getSendEml() : entity.getSendTel();
String destTo = isEmail ? entity.getDestEml() : entity.getDestTel();
return SendInfoDto.builder()
.cmid(entity.getCmid())
.bulkSendKey(entity.getBulkSendKey())
.sendTy(entity.getSendTy())
.resve(entity.isResve())
.sendStatus(entity.getSendStatus())
.resultCode(entity.getResultCode())
.reqstSvc(entity.getReqstSvc())
.prjctCd(entity.getPrjctCd())
.tmplatIdx(entity.getTmplatIdx())
.sendFrom(sendFrom)
.sendNm(entity.getSendNm())
.sendDt(entity.getSendDt())
.sid(entity.getSid())
.destTo(destTo)
.destNm(entity.getDestNm())
.reportDt(entity.getReportDt())
.regUser(entity.getRegUser())
.regDt(entity.getRegDt())
.build();
}
}

View File

@@ -0,0 +1,52 @@
package com.kri.notihub.server.dto.send;
import com.fasterxml.jackson.annotation.JsonFormat;
import io.swagger.v3.oas.annotations.media.Schema;
import jakarta.validation.constraints.NotBlank;
import jakarta.validation.constraints.NotNull;
import jakarta.validation.constraints.Size;
import lombok.*;
import java.time.LocalDateTime;
@Getter
@Setter
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class BulkSendCreateRequestDto {
@NotBlank
@Schema(description = "발송 요청 서비스 (로그용)")
private String reqstSvc;
@Schema(description = "발송 요청 서비스의 프로젝트 코드 (로그용)")
private String prjctCd;
@NotNull
@Schema(description = "템플릿 idx")
private Long tmplatIdx;
@NotNull
@Builder.Default
@Schema(description = "예약 여부")
private Boolean resve = false;
@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
@Schema(description = "발송일시(미입력 시 현재 시간)")
private LocalDateTime sendDt;
@NotNull
@Schema(description = "대상자 수")
private Integer trgtCnt;
@Size(max = 32)
@NotBlank
@Schema(description = "발송 요청 회사")
String reqstCmpn;
@Size(max = 32)
@NotBlank
@Schema(description = "발송 요청자")
String reqstUser;
}

View File

@@ -0,0 +1,35 @@
package com.kri.notihub.server.dto.send;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Getter;
import lombok.NoArgsConstructor;
@Getter
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class BulkSendResponseDto {
@Schema(description = "bulkSendKey")
private String bulkSendKey;
@Schema(description = "요청 건수")
private Integer requestCount;
@Schema(description = "Pringo send 요청 성공(return_key 수신) 건수")
private Integer acceptCount;
@Schema(description = "Pringo send 요청 실패(return_key 미수신) 건수")
private Integer failCount;
public static BulkSendResponseDto of(String bulkSendKey, Integer requestCount, Integer acceptCount, Integer failCount) {
return BulkSendResponseDto.builder()
.bulkSendKey(bulkSendKey)
.requestCount(requestCount)
.acceptCount(acceptCount)
.failCount(failCount)
.build();
}
}

View File

@@ -0,0 +1,47 @@
package com.kri.notihub.server.dto.send;
import com.kri.notihub.server.persistence.entity.TSendEntity;
import io.swagger.v3.oas.annotations.media.Schema;
import jakarta.validation.constraints.Email;
import jakarta.validation.constraints.Size;
import lombok.*;
import java.util.Map;
@Getter
@Setter
@Builder
@NoArgsConstructor
@AllArgsConstructor
@Schema(description = "수신 정보")
public class DestInfoDto {
@Schema(description = "리스트 아이디")
private String sid;
@Size(max = 64)
@Email
@Schema(description = "수신 이메일 (이메일 발송에서 사용)")
private String destEml;
@Size(max = 16)
@Schema(description = "수신 전화번호 (문자 발송에서 사용)")
private String destTel;
@Size(max = 32)
@Schema(description = "수신자 이름")
private String destNm;
@Schema(description = "수신 파라미터 (템플릿 내용 파싱용)")
private Map<String, String> msgParam;
public static DestInfoDto from(TSendEntity entity) {
return DestInfoDto.builder()
.sid(entity.getSid())
.destEml(entity.getDestEml())
.destTel(entity.getDestTel())
.destNm(entity.getDestNm())
.msgParam(entity.getMsgParam())
.build();
}
}

View File

@@ -0,0 +1,41 @@
package com.kri.notihub.server.dto.send;
import com.fasterxml.jackson.annotation.JsonFormat;
import com.kri.common.datetime.DateTimeUtil;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Getter;
import lombok.NoArgsConstructor;
import java.time.Instant;
import java.time.LocalDateTime;
@Getter
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class EmailPollQueueItemDto {
@Schema(description = "Pringo return_key(cmid)")
private String cmid;
@Schema(description = "폴링 시도 횟수(0부터 시작)")
private Integer attempt;
@Schema(description = "구동까지 남은 시간(ms)")
private Long remainingMs;
@Schema(description = "구동 예상 시간(KST LocalDateTime)")
@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private LocalDateTime triggerAt;
public static EmailPollQueueItemDto of(String cmid, int attempt, long remainingMs, long triggerAtEpochMs) {
return EmailPollQueueItemDto.builder()
.cmid(cmid)
.attempt(attempt)
.remainingMs(remainingMs)
.triggerAt(DateTimeUtil.toKstLocalDateTime(Instant.ofEpochMilli(triggerAtEpochMs)))
.build();
}
}

View File

@@ -0,0 +1,28 @@
package com.kri.notihub.server.dto.send;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Getter;
import lombok.NoArgsConstructor;
import java.util.List;
@Getter
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class EmailPollQueueResponseDto {
@Schema(description = "Queue size (snapshot)")
private Integer size;
@Schema(description = "Queue에 있는 작업 내용 (snapshot)")
private List<EmailPollQueueItemDto> items;
public static EmailPollQueueResponseDto of(List<EmailPollQueueItemDto> items) {
return EmailPollQueueResponseDto.builder()
.size(items != null ? items.size() : 0)
.items(items)
.build();
}
}

View File

@@ -0,0 +1,28 @@
package com.kri.notihub.server.dto.send;
import com.kri.notihub.server.common.enums.SendStatusType;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.*;
@Getter
@Setter
@Builder
@NoArgsConstructor
@AllArgsConstructor
@Schema(description = "이메일/문자 발송 결과")
public class SendInternalResultDto {
private String cmid;
private SendStatusType status;
private Short resultCode;
public static SendInternalResultDto of(String cmid, SendStatusType status, short resultCode) {
return SendInternalResultDto.builder()
.cmid(cmid)
.status(status)
.resultCode(resultCode)
.build();
}
}

View File

@@ -0,0 +1,29 @@
package com.kri.notihub.server.dto.send;
import io.swagger.v3.oas.annotations.media.Schema;
import jakarta.validation.constraints.Email;
import jakarta.validation.constraints.NotNull;
import jakarta.validation.constraints.Size;
import lombok.*;
@Getter
@Setter
@Builder
@NoArgsConstructor
@AllArgsConstructor
@Schema(description = "발송 기본 정보")
public class SendRequestBasicDto {
@Size(max = 64)
@Email
@Schema(description = "발신 이메일 (이메일 발송에만 사용)")
private String sendEml;
@Size(max = 16)
@Schema(description = "발신 전화번호 (문자 발송에만 사용)")
private String sendTel;
@Size(max = 32)
@Schema(description = "발신 이름")
private String sendNm;
}

View File

@@ -0,0 +1,23 @@
package com.kri.notihub.server.dto.send;
import io.swagger.v3.oas.annotations.media.Schema;
import jakarta.validation.constraints.NotBlank;
import jakarta.validation.constraints.NotNull;
import jakarta.validation.constraints.Size;
import lombok.*;
import java.util.List;
@Getter
@Setter
@Schema(description = "일괄 발송 요청 정보")
public class SendRequestBulkDto extends SendRequestBasicDto {
@Size(max = 32)
@NotBlank
@Schema(description = "일괄 발송 고유키")
String bulkSendKey;
@NotNull
@Schema(description = "수신자 정보")
List<DestInfoDto> destInfoList;
}

View File

@@ -0,0 +1,40 @@
package com.kri.notihub.server.dto.send;
import com.fasterxml.jackson.annotation.JsonFormat;
import com.kri.common.datetime.LenientLocalDateTime;
import io.swagger.v3.oas.annotations.media.Schema;
import jakarta.validation.constraints.NotBlank;
import jakarta.validation.constraints.NotNull;
import lombok.*;
import java.time.LocalDateTime;
@Getter
@Setter
@Schema(description = "단건 발송 요청 정보")
public class SendRequestSingleDto extends SendRequestBasicDto {
@NotNull
@Schema(description = "발송 템플릿")
private long tmplatIdx;
@NotBlank
@Schema(description = "발송 요청 서비스 (로그용)")
private String reqstSvc;
@Schema(description = "발송 요청 서비스의 프로젝트 코드 (로그용)")
private String prjctCd;
@NotNull
@Schema(description = "예약 여부")
private Boolean resve = false;
@Schema(description = "발송 희망 시간 (비어있는 경우 즉시)")
@LenientLocalDateTime
@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private LocalDateTime sendDt;
@NotNull
@Schema(description = "수신자 정보")
DestInfoDto destInfo;
}

View File

@@ -0,0 +1,23 @@
package com.kri.notihub.server.dto.send;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Getter;
import lombok.NoArgsConstructor;
@Getter
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class SmsCursorResponseDto {
@Schema(description = "SMS 결과 반영 스케줄러 커서(send_idx)")
private Long cursor;
public static SmsCursorResponseDto of(long cursor) {
return SmsCursorResponseDto.builder()
.cursor(cursor)
.build();
}
}

View File

@@ -0,0 +1,55 @@
package com.kri.notihub.server.dto.template;
import com.kri.notihub.server.common.enums.SendType;
import io.swagger.v3.oas.annotations.media.Schema;
import jakarta.validation.constraints.Email;
import jakarta.validation.constraints.NotBlank;
import jakarta.validation.constraints.NotNull;
import jakarta.validation.constraints.Size;
import lombok.AllArgsConstructor;
import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.Setter;
import lombok.experimental.SuperBuilder;
@Getter
@Setter
@SuperBuilder
@NoArgsConstructor
@AllArgsConstructor
public class TemplateBasicDto {
@NotNull
@Schema(description = "템플릿 타입")
public SendType tmplatTy;
@Size(max = 32)
@NotBlank
@Schema(description = "템플릿 명")
public String tmplatNm;
@Size(max = 128)
@Schema(description = "발송시 제목")
public String tmplatTitle;
@NotBlank
@Schema(description = "발송 내용")
public String tmplatBody;
@Schema(description = "이메일 건당 발송 딜레이(단위 ms, 기본: 500ms)")
public Short delayTime ;
@Size(max = 16)
@Schema(description = "발송 전화번호(문자 발송에서 사용)")
public String sendTel;
@Size(max = 64)
@Email
@Schema(description = "발송 이메일(이메일 발송에서 사용)")
public String sendEml;
@Size(max = 32)
@NotBlank
@Schema(description = "발송자 이름")
public String sendNm;
}

View File

@@ -0,0 +1,68 @@
package com.kri.notihub.server.dto.template;
import com.fasterxml.jackson.annotation.JsonProperty;
import com.kri.notihub.server.common.enums.SendType;
import com.kri.notihub.server.persistence.entity.TTmplatEntity;
import io.swagger.v3.oas.annotations.media.Schema;
import jakarta.validation.constraints.NotBlank;
import jakarta.validation.constraints.NotNull;
import jakarta.validation.constraints.Size;
import lombok.*;
import lombok.experimental.SuperBuilder;
import java.time.LocalDateTime;
@Getter
@Setter
@SuperBuilder
@NoArgsConstructor
@AllArgsConstructor
@Schema(description = "템플릿 정보")
public class TemplateDto extends TemplateBasicDto{
@NotNull
@Schema(description = "템플릿 고유 키 (없으면 Create / 있으면 Update)")
public Long tmplatIdx;
@Size(max = 32)
@NotBlank
@Schema(description = "인트라넷 프로젝트 코드")
public String itrntPrjctCd;
@Size(max = 32)
@Schema(description = "등록자", accessMode = Schema.AccessMode.READ_ONLY)
@JsonProperty(access = JsonProperty.Access.READ_ONLY)
private String regUser;
@Schema(description = "등록일시", accessMode = Schema.AccessMode.READ_ONLY)
@JsonProperty(access = JsonProperty.Access.READ_ONLY)
private LocalDateTime regDt;
@Size(max = 32)
@Schema(description = "수정자", accessMode = Schema.AccessMode.READ_ONLY)
@JsonProperty(access = JsonProperty.Access.READ_ONLY)
private String modUser;
@Schema(description = "수정일시", accessMode = Schema.AccessMode.READ_ONLY)
@JsonProperty(access = JsonProperty.Access.READ_ONLY)
private LocalDateTime modDt;
public static TemplateDto from(TTmplatEntity entity) {
return TemplateDto.builder()
.tmplatIdx(entity.getTmplatIdx())
.itrntPrjctCd(entity.getItrntPrjctCd())
.tmplatTy(SendType.fromCode(entity.getTmplatTy()))
.tmplatNm(entity.getTmplatNm())
.tmplatTitle(entity.getTmplatTitle())
.tmplatBody(entity.getTmplatBody())
.delayTime(entity.getDelayTime())
.sendTel(entity.getSendTel())
.sendEml(entity.getSendEml())
.sendNm(entity.getSendNm())
.regUser(entity.getRegUser())
.regDt(entity.getRegDt())
.modUser(entity.getModUser())
.modDt(entity.getModDt())
.build();
}
}

View File

@@ -0,0 +1,26 @@
package com.kri.notihub.server.dto.template;
import com.kri.notihub.server.persistence.entity.TTmplatEntity;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.*;
@Getter
@Setter
@Builder
@NoArgsConstructor
@AllArgsConstructor
@Schema(description = "템플릿 요약 정보")
public class TemplateSummaryDto {
@Schema(description = "템플릿 고유 키")
public Long tmplatIdx;
@Schema(description = "템플릿 명")
public String tmplatNm;
public static TemplateSummaryDto from(TTmplatEntity entity) {
return TemplateSummaryDto.builder()
.tmplatIdx(entity.getTmplatIdx())
.tmplatNm(entity.getTmplatNm())
.build();
}
}

View File

@@ -0,0 +1,148 @@
package com.kri.notihub.server.persistence.entity;
import jakarta.persistence.Column;
import jakarta.persistence.Entity;
import jakarta.persistence.Id;
import jakarta.persistence.Table;
import jakarta.validation.constraints.NotNull;
import jakarta.validation.constraints.Size;
import lombok.Getter;
import lombok.Setter;
import org.hibernate.annotations.ColumnDefault;
import java.time.LocalDateTime;
@Getter
@Setter
@Entity
@Table(name = "`BIZ_LOG`")
public class BizLogEntity {
@Id
@Size(max = 32)
@Column(name = "`CMID`", length = 32)
private String cmid;
@Size(max = 32)
@Column(name = "`UMID`", length = 32)
private String umid;
@Column(name = "`MSG_TYPE`")
private Integer msgType;
@Column(name = "`STATUS`")
private Integer status;
@Size(max = 32)
@Column(name = "`CALL_STATUS`", length = 32)
private String callStatus;
@Column(name = "`REQUEST_TIME`")
private LocalDateTime requestTime;
@Column(name = "`SEND_TIME`")
private LocalDateTime sendTime;
@Column(name = "`REPORT_TIME`")
private LocalDateTime reportTime;
@Size(max = 16)
@Column(name = "`DEST_PHONE`", length = 16)
private String destPhone;
@Size(max = 32)
@Column(name = "`DEST_NAME`", length = 32)
private String destName;
@Size(max = 16)
@Column(name = "`SEND_PHONE`", length = 16)
private String sendPhone;
@Size(max = 32)
@Column(name = "`SEND_NAME`", length = 32)
private String sendName;
@Size(max = 64)
@Column(name = "`SUBJECT`", length = 64)
private String subject;
@Size(max = 2000)
@Column(name = "`MSG_BODY`", length = 2000)
private String msgBody;
@Size(max = 5)
@Column(name = "`NATION_CODE`", length = 5)
private String nationCode;
@Size(max = 40)
@Column(name = "`SENDER_KEY`", length = 40)
private String senderKey;
@Size(max = 64)
@Column(name = "`TEMPLATE_CODE`", length = 64)
private String templateCode;
@Size(max = 8)
@Column(name = "`RESPONSE_METHOD`", length = 8)
private String responseMethod;
@Size(max = 4)
@Column(name = "`TIMEOUT`", length = 4)
private String timeout;
@Size(max = 3)
@Column(name = "`RE_TYPE`", length = 3)
private String reType;
@Size(max = 2000)
@Column(name = "`RE_BODY`", length = 2000)
private String reBody;
@Size(max = 1)
@Column(name = "`RE_PART`", length = 1)
private String rePart;
@Column(name = "`COVER_FLAG`")
private Integer coverFlag;
@Column(name = "`SMS_FLAG`")
private Integer smsFlag;
@Column(name = "`REPLY_FLAG`")
private Integer replyFlag;
@Column(name = "`RETRY_CNT`")
private Integer retryCnt;
@Size(max = 1000)
@Column(name = "`ATTACHED_FILE`", length = 1000)
private String attachedFile;
@Size(max = 64)
@Column(name = "`VXML_FILE`", length = 64)
private String vxmlFile;
@Column(name = "`USE_PAGE`")
private Integer usePage;
@Column(name = "`USE_TIME`")
private Integer useTime;
@Column(name = "`SN_RESULT`")
private Integer snResult;
@Size(max = 10)
@Column(name = "`TEL_INFO`", length = 10)
private String telInfo;
@Size(max = 32)
@Column(name = "`CINFO`", length = 32)
private String cinfo;
@Size(max = 30)
@Column(name = "`USER_KEY`", length = 30)
private String userKey;
@Size(max = 1)
@Column(name = "`AD_FLAG`", length = 1)
private String adFalg;
}

View File

@@ -0,0 +1,195 @@
package com.kri.notihub.server.persistence.entity;
import com.kri.notihub.server.common.enums.SendType;
import jakarta.persistence.Column;
import jakarta.persistence.Entity;
import jakarta.persistence.Id;
import jakarta.persistence.Table;
import jakarta.validation.constraints.NotNull;
import jakarta.validation.constraints.Size;
import lombok.*;
import org.hibernate.annotations.ColumnDefault;
import java.time.LocalDateTime;
@Getter
@Setter
@Builder
@Entity
@NoArgsConstructor
@AllArgsConstructor
@Table(name = "`BIZ_MSG`")
public class BizMsgEntity {
@Id
@Size(max = 32)
@Column(name = "`CMID`", nullable = false, length = 32)
private String cmid;
@Size(max = 32)
@Column(name = "`UMID`", length = 32)
private String umid;
@NotNull
@ColumnDefault("0")
@Column(name = "`MSG_TYPE`", nullable = false)
private Integer msgType;
@NotNull
@ColumnDefault("0")
@Column(name = "`STATUS`", nullable = false)
private Integer status;
@Size(max = 32)
@Column(name = "`CALL_STATUS`", length = 32)
private String callStatus;
@NotNull
@ColumnDefault("CURRENT_TIMESTAMP")
@Column(name = "`REQUEST_TIME`", nullable = false)
private LocalDateTime requestTime;
@NotNull
@ColumnDefault("CURRENT_TIMESTAMP")
@Column(name = "`SEND_TIME`", nullable = false)
private LocalDateTime sendTime;
@Column(name = "`REPORT_TIME`")
private LocalDateTime reportTime;
@Size(max = 16)
@NotNull
@Column(name = "`DEST_PHONE`", nullable = false, length = 16)
private String destPhone;
@Size(max = 32)
@Column(name = "`DEST_NAME`", length = 32)
private String destName;
@Size(max = 16)
@NotNull
@Column(name = "`SEND_PHONE`", nullable = false, length = 16)
private String sendPhone;
@Size(max = 32)
@Column(name = "`SEND_NAME`", length = 32)
private String sendName;
@Size(max = 64)
@Column(name = "`SUBJECT`", length = 64)
private String subject;
@Size(max = 2000)
@NotNull
@Column(name = "`MSG_BODY`", nullable = false, length = 2000)
private String msgBody;
@Size(max = 5)
@Column(name = "`NATION_CODE`", length = 5)
private String nationCode;
@Size(max = 40)
@Column(name = "`SENDER_KEY`", length = 40)
private String senderKey;
@Size(max = 64)
@Column(name = "`TEMPLATE_CODE`", length = 64)
private String templateCode;
@Size(max = 8)
@Column(name = "`RESPONSE_METHOD`", length = 8)
private String responseMethod;
@Size(max = 4)
@Column(name = "`TIMEOUT`", length = 4)
private String timeout;
@Size(max = 3)
@Column(name = "`RE_TYPE`", length = 3)
private String reType;
@Size(max = 2000)
@Column(name = "`RE_BODY`", length = 2000)
private String reBody;
@Size(max = 1)
@Column(name = "`RE_PART`", length = 1)
private String rePart;
@ColumnDefault("0")
@Column(name = "`COVER_FLAG`")
private Integer coverFlag;
@ColumnDefault("0")
@Column(name = "`SMS_FLAG`")
private Integer smsFlag;
@ColumnDefault("0")
@Column(name = "`REPLY_FLAG`")
private Integer replyFlag;
@Column(name = "`RETRY_CNT`")
private Integer retryCnt;
@Size(max = 1000)
@Column(name = "`ATTACHED_FILE`", length = 1000)
private String attachedFile;
@Size(max = 64)
@Column(name = "`VXML_FILE`", length = 64)
private String vxmlFile;
@ColumnDefault("0")
@Column(name = "`USE_PAGE`")
private Integer usePage;
@ColumnDefault("0")
@Column(name = "`USE_TIME`")
private Integer useTime;
@ColumnDefault("0")
@Column(name = "`SN_RESULT`")
private Integer snResult;
@Size(max = 10)
@Column(name = "`TEL_INFO`", length = 10)
private String telInfo;
@Size(max = 32)
@Column(name = "`CINFO`", length = 32)
private String cinfo;
@Size(max = 30)
@Column(name = "`USER_KEY`", length = 30)
private String userKey;
@Size(max = 1)
@Column(name = "`AD_FLAG`", length = 1)
private String adFalg;
/*
@Size(max = 32)
@Column(name = "rcs_refkey", length = 32)
private String rcsRefkey;
*/
public static BizMsgEntity fromSend(TSendEntity s){
int msgType = s.getSendTy().equals(SendType.SMS.getCode()) ? 0 : 5;
String subject = s.getSendTy().equals(SendType.SMS.getCode()) ? null : s.getMsgTitle();
return BizMsgEntity.builder()
.cmid(s.getCmid())
.msgType(msgType)
.status(0)
.requestTime(s.getRegDt())
.sendTime(s.getSendDt())
.destPhone(s.getDestTel().replace("-", ""))
.destName(s.getDestNm())
.sendPhone(s.getSendTel().replace("-", ""))
.sendName(s.getSendNm())
.subject(subject)
.msgBody(s.getMsgBody())
.cinfo(s.getReqstSvc())
.build();
}
}

View File

@@ -0,0 +1,114 @@
package com.kri.notihub.server.persistence.entity;
import com.kri.common.jpa.BaseUuidEntity;
import com.kri.notihub.server.dto.send.BulkSendCreateRequestDto;
import jakarta.persistence.*;
import jakarta.validation.constraints.NotNull;
import jakarta.validation.constraints.Size;
import lombok.*;
import org.hibernate.annotations.ColumnDefault;
import java.time.LocalDateTime;
@Getter
@Setter
@Entity
@Builder
@NoArgsConstructor
@AllArgsConstructor
@Table(name = "t_bulk_send")
public class TBulkSendEntity extends BaseUuidEntity {
@Id
@Size(max = 32)
@Column(name = "bulk_send_key", nullable = false, length = 32)
private String bulkSendKey;
@Size(max = 16)
@NotNull
@Column(name = "reqst_svc", nullable = false, length = 16)
private String reqstSvc;
@Size(max = 32)
@NotNull
@Column(name = "prjct_cd", nullable = false, length = 32)
private String prjctCd;
@Column(name = "tmplat_idx", columnDefinition = "int UNSIGNED")
private Long tmplatIdx;
@NotNull
@Column(name = "is_resve", nullable = false)
private Boolean resve = false;
@NotNull
@Column(name = "send_dt", nullable = false)
private LocalDateTime sendDt;
@NotNull
@Column(name = "trgt_cnt", nullable = false)
private Integer trgtCnt;
@NotNull
@Column(name = "send_cnt", nullable = false)
private Integer sendCnt;
@NotNull
@Column(name = "succes_cnt", nullable = false)
private Integer succesCnt;
@NotNull
@Column(name = "fail_cnt", nullable = false)
private Integer failCnt;
@Column(name = "complete_dt")
private LocalDateTime completeDt;
@Size(max = 32)
@NotNull
@Column(name = "reg_cmpn", nullable = false, length = 32)
private String regCmpn;
@Size(max = 32)
@NotNull
@Column(name = "reg_user", nullable = false, length = 32)
private String regUser;
@NotNull
@ColumnDefault("CURRENT_TIMESTAMP")
@Column(name = "reg_dt", nullable = false)
private LocalDateTime regDt;
public static TBulkSendEntity from(BulkSendCreateRequestDto req, LocalDateTime now) {
return TBulkSendEntity.builder()
.reqstSvc(req.getReqstSvc())
.prjctCd(req.getPrjctCd())
.tmplatIdx(req.getTmplatIdx())
.resve(req.getResve())
.sendDt(req.getSendDt() != null ? req.getSendDt() : now)
.trgtCnt(req.getTrgtCnt())
.sendCnt(0)
.succesCnt(0)
.failCnt(0)
.completeDt(null)
.regCmpn(req.getReqstCmpn())
.regUser(req.getReqstUser())
.regDt(now)
.build();
}
@Override
protected String getId() {
return this.bulkSendKey;
}
@Override
protected void setId(String id) {
this.bulkSendKey = id;
}
@Override
protected int idLength() {
return 32; // cmid가 32면 생략해도 되지만 명시해두면 안전
}
}

View File

@@ -0,0 +1,76 @@
package com.kri.notihub.server.persistence.entity;
import io.hypersistence.utils.hibernate.type.json.JsonType;
import jakarta.persistence.*;
import jakarta.validation.constraints.NotNull;
import lombok.*;
import org.hibernate.annotations.ColumnDefault;
import org.hibernate.annotations.Type;
import java.time.LocalDateTime;
import java.util.Map;
@Getter
@Setter
@NoArgsConstructor
@AllArgsConstructor
@Builder
@Entity
@Table(name = "t_resve_send")
public class TResveSendEntity {
@Id
@NotNull
@GeneratedValue(strategy = GenerationType.IDENTITY)
@Column(name = "resve_idx", nullable = false)
private Long resveIdx;
@Column(name = "bulk_send_key", length = 32)
private String bulkSendKey;
@NotNull
@Column(name = "send_ty", nullable = false)
private Short sendTy;
@NotNull
@Column(name = "reqst_svc", nullable = false, length = 16)
private String reqstSvc;
@NotNull
@Column(name = "prjct_cd", nullable = false, length = 32)
private String prjctCd;
@Column(name = "tmplat_idx")
private Long tmplatIdx;
@NotNull
@Column(name = "resve_dt", nullable = false)
private LocalDateTime resveDt;
@NotNull
@Column(name = "sid", nullable = false)
private Integer sid;
@NotNull
@Type(JsonType.class)
@Column(name = "msg_param", nullable = false, columnDefinition = "json")
private Map<String, Object> msgParam;
@Column(name = "dest_eml", length = 64)
private String destEml;
@Column(name = "dest_tel", length = 16)
private String destTel;
@Column(name = "dest_nm", length = 32)
private String destNm;
@NotNull
@Column(name = "reg_user", nullable = false, length = 32)
private String regUser;
@NotNull
@ColumnDefault("CURRENT_TIMESTAMP")
@Column(name = "reg_dt", nullable = false)
private LocalDateTime regDt;
}

View File

@@ -0,0 +1,232 @@
package com.kri.notihub.server.persistence.entity;
import com.kri.notihub.server.common.enums.SendCorpType;
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.dto.send.SendRequestBasicDto;
import com.kri.notihub.server.dto.send.SendRequestSingleDto;
import io.hypersistence.utils.hibernate.type.json.JsonType;
import jakarta.persistence.*;
import jakarta.validation.constraints.NotNull;
import jakarta.validation.constraints.Size;
import lombok.*;
import org.hibernate.annotations.ColumnDefault;
import org.hibernate.annotations.Type;
import java.time.LocalDateTime;
import java.util.Map;
@Builder
@Getter
@Setter
@Entity
@NoArgsConstructor
@AllArgsConstructor
@Table(name = "t_send")
public class TSendEntity {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
@Column(name = "send_idx", nullable = false)
private Long sendIdx;
@NotNull
@Size(max = 32)
@Column(name = "cmid", nullable = false, length = 32)
private String cmid;
@Size(max = 32)
@Column(name = "bulk_send_key", length = 32)
private String bulkSendKey;
@NotNull
@Column(name = "send_ty", nullable = false)
private Short sendTy;
@NotNull
@Column(name = "is_resve", nullable = false)
private boolean resve = false;
@NotNull
@Column(name = "send_corp", nullable = false)
private Short sendCorp;
@NotNull
@Column(name = "send_status", nullable = false)
private Short sendStatus;
@NotNull
@Column(name = "result_code", nullable = false)
private Short resultCode;
@Size(max = 32)
@NotNull
@Column(name = "itrnt_prjct_cd", nullable = false, length = 32)
private String itrntPrjctCd;
@Size(max = 16)
@NotNull
@Column(name = "reqst_svc", nullable = false, length = 16)
private String reqstSvc;
@Size(max = 32)
@NotNull
@Column(name = "prjct_cd", nullable = false, length = 32)
private String prjctCd;
@Column(name = "tmplat_idx", columnDefinition = "int UNSIGNED")
private Long tmplatIdx;
@Size(max = 64)
@Column(name = "send_eml", length = 64)
private String sendEml;
@Size(max = 16)
@Column(name = "send_tel", length = 16)
private String sendTel;
@Size(max = 32)
@Column(name = "send_nm", length = 32)
private String sendNm;
@NotNull
@Column(name = "send_dt", nullable = false)
private LocalDateTime sendDt;
@NotNull
@Size(max = 128)
@Column(name = "sid", nullable = false, length = 128)
private String sid;
@Size(max = 128)
@Column(name = "msg_title", length = 128)
private String msgTitle;
@NotNull
@Lob
@Column(name = "msg_body", nullable = false)
private String msgBody;
@NotNull
@Type(JsonType.class)
@Column(name = "msg_param", nullable = false)
private Map<String, String> msgParam;
@Size(max = 64)
@Column(name = "dest_eml", length = 64)
private String destEml;
@Size(max = 16)
@Column(name = "dest_tel", length = 16)
private String destTel;
@Size(max = 32)
@Column(name = "dest_nm", length = 32)
private String destNm;
@Column(name = "report_dt")
private LocalDateTime reportDt;
@Size(max = 32)
@NotNull
@Column(name = "reg_cmpn", nullable = false, length = 32)
private String regCmpn;
@Size(max = 32)
@NotNull
@Column(name = "reg_user", nullable = false, length = 32)
private String regUser;
@NotNull
@ColumnDefault("CURRENT_TIMESTAMP")
@Column(name = "reg_dt", nullable = false)
private LocalDateTime regDt;
public static TSendEntity from(
SendRequestSingleDto req,
SendType sendTy,
SendInternalResultDto sendResult,
String itrntPrjctCd,
String msgTitle,
String msgBody,
String regCmpn,
String regUser,
Boolean resve,
LocalDateTime sendDt,
LocalDateTime regDt
){
if (req == null) return null;
return from(
req,
req.getDestInfo(),
sendTy,
sendResult,
itrntPrjctCd,
req.getReqstSvc(),
req.getPrjctCd(),
req.getTmplatIdx(),
msgTitle,
msgBody,
regCmpn,
regUser,
resve,
sendDt,
null,
regDt
);
}
public static TSendEntity from(
SendRequestBasicDto basic,
DestInfoDto dest,
SendType sendTy,
SendInternalResultDto sendResult,
String itrntPrjctCd,
String reqstSvc,
String prjctCd,
Long tmplatIdx,
String msgTitle,
String msgBody,
String regCmpn,
String regUser,
Boolean resve,
LocalDateTime sendDt,
String bulkSendKey,
LocalDateTime regDt
){
if (basic == null) return null;
if (dest == null) return null;
Short sendCorp = sendTy == SendType.EMAIL ? SendCorpType.PRINGO.getCode() : SendCorpType.BIZ_PPURIO.getCode();
return TSendEntity.builder()
.cmid(sendResult.getCmid())
.bulkSendKey(bulkSendKey)
.sendTy(sendTy.getCode())
.resve(resve)
.sendCorp(sendCorp)
.sendStatus(sendResult.getStatus().getCode())
.resultCode(sendResult.getResultCode())
.itrntPrjctCd(itrntPrjctCd)
.reqstSvc(reqstSvc)
.prjctCd(prjctCd)
.tmplatIdx(tmplatIdx)
.sendEml(basic.getSendEml())
.sendTel(basic.getSendTel())
.sendNm(basic.getSendNm())
.sendDt(sendDt)
.sid(dest.getSid())
.msgTitle(msgTitle)
.msgBody(msgBody)
.msgParam(dest.getMsgParam() != null? dest.getMsgParam() : Map.of())
.destEml(dest.getDestEml())
.destTel(dest.getDestTel())
.destNm(dest.getDestNm())
.regCmpn(regCmpn)
.regUser(regUser)
.regDt(regDt)
.build();
}
}

View File

@@ -0,0 +1,41 @@
package com.kri.notihub.server.persistence.entity;
import jakarta.persistence.Column;
import jakarta.persistence.EmbeddedId;
import jakarta.persistence.Entity;
import jakarta.persistence.Table;
import jakarta.validation.constraints.NotNull;
import jakarta.validation.constraints.Size;
import lombok.Getter;
import lombok.Setter;
@Getter
@Setter
@Entity
@Table(name = "t_send_result_code")
public class TSendResultCodeEntity {
@EmbeddedId
private TSendResultCodeEntityId id;
@NotNull
@Column(name = "result_ty", nullable = false)
private Short resultTy;
@Size(max = 128)
@NotNull
@Column(name = "result_label", nullable = false, length = 128)
private String resultLabel;
@Size(max = 128)
@NotNull
@Column(name = "result_view_label", nullable = false, length = 128)
private String resultViewLabel;
@Size(max = 128)
@Column(name = "memo", length = 128)
private String memo;
public short getSendCorp() { return id.getSendCorp(); }
public short getResultCode() { return id.getResultCode(); }
}

View File

@@ -0,0 +1,40 @@
package com.kri.notihub.server.persistence.entity;
import jakarta.persistence.Column;
import jakarta.persistence.Embeddable;
import jakarta.validation.constraints.NotNull;
import lombok.Getter;
import lombok.Setter;
import org.hibernate.Hibernate;
import java.io.Serializable;
import java.util.Objects;
@Getter
@Setter
@Embeddable
public class TSendResultCodeEntityId implements Serializable {
private static final long serialVersionUID = -53054354660031517L;
@NotNull
@Column(name = "send_corp", nullable = false)
private Short sendCorp;
@NotNull
@Column(name = "result_code", nullable = false)
private Short resultCode;
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || Hibernate.getClass(this) != Hibernate.getClass(o)) return false;
TSendResultCodeEntityId entity = (TSendResultCodeEntityId) o;
return Objects.equals(this.sendCorp, entity.sendCorp) &&
Objects.equals(this.resultCode, entity.resultCode);
}
@Override
public int hashCode() {
return Objects.hash(sendCorp, resultCode);
}
}

View File

@@ -0,0 +1,124 @@
package com.kri.notihub.server.persistence.entity;
import com.kri.notihub.server.dto.template.TemplateBasicDto;
import jakarta.persistence.*;
import jakarta.validation.constraints.NotNull;
import jakarta.validation.constraints.Size;
import lombok.*;
import org.hibernate.annotations.ColumnDefault;
import java.time.LocalDateTime;
@Builder
@Getter
@Setter
@Entity
@Table(name = "t_tmplat")
@NoArgsConstructor
@AllArgsConstructor
public class TTmplatEntity {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
@Column(name = "tmplat_idx", columnDefinition = "int UNSIGNED not null")
private Long tmplatIdx;
@Size(max = 32)
@NotNull
@Column(name = "itrnt_prjct_cd", nullable = false, length = 32)
private String itrntPrjctCd;
@NotNull
@Column(name = "tmplat_ty", nullable = false)
private Short tmplatTy;
@Size(max = 32)
@NotNull
@Column(name = "tmplat_nm", nullable = false, length = 32)
private String tmplatNm;
@Size(max = 128)
@Column(name = "tmplat_title", length = 128)
private String tmplatTitle;
@NotNull
@Lob
@Column(name = "tmplat_body", nullable = false)
private String tmplatBody;
@Column(name = "delay_time")
private Short delayTime;
@Size(max = 16)
@Column(name = "send_tel", length = 16)
private String sendTel;
@Size(max = 64)
@Column(name = "send_eml", length = 64)
private String sendEml;
@Size(max = 32)
@Column(name = "send_nm", length = 32)
private String sendNm;
@Size(max = 32)
@NotNull
@Column(name = "reg_user", nullable = false, length = 32, updatable = false)
private String regUser;
@NotNull
@ColumnDefault("CURRENT_TIMESTAMP")
@Column(name = "reg_dt", nullable = false, updatable = false)
private LocalDateTime regDt;
@Size(max = 32)
@Column(name = "mod_user", length = 32, insertable = false)
private String modUser;
@Column(name = "mod_dt", insertable = false)
private LocalDateTime modDt;
@NotNull
@ColumnDefault("0")
@Column(name = "is_del", nullable = false)
private Boolean del = false;
@Size(max = 32)
@Column(name = "del_user", length = 32)
private String delUser;
@Column(name = "del_dt")
private LocalDateTime delDt;
public static TTmplatEntity create(String itrntPrjctCd, TemplateBasicDto template, String regUser, LocalDateTime regDt) {
return TTmplatEntity.builder()
.itrntPrjctCd(itrntPrjctCd)
.tmplatTy(template.tmplatTy.getCode())
.tmplatNm(template.tmplatNm)
.tmplatTitle(template.tmplatTitle)
.tmplatBody(template.tmplatBody)
.delayTime(template.delayTime)
.sendTel(template.sendTel)
.sendEml(template.sendEml)
.sendNm(template.sendNm)
.regUser(regUser)
.regDt(regDt)
.del(false)
.build();
}
public void updateFrom(TemplateBasicDto template, String modUser, LocalDateTime modDt) {
// 기본 정보 갱신
this.tmplatTy = template.tmplatTy.getCode();
this.tmplatNm = template.tmplatNm;
this.tmplatTitle = template.tmplatTitle;
this.tmplatBody = template.tmplatBody;
this.delayTime = template.delayTime;
this.sendTel = template.sendTel;
this.sendEml = template.sendEml;
this.sendNm = template.sendNm;
// 수정 메타 갱신
this.modUser = modUser;
this.modDt = modDt;
}
}

View File

@@ -0,0 +1,71 @@
package com.kri.notihub.server.persistence.entity;
import com.kri.notihub.server.common.enums.TemplateEventType;
import com.kri.notihub.server.dto.template.TemplateBasicDto;
import io.hypersistence.utils.hibernate.type.json.JsonType;
import jakarta.persistence.*;
import jakarta.validation.constraints.NotNull;
import jakarta.validation.constraints.Size;
import lombok.*;
import org.hibernate.annotations.ColumnDefault;
import org.hibernate.annotations.Type;
import java.time.LocalDateTime;
@Builder
@Getter
@Setter
@Entity
@Table(name = "t_tmplat_event_log")
@NoArgsConstructor
@AllArgsConstructor
public class TTmplatEventLogEntity {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
@Column(name = "tmplat_event_idx", columnDefinition = "int UNSIGNED not null")
private Long tmplatEventIdx;
@Column(name = "tmplat_idx", columnDefinition = "int UNSIGNED not null")
private Long tmplatIdx;
@NotNull
@Column(name = "event_ty", nullable = false)
private Short eventTy;
@Type(JsonType.class)
@Column(name = "before_tmplat")
private TemplateBasicDto beforeTmplat;
@NotNull
@Type(JsonType.class)
@Column(name = "after_tmplat", nullable = false)
private TemplateBasicDto afterTmplat;
@Size(max = 32)
@NotNull
@Column(name = "reg_user", nullable = false, length = 32)
private String regUser;
@NotNull
@ColumnDefault("CURRENT_TIMESTAMP")
@Column(name = "reg_dt", nullable = false)
private LocalDateTime regDt;
public static TTmplatEventLogEntity of(
Long tmplatIdx,
TemplateEventType eventTy,
TemplateBasicDto beforeTmplat,
TemplateBasicDto afterTmplat,
String regUser,
LocalDateTime regDt
) {
return TTmplatEventLogEntity.builder()
.tmplatIdx(tmplatIdx)
.eventTy(eventTy.getCode())
.beforeTmplat(beforeTmplat)
.afterTmplat(afterTmplat)
.regUser(regUser)
.regDt(regDt)
.build();
}
}

View File

@@ -0,0 +1,16 @@
package com.kri.notihub.server.persistence.repository;
import com.kri.notihub.server.persistence.entity.BizLogEntity;
import org.springframework.data.jpa.repository.JpaRepository;
import java.util.Collection;
import java.util.List;
import java.util.Optional;
public interface BizLogRepository extends JpaRepository<BizLogEntity, Long> {
Optional<BizLogEntity> findTopByCmidOrderByReportTimeDesc(String cmid);
// 또는 대량처리용(필요시)
List<BizLogEntity> findByCmidIn(Collection<String> cmids);
}

View File

@@ -0,0 +1,7 @@
package com.kri.notihub.server.persistence.repository;
import com.kri.notihub.server.persistence.entity.BizMsgEntity;
import org.springframework.data.jpa.repository.JpaRepository;
public interface BizMsgRepository extends JpaRepository<BizMsgEntity, Long> {
}

View File

@@ -0,0 +1,47 @@
package com.kri.notihub.server.persistence.repository;
import com.kri.notihub.server.persistence.entity.TBulkSendEntity;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.Query;
import java.util.List;
import java.util.Optional;
public interface BulkSendRepository extends JpaRepository<TBulkSendEntity, String> {
List<TBulkSendEntity> findByBulkSendKeyIn(List<String> bulkSendKeyList);
@Query("""
select b
from TBulkSendEntity b
join TTmplatEntity t on t.tmplatIdx = b.tmplatIdx
where t.tmplatTy in :sendTyList
and b.reqstSvc = :reqstSvc
and b.prjctCd = :prjctCd
order by b.regDt desc
""")
List<TBulkSendEntity> findBySendTyInAndReqstSvcAndPrjctCd(
List<Short> sendTyList,
String reqstSvc,
String prjctCd
);
@Query("""
select b
from TBulkSendEntity b
join TTmplatEntity t on t.tmplatIdx = b.tmplatIdx
where t.tmplatTy in :sendTyList
and b.reqstSvc = :reqstSvc
and b.prjctCd = :prjctCd
and b.regCmpn = :regCmpn
order by b.regDt desc
""")
List<TBulkSendEntity> findBySendTyInAndReqstSvcAndPrjctCdAndRegCmpn(
List<Short> sendTyList,
String reqstSvc,
String prjctCd,
String regCmpn
);
Optional<TBulkSendEntity> findByBulkSendKey(String bulkSendKey);
}

View File

@@ -0,0 +1,68 @@
package com.kri.notihub.server.persistence.repository;
import com.kri.notihub.server.persistence.entity.TSendEntity;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.Query;
import java.time.LocalDateTime;
import java.util.List;
import java.util.Optional;
public interface SendRepository extends JpaRepository<TSendEntity, String> {
Optional<TSendEntity> findByCmid(String cmid);
@Query("""
select coalesce(min(s.sendIdx), 0)
from TSendEntity s
where s.sendTy = :sendTy and s.sendStatus = 0
""")
long findMinSendIdxBySendTy(short sendTy);
@Query("""
select s
from TSendEntity s
where s.sendStatus = :sendStatus
and s.sendTy in :sendTyList
and s.sendDt between :fromDt and :toDt
order by s.sendIdx asc
""")
List<TSendEntity> findSendListToRefreshWithinHours(
List<Short> sendTyList,
short sendStatus,
LocalDateTime fromDt,
LocalDateTime toDt,
Pageable pageable
);
@Query("""
select s
from TSendEntity s
where s.sendTy = :sendTy
and s.resultCode = :resultCode
and s.resve = true
and s.sendDt <= :now
order by s.sendIdx asc
""")
List<TSendEntity> findReservedSendEmail(
short sendTy,
short resultCode,
LocalDateTime now,
Pageable pageable
);
/**
* Poller 복구용: STANDBY_EMAIL 상태로 남아있는 최근 발송건을 다시 enqueue 하기 위해 사용
*/
Page<TSendEntity> findBySendTyAndResultCodeAndSendDtAfterOrderBySendDtAsc(
short sendTy,
short resultCode,
LocalDateTime sendDtAfter,
Pageable pageable
);
Page<TSendEntity> findByBulkSendKey(String bulkSendKey, Pageable pageable);
}

View File

@@ -0,0 +1,9 @@
package com.kri.notihub.server.persistence.repository;
import com.kri.notihub.server.persistence.entity.TSendResultCodeEntity;
import com.kri.notihub.server.persistence.entity.TSendResultCodeEntityId;
import org.springframework.data.jpa.repository.JpaRepository;
public interface SendResultCodeRepository extends JpaRepository<TSendResultCodeEntity, TSendResultCodeEntityId> {
}

View File

@@ -0,0 +1,9 @@
package com.kri.notihub.server.persistence.repository;
import com.kri.notihub.server.persistence.entity.TTmplatEventLogEntity;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
public interface TemplateEventLogRepository extends JpaRepository<TTmplatEventLogEntity, Long>, JpaSpecificationExecutor<TTmplatEventLogEntity> {
}

View File

@@ -0,0 +1,29 @@
package com.kri.notihub.server.persistence.repository;
import com.kri.notihub.server.persistence.entity.TTmplatEntity;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
import org.springframework.data.jpa.repository.Modifying;
import org.springframework.data.jpa.repository.Query;
import java.time.LocalDateTime;
import java.util.List;
import java.util.Optional;
public interface TemplateRepository extends JpaRepository<TTmplatEntity, Long>, JpaSpecificationExecutor<TTmplatEntity> {
@Modifying(clearAutomatically = true, flushAutomatically = true)
@Query("""
update TTmplatEntity t
set t.del = true,
t.delUser = :delUser,
t.delDt = :delDt
where t.tmplatIdx = :idx
and t.del = false
""")
int softDeleteByTmplatIdx(long idx, String delUser, LocalDateTime delDt);
List<TTmplatEntity> findAllByItrntPrjctCdAndDelFalse(String itrntPrjctCd);
Optional<TTmplatEntity> findByTmplatIdxAndDelFalse(long tmplatIdx);
}

View File

@@ -0,0 +1,236 @@
package com.kri.notihub.server.scheduler;
import com.kri.common.datetime.DateTimeUtil;
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.persistence.entity.BizLogEntity;
import com.kri.notihub.server.persistence.entity.TBulkSendEntity;
import com.kri.notihub.server.persistence.entity.TSendEntity;
import com.kri.notihub.server.persistence.repository.BizLogRepository;
import com.kri.notihub.server.persistence.repository.BulkSendRepository;
import com.kri.notihub.server.persistence.repository.SendRepository;
import com.kri.notihub.server.service.SmsSendCursorStore;
import lombok.RequiredArgsConstructor;
import org.springframework.data.domain.PageRequest;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.time.LocalDateTime;
import java.util.*;
import java.util.function.Function;
import java.util.stream.Collectors;
@Service
@RequiredArgsConstructor
public class BizLogResultScheduler {
private final SmsSendCursorStore cursorStore;
private final SendRepository sendRepository;
private final BizLogRepository bizLogRepository;
private final BulkSendRepository bulkSendRepository;
@Scheduled(fixedDelay = 60 * 1_000) // 나중에 증가시킬 것
@Transactional(transactionManager = "transactionManager")
public void syncSmsResults() {
TimeWindow window = buildWindow(1L); // hours는 추후 파라미터화
List<Short> sendTyList = List.of(SendType.SMS.getCode(), SendType.LMS_MMS.getCode());
while (true) {
List<TSendEntity> batch = fetchRefreshTargets(sendTyList, window, 1000);
if (batch.isEmpty()) return;
BulkContext bulkCtx = loadBulkContext(batch);
BatchResult result = applyResultsAndCollectDeltas(batch, bulkCtx);
persistChanges(result, bulkCtx);
}
}
private TimeWindow buildWindow(long hours) {
LocalDateTime toDt = LocalDateTime.now();
return new TimeWindow(toDt.minusHours(hours), toDt);
}
private List<TSendEntity> fetchRefreshTargets(List<Short> sendTyList, TimeWindow window, int size) {
return sendRepository.findSendListToRefreshWithinHours(
sendTyList,
SendStatusType.STANDBY.getCode(),
window.from(),
window.to(),
PageRequest.of(0, size)
);
}
/** batch에서 bulkKey 수집 + bulk 엔티티 로딩 + Map 인덱싱 */
private BulkContext loadBulkContext(List<TSendEntity> batch) {
Set<String> bulkKeys = extractBulkKeys(batch);
if (bulkKeys.isEmpty()) {
return new BulkContext(Set.of(), Map.of());
}
List<TBulkSendEntity> bulkEntities =
bulkSendRepository.findByBulkSendKeyIn(new ArrayList<>(bulkKeys));
Map<String, TBulkSendEntity> bulkMap = bulkEntities.stream()
.collect(Collectors.toMap(
TBulkSendEntity::getBulkSendKey,
Function.identity(),
(a, b) -> a
));
return new BulkContext(bulkKeys, bulkMap);
}
private Set<String> extractBulkKeys(List<TSendEntity> batch) {
return batch.stream()
.map(TSendEntity::getBulkSendKey)
.filter(k -> k != null && !k.isBlank())
.collect(Collectors.toSet());
}
/** BizLog 반영 + send/bulk delta 수집 */
private BatchResult applyResultsAndCollectDeltas(List<TSendEntity> batch, BulkContext bulkCtx) {
Map<String, Integer> successDelta = new HashMap<>();
Map<String, Integer> failDelta = new HashMap<>();
List<TSendEntity> updatedSends = new ArrayList<>();
for (TSendEntity s : batch) {
if (!isResultPending(s)) continue;
Short beforeStatus = s.getSendStatus();
bizLogRepository.findTopByCmidOrderByReportTimeDesc(s.getCmid()).ifPresent(log -> {
applySmsResultFromBizLog(s, log);
updatedSends.add(s);
accumulateBulkDeltaIfNeeded(s, beforeStatus, bulkCtx.bulkMap(), successDelta, failDelta);
});
}
return new BatchResult(updatedSends, successDelta, failDelta);
}
private boolean isResultPending(TSendEntity s) {
if (s == null) return false;
Short resultCode = s.getResultCode();
return resultCode != null
&& (resultCode == NotihubConst.SMS_STANDBY || resultCode == NotihubConst.LMS_MMS_STANDBY);
}
/** STANDBY -> SUCCESS/FAIL 전이일 때만 bulk delta 누적 */
private void accumulateBulkDeltaIfNeeded(
TSendEntity s,
Short beforeStatus,
Map<String, TBulkSendEntity> bulkMap,
Map<String, Integer> successDelta,
Map<String, Integer> failDelta
) {
String key = s.getBulkSendKey();
if (key == null || key.isBlank()) return;
if (!bulkMap.containsKey(key)) return;
if (!Objects.equals(beforeStatus, SendStatusType.STANDBY.getCode())) return;
if (Objects.equals(s.getSendStatus(), SendStatusType.SUCCESS.getCode())) {
successDelta.merge(key, 1, Integer::sum);
} else if (Objects.equals(s.getSendStatus(), SendStatusType.FAIL.getCode())) {
failDelta.merge(key, 1, Integer::sum);
}
}
/** 저장 + cursor + bulk 카운트 반영 */
private void persistChanges(BatchResult result, BulkContext bulkCtx) {
LocalDateTime now = DateTimeUtil.nowKstLocalDateTime();
if (!result.updatedSends().isEmpty()) {
sendRepository.saveAll(result.updatedSends());
sendRepository.flush();
// 마지막 갱신 sendIdx 기록(현재 로직 유지)
cursorStore.set(result.updatedSends().get(result.updatedSends().size() - 1).getSendIdx());
}
if (bulkCtx.bulkMap().isEmpty()) return;
applyBulkCountDeltas(bulkCtx.bulkMap(), result.successDelta(), result.failDelta(), now);
bulkSendRepository.saveAll(bulkCtx.bulkMap().values());
}
private void applyBulkCountDeltas(
Map<String, TBulkSendEntity> bulkMap,
Map<String, Integer> successDelta,
Map<String, Integer> failDelta,
LocalDateTime now
) {
Set<String> touched = new HashSet<>();
successDelta.forEach((k, d) -> {
TBulkSendEntity e = bulkMap.get(k);
if (e != null) {
int cur = e.getSuccesCnt() == null ? 0 : e.getSuccesCnt();
e.setSuccesCnt(cur + d);
touched.add(k);
}
});
failDelta.forEach((k, d) -> {
TBulkSendEntity e = bulkMap.get(k);
if (e != null) {
int cur = e.getFailCnt() == null ? 0 : e.getFailCnt();
e.setFailCnt(cur + d);
touched.add(k);
}
});
// 완료 처리: trgt_cnt <= succes_cnt + fail_cnt 되는 순간 complete_dt 세팅
for (String k : touched) {
TBulkSendEntity e = bulkMap.get(k);
if (e == null) continue;
if (e.getCompleteDt() != null) continue; // 이미 완료면 재세팅 방지
int trgt = e.getTrgtCnt() == null ? 0 : e.getTrgtCnt();
int success = e.getSuccesCnt() == null ? 0 : e.getSuccesCnt();
int fail = e.getFailCnt() == null ? 0 : e.getFailCnt();
if (trgt <= (success + fail)) {
e.setCompleteDt(now);
}
}
}
private void applySmsResultFromBizLog(TSendEntity s, BizLogEntity log) {
// ReportDt(LocalDateTime) 반영
// BizLogEntity.reportTime 타입이 Date면 LocalDateTime 변환 로직으로 바꾸세요.
s.setReportDt(log.getReportTime());
short callStatus = safeParseShort(log.getCallStatus(), NotihubConst.SMS_NOT_RESULT);
if (callStatus == NotihubConst.SMS_SUCCESS || callStatus == NotihubConst.LMS_MMS_SUCCESS) {
s.setSendStatus(SendStatusType.SUCCESS.getCode());
s.setResultCode(callStatus);
} else {
s.setSendStatus(SendStatusType.FAIL.getCode());
s.setResultCode(callStatus); // “그 외 실패”이지만, 실제 코드 보존이 운영/분석에 유리
}
}
private short safeParseShort(String v, short fallback) {
if (v == null || v.isBlank()) return fallback;
try { return Short.parseShort(v.trim()); } catch (Exception e) { return fallback; }
}
private record TimeWindow(LocalDateTime from, LocalDateTime to) {}
private record BulkContext(Set<String> bulkKeys, Map<String, TBulkSendEntity> bulkMap) {}
private record BatchResult(List<TSendEntity> updatedSends,
Map<String, Integer> successDelta,
Map<String, Integer> failDelta) {}
}

View File

@@ -0,0 +1,73 @@
package com.kri.notihub.server.scheduler;
import com.kri.common.datetime.DateTimeUtil;
import com.kri.notihub.server.common.consts.NotihubConst;
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.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.SendRepository;
import com.kri.notihub.server.service.SendEmailService;
import lombok.RequiredArgsConstructor;
import org.springframework.data.domain.PageRequest;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.List;
@Service
@RequiredArgsConstructor
public class SendReservationEmailScheduler {
private final PringoApiClient pringoApiClient;
private final SendEmailService sendEmlService;
private final SendRepository sendRepository;
@Scheduled(cron = "0 */5 * * * *")
@Transactional(transactionManager = "transactionManager")
public void sendReservationEmail() {
LocalDateTime now = DateTimeUtil.nowKstLocalDateTime();
while (true) {
List<TSendEntity> updatedSends = new ArrayList<>();
List<TSendEntity> reservationList = sendRepository.findReservedSendEmail(
SendType.EMAIL.getCode(),
NotihubConst.EMAIL_STANDBY,
now,
PageRequest.of(0, 1000)
);
if(reservationList.isEmpty()) return;
for (TSendEntity s : reservationList) {
PringoJsonSendRequestDto pringoReq = sendEmlService.buildPringoSendRequest(
s.getSendEml(),
s.getSendNm(),
s.getMsgTitle(),
s.getMsgBody(),
DestInfoDto.from(s)
);
SendInternalResultDto sendResult = sendEmlService.sendPringoEmail(pringoReq);
s.setCmid(sendResult.getCmid());
s.setSendStatus(sendResult.getStatus().getCode());
s.setResultCode(sendResult.getResultCode());
updatedSends.add(s);
}
//TSendEntity update
sendRepository.saveAll(updatedSends);
sendRepository.flush();
//결과들을 모았다가 afterPersistSendEntities
sendEmlService.afterPersistSendEntities(updatedSends);
}
}
}

View File

@@ -0,0 +1,91 @@
package com.kri.notihub.server.scheduler;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;
import java.io.IOException;
import java.nio.file.*;
import java.nio.file.attribute.BasicFileAttributes;
import java.time.Duration;
import java.time.Instant;
@Slf4j
@Component
public class TempFileCleanupScheduler {
private final Path uploadBaseDir;
private final Duration expireDuration;
public TempFileCleanupScheduler(
@Value("${kri.body-image.upload-base-dir}") String uploadBaseDirStr,
@Value("${kri.body-image.temp-expire-hours:24}") long expireHours
) {
this.uploadBaseDir = Paths.get(uploadBaseDirStr);
this.expireDuration = Duration.ofHours(expireHours);
}
/**
* 매일 자정(00:00)에 실행.
* 필요하면 application.yml 에서 kri.body-image.temp-cleanup-cron 으로 변경 가능.
*/
@Scheduled(cron = "${kri.body-image.temp-cleanup-cron:0 0 0 * * *}")
public void cleanupOldTempFiles() {
if (!Files.isDirectory(uploadBaseDir)) {
log.warn("[TempCleanup] uploadBaseDir({}) 가 디렉토리가 아닙니다.", uploadBaseDir);
return;
}
Instant now = Instant.now();
Instant threshold = now.minus(expireDuration);
log.info("[TempCleanup] 시작 - baseDir={}, threshold={}", uploadBaseDir, threshold);
try (DirectoryStream<Path> projectDirs = Files.newDirectoryStream(uploadBaseDir)) {
for (Path projectDir : projectDirs) {
if (!Files.isDirectory(projectDir)) {
continue;
}
Path tempDir = projectDir.resolve("Temp"); // {prjctCd}/Temp
if (!Files.isDirectory(tempDir)) {
continue;
}
cleanupTempDir(tempDir, threshold);
}
} catch (IOException e) {
log.error("[TempCleanup] baseDir 스캔 중 오류 - baseDir={}", uploadBaseDir, e);
}
log.info("[TempCleanup] 종료");
}
private void cleanupTempDir(Path tempDir, Instant threshold) {
try (DirectoryStream<Path> stream = Files.newDirectoryStream(tempDir)) {
for (Path file : stream) {
if (!Files.isRegularFile(file)) {
continue;
}
try {
BasicFileAttributes attrs =
Files.readAttributes(file, BasicFileAttributes.class);
// 생성 시간(지원 안 하면 마지막 수정 시간)을 기준으로 비교
Instant created = attrs.creationTime() != null
? attrs.creationTime().toInstant()
: attrs.lastModifiedTime().toInstant();
if (created.isBefore(threshold)) {
Files.deleteIfExists(file);
log.debug("[TempCleanup] 삭제: {} (created={})", file, created);
}
} catch (IOException ex) {
log.warn("[TempCleanup] 파일 삭제 실패: {}", file, ex);
}
}
} catch (IOException e) {
log.warn("[TempCleanup] temp 디렉토리 스캔 실패: {}", tempDir, e);
}
}
}

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);
}
}
}

View File

@@ -0,0 +1 @@
spring.application.name=notihub-server

View File

@@ -0,0 +1,13 @@
package com.kri.notihub.server;
import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;
@SpringBootTest
class NotihubServerApplicationTests {
@Test
void contextLoads() {
}
}