WebSVN – SmartDukaan – Diff – /trunk/profitmandi-dao/src/main/java/com/spice/profitmandi/dao/service/ScratchService.java

 import com.spice.profitmandi.dao.repository.scratch.SeasonalOfferRepository;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Propagation;
 import org.springframework.transaction.annotation.Transactional;
 import java.time.LocalDate;
 import java.time.LocalDateTime;
 import java.time.LocalTime;
     FofoOrderItemRepository fofoOrderItemRepository;
     @Autowired
     ItemRepository itemRepository;
     @Autowired
     FofoOrderRepository fofoOrderRepository;
-//    @Transactional(propagation = Propagation.REQUIRES_NEW)
+    //    @Transactional(propagation = Propagation.REQUIRES_NEW)
     public void processScratchOffer(int fofoOrderId, Set<CustomPaymentOption> paymentOptions, Set<Integer> fofoOrderItemIds) throws ProfitMandiBusinessException {
         FofoOrder fofoOrder = fofoOrderRepository.selectByOrderId(fofoOrderId);
         logger.info("Starting scratchOffer for order: {}", fofoOrder);
         LocalDate today = LocalDate.now();
         for (Integer orderItemId : fofoOrderItemIds) {
 //                logger.info("Customer {} has chosen a different mode of payment.", fofoOrder.getCustomerId());
 //                return;
 //            }
             if (eligibleOffer != null) {
                 logger.info("Found active offer: {}", eligibleOffer.getId());
-//                 Get the customer's scratch list and check if this offer is already there
                 Integer activeOfferId = eligibleOffer.getId();
                 logger.info
                         ("Active offer ID: {}, Type: {}", activeOfferId, eligibleOffer.getName());
                 ScratchOffer availedOffer = scratchOfferRepository.getScractchOfferByCustomerIdAndOfferId(fofoOrder.getCustomerId(), activeOfferId);
                 if (availedOffer != null) {
                     logger.info("Customer {} has already scratched offer ID {}. No new gift will be allotted.", fofoOrder.getCustomerId(), activeOfferId);
-                    return; // Customer already has this offer
+                    return;
+                }
-                // Proceed with processing the offer since customer hasn't scratched it yet
                 if (this.processOffer(eligibleOffer, fofoOrder, itemCategoryId)) {
                     logger.info("Successfully processed offer for item: {}", orderItemId);
-                    return; // Successfully processed an offer
+                    break;
                 } else {
                     logger.info("Failed to process offer for item: {}", orderItemId);
+                }
             } else {
                 logger.info("No active offers found for today: {}", today);
+            }
             logger.info("No eligible gifts found for any items in order: {}", fofoOrder.getId());
-            return; // No eligible gifts found for any items
+            return;
+        }
         logger.info("No eligible gifts found for any items in order: {}", fofoOrder.getId());
+    }
     private OfferEntity FindEligibleOffer(List<OfferEntity> activeOffers, FofoOrder fofoOrder) {
         int customerFofoId = fofoOrder.getFofoId();
+        logger.info("Looking for eligible offer for customer fofoId: {}", customerFofoId);
+        logger.info("Total active offers to check: {}", activeOffers.size());
         for (OfferEntity activeOffer : activeOffers) {
+            logger.info("Checking offer ID: {} with classification: {}", activeOffer.getId(), activeOffer.getClassification());
             if ("PartnerWise".equals(activeOffer.getClassification())) {
                 List<GiftEntity> gifts = giftRepository.findByOfferId(activeOffer.getId());
+                logger.info("Found {} gifts for PartnerWise offer {}", gifts.size(), activeOffer.getId());
+                if (gifts.isEmpty()) {
+                    logger.warn("No gifts found for PartnerWise offer {}", activeOffer.getId());
+                    continue;
+                }
                 for (GiftEntity gift : gifts) {
+                    logger.info("Checking gift ID: {} with fofoStore: '{}'", gift.getId(), gift.getFofoStore());
+                    if (gift.getFofoStore() == null || gift.getFofoStore().trim().isEmpty()) {
+                        logger.warn("Gift {} has null/empty fofoStore - skipping", gift.getId());
+                        continue;
+                    }
                     String[] fofoStores = gift.getFofoStore().split(",");
+                    logger.info("Gift {} fofoStores array: {}", gift.getId(), Arrays.toString(fofoStores));
                     boolean isEligible = Arrays.stream(fofoStores)
-                            .map(Integer::parseInt) // Convert string to int
+                            .filter(store -> !store.trim().isEmpty())
+                            .map(store -> {
+                                try {
+                                    int storeId = Integer.parseInt(store.trim());
+                                    logger.info("Parsed fofoStore: {} (comparing with customer fofoId: {})", storeId, customerFofoId);
+                                    return storeId;
+                                } catch (NumberFormatException e) {
+                                    logger.warn("Invalid fofoId format in gift {}: '{}' - skipping", gift.getId(), store);
+                                    return -1;
+                                }
+                            })
+                            .anyMatch(fofoStore -> {
-                            .anyMatch(fofoStore -> fofoStore == customerFofoId);
+                                boolean matches = fofoStore == customerFofoId;
+                                logger.info("FofoStore {} matches customer fofoId {}: {}", fofoStore, customerFofoId, matches);
+                                return matches;
+                            });
+                    logger.info("Gift {} is eligible for customer fofoId {}: {}", gift.getId(), customerFofoId, isEligible);
                     if (isEligible) {
+                        logger.info("Found matching PartnerWise offer: {} for customer fofoId: {}", activeOffer.getId(), customerFofoId);
-                        return activeOffer;  // Return the matching PARTNERWISE offer
+                        return activeOffer;
+                    }
+                }
+                logger.info("No matching gifts found in PartnerWise offer {} for customer fofoId: {}", activeOffer.getId(), customerFofoId);
+            } else {
+                logger.info("Offer {} is not PartnerWise (classification: {})", activeOffer.getId(), activeOffer.getClassification());
+            }
+        }
-        // If no PARTNERWISE offer matches, return the first non-PARTNERWISE offer (if any)
+        logger.info("No PartnerWise offers matched. Looking for non-PartnerWise offers...");
-        return activeOffers.stream()
+        List<OfferEntity> nonPartnerWiseOffers = activeOffers.stream()
                 .filter(offer -> !"PartnerWise".equals(offer.getClassification()))
-                .findFirst()
+                .collect(Collectors.toList());
+        logger.info("Found {} non-PartnerWise offers", nonPartnerWiseOffers.size());
+        OfferEntity selectedOffer = nonPartnerWiseOffers.stream().findFirst().orElse(null);
-                .orElse(null);
+        if (selectedOffer != null) {
+            logger.info("Selected non-PartnerWise offer: {}", selectedOffer.getId());
+        } else {
+            logger.info("No eligible offers found for customer fofoId: {}", customerFofoId);
+        }
+        return selectedOffer;
+    }
     private Item getItemById(Integer itemId) throws ProfitMandiBusinessException {
         logger.info("Getting item by ID: {}", itemId);
         Item item = itemRepository.selectById(itemId);
         if (item == null) {
             logger.warn("Item not found with ID: {}", itemId);
         int perDayMaxQty = offer.getUserLimit();
         LocalDate today = LocalDate.now();
         boolean isMoreGiftAvailable = checkGiftAvailability(today, perDayMaxQty);
         logger.info("Gift availability result: {}", isMoreGiftAvailable);
+        if (allGifts.isEmpty()) {
+            logger.warn("Offer {} has no gifts - cannot process scratch offer", offer.getId());
+            return false;
+        }
         if (!isMoreGiftAvailable) {
             logger.info("Daily limit reached - assigning default gift");
             createScratchOffer(fofoOrder, offer, allGifts.get(0));
             return true;
+        }
     private boolean isItemCategoryEligible(String giftCategories, Integer itemCategoryId) {
         logger.info
                 ("Checking if item category {} is in gift categories: {}", itemCategoryId, giftCategories);
-        // Handle null or empty categories
         if (giftCategories == null || giftCategories.trim().isEmpty()) {
             return false;
+        }
         return Arrays.stream(giftCategories.split(","))
                 .map(category -> {
                     try {
                         return Integer.parseInt(category.trim());
                     } catch (NumberFormatException e) {
                         logger.warn("Invalid category format in gift categories: {}", category);
-                        return -1; // Will not match any real category ID
+                        return -1;
+                    }
                 })
                 .anyMatch(itemCategoryId::equals);
+    }
         return gifts.get(0);
+    }
     private GiftEntity handleRandomGifts(List<GiftEntity> gifts) {
         logger.info("Handling Random gifts selection from {} gifts", gifts.size());
-        // Create a new list for remaining gifts to avoid modifying the original list
         List<GiftEntity> giftPool = new ArrayList<>(gifts.subList(0, gifts.size()));
-        // Shuffle the gift pool to increase randomness
         Collections.shuffle(giftPool);
-        // Find a valid gift from the shuffled pool
         return giftPool.get(0);
+    }
     private GiftEntity handlePartnerWiseGifts(List<GiftEntity> gifts, FofoOrder order) {
         int fofoId = order.getFofoId();
         logger.info("Handling PartnerWise gifts selection from {} gifts for fofoId {}", gifts.size(), fofoId);
-        // Stream approach - consistent with FindEligibleOffer method
         return gifts.stream()
                 .filter(gift -> {
                     String[] fofoStores = gift.getFofoStore().split(",");
                     return Arrays.stream(fofoStores)
                             .map(storeId -> {
                                 try {
                                     return Integer.parseInt(storeId.trim());
                                 } catch (NumberFormatException e) {
                                     logger.warn("Invalid fofoId format in gift {}: {}", gift.getId(), storeId);
-                                    return -1; // Invalid ID that won't match
+                                    return -1;
+                                }
                             })
                             .anyMatch(storeId -> storeId == fofoId);
                 })
                 .findFirst()
         // TODO: Add brand-specific logic
         logger.warn("BrandSpecific gift selection not implemented yet");
         return null;
+    }
+    @Transactional(propagation = Propagation.REQUIRES_NEW)
-    private void createScratchOffer(FofoOrder order, OfferEntity offer, GiftEntity gift) {
+    public void createScratchOffer(FofoOrder order, OfferEntity offer, GiftEntity gift) {
+        try {
+            GiftEntity currentGift = giftRepository.findById(gift.getId());
+            if (currentGift == null || currentGift.getMaxRedemptions() <= 0) {
+                logger.warn("Gift {} has no remaining redemptions", gift.getId());
+                return;
+            }
+            // Decrement and save
+            currentGift.setMaxRedemptions(currentGift.getMaxRedemptions() - 1);
+            giftRepository.save(currentGift);
-        ScratchOffer so = new ScratchOffer();
+            ScratchOffer so = new ScratchOffer();
-        so.setCustomerId(order.getCustomerId());
+            so.setCustomerId(order.getCustomerId());
-        so.setOfferId(offer.getId());
+            so.setOfferId(offer.getId());
-        so.setGiftId(gift.getId());
+            so.setGiftId(gift.getId());
-        so.setInvoiceNumber(order.getInvoiceNumber());
+            so.setInvoiceNumber(order.getInvoiceNumber());
-        so.setCreatedTimestamp(LocalDateTime.now());
+            so.setCreatedTimestamp(LocalDateTime.now());
-        so.setOfferName(gift.getName());
+            so.setOfferName(gift.getName());
-        gift.setMaxRedemptions(gift.getMaxRedemptions() - 1);
-        scratchOfferRepository.persist(so);
+            scratchOfferRepository.persist(so);
-        logger.info("Created scratch offer: {}", so);
+            logger.info("Created scratch offer: {}", so);
+        } catch (Exception e) {
+            logger.error("Error creating scratch offer: {}", e.getMessage());
+        }
+    }
     public boolean createOffer(ScratchRequest request) {
         OfferEntity offer = mapToOfferEntity(request);
         seasonalOfferRepository.save(offer);
         List<GiftEntity> gifts = mapToGiftEntities(request.getGifts(), offer.getId());
         gifts.forEach(giftRepository::save);

Subversion Repositories SmartDukaan

(root)/trunk/profitmandi-dao/src/main/java/com/spice/profitmandi/dao/service/ScratchService.java – Rev 34804 → 35095