전남대 BE_박진화 6주차 과제(Step2)

src/main/java/gift/controller/MemberController.java

@@ -1,23 +1,27 @@
 package gift.controller;
 
+import gift.dto.member.LoginResponse;
+import gift.dto.member.MemberRequest;
+import gift.dto.member.MemberResponse;
 import gift.entity.Member;
 import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.http.HttpStatus;
 import org.springframework.http.ResponseEntity;
 import org.springframework.web.bind.annotation.*;
 import gift.service.MemberService;
 import gift.util.JwtUtil;
 
 import jakarta.servlet.http.HttpServletRequest;
-import java.util.HashMap;
-import java.util.Map;
+
+import java.net.URI;
 import java.util.Optional;
 
 import io.swagger.v3.oas.annotations.tags.Tag;
 import io.swagger.v3.oas.annotations.Operation;
 import io.swagger.v3.oas.annotations.Parameter;
 
 @RestController
-@RequestMapping("/member")
+@RequestMapping("/api/members")
 @Tag(name = "Member Management System", description = "Operations related to member management")
 public class MemberController {
     private final MemberService memberService;
@@ -29,31 +33,36 @@ public MemberController(MemberService service, JwtUtil util) {
         this.jwtUtil = util;
     }
 
-    @PostMapping("/register")
+    @PostMapping(value ="/register")
     @Operation(summary = "Register a new member", description = "Registers a new member to the system", tags = { "Member Management System" })
-    public ResponseEntity<Map<String, String>> register(
+    public ResponseEntity<MemberResponse> register(
             @Parameter(description = "Member object to be registered", required = true)
-            @RequestBody Member member) {
-        memberService.save(member);
-        Map<String, String> response = new HashMap<>();
-        response.put("message", "success");
-        return ResponseEntity.ok(response);
+            @RequestBody MemberRequest memberRequest) {
+        Member member = new Member.Builder()
+                .email(memberRequest.getEmail())
+                .password(memberRequest.getPassword())
+                .name(memberRequest.getName())
+                .build();
+        member = memberService.save(member);
+        String token = jwtUtil.generateToken(member.getEmail());
+        MemberResponse memberResponse = new MemberResponse(member.getId(), member.getEmail(), member.getName(), token);
+
+        return ResponseEntity.created(URI.create("/api/members/" + member.getId())).body(memberResponse);
     }
 
     @PostMapping("/login")
     @Operation(summary = "Login a member", description = "Logs in an existing member", tags = { "Member Management System" })
-    public ResponseEntity<Map<String, String>> login(
+    public ResponseEntity<LoginResponse> login(
             @Parameter(description = "Login request containing email and password", required = true)
-            @RequestBody Member loginRequest) {
+            @RequestBody MemberRequest loginRequest) {
         Optional<Member> memberOpt = memberService.findByEmail(loginRequest.getEmail());
         if (memberOpt.isPresent() && memberOpt.get().getPassword().equals(loginRequest.getPassword())) {
             String token = jwtUtil.generateToken(memberOpt.get().getEmail());
-            Map<String, String> response = new HashMap<>();
-            response.put("message", "success");
-            response.put("token", token);
+            LoginResponse response = new LoginResponse(token);
+
             return ResponseEntity.ok(response);
         }
-        return ResponseEntity.status(401).body(null);
+        return ResponseEntity.status(HttpStatus.UNAUTHORIZED).build();
     }
 
     @GetMapping("/me")

src/main/java/gift/controller/OptionController.java

@@ -1,17 +1,24 @@
 package gift.controller;
 
-import gift.dto.OptionRequest;
+import gift.dto.option.DeleteOptionRequest;
+import gift.dto.option.OptionRequest;
+import gift.dto.option.OptionResponse;
+import gift.dto.option.OptionUpdateResponse;
 import gift.entity.Option;
+import gift.exception.CustomException;
 import gift.service.OptionService;
 import jakarta.validation.Valid;
+import org.springframework.http.HttpStatus;
 import org.springframework.http.ResponseEntity;
 import org.springframework.web.bind.annotation.*;
 
+import java.net.URI;
 import java.util.List;
 
 import io.swagger.v3.oas.annotations.tags.Tag;
 import io.swagger.v3.oas.annotations.Operation;
 import io.swagger.v3.oas.annotations.Parameter;
+import org.springframework.web.util.UriComponentsBuilder;
 
 @RestController
 @RequestMapping("/api/products/{productId}/options")
@@ -25,45 +32,56 @@ public OptionController(OptionService optionService) {
 
     @GetMapping
     @Operation(summary = "Get options for a product", description = "Fetches all options for a specified product", tags = { "Product Option Management System" })
-    public ResponseEntity<List<Option>> getOptions(
+    public ResponseEntity<List<OptionResponse>> getOptions(
             @Parameter(description = "ID of the product", required = true)
             @PathVariable Long productId) {
-        List<Option> options = optionService.getOptionsByProductId(productId);
+        List<OptionResponse> options = optionService.getOptionsByProductId(productId);
         return ResponseEntity.ok(options);
     }
 
     @PostMapping
     @Operation(summary = "Add an option to a product", description = "Adds a new option to a specified product", tags = { "Product Option Management System" })
-    public ResponseEntity<Option> addOptionToProduct(
+    public ResponseEntity<OptionResponse> addOptionToProduct(
             @Parameter(description = "ID of the product", required = true)
             @PathVariable Long productId,
             @Parameter(description = "Option details", required = true)
-            @Valid @RequestBody OptionRequest optionDTO) {
-        Option option = optionService.addOptionToProduct(productId, optionDTO);
-        return ResponseEntity.ok(option);
+            @Valid @RequestBody OptionRequest optionRequest,
+            UriComponentsBuilder uriBuilder) {
+        Option option = optionService.addOptionToProduct(productId, optionRequest);
+        OptionResponse response = new OptionResponse(option.getId(), option.getName(), option.getQuantity());
+        URI location = uriBuilder.path("/api/products/{productId}/options/{optionId}").buildAndExpand(productId, option.getId()).toUri();
+        return ResponseEntity.created(location).body(response);
     }
 
     @PutMapping("/{optionId}")
     @Operation(summary = "Update an option for a product", description = "Updates an existing option of a specified product", tags = { "Product Option Management System" })
-    public ResponseEntity<Option> updateOption(
+    public ResponseEntity<OptionUpdateResponse> updateOption(
             @Parameter(description = "ID of the option to be updated", required = true)
             @PathVariable Long optionId,
             @Parameter(description = "Updated option details", required = true)
             @RequestBody OptionRequest optionRequest,
             @Parameter(description = "ID of the product", required = true)
             @PathVariable String productId) {
-        Option updatedOption = optionService.updateOption(optionId, optionRequest.getName(), optionRequest.getQuantity());
+        OptionUpdateResponse updatedOption = optionService.updateOption(optionId, optionRequest.getName(), optionRequest.getQuantity());
         return ResponseEntity.ok(updatedOption);
     }
 
     @DeleteMapping("/{optionId}")
     @Operation(summary = "Delete an option from a product", description = "Deletes an option from a specified product", tags = { "Product Option Management System" })
-    public ResponseEntity<Void> deleteOption(
+    public ResponseEntity<String> deleteOption(
             @Parameter(description = "ID of the option to be deleted", required = true)
             @PathVariable Long optionId,
             @Parameter(description = "ID of the product", required = true)
-            @PathVariable String productId) {
-        optionService.deleteOption(optionId);
-        return ResponseEntity.noContent().build();
+            @RequestBody DeleteOptionRequest deleteOptionRequest) {
+        try {
+            optionService.deleteOption(optionId, DeleteOptionRequest.getEmail(), DeleteOptionRequest.getPassword());
+            return ResponseEntity.ok("Option successfully deleted.");
+        } catch (CustomException.EntityNotFoundException e) {
+            return ResponseEntity.status(HttpStatus.NOT_FOUND).body(e.getMessage());
+        } catch (CustomException.InvalidPasswordException e) {
+            return ResponseEntity.status(HttpStatus.UNAUTHORIZED).body(e.getMessage());
+        } catch (Exception e) {
+            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body("An error occurred: " + e.getMessage());
+        }
     }
 }

src/main/java/gift/controller/OrderController.java

@@ -1,11 +1,13 @@
 package gift.controller;
 
-import gift.dto.OrderRequest;
-import gift.dto.OrderResponse;
+import gift.dto.order.OrderRequest;
+import gift.dto.order.OrderResponse;
 import gift.service.OrderService;
 import gift.util.JwtUtil;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
 import org.springframework.http.HttpStatus;
 import org.springframework.http.ResponseEntity;
 import org.springframework.web.bind.annotation.*;
@@ -29,6 +31,34 @@ public OrderController(OrderService orderService, JwtUtil jwtUtil) {
         this.orderService = orderService;
         this.jwtUtil = jwtUtil;
     }
+    @GetMapping
+    @Operation(summary = "Get all orders for the logged-in user", description = "Fetches all orders made by the logged-in user", tags = {"Order Management System"})
+    public ResponseEntity<Page<OrderResponse>> getOrders(
+            @Parameter(description = "Authorization token", required = true) @RequestHeader("Authorization") String authorizationHeader,
+            Pageable pageable) {
+        logger.info("Received request to fetch orders");
+
+        if (authorizationHeader == null || !authorizationHeader.startsWith("Bearer ")) {
+            logger.warn("Authorization header is missing or invalid");
+            return ResponseEntity.status(HttpStatus.UNAUTHORIZED).build();
+        }
+
+        String token = authorizationHeader.substring("Bearer ".length());
+        if (!jwtUtil.validateToken(token) || jwtUtil.isTokenExpired(token)) {
+            logger.warn("Invalid or expired token");
+            return ResponseEntity.status(HttpStatus.UNAUTHORIZED).build();
+        }
+
+        String email = jwtUtil.extractEmail(token);
+        if (email == null) {
+            logger.warn("Failed to extract email from token");
+            return ResponseEntity.status(HttpStatus.UNAUTHORIZED).build();
+        }
+
+        Page<OrderResponse> orderResponses = orderService.getOrdersByEmail(email, pageable);
+
+        return ResponseEntity.ok(orderResponses);
+    }
 
     @PostMapping
     @Operation(summary = "Place an order", description = "Places a new order in the system", tags = { "Order Management System" })