How to use jace.shim.springcamp2017.order.model.event

/**
 * 주문 이벤트 반영
 * @param orderCreated
 */
public void apply(OrderCreated orderCreated) {
  this.orderId = orderCreated.getOrderId();
  this.orderMember = orderCreated.getOrderMember();
  this.delivery = orderCreated.getDelivery();
  this.orderItems = orderCreated.getOrderItems();
}

@Override
public OrderRawEvent mapRow(ResultSet rs, int rowNum) throws SQLException {
  final OrderRawEvent commonRawEvent = new OrderRawEvent();
  commonRawEvent.setSeq(rs.getLong("seq"));
  commonRawEvent.setIdentifier(rs.getLong("identifier"));
  commonRawEvent.setType(rs.getString("type"));
  commonRawEvent.setVersion(rs.getLong("version"));
  commonRawEvent.setPayload(rs.getString("payload"));
  final Timestamp created = rs.getTimestamp("created");
  commonRawEvent.setCreated(convertTimestampToLocalDateTime(created));
  return commonRawEvent;
}

private List<Event<Long>> convertEvent(List<OrderRawEvent> rawEvents) {
  return rawEvents.stream().map(rawEvent -> {
    Event<Long> event = null;
    try {
      event = (Event) objectMapper.readValue(rawEvent.getPayload(), Class.forName(rawEvent.getType()));
    } catch (IOException | ClassNotFoundException e) {
      String exceptionMessage = String.format("Event Object Convert Error : {} {}", rawEvent.getSeq(), rawEvent.getType(),
        rawEvent.getPayload());
      log.error(exceptionMessage, e);
    }
    return event;
  }).collect(Collectors.toList());
}

public long save(OrderRawEvent commonRawEvent) {
  StringBuilder query = new StringBuilder();
  query.append(format("INSERT INTO %s ", TABLE_NAME));
  query.append(" ( identifier, type, version, payload, created ) ");
  query.append(" VALUES ( ?, ?, ?, ?, ? ) ");
  KeyHolder keyHolder = new GeneratedKeyHolder();
  jdbcTemplate.update(connection -> {
    PreparedStatement statement = connection.prepareStatement(query.toString(), Statement.RETURN_GENERATED_KEYS);
    int idx = 0;
    statement.setLong(++idx, commonRawEvent.getIdentifier());
    statement.setString(++idx, commonRawEvent.getType());
    statement.setLong(++idx, commonRawEvent.getVersion());
    statement.setString(++idx, commonRawEvent.getPayload());
    statement.setTimestamp(++idx, convertLocalDateTimeToTimestamp(commonRawEvent.getCreated()));
    return statement;
  }, keyHolder);
  return keyHolder.getKey().longValue();
}

@org.springframework.kafka.annotation.KafkaListener(id = "product-consumer-group", topics = "product-event-topic")
public void productEventListener(String message) {
  log.debug("receive message : {}", message);
  try {
    OrderRawEvent rawEvent = objectMapper.readValue(message, OrderRawEvent.class);
    final Class<?> eventType = Class.forName(rawEvent.getType());
    final Event event = (Event) objectMapper.readValue(rawEvent.getPayload(), eventType);
    // this.handle(event);
    eventProjector.handle(event);
  } catch (Exception e) {
    log.warn(e.getMessage(), e);
  }
}

  /**
   * 주문 이벤트 처리 - 상품재고 차감
   *
   * @param event
   */
  public void execute(OrderCreated event) {
    // todo 상품재고 수량 차감 이벤트를 발생 시켜야 하는데.
    final Set<OrderItem> orderItems = event.getOrderItems();
    for (OrderItem orderItem : orderItems) {
      ProductCommand.DecreaseQuantity productDecreaseQuantityCommand = new ProductCommand.DecreaseQuantity(orderItem.getQuantity());
      productService.decreaseQuantity(orderItem.getProduct().getProductId(), productDecreaseQuantityCommand);
    }
  }
}

Order(Long orderId, Member orderMember, Delivery delivery, List<OrderItem> checkoutItems) {
  super(orderId);
  this.orderId = orderId;
  this.orderMember = orderMember;
  this.delivery = delivery;
  this.created = LocalDateTime.now();
  for (OrderItem orderItem : checkoutItems) {
    this.with(orderItem);
  }
  applyChange(new OrderCreated(orderId, orderMember, delivery, orderItems, created));
}

OrderRawEvent rawEvent = new OrderRawEvent(identifier, type, expectedVersion, payload, now);

  event.getOrderId(),
  convertLocalDateTimeToTimestamp(event.getCreated()));
  event.getOrderId(),
  event.getOrderMember().getId());
  event.getOrderId(),
  event.getDelivery().getAddress(),
  event.getDelivery().getPhone(),
  event.getDelivery().getDeliveryMessage());
query.append(" ?, ?, ?, ?) ");
final Set<OrderItem> orderItems = event.getOrderItems();
for (OrderItem orderItem : orderItems) {
  jdbcTemplate.update(query.toString(),
    event.getOrderId(),
    orderItem.getProduct().getProductId(),
    orderItem.getProduct().getPrice(),

  @org.springframework.kafka.annotation.KafkaListener(id = "order-consumer-group", topics = "order-event-topic")
  public void orderEventListener(String message) {
    log.debug("receive message from order : {}", message);

    try {
      OrderRawEvent rawEvent = objectMapper.readValue(message, OrderRawEvent.class);
      final Class<?> eventType = Class.forName(rawEvent.getType());
      final Event event = (Event) objectMapper.readValue(rawEvent.getPayload(), eventType);

      //this.handle(event);

      eventProjector.handle(event);

    } catch (IOException | ClassNotFoundException e) {
      log.warn(e.getMessage(), e);
    }
  }
}

  event.getOrderId(),
  convertLocalDateTimeToTimestamp(event.getCreated()));
  event.getOrderId(),
  event.getOrderMember().getId());
  event.getOrderId(),
  event.getDelivery().getAddress(),
  event.getDelivery().getPhone(),
  event.getDelivery().getDeliveryMessage());
query.append(" ?, ?, ?, ?) ");
final Set<OrderItem> orderItems = event.getOrderItems();
for (OrderItem orderItem : orderItems) {
  jdbcTemplate.update(query.toString(),
    event.getOrderId(),
    orderItem.getProduct().getProductId(),
    orderItem.getProduct().getPrice(),