Subversion Repositories SmartDukaan

package com.spice.profitmandi.web.controller;

import com.spice.profitmandi.common.exception.ProfitMandiBusinessException;

import com.spice.profitmandi.common.model.CustomAddress;

import com.spice.profitmandi.common.model.CustomPaymentOption;

import com.spice.profitmandi.common.model.InsuranceModel;

import com.spice.profitmandi.common.model.ProfitMandiConstants;

import com.spice.profitmandi.common.util.FileUtil;

import com.spice.profitmandi.common.web.util.ResponseSender;

import com.spice.profitmandi.dao.entity.auth.AuthUser;

import com.spice.profitmandi.dao.entity.catalog.Item;

import com.spice.profitmandi.dao.entity.dtr.InsurancePolicy;

import com.spice.profitmandi.dao.entity.dtr.PaymentOptionTransaction;

import com.spice.profitmandi.dao.entity.fofo.*;

import com.spice.profitmandi.dao.entity.inventory.State;

import com.spice.profitmandi.dao.entity.user.User;

import com.spice.profitmandi.dao.enumuration.dtr.PaymentOptionReferenceType;

import com.spice.profitmandi.dao.enumuration.transaction.UpSaleCallStatus;

import com.spice.profitmandi.dao.model.PaymentLinkDetailModel;

import com.spice.profitmandi.dao.model.UpsellingReportModel;

import com.spice.profitmandi.dao.repository.auth.AuthRepository;

import com.spice.profitmandi.dao.repository.catalog.ItemRepository;

import com.spice.profitmandi.dao.repository.catalog.TagListingRepository;

import com.spice.profitmandi.dao.repository.cs.CsService;

import com.spice.profitmandi.dao.repository.dtr.FofoStoreRepository;

import com.spice.profitmandi.dao.repository.dtr.InsurancePolicyRepository;

import com.spice.profitmandi.dao.repository.dtr.PaymentOptionTransactionRepository;

import com.spice.profitmandi.dao.repository.fofo.*;

import com.spice.profitmandi.dao.repository.inventory.StateRepository;

import com.spice.profitmandi.dao.repository.user.UserRepository;

import com.spice.profitmandi.service.NotificationService;

import com.spice.profitmandi.service.authentication.RoleManager;

import com.spice.profitmandi.service.integrations.RazorpayPaymentService;

import com.spice.profitmandi.service.integrations.kommuno.RecordingService;

import com.spice.profitmandi.service.integrations.zest.InsuranceService;

import com.spice.profitmandi.service.integrations.zest.MobileInsurancePlan;

import com.spice.profitmandi.service.order.OrderService;

import com.spice.profitmandi.web.model.LoginDetails;

import com.spice.profitmandi.web.util.CookiesProcessor;

import com.spice.profitmandi.web.util.MVCResponseSender;

import org.apache.logging.log4j.LogManager;

import org.apache.logging.log4j.Logger;

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

import org.springframework.http.MediaType;

import org.springframework.http.ResponseEntity;

import org.springframework.stereotype.Controller;

import org.springframework.transaction.annotation.Transactional;

import org.springframework.ui.Model;

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

import javax.servlet.http.HttpServletRequest;

import java.time.Instant;

import java.time.LocalDate;

import java.time.LocalDateTime;

import java.time.ZoneId;

import java.time.format.DateTimeFormatter;

import java.util.*;

import java.util.stream.Collectors;

@Controller

@Transactional(rollbackFor = Throwable.class)

public class UpSaleController {

    private static final Logger LOGGER = LogManager.getLogger(UpSaleController.class);

    @Autowired

    AuthRepository authRepository;

    @Autowired

    UpsellRazorpayPaymentStatusRepository upsellRazorpayPaymentStatusRepository;

    @Autowired

    private CookiesProcessor cookiesProcessor;

    @Autowired

    private RoleManager roleManager;

    @Autowired

    private FofoOrderRepository fofoOrderRepository;

    @Autowired

    private InsurancePolicyRepository insurancePolicyRepository;

    @Autowired

    private CustomerRepository customerRepository;

    @Autowired

    private UpSaleCallRepository upSaleCallRepository;

    @Autowired

    private UpSaleOrderRepository upSaleOrderRepository;

    @Autowired

    private MVCResponseSender mvcResponseSender;

    @Autowired

    private InsuranceService insuranceService;

    @Autowired

    private FofoOrderItemRepository fofoOrderItemRepository;

    @Autowired

    private ResponseSender responseSender;

    @Autowired

    private StateRepository stateRepository;

    @Autowired

    private NotificationService notificationService;

    @Autowired

    private ItemRepository itemRepository;

    @Autowired

    private RazorpayPaymentService razorpayPaymentService;

    @Autowired

    private TagListingRepository tagListingRepository;

    @Autowired

    private PaymentOptionTransactionRepository paymentOptionTransactionRepository;

    @Autowired

    private OrderService orderService;

    @Autowired

    private FofoLineItemRepository fofoLineItemRepository;

    @Autowired

    private UpSaleAgentCollectionRepository upSaleAgentCollectionRepository;

    @Autowired

    private RecordingService recordingService;

    @Autowired

    private UpSellCallDetailRepository upsellCallDetailRepository;

    @Autowired

    private CsService csService;

    @Autowired

    private FofoStoreRepository fofoStoreRepository;

    @Autowired

    private UserRepository userRepository;

    @Autowired

    private CustomerAddressRepository customerAddressRepository;

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

    public String upsaleProductslist(HttpServletRequest request, Model model) throws Exception {

        LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

        AuthUser user = authRepository.selectByEmailOrMobile(loginDetails.getEmailId());

        List<UpSaleAgentCollection> upSaleAgentCollections = upSaleAgentCollectionRepository.selectByAgentId(user.getId());

        // Calculate the total product sale amount

        double totalProductSaleAmount = upSaleAgentCollections.stream()

                .mapToDouble(UpSaleAgentCollection::getProductSaleAmount)

                .sum();

        // Add the total amount to the model

        List<UpSaleCallStatus> upSaleCallStatuses = new ArrayList<>(Arrays.asList(UpSaleCallStatus.values()));

        LOGGER.info("upSaleCallStatuses {}", upSaleCallStatuses);

        model.addAttribute("upSaleCallStatuses", upSaleCallStatuses);

        model.addAttribute("totalProductSaleAmount", totalProductSaleAmount);

        model.addAttribute("upSaleAgentCollections", upSaleAgentCollections);

        return "up-sale-call";

    }

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

    public String razorpapPaymentStatusAgainstOrderID(HttpServletRequest request, Model model, @RequestParam int orderId) throws Exception {

        List<UpsellRazorpayPaymentStatus> upSellRazorpayPaymentStatusList = upsellRazorpayPaymentStatusRepository.selectByOrderId(orderId);

        LOGGER.info("upSellRazorpayPaymentStatusList {}", upSellRazorpayPaymentStatusList);

        model.addAttribute("upSellRazorpayPaymentStatusList", upSellRazorpayPaymentStatusList);

        return "upsell-payment-confirmation";

    }

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

    public String fetchMobileNumberForUpSale(HttpServletRequest request, Model model) throws Exception {

        LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

        AuthUser user = authRepository.selectByEmailOrMobile(loginDetails.getEmailId());

        Map<String, Set<Integer>> pp = csService.getAuthUserPartnerIdMappingByCategoryIds(Arrays.asList(ProfitMandiConstants.UPSELLING), true);

        Set<Integer> fofoIds = new HashSet<>(pp.get(user.getEmailId()));

        List<UpSaleAgentCollection> upSaleAgentCollections = upSaleAgentCollectionRepository.selectByAgentId(user.getId());

        double totalProductSaleAmount = upSaleAgentCollections.stream()

                .mapToDouble(UpSaleAgentCollection::getProductSaleAmount)

                .sum();

        try {

            // Fetch all rescheduled calls and filter them in-memory

            List<UpSaleCall> upSaleCalls = upSaleCallRepository.selectAllByDispostion(UpSaleCallStatus.RESCHEDULED);

            LOGGER.info("UpSaleCall {}", upSaleCalls);

            List<UpSaleCall> filteredUpSaleCalls = upSaleCalls.stream()

                    .filter(call -> call.getRescheduledTimestamp() != null

                            && call.getRescheduledTimestamp().isBefore(LocalDateTime.now())

                            && call.getCreatedTimestamp() != null

                            && call.getCreatedTimestamp().isAfter(LocalDateTime.now().minusHours(48)))

                    .collect(Collectors.toList());

            if (!filteredUpSaleCalls.isEmpty()) {

                for (UpSaleCall upSaleCall : filteredUpSaleCalls) {

                    FofoOrder fofoOrder = fofoOrderRepository.selectByOrderId(upSaleCall.getOriginalOrderId());

                    User fofoUser = userRepository.selectById(fofoOrder.getFofoId());

                    Customer customer = customerRepository.selectById(fofoOrder.getCustomerId());

                    if (fofoIds.contains(fofoOrder.getFofoId())) {

                        if (customer != null) {

                            upSaleCall.setStatus(UpSaleCallStatus.FETCHED);

                            upSaleCall.setRescheduledTimestamp(null);

                            List<Map<String, Object>> itemDetails = new ArrayList<>();

                            List<FofoOrderItem> fofoOrderItems = fofoOrderItemRepository.selectByOrderId(fofoOrder.getId());

                            for (FofoOrderItem fofoOrderItem : fofoOrderItems) {

                                Item item = itemRepository.selectById(fofoOrderItem.getItemId());

                                if (item.isSmartPhone()) {

                                    Map<String, List<MobileInsurancePlan>> plans = this.getPlans(fofoOrderItem.getSellingPrice(), item.getId());

                                    Map<String, Object> itemDetail = new HashMap<>();

                                    itemDetail.put("item", item);

                                    itemDetail.put("fofoOrderItem", fofoOrderItem);

                                    itemDetail.put("plans", plans);

                                    itemDetails.add(itemDetail);

                                }

                            }

                            Set<Integer> fofoOrderItemIds = fofoOrderItems.stream().map(FofoOrderItem::getId).collect(Collectors.toSet());

                            List<FofoLineItem> fofoLineItems = fofoLineItemRepository.selectByFofoOrderItemIds(fofoOrderItemIds);

                            Map<Integer, List<FofoLineItem>> fofoLineItemMap = fofoLineItems.stream()

                                    .collect(Collectors.groupingBy(FofoLineItem::getFofoOrderItemId));

                            List<UpSaleCallStatus> upSaleCallStatuses = new ArrayList<>(Arrays.asList(UpSaleCallStatus.values()));

                            model.addAttribute("upSaleCallStatuses", upSaleCallStatuses);

                            model.addAttribute("fofoOrder", fofoOrder);

                            model.addAttribute("fofoUser", fofoUser);

                            model.addAttribute("customer", customer);

                            model.addAttribute("itemDetails", itemDetails);

                            model.addAttribute("fofoLineItemMap", fofoLineItemMap);

                            model.addAttribute("upsaleCallId", upSaleCall.getId());

                            model.addAttribute("stateNames",

                                    stateRepository.selectAll().stream().map(x -> x.getName()).collect(Collectors.toList()));

                            model.addAttribute("totalProductSaleAmount", totalProductSaleAmount);

                            return "up-sale-call";

                        }

                    }

                }

            } else {

                throw new RuntimeException("No filtered calls available for processing");

            }

        } catch (Exception e) {

            // If no rescheduled calls found, fall back to original logic

            UpSaleOrder TMinus2UpsaleOrder = this.getTMinus2UpSaleOrderByFofoIds(fofoIds);

            TMinus2UpsaleOrder.setFetched(true);

            LOGGER.info("last48hourLatestOrder {}", TMinus2UpsaleOrder);

            if (TMinus2UpsaleOrder != null) {

                boolean exists = upSaleCallRepository.existsOrderId(TMinus2UpsaleOrder.getOrderId());

                if (!exists) {

                    FofoOrder fofoOrder = fofoOrderRepository.selectByOrderId(TMinus2UpsaleOrder.getOrderId());

                    User fofoUser = userRepository.selectById(fofoOrder.getFofoId());

                    if (fofoIds.contains(fofoOrder.getFofoId())) {

                        Customer customer = customerRepository.selectById(fofoOrder.getCustomerId());

                        if (customer != null) {

                            String mobile = customer.getMobileNumber();

                            UpSaleCall upSaleCall = new UpSaleCall();

                            upSaleCall.setAgentId(user.getId());

                            upSaleCall.setMobile(mobile);

                            upSaleCall.setOriginalOrderId(fofoOrder.getId());

                            upSaleCall.setStatus(UpSaleCallStatus.FETCHED);

                            upSaleCall.setCreatedTimestamp(LocalDateTime.now());

                            upSaleCallRepository.persist(upSaleCall);

                            LOGGER.info("Processing UpSaleOrder {}", TMinus2UpsaleOrder);

                            List<Map<String, Object>> itemDetails = new ArrayList<>();

                            List<FofoOrderItem> fofoOrderItems = fofoOrderItemRepository.selectByOrderId(fofoOrder.getId());

                            for (FofoOrderItem fofoOrderItem : fofoOrderItems) {

                                Item item = itemRepository.selectById(fofoOrderItem.getItemId());

                                if (item.isSmartPhone()) {

                                    float sellingPrice = tagListingRepository.selectByItemId(item.getId()).getSellingPrice();

                                    Map<String, List<MobileInsurancePlan>> plans = this.getPlans(fofoOrderItem.getSellingPrice(), item.getId());

                                    Map<String, Object> itemDetail = new HashMap<>();

                                    itemDetail.put("item", item);

                                    itemDetail.put("fofoOrderItem", fofoOrderItem);

                                    itemDetail.put("plans", plans);

                                    itemDetails.add(itemDetail);

                                }

                            }

                            Set<Integer> fofoOrderItemIds = fofoOrderItems.stream().map(FofoOrderItem::getId).collect(Collectors.toSet());

                            List<FofoLineItem> fofoLineItems = fofoLineItemRepository.selectByFofoOrderItemIds(fofoOrderItemIds);

                            Map<Integer, List<FofoLineItem>> fofoLineItemMap = fofoLineItems.stream()

                                    .collect(Collectors.groupingBy(FofoLineItem::getFofoOrderItemId));

                            List<UpSaleCallStatus> upSaleCallStatuses = new ArrayList<>(Arrays.asList(UpSaleCallStatus.values()));

                            model.addAttribute("upSaleCallStatuses", upSaleCallStatuses);

                            model.addAttribute("fofoOrder", fofoOrder);

                            model.addAttribute("fofoUser", fofoUser);

                            model.addAttribute("customer", customer);

                            model.addAttribute("itemDetails", itemDetails);

                            model.addAttribute("fofoLineItemMap", fofoLineItemMap);

                            model.addAttribute("upsaleCallId", upSaleCall.getId());

                            model.addAttribute("stateNames",

                                    stateRepository.selectAll().stream().map(State::getName).collect(Collectors.toList()));

                            model.addAttribute("totalProductSaleAmount", totalProductSaleAmount);

                            return "up-sale-call";

                        }

                    }

                }

            }

        }

        LOGGER.info("No valid UpSaleOrder found for up-sale call.");

        model.addAttribute("totalProductSaleAmount", totalProductSaleAmount);

        model.addAttribute("message", "No valid UpSaleOrder found.");

        return "up-sale-call";

    }

    UpSaleOrder getTMinus2UpSaleOrderByFofoIds(Set<Integer> fofoIds) {

        LocalDateTime startDateTime = LocalDateTime.now().minusDays(2); // 48 hours ago

        return upSaleOrderRepository.getTMinus2UpSaleOrderByFofoIds(fofoIds, startDateTime);

    }

    @RequestMapping(value = "/generatePaymentLink", method = RequestMethod.POST)

    public ResponseEntity<String> generatePaymentLink(HttpServletRequest request, Model model, @RequestBody PaymentLinkDetailModel paymentLinkDetailModel) {

        double amount;

        LOGGER.info("paymnetlinkmodel {}", paymentLinkDetailModel);

        try {

            String paymentLink = razorpayPaymentService.createPaymentLink(paymentLinkDetailModel);

            LOGGER.info("paymentLink {}", paymentLink);

            notificationService.sendPaymentLink(paymentLinkDetailModel.getMobile(), paymentLink);

//            model.addAttribute("message", "Payment link generated and sent successfully!");

            return responseSender.ok(true);

        } catch (Exception e) {

//            model.addAttribute("message", "Failed to generate payment link: " + e.getMessage());

            return responseSender.ok(false);

        }

    }

    private Map<String, List<MobileInsurancePlan>> getPlans(float sellingPrice, int itemId)

            throws ProfitMandiBusinessException {

        try {

            Map<String, List<MobileInsurancePlan>> productDurationPlans = new HashMap<>();

            productDurationPlans = insuranceService.getAllPlans(itemId,

                    sellingPrice, false);

            return productDurationPlans;

        } catch (Exception e) {

            LOGGER.info(e, e);

            throw new ProfitMandiBusinessException("Fetch Insurance Plans", "Insurance",

                    "Could not fetch insurance Plans");

        }

    }

    @RequestMapping(value = "/upsell/clickToCall/{toMobile}/{upsellCallId}", method = RequestMethod.POST, produces = MediaType.APPLICATION_JSON_VALUE)

    public ResponseEntity<?> upsellClickToCall(HttpServletRequest request, @PathVariable String toMobile, @PathVariable int upsellCallId) throws Exception {

        LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

        AuthUser user = authRepository.selectByEmailOrMobile(loginDetails.getEmailId());

        recordingService.upsellClickToCallKommuno(toMobile, loginDetails.getEmailId(), upsellCallId);

        return responseSender.ok(true);

    }

    @RequestMapping(value = "/upsell/disposition/{upsellCallId}", method = RequestMethod.POST, produces = MediaType.APPLICATION_JSON_VALUE)

    public ResponseEntity<?> upsellDisposition(HttpServletRequest request,

                                               @PathVariable String upsellCallId,

                                               @RequestParam(name = "disposition", required = false) UpSaleCallStatus disposition,

                                               @RequestParam(name = "scheduleTime", required = false) String scheduleTime) throws Exception {

        LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

        AuthUser user = authRepository.selectByEmailOrMobile(loginDetails.getEmailId());

        UpsellCallDetail upsellCallDetail = upsellCallDetailRepository.selectByUpSellCallId(upsellCallId);

        LOGGER.info("upsellCallDetail {}", upsellCallDetail);

        upsellCallDetail.setAgentId(user.getEmailId());

        upsellCallDetail.setDisposition(disposition);

        upsellCallDetail.setRemark(disposition.getValue());

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

            UpSaleCall upSaleCall = upSaleCallRepository.selectById(Integer.parseInt(upsellCallId));

            Instant instant = Instant.parse(scheduleTime);

            LocalDateTime scheduledDateTime = LocalDateTime.ofInstant(instant, ZoneId.systemDefault());

            upSaleCall.setRescheduledTimestamp(scheduledDateTime);

            upSaleCall.setStatus(disposition);

        }

        // Generate session id with 16 digits as kommuno service

        Long newId = (long) upsellCallDetail.getId();

        String sessionId = String.format("%014d", newId);

        upsellCallDetail.setDiallerSessionId(sessionId);

//        fill diposition on kommuno service

        recordingService.upsellFillDispositionWithKommuno(disposition.getValue(), sessionId);

        return responseSender.ok(true);

    }

    @RequestMapping(value = "/generatePlanDetail", method = RequestMethod.POST)

    public String generatePlanDetail(HttpServletRequest request, Model model, @RequestBody PaymentLinkDetailModel paymentLinkDetailModel) throws Exception {

        FofoOrderItem foi = fofoOrderItemRepository.selectById(Integer.parseInt(paymentLinkDetailModel.getOrderItemId()));

        FofoOrder fofoOrder = fofoOrderRepository.selectByOrderId(Integer.parseInt(paymentLinkDetailModel.getOrderId()));

        float deviceSellingPrice = tagListingRepository.selectByItemId(foi.getItemId()).getSellingPrice();

        MobileInsurancePlan mobileInsurancePlan = insuranceService.getPlanById(paymentLinkDetailModel.getPlanId(), foi.getSellingPrice(), paymentLinkDetailModel.getPlanName());

        Customer customer = customerRepository.selectById(fofoOrder.getCustomerId());

        model.addAttribute("fofoOrder", fofoOrder);

        model.addAttribute("fofoOrderItem", foi);

        model.addAttribute("deviceSellinnPrice", deviceSellingPrice);

        model.addAttribute("mobileInsurancePlan", mobileInsurancePlan);

        model.addAttribute("serialNumber", paymentLinkDetailModel.getSerialNumber());

        model.addAttribute("customer", customer);

        model.addAttribute("customerAddress", customer.getCustomerAddress());

        return "upsale-create-insurance-model";

    }

    @RequestMapping(value = "/create-insurance", method = RequestMethod.POST)

    public ResponseEntity<?> createInsurance(HttpServletRequest request, @RequestBody InsuranceModel insuranceModel, Model model) throws Exception {

        LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

        AuthUser user = authRepository.selectByEmailOrMobile(loginDetails.getEmailId());

        LOGGER.info("request at uri {} body {}", request.getRequestURI(), insuranceModel);

        FofoOrderItem foi = fofoOrderItemRepository.selectById(insuranceModel.getFofoOrderItemId());

        float deviceSellingPrice = tagListingRepository.selectByItemId(foi.getItemId()).getSellingPrice();

        FofoOrder fofoOrder = fofoOrderRepository.selectByOrderId(foi.getOrderId());

        FofoStore fs = fofoStoreRepository.selectByRetailerId(fofoOrder.getFofoId());

        Customer customer = customerRepository.selectById(fofoOrder.getCustomerId());

        LOGGER.info("customer {}", customer);

        LOGGER.info("customerAddress {}", customer.getCustomerAddress());

        if (fofoOrder.getCustomerAddressId() == 0) {

            throw new Exception("Please select a address or add new address");

        }

        customer.setDob(insuranceModel.getDob());

        fofoOrder.setDateOfBirth(insuranceModel.getDob());

        insuranceModel.setBrand(foi.getBrand());

        insuranceModel.setMfgDate(insuranceModel.getWmfgDate().atStartOfDay());

        insuranceModel.setColor(foi.getColor());

        insuranceModel.setInsuranceUId(insuranceModel.getInsuranceId());

        insuranceModel.setInsuranceId(String.valueOf(insuranceService.getOneAssistPremiumByVariantId(insuranceModel.getInsuranceId()).getId()));

        insuranceModel.setModelName(String.join(" ", foi.getModelName(), foi.getModelNumber()));

        insuranceModel.setDeviceSellingPrice(deviceSellingPrice);

        InsurancePolicy insurancePolicy = insuranceService.createInsurance(fofoOrder, insuranceModel, true);

        String documentNumber = orderService.getInvoiceNumber(fofoOrder.getFofoId(), fs.getCode());

        insurancePolicy.setInvoiceNumber(documentNumber);

        insurancePolicy.setDeviceInvoiceNumber(fofoOrder.getInvoiceNumber());

        FofoOrder fo = this.createAndGetFofoOrder(customer.getId(), fofoOrder.getCustomerGstNumber(), fofoOrder.getFofoId(), insurancePolicy.getInvoiceNumber(), insuranceModel.getInsuranceAmount(), fofoOrder.getCustomerAddressId());

        this.createPaymentOptions(fo, insuranceModel.getPaymentOptions());

//        agent collection persistance

        UpSaleAgentCollection upSaleAgentCollection = new UpSaleAgentCollection();

        upSaleAgentCollection.setAgentId(user.getId());

        upSaleAgentCollection.setOrderId(fofoOrder.getId());

        upSaleAgentCollection.setProductId(insuranceModel.getInsuranceId());

        upSaleAgentCollection.setInsurancePolicyId(insurancePolicy.getId());

        upSaleAgentCollection.setProductSaleAmount(insurancePolicy.getSaleAmount());

//        if insurance plan is selling than is insurance will be true

        upSaleAgentCollection.setInsurance(true);

        upSaleAgentCollection.setCreatedTimestamp(LocalDateTime.now());

        upSaleAgentCollectionRepository.persist(upSaleAgentCollection);

        return responseSender.ok(true);

    }

    private void createPaymentOptions(FofoOrder fofoOrder, Set<CustomPaymentOption> customPaymentOptions) throws ProfitMandiBusinessException {

        for (CustomPaymentOption customPaymentOption : customPaymentOptions) {

            if (customPaymentOption.getAmount() > 0) {

                PaymentOptionTransaction paymentOptionTransaction = new PaymentOptionTransaction();

                paymentOptionTransaction.setReferenceId(fofoOrder.getId());

                paymentOptionTransaction.setPaymentOptionId(customPaymentOption.getPaymentOptionId());

                paymentOptionTransaction.setReferenceType(PaymentOptionReferenceType.INSURANCE);

                paymentOptionTransaction.setAmount(customPaymentOption.getAmount());

                paymentOptionTransaction.setFofoId(fofoOrder.getFofoId());

                paymentOptionTransactionRepository.persist(paymentOptionTransaction);

            }

        }

    }

    private FofoOrder createAndGetFofoOrder(int customerId, String customerGstNumber, int fofoId, String documentNumber, float totalAmount, int customerAddressId) {

        // Idempotency: fast-path return if the row already exists for this (fofo, invoice).

        // Protects against concurrent duplicate inserts (client retry / upstream webhook retry).

        FofoOrder existing = findExistingFofoOrder(fofoId, documentNumber);

        if (existing != null) return existing;

        FofoOrder fofoOrder = new FofoOrder();

        fofoOrder.setCustomerGstNumber(customerGstNumber);

        fofoOrder.setCustomerId(customerId);

        fofoOrder.setFofoId(fofoId);

        fofoOrder.setInvoiceNumber(documentNumber);

        fofoOrder.setTotalAmount(totalAmount);

        fofoOrder.setCustomerAddressId(customerAddressId);

        try {

            fofoOrderRepository.persist(fofoOrder);

        } catch (org.springframework.dao.DataIntegrityViolationException dup) {

            // Lost a narrow race between our select and insert — re-fetch the winner's row.

            // Requires uk_fofo_order_fofo_invoice unique key to trigger this exception.

            FofoOrder winner = findExistingFofoOrder(fofoId, documentNumber);

            if (winner != null) return winner;

            throw dup;

        }

        return fofoOrder;

    }

    private FofoOrder findExistingFofoOrder(int fofoId, String invoiceNumber) {

        try {

            return fofoOrderRepository.selectByFofoIdAndInvoiceNumber(fofoId, invoiceNumber);

        } catch (ProfitMandiBusinessException ignored) {

            return null;

        }

    }

    @RequestMapping(value = "/customer/addaddress", method = RequestMethod.POST)

    public ResponseEntity<?> addAddress(HttpServletRequest request, @RequestParam int customerId,

                                        @RequestBody CustomAddress customAddress) {

        CustomerAddress customerAddress = this.toCustomerAddress(customerId, customAddress);

        customerAddressRepository.persist(customerAddress);

        return responseSender.ok(this.toCustomAddress(customerAddress));

    }

    private CustomAddress toCustomAddress(CustomerAddress customerAddress) {

        CustomAddress customAddress = new CustomAddress();

        customAddress.setCity(customerAddress.getCity());

        customAddress.setCountry(customerAddress.getCountry());

        customAddress.setLandmark(customerAddress.getLandmark());

        customAddress.setLine1(customerAddress.getLine1());

        customAddress.setLine2(customerAddress.getLine2());

        customAddress.setName(customerAddress.getName());

        customAddress.setLastName(customerAddress.getLastName());

        customAddress.setPhoneNumber(customerAddress.getPhoneNumber());

        customAddress.setPinCode(customerAddress.getPinCode());

        customAddress.setState(customerAddress.getState());

        customAddress.setId(customerAddress.getId());

        return customAddress;

    }

    private CustomerAddress toCustomerAddress(int customerId, CustomAddress customAddress) {

        CustomerAddress customerAddress = new CustomerAddress();

        customerAddress.setCustomerId(customerId);

        customerAddress.setName(customAddress.getName());

        customerAddress.setLastName(customAddress.getLastName());

        customerAddress.setLine1(customAddress.getLine1());

        customerAddress.setLine2(customAddress.getLine2());

        customerAddress.setLandmark(customAddress.getLandmark());

        customerAddress.setCity(customAddress.getCity());

        customerAddress.setPinCode(customAddress.getPinCode());

        customerAddress.setState(customAddress.getState());

        customerAddress.setCountry(customAddress.getCountry());

        customerAddress.setPhoneNumber(customAddress.getPhoneNumber());

        return customerAddress;

    }

    @RequestMapping(value = "/update-fofoOrder-addressId", method = RequestMethod.POST)

    public ResponseEntity<?> updateFofoOrderAddresId(HttpServletRequest request, @RequestParam(name = "orderId", defaultValue = "0") int orderId, @RequestParam(name = "addressId", defaultValue = "0") int addressId, Model model) throws Exception {

        FofoOrder fofoOrder = fofoOrderRepository.selectByOrderId(orderId);

        fofoOrder.setCustomerAddressId(addressId);

        return responseSender.ok(true);

    }

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

    public ResponseEntity<?> downloadUpsellingReport(HttpServletRequest request,

                                                     @RequestParam(name = "startDate") LocalDateTime startDate,

                                                     @RequestParam(name = "endDate") LocalDateTime endDate, Model model)

            throws Exception {

        List<List<?>> rows = new ArrayList<>();

        LocalDate startLocalDate = startDate.toLocalDate();

        LocalDate endLocalDate = endDate.toLocalDate();

        List<UpsellingReportModel> upsellingReportModels = upSaleCallRepository.getUpsellingReport(startLocalDate, endLocalDate.plusDays(1));

        DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("dd/MM/yyyy HH:mm");

        for (

                UpsellingReportModel report : upsellingReportModels) {

            rows.add(Arrays.asList(

                    report.getAgentEmail(),

                    report.getPartnerName(),

                    report.getPartnerMobile(),

                    report.getState(),

                    report.getPartnerName(),

                    report.getOrderId(),

                    report.getCustomerNumber(),

                    report.getCallingDate(),

                    report.getDisposition(),

                    report.getRemark(),

                    report.getPaymentStatus(),

                    report.getInsuranceStatus(),

                    report.getPolicySoldAmount(),

                    report.getInvoiceNumber(),

                    report.getSerialNumber()

            ));

        }

        org.apache.commons.io.output.ByteArrayOutputStream baos = FileUtil

                .getCSVByteStream(Arrays.asList("Agent Email", "Partner Name", "Partner Mobile Number", "Partner State", "Order Id", "Customer Mobile Number", "Calling Date", "Disposition", "Remark", "Payment Status", "Insurance Status", "Policy Sold Amount", "Invoice Number", "Serial Number"), rows);

        ResponseEntity<?> responseEntity = orderService.downloadReportInCsv(baos, rows, " Upselling Report");

        return responseEntity;

    }

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

    public String getUpsellingReport(

            HttpServletRequest request,

            @RequestParam(name = "startDate") LocalDateTime startDate,

            @RequestParam(name = "endDate") LocalDateTime endDate, Model model

    ) throws Exception {

        LocalDate startLocalDate = startDate.toLocalDate();

        LocalDate endLocalDate = endDate.toLocalDate();

        List<UpsellingReportModel> upsellingReportModels = upSaleCallRepository.getUpsellingReport(startLocalDate, endLocalDate.plusDays(1));

        model.addAttribute("upsellingReportModels", upsellingReportModels);

        return "upselling-report";

    }

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

    public String upsellingCallingList(

            HttpServletRequest request, Model model) throws Exception {

        return "upselling-calling-list";

    }

}