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

 package com.spice.profitmandi.dao.service;
 import com.spice.profitmandi.common.exception.ProfitMandiBusinessException;
-import com.spice.profitmandi.common.model.CustomFofoOrderItem;
 import com.spice.profitmandi.common.model.CustomPaymentOption;
 import com.spice.profitmandi.dao.entity.catalog.Item;
 import com.spice.profitmandi.dao.entity.dtr.ScratchOffer;
 import com.spice.profitmandi.dao.entity.fofo.FofoOrder;
 import com.spice.profitmandi.dao.entity.scratch.GiftEntity;
 import java.util.stream.Collectors;
 @Service
 @Transactional(rollbackFor = Throwable.class)
 public class ScratchService {
-    private static final Logger LOGGER = LogManager.getLogger(ScratchService.class);
     private static final Logger logger = LogManager.getLogger(ScratchService.class);
     @Autowired
     SeasonalOfferRepository seasonalOfferRepository;
     @Autowired
     GiftRepository giftRepository;
     FofoOrderItemRepository fofoOrderItemRepository;
     @Autowired
     ItemRepository itemRepository;
     @Autowired
     FofoOrderRepository fofoOrderRepository;
+//    @Transactional(propagation = Propagation.REQUIRES_NEW)
-    public void processScratchOffer(int fofoOrderId, Set<CustomPaymentOption> paymentOptions, Set<CustomFofoOrderItem> fofoOrderItems) throws ProfitMandiBusinessException {
+    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 (CustomFofoOrderItem orderItem : fofoOrderItems) {
+        for (Integer orderItemId : fofoOrderItemIds) {
-            logger.info("Processing order item: {}", orderItem.getItemId());
+            logger.info("Processing order item: {}", orderItemId);
-            Item item = this.getItemById(orderItem.getItemId());
+            Item item = this.getItemById(orderItemId);
             Integer itemCategoryId = item.getCategoryId();
             logger.info("Item category ID: {}", itemCategoryId);
             // Find active offer
             List<OfferEntity> activeOffers = seasonalOfferRepository.getOffersByDate(today);
+            logger.info("Found Active offer: {}", activeOffers);
             OfferEntity eligibleOffer = FindEligibleOffer(activeOffers, fofoOrder);
+//            Set<String> allowedPaymentMethods = Arrays.stream(eligibleOffer.getPaymentMethod().split(","))
+//                    .collect(Collectors.toSet());
+//
+//            boolean isOtherPaymentUsed = paymentOptions.stream()
+//                    .map(option -> String.valueOf(option.getPaymentOptionId())) // Replace with the correct getter
+//                    .anyMatch(paymentId -> !allowedPaymentMethods.contains(paymentId));
+//            // proceed with default because user payment method doest not match
+//            if (isOtherPaymentUsed) {
+//                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
                     return; // Customer already has this offer
+                }
                 // 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: {}", orderItem.getItemId());
+                    logger.info("Successfully processed offer for item: {}", orderItemId);
                     return; // Successfully processed an offer
                 } else {
-                    logger.info("Failed to process offer for item: {}", orderItem.getItemId());
+                    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());
+    }
     private OfferEntity FindEligibleOffer(List<OfferEntity> activeOffers, FofoOrder fofoOrder) {
-        int customerFofoId = fofoOrder.getFofoId(); // Changed to int
+        int customerFofoId = fofoOrder.getFofoId();
-        // First try to find a PARTNERWISE offer that matches the customer's FofoId
         for (OfferEntity activeOffer : activeOffers) {
             if ("PartnerWise".equals(activeOffer.getClassification())) {
                 List<GiftEntity> gifts = giftRepository.findByOfferId(activeOffer.getId());
                 for (GiftEntity gift : gifts) {
-                    // Check if the customer's FofoId is in the gift's FofoStore list
                     String[] fofoStores = gift.getFofoStore().split(",");
                     boolean isEligible = Arrays.stream(fofoStores)
                             .map(Integer::parseInt) // Convert string to int
-                            .anyMatch(fofoStore -> fofoStore == customerFofoId); // Use == for int comparison
+                            .anyMatch(fofoStore -> fofoStore == customerFofoId);
                     if (isEligible) {
                         return activeOffer;  // Return the matching PARTNERWISE offer
+                    }
+                }
+            }
         GiftEntity selectedGift = selectGiftByClassification(offer, eligibleGifts, fofoOrder);
         if (selectedGift == null || selectedGift.getMaxRedemptions() <= 0) {
             logger.info("No valid gift selected for offer: {}", offer.getId());
             createScratchOffer(fofoOrder, offer, allGifts.get(0));
-            return false;
+            return true;
+        }
         logger.info("Selected gift: {} for order: {}", selectedGift.getId(), fofoOrder.getId());
         // Create scratch offer
         so.setCreatedTimestamp(LocalDateTime.now());
         so.setOfferName(gift.getName());
         gift.setMaxRedemptions(gift.getMaxRedemptions() - 1);
         scratchOfferRepository.persist(so);
-        LOGGER.info("Created scratch offer: {}", so);
+        logger.info("Created scratch offer: {}", so);
+    }
     public boolean createOffer(ScratchRequest request) {
         OfferEntity offer = mapToOfferEntity(request);
         seasonalOfferRepository.save(offer);
         offer.setUserLimit(request.getUserLimit());
         offer.setScratchValidity(request.getScratchValidity());
         offer.setProductCategory(request.getProductCategory());
         offer.setPaymentMethod(request.getPaymentMethod());
         offer.setClassification(request.getClassification());
-        LOGGER.info("active flag - " + request.isActive());
+        logger.info("active flag - " + request.isActive());
         offer.setActive(request.isActive());
         return offer;
+    }
     //gift
     private List<GiftEntity> mapToGiftEntities(List<ScratchRequest.GiftData> giftsData, Integer offerId) {
         return giftsData.stream().map(giftData -> {
-            LOGGER.info("giftData: {}", giftData);
+            logger.info("giftData: {}", giftData);
             GiftEntity gift = new GiftEntity();
             gift.setName(giftData.getName());
             gift.setThumbnailUrl(giftData.getThumbnailUrl());
             gift.setMinCartValue(giftData.getMinCartValue());
             gift.setMaxRedemptions(giftData.getMaxRedemptions());

Subversion Repositories SmartDukaan

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