Subversion Repositories SmartDukaan

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

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

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

import com.spice.profitmandi.service.tag.ItemTagModel;

import in.shop2020.model.v1.catalog.status;

    private SuperCatalogMappingRepository superCatalogMappingRepository;

    @Autowired

    private Mongo mongoClient;

    @Autowired

    private int mapFrontendCategoryToDb(String frontendCategoryId) {

        if ("3".equals(frontendCategoryId)) return 10006;

        try {

            return Integer.parseInt(frontendCategoryId);

        } catch (NumberFormatException e) {

            return 10006;

        }

    }

    private List<FofoCatalogResponse> getCatalogResponseFromDb(int dbCategoryId, int fofoId, int offset, int limit,

                                                                String brand, String queryTerm, int subCategoryId) throws ProfitMandiBusinessException {

        List<status> statuses = Arrays.asList(status.ACTIVE, status.PAUSED_BY_RISK, status.PARTIALLY_ACTIVE);

        List<ItemTagModel> itemTagModels = tagListingRepository.getItemTagByCategoryAndStatus(dbCategoryId, statuses);

        List<String> excludeBrands = Arrays.asList("Dummy", "FOC HANDSET", "FOC", "Live Demo");

        Map<Integer, List<ItemTagModel>> catalogGrouped = itemTagModels.stream()

                .filter(itm -> !excludeBrands.contains(itm.getItem().getBrand()))

                .filter(itm -> brand == null || brand.isEmpty() || itm.getItem().getBrand().equalsIgnoreCase(brand))

                .filter(itm -> queryTerm == null || queryTerm.isEmpty() || queryTerm.equals("null")

                        || matchesSearchQuery(itm.getItem(), queryTerm))

                .filter(itm -> subCategoryId == 0 || itm.getItem().getCategoryId() == subCategoryId)

                .collect(Collectors.groupingBy(itm -> itm.getItem().getCatalogItemId()));

        if (catalogGrouped.isEmpty()) {

            return new ArrayList<>();

        }

        Set<Integer> allItemIds = catalogGrouped.values().stream()

                .flatMap(List::stream)

                .map(itm -> itm.getItem().getId())

                .collect(Collectors.toSet());

        Map<Integer, Integer> partnerStockMap = Collections.emptyMap();

        if (fofoId > 0) {

            partnerStockMap = currentInventorySnapshotRepository.selectItemsStock(fofoId).stream()

                    .collect(Collectors.toMap(x -> x.getItemId(), x -> x.getAvailability(), (a, b) -> a));

        }

        Map<Integer, Integer> warehouseStockMap = saholicInventoryService.getTotalAvailabilityByItemIds(new ArrayList<>(allItemIds));

        Map<Integer, List<WebOffer>> webOfferMap = webOfferRepository.selectAllActiveOffers();

        List<SuperCatalogModel> superCatalogModels = superCatalogMappingRepository.selectJoinedData();

        List<SuperCatalogMapping> superCatalogs = superCatalogMappingRepository.selectAll();

        List<Integer> allCatalogIds = new ArrayList<>(catalogGrouped.keySet());

        Map<Integer, Float> cashBackCache = fofoId > 0

                ? schemeService.getCatalogSchemeCashBack(fofoId, allCatalogIds)

                : new HashMap<>();

        Map<Long, ContentPojo> imageCache = mongoClient.getEntitiesByIds(

                allCatalogIds.stream().map(Integer::longValue).collect(Collectors.toList()));

        List<FofoCatalogResponse> dealResponse = new ArrayList<>();

        for (Map.Entry<Integer, List<ItemTagModel>> entry : catalogGrouped.entrySet()) {

            int catalogId = entry.getKey();

            List<ItemTagModel> catalogItems = entry.getValue();

            Item firstItem = catalogItems.get(0).getItem();

            FofoCatalogResponse ffdr = new FofoCatalogResponse();

            ffdr.setCatalogId(catalogId);

            String title = Arrays.asList(firstItem.getBrand(), firstItem.getModelName(), firstItem.getModelNumber())

                    .stream().filter(s -> s != null && !s.isEmpty()).collect(Collectors.joining(" "));

            ffdr.setTitle(title);

            ContentPojo cachedEntity = imageCache.get((long) catalogId);

            String imageUrl = cachedEntity != null ? cachedEntity.getDefaultImageUrl() : null;

            ffdr.setImageUrl(imageUrl != null ? imageUrl : "https://images.smartdukaan.com/uploads/campaigns/" + catalogId + ".jpg");

            ffdr.setBrand(firstItem.getBrand());

            ffdr.setIsSmartPhone(firstItem.isSmartPhone());

            ffdr.setFeature(null);

            Optional<SuperCatalogModel> scMapping = superCatalogModels.stream()

                    .filter(m -> m.getCatalogId() == catalogId).findFirst();

            if (scMapping.isPresent()) {

                ffdr.setSuperCatalogId(scMapping.get().getSuperCatalogId());

                ffdr.setSuperCatalogTitle(scMapping.get().getSuperCatalogName());

                ffdr.setSuperCatalogVariants(buildVariantsJson(superCatalogs, scMapping.get().getSuperCatalogId(), itemTagModels));

            } else {

                ffdr.setSuperCatalogId(0);

                ffdr.setSuperCatalogTitle(title);

                ffdr.setSuperCatalogVariants("[]");

            }

            List<WebOffer> webOffers = webOfferMap.get(catalogId);

            if (webOffers != null && !webOffers.isEmpty()) {

                ffdr.setOffers(webOffers.stream().map(x -> x.getTitle()).collect(Collectors.toList()));

            }

            Map<Integer, FofoAvailabilityInfo> fofoAvailabilityInfoMap = new HashMap<>();

            for (ItemTagModel itm : catalogItems) {

                Item item = itm.getItem();

                TagListing tl = itm.getTagListing();

                int itemId = item.getId();

                float sellingPrice = tl.getSellingPrice();

                if (fofoAvailabilityInfoMap.containsKey(itemId)) {

                    if (fofoAvailabilityInfoMap.get(itemId).getSellingPrice() > sellingPrice) {

                        fofoAvailabilityInfoMap.get(itemId).setSellingPrice(sellingPrice);

                        fofoAvailabilityInfoMap.get(itemId).setMop(tl.getMop());

                    }

                } else {

                    FofoAvailabilityInfo fdi = new FofoAvailabilityInfo();

                    fdi.setSellingPrice(sellingPrice);

                    fdi.setMrp(tl.getMrp());

                    fdi.setMop(tl.getMop());

                    fdi.setColor(item.getColor() != null ? item.getColor().replace("f_", "") : "");

                    fdi.setTagId(tl.getTagId());

                    fdi.setItem_id(itemId);

                    fdi.setCatalog_id(catalogId);

                    Float cb = cashBackCache.get(catalogId);

                    fdi.setCashback(cb != null ? cb : 0f);

                    fdi.setMinBuyQuantity(1);

                    int partnerAvailability = partnerStockMap.getOrDefault(itemId, 0);

                    int ourStockAvailability = Math.max(0, warehouseStockMap.getOrDefault(itemId, 0));

                    fdi.setActive(partnerAvailability > 0);

                    fdi.setPartnerAvailability(partnerAvailability);

                    fdi.setAvailability(Math.min(5, ourStockAvailability + partnerAvailability));

                    fdi.setQuantityStep(1);

                    fdi.setMaxQuantity(fdi.getAvailability());

                    fofoAvailabilityInfoMap.put(itemId, fdi);

                }

            }

            if (!fofoAvailabilityInfoMap.isEmpty()) {

                ffdr.setItems(fofoAvailabilityInfoMap.values().stream()

                        .sorted(Comparator.comparing(FofoAvailabilityInfo::isActive, Comparator.reverseOrder())

                                .thenComparingInt(y -> -y.getAvailability()))

                        .collect(Collectors.toList()));

                dealResponse.add(ffdr);

            }

        }

        dealResponse.sort(Comparator.comparing(FofoCatalogResponse::getItems,

                (s1, s2) -> (s2.get(0).isActive() ? 1 : 0) - (s1.get(0).isActive() ? 1 : 0))

                .thenComparing(FofoCatalogResponse::getItems,

                        (x, y) -> y.get(0).getAvailability() - x.get(0).getAvailability()));

        int start = Math.min(offset, dealResponse.size());

        int end = Math.min(offset + limit, dealResponse.size());

        return dealResponse.subList(start, end);

    }

    private boolean matchesSearchQuery(Item item, String query) {

        String q = query.toLowerCase();

        String searchable = String.join(" ",

                item.getBrand() != null ? item.getBrand() : "",

                item.getModelName() != null ? item.getModelName() : "",

                item.getModelNumber() != null ? item.getModelNumber() : "",

                item.getColor() != null ? item.getColor() : "").toLowerCase();

        for (String term : q.split("\\s+")) {

            if (!searchable.contains(term)) return false;

        }

        return true;

    }

    private String buildVariantsJson(List<SuperCatalogMapping> superCatalogs, int superCatalogId, List<ItemTagModel> itemTagModels) {

        List<Map<String, Object>> variantList = new ArrayList<>();

        List<SuperCatalogMapping> matchingVariants = superCatalogs.stream()

                .filter(m -> m.getSuperCatalogId() == superCatalogId)

                .collect(Collectors.toList());

        for (SuperCatalogMapping variant : matchingVariants) {

            if (variant.getVariantName() == null) continue;

            boolean hasActiveTag = itemTagModels.stream()

                    .anyMatch(tag -> tag.getItem().getCatalogItemId() == variant.getCatalogId() && tag.getTagListing().isActive());

            if (!hasActiveTag) continue;

            ItemTagModel tagModel = itemTagModels.stream()

                    .filter(tag -> tag.getItem().getCatalogItemId() == variant.getCatalogId())

                    .findFirst().orElse(null);

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

            variantObj.put("catalogId", variant.getCatalogId());

            variantObj.put("variantName", variant.getVariantName());

            variantObj.put("mrp", tagModel != null ? tagModel.getTagListing().getMrp() : 0.0);

            variantObj.put("mop", tagModel != null ? tagModel.getTagListing().getMop() : 0.0);

            variantObj.put("sellingPrice", tagModel != null ? tagModel.getTagListing().getSellingPrice() : 0.0);

            variantList.add(variantObj);

        }

        if (variantList.isEmpty()) return "[]";

        return new Gson().toJson(variantList);

    }