Subversion Repositories SmartDukaan

package com.spice.profitmandi.web.controller;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

import com.spice.profitmandi.service.user.RetailerService;

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.stereotype.Controller;

import org.springframework.transaction.annotation.Transactional;

import org.springframework.ui.Model;

import org.springframework.util.StringUtils;

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

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

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

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

import javax.servlet.http.HttpServletRequest;

import java.time.LocalDateTime;

import java.util.*;

import java.util.stream.Collectors;

@Controller

@Transactional(rollbackFor = Throwable.class)

public class HygieneController {

    @Autowired

    private FofoOrderRepository fofoOrderRepository;

    @Autowired

    private CustomerAddressRepository customerAddressRepository;

    @Autowired

    private RetailerService retailerService;

    @Autowired

    private FofoOrderItemRepository fofoOrderItemRepository;

    @Autowired

    private HygieneDataRepository hygieneDataRepository;

    @Autowired

    private ItemRepository itemRepository;

    @Autowired

    private MVCResponseSender mvcResponseSender;

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

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

    public String getHygieneData(HttpServletRequest request, @RequestParam(name = "fofoId", required = false, defaultValue = "0") int fofoId, @RequestParam(name = "date", required = false, defaultValue = "") LocalDateTime date, @RequestParam(name = "mobileNumber", required = false, defaultValue = "") String mobileNumber, Model model) throws ProfitMandiBusinessException {

        List<HygieneData> hygieneData = new ArrayList<HygieneData>();

        List<Integer> orderIds = new ArrayList<Integer>();

        if (!StringUtils.isEmpty(mobileNumber)) {

            orderIds = hygieneDataRepository.selectHygieneByMobile(mobileNumber);

            hygieneData = hygieneDataRepository.selectByOrderIds(orderIds);

        } else if (fofoId != 0 && date != null) {

            hygieneData = hygieneDataRepository.selectAllByFofoIdDate(fofoId, date.toLocalDate());

            model.addAttribute("date", date);

        } else if (fofoId != 0) {

            hygieneData = hygieneDataRepository.selectAllByFofoIdDisposedTimestamp(fofoId);

        } else if (date != null) {

            hygieneData = hygieneDataRepository.selectAllByDate(date.toLocalDate());

            model.addAttribute("date", date);

        }

        else {

            hygieneData = hygieneDataRepository.selectByDisposedTimestamp();

        }

        LOGGER.info("hygineeDate {}", hygieneData);

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

        if (!hygieneData.isEmpty()) {

            if (StringUtils.isEmpty(mobileNumber)) {

                orderIds = hygieneData.stream().map(x -> x.getOrderId()).collect(Collectors.toList());

            }

            Map<Integer, FofoOrder> fofoOrdersMap = new HashMap<Integer, FofoOrder>();

            if (!orderIds.isEmpty()) {

                fofoOrdersMap = this.getfofoOrderByOrderId(orderIds);

            }

            Set<Integer> fofoIds = fofoOrdersMap.values().stream().map(x -> x.getFofoId()).collect(Collectors.toSet());

            Map<Integer, CustomerAddress> customerAddress = this.getCustomerAddressByFofoOrder(fofoOrdersMap.values());

            Map<Integer, CustomRetailer> customRetailerMap = retailerService.getAllFofoRetailers();

            Map<Integer, CustomRetailer> partnerAddressMap = fofoIds.stream().map(x -> customRetailerMap.get(x)).filter(x -> x != null).collect(Collectors.toList()).stream().collect(Collectors.toMap(x -> x.getPartnerId(), x -> x));

            List<HygieneData> filteredHygieneData = new ArrayList<>();

            if (!hygieneData.isEmpty()) {

                List<Integer> filteredOrderIds = fofoOrdersMap.values().stream().map(x -> x.getId()).collect(Collectors.toList());

                filteredHygieneData.addAll(hygieneData.stream().filter(x -> filteredOrderIds.contains(x.getOrderId())).collect(Collectors.toList()));

            }

            model.addAttribute("hygieneData", filteredHygieneData).addAttribute("fofoOrder", fofoOrdersMap).addAttribute("partnerAddress", partnerAddressMap).addAttribute("customerAddress", customerAddress);

        } else {

            model.addAttribute("hygieneData", hygieneData);

        }

        return "hygiene";

    }

    private Map<Integer, FofoOrder> getfofoOrderByOrderId(List<Integer> fofoOrderIds) throws ProfitMandiBusinessException {

        Map<Integer, FofoOrder> fofoOrderMap = new HashMap<>();

        List<FofoOrder> fofoOrders = fofoOrderRepository.selectAllByOrderIds(fofoOrderIds);

        for (FofoOrder fofoOrder : fofoOrders) {

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

            boolean smartPhone = false;

            for (FofoOrderItem fofoItem : fofoItems) {

                Item orderItem = itemRepository.selectById(fofoItem.getItemId());

                if (orderItem.isSmartPhone()) {

                    smartPhone = true;

                }

            }

            if (smartPhone) {

                fofoOrderMap.put(fofoOrder.getId(), fofoOrder);

            }

        }

        return fofoOrderMap;

    }

    private Map<Integer, CustomerAddress> getCustomerAddressByFofoOrder(Collection<FofoOrder> fofoOrders) throws ProfitMandiBusinessException {

        Map<Integer, CustomerAddress> customerAddressMap = new HashMap<>();

        for (FofoOrder fofoOrder : fofoOrders) {

            CustomerAddress ca = customerAddressRepository.selectById(fofoOrder.getCustomerAddressId());

            customerAddressMap.put(fofoOrder.getCustomerAddressId(), ca);

        }

        return customerAddressMap;

    }

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

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

        FofoOrder fofoOrder = null;

        CustomRetailer customRetailer = null;

        CustomerAddress customerAddress = null;

        List<FofoOrderItem> fofoOrderItems = null;

        List<HygieneData> hygiene = hygieneDataRepository.selectAllByDisposedTimestamp();

        hygiene = hygiene.stream().filter(x -> x.getNextTimestamp().isBefore(LocalDateTime.now())).collect(Collectors.toList());

        if (!hygiene.isEmpty()) {

            fofoOrder = fofoOrderRepository.selectByOrderId(hygiene.get(0).getOrderId());

            customRetailer = retailerService.getFofoRetailer(fofoOrder.getFofoId());

            customerAddress = customerAddressRepository.selectById(fofoOrder.getCustomerAddressId());

            fofoOrderItems = fofoOrderItemRepository.selectByOrderId(fofoOrder.getId());

        } else {

            HygieneData hygieneData = hygieneDataRepository.selectFirstByDisposedTimestamp();

            if (hygieneData != null) {

                fofoOrder = fofoOrderRepository.selectByOrderId(hygieneData.getOrderId());

                customerAddress = customerAddressRepository.selectById(fofoOrder.getCustomerAddressId());

                customRetailer = retailerService.getFofoRetailer(fofoOrder.getFofoId());

                fofoOrderItems = fofoOrderItemRepository.selectByOrderId(fofoOrder.getId());

                LOGGER.info("hygieneData" + hygieneData);

                LOGGER.info("fofoOrder" + fofoOrder);

                LOGGER.info("customRetailer" + customRetailer);

                LOGGER.info("customerAddress" + customerAddress);

            }

        }

        model.addAttribute("fofoOrder", fofoOrder);

        model.addAttribute("customRetailer", customRetailer);

        model.addAttribute("customerAddress", customerAddress);

        model.addAttribute("fofoOrderItems", fofoOrderItems);

        return "hygiene-modal";

    }

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

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

        FofoOrder fofoOrder = null;

        CustomRetailer customRetailer = null;

        CustomerAddress customerAddress = null;

        List<FofoOrderItem> fofoOrderItems = null;

        HygieneData hygiene = hygieneDataRepository.selectById(orderId);

        fofoOrder = fofoOrderRepository.selectByOrderId(hygiene.getOrderId());

        customerAddress = customerAddressRepository.selectById(fofoOrder.getCustomerAddressId());

        customRetailer = retailerService.getFofoRetailer(fofoOrder.getFofoId());

        fofoOrderItems = fofoOrderItemRepository.selectByOrderId(fofoOrder.getId());

        LOGGER.info("hygieneData" + hygiene);

        LOGGER.info("fofoOrder" + fofoOrder);

        LOGGER.info("customRetailer" + customRetailer);

        LOGGER.info("customerAddress" + customerAddress);

        model.addAttribute("fofoOrder", fofoOrder);

        model.addAttribute("customRetailer", customRetailer);

        model.addAttribute("customerAddress", customerAddress);

        model.addAttribute("fofoOrderItems", fofoOrderItems);

        return "hygiene-modal";

    }

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

    public String HygieneData(HttpServletRequest request, @RequestBody HygieneDataModel hygieneDataModel, Model model) throws Exception {

        HygieneData hygieneData = hygieneDataRepository.selectById(hygieneDataModel.getOrderId());

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

        LocalDateTime hygieneDateTime = hygieneData.getCreatedTimestamp().toLocalDate().atStartOfDay();

        CustomerAddress customerAddress = customerAddressRepository.selectById(fofoOrder.getCustomerAddressId());

        List<CustomerAddress> customerAddresses = customerAddressRepository.selectByMobileNumber(customerAddress.getPhoneNumber());

        LOGGER.info("Fofo id {}, Date Range = {}, Customer Address Ids  {}", fofoOrder.getFofoId(), DateRangeModel.of(hygieneDateTime, hygieneDateTime.plusDays(1)), customerAddresses.stream().map(x -> x.getId()).collect(Collectors.toList()));

        List<FofoOrder> fofoOrders = fofoOrderRepository.selectByCustomerAddressIds(fofoOrder.getFofoId(), DateRangeModel.of(hygieneDateTime, hygieneDateTime.plusDays(1)), customerAddresses.stream().map(x -> x.getId()).collect(Collectors.toList()));

        LOGGER.info("Order Size - {}", fofoOrders.size());

        for (FofoOrder fo : fofoOrders) {

            int count = 0;

            LOGGER.info("Order Id - {}", fo.getId());

            hygieneData = hygieneDataRepository.selectById(fo.getId());

            if (hygieneData == null)

                continue;

            if (hygieneDataModel.getScheduleTime() != null) {

                hygieneData.setStatus(hygieneDataModel.getStatus());

                hygieneData.setRemark(hygieneDataModel.getRemark());

                hygieneData.setHygieneRating(hygieneDataModel.getHygieneRating());

                hygieneData.setNextTimestamp(hygieneDataModel.getScheduleTime());

                hygieneDataRepository.persist(hygieneData);

            } else {

                hygieneData.setStatus(hygieneDataModel.getStatus());

                hygieneData.setRemark(hygieneDataModel.getRemark());

                hygieneData.setRating(hygieneDataModel.getRating());

                hygieneData.setHygieneRating(hygieneDataModel.getHygieneRating());

                hygieneData.setDOP(hygieneDataModel.getDOP());

                hygieneData.setFeedback(hygieneDataModel.getFeedback());

                hygieneData.setQuesPhone(hygieneDataModel.getQuesPhone());

                hygieneData.setQuesInformation(hygieneDataModel.getQuesInformation());

                hygieneData.setQuesInvoice(hygieneDataModel.getQuesInvoice());

                hygieneData.setDisposedTimestamp(LocalDateTime.now());

                hygieneData.setNextTimestamp(null);

                hygieneDataRepository.persist(hygieneData);

            }

            count = hygieneData.getCallCount();

            count = count + 1;

            hygieneData.setCallCount(count);

        }

        model.addAttribute("response1", mvcResponseSender.createResponseString(true));

        return "response";

    }

}