Subversion Repositories SmartDukaan

package com.spice.profitmandi.web.controller;

import com.fasterxml.jackson.databind.ObjectMapper;

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

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

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

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

import com.spice.profitmandi.service.catalog.BrandsService;

import com.spice.profitmandi.service.catalog.HotDealAttributes;

import com.spice.profitmandi.service.catalog.ModelHotDealService;

import com.spice.profitmandi.dao.service.solr.FofoSolr;

import com.spice.profitmandi.web.model.LoginDetails;

import com.spice.profitmandi.web.util.CookiesProcessor;

import com.spice.profitmandi.web.util.MVCResponseSender;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

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

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

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

import javax.servlet.http.HttpServletRequest;

import java.time.LocalDate;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import java.util.Set;

import java.util.stream.Collectors;

@Controller

@Transactional(rollbackFor = Throwable.class)

public class HotDealController {

    private static final Logger LOGGER = LoggerFactory.getLogger(HotDealController.class);

    private static final int MOBILE_BRAND_CATEGORY_ID = 3;

    @Autowired

    private ModelHotDealService modelHotDealService;

    @Autowired

    private BrandsService brandsService;

    @Autowired

    private CatalogRepository catalogRepository;

    @Autowired

    private CookiesProcessor cookiesProcessor;

    @Autowired

    private MVCResponseSender mvcResponseSender;

    @Autowired

    private ObjectMapper objectMapper;

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

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

        model.addAttribute("brands", brandsService.getBrandsToDisplay(MOBILE_BRAND_CATEGORY_ID));

        model.addAttribute("maxDeals", ModelHotDealService.MAX_ACTIVE_DEALS_PER_BRAND);

        return "hot-deals";

    }

    /** All deals across brands: server-side searched + paginated table fragment. */

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

    public String getAllHotDeals(@RequestParam(defaultValue = "1") int page,

                                 @RequestParam(required = false, defaultValue = "") String q,

                                 Model model) throws Exception {

        int pageSize = 20;

        long total = modelHotDealService.countDeals(q);

        int pages = (int) Math.max(1, (total + pageSize - 1) / pageSize);

        page = Math.min(Math.max(1, page), pages);

        model.addAttribute("deals", modelHotDealService.searchDeals(q, page, pageSize));

        model.addAttribute("total", total);

        model.addAttribute("page", page);

        model.addAttribute("pages", pages);

        return "hot-deals-table";

    }

    /** Active-slot usage for a brand, e.g. "3 / 15". */

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

    public String getSlots(@RequestParam int brandId, Model model) throws Exception {

        model.addAttribute("response1", modelHotDealService.countActive(brandId)

                + " / " + ModelHotDealService.MAX_ACTIVE_DEALS_PER_BRAND);

        return "response";

    }

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

    public String getModelsForBrand(@RequestParam int brandId, Model model) throws Exception {

        List<Catalog> catalogs = catalogRepository.selectAllByBrandId(brandId);

        Set<Integer> activeIds = modelHotDealService.getDealsForBrand(brandId).stream()

                .filter(deal -> !"EXPIRED".equals(deal.getStatus()))

                .map(ModelHotDeal::getCatalogItemId)

                .collect(Collectors.toSet());

        List<Map<String, Object>> models = catalogs.stream()

                .filter(catalog -> !activeIds.contains(catalog.getId()))

                .map(catalog -> {

                    Map<String, Object> entry = new HashMap<>();

                    entry.put("catalogId", catalog.getId());

                    entry.put("description", catalog.getDescription());

                    return entry;

                })

                .collect(Collectors.toList());

        model.addAttribute("response1", objectMapper.writeValueAsString(models));

        return "response";

    }

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

    public String addHotDeal(HttpServletRequest request, @RequestParam int brandId,

                             @RequestParam int catalogItemId, @RequestParam String startDate,

                             @RequestParam String endDate,

                             @RequestParam(required = false) Integer warrantyMonths,

                             @RequestParam(required = false) String condition,

                             @RequestParam(required = false) Boolean fresh,

                             @RequestParam(required = false) Boolean financeMapping,

                             @RequestParam(required = false) Boolean affordability,

                             Model model) throws Exception {

        // required=false so a missing field reaches the service's mandatory-field

        // validation and comes back as a readable message instead of a Spring 400

        LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

        try {

            HotDealAttributes attributes = new HotDealAttributes(warrantyMonths, condition,

                    fresh, financeMapping, affordability);

            modelHotDealService.addDeal(brandId, catalogItemId, LocalDate.parse(startDate),

                    LocalDate.parse(endDate), attributes, loginDetails.getEmailId());

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

        } catch (ProfitMandiBusinessException e) {

            LOGGER.warn("Hot deal add rejected: {}", e.getMessage());

            model.addAttribute("response1", e.getMessage());

        }

        return "response";

    }

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

    public String updateHotDeal(HttpServletRequest request, @RequestParam int id,

                                @RequestParam String startDate, @RequestParam String endDate,

                                @RequestParam(required = false) Integer warrantyMonths,

                                @RequestParam(required = false) String condition,

                                @RequestParam(required = false) Boolean fresh,

                                @RequestParam(required = false) Boolean financeMapping,

                                @RequestParam(required = false) Boolean affordability,

                                Model model) throws Exception {

        LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

        try {

            HotDealAttributes attributes = new HotDealAttributes(warrantyMonths, condition,

                    fresh, financeMapping, affordability);

            modelHotDealService.updateDeal(id, LocalDate.parse(startDate), LocalDate.parse(endDate),

                    attributes, loginDetails.getEmailId());

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

        } catch (ProfitMandiBusinessException e) {

            LOGGER.warn("Hot deal update rejected: {}", e.getMessage());

            model.addAttribute("response1", e.getMessage());

        }

        return "response";

    }

    @Autowired

    private FofoSolr fofoSolr;

    /**

     * Manual, explicit Solr push for the selected deal models (Category team button).

     * Calls the indexer directly - deliberately NOT the prod-gated change event - so

     * curated models are searchable immediately without waiting for the daily sync.

     */

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

    public String pushDealsToSolr(@RequestParam String catalogIds, Model model) throws Exception {

        List<String> ok = new java.util.ArrayList<>();

        List<String> failed = new java.util.ArrayList<>();

        for (String raw : catalogIds.split(",")) {

            String id = raw.trim();

            if (id.isEmpty()) {

                continue;

            }

            try {

                fofoSolr.updateSingleCatalog(Integer.parseInt(id));

                ok.add(id);

            } catch (Exception e) {

                LOGGER.error("Manual Solr push failed for catalogId={}", id, e);

                failed.add(id + " (" + e.getMessage() + ")");

            }

        }

        String summary = "Pushed " + ok.size() + " model(s) to Solr"

                + (failed.isEmpty() ? "" : "; FAILED: " + String.join(", ", failed));

        model.addAttribute("response1", summary);

        return "response";

    }

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

    public String removeHotDeal(@RequestParam int id, Model model) throws Exception {

        try {

            modelHotDealService.removeDeal(id);

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

        } catch (ProfitMandiBusinessException e) {

            LOGGER.warn("Hot deal remove rejected: {}", e.getMessage());

            model.addAttribute("response1", e.getMessage());

        }

        return "response";

    }

}