Subversion Repositories SmartDukaan

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

import com.spice.profitmandi.common.exception.ProfitMandiBusinessException;
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.common.util.StringUtils;
import com.spice.profitmandi.dao.cart.CartService;
import com.spice.profitmandi.dao.entity.user.Address;
import com.spice.profitmandi.dao.model.UserCart;
import com.spice.profitmandi.dao.repository.dtr.UserAccountRepository;
import com.spice.profitmandi.dao.repository.user.AddressRepository;
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.transaction.annotation.Transactional;
import org.springframework.web.bind.annotation.*;

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

@RestController
@RequestMapping("/v2")
@Transactional(rollbackFor = Throwable.class)
public class V2OrderController extends V2BaseController {

    @Autowired
    private OrderController orderController;

    @Autowired
    private UserAccountRepository userAccountRepository;

    @Autowired
    private AddressRepository addressRepository;

    @Autowired
    private CartService cartService;

    @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,
                                                      @RequestParam(value = "reservationId", required = false) String reservationId) throws Throwable {
        return wrapResponse(orderController.createOrder(request, paymentOption, walletUsed, selfPickup, freeCreditDays, reservationId));
    }

    // 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));
    }

    /**
     * Direct-JPA address creation. Replaces the legacy
     * {@link OrderController#createAddress} path, which went through the
     * Thrift {@code UserClient} — that requires a remote config service
     * (Consul/ZK) not available in every environment and was throwing NPE
     * on {@code ConfigClient.getClient().get(...)}.
     */
    @PostMapping("/address/create")
    public ResponseEntity<ApiResponse<?>> createAddress(HttpServletRequest request,
                                                        @RequestBody in.shop2020.model.v1.user.Address body)
            throws ProfitMandiBusinessException {
        Object userIdAttr = request.getAttribute("userId");
        if (!(userIdAttr instanceof Integer)) {
            java.util.Map<String, Object> err = new java.util.HashMap<>();
            err.put("responseStatus", "FAILURE");
            err.put("statusCode", 401);
            err.put("statusMessage", "LOGIN_REQUIRED");
            return ResponseEntity.status(401).body(ApiResponse.success(err));
        }
        int userId = (int) userIdAttr;
        UserCart uc = userAccountRepository.getUserCart(userId);
        if (uc == null) {
            throw new ProfitMandiBusinessException("userId", userId, "USER_CART_NOT_FOUND");
        }

        Address entity = new Address();
        entity.setName(body.getName());
        entity.setLine1(body.getLine1());
        entity.setLine2(body.getLine2());
        entity.setLandmark(body.getLandmark());
        entity.setCity(body.getCity());
        entity.setState(body.getState());
        entity.setPinCode(body.getPin());
        entity.setCountry(body.getCountry() == null ? "India" : body.getCountry());
        entity.setPhoneNumber(body.getPhone());
        entity.setEnabled(true);
        // Entity setter has a historical typo ("Retaier") — keep using it so
        // we don't break every other caller. Renaming is out of scope here.
        entity.setRetaierId(uc.getUserId());
        entity.setCreateTimestamp(LocalDateTime.now());
        entity.setUpdateTimestamp(LocalDateTime.now());
        addressRepository.persist(entity);

        // Bind the new address to the partner's cart so the very next
        // /v2/cart/open call resolves pincode from it.
        cartService.addAddressToCart(uc.getCartId(), entity.getId());

        return ResponseEntity.ok(ApiResponse.success((long) entity.getId()));
    }

    // 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 {
        LocalDateTime createDate = LocalDateTime.parse(createdDate);
        return wrapResponse(orderController.getInsurancePrices(request, price, itemId, String.valueOf(createDate)));
    }

    @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);
    }
}