api ,aws 모듈 삭제

This commit is contained in:
주수현
2025-06-20 16:25:15 +09:00
parent 313a139b16
commit 66da005ebf
234 changed files with 0 additions and 8479 deletions

View File

@@ -1,60 +0,0 @@
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns="http://maven.apache.org/POM/4.0.0"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<artifactId>api</artifactId>
<build>
<plugins>
<plugin>
<artifactId>spring-boot-maven-plugin</artifactId>
<configuration>
<includeSystemScope>true</includeSystemScope>
</configuration>
<groupId>org.springframework.boot</groupId>
<version>3.4.0</version>
</plugin>
</plugins>
</build>
<dependencies>
<dependency>
<artifactId>aws</artifactId>
<groupId>app.module</groupId>
<version>0.0.1-SNAPSHOT</version>
</dependency>
<dependency>
<artifactId>core</artifactId>
<groupId>app.module</groupId>
<version>0.0.1-SNAPSHOT</version>
</dependency>
<dependency>
<artifactId>springdoc-openapi-starter-webmvc-ui</artifactId>
<groupId>org.springdoc</groupId>
<version>2.7.0</version>
</dependency>
<dependency>
<artifactId>jjwt</artifactId>
<groupId>io.jsonwebtoken</groupId>
<version>0.12.6</version>
</dependency>
</dependencies>
<description>API project</description>
<modelVersion>4.0.0</modelVersion>
<name>api</name>
<packaging>${packaging.type}</packaging>
<parent>
<artifactId>app.module</artifactId>
<groupId>app.module</groupId>
<version>0.0.1-SNAPSHOT</version>
</parent>
<properties>
<maven.compiler.source>17</maven.compiler.source>
<maven.compiler.target>17</maven.compiler.target>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
</properties>
<version>0.0.1-SNAPSHOT</version>
</project>

View File

@@ -1,26 +0,0 @@
package app.module.api;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.builder.SpringApplicationBuilder;
import org.springframework.boot.web.servlet.support.SpringBootServletInitializer;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.context.annotation.ComponentScan;
@SpringBootApplication
@EnableCaching
@ComponentScan(basePackages = "app.module")
public class ApiApplication extends SpringBootServletInitializer {
public static void main(String[] args) {
SpringApplication.run(ApiApplication.class, args);
}
/**
* maven jar 배포시 필요없지만, war 배포를 선택한 경우 configure 오버라이드가 필요하기에 선언.
*/
@Override
protected SpringApplicationBuilder configure(SpringApplicationBuilder builder) {
return builder.sources(ApiApplication.class);
}
}

View File

@@ -1,45 +0,0 @@
package app.module.api.config.adapters.web.advice;
import app.module.core.config.application.util.CoreUtil;
import lombok.RequiredArgsConstructor;
import org.springframework.core.MethodParameter;
import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity;
import org.springframework.http.converter.HttpMessageConverter;
import org.springframework.http.server.ServerHttpRequest;
import org.springframework.http.server.ServerHttpResponse;
import org.springframework.validation.BindingResult;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.servlet.mvc.method.annotation.ResponseBodyAdvice;
/**
* ResponseEntity 의 body 응답이 BindingResult 일 떄 메세지 코드 변환 작업 진행
*/
@ControllerAdvice
@RequiredArgsConstructor
public class ApiResponseBodyAdvice implements ResponseBodyAdvice<Object> {
private final CoreUtil coreUtil;
@Override
public boolean supports(
MethodParameter returnType, Class<? extends HttpMessageConverter<?>> converterType) {
return ResponseEntity.class.isAssignableFrom(returnType.getParameterType());
}
@Override
public Object beforeBodyWrite(
Object body,
MethodParameter returnType,
MediaType selectedContentType,
Class<? extends HttpMessageConverter<?>> selectedConverterType,
ServerHttpRequest request,
ServerHttpResponse response) {
if (body instanceof BindingResult bindingResult) {
return coreUtil.getErrorInfo(bindingResult);
}
return body;
}
}

View File

@@ -1,58 +0,0 @@
package app.module.api.config.adapters.web.filter;
import app.module.api.config.application.util.JwtTokenProvider;
import io.jsonwebtoken.Claims;
import jakarta.servlet.FilterChain;
import jakarta.servlet.ServletException;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.List;
import lombok.RequiredArgsConstructor;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.authority.SimpleGrantedAuthority;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.security.core.userdetails.User;
import org.springframework.stereotype.Component;
import org.springframework.util.StringUtils;
import org.springframework.web.filter.OncePerRequestFilter;
@RequiredArgsConstructor
@Component
public class JwtAuthenticationFilter extends OncePerRequestFilter {
private final JwtTokenProvider jwtTokenProvider;
@Override
protected void doFilterInternal(
HttpServletRequest request, HttpServletResponse response, FilterChain filterChain)
throws ServletException, IOException {
String token = resolveToken(request);
if (token != null && jwtTokenProvider.validateToken(token)) {
// Claims 에서 username 추출
String username = jwtTokenProvider.getUsername(token);
Claims claims = jwtTokenProvider.parseClaims(token).getPayload();
List<String> authorities = claims.get("authorities", List.class);
List<SimpleGrantedAuthority> grantedAuthorities =
authorities.stream().map(SimpleGrantedAuthority::new).toList();
SecurityContextHolder.getContext()
.setAuthentication(
new UsernamePasswordAuthenticationToken(
new User(username, "", grantedAuthorities), token, grantedAuthorities));
}
filterChain.doFilter(request, response);
}
private String resolveToken(HttpServletRequest request) {
String bearerToken = request.getHeader("Authorization");
if (StringUtils.hasText(bearerToken) && bearerToken.startsWith("Bearer ")) {
return bearerToken.substring(7);
}
return null;
}
}

View File

@@ -1,34 +0,0 @@
package app.module.api.config.adapters.web.mvc;
import java.util.Locale;
import lombok.RequiredArgsConstructor;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.LocaleResolver;
import org.springframework.web.servlet.config.annotation.ResourceHandlerRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
import org.springframework.web.servlet.i18n.AcceptHeaderLocaleResolver;
@Configuration
@RequiredArgsConstructor
public class ApiWebMvcConfig implements WebMvcConfigurer {
@Value("${path.upload.public}")
private String publicPath;
@Override
public void addResourceHandlers(ResourceHandlerRegistry registry) {
registry
.addResourceHandler("/content-disposition/inline/**")
.addResourceLocations("file:///" + publicPath + "/")
.setCachePeriod(20);
}
@Bean
public LocaleResolver localeResolver() {
AcceptHeaderLocaleResolver resolver = new AcceptHeaderLocaleResolver();
resolver.setDefaultLocale(Locale.KOREAN); // 기본 로케일 설정
return resolver;
}
}

View File

@@ -1,91 +0,0 @@
package app.module.api.config.adapters.web.security;
import app.module.api.config.adapters.web.filter.JwtAuthenticationFilter;
import java.util.List;
import lombok.RequiredArgsConstructor;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.authentication.AuthenticationManager;
import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.annotation.web.configurers.AbstractHttpConfigurer;
import org.springframework.security.config.http.SessionCreationPolicy;
import org.springframework.security.web.SecurityFilterChain;
import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;
import org.springframework.web.cors.CorsConfiguration;
import org.springframework.web.servlet.config.annotation.CorsRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
@Configuration
@EnableWebSecurity
@RequiredArgsConstructor
public class ApiSecurityConfig {
private final JwtAuthenticationFilter jwtAuthenticationFilter;
private final ApiUserDetailsService apiUserDetailsService;
@Bean
public SecurityFilterChain adminFilterChain(HttpSecurity http) throws Exception {
http.csrf(AbstractHttpConfigurer::disable)
// Spring Security 보안 필터 체인에서 CORS 허용
.cors(
cors ->
cors.configurationSource(
request -> {
var corsConfiguration = new CorsConfiguration();
corsConfiguration.setAllowedOrigins(List.of("*")); // 모든 도메인 허용
corsConfiguration.setAllowedMethods(
List.of("GET", "POST", "PUT", "DELETE", "PATCH", "OPTIONS"));
corsConfiguration.setAllowedHeaders(List.of("*"));
return corsConfiguration;
}))
.sessionManagement(
sessionConfigurer ->
sessionConfigurer.sessionCreationPolicy(SessionCreationPolicy.STATELESS))
.authorizeHttpRequests(
authRegistry ->
authRegistry
.requestMatchers(
"/v1/admin/auth/**",
"/v1/front/auth/**",
"/v1/front/user/create",
"/v1/front/uris/**",
"/v1/front/uicodes/**",
"/content-disposition/inline/**",
"/swagger-ui/**",
"/v3/api-docs/**")
.permitAll()
.requestMatchers("/v1/admin/**")
.hasAuthority("ADMIN_API")
.requestMatchers("/v1/front/**")
.hasAuthority("FRONT_API")
.anyRequest()
.authenticated())
.addFilterBefore(jwtAuthenticationFilter, UsernamePasswordAuthenticationFilter.class)
.userDetailsService(apiUserDetailsService);
return http.build();
}
// Spring MVC 에서 CORS 허용
@Bean
public WebMvcConfigurer corsConfigurer() {
return new WebMvcConfigurer() {
@Override
public void addCorsMappings(CorsRegistry registry) {
registry
.addMapping("/**") // 모든 경로에 대해 CORS 허용
.allowedOrigins("*") // 모든 도메인 허용
.allowedMethods("GET", "POST", "PUT", "DELETE", "PATCH",
"OPTIONS") // 허용할 HTTP 메서드
.allowedHeaders("*"); // 모든 헤더 허용
}
};
}
@Bean
public AuthenticationManager authenticationManager(HttpSecurity http) throws Exception {
return http.getSharedObject(AuthenticationManagerBuilder.class).build();
}
}

View File

@@ -1,32 +0,0 @@
package app.module.api.config.adapters.web.security;
import java.util.Collection;
import lombok.Getter;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.userdetails.User;
@Getter
public class ApiUser extends User {
private long remainPasswordDays;
public ApiUser(
String username,
String password,
boolean enabled,
boolean accountNonExpired,
boolean credentialsNonExpired,
boolean accountNonLocked,
Collection<? extends GrantedAuthority> authorities,
long remainPasswordDays) {
super(
username,
password,
enabled,
accountNonExpired,
credentialsNonExpired,
accountNonLocked,
authorities);
this.remainPasswordDays = remainPasswordDays;
}
}

View File

@@ -1,123 +0,0 @@
package app.module.api.config.adapters.web.security;
import app.module.core.config.adapters.web.security.domain.CorePrivilege;
import app.module.core.config.adapters.web.security.domain.CoreRole;
import app.module.core.usecase.admin.view.ports.AdminViewPortIn;
import app.module.core.usecase.admin.view.ports.application.domain.AdminView;
import app.module.core.usecase.user.findUser.ports.FindUserPortIn;
import app.module.core.usecase.user.findUser.ports.application.domain.FindUser;
import app.module.core.usecase.user.findUser.ports.application.domain.FindUserCmd;
import jakarta.servlet.http.HttpServletRequest;
import java.time.LocalDateTime;
import java.util.Collection;
import java.util.Optional;
import java.util.stream.Collectors;
import java.util.stream.Stream;
import lombok.RequiredArgsConstructor;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.authority.SimpleGrantedAuthority;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.core.userdetails.UsernameNotFoundException;
import org.springframework.stereotype.Service;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;
@Service
@RequiredArgsConstructor
public class ApiUserDetailsService implements UserDetailsService {
private final FindUserPortIn findUserPortIn;
private final AdminViewPortIn adminViewPortIn;
@Value("${app.api.password.validity.period.days}")
private long passwordValidPeriodDays;
@Override
public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
HttpServletRequest request =
((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();
String requestURI = request.getRequestURI();
if (requestURI.startsWith("/v1/admin/")) {
AdminView adminUser =
adminViewPortIn
.connect(username)
.orElseThrow(
() -> new UsernameNotFoundException("Invalid username or password."));
boolean accountLocked = Optional.ofNullable(adminUser.getAccountLocked()).orElse(false);
boolean accountDisabled = Optional.ofNullable(adminUser.getAccountDisabled())
.orElse(false);
return new ApiUser(
username,
adminUser.getPassword(),
!accountDisabled,
true,
isCredentialsNonExpired(adminUser.getPasswordUpdatedAt()),
!accountLocked,
getAuthorities(adminUser.getRoles()),
passwordValidPeriodDays - getDaysPassedFrom(adminUser.getPasswordUpdatedAt()));
} else if (requestURI.startsWith("/v1/front/")) {
FindUser findUser =
findUserPortIn
.operate(new FindUserCmd(username))
.orElseThrow(
() -> new UsernameNotFoundException("Invalid username or password."));
boolean accountLocked = Optional.ofNullable(findUser.getAccountLocked()).orElse(false);
boolean accountDisabled = Optional.ofNullable(findUser.getAccountDisabled())
.orElse(false);
return new ApiUser(
username,
findUser.getPassword(),
!accountDisabled,
true,
isCredentialsNonExpired(findUser.getPasswordUpdatedAt()),
!accountLocked,
getAuthorities(findUser.getRoles()),
passwordValidPeriodDays - getDaysPassedFrom(findUser.getPasswordUpdatedAt()));
}
return null;
}
/**
* Authorities (Role + Privileges) 합성. Role 과 Privileges 는 1:N 매핑되지만, 이 메서드를 통해 동일한 depth 로 배열에
* 담겨 반환된다. 즉, Privilege 는 또다른 종류의 Role 로 볼 수 있다.
*
* @param roles
* @return authorities
*/
private Collection<? extends GrantedAuthority> getAuthorities(Collection<CoreRole> roles) {
return Stream.concat(getRoles(roles), getPrivileges(roles))
.map(SimpleGrantedAuthority::new)
.collect(Collectors.toList());
}
private Stream<String> getRoles(Collection<CoreRole> roles) {
return roles.stream().map(CoreRole::getId);
}
private Stream<String> getPrivileges(Collection<CoreRole> roles) {
return roles.stream()
.flatMap(roleOutput -> roleOutput.getPrivileges().stream())
.map(CorePrivilege::getId);
}
// 패스워드 만료 여부체크. 이 기능이 필요하지 않다면 항상 true 를 반환하도록 변경하면 된다.
private boolean isCredentialsNonExpired(LocalDateTime passwordUpdatedAt) {
// return passwordValidPeriodDays == -1
// || getDaysPassedFrom(passwordUpdatedAt) <= passwordValidPeriodDays;
return true;
}
// 패스워드 만료일 정보를 반환. 이 기능이 필요하지 않다면 항상 0L 을 반환하도록 변경하면 된다.
private long getDaysPassedFrom(LocalDateTime passwordUpdatedAt) {
// return Duration.between(passwordUpdatedAt, LocalDateTime.now()).toDays();
return 0L;
}
}

View File

@@ -1,78 +0,0 @@
package app.module.api.config.adapters.web.swagger;
import io.swagger.v3.oas.models.Components;
import io.swagger.v3.oas.models.OpenAPI;
import io.swagger.v3.oas.models.info.Info;
import io.swagger.v3.oas.models.security.SecurityRequirement;
import io.swagger.v3.oas.models.security.SecurityScheme;
import org.apache.commons.lang3.StringUtils;
import org.springdoc.core.models.GroupedOpenApi;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
public class OpenAPIConfig {
@Value("${app.openapi.server.url:}")
private String serverURL;
@Value("${server.port:}")
private String serverPort;
@Bean
public OpenAPI openAPI() {
if (StringUtils.isEmpty(serverURL)) {
serverPort = StringUtils.isEmpty(serverPort) ? "8080" : serverPort;
serverURL = "http://localhost:" + serverPort;
}
return new OpenAPI()
.servers(
java.util.List.of(
new io.swagger.v3.oas.models.servers.Server()
.url(serverURL)
.description("Generated server url")))
.components(
new Components()
.addSecuritySchemes(
"bearer",
new SecurityScheme()
.type(SecurityScheme.Type.HTTP)
.scheme("bearer")
.bearerFormat("JWT")))
.info(new Info().title("recycle api").version("2.0.0"))
.addSecurityItem(new SecurityRequirement().addList("bearer"));
}
@Bean
public GroupedOpenApi adminGroup() {
return GroupedOpenApi.builder()
.group("ADMIN-API V1")
.pathsToMatch("/v1/admin/**")
.addOpenApiCustomizer(
openApi ->
openApi.info(
new Info()
.title("Recycle Admin API V1")
.version("2.0.0")
.description("api for administration")))
.build();
}
@Bean
public GroupedOpenApi frontGroup() {
return GroupedOpenApi.builder()
.group("FRONT-API V1")
.pathsToMatch("/v1/front/**")
.addOpenApiCustomizer(
openApi ->
openApi.info(
new Info()
.title("Recycle Front API V1")
.version("2.0.0")
.description("api for front")))
.build();
}
}

View File

@@ -1,60 +0,0 @@
package app.module.api.config.application.util;
import io.jsonwebtoken.Claims;
import io.jsonwebtoken.Jws;
import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.security.Keys;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import javax.crypto.SecretKey;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
@Component
public class JwtTokenProvider {
private final SecretKey secretKey;
private final long tokenValidityInMilliseconds;
public JwtTokenProvider(
@Value("${jwt.secret}") String secret,
@Value("${jwt.token-validity-in-seconds}") long tokenValidityInSeconds) {
this.secretKey = Keys.hmacShaKeyFor(secret.getBytes());
this.tokenValidityInMilliseconds = tokenValidityInSeconds * 1000;
}
public String createToken(String username, List<String> authorities) {
Date now = new Date();
Date validity = new Date(now.getTime() + tokenValidityInMilliseconds);
Map<String, List<String>> claims = new HashMap<>();
claims.put("authorities", authorities);
return Jwts.builder()
.subject(username)
.claims(claims)
.issuedAt(now)
.expiration(validity)
.signWith(secretKey)
.compact();
}
public String getUsername(String token) {
return parseClaims(token).getPayload().getSubject();
}
public boolean validateToken(String token) {
try {
parseClaims(token);
return true;
} catch (Exception e) {
return false;
}
}
public Jws<Claims> parseClaims(String token) {
return Jwts.parser().verifyWith(secretKey).build().parseSignedClaims(token);
}
}

View File

@@ -1,63 +0,0 @@
package app.module.api.frontUsecases.article.comment.createFrontArticleComment.adapter.web;
import app.module.api.frontUsecases.article.comment.createFrontArticleComment.adapter.web.model.CreateFrontArticleCommentReqVO;
import app.module.api.frontUsecases.article.comment.createFrontArticleComment.adapter.web.model.CreateFrontArticleCommentResVO;
import app.module.api.frontUsecases.article.createFrontArticle.adapter.web.model.CreateFrontArticleResVO;
import app.module.core.usecase.article.comment.createArticleComment.ports.CreateArticleCommentPortIn;
import app.module.core.usecase.article.comment.createArticleComment.ports.application.domain.CreateArticleComment;
import app.module.core.usecase.article.comment.createArticleComment.ports.application.domain.CreateArticleCommentCmd;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.media.Content;
import io.swagger.v3.oas.annotations.media.Schema;
import io.swagger.v3.oas.annotations.responses.ApiResponse;
import io.swagger.v3.oas.annotations.tags.Tag;
import jakarta.validation.Valid;
import lombok.RequiredArgsConstructor;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.validation.BindingResult;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;
@RestController
@RequiredArgsConstructor
@Tag(name = "ARTICLE COMMENT API", description = "예제 게시판 댓글 API")
class CreateFrontArticleCommentController {
private final CreateArticleCommentPortIn createArticleCommentPortIn;
@Operation(
summary = "예제 게시판 댓글 등록 API",
description = "Front 예제 게시판 게시물 등록",
requestBody =
@io.swagger.v3.oas.annotations.parameters.RequestBody(
description = "댓글 등록 요청 데이터",
content =
@Content(
mediaType = "application/json",
schema = @Schema(implementation = CreateFrontArticleCommentReqVO.class))),
responses = {
@ApiResponse(
description = "댓글 등록 응답 데이터",
content =
@Content(
mediaType = "application/json",
schema = @Schema(implementation = CreateFrontArticleCommentResVO.class)))
})
@PostMapping(path = "/v1/front/board/articles/comment/create")
ResponseEntity<?> operate(@Valid @RequestBody CreateFrontArticleCommentReqVO reqVO,
BindingResult bindingResult) {
if (bindingResult.hasErrors()) {
return ResponseEntity.status(HttpStatus.UNPROCESSABLE_ENTITY).body(bindingResult);
}
CreateArticleComment comment =
createArticleCommentPortIn.operate(
new CreateArticleCommentCmd(reqVO.getArticleId(), reqVO.getCommentContent()))
.orElseThrow();
return ResponseEntity.status(HttpStatus.OK)
.body(new CreateFrontArticleResVO(comment.getId(), comment.getContent()));
}
}

View File

@@ -1,31 +0,0 @@
package app.module.api.frontUsecases.article.comment.createFrontArticleComment.adapter.web.model;
import io.swagger.v3.oas.annotations.media.Schema;
import jakarta.validation.constraints.NotBlank;
import jakarta.validation.constraints.NotNull;
import lombok.AllArgsConstructor;
import lombok.EqualsAndHashCode;
import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.Setter;
import org.apache.commons.text.StringEscapeUtils;
@Getter
@Setter
@NoArgsConstructor
@AllArgsConstructor
@EqualsAndHashCode
@Schema(description = "댓글 등록 요청 데이터")
public class CreateFrontArticleCommentReqVO {
@NotNull(message = "{valid.article.comment.required}")
@Schema(description = "게시물 ID", example = "1")
private Long articleId;
@NotBlank(message = "{valid.article.comment.required}")
@Schema(description = "댓글 내용", example = "Create Comment")
private String commentContent;
public String getCommentContent() {
return StringEscapeUtils.escapeHtml4(commentContent);
}
}

View File

@@ -1,21 +0,0 @@
package app.module.api.frontUsecases.article.comment.createFrontArticleComment.adapter.web.model;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.AllArgsConstructor;
import lombok.EqualsAndHashCode;
import lombok.Getter;
import lombok.Setter;
@Getter
@Setter
@AllArgsConstructor
@EqualsAndHashCode
@Schema(description = "댓글 등록 응답 데이터")
public class CreateFrontArticleCommentResVO {
@Schema(description = "등록된 댓글 ID")
private Long commentId;
@Schema(description = "등록된 댓글 내용")
private String commentContent;
}

View File

@@ -1,74 +0,0 @@
package app.module.api.frontUsecases.article.comment.getFrontArticleComments.adapter.web;
import app.module.api.frontUsecases.article.comment.getFrontArticleComments.adapter.web.model.GetFrontArticleCommentsResVO;
import app.module.api.frontUsecases.article.getFrontArticle.adapter.web.model.GetFrontArticleResVO;
import app.module.core.usecase.article.comment.getArticleComments.ports.GetArticleCommentsPortIn;
import app.module.core.usecase.article.comment.getArticleComments.ports.application.domain.GetArticleComments;
import app.module.core.usecase.article.comment.getArticleComments.ports.application.domain.GetArticleCommentsCmd;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.Parameter;
import io.swagger.v3.oas.annotations.media.Content;
import io.swagger.v3.oas.annotations.media.Schema;
import io.swagger.v3.oas.annotations.responses.ApiResponse;
import io.swagger.v3.oas.annotations.tags.Tag;
import lombok.RequiredArgsConstructor;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.domain.Sort;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
@RestController
@RequiredArgsConstructor
@Tag(name = "ARTICLE COMMENT API", description = "예제 게시판 댓글 API")
class GetFrontArticleCommentsController {
private final GetArticleCommentsPortIn getArticleCommentsPortIn;
@Operation(
summary = "예제 게시판 댓글 목록 API",
description = "Front 예제 게시판 댓글 목록 조회",
responses = {
@ApiResponse(
description = "댓글 목록 응답 데이터",
content =
@Content(
mediaType = "application/json",
schema = @Schema(implementation = GetFrontArticleResVO.class)))
})
@GetMapping(path = "/v1/front/board/articles/comments")
ResponseEntity<?> operate(
@Parameter(description = "게시물 ID", example = "1")
@RequestParam(required = true)
Long articleId,
@Parameter(description = "페이지 번호 (0..N)")
@RequestParam(required = true, defaultValue = "0")
Integer page,
@Parameter(description = "페이지 크기 (0..N)")
@RequestParam(required = true, defaultValue = "10")
Integer size,
@Parameter(description = "정렬 (컬럼명,ASC|DESC)")
@RequestParam(required = true, defaultValue = "id,DESC")
String sort) {
Page<GetArticleComments> comments =
getArticleCommentsPortIn.operate(
PageRequest.of(
page,
size,
Sort.by(
new Sort.Order(
Sort.Direction.fromString(sort.split(",")[1]), sort.split(",")[0]))),
new GetArticleCommentsCmd(articleId));
return ResponseEntity.status(HttpStatus.OK)
.body(new GetFrontArticleCommentsResVO(comments.getContent(),
comments.getNumber(),
comments.getSize(),
comments.getTotalElements(),
comments.getTotalPages()));
}
}

View File

@@ -1,30 +0,0 @@
package app.module.api.frontUsecases.article.comment.getFrontArticleComments.adapter.web.model;
import app.module.core.usecase.article.comment.getArticleComments.ports.application.domain.GetArticleComments;
import io.swagger.v3.oas.annotations.media.Schema;
import java.util.List;
import lombok.AllArgsConstructor;
import lombok.EqualsAndHashCode;
import lombok.Getter;
import lombok.Setter;
@Getter
@Setter
@AllArgsConstructor
@EqualsAndHashCode
public class GetFrontArticleCommentsResVO {
@Schema(description = "예제 게시판 댓글 목록 데이터")
List<GetArticleComments> comments;
@Schema(description = "현재 페이지 번호")
private int page;
@Schema(description = "페이지 크기")
private int size;
@Schema(description = "전체 게시물 수")
private long totalElements;
@Schema(description = "전체 페이지 수")
private int totalPages;
}

View File

@@ -1,52 +0,0 @@
package app.module.api.frontUsecases.article.comment.removeFrontArticleComment.adapter.web;
import app.module.api.frontUsecases.article.comment.removeFrontArticleComment.adapter.web.model.RemoveFrontArticlesCommentReqVO;
import app.module.api.frontUsecases.article.comment.removeFrontArticleComment.adapter.web.model.RemoveFrontArticlesCommentResVO;
import app.module.core.usecase.article.comment.removeArticleComment.ports.RemoveArticleCommentPortIn;
import app.module.core.usecase.article.comment.removeArticleComment.ports.application.domain.RemoveArticleCommentCmd;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.media.Content;
import io.swagger.v3.oas.annotations.media.Schema;
import io.swagger.v3.oas.annotations.responses.ApiResponse;
import io.swagger.v3.oas.annotations.tags.Tag;
import lombok.RequiredArgsConstructor;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;
@RestController
@RequiredArgsConstructor
@Tag(name = "ARTICLE COMMENT API", description = "예제 게시판 댓글 API")
class RemoveFrontArticlesCommentController {
private final RemoveArticleCommentPortIn removeArticleCommentPortIn;
@DeleteMapping(path = "/v1/front/board/articles/comment/remove")
@Operation(
summary = "예제 게시판 댓글 삭제 API",
description = "Front 예제 게시판 댓글 삭제",
requestBody =
@io.swagger.v3.oas.annotations.parameters.RequestBody(
description = "댓글 삭제 요청 데이터",
content =
@Content(
mediaType = "application/json",
schema = @Schema(implementation = RemoveFrontArticlesCommentReqVO.class))),
responses = {
@ApiResponse(
description = "댓글 삭제 응답 데이터",
content =
@Content(
mediaType = "application/json",
schema = @Schema(implementation = RemoveFrontArticlesCommentResVO.class)))
})
ResponseEntity<?> operate(@RequestBody RemoveFrontArticlesCommentReqVO reqVO) {
removeArticleCommentPortIn.operate(new RemoveArticleCommentCmd(reqVO.getRemoveId()));
return ResponseEntity.status(HttpStatus.OK)
.body(new RemoveFrontArticlesCommentResVO(reqVO.getRemoveId()));
}
}

View File

@@ -1,20 +0,0 @@
package app.module.api.frontUsecases.article.comment.removeFrontArticleComment.adapter.web.model;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.AllArgsConstructor;
import lombok.EqualsAndHashCode;
import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.Setter;
@Getter
@Setter
@NoArgsConstructor
@AllArgsConstructor
@EqualsAndHashCode
@Schema(description = "댓글 삭제 요청 데이터")
public class RemoveFrontArticlesCommentReqVO {
@Schema(description = "삭제할 댓글 ID", example = "0")
private Long removeId;
}

View File

@@ -1,17 +0,0 @@
package app.module.api.frontUsecases.article.comment.removeFrontArticleComment.adapter.web.model;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.AllArgsConstructor;
import lombok.EqualsAndHashCode;
import lombok.Getter;
import lombok.Setter;
@Getter
@Setter
@AllArgsConstructor
@EqualsAndHashCode
@Schema(description = "댓글 삭제 응답 데이터")
public class RemoveFrontArticlesCommentResVO {
private Long removeId;
}

View File

@@ -1,67 +0,0 @@
package app.module.api.frontUsecases.article.comment.updateFrontArticleComment.adapters.web;
import app.module.api.frontUsecases.article.comment.updateFrontArticleComment.adapters.web.model.UpdateFrontArticlesCommentReqVO;
import app.module.api.frontUsecases.article.comment.updateFrontArticleComment.adapters.web.model.UpdateFrontArticlesCommentResVO;
import app.module.core.usecase.article.comment.updateArticleComment.ports.UpdateArticleCommentPortIn;
import app.module.core.usecase.article.comment.updateArticleComment.ports.application.domain.UpdateArticleComment;
import app.module.core.usecase.article.comment.updateArticleComment.ports.application.domain.UpdateArticleCommentCmd;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.media.Content;
import io.swagger.v3.oas.annotations.media.Schema;
import io.swagger.v3.oas.annotations.responses.ApiResponse;
import io.swagger.v3.oas.annotations.tags.Tag;
import jakarta.validation.Valid;
import lombok.RequiredArgsConstructor;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.validation.BindingResult;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;
@RestController
@RequiredArgsConstructor
@Tag(name = "ARTICLE COMMENT API", description = "예제 게시판 댓글 API")
class UpdateFrontArticlesCommentController {
private final UpdateArticleCommentPortIn updateArticleCommentPortIn;
@PutMapping(path = "/v1/front/board/articles/comment/update")
@Operation(
summary = "예제 게시판 댓글 수정 API",
description = "Front 예제 게시판 댓글 수정",
requestBody =
@io.swagger.v3.oas.annotations.parameters.RequestBody(
description = "댓글 수정 요청 데이터",
content =
@Content(
mediaType = "application/json",
schema = @Schema(implementation = UpdateFrontArticlesCommentReqVO.class))),
responses = {
@ApiResponse(
description = "댓글 수정 응답 데이터",
content =
@Content(
mediaType = "application/json",
schema = @Schema(implementation = UpdateFrontArticlesCommentResVO.class)))
})
ResponseEntity<?> operate(
@Valid @RequestBody UpdateFrontArticlesCommentReqVO reqVO,
BindingResult bindingResult) {
if (bindingResult.hasErrors()) {
return ResponseEntity.status(HttpStatus.UNPROCESSABLE_ENTITY).body(bindingResult);
}
UpdateArticleComment comment =
updateArticleCommentPortIn.operate(
new UpdateArticleCommentCmd(
reqVO.getCommentId(),
reqVO.getCommentContent(),
reqVO.getArticleId()))
.orElseThrow();
return ResponseEntity.status(HttpStatus.OK)
.body(new UpdateFrontArticlesCommentResVO(comment.getId(), comment.getContent()));
}
}

View File

@@ -1,34 +0,0 @@
package app.module.api.frontUsecases.article.comment.updateFrontArticleComment.adapters.web.model;
import io.swagger.v3.oas.annotations.media.Schema;
import jakarta.validation.constraints.NotBlank;
import jakarta.validation.constraints.NotNull;
import lombok.AllArgsConstructor;
import lombok.EqualsAndHashCode;
import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.Setter;
import org.apache.commons.text.StringEscapeUtils;
@Getter
@Setter
@NoArgsConstructor
@AllArgsConstructor
@EqualsAndHashCode
@Schema(description = "댓글 수정 요청 데이터")
public class UpdateFrontArticlesCommentReqVO {
@NotNull(message = "{valid.article.comment.required}")
@Schema(description = "댓글 ID", example = "0")
private Long commentId;
@NotBlank(message = "{valid.article.comment.required}")
@Schema(description = "댓글 내용", example = "Update Article No.0 Comment")
private String commentContent;
@Schema(description = "게시물 ID", example = "1")
@NotNull(message = "{valid.article.comment.required}")
private Long articleId;
public String getCommentContent() {
return StringEscapeUtils.escapeHtml4(commentContent);
}
}

View File

@@ -1,22 +0,0 @@
package app.module.api.frontUsecases.article.comment.updateFrontArticleComment.adapters.web.model;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.AllArgsConstructor;
import lombok.EqualsAndHashCode;
import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.Setter;
@Getter
@Setter
@NoArgsConstructor
@AllArgsConstructor
@EqualsAndHashCode
@Schema(description = "댓글 수정 응답 데이터")
public class UpdateFrontArticlesCommentResVO {
@Schema(description = "수정된 댓글 ID")
private Long commentId;
@Schema(description = "수정된 댓글 내용")
private String commentContent;
}

View File

@@ -1,70 +0,0 @@
package app.module.api.frontUsecases.article.createFrontArticle.adapter.web;
import app.module.api.frontUsecases.article.createFrontArticle.adapter.web.model.CreateFrontArticleReqVO;
import app.module.api.frontUsecases.article.createFrontArticle.adapter.web.model.CreateFrontArticleResVO;
import app.module.api.frontUsecases.article.createFrontArticle.adapter.web.validator.CreateFrontArticleValidator;
import app.module.core.usecase.article.createArticle.ports.CreateArticlePortIn;
import app.module.core.usecase.article.createArticle.ports.application.domain.CreateArticleCmd;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.media.Content;
import io.swagger.v3.oas.annotations.media.Schema;
import io.swagger.v3.oas.annotations.responses.ApiResponse;
import io.swagger.v3.oas.annotations.tags.Tag;
import jakarta.validation.Valid;
import lombok.RequiredArgsConstructor;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.validation.BindingResult;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;
@RestController
@RequiredArgsConstructor
@Tag(name = "ARTICLE API", description = "예제 게시판 API")
class CreateFrontArticleController {
private final CreateArticlePortIn createArticlePortIn;
private final CreateFrontArticleValidator createArticleValidator;
@Operation(
summary = "예제 게시판 게시물 등록 API",
description = "Front 예제 게시판 게시물 등록",
requestBody =
@io.swagger.v3.oas.annotations.parameters.RequestBody(
description = "게시물 등록 요청 데이터",
content =
@Content(
mediaType = "application/json",
schema = @Schema(implementation = CreateFrontArticleReqVO.class))),
responses = {
@ApiResponse(
description = "게시물 등록 응답 데이터",
content =
@Content(
mediaType = "application/json",
schema = @Schema(implementation = CreateFrontArticleResVO.class)))
})
@PostMapping(path = "/v1/front/board/articles/create")
ResponseEntity<?> operate(
@Valid @RequestBody CreateFrontArticleReqVO reqVO,
BindingResult bindingResult) {
createArticleValidator.validate(reqVO, bindingResult);
if (bindingResult.hasErrors()) {
return ResponseEntity.status(HttpStatus.UNPROCESSABLE_ENTITY).body(bindingResult);
}
return ResponseEntity.status(HttpStatus.OK)
.body(createArticlePortIn.operate(new CreateArticleCmd(
reqVO.getTitle(),
reqVO.getContent(),
reqVO.getVisible(),
reqVO.getStartDate(),
reqVO.getEndDate(),
reqVO.getFileMappingId()))
.map(article -> new CreateFrontArticleResVO(article.getId(), reqVO.getTitle()))
.orElseThrow());
}
}

View File

@@ -1,55 +0,0 @@
package app.module.api.frontUsecases.article.createFrontArticle.adapter.web.model;
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 java.time.LocalDateTime;
import java.util.List;
import lombok.AllArgsConstructor;
import lombok.EqualsAndHashCode;
import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.Setter;
import org.apache.commons.text.StringEscapeUtils;
@Getter
@Setter
@NoArgsConstructor
@AllArgsConstructor
@EqualsAndHashCode
public class CreateFrontArticleReqVO {
@NotBlank(message = "{valid.common.required}")
@Schema(description = "제목", example = "Article No.25")
private String title;
@NotBlank(message = "{valid.common.required}")
@Schema(description = "내용", example = "Content No.25")
private String content;
@NotNull(message = "{valid.common.required}")
@Schema(description = "공개여부", example = "true")
private Boolean visible;
@NotNull(message = "{valid.common.required}")
@Schema(description = "시작날짜", type = "string", example = "2025-03-07T08:38")
@JsonFormat(shape = JsonFormat.Shape.STRING, pattern = "yyyy-MM-dd'T'HH:mm")
private LocalDateTime startDate;
@NotNull(message = "{valid.common.required}")
@Schema(description = "종료날짜", type = "string", example = "2025-05-07T08:38")
@JsonFormat(shape = JsonFormat.Shape.STRING, pattern = "yyyy-MM-dd'T'HH:mm")
private LocalDateTime endDate;
@Schema(description = "파일 매핑 ID", nullable = true, defaultValue = "[]")
private List<String> fileMappingId;
public String getTitle() {
return StringEscapeUtils.escapeHtml4(title);
}
public String getContent() {
return StringEscapeUtils.escapeHtml4(content);
}
}

View File

@@ -1,20 +0,0 @@
package app.module.api.frontUsecases.article.createFrontArticle.adapter.web.model;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.AllArgsConstructor;
import lombok.EqualsAndHashCode;
import lombok.Getter;
import lombok.Setter;
@Getter
@Setter
@AllArgsConstructor
@EqualsAndHashCode
@Schema(description = "게시물 등록 응답 데이터")
public class CreateFrontArticleResVO {
@Schema(description = "등록된 게시물 ID")
private Long id;
@Schema(description = "등록된 게시물 제목")
private String title;
}

View File

@@ -1,55 +0,0 @@
package app.module.api.frontUsecases.article.createFrontArticle.adapter.web.validator;
import app.module.api.frontUsecases.article.createFrontArticle.adapter.web.model.CreateFrontArticleReqVO;
import app.module.core.config.application.util.MessageUtil;
import java.time.LocalDateTime;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Component;
import org.springframework.validation.Errors;
import org.springframework.validation.Validator;
@Component
@RequiredArgsConstructor
public class CreateFrontArticleValidator implements Validator {
private final MessageUtil messageUtil;
@Override
public boolean supports(Class<?> clazz) {
return CreateFrontArticleReqVO.class.equals(clazz);
}
@Override
public void validate(Object target, Errors errors) {
CreateFrontArticleReqVO vo = (CreateFrontArticleReqVO) target;
LocalDateTime startDate = vo.getStartDate();
LocalDateTime endDate = vo.getEndDate();
// 게시일 날짜 체크
if (startDate == null) {
errors.rejectValue(
"startDate", "valid.common.required",
messageUtil.getMessage("valid.common.required"));
}
if (endDate == null) {
errors.rejectValue(
"endDate", "valid.common.required",
messageUtil.getMessage("valid.common.required"));
}
if (startDate != null && endDate != null) {
if (!startDate.isBefore(endDate)) {
errors.rejectValue(
"startDate",
"valid.common.date.invalid",
messageUtil.getMessage("valid.common.date.invalid"));
errors.rejectValue(
"endDate",
"valid.common.date.invalid",
messageUtil.getMessage("valid.common.date.invalid"));
}
}
}
}

View File

@@ -1,60 +0,0 @@
package app.module.api.frontUsecases.article.getFrontArticle.adapter.web;
import app.module.api.frontUsecases.article.getFrontArticle.adapter.web.model.GetFrontArticleResVO;
import app.module.core.usecase.article.getArticle.ports.GetArticlePortIn;
import app.module.core.usecase.article.getArticle.ports.application.domain.GetArticle;
import app.module.core.usecase.article.getArticle.ports.application.domain.GetArticleCmd;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.media.Content;
import io.swagger.v3.oas.annotations.media.Schema;
import io.swagger.v3.oas.annotations.responses.ApiResponse;
import io.swagger.v3.oas.annotations.tags.Tag;
import lombok.RequiredArgsConstructor;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;
@RestController
@RequiredArgsConstructor
@Tag(name = "ARTICLE API", description = "예제 게시판 API")
class GetFrontArticleController {
private final GetArticlePortIn getArticlePortIn;
@Operation(
summary = "예제 게시판 게시물 상세 API",
description = "Front 예제 게시판 게시물 상세 조회",
responses = {
@ApiResponse(
description = "게시물 상세 응답 데이터",
content =
@Content(
mediaType = "application/json",
schema = @Schema(implementation = GetFrontArticleResVO.class)))
})
@GetMapping(path = "/v1/front/board/articles/{id}")
ResponseEntity<GetFrontArticleResVO> operate(
@PathVariable @Schema(description = "게시물 ID", example = "1") Long id) {
GetArticle article =
getArticlePortIn.operate(new GetArticleCmd(id)).orElseThrow();
return ResponseEntity.status(HttpStatus.OK)
.body(new GetFrontArticleResVO(
article.getCreatedAt(),
article.getCreatedBy(),
article.getUpdatedAt(),
article.getUpdatedBy(),
article.getId(),
article.getTitle(),
article.getContent(),
article.getVisible(),
article.getStartDate(),
article.getEndDate(),
article.getOrderNo(),
article.getUploadFiles()
));
}
}

View File

@@ -1,43 +0,0 @@
package app.module.api.frontUsecases.article.getFrontArticle.adapter.web.model;
import app.module.core.usecase.article.getArticle.ports.application.domain.GetArticleUploadFile;
import io.swagger.v3.oas.annotations.media.Schema;
import java.time.LocalDateTime;
import java.util.List;
import lombok.AllArgsConstructor;
import lombok.EqualsAndHashCode;
import lombok.Getter;
import lombok.Setter;
@Getter
@Setter
@AllArgsConstructor
@EqualsAndHashCode
@Schema(description = "Front 예제 게시판 게시물 상세")
public class GetFrontArticleResVO {
@Schema(description = "생성일")
private LocalDateTime createdAt;
@Schema(description = "생성자")
private String createdBy;
@Schema(description = "수정일")
private LocalDateTime updatedAt;
@Schema(description = "수정자")
private String updatedBy;
@Schema(description = "게시물 ID")
private Long id;
@Schema(description = "제목")
private String title;
@Schema(description = "내용")
private String content;
@Schema(description = "공개여부")
private Boolean visible;
@Schema(description = "시작일")
private LocalDateTime startDate;
@Schema(description = "종료일")
private LocalDateTime endDate;
@Schema(description = "정렬번호")
private Integer orderNo;
@Schema(description = "업로드파일")
private List<GetArticleUploadFile> uploadFiles;
}

View File

@@ -1,82 +0,0 @@
package app.module.api.frontUsecases.article.getFrontArticles.adapters.web;
import app.module.api.frontUsecases.article.getFrontArticles.adapters.web.model.GetFrontArticlesResVO;
import app.module.core.usecase.article.getArticles.ports.GetArticlesPortIn;
import app.module.core.usecase.article.getArticles.ports.application.domain.GetArticles;
import app.module.core.usecase.article.getArticles.ports.application.domain.GetArticlesCmd;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.Parameter;
import io.swagger.v3.oas.annotations.media.Content;
import io.swagger.v3.oas.annotations.media.Schema;
import io.swagger.v3.oas.annotations.responses.ApiResponse;
import io.swagger.v3.oas.annotations.tags.Tag;
import lombok.RequiredArgsConstructor;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.domain.Sort;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
@RestController
@RequiredArgsConstructor
@Tag(name = "ARTICLE API", description = "예제 게시판 API")
class GetFrontArticlesController {
private final GetArticlesPortIn getArticlesPortIn;
@Operation(
summary = "예제 게시판 게시물 목록 API",
description = "Front 예제 게시판 게시물 목록 조회",
responses = {
@ApiResponse(
description = "게시물 목록 응답 데이터",
content =
@Content(
mediaType = "application/json",
schema = @Schema(implementation = GetFrontArticlesResVO.class)))
})
@GetMapping(path = "/v1/front/board/articles")
ResponseEntity<GetFrontArticlesResVO> operate(
@Parameter(description = "검색 필드 조건")
@RequestParam(required = false)
@Schema(allowableValues = {"title", "updatedBy"})
String searchField,
@Parameter(description = "검색 필드 검색어")
@RequestParam(required = false)
String searchValue,
@Parameter(description = "공개여부 검색")
@RequestParam(required = false)
@Schema(allowableValues = {"true", "false"})
String searchOpen,
@Parameter(description = "페이지 번호 (0..N)")
@RequestParam(required = true, defaultValue = "0")
Integer page,
@Parameter(description = "페이지 크기 (0..N)")
@RequestParam(required = true, defaultValue = "10")
Integer size,
@Parameter(description = "정렬 (컬럼명,ASC|DESC)")
@RequestParam(required = true, defaultValue = "orderNo,DESC")
String sort) {
Page<GetArticles> result =
getArticlesPortIn.operate(
PageRequest.of(
page,
size,
Sort.by(
new Sort.Order(
Sort.Direction.fromString(sort.split(",")[1]), sort.split(",")[0]))),
new GetArticlesCmd(searchField, searchValue, searchOpen));
return ResponseEntity.status(HttpStatus.OK)
.body(new GetFrontArticlesResVO(
result.getContent(),
result.getNumber(),
result.getSize(),
result.getTotalElements(),
result.getTotalPages()));
}
}

View File

@@ -1,30 +0,0 @@
package app.module.api.frontUsecases.article.getFrontArticles.adapters.web.model;
import app.module.core.usecase.article.getArticles.ports.application.domain.GetArticles;
import io.swagger.v3.oas.annotations.media.Schema;
import java.util.List;
import lombok.AllArgsConstructor;
import lombok.EqualsAndHashCode;
import lombok.Getter;
import lombok.Setter;
@Getter
@Setter
@AllArgsConstructor
@EqualsAndHashCode
public class GetFrontArticlesResVO {
@Schema(description = "예제 게시판 목록 데이터")
List<GetArticles> articles;
@Schema(description = "현재 페이지 번호")
private int page;
@Schema(description = "페이지 크기")
private int size;
@Schema(description = "전체 게시물 수")
private long totalElements;
@Schema(description = "전체 페이지 수")
private int totalPages;
}

View File

@@ -1,59 +0,0 @@
package app.module.api.frontUsecases.article.removeFrontArticles.adapters.web;
import app.module.api.frontUsecases.article.removeFrontArticles.adapters.web.model.RemoveFrontArticlesReqVO;
import app.module.api.frontUsecases.article.removeFrontArticles.adapters.web.model.RemoveFrontArticlesResVO;
import app.module.core.usecase.article.removeArticles.ports.RemoveArticlesPortIn;
import app.module.core.usecase.article.removeArticles.ports.application.domain.RemoveArticlesCmd;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.media.Content;
import io.swagger.v3.oas.annotations.media.Schema;
import io.swagger.v3.oas.annotations.responses.ApiResponse;
import io.swagger.v3.oas.annotations.tags.Tag;
import jakarta.validation.Valid;
import lombok.RequiredArgsConstructor;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.validation.BindingResult;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;
@RestController
@RequiredArgsConstructor
@Tag(name = "ARTICLE API", description = "예제 게시판 API")
class RemoveFrontArticlesController {
private final RemoveArticlesPortIn removeArticlesPortIn;
@Operation(
summary = "예제 게시판 게시물 삭제 API",
description = "Front 예제 게시판 게시물 다건 삭제",
requestBody =
@io.swagger.v3.oas.annotations.parameters.RequestBody(
description = "게시물 다건 삭제 요청 데이터",
content =
@Content(
mediaType = "application/json",
schema = @Schema(implementation = RemoveFrontArticlesReqVO.class))),
responses = {
@ApiResponse(
description = "게시물 다건 삭제 응답 데이터",
content =
@Content(
mediaType = "application/json",
schema = @Schema(implementation = RemoveFrontArticlesResVO.class)))
})
@DeleteMapping(path = "/v1/front/board/articles/remove")
ResponseEntity<?> operate(
@Valid @RequestBody RemoveFrontArticlesReqVO reqVO,
BindingResult bindingResult) {
if (bindingResult.hasErrors()) {
return ResponseEntity.status(HttpStatus.UNPROCESSABLE_ENTITY).body(bindingResult);
}
removeArticlesPortIn.operate(new RemoveArticlesCmd(reqVO.getSelectIds()));
return ResponseEntity.status(HttpStatus.OK)
.body(new RemoveFrontArticlesResVO(reqVO.getSelectIds()));
}
}

View File

@@ -1,21 +0,0 @@
package app.module.api.frontUsecases.article.removeFrontArticles.adapters.web.model;
import io.swagger.v3.oas.annotations.media.Schema;
import java.util.Set;
import lombok.AllArgsConstructor;
import lombok.EqualsAndHashCode;
import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.Setter;
@Getter
@Setter
@NoArgsConstructor
@AllArgsConstructor
@EqualsAndHashCode
@Schema(description = "삭제할 게시물 ID 목록 요청 파라미터")
public class RemoveFrontArticlesReqVO {
@Schema(description = "삭제할 게시물 ID", example = "[24,25]")
private Set<Long> selectIds;
}

View File

@@ -1,18 +0,0 @@
package app.module.api.frontUsecases.article.removeFrontArticles.adapters.web.model;
import io.swagger.v3.oas.annotations.media.Schema;
import java.util.Set;
import lombok.AllArgsConstructor;
import lombok.EqualsAndHashCode;
import lombok.Getter;
import lombok.Setter;
@Getter
@Setter
@AllArgsConstructor
@EqualsAndHashCode
@Schema(description = "게시물 삭제 응답 데이터")
public class RemoveFrontArticlesResVO {
private Set<Long> selectIds;
}

View File

@@ -1,72 +0,0 @@
package app.module.api.frontUsecases.article.updateFrontArticle.adapters.web;
import app.module.api.frontUsecases.article.updateFrontArticle.adapters.web.model.UpdateFrontArticleReqVO;
import app.module.api.frontUsecases.article.updateFrontArticle.adapters.web.model.UpdateFrontArticleResVO;
import app.module.api.frontUsecases.article.updateFrontArticle.adapters.web.validator.UpdateFrontArticleValidator;
import app.module.core.usecase.article.updateArticle.ports.UpdateArticlePortIn;
import app.module.core.usecase.article.updateArticle.ports.application.domain.UpdateArticleCmd;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.media.Content;
import io.swagger.v3.oas.annotations.media.Schema;
import io.swagger.v3.oas.annotations.responses.ApiResponse;
import io.swagger.v3.oas.annotations.tags.Tag;
import jakarta.validation.Valid;
import lombok.RequiredArgsConstructor;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.validation.BindingResult;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;
@RestController
@RequiredArgsConstructor
@Tag(name = "ARTICLE API", description = "예제 게시판 API")
class UpdateFrontArticleController {
private final UpdateArticlePortIn updateArticlePortIn;
private final UpdateFrontArticleValidator updateFrontArticleValidator;
@Operation(
summary = "예제 게시판 게시물 수정 API",
description = "Front 예제 게시판 게시물 수정",
requestBody =
@io.swagger.v3.oas.annotations.parameters.RequestBody(
description = "게시물 수정 요청 데이터",
content =
@Content(
mediaType = "application/json",
schema = @Schema(implementation = UpdateFrontArticleReqVO.class))),
responses = {
@ApiResponse(
description = "게시물 수정 응답 데이터",
content =
@Content(
mediaType = "application/json",
schema = @Schema(implementation = UpdateFrontArticleResVO.class)))
})
@PutMapping(path = "/v1/front/board/articles/update")
ResponseEntity<?> operate(
@Valid @RequestBody UpdateFrontArticleReqVO reqVO, BindingResult bindingResult) {
updateFrontArticleValidator.validate(reqVO, bindingResult);
if (bindingResult.hasErrors()) {
return ResponseEntity.status(HttpStatus.UNPROCESSABLE_ENTITY).body(bindingResult);
}
updateArticlePortIn.operate(
new UpdateArticleCmd(
reqVO.getId(),
reqVO.getTitle(),
reqVO.getContent(),
reqVO.getVisible(),
reqVO.getOrderNo(),
reqVO.getStartDate(),
reqVO.getEndDate(),
reqVO.getFileMappingId()));
return ResponseEntity.status(HttpStatus.OK)
.body(new UpdateFrontArticleResVO(reqVO.getId(), reqVO.getTitle()));
}
}

View File

@@ -1,64 +0,0 @@
package app.module.api.frontUsecases.article.updateFrontArticle.adapters.web.model;
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 java.time.LocalDateTime;
import java.util.List;
import lombok.AllArgsConstructor;
import lombok.EqualsAndHashCode;
import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.Setter;
import org.apache.commons.text.StringEscapeUtils;
@Getter
@Setter
@NoArgsConstructor
@AllArgsConstructor
@EqualsAndHashCode
@Schema(description = "게시물 수정 요청 데이터")
public class UpdateFrontArticleReqVO {
@NotNull(message = "{valid.common.required}")
@Schema(description = "게시물 id", example = "1")
private Long id;
@NotBlank(message = "{valid.common.required}")
@Schema(description = "제목", example = "Update Article No.0")
private String title;
@NotBlank(message = "{valid.common.required}")
@Schema(description = "내용", example = "Update Content No.0")
private String content;
@NotNull(message = "{valid.common.required}")
@Schema(description = "공개여부", example = "true")
private Boolean visible;
@NotNull(message = "{valid.common.required}")
@Schema(description = "정렬번호", example = "0")
private Integer orderNo;
@NotNull(message = "{valid.common.required}")
@Schema(description = "시작날짜", type = "string", example = "2025-03-07T08:38")
@JsonFormat(shape = JsonFormat.Shape.STRING, pattern = "yyyy-MM-dd'T'HH:mm")
private LocalDateTime startDate;
@NotNull(message = "{valid.common.required}")
@Schema(description = "종료날짜", type = "string", example = "2025-05-07T08:38")
@JsonFormat(shape = JsonFormat.Shape.STRING, pattern = "yyyy-MM-dd'T'HH:mm")
private LocalDateTime endDate;
@Schema(description = "파일 매핑 ID", nullable = true, defaultValue = "[]")
private List<String> fileMappingId;
public String getTitle() {
return StringEscapeUtils.escapeHtml4(title);
}
public String getContent() {
return StringEscapeUtils.escapeHtml4(content);
}
}

View File

@@ -1,20 +0,0 @@
package app.module.api.frontUsecases.article.updateFrontArticle.adapters.web.model;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.AllArgsConstructor;
import lombok.EqualsAndHashCode;
import lombok.Getter;
import lombok.Setter;
@Getter
@Setter
@AllArgsConstructor
@EqualsAndHashCode
@Schema(description = "게시물 수정 응답 데이터")
public class UpdateFrontArticleResVO {
@Schema(description = "수정된 게시물 ID")
private Long id;
@Schema(description = "수정된 게시물 제목")
private String title;
}

View File

@@ -1,55 +0,0 @@
package app.module.api.frontUsecases.article.updateFrontArticle.adapters.web.validator;
import app.module.api.frontUsecases.article.updateFrontArticle.adapters.web.model.UpdateFrontArticleReqVO;
import app.module.core.config.application.util.MessageUtil;
import java.time.LocalDateTime;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Component;
import org.springframework.validation.Errors;
import org.springframework.validation.Validator;
@Component
@RequiredArgsConstructor
public class UpdateFrontArticleValidator implements Validator {
private final MessageUtil messageUtil;
@Override
public boolean supports(Class<?> clazz) {
return UpdateFrontArticleReqVO.class.equals(clazz);
}
@Override
public void validate(Object target, Errors errors) {
UpdateFrontArticleReqVO vo = (UpdateFrontArticleReqVO) target;
LocalDateTime startDate = vo.getStartDate();
LocalDateTime endDate = vo.getEndDate();
// 게시일 날짜 체크
if (startDate == null) {
errors.rejectValue(
"startDate", "valid.common.required",
messageUtil.getMessage("valid.common.required"));
}
if (endDate == null) {
errors.rejectValue(
"endDate", "valid.common.required",
messageUtil.getMessage("valid.common.required"));
}
if (startDate != null && endDate != null) {
if (!startDate.isBefore(endDate)) {
errors.rejectValue(
"startDate",
"valid.common.date.invalid",
messageUtil.getMessage("valid.common.date.invalid"));
errors.rejectValue(
"endDate",
"valid.common.date.invalid",
messageUtil.getMessage("valid.common.date.invalid"));
}
}
}
}

View File

@@ -1,64 +0,0 @@
package app.module.api.frontUsecases.auth.frontLogin.adapters.web;
import app.module.api.config.application.util.JwtTokenProvider;
import app.module.api.frontUsecases.auth.frontLogin.adapters.web.model.FrontLoginReqVO;
import app.module.api.frontUsecases.auth.frontLogin.adapters.web.model.FrontLoginResVO;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.media.Content;
import io.swagger.v3.oas.annotations.media.Schema;
import io.swagger.v3.oas.annotations.responses.ApiResponse;
import io.swagger.v3.oas.annotations.tags.Tag;
import jakarta.validation.Valid;
import java.util.stream.Collectors;
import lombok.RequiredArgsConstructor;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.security.authentication.AuthenticationManager;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.validation.BindingResult;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;
@RestController
@RequiredArgsConstructor
@Tag(name = "Front Auth API", description = "사용자 로그인 API")
public class FrontLoginController {
private final AuthenticationManager authenticationManager;
private final JwtTokenProvider jwtTokenProvider;
@PostMapping(path = "/v1/front/auth/login")
@Operation(
summary = "사용자 로그인",
description = "사용자 인증 API",
responses = {
@ApiResponse(
content =
@Content(
mediaType = "application/json",
schema = @Schema(implementation = FrontLoginResVO.class)))
})
ResponseEntity<?> operate(
@Valid @RequestBody FrontLoginReqVO reqVO, BindingResult bindingResult) {
if (bindingResult.hasErrors()) {
return ResponseEntity.status(HttpStatus.UNPROCESSABLE_ENTITY).body(bindingResult);
}
UsernamePasswordAuthenticationToken authenticationToken =
new UsernamePasswordAuthenticationToken(reqVO.getUsername(), reqVO.getPassword());
Authentication authentication = authenticationManager.authenticate(authenticationToken);
return ResponseEntity.status(HttpStatus.OK)
.body(
new FrontLoginResVO(
jwtTokenProvider.createToken(
authentication.getName(),
authentication.getAuthorities().stream()
.map(GrantedAuthority::getAuthority)
.collect(Collectors.toList()))));
}
}

View File

@@ -1,21 +0,0 @@
package app.module.api.frontUsecases.auth.frontLogin.adapters.web.model;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.AllArgsConstructor;
import lombok.EqualsAndHashCode;
import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.Setter;
@Getter
@Setter
@NoArgsConstructor
@AllArgsConstructor
@EqualsAndHashCode
public class FrontLoginReqVO {
@Schema(description = "사용자 계정", example = "generalUser")
private String username;
@Schema(description = "사용자 패스워드", example = "generalUser1@#$")
private String password;
}

View File

@@ -1,15 +0,0 @@
package app.module.api.frontUsecases.auth.frontLogin.adapters.web.model;
import lombok.AllArgsConstructor;
import lombok.EqualsAndHashCode;
import lombok.Getter;
import lombok.Setter;
@Getter
@Setter
@AllArgsConstructor
@EqualsAndHashCode
public class FrontLoginResVO {
private String jwtToken;
}

View File

@@ -1,78 +0,0 @@
package app.module.api.frontUsecases.file.createFile.adapters.web;
import app.module.api.frontUsecases.file.createFile.adapters.web.model.CreateFileReqVO;
import app.module.api.frontUsecases.file.createFile.adapters.web.model.CreateFileResVO;
import app.module.core.usecase.file.createFile.ports.CreateFilePortIn;
import app.module.core.usecase.file.createFile.ports.application.domain.CreateFile;
import app.module.core.usecase.file.createFile.ports.application.domain.CreateFileCmd;
import app.module.core.usecase.file.saveToStorage.ports.SaveToStoragePortIn;
import app.module.core.usecase.file.saveToStorage.ports.application.domain.SaveToStorage;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.media.Content;
import io.swagger.v3.oas.annotations.media.Schema;
import io.swagger.v3.oas.annotations.responses.ApiResponse;
import io.swagger.v3.oas.annotations.tags.Tag;
import jakarta.validation.Valid;
import java.io.IOException;
import lombok.RequiredArgsConstructor;
import org.springframework.http.HttpStatus;
import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity;
import org.springframework.validation.BindingResult;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
@RequiredArgsConstructor
@Tag(name = "FILE API")
class CreateFileFrontAPIController {
private final SaveToStoragePortIn saveToStoragePortIn;
private final CreateFilePortIn createFilePortIn;
@PostMapping(path = "/v1/front/file/create")
@Operation(
summary = "CreateFile API",
description = "CreateFile",
requestBody =
@io.swagger.v3.oas.annotations.parameters.RequestBody(
description = "CreateFile request",
content =
@Content(
mediaType = MediaType.MULTIPART_FORM_DATA_VALUE,
schema = @Schema(implementation = CreateFileReqVO.class))),
responses = {
@ApiResponse(
description = "CreateFile response",
content =
@Content(
mediaType = "application/json",
schema = @Schema(implementation = CreateFileResVO.class)))
})
ResponseEntity<?> operate(@Valid CreateFileReqVO reqVO, BindingResult bindingResult)
throws IOException {
if (bindingResult.hasErrors()) {
return ResponseEntity.status(HttpStatus.UNPROCESSABLE_ENTITY).body(bindingResult);
}
// storage 에 물리적 파일 저장. `LOCAL` or `S3`
SaveToStorage saveToStorage =
saveToStoragePortIn
.operate(reqVO.getFileUploadType(), reqVO.getFile())
.orElseThrow(() -> new RuntimeException("물리적 파일 저장에 실패했습니다."));
// DB 에 파일정보 저장
CreateFile createFile =
createFilePortIn
.operate(
new CreateFileCmd(
saveToStorage.getType(),
saveToStorage.getPath(),
saveToStorage.getName(),
saveToStorage.getOriginName(),
saveToStorage.getFileLength()))
.orElseThrow(() -> new RuntimeException("업로드 파일정보 DB 저장에 실패했습니다."));
return ResponseEntity.status(HttpStatus.OK).body(new CreateFileResVO(createFile));
}
}

View File

@@ -1,25 +0,0 @@
package app.module.api.frontUsecases.file.createFile.adapters.web.model;
import app.module.core.config.application.enums.FileUploadType;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.AllArgsConstructor;
import lombok.EqualsAndHashCode;
import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.Setter;
import org.springframework.web.multipart.MultipartFile;
@Getter
@Setter
@NoArgsConstructor
@AllArgsConstructor
@EqualsAndHashCode
@Schema(description = "CreateFile request")
public class CreateFileReqVO {
@Schema(description = "파일 업로드 타입", example = "EXAMPLE_PUBLIC")
private FileUploadType fileUploadType;
@Schema(description = "업로드 파일")
private MultipartFile file;
}

View File

@@ -1,18 +0,0 @@
package app.module.api.frontUsecases.file.createFile.adapters.web.model;
import app.module.core.usecase.file.createFile.ports.application.domain.CreateFile;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.AllArgsConstructor;
import lombok.EqualsAndHashCode;
import lombok.Getter;
import lombok.Setter;
@Getter
@Setter
@AllArgsConstructor
@EqualsAndHashCode
@Schema(description = "CreateFile response")
public class CreateFileResVO {
private CreateFile createFile;
}

View File

@@ -1,52 +0,0 @@
package app.module.api.frontUsecases.uicode.getFrontUICode.adapters.web;
import app.module.api.frontUsecases.uicode.getFrontUICode.adapters.web.model.GetFrontUiCodeResVO;
import app.module.core.usecase.uicode.view.ports.UICodeViewPortIn;
import app.module.core.usecase.uicode.view.ports.application.domain.UICodeView;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.media.Content;
import io.swagger.v3.oas.annotations.media.Schema;
import io.swagger.v3.oas.annotations.responses.ApiResponse;
import io.swagger.v3.oas.annotations.tags.Tag;
import java.util.NoSuchElementException;
import lombok.RequiredArgsConstructor;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;
@RestController
@RequiredArgsConstructor
@Tag(name = "UI CODE API")
class GetFrontUiCodeController {
private final UICodeViewPortIn uiCodeViewPortIn;
@GetMapping(path = "/v1/front/uicodes/{id}")
@Operation(
summary = "UI Code 상세 API",
description = "Front UI Code 상세 조회",
responses = {
@ApiResponse(
description = "UI Code 상세 응답 데이터",
content =
@Content(
mediaType = "application/json",
schema = @Schema(implementation = GetFrontUiCodeResVO.class)))
})
ResponseEntity<?> operate(
@PathVariable @Schema(description = "UI Code 아이디", example = "code.pageable.rows.10")
String id) {
UICodeView uiCode =
uiCodeViewPortIn
.connect(id)
.orElseThrow(
() ->
new NoSuchElementException(
String.format("'%s' - 존재하지 않는 UI Code 아이디 입니다.", id)));
return ResponseEntity.status(HttpStatus.OK).body(new GetFrontUiCodeResVO(uiCode));
}
}

View File

@@ -1,18 +0,0 @@
package app.module.api.frontUsecases.uicode.getFrontUICode.adapters.web.model;
import app.module.core.usecase.uicode.view.ports.application.domain.UICodeView;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.AllArgsConstructor;
import lombok.EqualsAndHashCode;
import lombok.Getter;
import lombok.Setter;
@Getter
@Setter
@AllArgsConstructor
@EqualsAndHashCode
@Schema(description = "UI Code 상세 응답 데이터")
public class GetFrontUiCodeResVO {
private UICodeView uiCode;
}

View File

@@ -1,44 +0,0 @@
package app.module.api.frontUsecases.uicode.getFrontUICodes.adapters.web;
import app.module.api.frontUsecases.uicode.getFrontUICodes.adapters.web.model.GetFrontUiCodesReqVO;
import app.module.api.frontUsecases.uicode.getFrontUICodes.adapters.web.model.GetFrontUiCodesResVO;
import app.module.core.usecase.uicode.list.ports.UICodeListPortIn;
import app.module.core.usecase.uicode.list.ports.application.domain.UICodeElement;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.media.Content;
import io.swagger.v3.oas.annotations.media.Schema;
import io.swagger.v3.oas.annotations.responses.ApiResponse;
import io.swagger.v3.oas.annotations.tags.Tag;
import java.util.List;
import lombok.RequiredArgsConstructor;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
@RequiredArgsConstructor
@Tag(name = "UI CODE API")
class GetFrontUiCodesController {
private final UICodeListPortIn uiCodeListPortIn;
@GetMapping(path = "/v1/front/uicodes")
@Operation(
summary = "UI Code 목록 API",
description = "Front UI Code 목록 조회",
responses = {
@ApiResponse(
description = "GetUiCodes response",
content =
@Content(
mediaType = "application/json",
schema = @Schema(implementation = GetFrontUiCodesResVO.class)))
})
ResponseEntity<?> operate(GetFrontUiCodesReqVO reqVO) {
List<UICodeElement> uiCodes = uiCodeListPortIn.connect(reqVO.getParentId());
return ResponseEntity.status(HttpStatus.OK).body(new GetFrontUiCodesResVO(uiCodes));
}
}

View File

@@ -1,20 +0,0 @@
package app.module.api.frontUsecases.uicode.getFrontUICodes.adapters.web.model;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.AllArgsConstructor;
import lombok.EqualsAndHashCode;
import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.Setter;
@Getter
@Setter
@NoArgsConstructor
@AllArgsConstructor
@EqualsAndHashCode
@Schema(description = "GetUiCodes request")
public class GetFrontUiCodesReqVO {
@Schema(description = "부모 아이디", example = "code.pageable.rows")
private String parentId;
}

View File

@@ -1,19 +0,0 @@
package app.module.api.frontUsecases.uicode.getFrontUICodes.adapters.web.model;
import app.module.core.usecase.uicode.list.ports.application.domain.UICodeElement;
import io.swagger.v3.oas.annotations.media.Schema;
import java.util.List;
import lombok.AllArgsConstructor;
import lombok.EqualsAndHashCode;
import lombok.Getter;
import lombok.Setter;
@Getter
@Setter
@AllArgsConstructor
@EqualsAndHashCode
@Schema(description = "UI Code 목록 응답 데이터")
public class GetFrontUiCodesResVO {
private List<UICodeElement> uiCodes;
}

View File

@@ -1,42 +0,0 @@
package app.module.api.frontUsecases.uri.getFrontUri.adapter.web;
import app.module.api.frontUsecases.uri.getFrontUri.adapter.web.model.GetFrontUriResVO;
import app.module.core.config.application.enums.AppType;
import app.module.core.usecase.uri.view.ports.URIViewPortIn;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.media.Content;
import io.swagger.v3.oas.annotations.media.Schema;
import io.swagger.v3.oas.annotations.responses.ApiResponse;
import io.swagger.v3.oas.annotations.tags.Tag;
import lombok.RequiredArgsConstructor;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;
@RestController
@RequiredArgsConstructor
@Tag(name = "URI API", description = "메뉴 정보 API")
class GetFrontUriController {
private final URIViewPortIn uriViewPortIn;
@Operation(
summary = "URI 상세 API",
description = "Front URI 상세 조회",
responses = {
@ApiResponse(
description = "URI 상세 응답 데이터",
content =
@Content(
mediaType = "application/json",
schema = @Schema(implementation = GetFrontUriResVO.class)))
})
@GetMapping(path = "/v1/front/uris/{id}")
ResponseEntity<?> operate(
@PathVariable @Schema(description = "메뉴 ID", example = "uri.front.board.articles") String id) {
return ResponseEntity.status(HttpStatus.OK)
.body(new GetFrontUriResVO(uriViewPortIn.connect(AppType.FRONT, id).orElse(null)));
}
}

View File

@@ -1,12 +0,0 @@
package app.module.api.frontUsecases.uri.getFrontUri.adapter.web.model;
import app.module.core.usecase.uri.view.ports.application.domain.URIView;
import lombok.AllArgsConstructor;
import lombok.Getter;
@Getter
@AllArgsConstructor
public class GetFrontUriResVO {
private URIView uri;
}

View File

@@ -1,40 +0,0 @@
package app.module.api.frontUsecases.uri.getFrontUris.adapter.web;
import app.module.api.frontUsecases.uri.getFrontUris.adapter.web.model.GetFrontUrisResVO;
import app.module.core.config.application.enums.AppType;
import app.module.core.usecase.uri.getUris.ports.GetUrisPortIn;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.media.Content;
import io.swagger.v3.oas.annotations.media.Schema;
import io.swagger.v3.oas.annotations.responses.ApiResponse;
import io.swagger.v3.oas.annotations.tags.Tag;
import lombok.RequiredArgsConstructor;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
@RequiredArgsConstructor
@Tag(name = "URI API", description = "메뉴 정보 API")
class GetFrontUrisController {
private final GetUrisPortIn getUrisPortIn;
@Operation(
summary = "URI 목록 API",
description = "Front URI 목록 조회",
responses = {
@ApiResponse(
description = "URI 목록 응답 데이터",
content =
@Content(
mediaType = "application/json",
schema = @Schema(implementation = GetFrontUrisResVO.class)))
})
@GetMapping(path = "/v1/front/uris")
ResponseEntity<?> operate() {
return ResponseEntity.status(HttpStatus.OK)
.body(new GetFrontUrisResVO(getUrisPortIn.connect(AppType.FRONT)));
}
}

View File

@@ -1,19 +0,0 @@
package app.module.api.frontUsecases.uri.getFrontUris.adapter.web.model;
import app.module.core.usecase.uri.getUris.ports.application.domain.URIElement;
import io.swagger.v3.oas.annotations.media.Schema;
import java.util.List;
import lombok.AllArgsConstructor;
import lombok.EqualsAndHashCode;
import lombok.Getter;
import lombok.Setter;
@Getter
@Setter
@AllArgsConstructor
@EqualsAndHashCode
public class GetFrontUrisResVO {
@Schema(description = "URI 목록")
private List<URIElement> uris;
}

View File

@@ -1,79 +0,0 @@
package app.module.api.frontUsecases.user.createFrontUser.adapters.web;
import app.module.api.frontUsecases.user.createFrontUser.adapters.web.model.CreateFrontUserReqVO;
import app.module.api.frontUsecases.user.createFrontUser.adapters.web.model.CreateFrontUserResVO;
import app.module.api.frontUsecases.user.createFrontUser.adapters.web.validator.CreateUserValidator;
import app.module.core.config.application.enums.SignUpType;
import app.module.core.usecase.user.createUser.ports.CreateUserPortIn;
import app.module.core.usecase.user.createUser.ports.application.domain.CreateUser;
import app.module.core.usecase.user.createUser.ports.application.domain.CreateUserCmd;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.media.Content;
import io.swagger.v3.oas.annotations.media.Schema;
import io.swagger.v3.oas.annotations.responses.ApiResponse;
import io.swagger.v3.oas.annotations.tags.Tag;
import jakarta.validation.Valid;
import java.util.Set;
import lombok.RequiredArgsConstructor;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.validation.BindingResult;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;
@RestController
@RequiredArgsConstructor
@Tag(name = "USER API", description = "사용자 회원가입 및 정보 API")
class CreateFrontUserController {
private final CreateUserPortIn createUserPortIn;
private final CreateUserValidator createUserValidator;
@PostMapping(path = "/v1/front/user/create")
@Operation(
summary = "회원가입 API",
description = "Front 회원가입",
requestBody =
@io.swagger.v3.oas.annotations.parameters.RequestBody(
description = "Front 회원가입 요청 데이터",
content =
@Content(
mediaType = "application/json",
schema = @Schema(implementation = CreateFrontUserReqVO.class))),
responses = {
@ApiResponse(
description = "Front 회원가입 응답 데이터",
content =
@Content(
mediaType = "application/json",
schema = @Schema(implementation = CreateFrontUserResVO.class)))
})
ResponseEntity<?> operate(
@Valid @RequestBody CreateFrontUserReqVO reqVO, BindingResult bindingResult) {
createUserValidator.validate(reqVO, bindingResult);
if (bindingResult.hasErrors()) {
return ResponseEntity.status(HttpStatus.UNPROCESSABLE_ENTITY).body(bindingResult);
}
CreateUser user =
createUserPortIn
.operate(
new CreateUserCmd(
reqVO.getId(),
reqVO.getPassword(),
reqVO.getEmail(),
reqVO.getNickname(),
SignUpType.NORMAL,
false,
0,
false,
Set.of("ROLE_GENERAL")))
.orElseThrow();
return ResponseEntity.status(HttpStatus.OK)
.body(new CreateFrontUserResVO(user.getId(), user.getEmail()));
}
}

View File

@@ -1,40 +0,0 @@
package app.module.api.frontUsecases.user.createFrontUser.adapters.web.model;
import io.swagger.v3.oas.annotations.media.Schema;
import jakarta.validation.constraints.NotBlank;
import jakarta.validation.constraints.Pattern;
import lombok.AllArgsConstructor;
import lombok.EqualsAndHashCode;
import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.Setter;
@Getter
@Setter
@NoArgsConstructor
@AllArgsConstructor
@EqualsAndHashCode
@Schema(description = "회원가입 요청 데이터")
public class CreateFrontUserReqVO {
@NotBlank(message = "{valid.common.required}")
@Schema(description = "아이디", example = "testUser")
private String id;
@NotBlank(message = "{valid.common.required}")
@Schema(description = "비밀번호", example = "testUser1@#$")
private String password;
@NotBlank(message = "{valid.common.required}")
@Schema(description = "비밀번호 재확인", example = "testUser1@#$")
private String passwordRe;
@NotBlank(message = "{valid.common.required}")
@Schema(description = "이메일", example = "testUser@test.com")
private String email;
@NotBlank(message = "{valid.common.required}")
@Schema(description = "닉네임", example = "TestUser")
@Pattern(regexp = "^[가-힣a-zA-Z0-9_-]{2,10}$", message = "{valid.common.nickname.wrong}")
private String nickname;
}

View File

@@ -1,18 +0,0 @@
package app.module.api.frontUsecases.user.createFrontUser.adapters.web.model;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.AllArgsConstructor;
import lombok.EqualsAndHashCode;
import lombok.Getter;
import lombok.Setter;
@Getter
@Setter
@AllArgsConstructor
@EqualsAndHashCode
@Schema(description = "회원가입 응답 데이터")
public class CreateFrontUserResVO {
private String id;
private String email;
}

View File

@@ -1,46 +0,0 @@
package app.module.api.frontUsecases.user.createFrontUser.adapters.web.validator;
import app.module.api.frontUsecases.user.createFrontUser.adapters.web.model.CreateFrontUserReqVO;
import java.util.Optional;
import org.springframework.stereotype.Component;
import org.springframework.validation.Errors;
import org.springframework.validation.Validator;
@Component
public class CreateUserValidator implements Validator {
private final String ID_REGEX = "^[a-zA-Z0-9_-]{6,12}$";
private final String PASSWORD_REGEX = "^((?=.*[a-z])(?=.*[A-Z])(?=.*[!@#$%_\\-])\\S{6,15})$";
private final String EMAIL_REGEX = "^[\\w!#$%&’*+/=?`{|}~^-]+(?:\\.[\\w!#$%&’*+/=?`{|}~^-]+)*@(?:[a-zA-Z0-9-]+\\.)+[a-zA-Z]{2,6}$";
@Override
public boolean supports(Class<?> clazz) {
return CreateFrontUserReqVO.class.equals(clazz);
}
@Override
public void validate(Object target, Errors errors) {
CreateFrontUserReqVO vo = (CreateFrontUserReqVO) target;
// 아이디
Optional.ofNullable(vo.getId())
.filter(id -> !id.isEmpty() && !id.matches(ID_REGEX))
.ifPresent(id -> errors.rejectValue("id", "valid.common.id.wrong"));
// 비밀번호
Optional.ofNullable(vo.getPassword())
.filter(password -> !password.isEmpty() && !password.matches(PASSWORD_REGEX))
.ifPresent(password -> errors.rejectValue("password", "valid.common.password.wrong"));
// 비밀번호 재확인
Optional.ofNullable(vo.getPasswordRe())
.filter(passwordRe -> !passwordRe.isEmpty() && !passwordRe.equals(vo.getPassword()))
.ifPresent(
passwordRe -> errors.rejectValue("passwordRe", "valid.common.re.password.wrong"));
// 이메일
Optional.ofNullable(vo.getEmail())
.filter(email -> !email.isEmpty() && !email.matches(EMAIL_REGEX))
.ifPresent(email -> errors.rejectValue("email", "valid.common.email.wrong"));
}
}

View File

@@ -1,63 +0,0 @@
package app.module.api.frontUsecases.user.getFrontUser.adapters.web;
import app.module.api.frontUsecases.user.getFrontUser.adapters.web.model.GetFrontUserResVO;
import app.module.core.config.application.util.CommonUtil;
import app.module.core.usecase.user.findUser.ports.FindUserPortIn;
import app.module.core.usecase.user.findUser.ports.application.domain.FindUser;
import app.module.core.usecase.user.findUser.ports.application.domain.FindUserCmd;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.media.Content;
import io.swagger.v3.oas.annotations.media.Schema;
import io.swagger.v3.oas.annotations.responses.ApiResponse;
import io.swagger.v3.oas.annotations.tags.Tag;
import lombok.RequiredArgsConstructor;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
@RequiredArgsConstructor
@Tag(name = "USER API", description = "사용자 회원가입 및 정보 API")
class GetFrontUserController {
private final FindUserPortIn findUserPortIn;
@GetMapping(path = "/v1/front/user/info")
@Operation(
summary = "회원정보 조회 API",
description = "회원정보 조회",
responses = {
@ApiResponse(
description = "회원정보 조회 응답 데이터",
content =
@Content(
mediaType = "application/json",
schema = @Schema(implementation = GetFrontUserResVO.class)))
})
ResponseEntity<?> operate() {
FindUser userInfo =
findUserPortIn.operate(new FindUserCmd(CommonUtil.getLoginUsername())).orElseThrow();
// 불필요한 정보는 제거
userInfo.setPassword(null);
return ResponseEntity.status(HttpStatus.OK)
.body(
new GetFrontUserResVO(
userInfo.getId(),
userInfo.getPassword(),
userInfo.getEmail(),
userInfo.getNickname(),
userInfo.getPasswordUpdatedAt(),
userInfo.getAccountDisabled(),
userInfo.getLoginFailCnt(),
userInfo.getAccountLocked(),
userInfo.getCreatedAt(),
userInfo.getCreatedBy(),
userInfo.getUpdatedAt(),
userInfo.getUpdatedBy(),
userInfo.getRoles(),
userInfo.getUploadFile()));
}
}

View File

@@ -1,16 +0,0 @@
package app.module.api.frontUsecases.user.getFrontUser.adapters.web.model;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.AllArgsConstructor;
import lombok.EqualsAndHashCode;
import lombok.Getter;
import lombok.Setter;
@Getter
@Setter
@AllArgsConstructor
@EqualsAndHashCode
@Schema(description = "FindFrontUser request")
public class GetFrontUserReqVO {
}

View File

@@ -1,34 +0,0 @@
package app.module.api.frontUsecases.user.getFrontUser.adapters.web.model;
import app.module.core.config.adapters.web.security.domain.CoreRole;
import app.module.core.usecase.user.findUser.ports.application.domain.FindProfileImages;
import io.swagger.v3.oas.annotations.media.Schema;
import java.time.LocalDateTime;
import java.util.Set;
import lombok.AllArgsConstructor;
import lombok.EqualsAndHashCode;
import lombok.Getter;
import lombok.Setter;
@Getter
@Setter
@AllArgsConstructor
@EqualsAndHashCode
@Schema(description = "회원 정보조회 응답 데이터")
public class GetFrontUserResVO {
private String id;
private String password;
private String email;
private String nickname;
private LocalDateTime passwordUpdatedAt;
private Boolean accountDisabled;
private Integer loginFailCnt;
private Boolean accountLocked;
private LocalDateTime createdAt;
private String createdBy;
private LocalDateTime updatedAt;
private String updatedBy;
private Set<CoreRole> roles;
private FindProfileImages uploadFile;
}

View File

@@ -1,67 +0,0 @@
package app.module.api.frontUsecases.user.updateFrontUser.adapters.web;
import app.module.api.frontUsecases.user.updateFrontUser.adapters.web.model.UpdateFrontUserReqVO;
import app.module.api.frontUsecases.user.updateFrontUser.adapters.web.model.UpdateFrontUserResVO;
import app.module.api.frontUsecases.user.updateFrontUser.adapters.web.validator.UpdateUserValidator;
import app.module.core.config.application.util.CommonUtil;
import app.module.core.usecase.user.updateFrontUser.ports.UpdateFrontUserPortIn;
import app.module.core.usecase.user.updateFrontUser.ports.application.domain.UpdateFrontUserInCmd;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.media.Content;
import io.swagger.v3.oas.annotations.media.Schema;
import io.swagger.v3.oas.annotations.responses.ApiResponse;
import io.swagger.v3.oas.annotations.tags.Tag;
import jakarta.validation.Valid;
import lombok.RequiredArgsConstructor;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.validation.BindingResult;
import org.springframework.web.bind.annotation.PatchMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;
@RestController
@RequiredArgsConstructor
@Tag(name = "USER API", description = "사용자 회원가입 및 정보 API")
class UpdateFrontUserController {
private final UpdateFrontUserPortIn updateFrontUserPortIn;
private final UpdateUserValidator updateUserValidator;
@PatchMapping(path = "/v1/front/user/update")
@Operation(
summary = "회원정보 수정 API",
description = "Front 회원정보 수정",
requestBody =
@io.swagger.v3.oas.annotations.parameters.RequestBody(
description = "Front 회원정보 수정 요청 데이터",
content =
@Content(
mediaType = "application/json",
schema = @Schema(implementation = UpdateFrontUserReqVO.class))),
responses = {
@ApiResponse(
description = "Front 회원정보 수정 응답 데이터",
content =
@Content(
mediaType = "application/json",
schema = @Schema(implementation = UpdateFrontUserResVO.class)))
})
ResponseEntity<?> operate(
@Valid @RequestBody UpdateFrontUserReqVO reqVO, BindingResult bindingResult) {
updateUserValidator.validate(reqVO, bindingResult);
if (bindingResult.hasErrors()) {
return ResponseEntity.status(HttpStatus.UNPROCESSABLE_ENTITY).body(bindingResult);
}
updateFrontUserPortIn.operate(
new UpdateFrontUserInCmd(
reqVO.getPassword(), reqVO.getEmail(), reqVO.getNickname(),
reqVO.getFileMappingId()));
return ResponseEntity.status(HttpStatus.OK)
.body(new UpdateFrontUserResVO(CommonUtil.getLoginUsername(), reqVO.getEmail()));
}
}

View File

@@ -1,38 +0,0 @@
package app.module.api.frontUsecases.user.updateFrontUser.adapters.web.model;
import io.swagger.v3.oas.annotations.media.Schema;
import jakarta.validation.constraints.NotBlank;
import jakarta.validation.constraints.Pattern;
import java.util.List;
import lombok.AllArgsConstructor;
import lombok.EqualsAndHashCode;
import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.Setter;
@Getter
@Setter
@NoArgsConstructor
@AllArgsConstructor
@EqualsAndHashCode
@Schema(description = "회원정보 수정 요청 데이터")
public class UpdateFrontUserReqVO {
@Schema(description = "비밀번호", example = "testUser1@#$")
private String password;
@Schema(description = "비밀번호 재확인", example = "testUser1@#$")
private String passwordRe;
@NotBlank(message = "{valid.common.required}")
@Schema(description = "이메일", example = "testUser@test.com")
private String email;
@NotBlank(message = "{valid.common.required}")
@Schema(description = "닉네임", example = "DemoUser")
@Pattern(regexp = "^[가-힣a-zA-Z0-9_-]{2,10}$", message = "{valid.common.nickname.wrong}")
private String nickname;
@Schema(description = "프로필 이미지 파일 매핑 ID", defaultValue = "[]")
private List<String> fileMappingId;
}

View File

@@ -1,18 +0,0 @@
package app.module.api.frontUsecases.user.updateFrontUser.adapters.web.model;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.AllArgsConstructor;
import lombok.EqualsAndHashCode;
import lombok.Getter;
import lombok.Setter;
@Getter
@Setter
@AllArgsConstructor
@EqualsAndHashCode
@Schema(description = "회원정보 수정 응답 데이터")
public class UpdateFrontUserResVO {
private String id;
private String email;
}

View File

@@ -1,40 +0,0 @@
package app.module.api.frontUsecases.user.updateFrontUser.adapters.web.validator;
import app.module.api.frontUsecases.user.updateFrontUser.adapters.web.model.UpdateFrontUserReqVO;
import java.util.Optional;
import org.springframework.stereotype.Component;
import org.springframework.validation.Errors;
import org.springframework.validation.Validator;
@Component
public class UpdateUserValidator implements Validator {
private final String PASSWORD_REGEX = "^((?=.*[a-z])(?=.*[A-Z])(?=.*[!@#$%_\\-])\\S{6,15})$";
private final String EMAIL_REGEX = "^[\\w!#$%&’*+/=?`{|}~^-]+(?:\\.[\\w!#$%&’*+/=?`{|}~^-]+)*@(?:[a-zA-Z0-9-]+\\.)+[a-zA-Z]{2,6}$";
@Override
public boolean supports(Class<?> clazz) {
return UpdateFrontUserReqVO.class.equals(clazz);
}
@Override
public void validate(Object target, Errors errors) {
UpdateFrontUserReqVO vo = (UpdateFrontUserReqVO) target;
// 비밀번호
Optional.ofNullable(vo.getPassword())
.filter(password -> !password.isEmpty() && !password.matches(PASSWORD_REGEX))
.ifPresent(password -> errors.rejectValue("password", "valid.common.password.wrong"));
// 비밀번호 재확인
Optional.ofNullable(vo.getPasswordRe())
.filter(passwordRe -> !passwordRe.isEmpty() && !passwordRe.equals(vo.getPassword()))
.ifPresent(
passwordRe -> errors.rejectValue("passwordRe", "valid.common.re.password.wrong"));
// 이메일
Optional.ofNullable(vo.getEmail())
.filter(email -> !email.isEmpty() && !email.matches(EMAIL_REGEX))
.ifPresent(email -> errors.rejectValue("email", "valid.common.email.wrong"));
}
}

View File

@@ -1,62 +0,0 @@
package app.module.api.usecases.admin.createAdmin.adapters.web;
import app.module.api.usecases.admin.createAdmin.adapters.web.model.CreateAdminReqVO;
import app.module.api.usecases.admin.createAdmin.adapters.web.model.CreateAdminResVO;
import app.module.api.usecases.admin.createAdmin.adapters.web.validator.CreateAdminValidator;
import app.module.core.usecase.admin.saveAdmin.ports.SaveAdminPortIn;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.media.Content;
import io.swagger.v3.oas.annotations.media.Schema;
import io.swagger.v3.oas.annotations.responses.ApiResponse;
import io.swagger.v3.oas.annotations.tags.Tag;
import jakarta.validation.Valid;
import lombok.RequiredArgsConstructor;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.validation.BindingResult;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;
@Tag(name = "ADMIN API", description = "관리자 정보 API 그룹")
@RestController
@RequiredArgsConstructor
class CreateAdminController {
private final CreateAdminValidator createAdminValidator;
private final SaveAdminPortIn saveAdminPortIn;
@Operation(
summary = "관리자 생성 API",
description = "관리자 생성",
responses = {
@ApiResponse(
description = "관리자 생성 응답 데이터",
content =
@Content(
mediaType = "application/json",
schema = @Schema(implementation = CreateAdminResVO.class)))
})
@PostMapping(path = "/v1/admin/admins/create")
ResponseEntity<?> operate(
@Valid @RequestBody CreateAdminReqVO reqVO, BindingResult bindingResult) {
createAdminValidator.validate(reqVO, bindingResult);
if (bindingResult.hasErrors()) {
return ResponseEntity.status(HttpStatus.UNPROCESSABLE_ENTITY).body(bindingResult);
}
String createdId =
saveAdminPortIn.apiConnect(
reqVO.getSeq(),
reqVO.getId(),
reqVO.getPassword(),
reqVO.getName(),
reqVO.getPhone(),
reqVO.getRegionMainCode(),
reqVO.getAccountDisabled(),
reqVO.getRoleId());
return ResponseEntity.status(HttpStatus.OK).body(new CreateAdminResVO(createdId));
}
}

View File

@@ -1,43 +0,0 @@
package app.module.api.usecases.admin.createAdmin.adapters.web.model;
import io.swagger.v3.oas.annotations.media.Schema;
import jakarta.validation.constraints.NotBlank;
import jakarta.validation.constraints.Pattern;
import java.util.List;
import lombok.AllArgsConstructor;
import lombok.EqualsAndHashCode;
import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.Setter;
@Getter
@Setter
@NoArgsConstructor
@AllArgsConstructor
@EqualsAndHashCode
public class CreateAdminReqVO {
private Long seq;
private String id;
private String name;
private String password;
private String phone;
@NotBlank(message = "{valid.common.required}")
@Pattern(
regexp =
"^[\\w!#$%&’*+/=?`{|}~^-]+(?:\\.[\\w!#$%&’*+/=?`{|}~^-]+)*@(?:[a-zA-Z0-9-]+\\.)+[a-zA-Z]{2,6}$",
message = "{valid.common.email.wrong}")
@Schema(description = "email", example = "admin-email@email.com")
private String email;
@Schema(description = "실사지역코드", example = "code.region.main.1")
private String regionMainCode;
@Schema(description = "계정 비활성화", example = "false")
private Boolean accountDisabled;
@Schema(description = "계정 잠김", example = "false")
private Boolean accountLocked;
private String roleId;
}

View File

@@ -1,16 +0,0 @@
package app.module.api.usecases.admin.createAdmin.adapters.web.model;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.AllArgsConstructor;
import lombok.Getter;
import lombok.Setter;
@Getter
@Setter
@AllArgsConstructor
@Schema(description = "관리자 생성 응답 데이터")
public class CreateAdminResVO {
@Schema(description = "생성 아이디")
private String id;
}

View File

@@ -1,36 +0,0 @@
package app.module.api.usecases.admin.createAdmin.adapters.web.validator;
import app.module.api.usecases.admin.createAdmin.adapters.web.model.CreateAdminReqVO;
import java.util.Optional;
import org.springframework.stereotype.Component;
import org.springframework.validation.Errors;
import org.springframework.validation.ValidationUtils;
import org.springframework.validation.Validator;
@Component
public class CreateAdminValidator implements Validator {
private final String PASSWORD_REGEX = "^((?=.*[a-z])(?=.*[A-Z])(?=.*[!@#$%_\\-])\\S{6,15})$";
@Override
public boolean supports(Class<?> clazz) {
return CreateAdminReqVO.class.equals(clazz);
}
@Override
public void validate(Object target, Errors errors) {
CreateAdminReqVO vo = (CreateAdminReqVO) target;
ValidationUtils.rejectIfEmptyOrWhitespace(errors, "password", "valid.common.required");
Optional.ofNullable(vo.getPassword())
.filter(password -> !password.matches(PASSWORD_REGEX))
.ifPresent(password -> errors.rejectValue("password", "valid.common.password.wrong"));
Optional.ofNullable(vo.getRoleId())
.ifPresent(
ids ->
errors.rejectValue(
"roleIds", "valid.common.required.size.min", new Object[]{1}, ""));
}
}

View File

@@ -1,69 +0,0 @@
package app.module.api.usecases.admin.getAdimin.adapters.web;
import app.module.api.usecases.admin.getAdimin.adapters.web.model.GetAdminResVO;
import app.module.core.config.adapters.web.security.domain.CoreRole;
import app.module.core.config.application.util.MessageUtil;
import app.module.core.usecase.admin.view.ports.AdminViewPortIn;
import app.module.core.usecase.admin.view.ports.application.domain.AdminView;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.media.Content;
import io.swagger.v3.oas.annotations.media.Schema;
import io.swagger.v3.oas.annotations.responses.ApiResponse;
import io.swagger.v3.oas.annotations.tags.Tag;
import java.util.NoSuchElementException;
import java.util.stream.Collectors;
import lombok.RequiredArgsConstructor;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;
@RestController
@RequiredArgsConstructor
@Tag(name = "ADMIN API", description = "관리자 정보 API 그룹")
class GetAdminController {
private final AdminViewPortIn adminViewPortIn;
private final MessageUtil messageUtil;
@GetMapping(path = "/v1/admin/admins/{id}")
@Operation(
summary = "관리자 상세 API",
description = "GetAdmin",
responses = {
@ApiResponse(
description = "GetAdmin response",
content =
@Content(
mediaType = "application/json",
schema = @Schema(implementation = GetAdminResVO.class)))
})
ResponseEntity<?> operate(
@PathVariable @Schema(description = "관리자 id", example = "recycle-super") String id) {
AdminView output =
adminViewPortIn
.connect(id)
.orElseThrow(
() ->
new NoSuchElementException(
messageUtil.getMessage("exception.noSuchElement", id, "Admin ID")));
return ResponseEntity.status(HttpStatus.OK)
.body(new GetAdminResVO(
output.getCreatedBy(),
output.getCreatedAt(),
output.getUpdatedBy(),
output.getUpdatedAt(),
output.getId(),
null,
output.getEmail(),
output.getPasswordUpdatedAt(),
output.getAccountDisabled(),
output.getLoginFailCnt(),
output.getAccountLocked(),
output.getRoles().stream().map(CoreRole::getId).collect(Collectors.toList())
));
}
}

View File

@@ -1,43 +0,0 @@
package app.module.api.usecases.admin.getAdimin.adapters.web.model;
import io.swagger.v3.oas.annotations.media.Schema;
import jakarta.validation.constraints.NotBlank;
import jakarta.validation.constraints.Pattern;
import java.time.LocalDateTime;
import java.util.List;
import lombok.AllArgsConstructor;
import lombok.EqualsAndHashCode;
import lombok.Getter;
import lombok.Setter;
@Getter
@Setter
@AllArgsConstructor
@EqualsAndHashCode
@Schema(description = "GetAdmin response")
public class GetAdminResVO {
private final String createdBy;
private final LocalDateTime createdAt;
private final String updatedBy;
private final LocalDateTime updatedAt;
private String id;
private String updatePassword;
@NotBlank(message = "{valid.common.required}")
@Pattern(
regexp =
"^[\\w!#$%&’*+/=?`{|}~^-]+(?:\\.[\\w!#$%&’*+/=?`{|}~^-]+)*@(?:[a-zA-Z0-9-]+\\.)+[a-zA-Z]{2,6}$",
message = "{valid.common.email.wrong}")
private String email;
private LocalDateTime passwordUpdatedAt;
private Boolean accountDisabled;
private Integer loginFailCnt;
private Boolean accountLocked;
private List<String> roleIds;
}

View File

@@ -1,67 +0,0 @@
package app.module.api.usecases.admin.getAdmins.adapters.web;
import app.module.api.usecases.admin.getAdmins.adapters.web.model.GetAdminsResVO;
import app.module.core.usecase.admin.getAdmins.ports.GetAdminsPortIn;
import app.module.core.usecase.admin.getAdmins.ports.application.domain.GetAdmins;
import app.module.core.usecase.admin.getAdmins.ports.application.domain.GetAdminsCmd;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.Parameter;
import io.swagger.v3.oas.annotations.media.Schema;
import io.swagger.v3.oas.annotations.tags.Tag;
import lombok.RequiredArgsConstructor;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.domain.Sort;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
@Tag(name = "ADMIN API", description = "관리자 정보 API 그룹")
@RestController
@RequiredArgsConstructor
class GetAdminsController {
private final GetAdminsPortIn getAdminsPortIn;
@Operation(summary = "관리자 목록 API", description = "관리자 목록 조회")
@GetMapping(path = "/v1/admin/admins")
ResponseEntity<GetAdminsResVO> operate(
@Parameter(description = "검색 필드 조건")
@RequestParam(required = false)
@Schema(allowableValues = {"id", "email"})
String searchField,
@Parameter(description = "검색 필드 검색어") @RequestParam(required = false) String searchValue,
@Parameter(description = "권한 검색")
@RequestParam(required = false)
@Schema(allowableValues = {"ROLE_SUPER", "ROLE_MANAGER", "ROLE_STAFF"})
String searchRole,
@Parameter(description = "페이지 번호 (0..N)") @RequestParam(required = true, defaultValue = "0")
Integer page,
@Parameter(description = "페이지 크기 (0..N)") @RequestParam(required = true, defaultValue = "10")
Integer size,
@Parameter(description = "정렬 (컬럼명,ASC|DESC)")
@RequestParam(required = true, defaultValue = "created_at,DESC")
String sort) {
Page<GetAdmins> result =
getAdminsPortIn.connect(
PageRequest.of(
page,
size,
Sort.by(
new Sort.Order(
Sort.Direction.fromString(sort.split(",")[1]), sort.split(",")[0]))),
new GetAdminsCmd(searchField, searchValue, searchRole));
return ResponseEntity.status(HttpStatus.OK)
.body(
new GetAdminsResVO(
result.getContent(),
result.getNumber(),
result.getSize(),
result.getTotalElements(),
result.getTotalPages()));
}
}

View File

@@ -1,19 +0,0 @@
package app.module.api.usecases.admin.getAdmins.adapters.web.model;
import lombok.AllArgsConstructor;
import lombok.EqualsAndHashCode;
import lombok.Getter;
import lombok.Setter;
@Getter
@Setter
@AllArgsConstructor
@EqualsAndHashCode
public class GetAdminsReqVO {
private String searchField;
private String searchValue;
private String searchRole;
}

View File

@@ -1,29 +0,0 @@
package app.module.api.usecases.admin.getAdmins.adapters.web.model;
import app.module.core.usecase.admin.getAdmins.ports.application.domain.GetAdmins;
import io.swagger.v3.oas.annotations.media.Schema;
import java.util.List;
import lombok.AllArgsConstructor;
import lombok.Getter;
import lombok.Setter;
@Getter
@Setter
@AllArgsConstructor
public class GetAdminsResVO {
@Schema(description = "관리자 목록 데이터")
private List<GetAdmins> content;
@Schema(description = "현재 페이지 번호")
private int page;
@Schema(description = "페이지 크기")
private int size;
@Schema(description = "전체 관리자 수")
private long totalElements;
@Schema(description = "전체 페이지 수")
private int totalPages;
}

View File

@@ -1,56 +0,0 @@
package app.module.api.usecases.admin.removeAdmin.adapters.web;
import app.module.api.usecases.admin.removeAdmin.adapters.web.model.RemoveAdminReqVO;
import app.module.api.usecases.admin.removeAdmin.adapters.web.model.RemoveAdminResVO;
import app.module.core.usecase.admin.removeAdmin.ports.RemoveAdminPortIn;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.media.Content;
import io.swagger.v3.oas.annotations.media.Schema;
import io.swagger.v3.oas.annotations.responses.ApiResponse;
import io.swagger.v3.oas.annotations.tags.Tag;
import jakarta.validation.Valid;
import lombok.RequiredArgsConstructor;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.validation.BindingResult;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;
@RestController
@RequiredArgsConstructor
@Tag(name = "ADMIN API")
class RemoveAdminController {
private final RemoveAdminPortIn removeAdminPortIn;
@DeleteMapping(path = "/v1/admin/admins/remove")
@Operation(
summary = "RemoveAdmin API",
description = "RemoveAdmin",
requestBody =
@io.swagger.v3.oas.annotations.parameters.RequestBody(
description = "RemoveAdmin request",
content =
@Content(
mediaType = "application/json",
schema = @Schema(implementation = RemoveAdminReqVO.class))),
responses = {
@ApiResponse(
description = "RemoveAdmin response",
content =
@Content(
mediaType = "application/json",
schema = @Schema(implementation = RemoveAdminResVO.class)))
})
ResponseEntity<?> operate(
@Valid @RequestBody RemoveAdminReqVO reqVO, BindingResult bindingResult) {
if (bindingResult.hasErrors()) {
return ResponseEntity.status(HttpStatus.UNPROCESSABLE_ENTITY).body(bindingResult);
}
removeAdminPortIn.connect(reqVO.getCheckedIds());
return ResponseEntity.status(HttpStatus.OK).body(new RemoveAdminResVO(true));
}
}

View File

@@ -1,22 +0,0 @@
package app.module.api.usecases.admin.removeAdmin.adapters.web.model;
import io.swagger.v3.oas.annotations.media.Schema;
import jakarta.validation.constraints.NotNull;
import jakarta.validation.constraints.Size;
import java.util.List;
import lombok.AllArgsConstructor;
import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.Setter;
@Getter
@Setter
@NoArgsConstructor
@AllArgsConstructor
@Schema(description = "RemoveAdmin request")
public class RemoveAdminReqVO {
@NotNull(message = "Checked IDs cannot be null")
@Size(min = 1, message = "Checked IDs cannot be empty")
private List<String> checkedIds;
}

View File

@@ -1,15 +0,0 @@
package app.module.api.usecases.admin.removeAdmin.adapters.web.model;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.AllArgsConstructor;
import lombok.Getter;
import lombok.Setter;
@Getter
@Setter
@AllArgsConstructor
@Schema(description = "RemoveAdmin response")
public class RemoveAdminResVO {
private boolean removed;
}

View File

@@ -1,66 +0,0 @@
package app.module.api.usecases.admin.updateAdmin.adapters.web;
import app.module.api.usecases.admin.updateAdmin.adapters.web.model.UpdateAdminReqVO;
import app.module.api.usecases.admin.updateAdmin.adapters.web.model.UpdateAdminResVO;
import app.module.api.usecases.admin.updateAdmin.adapters.web.validator.UpdateAdminValidator;
import app.module.core.usecase.admin.saveAdmin.ports.SaveAdminPortIn;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.media.Content;
import io.swagger.v3.oas.annotations.media.Schema;
import io.swagger.v3.oas.annotations.responses.ApiResponse;
import io.swagger.v3.oas.annotations.tags.Tag;
import jakarta.validation.Valid;
import lombok.RequiredArgsConstructor;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.validation.BindingResult;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;
@RestController
@RequiredArgsConstructor
@Tag(name = "ADMIN API")
class UpdateAdminController {
private final UpdateAdminValidator validator;
private final SaveAdminPortIn saveAdminPortIn;
@PutMapping(path = "/v1/admin/admins/update")
@Operation(
summary = "UpdateAdmin API",
description = "UpdateAdmin",
requestBody =
@io.swagger.v3.oas.annotations.parameters.RequestBody(
description = "UpdateAdmin request",
content =
@Content(
mediaType = "application/json",
schema = @Schema(implementation = UpdateAdminReqVO.class))),
responses = {
@ApiResponse(
description = "UpdateAdmin response",
content =
@Content(
mediaType = "application/json",
schema = @Schema(implementation = UpdateAdminResVO.class)))
})
ResponseEntity<?> operate(
@Valid @RequestBody UpdateAdminReqVO reqVO, BindingResult bindingResult) {
validator.validate(reqVO, bindingResult);
if (bindingResult.hasErrors()) {
return ResponseEntity.status(HttpStatus.UNPROCESSABLE_ENTITY).body(bindingResult);
}
String updatedId =
saveAdminPortIn.connect(
reqVO.getSeq(),
reqVO.getId(),
reqVO.getUpdatePassword(),
reqVO.getRegionMainCode(),
reqVO.getAccountDisabled(),
reqVO.getRoleIds());
return ResponseEntity.status(HttpStatus.OK).body(new UpdateAdminResVO(updatedId));
}
}

View File

@@ -1,49 +0,0 @@
package app.module.api.usecases.admin.updateAdmin.adapters.web.model;
import io.swagger.v3.oas.annotations.media.Schema;
import jakarta.validation.constraints.NotBlank;
import jakarta.validation.constraints.Pattern;
import java.util.List;
import lombok.AllArgsConstructor;
import lombok.EqualsAndHashCode;
import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.Setter;
@Getter
@Setter
@NoArgsConstructor
@AllArgsConstructor
@EqualsAndHashCode
@Schema(description = "UpdateAdmin request")
public class UpdateAdminReqVO {
@Schema(description = "seq", example = "seq")
private Long seq;
@Schema(description = "id", example = "staff")
private String id;
@Schema(description = "신규 패스워드", example = "")
private String updatePassword;
@NotBlank(message = "{valid.common.required}")
@Pattern(
regexp =
"^[\\w!#$%&’*+/=?`{|}~^-]+(?:\\.[\\w!#$%&’*+/=?`{|}~^-]+)*@(?:[a-zA-Z0-9-]+\\.)+[a-zA-Z]{2,6}$",
message = "{valid.common.email.wrong}")
@Schema(description = "email", example = "staff@new-staff.com")
private String email;
@Schema(description = "실사지역코드", example = "code.region.main.1")
private String regionMainCode;
@Schema(description = "계정 비활성화 여부", example = "false")
private Boolean accountDisabled;
@Schema(description = "계정잠김 여부", example = "false")
private Boolean accountLocked;
@Schema(description = "권한", example = "[\"ROLE_STAFF\"]")
private List<String> roleIds;
}

View File

@@ -1,17 +0,0 @@
package app.module.api.usecases.admin.updateAdmin.adapters.web.model;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.AllArgsConstructor;
import lombok.EqualsAndHashCode;
import lombok.Getter;
import lombok.Setter;
@Getter
@Setter
@AllArgsConstructor
@EqualsAndHashCode
@Schema(description = "UpdateAdmin response")
public class UpdateAdminResVO {
private String updatedId;
}

View File

@@ -1,34 +0,0 @@
package app.module.api.usecases.admin.updateAdmin.adapters.web.validator;
import app.module.api.usecases.admin.updateAdmin.adapters.web.model.UpdateAdminReqVO;
import java.util.Optional;
import org.springframework.stereotype.Component;
import org.springframework.validation.Errors;
import org.springframework.validation.Validator;
@Component
public class UpdateAdminValidator implements Validator {
private final String PASSWORD_REGEX = "^((?=.*[a-z])(?=.*[A-Z])(?=.*[!@#$%_\\-])\\S{6,15})$";
@Override
public boolean supports(Class<?> clazz) {
return UpdateAdminReqVO.class.equals(clazz);
}
@Override
public void validate(Object target, Errors errors) {
UpdateAdminReqVO vo = (UpdateAdminReqVO) target;
Optional.ofNullable(vo.getRoleIds())
.filter(ids -> ids.size() < 1)
.ifPresent(
ids ->
errors.rejectValue(
"roleIds", "valid.common.required.size.min", new Object[]{1}, ""));
Optional.ofNullable(vo.getUpdatePassword())
.filter(s -> !s.trim().isEmpty() && !s.matches(PASSWORD_REGEX))
.ifPresent(s -> errors.rejectValue("updatePassword", "valid.common.password.wrong"));
}
}

View File

@@ -1,70 +0,0 @@
package app.module.api.usecases.article.createArticle.adapters.web;
import app.module.api.usecases.article.createArticle.adapters.web.model.CreateArticleReqVO;
import app.module.api.usecases.article.createArticle.adapters.web.model.CreateArticleResVO;
import app.module.api.usecases.article.createArticle.adapters.web.validator.CreateArticleValidator;
import app.module.core.usecase.article.createArticle.ports.CreateArticlePortIn;
import app.module.core.usecase.article.createArticle.ports.application.domain.CreateArticleCmd;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.media.Content;
import io.swagger.v3.oas.annotations.media.Schema;
import io.swagger.v3.oas.annotations.responses.ApiResponse;
import io.swagger.v3.oas.annotations.tags.Tag;
import jakarta.validation.Valid;
import lombok.RequiredArgsConstructor;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.validation.BindingResult;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;
@RestController
@RequiredArgsConstructor
@Tag(name = "ARTICLE API", description = "예제 게시판 API")
class CreateArticleController {
private final CreateArticlePortIn createArticlePortIn;
private final CreateArticleValidator createArticleValidator;
@Operation(
summary = "예제 게시판 게시물 등록 API",
description = "Admin 예제 게시판 게시물 등록",
requestBody =
@io.swagger.v3.oas.annotations.parameters.RequestBody(
description = "게시물 등록 요청 데이터",
content =
@Content(
mediaType = "application/json",
schema = @Schema(implementation = CreateArticleReqVO.class))),
responses = {
@ApiResponse(
description = "게시물 등록 응답 데이터",
content =
@Content(
mediaType = "application/json",
schema = @Schema(implementation = CreateArticleResVO.class)))
})
@PostMapping(path = "/v1/admin/board/articles/create")
ResponseEntity<?> operate(
@Valid @RequestBody CreateArticleReqVO reqVO,
BindingResult bindingResult) {
createArticleValidator.validate(reqVO, bindingResult);
if (bindingResult.hasErrors()) {
return ResponseEntity.status(HttpStatus.UNPROCESSABLE_ENTITY).body(bindingResult);
}
return ResponseEntity.status(HttpStatus.OK)
.body(createArticlePortIn.operate(new CreateArticleCmd(
reqVO.getTitle(),
reqVO.getContent(),
reqVO.getVisible(),
reqVO.getStartDate(),
reqVO.getEndDate(),
reqVO.getFileMappingId()))
.map(article -> new CreateArticleResVO(article.getId(), reqVO.getTitle()))
.orElseThrow());
}
}

View File

@@ -1,55 +0,0 @@
package app.module.api.usecases.article.createArticle.adapters.web.model;
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 java.time.LocalDateTime;
import java.util.List;
import lombok.AllArgsConstructor;
import lombok.EqualsAndHashCode;
import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.Setter;
import org.apache.commons.text.StringEscapeUtils;
@Getter
@Setter
@NoArgsConstructor
@AllArgsConstructor
@EqualsAndHashCode
public class CreateArticleReqVO {
@NotBlank(message = "{valid.common.required}")
@Schema(description = "제목", example = "Article No.25")
private String title;
@NotBlank(message = "{valid.common.required}")
@Schema(description = "내용", example = "Content No.25")
private String content;
@NotNull(message = "{valid.common.required}")
@Schema(description = "공개여부", example = "true")
private Boolean visible;
@NotNull(message = "{valid.common.required}")
@Schema(description = "시작날짜", type = "string", example = "2025-03-07T08:38")
@JsonFormat(shape = JsonFormat.Shape.STRING, pattern = "yyyy-MM-dd'T'HH:mm")
private LocalDateTime startDate;
@NotNull(message = "{valid.common.required}")
@Schema(description = "종료날짜", type = "string", example = "2025-05-07T08:38")
@JsonFormat(shape = JsonFormat.Shape.STRING, pattern = "yyyy-MM-dd'T'HH:mm")
private LocalDateTime endDate;
@Schema(description = "파일 매핑 ID", nullable = true, defaultValue = "[]")
private List<String> fileMappingId;
public String getTitle() {
return StringEscapeUtils.escapeHtml4(title);
}
public String getContent() {
return StringEscapeUtils.escapeHtml4(content);
}
}

View File

@@ -1,20 +0,0 @@
package app.module.api.usecases.article.createArticle.adapters.web.model;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.AllArgsConstructor;
import lombok.EqualsAndHashCode;
import lombok.Getter;
import lombok.Setter;
@Getter
@Setter
@AllArgsConstructor
@EqualsAndHashCode
@Schema(description = "게시물 등록 응답 데이터")
public class CreateArticleResVO {
@Schema(description = "등록된 게시물 ID")
private Long id;
@Schema(description = "등록된 게시물 제목")
private String title;
}

View File

@@ -1,55 +0,0 @@
package app.module.api.usecases.article.createArticle.adapters.web.validator;
import app.module.api.usecases.article.createArticle.adapters.web.model.CreateArticleReqVO;
import app.module.core.config.application.util.MessageUtil;
import java.time.LocalDateTime;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Component;
import org.springframework.validation.Errors;
import org.springframework.validation.Validator;
@Component
@RequiredArgsConstructor
public class CreateArticleValidator implements Validator {
private final MessageUtil messageUtil;
@Override
public boolean supports(Class<?> clazz) {
return CreateArticleReqVO.class.equals(clazz);
}
@Override
public void validate(Object target, Errors errors) {
CreateArticleReqVO vo = (CreateArticleReqVO) target;
LocalDateTime startDate = vo.getStartDate();
LocalDateTime endDate = vo.getEndDate();
// 게시일 날짜 체크
if (startDate == null) {
errors.rejectValue(
"startDate", "valid.common.required",
messageUtil.getMessage("valid.common.required"));
}
if (endDate == null) {
errors.rejectValue(
"endDate", "valid.common.required",
messageUtil.getMessage("valid.common.required"));
}
if (startDate != null && endDate != null) {
if (!startDate.isBefore(endDate)) {
errors.rejectValue(
"startDate",
"valid.common.date.invalid",
messageUtil.getMessage("valid.common.date.invalid"));
errors.rejectValue(
"endDate",
"valid.common.date.invalid",
messageUtil.getMessage("valid.common.date.invalid"));
}
}
}
}

View File

@@ -1,60 +0,0 @@
package app.module.api.usecases.article.getArticle.adapters.web;
import app.module.api.usecases.article.getArticle.adapters.web.model.GetArticleResVO;
import app.module.core.usecase.article.getArticle.ports.GetArticlePortIn;
import app.module.core.usecase.article.getArticle.ports.application.domain.GetArticle;
import app.module.core.usecase.article.getArticle.ports.application.domain.GetArticleCmd;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.media.Content;
import io.swagger.v3.oas.annotations.media.Schema;
import io.swagger.v3.oas.annotations.responses.ApiResponse;
import io.swagger.v3.oas.annotations.tags.Tag;
import lombok.RequiredArgsConstructor;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;
@RestController
@RequiredArgsConstructor
@Tag(name = "ARTICLE API", description = "예제 게시판 API")
class GetArticleController {
private final GetArticlePortIn getArticlePortIn;
@Operation(
summary = "예제 게시판 게시물 상세 API",
description = "Admin 예제 게시판 게시물 상세 조회",
responses = {
@ApiResponse(
description = "게시물 상세 응답 데이터",
content =
@Content(
mediaType = "application/json",
schema = @Schema(implementation = GetArticleResVO.class)))
})
@GetMapping(path = "/v1/admin/board/articles/{id}")
ResponseEntity<GetArticleResVO> operate(
@PathVariable @Schema(description = "게시물 ID", example = "1") Long id) {
GetArticle article =
getArticlePortIn.operate(new GetArticleCmd(id)).orElseThrow();
return ResponseEntity.status(HttpStatus.OK)
.body(new GetArticleResVO(
article.getCreatedAt(),
article.getCreatedBy(),
article.getUpdatedAt(),
article.getUpdatedBy(),
article.getId(),
article.getTitle(),
article.getContent(),
article.getVisible(),
article.getStartDate(),
article.getEndDate(),
article.getOrderNo(),
article.getUploadFiles()
));
}
}

View File

@@ -1,43 +0,0 @@
package app.module.api.usecases.article.getArticle.adapters.web.model;
import app.module.core.usecase.article.getArticle.ports.application.domain.GetArticleUploadFile;
import io.swagger.v3.oas.annotations.media.Schema;
import java.time.LocalDateTime;
import java.util.List;
import lombok.AllArgsConstructor;
import lombok.EqualsAndHashCode;
import lombok.Getter;
import lombok.Setter;
@Getter
@Setter
@AllArgsConstructor
@EqualsAndHashCode
@Schema(description = "Admin 예제 게시판 게시물 상세")
public class GetArticleResVO {
@Schema(description = "생성일")
private LocalDateTime createdAt;
@Schema(description = "생성자")
private String createdBy;
@Schema(description = "수정일")
private LocalDateTime updatedAt;
@Schema(description = "수정자")
private String updatedBy;
@Schema(description = "게시물 ID")
private Long id;
@Schema(description = "제목")
private String title;
@Schema(description = "내용")
private String content;
@Schema(description = "공개여부")
private Boolean visible;
@Schema(description = "시작일")
private LocalDateTime startDate;
@Schema(description = "종료일")
private LocalDateTime endDate;
@Schema(description = "정렬번호")
private Integer orderNo;
@Schema(description = "업로드파일")
private List<GetArticleUploadFile> uploadFiles;
}

View File

@@ -1,82 +0,0 @@
package app.module.api.usecases.article.getArticles.adapters.web;
import app.module.api.usecases.article.getArticles.adapters.web.model.GetArticlesResVO;
import app.module.core.usecase.article.getArticles.ports.GetArticlesPortIn;
import app.module.core.usecase.article.getArticles.ports.application.domain.GetArticles;
import app.module.core.usecase.article.getArticles.ports.application.domain.GetArticlesCmd;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.Parameter;
import io.swagger.v3.oas.annotations.media.Content;
import io.swagger.v3.oas.annotations.media.Schema;
import io.swagger.v3.oas.annotations.responses.ApiResponse;
import io.swagger.v3.oas.annotations.tags.Tag;
import lombok.RequiredArgsConstructor;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.domain.Sort;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
@RestController
@RequiredArgsConstructor
@Tag(name = "ARTICLE API", description = "예제 게시판 API")
class GetArticlesController {
private final GetArticlesPortIn getArticlesPortIn;
@Operation(
summary = "예제 게시판 게시물 페이징 목록 API",
description = "Admin 예제 게시판 게시물 페이징 처리된 목록 조회",
responses = {
@ApiResponse(
description = "게시물 목록 응답 데이터",
content =
@Content(
mediaType = "application/json",
schema = @Schema(implementation = GetArticlesResVO.class)))
})
@GetMapping(path = "/v1/admin/board/articles")
ResponseEntity<GetArticlesResVO> operate(
@Parameter(description = "검색 필드 조건")
@RequestParam(required = false)
@Schema(allowableValues = {"title", "updatedBy"})
String searchField,
@Parameter(description = "검색 필드 검색어")
@RequestParam(required = false)
String searchValue,
@Parameter(description = "공개여부 검색")
@RequestParam(required = false)
@Schema(allowableValues = {"true", "false"})
String searchOpen,
@Parameter(description = "페이지 번호 (0..N)")
@RequestParam(required = true, defaultValue = "0")
Integer page,
@Parameter(description = "페이지 크기 (0..N)")
@RequestParam(required = true, defaultValue = "10")
Integer size,
@Parameter(description = "정렬 (컬럼명,ASC|DESC)")
@RequestParam(required = true, defaultValue = "orderNo,DESC")
String sort) {
Page<GetArticles> result =
getArticlesPortIn.operate(
PageRequest.of(
page,
size,
Sort.by(
new Sort.Order(
Sort.Direction.fromString(sort.split(",")[1]), sort.split(",")[0]))),
new GetArticlesCmd(searchField, searchValue, searchOpen));
return ResponseEntity.status(HttpStatus.OK)
.body(new GetArticlesResVO(
result.getContent(),
result.getNumber(),
result.getSize(),
result.getTotalElements(),
result.getTotalPages()));
}
}

View File

@@ -1,30 +0,0 @@
package app.module.api.usecases.article.getArticles.adapters.web.model;
import app.module.core.usecase.article.getArticles.ports.application.domain.GetArticles;
import io.swagger.v3.oas.annotations.media.Schema;
import java.util.List;
import lombok.AllArgsConstructor;
import lombok.EqualsAndHashCode;
import lombok.Getter;
import lombok.Setter;
@Getter
@Setter
@AllArgsConstructor
@EqualsAndHashCode
public class GetArticlesResVO {
@Schema(description = "예제 게시판 목록 데이터")
List<GetArticles> articles;
@Schema(description = "현재 페이지 번호")
private int page;
@Schema(description = "페이지 크기")
private int size;
@Schema(description = "전체 게시물 수")
private long totalElements;
@Schema(description = "전체 페이지 수")
private int totalPages;
}

View File

@@ -1,59 +0,0 @@
package app.module.api.usecases.article.getArticlesList.adapters.web;
import app.module.api.usecases.article.getArticlesList.adapters.web.model.GetArticlesListResVO;
import app.module.core.usecase.article.getArticles.ports.GetArticlesPortIn;
import app.module.core.usecase.article.getArticles.ports.application.domain.GetArticles;
import app.module.core.usecase.article.getArticles.ports.application.domain.GetArticlesCmd;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.Parameter;
import io.swagger.v3.oas.annotations.media.Content;
import io.swagger.v3.oas.annotations.media.Schema;
import io.swagger.v3.oas.annotations.responses.ApiResponse;
import io.swagger.v3.oas.annotations.tags.Tag;
import java.util.List;
import lombok.RequiredArgsConstructor;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
@RestController
@RequiredArgsConstructor
@Tag(name = "ARTICLE API", description = "예제 게시판 API")
class GetArticlesListController {
private final GetArticlesPortIn getArticlesPortIn;
@GetMapping(path = "/v1/admin/board/articles/list")
@Operation(
summary = "예제 게시판 게시물 전체 목록 API",
description = "Admin 예제 게시판 게시물 전체 목록 조회",
responses = {
@ApiResponse(
description = "GetArticlesList response",
content =
@Content(
mediaType = "application/json",
schema = @Schema(implementation = GetArticlesListResVO.class)))
})
ResponseEntity<GetArticlesListResVO> operate(
@Parameter(description = "검색 필드 조건")
@RequestParam(required = false)
@Schema(allowableValues = {"title", "updatedBy"})
String searchField,
@Parameter(description = "검색 필드 검색어")
@RequestParam(required = false)
String searchValue,
@Parameter(description = "공개여부 검색")
@RequestParam(required = false)
@Schema(allowableValues = {"true", "false"})
String searchOpen) {
List<GetArticles> result =
getArticlesPortIn.operateList(new GetArticlesCmd(searchField, searchValue, searchOpen));
return ResponseEntity.status(HttpStatus.OK)
.body(new GetArticlesListResVO(result));
}
}

View File

@@ -1,20 +0,0 @@
package app.module.api.usecases.article.getArticlesList.adapters.web.model;
import app.module.core.usecase.article.getArticles.ports.application.domain.GetArticles;
import io.swagger.v3.oas.annotations.media.Schema;
import java.util.List;
import lombok.AllArgsConstructor;
import lombok.EqualsAndHashCode;
import lombok.Getter;
import lombok.Setter;
@Getter
@Setter
@AllArgsConstructor
@EqualsAndHashCode
@Schema(description = "GetArticlesList response")
public class GetArticlesListResVO {
@Schema(description = "예제 게시판 목록 데이터")
List<GetArticles> articles;
}

View File

@@ -1,59 +0,0 @@
package app.module.api.usecases.article.removeArticles.adapters.web;
import app.module.api.usecases.article.removeArticles.adapters.web.model.RemoveArticlesReqVO;
import app.module.api.usecases.article.removeArticles.adapters.web.model.RemoveArticlesResVO;
import app.module.core.usecase.article.removeArticles.ports.RemoveArticlesPortIn;
import app.module.core.usecase.article.removeArticles.ports.application.domain.RemoveArticlesCmd;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.media.Content;
import io.swagger.v3.oas.annotations.media.Schema;
import io.swagger.v3.oas.annotations.responses.ApiResponse;
import io.swagger.v3.oas.annotations.tags.Tag;
import jakarta.validation.Valid;
import lombok.RequiredArgsConstructor;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.validation.BindingResult;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;
@RestController
@RequiredArgsConstructor
@Tag(name = "ARTICLE API", description = "예제 게시판 API")
class RemoveArticlesController {
private final RemoveArticlesPortIn removeArticlesPortIn;
@Operation(
summary = "예제 게시판 게시물 삭제 API",
description = "Admin 예제 게시판 게시물 다건 삭제",
requestBody =
@io.swagger.v3.oas.annotations.parameters.RequestBody(
description = "게시물 다건 삭제 요청 데이터",
content =
@Content(
mediaType = "application/json",
schema = @Schema(implementation = RemoveArticlesReqVO.class))),
responses = {
@ApiResponse(
description = "게시물 삭제 응답 데이터",
content =
@Content(
mediaType = "application/json",
schema = @Schema(implementation = RemoveArticlesResVO.class)))
})
@DeleteMapping(path = "/v1/admin/board/articles/remove")
ResponseEntity<?> operate(
@Valid @RequestBody RemoveArticlesReqVO reqVO,
BindingResult bindingResult) {
if (bindingResult.hasErrors()) {
return ResponseEntity.status(HttpStatus.UNPROCESSABLE_ENTITY).body(bindingResult);
}
removeArticlesPortIn.operate(new RemoveArticlesCmd(reqVO.getSelectIds()));
return ResponseEntity.status(HttpStatus.OK)
.body(new RemoveArticlesResVO(reqVO.getSelectIds()));
}
}

View File

@@ -1,21 +0,0 @@
package app.module.api.usecases.article.removeArticles.adapters.web.model;
import io.swagger.v3.oas.annotations.media.Schema;
import java.util.Set;
import lombok.AllArgsConstructor;
import lombok.EqualsAndHashCode;
import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.Setter;
@Getter
@Setter
@NoArgsConstructor
@AllArgsConstructor
@EqualsAndHashCode
@Schema(description = "삭제할 게시물 ID 목록 요청 데이터")
public class RemoveArticlesReqVO {
@Schema(description = "삭제할 게시물 ID", example = "[24,25]")
private Set<Long> selectIds;
}

View File

@@ -1,18 +0,0 @@
package app.module.api.usecases.article.removeArticles.adapters.web.model;
import io.swagger.v3.oas.annotations.media.Schema;
import java.util.Set;
import lombok.AllArgsConstructor;
import lombok.EqualsAndHashCode;
import lombok.Getter;
import lombok.Setter;
@Getter
@Setter
@AllArgsConstructor
@EqualsAndHashCode
@Schema(description = "게시물 삭제 응답 데이터")
public class RemoveArticlesResVO {
private Set<Long> selectIds;
}

View File

@@ -1,66 +0,0 @@
package app.module.api.usecases.article.sortArticles.adapters.web;
import app.module.api.usecases.article.sortArticles.adapters.web.model.SortArticlesReqVO;
import app.module.api.usecases.article.sortArticles.adapters.web.model.SortArticlesResVO;
import app.module.core.usecase.article.sortArticles.ports.SortArticlesPortIn;
import app.module.core.usecase.article.sortArticles.ports.application.domain.SortArticlesCmd;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.media.Content;
import io.swagger.v3.oas.annotations.media.Schema;
import io.swagger.v3.oas.annotations.responses.ApiResponse;
import io.swagger.v3.oas.annotations.tags.Tag;
import jakarta.validation.Valid;
import java.util.List;
import java.util.stream.Collectors;
import lombok.RequiredArgsConstructor;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.validation.BindingResult;
import org.springframework.web.bind.annotation.PatchMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;
@RestController
@RequiredArgsConstructor
@Tag(name = "ARTICLE API", description = "예제 게시판 API")
class SortArticlesController {
private final SortArticlesPortIn sortArticlesPortIn;
@Operation(
summary = "예제 게시판 게시물 정렬 변경 API",
description = "Admin 예제 게시판 게시물 정렬 변경",
requestBody =
@io.swagger.v3.oas.annotations.parameters.RequestBody(
description = "게시물 정렬 변경 요청 데이터",
content =
@Content(
mediaType = "application/json",
schema = @Schema(implementation = SortArticlesReqVO.class))),
responses = {
@ApiResponse(
description = "게시물 정렬 변경 응답 데이터",
content =
@Content(
mediaType = "application/json",
schema = @Schema(implementation = SortArticlesResVO.class)))
})
@PatchMapping(path = "/v1/admin/board/articles/sort")
ResponseEntity<?> operate(
@Valid @RequestBody List<SortArticlesReqVO> reqVOs,
BindingResult bindingResult) {
if (bindingResult.hasErrors()) {
return ResponseEntity.status(HttpStatus.UNPROCESSABLE_ENTITY).body(bindingResult);
}
sortArticlesPortIn.operate(
reqVOs.stream()
.map(
sortArticlesReqVO ->
new SortArticlesCmd(sortArticlesReqVO.getId(),
sortArticlesReqVO.getOrderNo()))
.collect(Collectors.toList()));
return ResponseEntity.status(HttpStatus.OK).body(new SortArticlesResVO(true));
}
}

View File

@@ -1,26 +0,0 @@
package app.module.api.usecases.article.sortArticles.adapters.web.model;
import io.swagger.v3.oas.annotations.media.Schema;
import jakarta.validation.constraints.NotNull;
import lombok.AllArgsConstructor;
import lombok.EqualsAndHashCode;
import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.Setter;
@Getter
@Setter
@NoArgsConstructor
@AllArgsConstructor
@EqualsAndHashCode
@Schema(description = "정렬 변경할 게시물 요청 파라미터")
public class SortArticlesReqVO {
@NotNull(message = "{valid.common.required}")
@Schema(description = "게시물 ID", example = "[1,2]")
private Long id;
@NotNull(message = "{valid.common.required}")
@Schema(description = "정렬 번호", example = "[3,4]")
private Integer orderNo;
}

View File

@@ -1,17 +0,0 @@
package app.module.api.usecases.article.sortArticles.adapters.web.model;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.AllArgsConstructor;
import lombok.EqualsAndHashCode;
import lombok.Getter;
import lombok.Setter;
@Getter
@Setter
@AllArgsConstructor
@EqualsAndHashCode
@Schema(description = "정렬 변경할 게시물 응답 데이터")
public class SortArticlesResVO {
private boolean sorted;
}

View File

@@ -1,72 +0,0 @@
package app.module.api.usecases.article.updateArticle.adapters.web;
import app.module.api.usecases.article.updateArticle.adapters.web.model.UpdateArticleReqVO;
import app.module.api.usecases.article.updateArticle.adapters.web.model.UpdateArticleResVO;
import app.module.api.usecases.article.updateArticle.adapters.web.validator.UpdateArticleValidator;
import app.module.core.usecase.article.updateArticle.ports.UpdateArticlePortIn;
import app.module.core.usecase.article.updateArticle.ports.application.domain.UpdateArticleCmd;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.media.Content;
import io.swagger.v3.oas.annotations.media.Schema;
import io.swagger.v3.oas.annotations.responses.ApiResponse;
import io.swagger.v3.oas.annotations.tags.Tag;
import jakarta.validation.Valid;
import lombok.RequiredArgsConstructor;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.validation.BindingResult;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;
@RestController
@RequiredArgsConstructor
@Tag(name = "ARTICLE API", description = "예제 게시판 API")
class UpdateArticleController {
private final UpdateArticlePortIn updateArticlePortIn;
private final UpdateArticleValidator updateArticleValidator;
@Operation(
summary = "예제 게시판 게시물 수정 API",
description = "Admin 예제 게시판 게시물 수정",
requestBody =
@io.swagger.v3.oas.annotations.parameters.RequestBody(
description = "게시물 수정 요청 데이터",
content =
@Content(
mediaType = "application/json",
schema = @Schema(implementation = UpdateArticleReqVO.class))),
responses = {
@ApiResponse(
description = "게시물 수정 응답 데이터",
content =
@Content(
mediaType = "application/json",
schema = @Schema(implementation = UpdateArticleResVO.class)))
})
@PutMapping(path = "/v1/admin/board/articles/update")
ResponseEntity<?> operate(
@Valid @RequestBody UpdateArticleReqVO reqVO, BindingResult bindingResult) {
updateArticleValidator.validate(reqVO, bindingResult);
if (bindingResult.hasErrors()) {
return ResponseEntity.status(HttpStatus.UNPROCESSABLE_ENTITY).body(bindingResult);
}
updateArticlePortIn.operate(
new UpdateArticleCmd(
reqVO.getId(),
reqVO.getTitle(),
reqVO.getContent(),
reqVO.getVisible(),
reqVO.getOrderNo(),
reqVO.getStartDate(),
reqVO.getEndDate(),
reqVO.getFileMappingId()));
return ResponseEntity.status(HttpStatus.OK)
.body(new UpdateArticleResVO(reqVO.getId(), reqVO.getTitle()));
}
}

View File

@@ -1,64 +0,0 @@
package app.module.api.usecases.article.updateArticle.adapters.web.model;
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 java.time.LocalDateTime;
import java.util.List;
import lombok.AllArgsConstructor;
import lombok.EqualsAndHashCode;
import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.Setter;
import org.apache.commons.text.StringEscapeUtils;
@Getter
@Setter
@NoArgsConstructor
@AllArgsConstructor
@EqualsAndHashCode
@Schema(description = "게시물 수정 요청 데이터")
public class UpdateArticleReqVO {
@NotNull(message = "{valid.common.required}")
@Schema(description = "게시물 id", example = "1")
private Long id;
@NotBlank(message = "{valid.common.required}")
@Schema(description = "제목", example = "Article No.0 update")
private String title;
@NotBlank(message = "{valid.common.required}")
@Schema(description = "내용", example = "Content No.0 update")
private String content;
@NotNull(message = "{valid.common.required}")
@Schema(description = "공개여부", example = "true")
private Boolean visible;
@NotNull(message = "{valid.common.required}")
@Schema(description = "정렬번호", example = "0")
private Integer orderNo;
@NotNull(message = "{valid.common.required}")
@Schema(description = "시작날짜", type = "string", example = "2025-03-07T08:38")
@JsonFormat(shape = JsonFormat.Shape.STRING, pattern = "yyyy-MM-dd'T'HH:mm")
private LocalDateTime startDate;
@NotNull(message = "{valid.common.required}")
@Schema(description = "종료날짜", type = "string", example = "2025-05-07T08:38")
@JsonFormat(shape = JsonFormat.Shape.STRING, pattern = "yyyy-MM-dd'T'HH:mm")
private LocalDateTime endDate;
@Schema(description = "파일 매핑 ID", nullable = true, defaultValue = "[]")
private List<String> fileMappingId;
public String getTitle() {
return StringEscapeUtils.escapeHtml4(title);
}
public String getContent() {
return StringEscapeUtils.escapeHtml4(content);
}
}

View File

@@ -1,20 +0,0 @@
package app.module.api.usecases.article.updateArticle.adapters.web.model;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.AllArgsConstructor;
import lombok.EqualsAndHashCode;
import lombok.Getter;
import lombok.Setter;
@Getter
@Setter
@AllArgsConstructor
@EqualsAndHashCode
@Schema(description = "게시물 수정 응답 데이터")
public class UpdateArticleResVO {
@Schema(description = "수정된 게시물 ID")
private Long id;
@Schema(description = "수정된 게시물 제목")
private String title;
}

View File

@@ -1,55 +0,0 @@
package app.module.api.usecases.article.updateArticle.adapters.web.validator;
import app.module.api.usecases.article.updateArticle.adapters.web.model.UpdateArticleReqVO;
import app.module.core.config.application.util.MessageUtil;
import java.time.LocalDateTime;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Component;
import org.springframework.validation.Errors;
import org.springframework.validation.Validator;
@Component
@RequiredArgsConstructor
public class UpdateArticleValidator implements Validator {
private final MessageUtil messageUtil;
@Override
public boolean supports(Class<?> clazz) {
return UpdateArticleReqVO.class.equals(clazz);
}
@Override
public void validate(Object target, Errors errors) {
UpdateArticleReqVO vo = (UpdateArticleReqVO) target;
LocalDateTime startDate = vo.getStartDate();
LocalDateTime endDate = vo.getEndDate();
// 게시일 날짜 체크
if (startDate == null) {
errors.rejectValue(
"startDate", "valid.common.required",
messageUtil.getMessage("valid.common.required"));
}
if (endDate == null) {
errors.rejectValue(
"endDate", "valid.common.required",
messageUtil.getMessage("valid.common.required"));
}
if (startDate != null && endDate != null) {
if (!startDate.isBefore(endDate)) {
errors.rejectValue(
"startDate",
"valid.common.date.invalid",
messageUtil.getMessage("valid.common.date.invalid"));
errors.rejectValue(
"endDate",
"valid.common.date.invalid",
messageUtil.getMessage("valid.common.date.invalid"));
}
}
}
}

View File

@@ -1,64 +0,0 @@
package app.module.api.usecases.auth.adminLogin.adapters.web;
import app.module.api.config.application.util.JwtTokenProvider;
import app.module.api.usecases.auth.adminLogin.adapters.web.model.AdminLoginReqVO;
import app.module.api.usecases.auth.adminLogin.adapters.web.model.AdminLoginResVO;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.media.Content;
import io.swagger.v3.oas.annotations.media.Schema;
import io.swagger.v3.oas.annotations.responses.ApiResponse;
import io.swagger.v3.oas.annotations.tags.Tag;
import jakarta.validation.Valid;
import java.util.stream.Collectors;
import lombok.RequiredArgsConstructor;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.security.authentication.AuthenticationManager;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.validation.BindingResult;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;
@RestController
@RequiredArgsConstructor
@Tag(name = "Admin Auth API", description = "관리자 로그인 API")
class AdminLoginController {
private final AuthenticationManager authenticationManager;
private final JwtTokenProvider jwtTokenProvider;
@PostMapping(path = "/v1/admin/auth/login")
@Operation(
summary = "관리자 로그인",
description = "관리자 인증 API",
responses = {
@ApiResponse(
content =
@Content(
mediaType = "application/json",
schema = @Schema(implementation = AdminLoginResVO.class)))
})
ResponseEntity<?> operate(
@Valid @RequestBody AdminLoginReqVO reqVO, BindingResult bindingResult) {
if (bindingResult.hasErrors()) {
return ResponseEntity.status(HttpStatus.UNPROCESSABLE_ENTITY).body(bindingResult);
}
UsernamePasswordAuthenticationToken authenticationToken =
new UsernamePasswordAuthenticationToken(reqVO.getUsername(), reqVO.getPassword());
Authentication authentication = authenticationManager.authenticate(authenticationToken);
return ResponseEntity.status(HttpStatus.OK)
.body(
new AdminLoginResVO(
jwtTokenProvider.createToken(
authentication.getName(),
authentication.getAuthorities().stream()
.map(GrantedAuthority::getAuthority)
.collect(Collectors.toList()))));
}
}

View File

@@ -1,21 +0,0 @@
package app.module.api.usecases.auth.adminLogin.adapters.web.model;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.AllArgsConstructor;
import lombok.EqualsAndHashCode;
import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.Setter;
@Getter
@Setter
@NoArgsConstructor
@AllArgsConstructor
@EqualsAndHashCode
public class AdminLoginReqVO {
@Schema(description = "사용자 계정", example = "recycle-super")
private String username;
@Schema(description = "사용자 패스워드", example = "recycle1@#$")
private String password;
}

Some files were not shown because too many files have changed in this diff Show More