Subversion Repositories SmartDukaan

package com.spice.profitmandi.web.controller;

import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

import javax.servlet.http.HttpServletRequest;

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.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;

import com.spice.profitmandi.common.exception.ProfitMandiBusinessException;
import com.spice.profitmandi.common.model.CustomRetailer;
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.repository.catalog.HygieneDataModel;
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.dao.repository.user.AddressRepository;
import com.spice.profitmandi.dao.repository.user.UserRepository;
import com.spice.profitmandi.service.user.RetailerService;
import com.spice.profitmandi.web.util.MVCResponseSender;

@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 MVCResponseSender mvcResponseSender;
        private static final Logger LOGGER = LogManager.getLogger(HygieneController.class);

        @RequestMapping(value = "/getHygieneData", method = RequestMethod.GET)
        public String getHygieneData(HttpServletRequest request, Model model) throws ProfitMandiBusinessException {
                List<Integer> OrderIds = hygieneDataRepository.selectByDisposedTimestamp().stream().map(x -> x.getOrderId())
                                .collect(Collectors.toList());
                List<HygieneData> hygieneData = hygieneDataRepository.selectByDisposedTimestamp();
                List<FofoOrder> fofoOrders = this.getfofoOrderByOrderId(hygieneData);

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

                Map<Integer, CustomRetailer> partnerAddress = this.getAddressByFofoOrder(fofoOrders);
                model.addAttribute("hygieneData", hygieneData);
                model.addAttribute("fofoOrders", fofoOrders);
                model.addAttribute("partnerAddress", partnerAddress);
                model.addAttribute("customerAddress", customerAddress);

                LOGGER.info("hygieneData" + OrderIds);
                LOGGER.info("fofoOrder" + fofoOrders);
                LOGGER.info("customRetailer" + partnerAddress);
                LOGGER.info("customerAddress" + customerAddress);

                return "hygiene";
        }

        private List<FofoOrder> getfofoOrderByOrderId(List<HygieneData> hygienesData) throws ProfitMandiBusinessException {
                List<FofoOrder> fofoOrders = new ArrayList<>();
                for (HygieneData hygieneData : hygienesData) {
                        FofoOrder fofoOrder = fofoOrderRepository.selectByOrderId(hygieneData.getOrderId());
                        fofoOrders.add(fofoOrder);

                }
                return fofoOrders;
        }

        private Map<Integer, CustomRetailer> getAddressByFofoOrder(List<FofoOrder> fofoOrders)
                        throws ProfitMandiBusinessException {
                Map<Integer, CustomRetailer> addressMap = new HashMap<>();
                for (FofoOrder fofoOrder : fofoOrders) {
                        CustomRetailer customRetailer = retailerService.getFofoRetailer(fofoOrder.getFofoId());
                        addressMap.put(fofoOrder.getFofoId(), customRetailer);

                }
                return addressMap;
        }

        private Map<Integer, CustomerAddress> getCustomerAddressByFofoOrder(List<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 = "/hygieneData", method = RequestMethod.POST)
        public String HygieneData(HttpServletRequest request, @RequestBody HygieneDataModel hygieneDataModel, Model model)
                        throws Exception {
                HygieneData hygieneData = hygieneDataRepository.selectById(hygieneDataModel.getOrderId());
                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);
                }

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

                return "response";
        }

}