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.common.model.ProfitMandiConstants;

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

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

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

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

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.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.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("oemBrands", modelHotDealService.oemBrandNames());

        return "hot-deals";

    }

    /**

     * Every Hot Deal-brand model, with or without an attributes row: server-side searched +

     * paginated table fragment. {@code attention} narrows to models missing attributes or an

     * OEM brand - the ones that silently drop out of the partner app's brand chips.

     */

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

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

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

                                 @RequestParam(required = false, defaultValue = "false") boolean attention,

                                 Model model) throws Exception {

        int pageSize = 20;

        long total = modelHotDealService.countDeals(q, attention);

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

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

        long[] stats = modelHotDealService.stats();

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

        model.addAttribute("oemBrands", modelHotDealService.oemBrandNames());

        model.addAttribute("statTotal", stats[0]);

        model.addAttribute("statNoAttributes", stats[1]);

        model.addAttribute("statNoOemBrand", stats[2]);

        model.addAttribute("attention", attention);

        model.addAttribute("total", total);

        model.addAttribute("page", page);

        model.addAttribute("pages", pages);

        return "hot-deals-table";

    }

    /**

     * Every Hot Deal-brand model. One brand now, and no expiry, so there is nothing to

     * filter out. No category filter either: the brand spans mobile, refurbished, earbuds

     * and LED TV, so the old mobile-only restriction would have hidden most of it.

     */

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

    public String getHotDealModels(Model model) throws Exception {

        List<Catalog> catalogs = catalogRepository.selectAllByCatalogIds(new java.util.ArrayList<>(

                catalogRepository.selectCatalogIdsByBrand(ProfitMandiConstants.HOT_DEAL_BRAND)));

        // model_name holds the original brand on Hot Deal models; offered only when it is a real brand

        Map<String, String> brandByLowerName = new HashMap<>();

        for (String brand : modelHotDealService.oemBrandNames()) {

            brandByLowerName.put(brand.toLowerCase(), brand);

        }

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

                .map(catalog -> {

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

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

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

                    // Pre-fills the OEM brand picker, which in turn scopes the OEM model autosuggest.

                    ModelHotDeal attributes = modelHotDealService.getAttributes(catalog.getId());

                    String stored = attributes == null ? null : attributes.getOemBrand();

                    String suggested = catalog.getModelName() == null ? null

                            : brandByLowerName.get(catalog.getModelName().trim().toLowerCase());

                    entry.put("oemBrand", stored != null ? stored : (suggested == null ? "" : suggested));

                    entry.put("oemBrandSuggested", stored == null && suggested != null);

                    return entry;

                })

                .collect(Collectors.toList());

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

        return "response";

    }

    /**

     * Create or update the five pill attributes for one Hot Deal model. Replaces the old

     * add/update pair: there is no date window to set and no cap to respect, so the only

     * thing left to edit is the attributes, and whether a row already exists is an

     * implementation detail the caller should not have to know.

     */

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

    public String saveAttributes(HttpServletRequest request, @RequestParam int catalogItemId,

                                 @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,

                                 @RequestParam(required = false) String oemBrand,

                                 @RequestParam(required = false) Integer oemCatalogId,

                                 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.saveAttributes(catalogItemId, attributes, oemBrand, oemCatalogId,

                    loginDetails.getEmailId());

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

        } catch (ProfitMandiBusinessException e) {

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

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

        }

        return "response";

    }

    /**

     * Catalogs under one OEM brand, for the optional channel-counterpart autosuggest.

     * Scoped to the brand the hot-deal model came from, so ops cannot map a Samsung deal

     * onto a Vivo model; the service re-checks this on save.

     */

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

    public String getOemModels(@RequestParam String brand, Model model) throws Exception {

        List<Map<String, Object>> models = new java.util.ArrayList<>();

        if (brand != null && !brand.trim().isEmpty()

                && !ProfitMandiConstants.HOT_DEAL_BRAND.equalsIgnoreCase(brand.trim())) {

            for (Catalog catalog : catalogRepository.selectAllByCatalogIds(new java.util.ArrayList<>(

                    catalogRepository.selectCatalogIdsByBrand(brand.trim())))) {

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

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

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

                models.add(entry);

            }

        }

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

        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.removeAttributes(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";

    }

}