✨ 문의하기 API

pennyway-app-external-api/src/main/java/kr/co/pennyway/api/apis/question/api/QuestionApi.java

@@ -0,0 +1,26 @@
+package kr.co.pennyway.api.apis.question.api;
+
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.media.Content;
+import io.swagger.v3.oas.annotations.media.ExampleObject;
+import io.swagger.v3.oas.annotations.responses.ApiResponse;
+import io.swagger.v3.oas.annotations.tags.Tag;
+import kr.co.pennyway.api.apis.question.dto.QuestionReq;
+import org.springframework.http.ResponseEntity;
+import org.springframework.validation.annotation.Validated;
+import org.springframework.web.bind.annotation.RequestBody;
+
+@Tag(name = "[문의 API]")
+public interface QuestionApi {
+
+    @Operation(summary = "문의 전송", description = "사용자는 관리자에게 문의 메일을 발송한다.")
+    @ApiResponse(responseCode = "200", content = @Content(mediaType = "application/json", examples = {
+            @ExampleObject(name = "발신 성공", value = """
+                    {
+                        "code": "2000",
+                        "data": {}
+                    }
+                    """)
+    }))
+    ResponseEntity<?> sendQuestion(@RequestBody @Validated QuestionReq request);
+}

pennyway-app-external-api/src/main/java/kr/co/pennyway/api/apis/question/controller/QuestionController.java

@@ -0,0 +1,31 @@
+package kr.co.pennyway.api.apis.question.controller;
+
+import kr.co.pennyway.api.apis.question.api.QuestionApi;
+import kr.co.pennyway.api.apis.question.dto.QuestionReq;
+import kr.co.pennyway.api.apis.question.usecase.QuestionUseCase;
+import kr.co.pennyway.api.common.response.SuccessResponse;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.http.ResponseEntity;
+import org.springframework.security.access.prepost.PreAuthorize;
+import org.springframework.validation.annotation.Validated;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+@Slf4j
+@RestController
+@RequiredArgsConstructor
+@RequestMapping("/v1/questions")
+public class QuestionController implements QuestionApi {
+    private final QuestionUseCase questionUseCase;
+
+    @Override
+    @PostMapping("")
+    @PreAuthorize("permitAll()")
+    public ResponseEntity<?> sendQuestion(@RequestBody @Validated QuestionReq request) {
+        questionUseCase.sendQuestion(request);
+        return ResponseEntity.ok(SuccessResponse.noContent());
+    }
+}

pennyway-app-external-api/src/main/java/kr/co/pennyway/api/apis/question/dto/QuestionReq.java

@@ -0,0 +1,29 @@
+package kr.co.pennyway.api.apis.question.dto;
+
+import io.swagger.v3.oas.annotations.media.Schema;
+import jakarta.validation.constraints.Email;
+import jakarta.validation.constraints.NotBlank;
+import jakarta.validation.constraints.NotNull;
+import kr.co.pennyway.domain.domains.question.domain.Question;
+import kr.co.pennyway.domain.domains.question.domain.QuestionCategory;
+
+public record QuestionReq(
+        @Schema(description = "문의자 이메일", example = "[email protected]")
+        @NotBlank(message = "이메일을 입력해주세요")
+        @Email(message = "이메일 형식이 올바르지 않습니다.")
+        String email,
+        @Schema(description = "문의 내용", example = "문의 내용입니다.")
+        @NotBlank(message = "문의 내용을 입력해주세요")
+        String content,
+        @Schema(description = "문의 카테고리", example = "UTILIZATION")
+        @NotNull(message = "문의 카테고리를 입력해주세요")
+        QuestionCategory category
+) {
+    public Question toEntity() {
+        return Question.builder()
+                .email(email)
+                .content(content)
+                .category(category)
+                .build();
+    }
+}

pennyway-app-external-api/src/main/java/kr/co/pennyway/api/apis/question/usecase/QuestionUseCase.java

@@ -0,0 +1,27 @@
+package kr.co.pennyway.api.apis.question.usecase;
+
+import jakarta.transaction.Transactional;
+import kr.co.pennyway.api.apis.question.dto.QuestionReq;
+import kr.co.pennyway.common.annotation.UseCase;
+import kr.co.pennyway.domain.domains.question.domain.Question;
+import kr.co.pennyway.domain.domains.question.service.QuestionService;
+import kr.co.pennyway.infra.common.event.MailEvent;
+import lombok.AllArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.context.ApplicationEventPublisher;
+
+@Slf4j
+@UseCase
+@AllArgsConstructor
+public class QuestionUseCase {
+    private final QuestionService questionService;
+    private final ApplicationEventPublisher applicationEventPublisher;
+
+    @Transactional
+    public void sendQuestion(QuestionReq request) {
+        Question question = request.toEntity();
+
+        questionService.createQuestion(question);
+        applicationEventPublisher.publishEvent(MailEvent.of(request.email(), request.content(), request.category().getTitle()));
+    }
+}

pennyway-app-external-api/src/main/java/kr/co/pennyway/api/config/security/SecurityConfig.java

@@ -27,9 +27,11 @@
 @RequiredArgsConstructor
 public class SecurityConfig {
     private static final String[] READ_ONLY_PUBLIC_ENDPOINTS = {"/favicon.ico", "/v1/duplicate/**"};
+    private static final String[] PUBLIC_ENDPOINTS = {"/v1/questions/**"};
     private static final String[] ANONYMOUS_ENDPOINTS = {"/v1/auth/**", "/v1/phone/**"};
     private static final String[] SWAGGER_ENDPOINTS = {"/api-docs/**", "/v3/api-docs/**", "/swagger-ui/**", "/swagger",};
 
+
     private final SecurityAdapterConfig securityAdapterConfig;
     private final CorsConfigurationSource corsConfigurationSource;
     private final AccessDeniedHandler accessDeniedHandler;
@@ -79,6 +81,7 @@ private AbstractRequestMatcherRegistry<AuthorizeHttpRequestsConfigurer<HttpSecur
         return auth.requestMatchers(PathRequest.toStaticResources().atCommonLocations()).permitAll()
                 .requestMatchers(HttpMethod.OPTIONS, "*").permitAll()
                 .requestMatchers(HttpMethod.GET, READ_ONLY_PUBLIC_ENDPOINTS).permitAll()
+                .requestMatchers(PUBLIC_ENDPOINTS).permitAll()
                 .requestMatchers(ANONYMOUS_ENDPOINTS).anonymous();
     }
 }

pennyway-app-external-api/src/test/java/kr/co/pennyway/api/apis/question/controller/QuestionControllerTest.java

@@ -0,0 +1,126 @@
+package kr.co.pennyway.api.apis.question.controller;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import kr.co.pennyway.api.apis.question.dto.QuestionReq;
+import kr.co.pennyway.api.apis.question.usecase.QuestionUseCase;
+import kr.co.pennyway.domain.domains.question.domain.QuestionCategory;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.autoconfigure.web.servlet.WebMvcTest;
+import org.springframework.boot.test.mock.mockito.MockBean;
+import org.springframework.http.MediaType;
+import org.springframework.test.context.ActiveProfiles;
+import org.springframework.test.web.servlet.MockMvc;
+import org.springframework.test.web.servlet.ResultActions;
+import org.springframework.test.web.servlet.setup.MockMvcBuilders;
+import org.springframework.web.context.WebApplicationContext;
+
+import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.post;
+import static org.springframework.test.web.servlet.result.MockMvcResultHandlers.print;
+import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.jsonPath;
+import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;
+
+@WebMvcTest(controllers = QuestionController.class)
+@ActiveProfiles("local")
+public class QuestionControllerTest {
+
+    private final String expectedEmail = "[email protected]";
+    private final String expectedContent = "test question content";
+    private final QuestionCategory expectedCategory = QuestionCategory.ETC;
+    @Autowired
+    private MockMvc mockMvc;
+    @Autowired
+    private ObjectMapper objectMapper;
+    @MockBean
+    private QuestionUseCase questionUseCase;
+
+    @BeforeEach
+    void setUp(WebApplicationContext webApplicationContext) {
+        this.mockMvc = MockMvcBuilders
+                .webAppContextSetup(webApplicationContext)
+                .defaultRequest(post("/**"))//.with(csrf()))
+                .build();
+    }
+
+    @Test
+    @DisplayName("[1] 이메일, 내용을 필수로 입력해야 합니다.")
+    void requiredInputError() throws Exception {
+        // given
+        QuestionReq request = new QuestionReq("", "", QuestionCategory.ETC);
+
+        // when
+        ResultActions resultActions = mockMvc.perform(
+                post("/v1/questions")
+                        .contentType(MediaType.APPLICATION_JSON)
+                        .content(objectMapper.writeValueAsString(request))
+        );
+
+        // then
+        resultActions
+                .andExpect(status().isUnprocessableEntity())
+                .andExpect(jsonPath("$.fieldErrors.email").value("이메일을 입력해주세요"))
+                .andExpect(jsonPath("$.fieldErrors.content").value("문의 내용을 입력해주세요"))
+                .andDo(print());
+    }
+
+    @Test
+    @DisplayName("[2] 이메일 형식 오류입니다.")
+    void emailValidError() throws Exception {
+        // given
+        QuestionReq request = new QuestionReq("test", "test question content", QuestionCategory.ETC);
+
+        // when
+        ResultActions resultActions = mockMvc.perform(
+                post("/v1/questions")
+                        .contentType(MediaType.APPLICATION_JSON)
+                        .content(objectMapper.writeValueAsString(request))
+        );
+
+        // then
+        resultActions
+                .andExpect(status().isUnprocessableEntity())
+                .andExpect(jsonPath("$.fieldErrors.email").value("이메일 형식이 올바르지 않습니다."))
+                .andDo(print());
+    }
+
+    @Test
+    @DisplayName(("[3] 문의 카테고리를 선택해주세요."))
+    void categoryMissingError() throws Exception {
+        // given
+        QuestionReq request = new QuestionReq("[email protected]", "test question content", null);
+
+        // when
+        ResultActions resultActions = mockMvc.perform(
+                post("/v1/questions")
+                        .contentType(MediaType.APPLICATION_JSON)
+                        .content(objectMapper.writeValueAsString(request))
+        );
+
+        // then
+        resultActions
+                .andExpect(status().isUnprocessableEntity())
+                .andExpect(jsonPath("$.fieldErrors.category").value("문의 카테고리를 입력해주세요"))
+                .andDo(print());
+    }
+
+    @Test
+    @DisplayName("[4] 정상적인 문의 요청입니다.")
+    void sendQuestion() throws Exception {
+        // given
+        QuestionReq request = new QuestionReq(expectedEmail, expectedContent, expectedCategory);
+
+        // when
+        ResultActions resultActions = mockMvc.perform(
+                post("/v1/questions")
+                        .contentType(MediaType.APPLICATION_JSON)
+                        .content(objectMapper.writeValueAsString(request))
+        );
+
+        // then
+        resultActions
+                .andExpect(status().isOk())
+                .andDo(print());
+    }
+}

pennyway-domain/src/main/java/kr/co/pennyway/domain/common/converter/QuestionCategoryConverter.java

@@ -0,0 +1,13 @@
+package kr.co.pennyway.domain.common.converter;
+
+import jakarta.persistence.Converter;
+import kr.co.pennyway.domain.domains.question.domain.QuestionCategory;
+
+@Converter
+public class QuestionCategoryConverter extends AbstractLegacyEnumAttributeConverter<QuestionCategory> {
+    private static final String ENUM_NAME = "문의 카테고리";
+
+    public QuestionCategoryConverter() {
+        super(QuestionCategory.class, false, ENUM_NAME);
+    }
+}

pennyway-domain/src/main/java/kr/co/pennyway/domain/domains/question/domain/Question.java

@@ -0,0 +1,41 @@
+package kr.co.pennyway.domain.domains.question.domain;
+
+import jakarta.persistence.*;
+import kr.co.pennyway.domain.common.converter.QuestionCategoryConverter;
+import lombok.AccessLevel;
+import lombok.Builder;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import org.springframework.data.annotation.CreatedDate;
+import org.springframework.data.jpa.domain.support.AuditingEntityListener;
+
+import java.time.LocalDateTime;
+
+@Entity
+@Getter
+@Table(name = "Question")
+@NoArgsConstructor(access = AccessLevel.PROTECTED)
+@EntityListeners(AuditingEntityListener.class)
+public class Question {
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Long id;
+    @Column(nullable = false)
+    private String email;
+    @Convert(converter = QuestionCategoryConverter.class)
+    @Column(nullable = false)
+    private QuestionCategory category;
+    private String content;
+    @CreatedDate
+    @Column(name = "created_at", nullable = false, updatable = false)
+    private LocalDateTime createdAt;
+    private LocalDateTime deletedAt;
+
+    @Builder
+    private Question(String email, QuestionCategory category, String content, LocalDateTime createdAt, LocalDateTime deletedAt) {
+        this.email = email;
+        this.category = category;
+        this.content = content;
+        this.createdAt = createdAt;
+    }
+}

pennyway-domain/src/main/java/kr/co/pennyway/domain/domains/question/domain/QuestionCategory.java

@@ -0,0 +1,19 @@
+package kr.co.pennyway.domain.domains.question.domain;
+
+import kr.co.pennyway.domain.common.converter.LegacyCommonType;
+import lombok.AccessLevel;
+import lombok.Getter;
+import lombok.RequiredArgsConstructor;
+
+
+@RequiredArgsConstructor(access = AccessLevel.PRIVATE)
+@Getter
+public enum QuestionCategory implements LegacyCommonType {
+    UTILIZATION("1", "이용 관련"),
+    BUG_REPORT("2", "오류 신고"),
+    SUGGESTION("3", "서비스 제안"),
+    ETC("4", "기타");
+
+    private final String code;
+    private final String title;
+}

pennyway-domain/src/main/java/kr/co/pennyway/domain/domains/question/exception/QuestionErrorCode.java

@@ -0,0 +1,26 @@
+package kr.co.pennyway.domain.domains.question.exception;
+
+import kr.co.pennyway.common.exception.BaseErrorCode;
+import kr.co.pennyway.common.exception.CausedBy;
+import kr.co.pennyway.common.exception.ReasonCode;
+import kr.co.pennyway.common.exception.StatusCode;
+import lombok.AllArgsConstructor;
+
+@AllArgsConstructor
+public enum QuestionErrorCode implements BaseErrorCode {
+    INTERNAL_MAIL_ERROR(StatusCode.INTERNAL_SERVER_ERROR, ReasonCode.UNEXPECTED_ERROR, "메일 발송에 실패했습니다.");
+
+    private final StatusCode statusCode;
+    private final ReasonCode reasonCode;
+    private final String message;
+
+    @Override
+    public CausedBy causedBy() {
+        return CausedBy.of(statusCode, reasonCode);
+    }
+
+    @Override
+    public String getExplainError() throws NoSuchFieldError {
+        return message;
+    }
+}

pennyway-domain/src/main/java/kr/co/pennyway/domain/domains/question/exception/QuestionErrorException.java

@@ -0,0 +1,24 @@
+package kr.co.pennyway.domain.domains.question.exception;
+
+import kr.co.pennyway.common.exception.BaseErrorCode;
+import kr.co.pennyway.common.exception.CausedBy;
+import kr.co.pennyway.common.exception.GlobalErrorException;
+import kr.co.pennyway.domain.domains.user.exception.UserErrorCode;
+import lombok.Getter;
+
+public class QuestionErrorException extends GlobalErrorException {
+    private final QuestionErrorCode questionErrorCode;
+
+    public QuestionErrorException(QuestionErrorCode questionErrorCode) {
+        super(questionErrorCode);
+        this.questionErrorCode = questionErrorCode;
+    }
+
+    public CausedBy causedBy() {
+        return questionErrorCode.causedBy();
+    }
+
+    public String getExplainError() {
+        return questionErrorCode.getExplainError();
+    }
+}