Subversion Repositories SmartDukaan

package com.spice.profitmandi.web.v2.controller;

import com.spice.profitmandi.common.model.SamsungUpgradeOfferModel;
import com.spice.profitmandi.common.model.CreateOrderRequest;
import com.spice.profitmandi.common.model.InsuranceModel;
import com.spice.profitmandi.web.controller.checkout.OrderController;
import com.spice.profitmandi.web.v2.response.ApiResponse;
import in.shop2020.model.v1.order.OrderStatus;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.ResponseEntity;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.*;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.time.YearMonth;
import java.util.List;

@RestController
@RequestMapping("/v2")
public class V2OrderController extends V2BaseController {

    @Autowired
    private OrderController orderController;

    @RequestMapping(value = "/order/create", method = {RequestMethod.POST, RequestMethod.GET})
    public ResponseEntity<ApiResponse<?>> createOrder(HttpServletRequest request,
                                                      @RequestParam(value = "paymentOption") String paymentOption,
                                                      @RequestParam(value = "walletUsed") double walletUsed,
                                                      @RequestParam(value = "selfPickup", defaultValue = "false") boolean selfPickup,
                                                      @RequestParam(defaultValue = "0") int freeCreditDays) throws Throwable {
        return wrapResponse(orderController.createOrder(request, paymentOption, walletUsed, selfPickup, freeCreditDays));
    }

    // TODO: paymentOptions writes directly to response via void method - skipping v2 wrapper
    // @GetMapping("/paymentOptions")

    @GetMapping("/order/payStatus")
    public ResponseEntity<ApiResponse<?>> payStatus(HttpServletRequest request,
                                                    @RequestParam(value = "paymentId") long paymentId) throws Throwable {
        return wrapResponse(orderController.payStatus(request, paymentId));
    }

    @GetMapping("/order/transactionId")
    public ResponseEntity<ApiResponse<?>> getOrdersByTransactionId(HttpServletRequest request,
                                                                    @RequestParam(name = "transactionId") int transactionId) throws Throwable {
        return wrapResponse(orderController.getOrdersByTransactionId(request, transactionId));
    }

    @GetMapping("/order/all")
    public ResponseEntity<ApiResponse<?>> getOrdersByRetailerId(HttpServletRequest request,
                                                                @RequestParam(defaultValue = "0") int offset,
                                                                @RequestParam(defaultValue = "20") int limit) throws Throwable {
        return wrapResponse(orderController.getOrdersByRetailerId(request, offset, limit));
    }

    @GetMapping("/order/grnPending")
    public ResponseEntity<ApiResponse<?>> grnPending(HttpServletRequest request) throws Throwable {
        return wrapResponse(orderController.grnPending(request));
    }

    @GetMapping("/order/billed")
    public ResponseEntity<ApiResponse<?>> billedOrders(HttpServletRequest request) throws Throwable {
        return wrapResponse(orderController.billedOrders(request));
    }

    @GetMapping("/retailerStock")
    public ResponseEntity<ApiResponse<?>> partnerAllStock(HttpServletRequest request) throws Throwable {
        return wrapResponse(orderController.partnerAllStock(request));
    }

    @GetMapping("/retailerStock/brandwise/{brand}")
    public ResponseEntity<ApiResponse<?>> partnerAllStockBrandwise(HttpServletRequest request,
                                                                   @PathVariable String brand) throws Throwable {
        return wrapResponse(orderController.partnerAllStockBrandwise(request, brand));
    }

    @GetMapping("/order/orderAll/{status}/{yearMonth}")
    public ResponseEntity<ApiResponse<?>> getOrders(HttpServletRequest request,
                                                    @PathVariable OrderStatus status,
                                                    @PathVariable YearMonth yearMonth) throws Throwable {
        return wrapResponse(orderController.getOrders(request, status, yearMonth));
    }

    @PostMapping("/partnerCancelOrder")
    public ResponseEntity<ApiResponse<?>> partnerCancelOrder(HttpServletRequest request,
                                                             @RequestParam int orderId,
                                                             @RequestParam String reason) throws Throwable {
        return wrapResponse(orderController.partnerCancelOrder(request, orderId, reason));
    }

    @PostMapping("/order/cancellation")
    public ResponseEntity<ApiResponse<?>> CancellableRequest(HttpServletRequest request,
                                                             @RequestParam(name = "orderId") long orderId,
                                                             @RequestParam(name = "splitOrderQty") long splitOrderQty) throws Throwable {
        return wrapResponse(orderController.CancellableRequest(request, orderId, splitOrderQty));
    }

    @GetMapping("/order/list")
    public ResponseEntity<ApiResponse<?>> getOrderListByOrderId(HttpServletRequest request,
                                                                @RequestParam(name = "orderId") List<Integer> orderIds) throws Throwable {
        return wrapResponse(orderController.getOrderListByOrderId(request, orderIds));
    }

    @PostMapping("/address/create")
    public ResponseEntity<ApiResponse<?>> createAddress(HttpServletRequest request,
                                                        @RequestBody in.shop2020.model.v1.user.Address address) throws Throwable {
        return wrapResponse(orderController.createAddress(request, address));
    }

    // TODO: fetchOnlineOrders writes directly to response via void method - skipping v2 wrapper
    // @GetMapping("/online-orders")

    @GetMapping("/order/notify-orders")
    public ResponseEntity<ApiResponse<?>> getNotifyOrders(HttpServletRequest request,
                                                          HttpServletResponse response,
                                                          @RequestParam(value = "offset") String offset,
                                                          @RequestParam(value = "limit") String limit) throws Throwable {
        return wrapResponse(orderController.getNotifyOrders(request, response, offset, limit));
    }

    @PostMapping("/order/notify-color-change")
    public ResponseEntity<ApiResponse<?>> NotifyColorChange(HttpServletRequest request,
                                                            HttpServletResponse response,
                                                            @RequestParam(name = "orderId") int orderId,
                                                            @RequestParam(name = "itemId") int itemId) throws Throwable {
        return wrapResponse(orderController.applyColorChange(request, response, orderId, itemId));
    }

    @PostMapping("/hold-notify-order")
    public ResponseEntity<ApiResponse<?>> NotifyHold(HttpServletRequest request,
                                                     HttpServletResponse response,
                                                     @RequestParam(name = "orderId") int orderId) throws Throwable {
        return wrapResponse(orderController.NotifyHold(request, response, orderId));
    }

    @PostMapping("/cancelOrder")
    public ResponseEntity<ApiResponse<?>> cancelOrder(HttpServletRequest request,
                                                      @RequestParam int orderId) throws Throwable {
        return wrapResponse(orderController.cancelOrder(request, orderId));
    }

    @GetMapping("/order/notify-cancel-orders")
    public ResponseEntity<ApiResponse<?>> getNotifyCancelOrders(HttpServletRequest request,
                                                                HttpServletResponse response,
                                                                @RequestParam(value = "offset") String offset,
                                                                @RequestParam(value = "limit") String limit) throws Throwable {
        return wrapResponse(orderController.getNotifyCancelOrders(request, response, offset, limit));
    }

    @PostMapping("/cancelNotifyOrder")
    public ResponseEntity<ApiResponse<?>> cancelNotifyOrder(HttpServletRequest request,
                                                            @RequestParam int orderId) throws Throwable {
        return wrapResponse(orderController.cancelNotifyOrder(request, orderId));
    }

    @PostMapping("/raiseBypassRequest")
    public ResponseEntity<ApiResponse<?>> raiseBypassRequest(HttpServletRequest request) throws Throwable {
        return wrapResponse(orderController.raiseBypassRequest(request));
    }

    @GetMapping("/item")
    public ResponseEntity<ApiResponse<?>> getItem(HttpServletRequest request,
                                                  Model model,
                                                  @RequestParam String query) throws Throwable {
        return wrapResponse(orderController.getItem(request, model, query));
    }

    @GetMapping("/checkItemAvailability")
    public ResponseEntity<ApiResponse<?>> getItemAvailability(HttpServletRequest request,
                                                              @RequestParam(name = "itemId") int itemId,
                                                              Model model) throws Throwable {
        return wrapResponse(orderController.getItemAvailability(request, itemId, model));
    }

    @GetMapping("/getItemPricing")
    public ResponseEntity<ApiResponse<?>> getItemPricing(HttpServletRequest request,
                                                         Model model,
                                                         @RequestParam int itemId) throws Throwable {
        return wrapResponse(orderController.getItemPricing(request, model, itemId));
    }

    @GetMapping("/getFofoPaymentOptions")
    public ResponseEntity<ApiResponse<?>> getPaymentOptions(HttpServletRequest request) throws Throwable {
        return wrapResponse(orderController.getPaymentOptions(request));
    }

    @PostMapping("/create-order")
    public ResponseEntity<ApiResponse<?>> createFofoOrder(HttpServletRequest request,
                                                          @RequestBody CreateOrderRequest createOrderRequest,
                                                          Model model) throws Throwable {
        return wrapResponse(orderController.createOrder(request, createOrderRequest, model));
    }

    @GetMapping("/getCustomerOffers")
    public ResponseEntity<ApiResponse<?>> getCustomerOffers(HttpServletRequest request,
                                                            @RequestParam int itemId,
                                                            @RequestParam String imei,
                                                            @RequestParam int orderId) throws Throwable {
        return wrapResponse(orderController.getCustomerOffers(request, itemId, imei, orderId));
    }

    @PostMapping("/upgradeOffer/createSamsungUpgradeOffer")
    public ResponseEntity<ApiResponse<?>> createSamsungUpgradeOffer(HttpServletRequest request,
                                                                    @RequestBody SamsungUpgradeOfferModel suom) throws Throwable {
        return wrapResponse(orderController.createSamsungUpgradeOffer(request, suom));
    }

    @PostMapping("/upgradeOffer/changeOrderPricing")
    public ResponseEntity<ApiResponse<?>> changeOrderPricing(HttpServletRequest request,
                                                             @RequestParam String imei,
                                                             @RequestParam int totalPayout) throws Throwable {
        return wrapResponse(orderController.changeOrderPricing(request, imei, totalPayout));
    }

    @GetMapping("/insurance/checkInsurance")
    public ResponseEntity<ApiResponse<?>> checkInsurance(HttpServletRequest request,
                                                         @RequestParam String imei) throws Throwable {
        return wrapResponse(orderController.checkInsurance(request, imei));
    }

    @GetMapping("/insurance/checkplans")
    public ResponseEntity<ApiResponse<?>> getInsurancePrices(HttpServletRequest request,
                                                             @RequestParam float price,
                                                             @RequestParam int itemId,
                                                             @RequestParam String createdDate) throws Throwable {
        return wrapResponse(orderController.getInsurancePrices(request, price, itemId, createdDate));
    }

    @PostMapping("/create-insurance")
    public ResponseEntity<ApiResponse<?>> createInsurance(HttpServletRequest request,
                                                          @RequestBody InsuranceModel insuranceModel,
                                                          Model model) throws Throwable {
        return wrapResponse(orderController.createInsurance(request, insuranceModel, model));
    }

    @GetMapping("/order/generateInvoice")
    public ResponseEntity<?> generateInvoice(HttpServletRequest request,
                                             @RequestParam(name = "invoiceNumber") String invoiceNumber) throws Throwable {
        // Returns PDF binary - pass through directly, cannot wrap in ApiResponse
        return orderController.generateInvoice(request, invoiceNumber);
    }
}