Initial Commit

src/main/java/com/myshop/member/command/domain/PasswordChangedEvent.java

+package com.myshop.member.command.domain;
+
+public class PasswordChangedEvent {
+    private String id;
+    private String newPassword;
+
+    public PasswordChangedEvent(String id, String newPassword) {
+        this.id = id;
+        this.newPassword = newPassword;
+    }
+
+    public String getId() {
+        return id;
+    }
+
+    public String getNewPassword() {
+        return newPassword;
+    }
+}

src/main/java/com/myshop/member/infra/PasswordChangedEventHandler.java

+package com.myshop.member.infra;
+
+import com.myshop.member.command.domain.PasswordChangedEvent;
+import org.springframework.context.event.EventListener;
+import org.springframework.stereotype.Component;
+
+@Component
+public class PasswordChangedEventHandler {
+    @EventListener(PasswordChangedEvent.class)
+    public void handle(PasswordChangedEvent event) {
+        // 이메일 발송 코드
+    }
+}

src/main/java/com/myshop/member/query/MemberData.java

+package com.myshop.member.query;
+
+import javax.persistence.Column;
+import javax.persistence.Entity;
+import javax.persistence.Id;
+import javax.persistence.Table;
+
+@Entity
+@Table(name = "member")
+public class MemberData {
+    @Id
+    @Column(name = "member_id")
+    private String id;
+    @Column(name = "name")
+    private String name;
+    @Column(name = "blocked")
+    private boolean blocked;
+
+    protected MemberData() {
+    }
+
+    public MemberData(String id, String name, boolean blocked) {
+        this.id = id;
+        this.name = name;
+        this.blocked = blocked;
+    }
+
+    public String getId() {
+        return id;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public boolean isBlocked() {
+        return blocked;
+    }
+}

src/main/java/com/myshop/member/query/MemberDataDao.java

+package com.myshop.member.query;
+
+import com.myshop.common.jpa.Rangeable;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.jpa.domain.Specification;
+import org.springframework.data.repository.Repository;
+
+import java.util.List;
+import java.util.Optional;
+
+public interface MemberDataDao extends Repository<MemberData, String> {
+
+    MemberData findById(String memberId);
+
+    Page<MemberData> findByBlocked(boolean blocked, Pageable pageable);
+    List<MemberData> findByNameLike(String name, Pageable pageable);
+
+    List<MemberData> findAll(Specification<MemberData> spec, Pageable pageable);
+
+    List<MemberData> getRange(Specification<MemberData> spec, Rangeable rangeable);
+
+    List<MemberData> findFirst3ByNameLikeOrderByName(String name);
+    Optional<MemberData> findFirstByNameLikeOrderByName(String name);
+    MemberData findFirstByBlockedOrderById(boolean blocked);
+}

src/main/java/com/myshop/member/query/MemberDataSpecs.java

+package com.myshop.member.query;
+
+import org.springframework.data.jpa.domain.Specification;
+
+public class MemberDataSpecs {
+
+    public static Specification<MemberData> nonBlocked() {
+        return (root, query, cb) -> cb.equal(root.<Boolean>get("blocked"), false);
+    }
+
+    public static Specification<MemberData> nameLike(String keyword) {
+        return (root, query, cb) -> cb.like(root.<String>get("name"), keyword + "%");
+    }
+}

src/main/java/com/myshop/member/query/MemberQueryService.java

+package com.myshop.member.query;
+
+import com.myshop.member.command.application.NoMemberException;
+import org.springframework.stereotype.Service;
+
+@Service
+public class MemberQueryService {
+    private MemberDataDao memberDataDao;
+
+    public MemberQueryService(MemberDataDao memberDataDao) {
+        this.memberDataDao = memberDataDao;
+    }
+
+    public MemberData getMemberData(String memberId) {
+        MemberData memberData = memberDataDao.findById(memberId);
+        if (memberData == null) {
+            throw new NoMemberException();
+        }
+        return memberData;
+    }
+}

src/main/java/com/myshop/order/NoOrderException.java

+package com.myshop.order;
+
+public class NoOrderException extends RuntimeException {
+}

src/main/java/com/myshop/order/command/application/CancelOrderService.java

+package com.myshop.order.command.application;
+
+import com.myshop.order.NoOrderException;
+import com.myshop.order.command.domain.*;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+@Service
+public class CancelOrderService {
+    private OrderRepository orderRepository;
+    private CancelPolicy cancelPolicy;
+
+    public CancelOrderService(OrderRepository orderRepository,
+                              CancelPolicy cancelPolicy) {
+        this.orderRepository = orderRepository;
+        this.cancelPolicy = cancelPolicy;
+    }
+
+    @Transactional
+    public void cancel(OrderNo orderNo, Canceller canceller) {
+        Order order = orderRepository.findById(orderNo)
+                .orElseThrow(() -> new NoOrderException());
+        if (!cancelPolicy.hasCancellationPermission(order, canceller)) {
+            throw new NoCancellablePermission();
+        }
+        order.cancel();
+    }
+
+}

src/main/java/com/myshop/order/command/application/ChangeShippingRequest.java

+package com.myshop.order.command.application;
+
+import com.myshop.order.command.domain.ShippingInfo;
+
+public class ChangeShippingRequest {
+    private String number;
+    private ShippingInfo shippingInfo;
+
+    public ChangeShippingRequest(String number, ShippingInfo shippingInfo) {
+        this.number = number;
+        this.shippingInfo = shippingInfo;
+    }
+
+    public String getNumber() {
+        return number;
+    }
+
+    public ShippingInfo getShippingInfo() {
+        return shippingInfo;
+    }
+}

src/main/java/com/myshop/order/command/application/ChangeShippingService.java

+package com.myshop.order.command.application;
+
+import com.myshop.order.NoOrderException;
+import com.myshop.order.command.domain.Order;
+import com.myshop.order.command.domain.OrderNo;
+import com.myshop.order.command.domain.OrderRepository;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.util.Optional;
+
+@Service
+public class ChangeShippingService {
+    private OrderRepository orderRepository;
+
+    public ChangeShippingService(OrderRepository orderRepository) {
+        this.orderRepository = orderRepository;
+    }
+
+    @Transactional
+    public void changeShipping(ChangeShippingRequest changeReq) {
+        Optional<Order> orderOpt = orderRepository.findById(new OrderNo(changeReq.getNumber()));
+        Order order = orderOpt.orElseThrow(() -> new NoOrderException());
+        order.changeShippingInfo(changeReq.getShippingInfo());
+    }
+
+}

src/main/java/com/myshop/order/command/application/NoCancellablePermission.java

+package com.myshop.order.command.application;
+
+public class NoCancellablePermission extends RuntimeException {
+}

src/main/java/com/myshop/order/command/application/NoOrderProductException.java

+package com.myshop.order.command.application;
+
+public class NoOrderProductException extends RuntimeException {
+    private String productId;
+
+    public NoOrderProductException(String productId) {
+        this.productId = productId;
+    }
+
+    public String getProductId() {
+        return productId;
+    }
+}

src/main/java/com/myshop/order/command/application/OrderProduct.java

+package com.myshop.order.command.application;
+
+public class OrderProduct {
+    private String productId;
+    private int quantity;
+
+    public OrderProduct() {
+    }
+
+    public OrderProduct(String productId, int quantity) {
+        this.productId = productId;
+        this.quantity = quantity;
+    }
+
+    public String getProductId() {
+        return productId;
+    }
+
+    public int getQuantity() {
+        return quantity;
+    }
+}

src/main/java/com/myshop/order/command/application/OrderRequest.java

+package com.myshop.order.command.application;
+
+import com.myshop.member.command.domain.MemberId;
+import com.myshop.order.command.domain.ShippingInfo;
+
+import java.util.List;
+
+public class OrderRequest {
+    private List<OrderProduct> orderProducts;
+    private MemberId ordererMemberId;
+    private ShippingInfo shippingInfo;
+
+    public List<OrderProduct> getOrderProducts() {
+        return orderProducts;
+    }
+
+    public void setOrderProducts(List<OrderProduct> orderProducts) {
+        this.orderProducts = orderProducts;
+    }
+
+    public MemberId getOrdererMemberId() {
+        return ordererMemberId;
+    }
+
+    public void setOrdererMemberId(MemberId ordererMemberId) {
+        this.ordererMemberId = ordererMemberId;
+    }
+
+    public ShippingInfo getShippingInfo() {
+        return shippingInfo;
+    }
+
+    public void setShippingInfo(ShippingInfo shippingInfo) {
+        this.shippingInfo = shippingInfo;
+    }
+}

src/main/java/com/myshop/order/command/application/OrderRequestValidator.java

+package com.myshop.order.command.application;
+
+import com.myshop.common.ValidationError;
+import org.springframework.util.StringUtils;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class OrderRequestValidator {
+    public List<ValidationError> validate(OrderRequest orderRequest) {
+        List<ValidationError> errors = new ArrayList<>();
+        if (orderRequest == null) {
+            errors.add(ValidationError.of("required"));
+        } else {
+            if (orderRequest.getOrdererMemberId() == null)
+                errors.add(ValidationError.of("ordererMemberId", "required"));
+            if (orderRequest.getOrderProducts() == null)
+                errors.add(ValidationError.of("orderProducts", "required"));
+            if (orderRequest.getOrderProducts().isEmpty())
+                errors.add(ValidationError.of("orderProducts", "required"));
+
+            if (orderRequest.getShippingInfo() == null) {
+                errors.add(ValidationError.of("shippingInfo", "required"));
+            } else {
+                if (orderRequest.getShippingInfo().getReceiver() == null) {
+                    errors.add(ValidationError.of("shippingInfo.receiver", "required"));
+                } else {
+                    if (!StringUtils.hasText(orderRequest.getShippingInfo().getReceiver().getName())) {
+                        errors.add(ValidationError.of("shippingInfo.receiver.name", "required"));
+                    }
+                    if (!StringUtils.hasText(orderRequest.getShippingInfo().getReceiver().getPhone())) {
+                        errors.add(ValidationError.of("shippingInfo.receiver.phone", "required"));
+                    }
+                    if (orderRequest.getShippingInfo().getAddress() == null) {
+                        errors.add(ValidationError.of("shippingInfo.address", "required"));
+                    } else {
+                        if (!StringUtils.hasText(orderRequest.getShippingInfo().getAddress().getZipCode())) {
+                            errors.add(ValidationError.of("shippingInfo.address.zipCode", "required"));
+                        }
+                        if (!StringUtils.hasText(orderRequest.getShippingInfo().getAddress().getAddress1())) {
+                            errors.add(ValidationError.of("shippingInfo.address.address1", "required"));
+                        }
+                        if (!StringUtils.hasText(orderRequest.getShippingInfo().getAddress().getAddress2())) {
+                            errors.add(ValidationError.of("shippingInfo.address.address2", "required"));
+                        }
+                    }
+                }
+            }
+        }
+        return errors;
+    }
+}

src/main/java/com/myshop/order/command/application/PlaceOrderService.java

+package com.myshop.order.command.application;
+
+import com.myshop.catalog.command.domain.product.Product;
+import com.myshop.catalog.command.domain.product.ProductId;
+import com.myshop.catalog.command.domain.product.ProductRepository;
+import com.myshop.common.ValidationError;
+import com.myshop.common.ValidationErrorException;
+import com.myshop.order.command.domain.*;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Optional;
+
+@Service
+public class PlaceOrderService {
+    private ProductRepository productRepository;
+    private OrderRepository orderRepository;
+    private OrdererService ordererService;
+
+    public PlaceOrderService(ProductRepository productRepository,
+                             OrderRepository orderRepository,
+                             OrdererService ordererService) {
+        this.productRepository = productRepository;
+        this.orderRepository = orderRepository;
+        this.ordererService = ordererService;
+    }
+
+    @Transactional
+    public OrderNo placeOrder(OrderRequest orderRequest) {
+        List<ValidationError> errors = validateOrderRequest(orderRequest);
+        if (!errors.isEmpty()) throw new ValidationErrorException(errors);
+
+        List<OrderLine> orderLines = new ArrayList<>();
+        for (OrderProduct op : orderRequest.getOrderProducts()) {
+            Optional<Product> productOpt = productRepository.findById(new ProductId(op.getProductId()));
+            Product product = productOpt.orElseThrow(() -> new NoOrderProductException(op.getProductId()));
+            orderLines.add(new OrderLine(product.getId(), product.getPrice(), op.getQuantity()));
+        }
+        OrderNo orderNo = orderRepository.nextOrderNo();
+        Orderer orderer = ordererService.createOrderer(orderRequest.getOrdererMemberId());
+
+        Order order = new Order(orderNo, orderer, orderLines, orderRequest.getShippingInfo(), OrderState.PAYMENT_WAITING);
+        orderRepository.save(order);
+        return orderNo;
+    }
+
+    private List<ValidationError> validateOrderRequest(OrderRequest orderRequest) {
+        return new OrderRequestValidator().validate(orderRequest);
+    }
+
+}

src/main/java/com/myshop/order/command/application/RefundService.java

+package com.myshop.order.command.application;
+
+public interface RefundService {
+    void refund(String orderNumber);
+}

src/main/java/com/myshop/order/command/application/StartShippingRequest.java

+package com.myshop.order.command.application;
+
+public class StartShippingRequest {
+    private String orderNumber;
+    private long version;
+
+    protected StartShippingRequest() {
+    }
+
+    public StartShippingRequest(String orderNumber, long version) {
+        this.orderNumber = orderNumber;
+        this.version = version;
+    }
+
+    public String getOrderNumber() {
+        return orderNumber;
+    }
+
+    public long getVersion() {
+        return version;
+    }
+}

src/main/java/com/myshop/order/command/application/StartShippingService.java

+package com.myshop.order.command.application;
+
+import com.myshop.common.VersionConflictException;
+import com.myshop.order.NoOrderException;
+import com.myshop.order.command.domain.Order;
+import com.myshop.order.command.domain.OrderNo;
+import com.myshop.order.command.domain.OrderRepository;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.util.Optional;
+
+@Service
+public class StartShippingService {
+    private OrderRepository orderRepository;
+
+    public StartShippingService(OrderRepository orderRepository) {
+        this.orderRepository = orderRepository;
+    }
+
+    @Transactional
+    public void startShipping(StartShippingRequest req) {
+        Optional<Order> orderOpt = orderRepository.findById(new OrderNo(req.getOrderNumber()));
+        Order order = orderOpt.orElseThrow(() -> new NoOrderException());
+        if (order.matchVersion(req.getVersion())) {
+            throw new VersionConflictException();
+        }
+        order.startShipping();
+    }
+}

src/main/java/com/myshop/order/command/domain/AlreadyShippedException.java

+package com.myshop.order.command.domain;
+
+public class AlreadyShippedException extends RuntimeException {
+}