OrderService + OrderConditionService

package com.example.investment_api.virtual.order.controller.dto;

import lombok.Getter;
import lombok.Setter;

@Getter
@Setter
public class OrderRequest {
private Long memberId; // 회원 ID
private String stockName; // 주식 이름
private int quantity; // 주문 수량
private int price; // 가격 (현재가 또는 지정가)
private String orderType; // 주문 유형 ("BUY" 또는 "SELL")
}

package com.example.investment_api.virtual.order.controller;

import com.example.investment_api.virtual.order.controller.dto.OrderRequest;

import com.example.investment_api.virtual.order.domain.entity.Order;
import com.example.investment_api.virtual.order.domain.entity.OrderCondition;

import com.example.investment_api.virtual.order.service.OrderService;
import com.example.investment_api.virtual.order.service.OrderConditionService;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
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.RequestParam;
import org.springframework.web.bind.annotation.RestController;

import java.util.List;

@RestController
@RequestMapping("/api/orders")
public class OrderController {

    private final OrderService orderService;
    private final OrderConditionService orderConditionService;

    @Autowired
    public OrderController(OrderService orderService, OrderConditionService orderConditionService) {
        this.orderService = orderService;
        this.orderConditionService = orderConditionService;
    }

    @PostMapping
    public Order createOrder(@RequestBody OrderRequest orderRequest) {
        return orderService.placeOrder(
                orderRequest.getMemberId(),
                orderRequest.getStockName(),
                orderRequest.getQuantity(),
                orderRequest.getPrice(),
                orderRequest.getOrderType()
        );
    }

    @PostMapping("/conditions")
    public OrderCondition createOrderCondition(@RequestBody OrderRequest orderRequest) {
        return orderConditionService.setOrderCondition(
                orderRequest.getMemberId(),
                orderRequest.getStockName(),
                orderRequest.getPrice(),
                orderRequest.getQuantity(),
                orderRequest.getOrderType()
        );
    }

    @GetMapping("/conditions")
    public List<OrderCondition> getOrderConditions(@RequestParam Long memberId) {
        return orderConditionService.getOrderConditionsByMemberId(memberId);
    }

    @GetMapping("/calculate-total")
    public double calculateTotal(@RequestParam int quantity, @RequestParam int price) {
        return orderService.calculateTotalOrderAmount(quantity, price);
    }
}



package com.example.investment_api.virtual.order.domain.entity;

import jakarta.persistence.Entity;
import jakarta.persistence.GeneratedValue;
import jakarta.persistence.GenerationType;
import jakarta.persistence.Id;
import lombok.Getter;

@Entity
@Getter
public class Order {

@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;

private Long memberId;
private String stockName;
private int quantity;
private int executedPrice; // 체결된 가격
private String orderType; // "BUY" or "SELL"

public Order(Long memberId, String stockName, int quantity, int executedPrice, String orderType) {
    this.memberId = memberId;
    this.stockName = stockName;
    this.quantity = quantity;
    this.executedPrice = executedPrice;
    this.orderType = orderType;
}

public Order() {

}

}

package com.example.investment_api.virtual.order.domain.entity;

import jakarta.persistence.Entity;
import jakarta.persistence.GeneratedValue;
import jakarta.persistence.GenerationType;
import jakarta.persistence.Id;
import lombok.Getter;

@Entity
@Getter
public class OrderCondition {

@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;

private Long memberId;
private String stockName;
private int targetPrice;  // 지정가
private int quantity;
private String orderType; // "BUY" or "SELL"

public OrderCondition(Long memberId, String stockName, int targetPrice, int quantity, String orderType) {
    this.memberId = memberId;
    this.stockName = stockName;
    this.targetPrice = targetPrice;
    this.quantity = quantity;
    this.orderType = orderType;
}

public OrderCondition() {

}

}
package com.example.investment_api.virtual.order.domain.repository;

import com.example.investment_api.virtual.order.domain.entity.OrderCondition;
import org.springframework.data.jpa.repository.JpaRepository;

import java.util.List;

public interface OrderConditionRepository extends JpaRepository<OrderCondition, Long> {

List<OrderCondition> findByMemberId(Long memberId);

}
package com.example.investment_api.virtual.order.domain.repository;

import com.example.investment_api.virtual.order.domain.entity.Order;

import org.springframework.data.jpa.repository.JpaRepository;

import org.springframework.stereotype.Repository;

@Repository
public interface OrderRepository extends JpaRepository<Order, Long> {

}
package com.example.investment_api.virtual.order.service;

import com.example.investment_api.virtual.order.domain.entity.OrderCondition;
import com.example.investment_api.virtual.order.domain.repository.OrderConditionRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

@Service
public class OrderConditionService {

private final OrderConditionRepository orderConditionRepository;

@Autowired
public OrderConditionService(OrderConditionRepository orderConditionRepository) {
    this.orderConditionRepository = orderConditionRepository;
}

public OrderCondition setOrderCondition(Long memberId, String stockName, int targetPrice, int quantity, String orderType) {
    OrderCondition orderCondition = new OrderCondition(memberId, stockName, targetPrice, quantity, orderType);
    return orderConditionRepository.save(orderCondition);
}

public List<OrderCondition> getOrderConditionsByMemberId(Long memberId) {
    return orderConditionRepository.findByMemberId(memberId);
}

}
package com.example.investment_api.virtual.order.service;

import com.example.investment_api.virtual.order.domain.entity.Order;
import com.example.investment_api.virtual.order.domain.repository.OrderRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class OrderService {

private final OrderRepository orderRepository;

@Autowired
public OrderService(OrderRepository orderRepository) {
    this.orderRepository = orderRepository;
}

public Order placeOrder(Long memberId, String stockName, int quantity, int executedPrice, String orderType) {
    Order order = new Order(memberId, stockName, quantity, executedPrice, orderType);
    return orderRepository.save(order);
}

public double calculateTotalOrderAmount(int quantity, int executedPrice) {
    return quantity * executedPrice;
}

}

지정가로 매수 매도를 할 때는 영속성 컨텍스트를 이용한다 ->
지정가와 현재가가 일치할 때 까지 쓰기지연을한다.