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.transaction.NotifyOrder;

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.inventory.NotifyStatus;

import com.spice.profitmandi.dao.repository.transaction.NotifyOrderRespository;

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.LocalDate;

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;

    @Autowired

    private NotifyOrderRespository notifyOrderRespository;

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

    }

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

    }

    /**

     * V2 partner-side cancel for a color-change notify order.

     * Flips NotifyOrder.status to `cancel` for every pending row on the given orderId —

     * mirrors the pattern used by applyColorChange (`approved`) and NotifyHold (`hold`).

     * Does not refund or change the underlying Order.status.

     */

    @PostMapping("/order/notify-cancel-request")

    public ResponseEntity<ApiResponse<?>> notifyCancelRequest(@RequestParam int orderId) throws Throwable {

        List<NotifyOrder> notifyOrders = notifyOrderRespository.selectByOrder(orderId);

        for (NotifyOrder no : notifyOrders) {

            if (no.getStatus() == NotifyStatus.pending) {

                no.setStatus(NotifyStatus.cancel);

                no.setUpdateTimestamp(LocalDateTime.now());

            }

        }

        return ResponseEntity.ok(ApiResponse.success(true));

    }

    @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 = createdDate.contains("T")

                ? LocalDateTime.parse(createdDate)

                : LocalDate.parse(createdDate).atStartOfDay();

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

    }

}