Subversion Repositories SmartDukaan

Rev

Rev 31992 | Rev 32023 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
27877 amit.gupta 1 
package com.spice.profitmandi.service.offers;
2 
 
29783 amit.gupta 3 
import com.google.common.collect.Lists;
27877 amit.gupta 4 
import com.google.gson.Gson;
5 
import com.spice.profitmandi.common.exception.ProfitMandiBusinessException;
29683 amit.gupta 6 
import com.spice.profitmandi.common.model.PartnerTargetModel;
7 
import com.spice.profitmandi.common.model.ProfitMandiConstants;
31920 amit.gupta 8 
import com.spice.profitmandi.common.util.Utils;
27877 amit.gupta 9 
import com.spice.profitmandi.dao.entity.catalog.ItemCriteria;
10 
import com.spice.profitmandi.dao.entity.catalog.Offer;
29783 amit.gupta 11 
import com.spice.profitmandi.dao.entity.catalog.TagListing;
31903 amit.gupta 12 
import com.spice.profitmandi.dao.entity.catalog.TargetSlabEntity;
31920 amit.gupta 13 
import com.spice.profitmandi.dao.entity.fofo.FofoLineItem;
14 
import com.spice.profitmandi.dao.entity.fofo.FofoOrderItem;
31205 amit.gupta 15 
import com.spice.profitmandi.dao.entity.fofo.InventoryItem;
16 
import com.spice.profitmandi.dao.entity.fofo.OfferPayout;
31920 amit.gupta 17 
import com.spice.profitmandi.dao.entity.transaction.LineItem;
18 
import com.spice.profitmandi.dao.entity.transaction.Order;
31747 amit.gupta 19 
import com.spice.profitmandi.dao.entity.transaction.UserWalletHistory;
31920 amit.gupta 20 
import com.spice.profitmandi.dao.entity.warehouse.WarehouseInventoryItem;
21 
import com.spice.profitmandi.dao.entity.warehouse.WarehouseScan;
22 
import com.spice.profitmandi.dao.enumuration.catalog.AchievementType;
29783 amit.gupta 23 
import com.spice.profitmandi.dao.enumuration.catalog.AmountType;
29499 amit.gupta 24 
import com.spice.profitmandi.dao.enumuration.catalog.OfferSchemeType;
31205 amit.gupta 25 
import com.spice.profitmandi.dao.enumuration.transaction.SchemePayoutStatus;
31903 amit.gupta 26 
import com.spice.profitmandi.dao.model.AmountModel;
27877 amit.gupta 27 
import com.spice.profitmandi.dao.model.CreateOfferRequest;
28 
import com.spice.profitmandi.dao.model.ItemCriteriaPayout;
31920 amit.gupta 29 
import com.spice.profitmandi.dao.model.OfferRowModel;
30066 amit.gupta 30 
import com.spice.profitmandi.dao.repository.catalog.*;
31920 amit.gupta 31 
import com.spice.profitmandi.dao.repository.fofo.ActivatedImeiRepository;
32 
import com.spice.profitmandi.dao.repository.fofo.InventoryItemRepository;
31205 amit.gupta 33 
import com.spice.profitmandi.dao.repository.fofo.OfferPayoutRepository;
31920 amit.gupta 34 
import com.spice.profitmandi.dao.repository.transaction.LineItemImeisRepository;
35 
import com.spice.profitmandi.dao.repository.warehouse.WarehouseInventoryItemRepository;
36 
import com.spice.profitmandi.dao.repository.warehouse.WarehouseScanRepository;
37 
import com.spice.profitmandi.service.pricecircular.PriceCircularService;
38 
import com.spice.profitmandi.service.scheme.InventoryPayoutModel;
27877 amit.gupta 39 
import com.spice.profitmandi.service.user.RetailerService;
31205 amit.gupta 40 
import com.spice.profitmandi.service.wallet.WalletService;
41 
import in.shop2020.model.v1.order.WalletReferenceType;
30066 amit.gupta 42 
import org.apache.logging.log4j.LogManager;
43 
import org.apache.logging.log4j.Logger;
44 
import org.apache.poi.ss.usermodel.Cell;
45 
import org.apache.poi.ss.usermodel.CellType;
46 
import org.apache.poi.ss.usermodel.Row;
47 
import org.apache.poi.ss.usermodel.Row.MissingCellPolicy;
48 
import org.apache.poi.xssf.usermodel.XSSFRow;
49 
import org.apache.poi.xssf.usermodel.XSSFSheet;
50 
import org.apache.poi.xssf.usermodel.XSSFWorkbook;
51 
import org.springframework.beans.factory.annotation.Autowired;
52 
import org.springframework.cache.CacheManager;
53 
import org.springframework.cache.annotation.Cacheable;
54 
import org.springframework.stereotype.Component;
27877 amit.gupta 55 
 
30066 amit.gupta 56 
import java.io.IOException;
57 
import java.io.InputStream;
58 
import java.time.LocalDate;
31205 amit.gupta 59 
import java.time.LocalDateTime;
30066 amit.gupta 60 
import java.time.YearMonth;
61 
import java.util.*;
62 
import java.util.stream.Collectors;
63 
 
27877 amit.gupta 64 
@Component
65 
public class OfferServiceImpl implements OfferService {
66 
 
31747 amit.gupta 67 
    private static final List<String> targets = Arrays.asList("Target 1", "Target 2", "Target 3", "Target 4",
68 
            "Target 5");
29499 amit.gupta 69 
 
31747 amit.gupta 70 
    @Autowired
71 
    private Gson gson;
27877 amit.gupta 72 
 
31747 amit.gupta 73 
    @Autowired
74 
    private OfferRepository offerRepository;
27877 amit.gupta 75 
 
31747 amit.gupta 76 
    @Autowired
77 
    private RetailerService retailerService;
31920 amit.gupta 78 
    @Autowired
79 
    PriceCircularService priceCircularService;
27877 amit.gupta 80 
 
31747 amit.gupta 81 
    @Autowired
82 
    OfferPayoutRepository offerPayoutRepository;
31205 amit.gupta 83 
 
31747 amit.gupta 84 
    @Autowired
85 
    private ItemCriteriaRepository itemCriteriaRepository;
27877 amit.gupta 86 
 
31747 amit.gupta 87 
    @Autowired
88 
    private ItemRepository itemRepository;
27877 amit.gupta 89 
 
31747 amit.gupta 90 
    @Autowired
91 
    private TagListingRepository tagListingRepository;
29783 amit.gupta 92 
 
31747 amit.gupta 93 
    @Autowired
94 
    private OfferTargetSlabRepository offerTargetSlabRepository;
30684 amit.gupta 95 
 
31747 amit.gupta 96 
    @Autowired
97 
    CacheManager thirtyMinsTimeOutCacheManager;
27877 amit.gupta 98 
 
29806 amit.gupta 99 
 
31747 amit.gupta 100 
    private static final Logger LOGGER = LogManager.getLogger(OfferServiceImpl.class);
27877 amit.gupta 101 
 
31920 amit.gupta 102 
    @Autowired
103 
    private ActivatedImeiRepository activatedImeiRepository;
104 
    @Autowired
105 
    private WarehouseScanRepository warehouseScanRepository;
106 
 
107 
    @Autowired
108 
    private WarehouseInventoryItemRepository warehouseInventoryItemRepository;
109 
 
110 
    @Autowired
111 
    private LineItemImeisRepository lineItemImeisRepository;
112 
    @Autowired
113 
    private InventoryItemRepository inventoryItemRepository;
114 
 
31747 amit.gupta 115 
    @Override
116 
    public void addOfferService(CreateOfferRequest createOfferRequest) throws ProfitMandiBusinessException {
117 
        LOGGER.info("createOfferRequest  -- {}", createOfferRequest);
118 
        this.createOffer(createOfferRequest);
119 
        this.createTargetSlabs(createOfferRequest);
120 
    }
27877 amit.gupta 121 
 
31747 amit.gupta 122 
    private void createOffer(CreateOfferRequest createOfferRequest) {
123 
        Offer offer = new Offer();
124 
        offer.setName(createOfferRequest.getName());
125 
        offer.setTargetType(createOfferRequest.getTargetType());
126 
        offer.setBooster(createOfferRequest.isBooster());
127 
        offer.setPayoutType(createOfferRequest.getPayoutType());
128 
        offer.setSchemeType(createOfferRequest.getSchemeType());
129 
        offer.setBaseCriteia(createOfferRequest.isBaseCriteria());
130 
        offer.setEndDate(createOfferRequest.getEndDate());
131 
        offer.setStartDate(createOfferRequest.getStartDate());
132 
        offer.setBrandSharePercentage(createOfferRequest.getBrandShareTerms());
133 
        offer.setSellinPercentage(createOfferRequest.getSellinPercentage());
134 
        offer.setOfferNotes(createOfferRequest.getOfferNotes());
135 
        offer.setActivationBrands(createOfferRequest.getActivationBrands());
136 
        offer.setTerms(createOfferRequest.getTerms());
137 
        offer.setItemCriteria(gson.toJson(createOfferRequest.getItemCriteria()));
138 
        offer.setPartnerCriteria(gson.toJson(createOfferRequest.getPartnerCriteria()));
139 
        offerRepository.persist(offer);
140 
        createOfferRequest.setId(offer.getId());
141 
    }
27877 amit.gupta 142 
 
31747 amit.gupta 143 
    @Override
144 
    public List<CreateOfferRequest> getPublishedOffers(int fofoId, YearMonth yearMonth) {
145 
        List<Offer> publishedOffers = offerRepository.selectAllPublishedMapByPartner(yearMonth).get(fofoId);
146 
        List<CreateOfferRequest> createOfferRequests = new ArrayList<>();
147 
        if (publishedOffers != null) {
148 
            for (Offer offer : publishedOffers) {
149 
                CreateOfferRequest createOfferRequest = this.getCreateOfferRequest(offer);
150 
                createOfferRequests.add(createOfferRequest);
151 
                setCriteriaPayoutAchieved(fofoId, createOfferRequest);
27877 amit.gupta 152 
 
31747 amit.gupta 153 
            }
154 
        }
155 
        return createOfferRequests;
156 
    }
27877 amit.gupta 157 
 
31747 amit.gupta 158 
    private void setCriteriaPayoutAchieved(int fofoId, CreateOfferRequest createOfferRequest) {
159 
        Map<Integer, Long> criteriaTransactionMap = null;
160 
        if (createOfferRequest.getSchemeType().equals(OfferSchemeType.SELLIN)) {
161 
            criteriaTransactionMap = offerRepository.getPartnerWisePurchaseSum(createOfferRequest).get(fofoId);
162 
        } else {
163 
            criteriaTransactionMap = offerRepository.getPartnerWiseSalesSum(createOfferRequest).get(fofoId);
164 
        }
165 
        LOGGER.info("I am here ------- {}", createOfferRequest.getId());
166 
        List<com.spice.profitmandi.dao.model.ItemCriteriaPayout> itemCriteriaPayouts = createOfferRequest
167 
                .getTargetSlabs().get(0).getItemCriteriaPayouts();
27877 amit.gupta 168 
 
31747 amit.gupta 169 
        for (com.spice.profitmandi.dao.model.ItemCriteriaPayout itemCriteriaPayout : itemCriteriaPayouts) {
170 
            itemCriteriaPayout.setNextSlab(null);
171 
            LOGGER.info("I am here --- {}", itemCriteriaPayout.getPayoutSlabs());
172 
            long saleAmount = 0;
173 
            if (criteriaTransactionMap != null
174 
                    && criteriaTransactionMap.containsKey(itemCriteriaPayout.getItemCriteria().getId())) {
31853 amit.gupta 175 
                saleAmount = criteriaTransactionMap.containsKey(0) ? criteriaTransactionMap.get(0) : criteriaTransactionMap.get(itemCriteriaPayout.getItemCriteria().getId());
31747 amit.gupta 176 
            }
177 
            itemCriteriaPayout.setAchievedValue(saleAmount);
178 
            List<com.spice.profitmandi.service.offers.PayoutSlab> payoutSlabs = itemCriteriaPayout.getPayoutSlabs();
179 
            for (int i = 0; i < payoutSlabs.size(); i++) {
180 
                com.spice.profitmandi.service.offers.PayoutSlab beginSlab = payoutSlabs.get(i);
181 
                com.spice.profitmandi.service.offers.PayoutSlab endSlab = null;
182 
                if (payoutSlabs.size() - 1 > i) {
183 
                    endSlab = payoutSlabs.get(i + 1);
184 
                }
185 
                if (beginSlab.getOnwardsAmount() > saleAmount) {
186 
                    itemCriteriaPayout.setShortValue(beginSlab.getOnwardsAmount() - saleAmount);
187 
                    itemCriteriaPayout.setNextSlab(beginSlab);
188 
                    LOGGER.info("I am here");
189 
                    break;
190 
                }
191 
                if (endSlab != null) {
192 
                    if (beginSlab.getOnwardsAmount() <= saleAmount && endSlab.getOnwardsAmount() > saleAmount) {
193 
                        itemCriteriaPayout.setCurrentSlab(beginSlab);
194 
                        beginSlab.setSelected(true);
195 
                        itemCriteriaPayout.setNextSlab(endSlab);
196 
                        itemCriteriaPayout.setShortValue(endSlab.getOnwardsAmount() - saleAmount);
197 
                        LOGGER.info("I am here");
198 
                        break;
199 
                    }
200 
                    // Last loop
201 
                } else {
202 
                    beginSlab.setSelected(true);
203 
                    itemCriteriaPayout.setCurrentSlab(beginSlab);
204 
                    LOGGER.info("I am here");
205 
                }
206 
            }
207 
            LOGGER.info("I am here --- {}", itemCriteriaPayout);
208 
        }
29783 amit.gupta 209 
 
31747 amit.gupta 210 
    }
27877 amit.gupta 211 
 
31747 amit.gupta 212 
    @Override
213 
    @Cacheable(value = "allOffers", cacheManager = "thirtyMinsTimeOutCacheManager")
214 
    public Map<Integer, CreateOfferRequest> getAllOffers(YearMonth yearMonth) {
215 
        List<Offer> allOffers = offerRepository.selectAll(yearMonth, false);
216 
        List<CreateOfferRequest> createOfferRequests = new ArrayList<>();
217 
        for (Offer offer : allOffers) {
218 
            CreateOfferRequest createOfferRequest = this.getCreateOfferRequest(offer);
219 
            createOfferRequests.add(createOfferRequest);
220 
        }
221 
        return createOfferRequests.stream().collect(Collectors.toMap(CreateOfferRequest::getId, x -> x));
222 
    }
27877 amit.gupta 223 
 
31747 amit.gupta 224 
    @Override
225 
    @Cacheable(value = "partnerOffers", cacheManager = "thirtyMinsTimeOutCacheManager")
226 
    public CreateOfferRequest getOffer(int fofoId, int offerId) {
227 
        Offer offer = offerRepository.selectById(offerId);
228 
        CreateOfferRequest createOfferRequest = this.getCreateOfferRequest(offer);
229 
        if (fofoId > 0) {
230 
            this.setCriteriaPayoutAchieved(fofoId, createOfferRequest);
231 
        }
29783 amit.gupta 232 
 
31747 amit.gupta 233 
        return createOfferRequest;
234 
    }
27877 amit.gupta 235 
 
31747 amit.gupta 236 
    @Override
237 
    public CreateOfferRequest getCreateOfferRequest(Offer fromOffer) {
238 
        CreateOfferRequest createOfferRequest = new CreateOfferRequest();
239 
        createOfferRequest.setName(fromOffer.getName());
240 
        createOfferRequest.setTargetType(fromOffer.getTargetType());
241 
        createOfferRequest.setPayoutType(fromOffer.getPayoutType());
242 
        createOfferRequest.setSchemeType(fromOffer.getSchemeType());
243 
        createOfferRequest.setActivationBrands(fromOffer.getActivationBrands());
244 
        createOfferRequest.setEndDate(fromOffer.getEndDate());
245 
        createOfferRequest.setProcessTimestamp(fromOffer.getProcessedTimestamp());
246 
        createOfferRequest.setStartDate(fromOffer.getStartDate());
247 
        createOfferRequest.setBooster(fromOffer.isBooster());
248 
        createOfferRequest.setActive(fromOffer.isActive());
249 
        createOfferRequest.setSellinPercentage(fromOffer.getSellinPercentage());
250 
        createOfferRequest.setBrandShareTerms(fromOffer.getBrandSharePercentage());
251 
        createOfferRequest.setOfferNotes(fromOffer.getOfferNotes());
252 
        createOfferRequest.setTerms(fromOffer.getTerms());
253 
        createOfferRequest.setBaseCriteria(fromOffer.isBaseCriteia());
254 
        createOfferRequest.setItemCriteria(
255 
                gson.fromJson(fromOffer.getItemCriteria(), com.spice.profitmandi.service.offers.ItemCriteria.class));
256 
        createOfferRequest.setPartnerCriteria(gson.fromJson(fromOffer.getPartnerCriteria(), PartnerCriteria.class));
257 
        createOfferRequest.setId(fromOffer.getId());
258 
        createOfferRequest.setCreatedOn(fromOffer.getCreatedTimestamp());
259 
        createOfferRequest.setItemCriteriaString(
260 
                itemCriteriaRepository.getItemCriteriaDescription(createOfferRequest.getItemCriteria()));
261 
        List<com.spice.profitmandi.dao.model.TargetSlab> targetSlabs = offerTargetSlabRepository
262 
                .getByOfferId(fromOffer.getId());
263 
        createOfferRequest.setPartnerCriteriaString(
264 
                retailerService.getPartnerCriteriaString(createOfferRequest.getPartnerCriteria()));
265 
        createOfferRequest.setTargetSlabs(targetSlabs);
266 
        for (com.spice.profitmandi.dao.model.ItemCriteriaPayout itemCriteriaPayout : createOfferRequest.getTargetSlabs()
267 
                .get(0).getItemCriteriaPayouts()) {
268 
            itemCriteriaPayout.setNextSlab(itemCriteriaPayout.getPayoutSlabs().get(0));
269 
        }
270 
        return createOfferRequest;
27877 amit.gupta 271 
 
31747 amit.gupta 272 
    }
27877 amit.gupta 273 
 
31747 amit.gupta 274 
    @Autowired
275 
    private WalletService walletService;
31205 amit.gupta 276 
 
31747 amit.gupta 277 
    @Override
278 
    public void reverseAdditionalSelloutSchemes(int fofoId, List<InventoryItem> inventoryItems) throws ProfitMandiBusinessException {
279 
        List<OfferPayout> offerPayouts = new ArrayList<>();
31748 amit.gupta 280 
        LOGGER.info("Reversing schemes for fofoId {}, InventoryItems {}", fofoId, inventoryItems);
31747 amit.gupta 281 
        //As of now we are not handling non-serialised items
282 
        inventoryItems = inventoryItems.stream().filter(x -> x.getSerialNumber() != null).collect(Collectors.toList());
31750 amit.gupta 283 
        if (inventoryItems.size() > 0) {
31205 amit.gupta 284 
 
31750 amit.gupta 285 
            for (InventoryItem inventoryItem : inventoryItems) {
286 
                offerPayouts.addAll(offerPayoutRepository.selectAllBySerialNumber(inventoryItem.getFofoId(), inventoryItem.getSerialNumber())
287 
                        .stream()
288 
                        .filter(x -> x.getRejectTimestamp() == null)
289 
                        .collect(Collectors.toList()));
31747 amit.gupta 290 
            }
31750 amit.gupta 291 
            for (OfferPayout offerPayout : offerPayouts) {
292 
                offerPayout.setStatus(SchemePayoutStatus.REJECTED);
293 
                offerPayout.setRejectTimestamp(LocalDateTime.now());
294 
            }
295 
            Map<Long, Double> offerPayoutAmountMap = offerPayouts.stream().collect(Collectors.groupingBy(x -> x.getOfferId(), Collectors.summingDouble(x -> x.getAmount())));
296 
            for (Map.Entry<Long, Double> offerPayoutEntry : offerPayoutAmountMap.entrySet()) {
297 
                List<UserWalletHistory> histories = walletService.getAllByReference(fofoId, offerPayoutEntry.getKey().intValue(), WalletReferenceType.ADDITIONAL_SCHEME);
298 
                if (histories.size() > 0) {
299 
 
300 
                    walletService.rollbackAmountFromWallet(fofoId, offerPayoutEntry.getValue().floatValue(), offerPayoutEntry.getKey().intValue(),
301 
                            WalletReferenceType.ADDITIONAL_SCHEME, "Models/Imeis for corresponding schemes were returned", LocalDateTime.now());
302 
                }
303 
            }
31747 amit.gupta 304 
        }
305 
    }
30684 amit.gupta 306 
 
31747 amit.gupta 307 
    private void createTargetSlabs(CreateOfferRequest createOfferRequest) throws ProfitMandiBusinessException {
308 
        List<com.spice.profitmandi.dao.model.TargetSlab> targetSlabs = createOfferRequest.getTargetSlabs().stream()
309 
                .filter(x -> x.validate()).collect(Collectors.toList());
310 
        if (targetSlabs.size() >= 0) {
311 
            Collections.sort(targetSlabs);
312 
            for (com.spice.profitmandi.dao.model.TargetSlab targetSlab : targetSlabs) {
313 
                if (targetSlab.validate()) {
314 
                    List<ItemCriteriaPayout> itemCriteriaPayouts = targetSlab.getItemCriteriaPayouts();
315 
                    for (ItemCriteriaPayout itemCriteriaPayout : itemCriteriaPayouts) {
316 
                        ItemCriteria itemCriteria = itemCriteriaRepository.selectById(itemCriteriaPayout.getItemCriteria().getId());
317 
                        if (itemCriteriaPayout.getItemCriteria().getId() > 0) {
318 
                            itemCriteriaPayout.getItemCriteria().setId(0);
319 
                        } else {
27877 amit.gupta 320 
 
31747 amit.gupta 321 
                            String itemCriteriaJson = gson.toJson(itemCriteriaPayout.getItemCriteria());
322 
                            itemCriteria = itemCriteriaRepository.selectByCriteria(itemCriteriaJson);
323 
                            // ItemCriteria Only once
324 
                            if (itemCriteria == null) {
325 
                                itemCriteria = new ItemCriteria();
326 
                                itemCriteria.setCriteria(gson.toJson(itemCriteriaPayout.getItemCriteria()));
327 
                                itemCriteriaRepository.persist(itemCriteria);
328 
                            }
329 
                        }
330 
                        for (PayoutSlab payoutSlab : itemCriteriaPayout.getPayoutSlabs()) {
31903 amit.gupta 331 
                            TargetSlabEntity targetSlabEntity = new TargetSlabEntity();
332 
                            targetSlabEntity.setOfferId(createOfferRequest.getId());
333 
                            targetSlabEntity.setOnwardsTarget(targetSlab.getOnwardsAmount());
334 
                            targetSlabEntity.setTargetDescription(targetSlab.getTargetDescription());
335 
                            targetSlabEntity.setPayoutTarget(payoutSlab.getOnwardsAmount());
336 
                            targetSlabEntity.setPayoutValue(payoutSlab.getPayoutAmount());
337 
                            targetSlabEntity.setItemCriteriaId(itemCriteria.getId());
338 
                            targetSlabEntity.setAmountType(itemCriteriaPayout.getAmountType());
339 
                            offerTargetSlabRepository.persist(targetSlabEntity);
31747 amit.gupta 340 
                        }
341 
                    }
342 
                }
343 
            }
27877 amit.gupta 344 
 
31747 amit.gupta 345 
        } else {
346 
            throw new ProfitMandiBusinessException("Invalid Target Slabs", "Invalid Target", "");
347 
        }
27877 amit.gupta 348 
 
31747 amit.gupta 349 
    }
27877 amit.gupta 350 
 
31747 amit.gupta 351 
    @Override
352 
    public List<CreateOfferRequest> getPublishedOffers(LocalDate date, int fofoId, int catalogId) {
353 
        List<Offer> publishedOffers = offerRepository.selectAllPublishedMapByPartner(YearMonth.from(date)).get(fofoId);
354 
        List<CreateOfferRequest> createOfferRequests = new ArrayList<>();
355 
        if (publishedOffers != null) {
356 
            for (Offer offer : publishedOffers) {
357 
                boolean found = false;
358 
                List<com.spice.profitmandi.dao.model.TargetSlab> targetSlabs = offerTargetSlabRepository
359 
                        .getByOfferId(offer.getId());
360 
                CreateOfferRequest createOfferRequest = this.getCreateOfferRequest(offer);
361 
                createOfferRequest.setTargetSlabs(targetSlabs);
362 
                this.setCriteriaPayoutAchieved(fofoId, createOfferRequest);
363 
                Set<com.spice.profitmandi.service.offers.ItemCriteria> itemCriteriaSet = targetSlabs.stream()
364 
                        .flatMap(x -> x.getItemCriteriaPayouts().stream()).map(x -> x.getItemCriteria()).distinct()
365 
                        .filter(x -> itemRepository.containsModel(x, catalogId)).collect(Collectors.toSet());
29499 amit.gupta 366 
 
31747 amit.gupta 367 
                for (com.spice.profitmandi.dao.model.TargetSlab targetSlab : targetSlabs) {
368 
                    targetSlab.setItemCriteriaPayouts(targetSlab.getItemCriteriaPayouts().stream()
369 
                            .filter(x -> itemCriteriaSet.contains(x.getItemCriteria())).collect(Collectors.toList()));
370 
                    if (targetSlab.getItemCriteriaPayouts().size() > 0) {
371 
                        found = true;
372 
                    }
373 
                }
374 
                if (found) {
375 
                    createOfferRequests.add(createOfferRequest);
376 
                }
377 
            }
378 
        }
29783 amit.gupta 379 
 
31747 amit.gupta 380 
        return createOfferRequests;
381 
    }
29783 amit.gupta 382 
 
31747 amit.gupta 383 
    @Override
384 
    public void createOffers(InputStream fileInputStream) throws Exception {
385 
        Map<CreateOfferRequest, List<PartnerTargetModel>> offerPartnerTargetMap = this.parseFromExcel(fileInputStream);
386 
        for (Map.Entry<CreateOfferRequest, List<PartnerTargetModel>> partnerTargetEntry : offerPartnerTargetMap
387 
                .entrySet()) {
388 
            CreateOfferRequest createOfferRequest = partnerTargetEntry.getKey();
389 
            Map<List<Integer>, List<Integer>> targetPartnerMap = partnerTargetEntry.getValue().stream()
390 
                    .collect(Collectors.groupingBy(PartnerTargetModel::getTargets,
391 
                            Collectors.mapping(PartnerTargetModel::getFofoId, Collectors.toList())));
392 
            for (Map.Entry<List<Integer>, List<Integer>> targetPartnersEntry : targetPartnerMap.entrySet()) {
393 
                List<Integer> fofoIds = createOfferRequest.getPartnerCriteria().getFofoIds();
394 
                List<Integer> filterFofoIds = targetPartnersEntry.getValue().stream().filter(x -> !fofoIds.contains(x))
395 
                        .collect(Collectors.toList());
396 
                LOGGER.info("FofoIds {}", filterFofoIds);
397 
                List<Integer> targets = targetPartnersEntry.getKey();
398 
                LOGGER.info("Targets  {}", targets);
29806 amit.gupta 399 
 
31747 amit.gupta 400 
                createOfferRequest.getPartnerCriteria().setFofoIds(filterFofoIds);
401 
                int counter = 0;
402 
                List<ItemCriteriaPayout> itemCriteriaPayouts = createOfferRequest.getTargetSlabs().get(0)
403 
                        .getItemCriteriaPayouts();
404 
                List<PayoutSlab> payoutSlabs = itemCriteriaPayouts.stream().flatMap(x -> x.getPayoutSlabs().stream()).collect(Collectors.toList());
405 
                for (PayoutSlab payoutSlab : payoutSlabs) {
406 
                    payoutSlab.setOnwardsAmount(targets.get(counter));
407 
                    counter++;
408 
                }
409 
                this.addOfferService(createOfferRequest);
410 
            }
411 
        }
412 
        thirtyMinsTimeOutCacheManager.getCache("allOffers").evict(YearMonth.now());
27877 amit.gupta 413 
 
31747 amit.gupta 414 
    }
29783 amit.gupta 415 
 
31747 amit.gupta 416 
    private Map<CreateOfferRequest, List<PartnerTargetModel>> parseFromExcel(InputStream inputStream)
417 
            throws ProfitMandiBusinessException {
29783 amit.gupta 418 
 
31747 amit.gupta 419 
        Map<CreateOfferRequest, List<PartnerTargetModel>> offerPartnerTargetMap = new HashMap<>();
420 
        XSSFWorkbook myWorkBook = null;
421 
        try {
422 
            myWorkBook = new XSSFWorkbook(inputStream);
423 
            myWorkBook.setMissingCellPolicy(MissingCellPolicy.RETURN_BLANK_AS_NULL);
424 
            for (int i = 0; i < myWorkBook.getNumberOfSheets(); i++) {
29683 amit.gupta 425 
 
31747 amit.gupta 426 
                XSSFSheet mySheet = myWorkBook.getSheetAt(i);
427 
                int offerId = Integer.parseInt(mySheet.getSheetName());
428 
                CreateOfferRequest existingOffer = this.getOffer(0, offerId);
429 
                List<PartnerTargetModel> partnerTargetModels = new ArrayList<>();
430 
                offerPartnerTargetMap.put(existingOffer, partnerTargetModels);
431 
                this.printIterator(mySheet);
432 
                LOGGER.info("rowCellNum {}", mySheet.getLastRowNum());
433 
                for (int rowNumber = 1; rowNumber <= mySheet.getLastRowNum(); rowNumber++) {
434 
                    XSSFRow row = mySheet.getRow(rowNumber);
435 
                    LOGGER.info("row {}", row);
436 
                    PartnerTargetModel partnerTargetModel = new PartnerTargetModel();
29783 amit.gupta 437 
 
31747 amit.gupta 438 
                    if (row.getCell(0) != null && row.getCell(0).getCellTypeEnum() == CellType.NUMERIC) {
439 
                        partnerTargetModel.setFofoId((int) row.getCell(0).getNumericCellValue());
440 
                    } else {
441 
                        ProfitMandiBusinessException profitMandiBusinessException = new ProfitMandiBusinessException(
442 
                                "FOFO ID", row.getCell(0).toString(), "TGLSTNG_VE_1010");
443 
                        LOGGER.error("Excel file parse error : ", profitMandiBusinessException);
444 
                        throw profitMandiBusinessException;
445 
                    }
446 
                    List<Integer> targets = new ArrayList<>();
447 
                    long targetsSize = existingOffer.getTargetSlabs().get(0).getItemCriteriaPayouts().stream().flatMap(x -> x.getPayoutSlabs().stream()).collect(Collectors.counting());
448 
                    for (int cellNumber = 1; cellNumber <= targetsSize; cellNumber++) {
449 
                        if (row.getCell(cellNumber) != null
450 
                                && row.getCell(cellNumber).getCellTypeEnum() == CellType.NUMERIC) {
451 
                            targets.add((int) row.getCell(cellNumber).getNumericCellValue());
452 
                        } else {
453 
                            ProfitMandiBusinessException profitMandiBusinessException = new ProfitMandiBusinessException(
454 
                                    "Target Column issue at " + rowNumber + ", " + cellNumber, row.getCell(cellNumber),
455 
                                    "Invalid target");
456 
                            LOGGER.error("Excel file parse error : ", profitMandiBusinessException);
457 
                            throw profitMandiBusinessException;
458 
                        }
459 
                    }
460 
                    partnerTargetModel.setTargets(targets);
461 
                    partnerTargetModels.add(partnerTargetModel);
462 
                }
463 
            }
464 
            myWorkBook.close();
465 
        } catch (ProfitMandiBusinessException pbse) {
466 
            throw pbse;
467 
        } catch (IOException ioException) {
468 
            ioException.printStackTrace();
469 
            throw new ProfitMandiBusinessException(ProfitMandiConstants.EXCEL_FILE, ioException.getMessage(),
470 
                    "EXL_VE_1000");
471 
        } finally {
472 
            if (myWorkBook != null) {
473 
                try {
474 
                    myWorkBook.close();
475 
                } catch (IOException e) {
476 
                    // TODO Auto-generated catch block
477 
                    e.printStackTrace();
478 
                }
479 
            }
480 
        }
481 
        LOGGER.info("offerPartnerTargetMap {}", offerPartnerTargetMap);
482 
        return offerPartnerTargetMap;
483 
    }
29783 amit.gupta 484 
 
31747 amit.gupta 485 
    private void printIterator(XSSFSheet sheet) {
486 
        Iterator<Row> rowIterator = sheet.iterator();
487 
        while (rowIterator.hasNext()) {
488 
            Row row = rowIterator.next();
489 
            // For each row, iterate through all the columns
490 
            Iterator<Cell> cellIterator = row.cellIterator();
29683 amit.gupta 491 
 
31747 amit.gupta 492 
            while (cellIterator.hasNext()) {
493 
                Cell cell = cellIterator.next();
494 
                // Check the cell type and format accordingly
495 
                switch (cell.getCellType()) {
496 
                    case Cell.CELL_TYPE_NUMERIC:
497 
                        System.out.print(cell.getNumericCellValue() + "t");
498 
                        break;
499 
                    case Cell.CELL_TYPE_STRING:
500 
                        System.out.print(cell.getStringCellValue() + "t");
501 
                        break;
502 
                }
503 
            }
504 
            System.out.println("");
505 
        }
506 
    }
29683 amit.gupta 507 
 
31747 amit.gupta 508 
    @Override
509 
    public Map<Integer, CreateOfferRequest> getPublishedOffers(LocalDate date, int fofoId, String brand) {
510 
        // TODO Auto-generated method stub
511 
        return null;
512 
    }
30684 amit.gupta 513 
 
31747 amit.gupta 514 
    @Override
515 
    @Cacheable(value = "slabPayoutMap", cacheManager = "oneDayCacheManager")
516 
    public Map<Integer, Map<Integer, Long>> getSlabPayoutMap(CreateOfferRequest createOfferRequest) {
517 
        Map<Integer, Map<Integer, Long>> catalogSlabPayoutMap = new HashMap<>();
518 
        com.spice.profitmandi.dao.model.TargetSlab targetSlab = createOfferRequest.getTargetSlabs().get(0);
519 
        List<ItemCriteriaPayout> payouts = targetSlab.getItemCriteriaPayouts();
29783 amit.gupta 520 
 
31747 amit.gupta 521 
        for (ItemCriteriaPayout itemCriteriaPayout : payouts) {
522 
            com.spice.profitmandi.service.offers.ItemCriteria itemCriteria = itemCriteriaPayout.getItemCriteria();
523 
            List<Integer> catalogIds = itemRepository.getCatalogIds(itemCriteria);
524 
            for (PayoutSlab payoutSlab : Lists.reverse(itemCriteriaPayout.getPayoutSlabs())) {
525 
                if (itemCriteriaPayout.getAmountType().equals(AmountType.FIXED)) {
526 
                    for (Integer catalogId : catalogIds) {
527 
                        if (!catalogSlabPayoutMap.containsKey(catalogId)) {
528 
                            catalogSlabPayoutMap.put(catalogId, new LinkedHashMap<>());
529 
                        }
530 
                        catalogSlabPayoutMap.get(catalogId).put(payoutSlab.getOnwardsAmount(),
531 
                                (long) payoutSlab.getPayoutAmount());
532 
                    }
533 
                } else if (itemCriteriaPayout.getAmountType().equals(AmountType.SLAB_FIXED)) {
534 
                    for (Integer catalogId : catalogIds) {
535 
                        if (!catalogSlabPayoutMap.containsKey(catalogId)) {
536 
                            catalogSlabPayoutMap.put(catalogId, new LinkedHashMap<>());
537 
                        }
538 
                        catalogSlabPayoutMap.get(catalogId).put(payoutSlab.getOnwardsAmount(),
539 
                                (long) (payoutSlab.getPayoutAmount() / payoutSlab.getOnwardsAmount()));
540 
                    }
541 
                } else if (itemCriteriaPayout.getAmountType().equals(AmountType.PERCENTAGE)) {
542 
                    Map<Integer, TagListing> tagListingsMap = tagListingRepository.selectAllByCatalogIds(catalogIds);
543 
                    for (Map.Entry<Integer, TagListing> tagListingEntry : tagListingsMap.entrySet()) {
544 
                        TagListing tagListing = tagListingEntry.getValue();
545 
                        if (!catalogSlabPayoutMap.containsKey(tagListingEntry.getKey())) {
546 
                            catalogSlabPayoutMap.put(tagListingEntry.getKey(), new LinkedHashMap<>());
547 
                        }
548 
                        catalogSlabPayoutMap.get(tagListingEntry.getKey()).put(payoutSlab.getOnwardsAmount(),
549 
                                (long) (tagListing.getSellingPrice() * payoutSlab.getPayoutAmount() / 100));
550 
                    }
551 
                }
552 
            }
553 
        }
554 
        return catalogSlabPayoutMap;
555 
    }
556 
 
31903 amit.gupta 557 
    @Override
558 
    @Cacheable(value = "slabPayoutMap", cacheManager = "oneDayCacheManager")
559 
    public Map<Integer, Map<Integer, AmountModel>> getSlabPayoutMapNew(CreateOfferRequest createOfferRequest) {
560 
        Map<Integer, Map<Integer, AmountModel>> catalogSlabPayoutMap = new HashMap<>();
561 
        com.spice.profitmandi.dao.model.TargetSlab targetSlab = createOfferRequest.getTargetSlabs().get(0);
562 
        List<ItemCriteriaPayout> payouts = targetSlab.getItemCriteriaPayouts();
563 
 
564 
        for (ItemCriteriaPayout itemCriteriaPayout : payouts) {
565 
            com.spice.profitmandi.service.offers.ItemCriteria itemCriteria = itemCriteriaPayout.getItemCriteria();
566 
            List<Integer> catalogIds = itemRepository.getCatalogIds(itemCriteria);
567 
            for (PayoutSlab payoutSlab : Lists.reverse(itemCriteriaPayout.getPayoutSlabs())) {
568 
                if (itemCriteriaPayout.getAmountType().equals(AmountType.FIXED)) {
569 
                    for (Integer catalogId : catalogIds) {
570 
                        if (!catalogSlabPayoutMap.containsKey(catalogId)) {
571 
                            catalogSlabPayoutMap.put(catalogId, new LinkedHashMap<>());
572 
                        }
573 
                        AmountModel amountModel = new AmountModel();
574 
                        amountModel.setAmountType(AmountType.FIXED);
575 
                        amountModel.setAmount(payoutSlab.getPayoutAmount());
32021 amit.gupta 576 
                        amountModel.setDiscount(createOfferRequest.isDiscount());
31903 amit.gupta 577 
                        catalogSlabPayoutMap.get(catalogId).put(payoutSlab.getOnwardsAmount(),
578 
                                amountModel);
579 
                    }
580 
                } else if (itemCriteriaPayout.getAmountType().equals(AmountType.SLAB_FIXED)) {
581 
                    for (Integer catalogId : catalogIds) {
582 
                        if (!catalogSlabPayoutMap.containsKey(catalogId)) {
583 
                            catalogSlabPayoutMap.put(catalogId, new LinkedHashMap<>());
584 
                        }
585 
 
586 
                        AmountModel amountModel = new AmountModel();
587 
                        amountModel.setAmountType(AmountType.FIXED);
32021 amit.gupta 588 
                        amountModel.setDiscount(createOfferRequest.isDiscount());
31903 amit.gupta 589 
                        amountModel.setAmount(payoutSlab.getPayoutAmount() / payoutSlab.getOnwardsAmount());
590 
                        catalogSlabPayoutMap.get(catalogId).put(payoutSlab.getOnwardsAmount(),
591 
                                amountModel);
592 
                    }
593 
                } else if (itemCriteriaPayout.getAmountType().equals(AmountType.PERCENTAGE)) {
594 
                    for (Integer catalogId : catalogIds) {
595 
                        if (!catalogSlabPayoutMap.containsKey(catalogId)) {
596 
                            catalogSlabPayoutMap.put(catalogId, new LinkedHashMap<>());
597 
                        }
598 
                        AmountModel amountModel = new AmountModel();
599 
                        amountModel.setAmountType(AmountType.PERCENTAGE);
600 
                        amountModel.setAmount(payoutSlab.getPayoutAmount());
32021 amit.gupta 601 
                        amountModel.setDiscount(createOfferRequest.isDiscount());
31903 amit.gupta 602 
                        catalogSlabPayoutMap.get(catalogId).put(payoutSlab.getOnwardsAmount(),
603 
                                amountModel);
604 
                    }
605 
                }
606 
            }
607 
        }
608 
        return catalogSlabPayoutMap;
609 
    }
610 
 
31920 amit.gupta 611 
 
612 
    private double getAmount(InventoryPayoutModel inventoryPayoutModel, AmountModel amountModel) {
613 
        double rollout = 0;
614 
        if (amountModel.getAmountType().equals(AmountType.PERCENTAGE)) {
615 
            double effectiveDp = inventoryPayoutModel.getDp() - inventoryPayoutModel.getFixedAmount();
616 
            double totalPercentage = inventoryPayoutModel.getPercentageAmount() + amountModel.getAmount();
617 
            rollout = effectiveDp * (totalPercentage / (100 + totalPercentage) - (inventoryPayoutModel.getPercentageAmount() / (100 + inventoryPayoutModel.getPercentageAmount())));
618 
        } else {
619 
            rollout = amountModel.getAmount() * (100 / (100 + inventoryPayoutModel.getPercentageAmount()));
620 
        }
621 
        return rollout;
622 
    }
623 
 
624 
    @Override
625 
    public void processActivationtOffer(CreateOfferRequest createOfferRequest) throws ProfitMandiBusinessException {
626 
        //List<OfferRowModel> offerRowModels = new ArrayList<>();
627 
        List<OfferPayout> offerPayouts = offerPayoutRepository.selectAllByOfferId(createOfferRequest.getId());
628 
        List<ItemCriteriaPayout> itemCriteriaPayouts = createOfferRequest.getTargetSlabs().get(0).getItemCriteriaPayouts();
629 
        Map<Integer, ItemCriteriaPayout> itemCriteriaPayoutMap = itemCriteriaPayouts.stream().collect(Collectors.toMap(x -> x.getItemCriteria().getId(), x -> x));
31923 amit.gupta 630 
        LOGGER.info("itemCriteriaPayoutMap {}", itemCriteriaPayoutMap);
631 
        LOGGER.info("offerPayouts {}", offerPayouts);
31924 amit.gupta 632 
        Map<Integer, Map<Integer, Double>> fixedSlabCriteriaPartnerMap = offerPayouts.stream().filter(x -> itemCriteriaPayoutMap.get((int) x.getCriteriaId()).getAmountType().equals(AmountType.SLAB_FIXED))
31920 amit.gupta 633 
                .collect(Collectors.groupingBy(x -> (int) x.getCriteriaId(), Collectors.groupingBy(x -> (int) x.getFofoId(), Collectors.summingDouble(x -> x.getSlabAmount()))));
634 
 
635 
 
636 
        Map<String, Double> serialNumberPaid = offerPayouts.stream().filter(x -> x.getRejectTimestamp() == null).collect(Collectors.groupingBy(x -> x.getSerialNumber(), Collectors.summingDouble(x -> x.getSlabAmount())));
637 
        /*if (offerPayouts.size() > 0) {
638 
            throw new ProfitMandiBusinessException("Offer Already Processed", "Offer Already Processed", "Offer Already Processed");
639 
        }*/
640 
        Map<Integer, Map<Integer, List<FofoOrderItem>>> criteriaPartnerwiseTertiary = offerRepository.getCriteriaWisePartnerTertiary(createOfferRequest);
641 
 
642 
 
643 
        final Set<String> activatedImeis;
644 
        final Set<String> missingImeis;
645 
        if (createOfferRequest.getSchemeType().equals(OfferSchemeType.ACTIVATION)) {
646 
            //All Serialnumbers for all eligible retailers
647 
            List<String> serialNumbers = criteriaPartnerwiseTertiary.entrySet().stream().flatMap(x -> x.getValue().entrySet().stream().flatMap(foiList -> foiList.getValue().stream()))
648 
                    .flatMap(y -> y.getFofoLineItems().stream()).filter(fli -> fli.getSerialNumber() != null)
649 
                    .map(x -> x.getSerialNumber()).collect(Collectors.toList());
650 
            if (serialNumbers.size() > 0) {
651 
                activatedImeis = activatedImeiRepository.selectBySerialNumbers(serialNumbers).stream()
652 
                        .filter(x -> createOfferRequest.isWithinRange(x.getActivationTimestamp()))
653 
                        .map(x -> x.getSerialNumber()).collect(Collectors.toSet());
654 
                //missingImeis = serialNumbers.stream().filter(x -> !activatedImeis.contains(x)).collect(Collectors.toSet());
655 
                //activatedImeis.addAll(missingImeis);
656 
                //serialNumbers.removeAll(activatedImeis);
657 
            } else {
658 
                activatedImeis = null;
659 
            }
660 
            // TODO Amit
661 
            /**
662 
             * Missing imeis are considered as activated as long as payout calculations are
663 
             * concerned - Add flag if calculations are meant for final payout(Wherein
664 
             * missing imeis are no longer considered to be activated)
665 
             **/
666 
        } else {
667 
            activatedImeis = null;
668 
        }
669 
 
670 
        Map<Integer, Integer> userBaseQtyMap = new HashMap<>();
671 
        Map<Integer, Integer> userBaseValueMap = new HashMap<>();
672 
        Map<Integer, Integer> eligibleBaseQtyMap = new HashMap<>();
673 
        Map<Integer, Integer> eligibleBaseValueMap = new HashMap<>();
674 
 
675 
        if (createOfferRequest.isBaseCriteria()) {
676 
            Map<Integer, List<FofoOrderItem>> foiMap = criteriaPartnerwiseTertiary.get(0);
677 
            for (Map.Entry<Integer, List<FofoOrderItem>> orderEntry : foiMap.entrySet()) {
678 
                int fofoId = orderEntry.getKey();
679 
                List<FofoOrderItem> fofoOrderItems = orderEntry.getValue();
680 
                int totalBaseQty = fofoOrderItems.stream().collect(Collectors.summingInt(x -> (x.getQuantity())));
681 
                int totalBaseValue = fofoOrderItems.stream().collect(Collectors.summingInt(x -> (Math.round(x.getDp())) * x.getQuantity()));
682 
                userBaseQtyMap.put(fofoId, totalBaseQty);
683 
                userBaseValueMap.put(fofoId, totalBaseValue);
684 
                if (createOfferRequest.getSchemeType().equals(OfferSchemeType.ACTIVATION)) {
685 
                    Map<Integer, Integer> inventoryItemValueMap = new HashMap<>();
686 
                    for (FofoOrderItem fofoOrderItem : fofoOrderItems) {
687 
                        fofoOrderItem.getFofoLineItems().stream().filter(x -> x.getSerialNumber() != null).forEach(
688 
                                lineItem -> {
689 
                                    if (activatedImeis == null || activatedImeis.contains(lineItem.getSerialNumber())) {
690 
                                        inventoryItemValueMap.put(lineItem.getInventoryItemId(), (int) fofoOrderItem.getDp());
691 
                                    }
692 
                                }
693 
                        );
694 
                    }
695 
                    eligibleBaseQtyMap.put(fofoId, inventoryItemValueMap.size());
696 
                    eligibleBaseValueMap.put(fofoId, inventoryItemValueMap.entrySet().stream().collect(Collectors.summingInt(x -> x.getValue())));
697 
                } else {
698 
                    eligibleBaseQtyMap.put(fofoId, totalBaseQty);
699 
                    eligibleBaseValueMap.put(fofoId, totalBaseValue);
700 
 
701 
                }
702 
 
703 
            }
704 
        }
705 
        //Map<Integer, Double> totalPurchaseValueMap = null;
706 
        if (createOfferRequest.getSellinPercentage() > 0) {
707 
			/*List<Order> purchaseOrders = orderRepository.selectOrdersBetweenDates(fofoIds, "billingTimestamp",
708 
					createOfferRequest.getStartDate(), createOfferRequest.getEndDate());
709 
			Map<Integer, Double> totalPurchaseValueMap = purchaseOrders.stream().collect(
710 
					Collectors.groupingBy(x -> x.getRetailerId(), Collectors.summingDouble(x -> x.getWalletAmount())));*/
711 
        }
712 
 
713 
 
714 
        //As of now eligible sale is considered to be without special criteria like brand/
715 
        for (ItemCriteriaPayout itemCriteriaPayout : createOfferRequest.getTargetSlabs().get(0).getItemCriteriaPayouts()) {
716 
            int criteriaId = itemCriteriaPayout.getItemCriteria().getId();
717 
            Map<Integer, List<FofoOrderItem>> ordersMap = criteriaPartnerwiseTertiary.get(criteriaId);
718 
            for (Map.Entry<Integer, List<FofoOrderItem>> orderEntry : ordersMap.entrySet()) {
31992 amit.gupta 719 
                double totalRolloutAmount = 0;
31920 amit.gupta 720 
                int fofoId = orderEntry.getKey();
721 
                List<FofoOrderItem> fofoOrderItems = orderEntry.getValue();
722 
                OfferRowModel offerRowModel = new OfferRowModel();
723 
                int totalQty = fofoOrderItems.stream().collect(Collectors.summingInt(x -> (x.getQuantity())));
724 
                int totalValue = fofoOrderItems.stream().collect(Collectors.summingInt(x -> Math.round(x.getDp()) * (x.getQuantity())));
725 
                int eligibleQty = totalQty;
726 
                int eligibleValue = totalValue;
727 
                Map<FofoLineItem, Integer> lineItemValueMap = new HashMap<>();
728 
                if (createOfferRequest.getSchemeType().equals(OfferSchemeType.ACTIVATION)) {
729 
                    for (FofoOrderItem fofoOrderItem : fofoOrderItems) {
730 
                        fofoOrderItem.getFofoLineItems().stream().filter(x -> x.getSerialNumber() != null).forEach(
731 
                                lineItem -> {
732 
                                    if (activatedImeis == null || activatedImeis.contains(lineItem.getSerialNumber())) {
733 
                                        lineItemValueMap.put(lineItem, (int) fofoOrderItem.getDp());
734 
                                    }
735 
                                }
736 
                        );
737 
                    }
738 
                    eligibleQty = lineItemValueMap.size();
739 
                    eligibleValue = lineItemValueMap.entrySet().stream().collect(Collectors.summingInt(x -> x.getValue()));
740 
                    offerRowModel.setEligibleImeis(lineItemValueMap.keySet().stream().map(x -> x.getSerialNumber()).collect(Collectors.toList()));
741 
                }
742 
 
743 
                int totalBaseQty = totalQty;
744 
                int totalBaseValue = totalValue;
745 
                int eligibleBaseQty = eligibleQty;
746 
                int eligibleBaseValue = eligibleValue;
747 
                if (createOfferRequest.isBaseCriteria()) {
748 
                    totalBaseQty = userBaseQtyMap.get(fofoId) == null ? 0 : userBaseQtyMap.get(fofoId);
749 
                    totalBaseValue = userBaseValueMap.get(fofoId) == null ? 0 : userBaseValueMap.get(fofoId);
750 
                    eligibleBaseQty = eligibleBaseQtyMap.get(fofoId) == null ? 0 : eligibleBaseQtyMap.get(fofoId);
751 
                    eligibleBaseValue = eligibleBaseValueMap.get(fofoId) == null ? 0 : eligibleBaseValueMap.get(fofoId);
752 
                }
753 
 
754 
 
755 
                int totalSale = totalBaseValue;
756 
                int eligibleSale = eligibleBaseValue;
757 
                int criteriaSale = totalValue;
758 
                int eligibleCriteriaSale = eligibleValue;
759 
                int eligibleCriteriaSaleDp = eligibleValue;
760 
 
761 
                if (createOfferRequest.getTargetType().equals(AchievementType.QUANTITY)) {
762 
                    totalSale = totalBaseQty;
763 
                    eligibleSale = eligibleBaseQty;
764 
                    criteriaSale = totalQty;
765 
                    eligibleCriteriaSale = eligibleQty;
766 
                }
767 
 
768 
                offerRowModel.setTotalSale(totalSale);
769 
                offerRowModel.setEligibleSale(eligibleSale);
770 
                float eligiblePayoutValue = 0;
771 
                double finalPayout = 0;
772 
                for (PayoutSlab payoutSlab : itemCriteriaPayout.getPayoutSlabs()) {
773 
                    if (payoutSlab.getOnwardsAmount() <= eligibleSale) {
774 
                        offerRowModel.setPayoutTargetAchieved(payoutSlab.getOnwardsAmount());
775 
                        eligiblePayoutValue = payoutSlab.getPayoutAmount();
776 
                        offerRowModel.setPayoutValue(eligiblePayoutValue);
777 
                    }
778 
                }
779 
                if (AmountType.PERCENTAGE.equals(itemCriteriaPayout.getAmountType())) {
780 
                    finalPayout = (eligiblePayoutValue * eligibleCriteriaSaleDp) / 100;
781 
                } else if (AmountType.FIXED.equals(itemCriteriaPayout.getAmountType())) {
782 
                    finalPayout = eligiblePayoutValue * eligibleCriteriaSale;
783 
                } else {
784 
                    finalPayout = eligiblePayoutValue;
785 
                    Map<Integer, Double> fofoCriteriaMap = fixedSlabCriteriaPartnerMap.get(criteriaId);
786 
                    if (fofoCriteriaMap != null) {
787 
                        if (fofoCriteriaMap.containsKey(fofoId)) {
788 
                            double totalPayout = fofoCriteriaMap.get(fofoId);
789 
                            if (totalPayout - finalPayout > Utils.DOUBLE_EPSILON)
790 
                                finalPayout = 0;
791 
                        }
792 
                    }
793 
                }
794 
 
795 
                if (finalPayout > 0) {
796 
                    List<Integer> inventoryItemIds = lineItemValueMap.keySet().stream().map(x -> x.getInventoryItemId()).collect(Collectors.toList());
797 
                    Map<Integer, InventoryItem> inventoryItemsMap = inventoryItemRepository.selectAllByIds(inventoryItemIds).stream().collect(Collectors.toMap(x -> x.getId(), x -> x));
798 
                    int totalDpValue = lineItemValueMap.values().stream().collect(Collectors.summingInt(x -> x));
799 
                    for (Map.Entry<FofoLineItem, Integer> lineItemValueEntry : lineItemValueMap.entrySet()) {
800 
                        double amount = 0;
801 
                        if (AmountType.SLAB_FIXED.equals(itemCriteriaPayout.getAmountType())) {
802 
                            amount = eligiblePayoutValue * (lineItemValueEntry.getValue() / totalDpValue);
803 
                            //Fixed slab should be treated as fixed after payout
804 
                        } else {
805 
                            amount = eligiblePayoutValue;
806 
                        }
807 
 
808 
                        if (serialNumberPaid.containsKey(lineItemValueEntry.getKey().getSerialNumber())) {
809 
                            amount = amount - serialNumberPaid.get(lineItemValueEntry.getKey().getSerialNumber());
810 
                        }
811 
                        //ignore reasonably small
812 
                        if (amount < Utils.DOUBLE_EPSILON) continue;
813 
                        AmountModel amountModel = new AmountModel();
814 
                        amountModel.setAmountType(itemCriteriaPayout.getAmountType());
815 
                        amountModel.setAmount(amount);
32021 amit.gupta 816 
                        amountModel.setDiscount(createOfferRequest.isDiscount());
31920 amit.gupta 817 
                        InventoryPayoutModel inventoryPayoutModel = priceCircularService.getPayouts(inventoryItemsMap.get(lineItemValueEntry.getKey().getInventoryItemId()));
818 
                        double rolloutAmount = inventoryPayoutModel.getRolloutAmount(amountModel);
819 
                        totalRolloutAmount += rolloutAmount;
820 
 
821 
                        OfferPayout offerPayout = new OfferPayout(fofoId, createOfferRequest.getId(), criteriaId, amount, lineItemValueEntry.getKey().getSerialNumber(), rolloutAmount, SchemePayoutStatus.CREDITED, createOfferRequest.getDescription(), LocalDateTime.now());
822 
                        //offerPayout.setInventoryItemId(inventoryItemSaleModelsMap.get(lineItemValueEntry.getKey().getInventoryItemId()));
823 
                        offerPayoutRepository.persist(offerPayout);
824 
                    }
825 
                }
826 
                walletService.addAmountToWallet((int) fofoId, createOfferRequest.getId(), WalletReferenceType.ADDITIONAL_SCHEME, createOfferRequest.getDescription(), (float) totalRolloutAmount, LocalDateTime.now());
827 
            }
828 
        }
829 
        Offer offer = offerRepository.selectById(createOfferRequest.getId());
830 
        offer.setProcessedTimestamp(LocalDateTime.now());
831 
    }
832 
 
833 
    @Override
834 
    public void processSellin(CreateOfferRequest createOfferRequest) throws Exception {
835 
 
836 
        //List<OfferRowModel> offerRowModels = new ArrayList<>();
837 
        List<OfferPayout> offerPayouts = offerPayoutRepository.selectAllByOfferId(createOfferRequest.getId());
838 
        Set<Long> fofoIds = offerPayouts.stream().map(x -> x.getFofoId()).collect(Collectors.toSet());
839 
 
840 
        Map<Integer, Map<Integer, List<Order>>> criteriaOrdersMap = offerRepository.getPartnerWiseSellin(createOfferRequest, true);
841 
 
842 
        Map<Integer, List<Order>> userBaseCriteriaOrdersMap = null;
843 
        if (criteriaOrdersMap.get(0) != null && criteriaOrdersMap.get(0).size() > 0) {
844 
            userBaseCriteriaOrdersMap = criteriaOrdersMap.get(0).entrySet().stream()
845 
                    .filter(x -> !fofoIds.contains(x.getKey())).collect(Collectors.toMap(x -> x.getKey(), x -> x.getValue()));
846 
        }
847 
 
848 
        Map<Integer, Integer> userBaseQtyMap = null;
849 
        Map<Integer, Integer> userBaseValueMap = null;
850 
        if (userBaseCriteriaOrdersMap != null) {
851 
            userBaseQtyMap = new HashMap<>();
852 
            userBaseValueMap = new HashMap<>();
853 
            for (Map.Entry<Integer, List<Order>> orderEntry : userBaseCriteriaOrdersMap.entrySet()) {
854 
                int fofoId = orderEntry.getKey();
855 
                List<Order> orders = orderEntry.getValue();
856 
                int totalBaseQty = orders.stream().collect(Collectors.summingInt(x -> (x.getLineItem().getQuantity() - x.getLineItem().getReturnQty())));
857 
                int totalBaseValue = orders.stream().collect(Collectors.summingInt(x ->
858 
                        Math.round(x.getLineItem().getUnitPrice() * (x.getLineItem().getQuantity() - x.getLineItem().getReturnQty()))
859 
                ));
860 
                userBaseQtyMap.put(fofoId, totalBaseQty);
861 
                userBaseValueMap.put(fofoId, totalBaseValue);
862 
            }
863 
        }
864 
        LOGGER.info("Base Qty Map - {}", userBaseQtyMap);
865 
        LOGGER.info("Base Value Map - {}", userBaseValueMap);
866 
 
867 
        LOGGER.info("Processing sellin");
868 
        List<OfferPayout> offerPayoutsNew = new ArrayList<>();
869 
        for (ItemCriteriaPayout itemCriteriaPayout : createOfferRequest.getTargetSlabs().get(0).getItemCriteriaPayouts()) {
870 
            int criteriaId = itemCriteriaPayout.getItemCriteria().getId();
871 
            LOGGER.info("Criteria Id - {}", criteriaId);
872 
            Map<Integer, List<Order>> ordersMap = criteriaOrdersMap.get(criteriaId).entrySet().stream()
873 
                    .filter(x -> !fofoIds.contains(x.getKey())).collect(Collectors.toMap(x -> x.getKey(), x -> x.getValue()));
874 
            for (Map.Entry<Integer, List<Order>> orderEntry : ordersMap.entrySet()) {
875 
                int fofoId = orderEntry.getKey();
876 
                //CustomRetailer retailer = retailerService.getAllFofoRetailers().get(fofoId);
877 
                List<Order> orders = orderEntry.getValue();
878 
                Set<String> returnedSerialNumbers = orders.stream().filter(x -> x.getSerialNumber() != null).flatMap(x -> x.getReturnedImeis().stream()).collect(Collectors.toSet());
879 
                int totalQty = orders.stream().collect(Collectors.summingInt(x -> (x.getLineItem().getQuantity() - x.getLineItem().getReturnQty())));
880 
                LOGGER.info("LineItems = {}", orders.stream().map(x -> x.getLineItem().getId()).collect(Collectors.toList()));
881 
                int totalValue = orders.stream().collect(Collectors.summingInt(x -> Math.round(x.getLineItem().
882 
                        getUnitPrice() * (x.getLineItem().getQuantity() - x.getLineItem().getReturnQty()))));
883 
                int totalBaseQty = totalQty;
884 
                int totalBaseValue = totalValue;
885 
                if (userBaseCriteriaOrdersMap != null) {
886 
                    if (userBaseQtyMap.containsKey(fofoId)) {
887 
                        totalBaseQty = userBaseQtyMap.get(fofoId);
888 
                        totalBaseValue = userBaseValueMap.get(fofoId);
889 
                    } else {
890 
                        continue;
891 
                    }
892 
                }
893 
 
894 
                int purchasedValue;
895 
                if (createOfferRequest.getTargetType().equals(AchievementType.VALUE)) {
896 
                    purchasedValue = totalBaseValue;
897 
                } else {
898 
                    purchasedValue = totalBaseQty;
899 
                }
900 
                PayoutSlab currentSlab = itemCriteriaPayout.getPayoutSlabs().stream()
901 
                        .filter(x -> x.getOnwardsAmount() <= purchasedValue).max(Comparator.comparing(x
902 
                                -> x.getOnwardsAmount())).orElse(null);
903 
                int targetAchieved = currentSlab ==
904 
                        null ? 0 : currentSlab.getOnwardsAmount();
905 
 
906 
                //TODO-- payouts handling is here
907 
                if (currentSlab == null) continue;
908 
                //Need to remove hardcoding on tax
909 
                List<Integer> orderIds = orders.stream().map(x -> x.getId()).collect(Collectors.toList());
910 
                Map<Integer, LineItem> lineItemMap = orders.stream().collect(Collectors.toMap(x -> x.getLineItem().getId(), x -> x.getLineItem()));
911 
                List<WarehouseScan> warehouseScans = warehouseScanRepository.selectAllByOrderIds(orderIds);
912 
                List<Integer> inventoryItemIds = warehouseScans.stream().collect(Collectors.groupingBy(x -> x.getInventoryItemId())).entrySet()
913 
                        .stream().filter(x -> x.getValue().size() == 1).map(x -> x.getKey()).collect(Collectors.toList());
914 
                Set<String> serialNumbers;
915 
                LOGGER.info("inventoryItemIds {}", inventoryItemIds);
916 
                if (inventoryItemIds.size() > 0) {
917 
                    List<WarehouseInventoryItem> warehouseInventoryItems = warehouseInventoryItemRepository.selectAllByIds(inventoryItemIds);
918 
                    serialNumbers = warehouseInventoryItems.stream().map(x -> x.getSerialNumber()).collect(Collectors.toSet());
919 
                } else {
920 
                    serialNumbers = new HashSet<>();
921 
                }
922 
                LOGGER.info("SerialNumbers {}", serialNumbers);
923 
                Map<String, Long> serialNumberCountMap = lineItemImeisRepository.selectByLineItemIds(new ArrayList<>(lineItemMap.keySet()))
924 
                        .stream().collect(Collectors.groupingBy(x -> x.getSerialNumber(), Collectors.counting()));
925 
                LOGGER.info("SerialNumbers Count Map {}", serialNumberCountMap);
926 
                Map<String, LineItem> serialNumberMap = lineItemImeisRepository.selectByLineItemIds(new ArrayList<>(lineItemMap.keySet()))
927 
                        .stream().collect(Collectors.toMap(x -> x.getSerialNumber(), x -> lineItemMap.get(x.getLineItemId()), (x1, x2) -> x1.getId() > x2.getId() ? x1 : x2));
928 
 
929 
                serialNumberMap = serialNumberMap.entrySet().stream().filter(x -> serialNumbers.contains(x.getKey())).collect(Collectors.toMap(x -> x.getKey(), x -> x.getValue()));
930 
 
931 
                LOGGER.info("serialNumberMap {}", serialNumberMap);
932 
                double amount = 0;
933 
                int lineItemsValue = serialNumberMap.values().stream().collect(Collectors.summingInt(x -> x.getUnitPrice().intValue()));
934 
                LOGGER.info("lineItemsValue - {}, totalValue - {}", lineItemsValue, totalValue);
935 
                for (Map.Entry<String, LineItem> entry : serialNumberMap.entrySet()) {
936 
                    LOGGER.info("Serial no - {}", entry.getKey());
937 
                    LineItem lineItem = entry.getValue();
938 
                    if (AmountType.PERCENTAGE.equals(itemCriteriaPayout.getAmountType())) {
939 
                        float percentageAmount = currentSlab.getPayoutAmount();
940 
                        amount = entry.getValue().getUnitPrice() * (percentageAmount / 100);
941 
                    } else if (AmountType.SLAB_FIXED.equals(itemCriteriaPayout.getAmountType())) {
942 
                        float totalAmount = currentSlab.getPayoutAmount();
943 
                        amount = Math.round((totalAmount / totalValue) * lineItem.getUnitPrice());
944 
                        LOGGER.info("Serial no - {}, unitPrice - {}, amount - {}", entry.getKey(), lineItem.getUnitPrice(), amount);
945 
                    } else {
946 
                        //per unit amount
947 
                        amount = currentSlab.getPayoutAmount();
948 
                    }
949 
                    if (fofoIds.contains(Long.valueOf(fofoId))) continue;
950 
                    OfferPayout offerPayout = new OfferPayout(fofoId, createOfferRequest.getId(), criteriaId, currentSlab.getPayoutAmount(), entry.getKey(), amount, SchemePayoutStatus.CREDITED, createOfferRequest.getDescription(), LocalDateTime.now());
951 
                    //offerPayout.setLineItemId();
952 
                    offerPayoutRepository.persist(offerPayout);
953 
                    offerPayoutsNew.add(offerPayout);
954 
                }
955 
 
956 
            }
957 
        }
958 
        Map<Long, Double> offerPayoutMap = offerPayoutsNew.stream().collect(Collectors.groupingBy(x -> x.getFofoId(), Collectors.summingDouble(x -> x.getAmount())));
959 
        for (Map.Entry<Long, Double> offerPayoutEntry : offerPayoutMap.entrySet()) {
960 
            long fofoId = offerPayoutEntry.getKey();
961 
            double amountToCredit = offerPayoutEntry.getValue();
962 
            walletService.addAmountToWallet((int) fofoId, createOfferRequest.getId(), WalletReferenceType.ADDITIONAL_SCHEME, createOfferRequest.getDescription(), (float) amountToCredit, LocalDateTime.now());
963 
        }
964 
        Offer offer = offerRepository.selectById(createOfferRequest.getId());
965 
        offer.setProcessedTimestamp(LocalDateTime.now());
966 
    }
27877 amit.gupta 967 
}