Subversion Repositories SmartDukaan

Rev

Rev 27876 | Go to most recent revision | View as "text/plain" | Blame | Compare with Previous | Last modification | View Log | RSS feed

package com.spice.profitmandi.web.controller;

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

import javax.servlet.http.HttpServletRequest;
import javax.transaction.Transactional;

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.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.google.gson.Gson;
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.catalog.Offer;
import com.spice.profitmandi.dao.entity.catalog.OfferPartner;
import com.spice.profitmandi.dao.entity.catalog.Offermargin;
import com.spice.profitmandi.dao.entity.fofo.PartnerType;
import com.spice.profitmandi.dao.enumuration.catalog.ItemCriteriaType;
import com.spice.profitmandi.dao.model.AmountMarginModel;
import com.spice.profitmandi.dao.model.CreateOfferRequest;
import com.spice.profitmandi.dao.model.ItemTypeParams;
import com.spice.profitmandi.dao.model.SimpleItemType;
import com.spice.profitmandi.dao.repository.catalog.ItemRepository;
import com.spice.profitmandi.dao.repository.catalog.OfferMarginRepository;
import com.spice.profitmandi.dao.repository.catalog.OfferPartnerRepository;
import com.spice.profitmandi.dao.repository.catalog.OfferRepository;
import com.spice.profitmandi.dao.repository.dtr.FofoStoreRepository;
import com.spice.profitmandi.dao.repository.dtr.Mongo;
import com.spice.profitmandi.dao.repository.fofo.PartnerTypeChangeService;
import com.spice.profitmandi.service.user.RetailerService;
import com.spice.profitmandi.web.model.LoginDetails;
import com.spice.profitmandi.web.util.CookiesProcessor;
import com.spice.profitmandi.web.util.MVCResponseSender;

@Controller
@Transactional(rollbackOn = Throwable.class)
public class OfferController {
        private static final Logger LOGGER = LogManager.getLogger(OfferController.class);
        @Autowired
        private OfferRepository offerRepository;

        @Autowired
        private OfferMarginRepository offerMarginRepository;

        @Autowired
        private FofoStoreRepository fofoStoreRepository;

        @Autowired
        private OfferPartnerRepository offerPartnerRepository;

        @Autowired
        private ItemRepository itemRepository;

        @Autowired
        private MVCResponseSender mvcResponseSender;

        @Autowired
        private Gson gson;

        @Autowired
        private RetailerService retailerService;

        @Autowired
        private Mongo mongoClient;

        @Autowired
        private CookiesProcessor cookiesProcessor;

        @Autowired
        private PartnerTypeChangeService partnerTypeChangeService;

        @RequestMapping(value = "/getCreateOffer", method = RequestMethod.GET)
        public String getCreateOffer(HttpServletRequest request, Model model) throws ProfitMandiBusinessException {
                LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
                List<Integer> fofoIds = fofoStoreRepository.selectActiveStores().stream().map(x -> x.getId())
                                .collect(Collectors.toList());

                List<String> brands = mongoClient.getMongoBrands(loginDetails.getFofoId(), null, 3).stream()
                                .map(x -> (String) x.get("name")).collect(Collectors.toList());

                Map<Integer, CustomRetailer> customRetailersMap = retailerService.getFofoRetailers(fofoIds);

                model.addAttribute("customRetailersMap", customRetailersMap);
                model.addAttribute("itemCriteriaType", ItemCriteriaType.values());
                model.addAttribute("brands", brands);
                model.addAttribute("partnerCategories", PartnerType.values());
                return "scheme_offer";

        }

        @RequestMapping(value = "/createOffer", method = RequestMethod.POST)
        public String createOffer(HttpServletRequest request, @RequestBody CreateOfferRequest createOfferRequest,
                        Model model) throws Exception {
                LOGGER.info("createOfferRequest" + createOfferRequest.getAmountOffer());

                Offer offer = new Offer();
                offer.setName(createOfferRequest.getName());
                offer.setDescription(createOfferRequest.getDescription());
                offer.setItemCreteria(createOfferRequest.getItemCriteria());
                offer.setTargetType(createOfferRequest.getTargetType());
                offer.setAmountType(createOfferRequest.getAmountType());
                offer.setStartDateTime(createOfferRequest.getStartDate());
                offer.setEndDateTime(createOfferRequest.getEndDate());
                offer.setPrice(createOfferRequest.getPrice());
                offer.setCreatedTimestamp(LocalDateTime.now());
                offer.setSchemeType(createOfferRequest.getSchemeType());
                offer.setCriteria(createOfferRequest.getCriteria());
                offer.setPartnerType(createOfferRequest.getPartnerType());

                if (createOfferRequest.getItemCriteria().equals(ItemCriteriaType.Item_Model)) {
                        ItemTypeParams itemTypeParams = new ItemTypeParams();
                        itemTypeParams.setCatalogId(createOfferRequest.getCatalogIds());
                        SimpleItemType sit = new SimpleItemType(itemTypeParams);
                        sit.setItemTypeParams(itemTypeParams);
                        offer.setItemParam(gson.toJson(itemTypeParams));
                } else if (createOfferRequest.getItemCriteria().equals(ItemCriteriaType.Multiple_Brand)) {
                        ItemTypeParams itemTypeParams = new ItemTypeParams();
                        itemTypeParams.setBrands(createOfferRequest.getBrands());
                        SimpleItemType sit = new SimpleItemType(itemTypeParams);
                        sit.setItemTypeParams(itemTypeParams);
                        offer.setItemParam(gson.toJson(itemTypeParams));
                }

                offerRepository.persist(offer);
                if (createOfferRequest.getFofoIds().isEmpty()) {
                        List<Integer> fofoIds = fofoStoreRepository.selectActiveStores().stream().map(x -> x.getId())
                                        .collect(Collectors.toList());
                        for (Integer fofoId : fofoIds) {
                                PartnerType partnerType = partnerTypeChangeService.getTypeOnDate(fofoId,
                                                offer.getStartDateTime().toLocalDate());
                                if (offer.getPartnerType().equals(partnerType)) {
                                        LOGGER.info("partnerType" + partnerType);
                                        LOGGER.info("fofoId" + fofoId);

                                        OfferPartner op = new OfferPartner();
                                        op.setFofoId(fofoId);
                                        op.setOfferId(offer.getId());
                                        offerPartnerRepository.persist(op);
                                }

                        }
                }

                else {

                        for (Integer fofoId : createOfferRequest.getFofoIds()) {
                                OfferPartner op = new OfferPartner();
                                op.setFofoId(fofoId);
                                op.setOfferId(offer.getId());
                                offerPartnerRepository.persist(op);
                        }
                }
                for (AmountMarginModel amm : createOfferRequest.getAmountOffer()) {
                        Offermargin om = new Offermargin();
                        om.setValue(amm.getValue());
                        om.setMargin(amm.getMargin());
                        om.setOfferId(offer.getId());
                        offerMarginRepository.persist(om);
                }

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

        }

        @RequestMapping(value = "/getOffers", method = RequestMethod.GET)
        public String createOffer(HttpServletRequest request, @RequestParam(name = "offset", defaultValue = "0") int offset,
                        @RequestParam(name = "limit", defaultValue = "10") int limit,
                        @RequestParam(name = "searchTerm", required = false, defaultValue = "") String searchTerm, Model model)
                        throws Exception {

                List<Offer> offers = null;
                long size = 0;

                offers = offerRepository.selectAll(offset, limit);
                size = offerRepository.selectAllCount();

                model.addAttribute("offers", offers);
                model.addAttribute("start", offset + 1);
                model.addAttribute("size", size);
                model.addAttribute("searchTerm", searchTerm);

                if (offers.size() < limit) {
                        model.addAttribute("end", offset + offers.size());
                } else {
                        model.addAttribute("end", offset + limit);
                }

                return "offer_history";

        }

        @RequestMapping(value = "/getPaginatedOffers", method = RequestMethod.GET)
        public String getPaginatedOffers(HttpServletRequest request,
                        @RequestParam(name = "offset", defaultValue = "0") int offset,
                        @RequestParam(name = "limit", defaultValue = "10") int limit, Model model)
                        throws ProfitMandiBusinessException {

                List<Offer> offers = null;
                offers = offerRepository.selectAll(offset, limit);
                model.addAttribute("offers", offers);

                return "offer_history_paginated";
        }

        @RequestMapping(value = "/searchOffer")
        public String getOfferById(HttpServletRequest request,
                        @RequestParam(name = "offset", defaultValue = "0") int offset,
                        @RequestParam(name = "limit", defaultValue = "10") int limit,
                        @RequestParam(name = "searchTerm", required = false, defaultValue = "") String searchTerm, Model model)
                        throws ProfitMandiBusinessException {
                List<Offer> offers = null;
                long size = 0;
                if (!(searchTerm.equals(""))) {
                        offers = offerRepository.selectBySearchTerm(searchTerm, offset, limit);
                        if (!(offers.size() == 0)) {
                                size = offerRepository.selectAllCount();
                                LOGGER.info("offers" + offers);
                                model.addAttribute("offers", offers);
                                model.addAttribute("start", offset + 1);
                                model.addAttribute("size", size);
                                model.addAttribute("searchTerm", searchTerm);
                                if (offers.size() < limit) {
                                        model.addAttribute("end", offset + offers.size());
                                } else {
                                        model.addAttribute("end", offset + limit);
                                }
                        } else {
                                throw new ProfitMandiBusinessException("OfferId", searchTerm, "offerId Not Found");
                        }
                } else {

                        offers = offerRepository.selectAll(offset, limit);
                        size = offerRepository.selectAllCount();

                        model.addAttribute("offers", offers);
                        model.addAttribute("start", offset + 1);
                        model.addAttribute("size", size);
                        model.addAttribute("searchTerm", searchTerm);

                        if (offers.size() < limit) {
                                model.addAttribute("end", offset + offers.size());
                        } else {
                                model.addAttribute("end", offset + limit);
                        }
                }
                return "offer_history";
        }

        @RequestMapping(value = "/updateOfferStatus", method = RequestMethod.POST)
        public String updateOfferStatus(HttpServletRequest request, @RequestParam int id, Model model) throws Exception {

                Offer offer = offerRepository.selectById(id);
                LOGGER.info("status" + offer.getStatus());

                if (offer.getStatus() == false) {
                        offer.setStatus(true);
                } else {
                        offer.setStatus(false);
                }
                offer.setCreatedTimestamp(LocalDateTime.now());
                model.addAttribute("response", mvcResponseSender.createResponseString(true));
                return "response";

        }

        @RequestMapping(value = "/getOfferMargin", method = RequestMethod.GET)
        public String getOfferMargin(HttpServletRequest request,
                        @RequestParam(name = "offerId", defaultValue = "0") int offerId, Model model) throws Exception {
                Offer offer = offerRepository.selectById(offerId);
                List<Integer> fofoIds = fofoStoreRepository.selectActiveStores().stream().map(x -> x.getId())
                                .collect(Collectors.toList());
                Map<Integer, CustomRetailer> customRetailersMap = retailerService.getFofoRetailers(fofoIds);
                List<OfferPartner> offerPartners = offerPartnerRepository.selectByOfferId(offerId);

                LOGGER.info("offerId" + offer.getId());

                Map<Integer, Double> value = offerRepository.selectSumOfferByRetailer(offer.getStartDateTime(),
                                offer.getEndDateTime(), 0, offer, true);

                LOGGER.info("value" + value);
                List<Offermargin> offerMargin = offerMarginRepository.selectByOfferId(offerId);
                Map<Integer, Double> partnerValueMap = new HashMap<>();
                Map<Integer, List<Double>> partnerMarginMap = new HashMap<Integer, List<Double>>();
                Map<Integer, Integer> shortageAmount = new HashMap<>();

                for (OfferPartner op : offerPartners) {

                        LOGGER.info("offerPartneer" + op.getFofoId());
                        if (value.containsKey(op.getFofoId())) {
                                partnerValueMap.put(op.getFofoId(), value.get(op.getFofoId()));

                        } else {
                                value.put(op.getFofoId(), 0d);

                                partnerValueMap.put(op.getFofoId(), 0d);

                        }
                        List<Double> valSetOne = new ArrayList<Double>();

                        for (Offermargin om : offerMargin) {

                                if (value.get(op.getFofoId()) <= om.getValue()) {
                                        LOGGER.info("om1" + om.getMargin());
                                        shortageAmount.put(op.getFofoId(), om.getValue() - value.get(op.getFofoId()).intValue());
                                        valSetOne.add(om.getMargin());
                                        partnerMarginMap.put(op.getFofoId(), valSetOne);

                                        break;
                                } else {
                                        LOGGER.info("om2" + om.getMargin());
                                        valSetOne.add(om.getMargin());

                                        int shortage = om.getValue() - value.get(op.getFofoId()).intValue();

                                        if (shortage < 0) {
                                                shortageAmount.put(op.getFofoId(), 0);
                                        }

                                        partnerMarginMap.put(op.getFofoId(), valSetOne);

                                }
                        }

                }

                LOGGER.info("partnerMarginMap" + partnerMarginMap);
                LOGGER.info("partnerValueMap" + partnerValueMap);
                LOGGER.info("shortageAmount" + shortageAmount);

                ItemTypeParams scp = gson.fromJson(offer.getItemParam(), ItemTypeParams.class);
                if (offer.getItemCriteria().equals(ItemCriteriaType.Multiple_Brand)) {
                        List<String> brands = scp.getBrands();
                        model.addAttribute("brands", brands);
                }
                if (offer.getItemCriteria().equals(ItemCriteriaType.Item_Model)) {
                        List<Integer> catalogIds = scp.getCatalogId();
                        List<Item> newList = new ArrayList<>();
                        Set<Integer> catalogId = new HashSet<>();
                        List<Item> items = itemRepository.selectAllByCatalogIds(catalogIds.stream().collect(Collectors.toSet()));
                        for (Item item : items) {
                                if (catalogId.add(item.getCatalogItemId())) {
                                        newList.add(item);
                                }
                        }
                        model.addAttribute("items", newList);
                }
                model.addAttribute("partnerMarginMap", partnerMarginMap);
                model.addAttribute("partnerValueMap", partnerValueMap);
                model.addAttribute("customRetailersMap", customRetailersMap);
                model.addAttribute("offerMargin", offerMargin);
                model.addAttribute("offer", offer);
                model.addAttribute("shortageAmount", shortageAmount);

                return "offer_margin_detail";

        }

        @RequestMapping(value = "/offerById", method = RequestMethod.GET)
        public String offerById(HttpServletRequest request, int offerId, Model model) throws ProfitMandiBusinessException {
                Offer offer = offerRepository.selectById(offerId);

                model.addAttribute("offer", offer);

                return "offer-edit";

        }

        @RequestMapping(value = "/extendByOfferId", method = RequestMethod.POST)
        public String extendByOfferId(HttpServletRequest request,

                        int offerId, @RequestBody LocalDateTime extendDatetime, Model model) throws Exception {

                LOGGER.info("ExtendDatetime" + extendDatetime);
                LOGGER.info("schemeId" + offerId);
                Offer offer = offerRepository.selectById(offerId);

                offer.setEndDateTime(extendDatetime);
                offerRepository.persist(offer);
                model.addAttribute("response", mvcResponseSender.createResponseString(true));
                return "response";
        }

}