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.Transactional;
 import java.time.LocalDate;
 import java.time.LocalDateTime;
 import java.time.LocalTime;
 import java.util.*;
     @Autowired
     FofoOrderRepository fofoOrderRepository;
     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("Processing order item: {}", orderItemId);
-            Item item = this.getItemById(orderItemId);
-            Integer itemCategoryId = item.getCategoryId();
-            logger.info("Item category ID: {}", itemCategoryId);
-            // Find active offer
-            List<OfferEntity> activeOffers = seasonalOfferRepository.getOffersByDate(today);
+        List<OfferEntity> activeOffers = seasonalOfferRepository.getOffersByDate(LocalDate.now());
-            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()))
-//                    .anyMatch(paymentId -> !allowedPaymentMethods.contains(paymentId));
-//            // proceed with default because user payment method doest not match
-//            if (isOtherPaymentUsed) {
+        if (activeOffers.isEmpty()) {
-//                logger.info("Customer {} has chosen a different mode of payment.", fofoOrder.getCustomerId());
-//                return;
+            return;
-//            }
+        }
-            if (eligibleOffer != null) {
-                logger.info("Found active offer: {}", eligibleOffer.getId());
-                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;
-                }
-                if (this.processOffer(eligibleOffer, fofoOrder, itemCategoryId)) {
+        FofoOrder fofoOrder = fofoOrderRepository.selectByOrderId(fofoOrderId);
-                    logger.info("Successfully processed offer for item: {}", orderItemId);
+        OfferEntity eligibleOffer = findEligibleOffer(activeOffers, fofoOrder);
-                    break;
-                } else {
+        if (eligibleOffer == null) {
-                    logger.info("Failed to process offer for item: {}", orderItemId);
+            logger.info("No eligible offer for order {}", fofoOrderId);
-                }
-            } else {
+            return;
-                logger.info("No active offers found for today: {}", today);
-            }
+        }
+        ScratchOffer availedOffer = scratchOfferRepository.getScractchOfferByCustomerIdAndOfferId(fofoOrder.getCustomerId(), eligibleOffer.getId());
+        if (availedOffer != null) {
-            logger.info("No eligible gifts found for any items in order: {}", fofoOrder.getId());
+            logger.info("Customer {} already availed offer {}", fofoOrder.getCustomerId(), eligibleOffer.getId());
             return;
+        }
-        logger.info("No eligible gifts found for any items in order: {}", fofoOrder.getId());
+        this.processOffer(eligibleOffer, fofoOrder);
+    }
-    private OfferEntity FindEligibleOffer(List<OfferEntity> activeOffers, FofoOrder fofoOrder) {
+    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());
+        // Check PartnerWise offers first
         for (OfferEntity activeOffer : activeOffers) {
-            logger.info("Checking offer ID: {} with classification: {}", activeOffer.getId(), activeOffer.getClassification());
-            if ("PartnerWise".equals(activeOffer.getClassification())) {
+            if (!"PartnerWise".equals(activeOffer.getClassification())) {
+                continue;
+            }
-                List<GiftEntity> gifts = giftRepository.findByOfferId(activeOffer.getId());
+            List<GiftEntity> gifts = giftRepository.findByOfferId(activeOffer.getId());
-                logger.info("Found {} gifts for PartnerWise offer {}", gifts.size(), activeOffer.getId());
-                if (gifts.isEmpty()) {
+            for (GiftEntity gift : gifts) {
-                    logger.warn("No gifts found for PartnerWise offer {}", activeOffer.getId());
+                if (gift.getFofoStore() == null || gift.getFofoStore().trim().isEmpty()) {
                     continue;
+                }
-                for (GiftEntity gift : gifts) {
-                    logger.info("Checking gift ID: {} with fofoStore: '{}'", gift.getId(), gift.getFofoStore());
-                    if (gift.getFofoStore() == null || gift.getFofoStore().trim().isEmpty()) {
+                boolean matches = Arrays.stream(gift.getFofoStore().split(","))
-                        logger.warn("Gift {} has null/empty fofoStore - skipping", gift.getId());
-                        continue;
+                        .map(String::trim)
-                    }
-                    String[] fofoStores = gift.getFofoStore().split(",");
-                    logger.info("Gift {} fofoStores array: {}", gift.getId(), Arrays.toString(fofoStores));
-                    boolean isEligible = Arrays.stream(fofoStores)
-                            .filter(store -> !store.trim().isEmpty())
+                        .filter(s -> !s.isEmpty())
-                            .map(store -> {
+                        .anyMatch(store -> {
-                                try {
+                            try {
-                                    int storeId = Integer.parseInt(store.trim());
+                                return Integer.parseInt(store) == customerFofoId;
-                                    logger.info("Parsed fofoStore: {} (comparing with customer fofoId: {})", storeId, customerFofoId);
-                                    return storeId;
-                                } catch (NumberFormatException e) {
+                            } catch (NumberFormatException e) {
-                                    logger.warn("Invalid fofoId format in gift {}: '{}' - skipping", gift.getId(), store);
-                                    return -1;
+                                return false;
-                                }
-                            })
+                            }
-                            .anyMatch(fofoStore -> {
-                                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) {
+                if (matches) {
-                        logger.info("Found matching PartnerWise offer: {} for customer fofoId: {}", activeOffer.getId(), customerFofoId);
-                        return activeOffer;
+                    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());
+            }
+        }
-        logger.info("No PartnerWise offers matched. Looking for non-PartnerWise offers...");
+        // Fallback to first non-PartnerWise offer
-        List<OfferEntity> nonPartnerWiseOffers = activeOffers.stream()
+        return activeOffers.stream()
                 .filter(offer -> !"PartnerWise".equals(offer.getClassification()))
-                .collect(Collectors.toList());
+                .findFirst()
-        logger.info("Found {} non-PartnerWise offers", nonPartnerWiseOffers.size());
-        OfferEntity selectedOffer = nonPartnerWiseOffers.stream().findFirst().orElse(null);
-        if (selectedOffer != null) {
+                .orElse(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);
-        }
-        return item;
-    }
     private boolean checkGiftAvailability(LocalDate date, int perDayMaxQty, OfferEntity offer) {
-        int defaultGiftId = giftRepository.getDefaultGift(offer.getId()).getId();
+        GiftEntity defaultGift = giftRepository.getDefaultGift(offer.getId());
+        if (defaultGift == null) return false;
-        Integer giftCounts = scratchOfferRepository.countTodaysGiftDistribution(date.atStartOfDay(), date.atTime(LocalTime.MAX), defaultGiftId);
+        Integer giftCounts = scratchOfferRepository.countTodaysGiftDistribution(date.atStartOfDay(), date.atTime(LocalTime.MAX), defaultGift.getId());
         return giftCounts < perDayMaxQty;
+    }
     private boolean isAppleItem(FofoOrder fofoOrder) {
         List<FofoOrderItem> fofoOrderItems = fofoOrderItemRepository.selectByOrderId(fofoOrder.getId());
         if (fofoOrderItems == null || fofoOrderItems.isEmpty()) {
             return false;
+        }
-        for (FofoOrderItem item : fofoOrderItems) {
+        return fofoOrderItems.stream()
-            if (item != null && item.getBrand() != null && item.getBrand().equalsIgnoreCase("apple")) {
+                .anyMatch(item -> item != null && "apple".equalsIgnoreCase(item.getBrand()));
-                return true;
-            }
-        }
-        return false;
+    }
-    private boolean processOffer(OfferEntity offer, FofoOrder fofoOrder, Integer itemCategoryId) {
+    private boolean processOffer(OfferEntity offer, FofoOrder fofoOrder) {
-        List<GiftEntity> allGifts = giftRepository.findNonDefaultGIft(offer.getId());
         logger.info("Processing offer {} for order {}", offer.getId(), fofoOrder.getId());
+        List<GiftEntity> allGifts = giftRepository.findNonDefaultGIft(offer.getId());
+        GiftEntity defaultGift = giftRepository.getDefaultGift(offer.getId());
+        if (allGifts.isEmpty()) {
+            logger.warn("Offer {} has no gifts", offer.getId());
+            return false;
+        }
+        // Apple items always get the last gift
         if (isAppleItem(fofoOrder)) {
             GiftEntity lastGift = allGifts.get(allGifts.size() - 1);
             if (lastGift.getMaxRedemptions() > 0) {
                 createScratchOffer(fofoOrder, offer, lastGift);
-                logger.info("Apple item detected, assigned last gift: {}", lastGift.getName());
             } else {
-                logger.info("Apple last gift exhausted, assigning Better Luck Next Time");
                 createBetterLuckNextTimeScratch(fofoOrder, offer);
+            }
             return true;
+        }
-        int perDayMaxQty = offer.getUserLimit();
-        LocalDate today = LocalDate.now();
-        boolean isMoreGiftAvailable = checkGiftAvailability(today, perDayMaxQty, offer);
-        logger.info("Gift availability result: {}", isMoreGiftAvailable);
-        if (allGifts.isEmpty()) {
-            logger.warn("Offer {} has no gifts - cannot process scratch offer", offer.getId());
-            return false;
+        // Check daily limit
-        }
-        if (!isMoreGiftAvailable) {
-            logger.info("Daily limit reached - assigning default gift");
+        if (!checkGiftAvailability(LocalDate.now(), offer.getUserLimit(), offer)) {
-            createDefaultGiftScratch(fofoOrder, offer, giftRepository.getDefaultGift(offer.getId()));
+            createDefaultGiftScratch(fofoOrder, offer, defaultGift);
             return true;
+        }
+        // Find eligible gifts by cart value and category
+        List<FofoOrderItem> orderItems = fofoOrderItemRepository.selectByOrderId(fofoOrder.getId());
+        Set<Integer> itemCategoryIds = new HashSet<>();
+        for (FofoOrderItem orderItem : orderItems) {
+            try {
+                Item item = itemRepository.selectById(orderItem.getItemId());
-        // Get eligible gifts
+                if (item != null) {
+                    itemCategoryIds.add(item.getCategoryId());
+                }
+            } catch (ProfitMandiBusinessException e) {
+                logger.warn("Item {} not found", orderItem.getItemId());
+            }
+        }
+        float totalAmount = fofoOrder.getTotalAmount();
+        List<GiftEntity> allOfferGifts = giftRepository.findByOfferId(offer.getId());
-        List<GiftEntity> eligibleGifts = findEligibleGifts(offer, fofoOrder, itemCategoryId);
+        List<GiftEntity> eligibleGifts = allOfferGifts.stream()
+                .filter(gift -> gift.getMaxRedemptions() > 0
+                        && totalAmount >= gift.getMinCartValue()
+                        && totalAmount <= gift.getMaxCartValue()
+                        && itemCategoryIds.stream().anyMatch(catId -> isItemCategoryEligible(gift.getProductCategory(), catId)))
+                .collect(Collectors.toList());
         if (eligibleGifts.isEmpty()) {
-            logger.info("No eligible gifts found for offer: {}", offer.getId());
-            createDefaultGiftScratch(fofoOrder, offer, giftRepository.getDefaultGift(offer.getId()));
+            createDefaultGiftScratch(fofoOrder, offer, defaultGift);
             return true;
+        }
-        logger.info("Found {} eligible gifts for offer {}", eligibleGifts.size(), offer.getId());
-        // Select gift based on classification
         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));
+            createDefaultGiftScratch(fofoOrder, offer, defaultGift);
             return true;
+        }
-        logger.info("Selected gift: {} for order: {}", selectedGift.getId(), fofoOrder.getId());
-        // Create scratch offer
         createScratchOffer(fofoOrder, offer, selectedGift);
-        logger.info("Created scratch offer for order: {}", fofoOrder.getId());
         return true;
+    }
-    private List<GiftEntity> findEligibleGifts(OfferEntity offer, FofoOrder fofoOrder, Integer itemCategoryId) {
-        logger.info("Finding eligible gifts for offer: {} and category: {}", offer.getId(), itemCategoryId);
-        List<GiftEntity> activeOfferGifts = giftRepository.findByOfferId(offer.getId());
-        logger.info("Total gifts for offer {}: {}", offer.getId(), activeOfferGifts.size());
-        float totalAmount = fofoOrder.getTotalAmount();
-        logger.info("Order total amount: {}", totalAmount);
-        List<GiftEntity> eligibleGifts = activeOfferGifts.stream().filter(gift -> isGiftEligible(gift, totalAmount, itemCategoryId)).collect(Collectors.toList());
-        logger.info("Filtered to {} eligible gifts", eligibleGifts.size());
-        for (GiftEntity gift : activeOfferGifts) {
-            boolean isEligible = isGiftEligible(gift, totalAmount, itemCategoryId);
-            logger.info("Gift ID: {}, Name: {}, MinCart: {}, MaxCart: {}, Categories: {}, MaxRedemptions: {}, Eligible: {}",
-                    gift.getId(), gift.getName(), gift.getMinCartValue(), gift.getMaxCartValue(),
-                    gift.getProductCategory(), gift.getMaxRedemptions(), isEligible);
-        }
-        return eligibleGifts;
-    }
-    private boolean isGiftEligible(GiftEntity gift, float totalAmount, Integer itemCategoryId) {
-        logger.info("Checking eligibility for gift: {}", gift.getId());
-        // Check cart value condition
-        boolean cartValueCondition = totalAmount >= gift.getMinCartValue() && totalAmount <= gift.getMaxCartValue() && gift.getMaxRedemptions() > 0;
-        logger.info(
-                "Gift {} cart value condition: {} (order amount: {}, min: {}, max: {}, max redemptions: {})",
-                gift.getId(), cartValueCondition, totalAmount,
-                gift.getMinCartValue(), gift.getMaxCartValue(),
-                gift.getMaxRedemptions());
-        // Check category condition
-        boolean categoryCondition = isItemCategoryEligible(gift.getProductCategory(), itemCategoryId);
-        logger.info
-                ("Gift {} category condition: {} (item category: {}, gift categories: {})", gift.getId(), categoryCondition, itemCategoryId, gift.getProductCategory());
-        boolean isEligible = cartValueCondition && categoryCondition;
-        logger.info
-                ("Gift {} is eligible: {}", gift.getId(), isEligible);
-        return isEligible;
-    }
     private boolean isItemCategoryEligible(String giftCategories, Integer itemCategoryId) {
-        logger.info
-                ("Checking if item category {} is in gift categories: {}", itemCategoryId, giftCategories);
         if (giftCategories == null || giftCategories.trim().isEmpty()) {
             return false;
+        }
         return Arrays.stream(giftCategories.split(","))
+                .map(String::trim)
-                .filter(category -> !category.trim().isEmpty()) // Filter out empty strings
+                .filter(s -> !s.isEmpty())
                 .map(category -> {
                     try {
-                        return Integer.parseInt(category.trim());
+                        return Integer.parseInt(category);
                     } catch (NumberFormatException e) {
-                        logger.warn("Invalid category format in gift categories: {}", category);
                         return -1;
+                    }
                 })
                 .anyMatch(itemCategoryId::equals);
+    }
     private GiftEntity selectGiftByClassification(OfferEntity offer, List<GiftEntity> eligibleGifts, FofoOrder fofoOrder) {
-        String classification = offer.getClassification();
-        logger.info("Selecting gift by classification: {}", classification);
-        GiftEntity selectedGift;
-        switch (classification) {
+        switch (offer.getClassification()) {
             case "Serial":
-                logger.info("Using Serial gift selection strategy");
-                selectedGift = handleSerialGifts(eligibleGifts);
+                return eligibleGifts.get(0);
-                break;
             case "Random":
-                logger.info("Using Random gift selection strategy");
+                List<GiftEntity> shuffled = new ArrayList<>(eligibleGifts);
-                selectedGift = handleRandomGifts(eligibleGifts);
+                Collections.shuffle(shuffled);
-                break;
+                return shuffled.get(0);
             case "PartnerWise":
+                int fofoId = fofoOrder.getFofoId();
+                return eligibleGifts.stream()
-                logger.info("Using PartnerWise gift selection strategy");
+                        .filter(gift -> gift.getFofoStore() != null
-                selectedGift = handlePartnerWiseGifts(eligibleGifts, fofoOrder);
+                                && Arrays.stream(gift.getFofoStore().split(","))
-                break;
+                                .map(String::trim)
-            case "BrandSpecific":
+                                .anyMatch(s -> {
-                logger.info("Using BrandSpecific gift selection strategy");
+                                    try { return Integer.parseInt(s) == fofoId; }
-                selectedGift = handleBrandSpecificGifts(eligibleGifts, fofoOrder);
+                                    catch (NumberFormatException e) { return false; }
+                                }))
+                        .findFirst()
-                break;
+                        .orElse(null);
             default:
-                logger.warn("Unknown classification: {}", classification);
+                logger.warn("Unknown classification: {}", offer.getClassification());
-                selectedGift = null;
+                return null;
+        }
-        if (selectedGift != null) {
-            logger.info("Selected gift: {}", selectedGift.getId());
-        } else {
-            logger.warn("No gift selected for classification: {}", classification);
-        }
-        return selectedGift;
-    }
-    private GiftEntity handleSerialGifts(List<GiftEntity> gifts) {
-        logger.info("Handling Serial gifts selection from {} gifts", gifts.size());
-        return gifts.get(0);
-    }
-    private GiftEntity handleRandomGifts(List<GiftEntity> gifts) {
-        logger.info("Handling Random gifts selection from {} gifts", gifts.size());
-        List<GiftEntity> giftPool = new ArrayList<>(gifts.subList(0, gifts.size()));
-        Collections.shuffle(giftPool);
-        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);
-        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;
-                                }
-                            })
-                            .anyMatch(storeId -> storeId == fofoId);
-                })
-                .findFirst()
-                .orElse(null);
-    }
-    private GiftEntity handleBrandSpecificGifts(List<GiftEntity> gifts, FofoOrder order) {
-        logger.info("Handling BrandSpecific gifts selection from {} gifts for order {}", gifts.size(), order.getId());
-        // TODO: Add brand-specific logic
-        logger.warn("BrandSpecific gift selection not implemented yet");
-        return null;
+    }
     public void createBetterLuckNextTimeScratch(FofoOrder order, OfferEntity offer) {
-        try {
-            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(1);
+        so.setGiftId(1);
-            so.setInvoiceNumber(order.getInvoiceNumber());
+        so.setInvoiceNumber(order.getInvoiceNumber());
-            so.setCreatedTimestamp(LocalDateTime.now());
+        so.setCreatedTimestamp(LocalDateTime.now());
-            so.setOfferName(offer.getName());
+        so.setOfferName(offer.getName());
-            scratchOfferRepository.persist(so);
+        scratchOfferRepository.persist(so);
-            logger.info("Created Better Luck Next Time scratch offer: {}", so);
-        } catch (Exception e) {
-            logger.error("Error creating Better Luck Next Time scratch offer: {}", e.getMessage());
-        }
+    }
     public void createScratchOffer(FofoOrder order, OfferEntity offer, GiftEntity gift) {
-        try {
-            GiftEntity currentGift = giftRepository.findById(gift.getId());
+        int updated = giftRepository.decrementMaxRedemptions(gift.getId());
-            if (currentGift == null || currentGift.getMaxRedemptions() <= 0) {
+        if (updated == 0) {
-                logger.warn("Gift {} has no remaining redemptions", gift.getId());
+            logger.warn("Gift {} has no remaining redemptions", gift.getId());
-                return;
+            return;
-            }
-            currentGift.setMaxRedemptions(currentGift.getMaxRedemptions() - 1);
-            giftRepository.save(currentGift);
-            ScratchOffer so = new ScratchOffer();
-            so.setCustomerId(order.getCustomerId());
-            so.setOfferId(offer.getId());
-            so.setGiftId(gift.getId());
-            so.setInvoiceNumber(order.getInvoiceNumber());
-            so.setCreatedTimestamp(LocalDateTime.now());
-            so.setOfferName(gift.getName());
-            scratchOfferRepository.persist(so);
-            logger.info("Created scratch offer: {}", so);
-        } catch (Exception e) {
-            logger.error("Error creating scratch offer: {}", e.getMessage());
+        }
+        ScratchOffer so = new ScratchOffer();
+        so.setCustomerId(order.getCustomerId());
+        so.setOfferId(offer.getId());
+        so.setGiftId(gift.getId());
+        so.setInvoiceNumber(order.getInvoiceNumber());
+        so.setCreatedTimestamp(LocalDateTime.now());
+        so.setOfferName(gift.getName());
+        scratchOfferRepository.persist(so);
+        logger.info("Created scratch offer for order {} gift {}", order.getId(), gift.getId());
+    }
     public void createDefaultGiftScratch(FofoOrder order, OfferEntity offer, GiftEntity gift) {
-        try {
-            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());
-            scratchOfferRepository.persist(so);
+        scratchOfferRepository.persist(so);
-            logger.info("Created default (unlimited) scratch offer: {}", so);
-        } catch (Exception e) {
-            logger.error("Error creating default scratch offer: {}", e.getMessage());
-        }
+    }
     public boolean createOffer(ScratchRequest request) {
         OfferEntity offer = mapToOfferEntity(request);

Subversion Repositories SmartDukaan

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