Subversion Repositories SmartDukaan

package com.spice.profitmandi.web.controller;

import java.time.LocalDate;

import java.time.LocalDateTime;

import java.util.ArrayList;

import java.util.Collection;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import java.util.Set;

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 org.springframework.web.bind.annotation.RequestParam;

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.dtr.FofoStoreRepository;

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;

@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, Model model)

			throws ProfitMandiBusinessException {

		List<HygieneData> hygieneData = null;

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

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

		} else if (fofoId != 0) {

			hygieneData = hygieneDataRepository.selectAllByFofoIdDisposedTimestamp(fofoId);

		} else if (date != null) {

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

		}

		else {

			hygieneData = hygieneDataRepository.selectByDisposedTimestamp();

		}

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

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

		Map<Integer, FofoOrder> 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);

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

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

			}

		}

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

		return "response";

	}

}