KORAIL_STORE

package com.stoneitgt.user.controller;

import com.fasterxml.jackson.databind.ObjectMapper;

import com.stoneitgt.common.Paging;

import com.stoneitgt.data.OrderType;

import com.stoneitgt.data.UseFlag;

import com.stoneitgt.domain.*;

import com.stoneitgt.domain.vo.*;

import com.stoneitgt.user.domain.CommonResponse;

import com.stoneitgt.user.domain.PaginationResponse;

import com.stoneitgt.user.domain.common.DormantReleaseForm;

import com.stoneitgt.user.domain.delivery.IdListForm;

import com.stoneitgt.user.domain.delivery.DeliveryRequestForm;

import com.stoneitgt.user.domain.delivery.UserDeliveryResponse;

import com.stoneitgt.user.domain.order.*;

import com.stoneitgt.user.services.*;

import com.stoneitgt.user.services.auth.UserService;

import com.stoneitgt.user.util.DateUtils;

import com.stoneitgt.user.util.DateValidator;

import com.stoneitgt.user.util.RequestUtils;

import io.swagger.annotations.ApiOperation;

import lombok.extern.slf4j.Slf4j;

import org.apache.commons.lang3.StringUtils;

import org.joda.time.DateTime;

import org.json.simple.parser.JSONParser;

import org.json.simple.JSONObject;

import org.json.simple.parser.ParseException;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.beans.factory.annotation.Value;

import org.springframework.http.ResponseEntity;

import org.springframework.stereotype.Controller;

import org.springframework.web.bind.annotation.*;

import javax.transaction.Transactional;

import java.io.*;

import java.net.HttpURLConnection;

import java.net.ProtocolException;

import java.net.URL;

import java.net.URLEncoder;

import java.nio.charset.StandardCharsets;

import java.util.*;

@Controller

@RequestMapping("/api")

@Slf4j

public class OrderController extends BaseController {

  @Value("${system.delivery.amount}")

  private Integer systemDeliveryAmount;

  @Autowired

  private UserService userService;

  @Autowired

  private UserDeliveryService userDeliveryService;

  @Autowired

  private OrderService orderService;

  @Autowired

  private OrderProductService orderProductService;

  @Autowired

  private MallService mallService;

  @Autowired

  private ProductService productService;

  @Autowired

  private MallDeliveryService mallDeliveryService;

  @GetMapping(value = "/default_delivery")

  @ApiOperation(value = "기본 배송지 정보")

  public ResponseEntity<UserDeliveryResponse.UserDelivery> defaultDelivery(DormantReleaseForm form) {

    try {

      if (StringUtils.isEmpty(form.getId())) {

        return requiredFieldBadRequest("id");

      }

      UserVO searchUser = userService.findByUserId(form.getId());

      if (searchUser != null) {

        UserDeliveryResponse.UserDelivery data = new UserDeliveryResponse.UserDelivery();

        UserDeliveryVO delivery = userDeliveryService.getUserDefaultDelivery(searchUser.getUserSeq());

        if (delivery != null) {

          data.setDeliveryCode(delivery.getDeliveryCode());

          data.setReceiverName(delivery.getReceiverName());

          data.setReceiverPhone(delivery.getReceiverPhone());

          data.setZipcode(delivery.getZipcode());

          data.setAddress(delivery.getAddress());

          data.setSubAddress(delivery.getSubAddress());

        } else {

          data.setDeliveryCode(null);

          data.setReceiverName(searchUser.getUsername());

          data.setZipcode(searchUser.getHp());

          data.setZipcode(searchUser.getZipcode());

          data.setAddress(searchUser.getAddress());

          data.setSubAddress(searchUser.getSubAddress());

        }

        return ResponseEntity.ok(data);

      } else {

        return badRequest("common.error.idNotExist", "id");

      }

    } catch (Exception e) {

      log.error(e.getMessage(), e);

      return internalServerError();

    }

  }

  @RequestMapping(value = "/delivery_list", method = RequestMethod.GET)

  @ResponseBody

  @ApiOperation(value = "배송지 리스트")

  public ResponseEntity<PaginationResponse<UserDeliveryResponse.UserDelivery>> deliveryList(IdListForm form) {

    try {

      if (StringUtils.isEmpty(form.getId())) {

        return requiredFieldBadRequest("id");

      }

      UserVO searchUser = userService.findByUserId(form.getId());

      if (searchUser != null) {

        Paging paging = new Paging();

        paging.setPage(form.getPage_no());

        paging.setSize(form.getPage_size());

        paging.putWithNotEmpty("userSeq", searchUser.getUserSeq());

        List<UserDeliveryVO> list = userDeliveryService.selectPagination(paging);

        int totalCount = userDeliveryService.countPagination(paging);

        if (list != null && !list.isEmpty()) {

          List<UserDeliveryResponse.UserDelivery> deliveries = new ArrayList<>();

          for (UserDeliveryVO delivery : list) {

            UserDeliveryResponse.UserDelivery data = new UserDeliveryResponse.UserDelivery();

            data.setDeliveryCode(delivery.getDeliveryCode());

            data.setReceiverName(delivery.getReceiverName());

            data.setReceiverPhone(delivery.getReceiverPhone());

            data.setZipcode(delivery.getZipcode());

            data.setAddress(delivery.getAddress());

            data.setSubAddress(delivery.getSubAddress());

            data.setDefaultYn(UseFlag.Y.equals(delivery.getDefaultYn()) ? "Y" : "N");

            deliveries.add(data);

          }

          PaginationResponse<UserDeliveryResponse.UserDelivery> paginationResponse =

              new PaginationResponse<>(paging, deliveries, totalCount);

          return ResponseEntity.ok(paginationResponse);

        } else {

          return dataNotFound();

        }

      } else {

        return badRequest("common.error.idNotExist", "id");

      }

    } catch (Exception e) {

      log.error(e.getMessage(), e);

      return internalServerError();

    }

  }

  @PostMapping(value = "/delivery")

  @ApiOperation(value = "배송지 추가")

  @Transactional

  public ResponseEntity<CommonResponse> addDelivery(@RequestBody DeliveryRequestForm.DeliveryAddForm deliveryAddForm) {

    try {

      if (StringUtils.isEmpty(deliveryAddForm.getId())) {

        return requiredFieldBadRequest("id");

      }

      if (StringUtils.isEmpty(deliveryAddForm.getReceiver_name())) {

        return requiredFieldBadRequest("receiver_name");

      }

      if (StringUtils.isEmpty(deliveryAddForm.getReceiver_phone())) {

        return requiredFieldBadRequest("receiver_phone");

      }

      if (StringUtils.isEmpty(deliveryAddForm.getZipcode())) {

        return requiredFieldBadRequest("zipcode");

      }

      if (StringUtils.isEmpty(deliveryAddForm.getAddress())) {

        return requiredFieldBadRequest("address");

      }

      if (StringUtils.isEmpty(deliveryAddForm.getDefault_yn())) {

        return requiredFieldBadRequest("default_yn");

      }

      if (!StringUtils.equalsAny(deliveryAddForm.getDefault_yn(), "Y", "N")) {

        return inputFieldBadRequest("default_yn", "Y/N");

      }

      User searchUser = userService.findByUserId(deliveryAddForm.getId());

      if (searchUser != null) {

        UserDelivery record = new UserDelivery();

        record.setDeliveryCode(UUID.randomUUID().toString());

        record.setReceiverName(deliveryAddForm.getReceiver_name());

        record.setReceiverPhone(deliveryAddForm.getReceiver_phone());

        record.setZipcode(deliveryAddForm.getZipcode());

        record.setAddress(deliveryAddForm.getAddress());

        record.setSubAddress(deliveryAddForm.getSub_address());

        if ("Y".equals(deliveryAddForm.getDefault_yn())) {

          record.setDefaultYn(UseFlag.Y);

          userDeliveryService.releaseDefault(searchUser.getUserSeq());

        } else {

          record.setDefaultYn(UseFlag.N);

        }

        record.setUserSeq(searchUser.getUserSeq());

        record.setRegUserSeq(searchUser.getUserSeq());

        userDeliveryService.insert(record);

        return ResponseEntity.ok(CommonResponse.ok());

      } else {

        return badRequest("common.error.idNotExist", "id");

      }

    } catch (Exception e) {

      log.error(e.getMessage(), e);

      return internalServerError();

    }

  }

  @PutMapping(value = "/delivery")

  @ApiOperation(value = "배송지 변경")

  @Transactional

  public ResponseEntity<CommonResponse> updateDelivery(@RequestBody DeliveryRequestForm.DeliveryUpdateForm deliveryUpdateForm) {

    try {

      if (StringUtils.isEmpty(deliveryUpdateForm.getDelivery_code())) {

        return requiredFieldBadRequest("delivery_code");

      }

      if (StringUtils.isEmpty(deliveryUpdateForm.getReceiver_name())) {

        return requiredFieldBadRequest("receiver_name");

      }

      if (StringUtils.isEmpty(deliveryUpdateForm.getReceiver_phone())) {

        return requiredFieldBadRequest("receiver_phone");

      }

      if (StringUtils.isEmpty(deliveryUpdateForm.getZipcode())) {

        return requiredFieldBadRequest("zipcode");

      }

      if (StringUtils.isEmpty(deliveryUpdateForm.getAddress())) {

        return requiredFieldBadRequest("address");

      }

      if (StringUtils.isEmpty(deliveryUpdateForm.getDefault_yn())) {

        return requiredFieldBadRequest("default_yn");

      }

      if (!StringUtils.equalsAny(deliveryUpdateForm.getDefault_yn(), "Y", "N")) {

        return inputFieldBadRequest("default_yn", "Y/N");

      }

      UserDeliveryVO delivery = userDeliveryService.getByPK(deliveryUpdateForm.getDelivery_code());

      if (delivery != null) {

        UserDelivery record = new UserDelivery();

        record.setDeliveryCode(delivery.getDeliveryCode());

        record.setReceiverName(deliveryUpdateForm.getReceiver_name());

        record.setReceiverPhone(deliveryUpdateForm.getReceiver_phone());

        record.setZipcode(deliveryUpdateForm.getZipcode());

        record.setAddress(deliveryUpdateForm.getAddress());

        record.setSubAddress(deliveryUpdateForm.getSub_address());

        if ("Y".equals(deliveryUpdateForm.getDefault_yn())) {

          record.setDefaultYn(UseFlag.Y);

          userDeliveryService.releaseDefault(delivery.getUserSeq());

        } else {

          record.setDefaultYn(UseFlag.N);

        }

        userDeliveryService.update(record);

        return ResponseEntity.ok(CommonResponse.ok());

      } else {

        return dataNotFound();

      }

    } catch (Exception e) {

      log.error(e.getMessage(), e);

      return internalServerError();

    }

  }

  @DeleteMapping(value = "/delivery")

  @ApiOperation(value = "배송지 삭제")

  @Transactional

  public ResponseEntity<CommonResponse> updateDelivery(DeliveryRequestForm.DeliveryDeleteForm deliveryDeleteForm) {

    try {

      if (StringUtils.isEmpty(deliveryDeleteForm.getDelivery_code())) {

        return requiredFieldBadRequest("delivery_code");

      }

      UserDeliveryVO delivery = userDeliveryService.getByPK(deliveryDeleteForm.getDelivery_code());

      if (delivery != null) {

        userDeliveryService.delete(delivery.getDeliveryCode());

        return ok();

      } else {

        return dataNotFound();

      }

    } catch (Exception e) {

      log.error(e.getMessage(), e);

      return internalServerError();

    }

  }

  @PostMapping(value = "/store_order_cancel")

  @ApiOperation(value = "스마트오더 주문 취소")

  @Transactional

  public ResponseEntity<CommonResponse> storeOrderCancel(@RequestBody StoreOrderCancelForm storeOrderCancelForm) {

    try {

      if (StringUtils.isEmpty(storeOrderCancelForm.getId())) {

        return requiredFieldBadRequest("id");

      }

      if (StringUtils.isEmpty(storeOrderCancelForm.getOrder_no())) {

        return requiredFieldBadRequest("order_no");

      }

      if (StringUtils.isEmpty(storeOrderCancelForm.getCancel_reason_type())) {

        return requiredFieldBadRequest("cancel_reason_type");

      }

      OrderVO order = orderService.getByPK(storeOrderCancelForm.getOrder_no());

      if(order == null){

        return dataNotFound();

      }

      if(!"SS01".equals(order.getSmartOrderStatus())){

        return badRequest("smartOrder.error.notAllowCancel");

      }

      User searchUser = userService.findByUserId(storeOrderCancelForm.getId());

      if (searchUser != null) {

        OrderVO record = new OrderVO();

        record.setOrderNo(order.getOrderNo());

        record.setSmartOrderStatus("SS05");

        record.setCancelReasonType(storeOrderCancelForm.getCancel_reason_type());

        record.setModUserSeq(searchUser.getUserSeq());

        orderService.update(record);

        return ok();

      } else {

        return dataNotFound("common.error.idNotExist", "id");

      }

    } catch (Exception e) {

      log.error(e.getMessage(), e);

      return internalServerError();

    }

  }

  @PostMapping(value = "/online_order")

  @ApiOperation(value = "온라인몰 주문")

  public ResponseEntity<CommonResponse> onlineOrder(@RequestBody OrderRequestForm.OrderOnlineForm orderOnlineForm) {

    try {

      ResponseEntity<CommonResponse> error = validateOnlineOrderForm(orderOnlineForm);

      if (error != null) {

        return error;

      }

      List<OrderProduct> orderProducts = getOrderProductList(orderOnlineForm.getOrder_products());

      OrderPayment orderPayment = getOrderPayment(orderOnlineForm.getPayment_info());

      User searchUser = userService.findByUserId(orderOnlineForm.getId());

      if (searchUser != null) {

        OrderVO orderForm = getOnlineOrderForm(orderOnlineForm, searchUser);

        orderService.addOrder(orderForm, orderProducts, orderPayment);

        return ok();

      } else {

        return badRequest("common.error.idNotExist", "id");

      }

    } catch (Exception e) {

      log.error(e.getMessage(), e);

      return internalServerError();

    }

  }

  @PostMapping(value = "/store_order")

  @ApiOperation(value = "스마트오더 주문 ")

  public ResponseEntity<CommonResponse> storeOrder(@RequestBody OrderRequestForm.OrderStoreForm orderStoreForm) {

    try {

      ResponseEntity<CommonResponse> error = validateStoreOrderForm(orderStoreForm);

      if (error != null) {

        return error;

      }

      List<OrderProduct> orderProducts = getOrderProductList(orderStoreForm.getOrder_products());

      OrderPayment orderPayment = getOrderPayment(orderStoreForm.getPayment_info());

      User searchUser = userService.findByUserId(orderStoreForm.getId());

      if (searchUser != null) {

        OrderVO orderForm = getStoreOrderForm(orderStoreForm, searchUser);

        orderService.addOrder(orderForm, orderProducts, orderPayment);

        return ok();

      } else {

        return badRequest("common.error.idNotExist", "id");

      }

    } catch (Exception e) {

      log.error(e.getMessage(), e);

      return internalServerError();

    }

  }

  @PostMapping(value = "/pay_confirm")

  @ApiOperation(value = "스마트오더 주문 ")

  public ResponseEntity<JSONObject> payment(@RequestBody PaymentRequest paymentRequest) throws IOException, ParseException {

    // 서버상 관리되어야 하는 결제 secret 키, 노출 시 심각한 보안 위험 및 injection을 통한 위변조 결제가 가능하므로 해당 결제키를 서버 side에서 관리하여 front에 노출되지 않도록 관리 필요.

    String secretKey = "test_sk_zXLkKEypNArWmo50nX3lmeaxYG5R:";

    String orderId = paymentRequest.getOrderId();

    // orderId로 DB상 주문 정보 조회 및 품절 상태, 총 결제 금액 등 확인 로직 추가

    long amount = paymentRequest.getAmount();

    // amount와 DB상 해당 주문건의 총 결제 금액 비교하여 결제 프로세스 상 금액 위변조 여부 확인 로직 추가

    Base64.Encoder encoder = Base64.getEncoder();

    byte[] encodedBytes = encoder.encode(secretKey.getBytes(StandardCharsets.UTF_8));

    String authorizations = "Basic "+ new String(encodedBytes);

    paymentRequest.setPaymentKey(URLEncoder.encode(paymentRequest.getPaymentKey(), String.valueOf(StandardCharsets.UTF_8)));

    URL url = new URL("https://api.tosspayments.com/v1/payments/confirm");

    HttpURLConnection connection = (HttpURLConnection) url.openConnection();

    connection.setRequestProperty("Authorization", authorizations);

    connection.setRequestProperty("Content-Type", "application/json");

    connection.setRequestMethod("POST");

    connection.setDoOutput(true);

    OutputStream outputStream = connection.getOutputStream();

    ObjectMapper mapper = new ObjectMapper();

    outputStream.write(mapper.writeValueAsString(paymentRequest).getBytes(StandardCharsets.UTF_8));

    int code = connection.getResponseCode();

    boolean isSuccess = code == 200 ? true : false;

    InputStream responseStream = isSuccess? connection.getInputStream(): connection.getErrorStream();

    Reader reader = new InputStreamReader(responseStream, StandardCharsets.UTF_8);

    JSONParser parser = new JSONParser();

    JSONObject jsonObject = (JSONObject) parser.parse(reader);

    responseStream.close();

    // jsonObject 내용 안의 최종 결제 정보를 확인하여 정상 결제인경우 주문 정보 DB 업데이트. (결제 정보 및 수단, 금액 및 현금영수증 정보 등의 내용을 DB에 작성)

    // order_no 및 최종 결제 상태 리턴.

    return ResponseEntity.ok(jsonObject);

  }

  @RequestMapping(value = "/order_list", method = RequestMethod.GET)

  @ResponseBody

  @ApiOperation(value = "주문 리스트")

  public ResponseEntity<PaginationResponse<OrderResponse>> orderList(OrderListForm form) {

    try {

      if (StringUtils.isEmpty(form.getMall_type())) {

        return requiredFieldBadRequest("mall_type");

      }

      if (StringUtils.isEmpty(form.getId())) {

        return requiredFieldBadRequest("id");

      }

      if (!StringUtils.equalsAny(form.getMall_type(), "online", "store")) {

        return inputFieldBadRequest("mall_type", "online/store");

      }

      if(StringUtils.isNotEmpty(form.getStart_date())){

        DateValidator dateValidator2 = new DateValidator("yyyyMMdd");

        if(!dateValidator2.isValid(form.getStart_date())){

          return inputFieldBadRequest("start_date", form.getStart_date());

        }

      }

      if(StringUtils.isNotEmpty(form.getEnd_date())){

        DateValidator dateValidator2 = new DateValidator("yyyyMMdd");

        if(!dateValidator2.isValid(form.getEnd_date())){

          return inputFieldBadRequest("end_date", form.getEnd_date());

        }

      }

      UserVO searchUser = userService.findByUserId(form.getId());

      if (searchUser != null) {

        Paging paging = new Paging();

        paging.setPage(form.getPage_no());

        paging.setSize(form.getPage_size());

        paging.putParam("userSeq", searchUser.getUserSeq());

        paging.putParam("mallType", form.getMall_type());

        paging.putWithNotEmpty("startDate", form.getStart_date());

        paging.putWithNotEmpty("endDate", form.getEnd_date());

        List<OrderVO> list = orderService.selectPagination(paging);

        int totalCount = orderService.countPagination(paging);

        if (list != null && !list.isEmpty()) {

          List<OrderResponse> orderResponseList = new ArrayList<>();

          for (OrderVO order : list) {

            OrderResponse data = new OrderResponse();

            data.setMallCode(order.getMallCode());

            data.setMallName(order.getMallName());

            data.setOrderNo(order.getOrderNo());

            data.setOrderAmount(order.getOrderAmount());

            data.setPaymentAmount(order.getPaymentAmount());

            if ("online".equals(order.getMallType())) {

              data.setOrderStatus(order.getOrderStatus());

              data.setOrderStatusName(order.getOrderStatusName());

            } else {

              data.setOrderStatus(order.getSmartOrderStatus());

              data.setOrderStatusName(order.getSmartOrderStatusName());

            }

            data.setRegDate(DateUtils.toApiDate(order.getRegDate()));

            data.setOrderReviewYn(order.getOrderReviewYn());

            List<OrderProductResponse> orderProductResponses = new ArrayList<>();

            List<OrderProductVO> orderProducts = orderProductService.getByOrderNo(order.getOrderNo());

            for (OrderProductVO orderProduct : orderProducts) {

              OrderProductResponse orderProductResponse = new OrderProductResponse();

              orderProductResponse.setProductCode(orderProduct.getProductCode());

              orderProductResponse.setProductName(orderProduct.getProductName());

              orderProductResponse.setSalePrice(orderProduct.getSalePrice());

              orderProductResponse.setOrderCount(orderProduct.getOrderCount());

              orderProductResponse.setProductAmount(orderProduct.getProductAmount());

              orderProductResponse.setProductReviewYn(orderProduct.getProductReviewYn());

              orderProductResponse.setImageUrl(getImageUrl(orderProduct.getImageFile()));

              orderProductResponses.add(orderProductResponse);

            }

            data.setProducts(orderProductResponses);

            orderResponseList.add(data);

          }

          PaginationResponse<OrderResponse> paginationResponse =

              new PaginationResponse<>(paging, orderResponseList, totalCount);

          return ResponseEntity.ok(paginationResponse);

        } else {

          return dataNotFound();

        }

      } else {

        return badRequest("common.error.idNotExist", "id");

      }

    } catch (Exception e) {

      log.error(e.getMessage(), e);

      return internalServerError();

    }

  }

  @PostMapping(value = "/online_claim")

  @ApiOperation(value = "온라인몰 클레임 신청")

  public ResponseEntity<CommonResponse> claim(@RequestBody OrderRequestForm.ClaimAddForm claimAddForm) {

    try {

      if (StringUtils.isEmpty(claimAddForm.getId())) {

        return requiredFieldBadRequest("id");

      }

      if (StringUtils.isEmpty(claimAddForm.getOrder_no())) {

        return requiredFieldBadRequest("order_no");

      }

      if (StringUtils.isEmpty(claimAddForm.getClaim_type())) {

        return requiredFieldBadRequest("claim_type");

      }

      if (!StringUtils.equalsAny(claimAddForm.getClaim_type(), "10", "20", "30")) {

        return inputFieldBadRequest("claim_type", "10/20/30");

      }

      if (StringUtils.isEmpty(claimAddForm.getClaim_reason_type())) {

        return requiredFieldBadRequest("claim_reason_type");

      }

      UserVO user = userService.findByUserId(claimAddForm.getId());

      if (user == null) {

        return badRequest("common.error.idNotExist", "id");

      }

      OrderVO order = orderService.getByPK(claimAddForm.getOrder_no());

      if (order == null) {

        return dataNotFound();

      }

      Order record = new Order();

      record.setOrderNo(claimAddForm.getOrder_no());

      record.setClaimReasonType(claimAddForm.getClaim_reason_type());

      record.setClaimStatus("CS" + claimAddForm.getClaim_type());

      record.setClaimDesc(claimAddForm.getClaim_desc());

      record.setCollectorName(claimAddForm.getCollector_name());

      record.setCollectorPhone(claimAddForm.getCollector_phone());

      record.setCollectZipcode(claimAddForm.getCollect_zipcode());

      record.setCollectAddress(claimAddForm.getCollect_address());

      record.setCollectSubAddress(claimAddForm.getCollect_sub_address());

      record.setRedeliveryReceiverName(claimAddForm.getRedelivery_receiver_name());

      record.setRedeliveryReceiverPhone(claimAddForm.getRedelivery_receiver_phone());

      record.setRedeliveryZipcode(claimAddForm.getRedelivery_zipcode());

      record.setRedeliveryAddress(claimAddForm.getRedelivery_address());

      record.setRedeliverySubAddress(claimAddForm.getRedelivery_sub_address());

      record.setModUserSeq(user.getUserSeq());

      orderService.update(record);

      return ok();

    } catch (Exception e) {

      log.error(e.getMessage(), e);

      return internalServerError();

    }

  }

  @GetMapping(value = "/order")

  @ApiOperation(value = "주문 정보")

  public ResponseEntity<OrderInfoResponse> orderInfo(OrderRequestForm.GetInfoForm form) {

    if (StringUtils.isEmpty(form.getOrder_no())) {

      return requiredFieldBadRequest("order_no");

    }

    OrderVO order = orderService.getByPK(form.getOrder_no());

    if (order != null) {

      OrderDetailResponse response = new OrderDetailResponse();

      response.setStatus(200);

      response.setMallCode(order.getMallCode());

      response.setMallName(order.getMallName());

      response.setOrderNo(order.getOrderNo());

      response.setOrderAmount(order.getOrderAmount());

      response.setDeliveryAmount(order.getDeliveryAmount());

      response.setUsePoint(order.getUsePoint());

      response.setUseMoney(order.getUseMoney());

      response.setCouponCode(order.getCouponCode());

      response.setCouponAmount(order.getCouponAmount());

      response.setReceiveHopeTime(order.getReceiveHopeTime());

      response.setReceiveTime(order.getReceiveTime());

      response.setPaymentAmount(order.getPaymentAmount());

      response.setPaymentMethod(order.getPaymentMethod());

      response.setPaymentMethodName(order.getPaymentMethodName());

      if ("online".equals(order.getMallType())) {

        response.setOrderStatus(order.getOrderStatus());

        response.setOrderStatusName(order.getOrderStatusName());

      } else {

        response.setOrderStatus(order.getSmartOrderStatus());

        response.setOrderStatusName(order.getSmartOrderStatusName());

      }

      response.setDeliveryInvoiceNo(order.getDeliveryInvoiceNo());

      response.setRegDate(DateUtils.toApiDate(order.getRegDate()));

      response.setClaimStatus(order.getClaimStatus());

      response.setClaimStatusName(order.getClaimStatusName());

      List<OrderProductResponse> orderProductResponses = new ArrayList<>();

      List<OrderProductVO> orderProducts = orderProductService.getByOrderNo(order.getOrderNo());

      for (OrderProductVO orderProduct : orderProducts) {

        OrderProductResponse orderProductResponse = new OrderProductResponse();

        orderProductResponse.setProductCode(orderProduct.getProductCode());

        orderProductResponse.setProductName(orderProduct.getProductName());

        orderProductResponse.setSalePrice(orderProduct.getSalePrice());

        orderProductResponse.setOrderCount(orderProduct.getOrderCount());

        orderProductResponse.setProductAmount(orderProduct.getProductAmount());

        orderProductResponse.setImageUrl(getImageUrl(orderProduct.getImageFile()));

        orderProductResponses.add(orderProductResponse);

      }

      response.setProducts(orderProductResponses);

      return ResponseEntity.ok(response);

    } else {

      return dataNotFound();

    }

  }

  @GetMapping(value = "/delivery_amount")

  @ApiOperation(value = "배송비 산정")

  public ResponseEntity<DeliveryAmountResponse> deliveryAmount(OrderRequestForm.DeliveryAmountForm form) {

    if (StringUtils.isEmpty(form.getMall_code())) {

      return requiredFieldBadRequest("mall_code");

    }

    if (StringUtils.isEmpty(form.getOrder_amount())) {

      return requiredFieldBadRequest("order_amount");

    }

    if (!StringUtils.isNumeric(form.getOrder_amount())) {

      return inputFieldBadRequest("order_amount", form.getOrder_amount());

    }

    if (StringUtils.isEmpty(form.getPayment_amount())) {

      return requiredFieldBadRequest("payment_amount");

    }

    if (!StringUtils.isNumeric(form.getPayment_amount())) {

      return inputFieldBadRequest("payment_amount", form.getPayment_amount());

    }

    MallVO mall = mallService.getByPK(form.getMall_code());

    if (mall != null) {

      List<MallDeliveryVO> mallDeliveryList = mallDeliveryService.getListByMallCode(mall.getMallCode());

      MallDeliveryVO mallDelivery = mallDeliveryList.stream().filter(obj -> {

        Integer amount = 0;

        if (UseFlag.N.equals(mall.getDeliveryDiscountPriceYn())) {

          amount = Integer.parseInt(form.getOrder_amount());

        } else {

          amount = Integer.parseInt(form.getPayment_amount());

        }

        Integer startAmount = obj.getStartAmount() == null ? 0 : obj.getStartAmount();

        Integer endAmount = obj.getEndAmount();

        if (startAmount < amount) {

          if (endAmount == null || amount < endAmount) {

            return true;

          }

        }

        return false;

      }).findFirst()

          .orElse(null);

      DeliveryAmountResponse response = new DeliveryAmountResponse();

      if (mallDelivery != null) {

        response.setDeliveryAmount(mallDelivery.getDeliveyAmount());

      } else {

        response.setDeliveryAmount(systemDeliveryAmount);

      }

      return ResponseEntity.ok(response);

    } else {

      return dataNotFound();

    }

  }

  private ResponseEntity<CommonResponse> validateOnlineOrderForm(OrderRequestForm.OrderOnlineForm form) {

    if (StringUtils.isEmpty(form.getId())) {

      return requiredFieldBadRequest("id");

    }

    if (StringUtils.isEmpty(form.getMall_code())) {

      return requiredFieldBadRequest("mall_code");

    }

    MallVO mall = mallService.getByPK(form.getMall_code());

    if (mall == null) {

      return inputFieldBadRequest("mall_code", form.getMall_code());

    }

    if (StringUtils.isEmpty(form.getOrder_amount())) {

      return requiredFieldBadRequest("order_amount");

    }

    if (!StringUtils.isNumeric(form.getOrder_amount())) {

      return inputFieldBadRequest("order_amount", form.getOrder_amount());

    }

    if (StringUtils.isEmpty(form.getDelivery_amount())) {

      return requiredFieldBadRequest("delivery_amount");

    }

    if (!StringUtils.isNumeric(form.getDelivery_amount())) {

      return inputFieldBadRequest("delivery_amount", form.getDelivery_amount());

    }

    if (StringUtils.isNotEmpty(form.getUse_point())) {

      if (!StringUtils.isNumeric(form.getUse_point())) {

        return inputFieldBadRequest("use_point", form.getUse_point());

      }

    }

    if (StringUtils.isNotEmpty(form.getUse_money())) {

      if (!StringUtils.isNumeric(form.getUse_money())) {

        return inputFieldBadRequest("use_money", form.getUse_money());

      }

    }

    if (StringUtils.isNotEmpty(form.getCoupon_amount())) {

      if (!StringUtils.isNumeric(form.getCoupon_amount())) {

        return inputFieldBadRequest("coupon_amount", form.getCoupon_amount());

      }

    }

    if (StringUtils.isEmpty(form.getPayment_amount())) {

      return requiredFieldBadRequest("payment_amount");

    }

    if (!StringUtils.isNumeric(form.getPayment_amount())) {

      return inputFieldBadRequest("payment_amount", form.getPayment_amount());

    }

    if (StringUtils.isEmpty(form.getReceiver_name())) {

      return requiredFieldBadRequest("receiver_name");

    }

    if (StringUtils.isEmpty(form.getReceiver_phone())) {

      return requiredFieldBadRequest("receiver_phone");

    }