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.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.enumuration.dtr.PaymentOptionReferenceType;

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

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

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.service.NotificationService;

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

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

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

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

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 KommunoService kommunoService;

    @Autowired

    private UpSellCallDetailRepository upsellCallDetailRepository;

    @Autowired

    private CsService csService;

    @Autowired

    private FofoStoreRepository fofoStoreRepository;

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

        LOGGER.info("pp pp - {}", pp);

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

        LOGGER.info("fofoIds- {}", fofoIds);

        LocalDate currentYearJune21 = LocalDate.of(LocalDate.now().getYear(), Month.JUNE, 21);

        LocalDateTime startDate = currentYearJune21.atStartOfDay();

        LocalDateTime endDate = LocalDateTime.now();

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

            List<UpSaleCall> filteredUpSaleCalls = upSaleCalls.stream()

                    .filter(call -> call.getRescheduledTimestamp() != null && call.getRescheduledTimestamp().isBefore(endDate))

                    .collect(Collectors.toList());

            if (!filteredUpSaleCalls.isEmpty()) {

                for (UpSaleCall upSaleCall : filteredUpSaleCalls) {

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

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

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

                        if (customer != null) {

                            String mobile = customer.getMobileNumber();

                            // Update the UpSaleCall status to FETCHED and set reschedule time to null

                            upSaleCall.setStatus(UpSaleCallStatus.FETCHED);

                            upSaleCall.setRescheduledTimestamp(null);

                            LOGGER.info("Processing Rescheduled UpSaleCall {}", upSaleCall);

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

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

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

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

                            model.addAttribute("upSaleCallStatuses", upSaleCallStatuses);

                            model.addAttribute("fofoOrder", fofoOrder);

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

                        }

                    }

                }

            }

        } catch (Exception e) {

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

            List<UpSaleOrder> upSaleOrders = upSaleOrderRepository.selectAllBetweenDates(startDate, endDate);

            for (UpSaleOrder upSaleOrder : upSaleOrders) {

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

                if (!exists) {

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

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

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

                        if (customer != null) {

                            String mobile = customer.getMobileNumber();

                            boolean mobileExists = upSaleCallRepository.existsByMobileAndOrderId(mobile, fofoOrder.getId());

                            if (!mobileExists) {

                                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 {}", upSaleOrder);

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

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

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

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

                                model.addAttribute("upSaleCallStatuses", upSaleCallStatuses);

                                model.addAttribute("fofoOrder", fofoOrder);

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

    }

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

            String message = "Dear Customer,\n" +

                    "Here is a payment link for your recent purchased product.\n" +

                    "Please do your payment with this link\n" +

                    paymentLink + "\n" +

                    "Team SmartDukaan";

            LOGGER.info("message- {}", message);

            notificationService.sendPaymentWhatsappMessage(paymentLinkDetailModel.getMobile(), message);

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

        kommunoService.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("%015d", newId);

        upsellCallDetail.setDiallerSessionId(sessionId);

//        fill diposition on kommuno service

        kommunoService.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.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) {

        FofoOrder fofoOrder = new FofoOrder();

        fofoOrder.setCustomerGstNumber(customerGstNumber);

        fofoOrder.setCustomerId(customerId);

        fofoOrder.setFofoId(fofoId);

        fofoOrder.setInvoiceNumber(documentNumber);

        fofoOrder.setTotalAmount(totalAmount);

        fofoOrder.setCustomerAddressId(customerAddressId);

        fofoOrderRepository.persist(fofoOrder);

        return fofoOrder;

    }

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

    }

}