Subversion Repositories SmartDukaan

import com.spice.profitmandi.common.util.Utils;

import com.spice.profitmandi.dao.entity.fofo.FofoLineItem;

import com.spice.profitmandi.dao.entity.fofo.FofoOrderItem;

import com.spice.profitmandi.dao.entity.transaction.LineItem;

import com.spice.profitmandi.dao.entity.transaction.Order;

import com.spice.profitmandi.dao.entity.warehouse.WarehouseInventoryItem;

import com.spice.profitmandi.dao.entity.warehouse.WarehouseScan;

import com.spice.profitmandi.dao.enumuration.catalog.AchievementType;

import com.spice.profitmandi.dao.model.OfferRowModel;

import com.spice.profitmandi.dao.repository.fofo.ActivatedImeiRepository;

import com.spice.profitmandi.dao.repository.fofo.FofoOrderRepository;

import com.spice.profitmandi.dao.repository.fofo.InventoryItemRepository;

import com.spice.profitmandi.dao.repository.transaction.LineItemImeisRepository;

import com.spice.profitmandi.dao.repository.warehouse.WarehouseInventoryItemRepository;

import com.spice.profitmandi.service.pricecircular.PriceCircularService;

import com.spice.profitmandi.service.scheme.InventoryPayoutModel;

    @Autowired

    PriceCircularService priceCircularService;

    @Autowired

    private ActivatedImeiRepository activatedImeiRepository;

    @Autowired

    @Autowired

    private WarehouseInventoryItemRepository warehouseInventoryItemRepository;

    @Autowired

    private LineItemImeisRepository lineItemImeisRepository;

    @Autowired

    private InventoryItemRepository inventoryItemRepository;

    private double getAmount(InventoryPayoutModel inventoryPayoutModel, AmountModel amountModel) {

        double rollout = 0;

        if (amountModel.getAmountType().equals(AmountType.PERCENTAGE)) {

            double effectiveDp = inventoryPayoutModel.getDp() - inventoryPayoutModel.getFixedAmount();

            double totalPercentage = inventoryPayoutModel.getPercentageAmount() + amountModel.getAmount();

            rollout = effectiveDp * (totalPercentage / (100 + totalPercentage) - (inventoryPayoutModel.getPercentageAmount() / (100 + inventoryPayoutModel.getPercentageAmount())));

        } else {

            rollout = amountModel.getAmount() * (100 / (100 + inventoryPayoutModel.getPercentageAmount()));

        }

        return rollout;

    }

    @Override

    public void processActivationtOffer(CreateOfferRequest createOfferRequest) throws ProfitMandiBusinessException {

        //List<OfferRowModel> offerRowModels = new ArrayList<>();

        List<OfferPayout> offerPayouts = offerPayoutRepository.selectAllByOfferId(createOfferRequest.getId());

        List<ItemCriteriaPayout> itemCriteriaPayouts = createOfferRequest.getTargetSlabs().get(0).getItemCriteriaPayouts();

        Map<Integer, ItemCriteriaPayout> itemCriteriaPayoutMap = itemCriteriaPayouts.stream().collect(Collectors.toMap(x -> x.getItemCriteria().getId(), x -> x));

        Map<Integer, Map<Integer, Double>> fixedSlabCriteriaPartnerMap = offerPayouts.stream().filter(x -> itemCriteriaPayoutMap.get(x.getCriteriaId()).getAmountType().equals(AmountType.SLAB_FIXED))

                .collect(Collectors.groupingBy(x -> (int) x.getCriteriaId(), Collectors.groupingBy(x -> (int) x.getFofoId(), Collectors.summingDouble(x -> x.getSlabAmount()))));

        Map<String, Double> serialNumberPaid = offerPayouts.stream().filter(x -> x.getRejectTimestamp() == null).collect(Collectors.groupingBy(x -> x.getSerialNumber(), Collectors.summingDouble(x -> x.getSlabAmount())));

        /*if (offerPayouts.size() > 0) {

            throw new ProfitMandiBusinessException("Offer Already Processed", "Offer Already Processed", "Offer Already Processed");

        }*/

        Map<Integer, Map<Integer, List<FofoOrderItem>>> criteriaPartnerwiseTertiary = offerRepository.getCriteriaWisePartnerTertiary(createOfferRequest);

        final Set<String> activatedImeis;

        final Set<String> missingImeis;

        if (createOfferRequest.getSchemeType().equals(OfferSchemeType.ACTIVATION)) {

            //All Serialnumbers for all eligible retailers

            List<String> serialNumbers = criteriaPartnerwiseTertiary.entrySet().stream().flatMap(x -> x.getValue().entrySet().stream().flatMap(foiList -> foiList.getValue().stream()))

                    .flatMap(y -> y.getFofoLineItems().stream()).filter(fli -> fli.getSerialNumber() != null)

                    .map(x -> x.getSerialNumber()).collect(Collectors.toList());

            if (serialNumbers.size() > 0) {

                activatedImeis = activatedImeiRepository.selectBySerialNumbers(serialNumbers).stream()

                        .filter(x -> createOfferRequest.isWithinRange(x.getActivationTimestamp()))

                        .map(x -> x.getSerialNumber()).collect(Collectors.toSet());

                //missingImeis = serialNumbers.stream().filter(x -> !activatedImeis.contains(x)).collect(Collectors.toSet());

                //activatedImeis.addAll(missingImeis);

                //serialNumbers.removeAll(activatedImeis);

            } else {

                activatedImeis = null;

            }

            // TODO Amit

            /**

             * Missing imeis are considered as activated as long as payout calculations are

             * concerned - Add flag if calculations are meant for final payout(Wherein

             * missing imeis are no longer considered to be activated)

             **/

        } else {

            activatedImeis = null;

        }

        Map<Integer, Integer> userBaseQtyMap = new HashMap<>();

        Map<Integer, Integer> userBaseValueMap = new HashMap<>();

        Map<Integer, Integer> eligibleBaseQtyMap = new HashMap<>();

        Map<Integer, Integer> eligibleBaseValueMap = new HashMap<>();

        if (createOfferRequest.isBaseCriteria()) {

            Map<Integer, List<FofoOrderItem>> foiMap = criteriaPartnerwiseTertiary.get(0);

            for (Map.Entry<Integer, List<FofoOrderItem>> orderEntry : foiMap.entrySet()) {

                int fofoId = orderEntry.getKey();

                List<FofoOrderItem> fofoOrderItems = orderEntry.getValue();

                int totalBaseQty = fofoOrderItems.stream().collect(Collectors.summingInt(x -> (x.getQuantity())));

                int totalBaseValue = fofoOrderItems.stream().collect(Collectors.summingInt(x -> (Math.round(x.getDp())) * x.getQuantity()));

                userBaseQtyMap.put(fofoId, totalBaseQty);

                userBaseValueMap.put(fofoId, totalBaseValue);

                if (createOfferRequest.getSchemeType().equals(OfferSchemeType.ACTIVATION)) {

                    Map<Integer, Integer> inventoryItemValueMap = new HashMap<>();

                    for (FofoOrderItem fofoOrderItem : fofoOrderItems) {

                        fofoOrderItem.getFofoLineItems().stream().filter(x -> x.getSerialNumber() != null).forEach(

                                lineItem -> {

                                    if (activatedImeis == null || activatedImeis.contains(lineItem.getSerialNumber())) {

                                        inventoryItemValueMap.put(lineItem.getInventoryItemId(), (int) fofoOrderItem.getDp());

                                    }

                                }

                        );

                    }

                    eligibleBaseQtyMap.put(fofoId, inventoryItemValueMap.size());

                    eligibleBaseValueMap.put(fofoId, inventoryItemValueMap.entrySet().stream().collect(Collectors.summingInt(x -> x.getValue())));

                } else {

                    eligibleBaseQtyMap.put(fofoId, totalBaseQty);

                    eligibleBaseValueMap.put(fofoId, totalBaseValue);

                }

            }

        }

        //Map<Integer, Double> totalPurchaseValueMap = null;

        if (createOfferRequest.getSellinPercentage() > 0) {

			/*List<Order> purchaseOrders = orderRepository.selectOrdersBetweenDates(fofoIds, "billingTimestamp",

					createOfferRequest.getStartDate(), createOfferRequest.getEndDate());

			Map<Integer, Double> totalPurchaseValueMap = purchaseOrders.stream().collect(

					Collectors.groupingBy(x -> x.getRetailerId(), Collectors.summingDouble(x -> x.getWalletAmount())));*/

        }

        //As of now eligible sale is considered to be without special criteria like brand/

        for (ItemCriteriaPayout itemCriteriaPayout : createOfferRequest.getTargetSlabs().get(0).getItemCriteriaPayouts()) {

            int criteriaId = itemCriteriaPayout.getItemCriteria().getId();

            Map<Integer, List<FofoOrderItem>> ordersMap = criteriaPartnerwiseTertiary.get(criteriaId);

            double totalRolloutAmount = 0;

            for (Map.Entry<Integer, List<FofoOrderItem>> orderEntry : ordersMap.entrySet()) {

                int fofoId = orderEntry.getKey();

                List<FofoOrderItem> fofoOrderItems = orderEntry.getValue();

                OfferRowModel offerRowModel = new OfferRowModel();

                int totalQty = fofoOrderItems.stream().collect(Collectors.summingInt(x -> (x.getQuantity())));

                int totalValue = fofoOrderItems.stream().collect(Collectors.summingInt(x -> Math.round(x.getDp()) * (x.getQuantity())));

                int eligibleQty = totalQty;

                int eligibleValue = totalValue;

                Map<FofoLineItem, Integer> lineItemValueMap = new HashMap<>();

                if (createOfferRequest.getSchemeType().equals(OfferSchemeType.ACTIVATION)) {

                    for (FofoOrderItem fofoOrderItem : fofoOrderItems) {

                        fofoOrderItem.getFofoLineItems().stream().filter(x -> x.getSerialNumber() != null).forEach(

                                lineItem -> {

                                    if (activatedImeis == null || activatedImeis.contains(lineItem.getSerialNumber())) {

                                        lineItemValueMap.put(lineItem, (int) fofoOrderItem.getDp());

                                    }

                                }

                        );

                    }

                    eligibleQty = lineItemValueMap.size();

                    eligibleValue = lineItemValueMap.entrySet().stream().collect(Collectors.summingInt(x -> x.getValue()));

                    offerRowModel.setEligibleImeis(lineItemValueMap.keySet().stream().map(x -> x.getSerialNumber()).collect(Collectors.toList()));

                }

                int totalBaseQty = totalQty;

                int totalBaseValue = totalValue;

                int eligibleBaseQty = eligibleQty;

                int eligibleBaseValue = eligibleValue;

                if (createOfferRequest.isBaseCriteria()) {

                    totalBaseQty = userBaseQtyMap.get(fofoId) == null ? 0 : userBaseQtyMap.get(fofoId);

                    totalBaseValue = userBaseValueMap.get(fofoId) == null ? 0 : userBaseValueMap.get(fofoId);

                    eligibleBaseQty = eligibleBaseQtyMap.get(fofoId) == null ? 0 : eligibleBaseQtyMap.get(fofoId);

                    eligibleBaseValue = eligibleBaseValueMap.get(fofoId) == null ? 0 : eligibleBaseValueMap.get(fofoId);

                }

                int totalSale = totalBaseValue;

                int eligibleSale = eligibleBaseValue;

                int criteriaSale = totalValue;

                int eligibleCriteriaSale = eligibleValue;

                int eligibleCriteriaSaleDp = eligibleValue;

                if (createOfferRequest.getTargetType().equals(AchievementType.QUANTITY)) {

                    totalSale = totalBaseQty;

                    eligibleSale = eligibleBaseQty;

                    criteriaSale = totalQty;

                    eligibleCriteriaSale = eligibleQty;

                }

                offerRowModel.setTotalSale(totalSale);

                offerRowModel.setEligibleSale(eligibleSale);

                float eligiblePayoutValue = 0;

                double finalPayout = 0;

                for (PayoutSlab payoutSlab : itemCriteriaPayout.getPayoutSlabs()) {

                    if (payoutSlab.getOnwardsAmount() <= eligibleSale) {

                        offerRowModel.setPayoutTargetAchieved(payoutSlab.getOnwardsAmount());

                        eligiblePayoutValue = payoutSlab.getPayoutAmount();

                        offerRowModel.setPayoutValue(eligiblePayoutValue);

                    }

                }

                if (AmountType.PERCENTAGE.equals(itemCriteriaPayout.getAmountType())) {

                    finalPayout = (eligiblePayoutValue * eligibleCriteriaSaleDp) / 100;

                } else if (AmountType.FIXED.equals(itemCriteriaPayout.getAmountType())) {

                    finalPayout = eligiblePayoutValue * eligibleCriteriaSale;

                } else {

                    finalPayout = eligiblePayoutValue;

                    Map<Integer, Double> fofoCriteriaMap = fixedSlabCriteriaPartnerMap.get(criteriaId);

                    if (fofoCriteriaMap != null) {

                        if (fofoCriteriaMap.containsKey(fofoId)) {

                            double totalPayout = fofoCriteriaMap.get(fofoId);

                            if (totalPayout - finalPayout > Utils.DOUBLE_EPSILON)

                                finalPayout = 0;

                        }

                    }

                }

                if (finalPayout > 0) {

                    List<Integer> inventoryItemIds = lineItemValueMap.keySet().stream().map(x -> x.getInventoryItemId()).collect(Collectors.toList());

                    Map<Integer, InventoryItem> inventoryItemsMap = inventoryItemRepository.selectAllByIds(inventoryItemIds).stream().collect(Collectors.toMap(x -> x.getId(), x -> x));

                    int totalDpValue = lineItemValueMap.values().stream().collect(Collectors.summingInt(x -> x));

                    for (Map.Entry<FofoLineItem, Integer> lineItemValueEntry : lineItemValueMap.entrySet()) {

                        double amount = 0;

                        if (AmountType.SLAB_FIXED.equals(itemCriteriaPayout.getAmountType())) {

                            amount = eligiblePayoutValue * (lineItemValueEntry.getValue() / totalDpValue);

                            //Fixed slab should be treated as fixed after payout

                        } else {

                            amount = eligiblePayoutValue;

                        }

                        if (serialNumberPaid.containsKey(lineItemValueEntry.getKey().getSerialNumber())) {

                            amount = amount - serialNumberPaid.get(lineItemValueEntry.getKey().getSerialNumber());

                        }

                        //ignore reasonably small

                        if (amount < Utils.DOUBLE_EPSILON) continue;

                        AmountModel amountModel = new AmountModel();

                        amountModel.setAmountType(itemCriteriaPayout.getAmountType());

                        amountModel.setAmount(amount);

                        InventoryPayoutModel inventoryPayoutModel = priceCircularService.getPayouts(inventoryItemsMap.get(lineItemValueEntry.getKey().getInventoryItemId()));

                        double rolloutAmount = inventoryPayoutModel.getRolloutAmount(amountModel);

                        totalRolloutAmount += rolloutAmount;

                        OfferPayout offerPayout = new OfferPayout(fofoId, createOfferRequest.getId(), criteriaId, amount, lineItemValueEntry.getKey().getSerialNumber(), rolloutAmount, SchemePayoutStatus.CREDITED, createOfferRequest.getDescription(), LocalDateTime.now());

                        //offerPayout.setInventoryItemId(inventoryItemSaleModelsMap.get(lineItemValueEntry.getKey().getInventoryItemId()));

                        offerPayoutRepository.persist(offerPayout);

                    }

                }

                walletService.addAmountToWallet((int) fofoId, createOfferRequest.getId(), WalletReferenceType.ADDITIONAL_SCHEME, createOfferRequest.getDescription(), (float) totalRolloutAmount, LocalDateTime.now());

            }

        }

        Offer offer = offerRepository.selectById(createOfferRequest.getId());

        offer.setProcessedTimestamp(LocalDateTime.now());

    }

    @Override

    public void processSellin(CreateOfferRequest createOfferRequest) throws Exception {

        //List<OfferRowModel> offerRowModels = new ArrayList<>();

        List<OfferPayout> offerPayouts = offerPayoutRepository.selectAllByOfferId(createOfferRequest.getId());

        Set<Long> fofoIds = offerPayouts.stream().map(x -> x.getFofoId()).collect(Collectors.toSet());

        Map<Integer, Map<Integer, List<Order>>> criteriaOrdersMap = offerRepository.getPartnerWiseSellin(createOfferRequest, true);

        Map<Integer, List<Order>> userBaseCriteriaOrdersMap = null;

        if (criteriaOrdersMap.get(0) != null && criteriaOrdersMap.get(0).size() > 0) {

            userBaseCriteriaOrdersMap = criteriaOrdersMap.get(0).entrySet().stream()

                    .filter(x -> !fofoIds.contains(x.getKey())).collect(Collectors.toMap(x -> x.getKey(), x -> x.getValue()));

        }

        Map<Integer, Integer> userBaseQtyMap = null;

        Map<Integer, Integer> userBaseValueMap = null;

        if (userBaseCriteriaOrdersMap != null) {

            userBaseQtyMap = new HashMap<>();

            userBaseValueMap = new HashMap<>();

            for (Map.Entry<Integer, List<Order>> orderEntry : userBaseCriteriaOrdersMap.entrySet()) {

                int fofoId = orderEntry.getKey();

                List<Order> orders = orderEntry.getValue();

                int totalBaseQty = orders.stream().collect(Collectors.summingInt(x -> (x.getLineItem().getQuantity() - x.getLineItem().getReturnQty())));

                int totalBaseValue = orders.stream().collect(Collectors.summingInt(x ->

                        Math.round(x.getLineItem().getUnitPrice() * (x.getLineItem().getQuantity() - x.getLineItem().getReturnQty()))

                ));

                userBaseQtyMap.put(fofoId, totalBaseQty);

                userBaseValueMap.put(fofoId, totalBaseValue);

            }

        }

        LOGGER.info("Base Qty Map - {}", userBaseQtyMap);

        LOGGER.info("Base Value Map - {}", userBaseValueMap);

        LOGGER.info("Processing sellin");

        List<OfferPayout> offerPayoutsNew = new ArrayList<>();

        for (ItemCriteriaPayout itemCriteriaPayout : createOfferRequest.getTargetSlabs().get(0).getItemCriteriaPayouts()) {

            int criteriaId = itemCriteriaPayout.getItemCriteria().getId();

            LOGGER.info("Criteria Id - {}", criteriaId);

            Map<Integer, List<Order>> ordersMap = criteriaOrdersMap.get(criteriaId).entrySet().stream()

                    .filter(x -> !fofoIds.contains(x.getKey())).collect(Collectors.toMap(x -> x.getKey(), x -> x.getValue()));

            for (Map.Entry<Integer, List<Order>> orderEntry : ordersMap.entrySet()) {

                int fofoId = orderEntry.getKey();

                //CustomRetailer retailer = retailerService.getAllFofoRetailers().get(fofoId);

                List<Order> orders = orderEntry.getValue();

                Set<String> returnedSerialNumbers = orders.stream().filter(x -> x.getSerialNumber() != null).flatMap(x -> x.getReturnedImeis().stream()).collect(Collectors.toSet());

                int totalQty = orders.stream().collect(Collectors.summingInt(x -> (x.getLineItem().getQuantity() - x.getLineItem().getReturnQty())));

                LOGGER.info("LineItems = {}", orders.stream().map(x -> x.getLineItem().getId()).collect(Collectors.toList()));

                int totalValue = orders.stream().collect(Collectors.summingInt(x -> Math.round(x.getLineItem().

                        getUnitPrice() * (x.getLineItem().getQuantity() - x.getLineItem().getReturnQty()))));

                int totalBaseQty = totalQty;

                int totalBaseValue = totalValue;

                if (userBaseCriteriaOrdersMap != null) {

                    if (userBaseQtyMap.containsKey(fofoId)) {

                        totalBaseQty = userBaseQtyMap.get(fofoId);

                        totalBaseValue = userBaseValueMap.get(fofoId);

                    } else {

                        continue;

                    }

                }

                int purchasedValue;

                if (createOfferRequest.getTargetType().equals(AchievementType.VALUE)) {

                    purchasedValue = totalBaseValue;

                } else {

                    purchasedValue = totalBaseQty;

                }

                PayoutSlab currentSlab = itemCriteriaPayout.getPayoutSlabs().stream()

                        .filter(x -> x.getOnwardsAmount() <= purchasedValue).max(Comparator.comparing(x

                                -> x.getOnwardsAmount())).orElse(null);

                int targetAchieved = currentSlab ==

                        null ? 0 : currentSlab.getOnwardsAmount();

                //TODO-- payouts handling is here

                if (currentSlab == null) continue;

                //Need to remove hardcoding on tax

                List<Integer> orderIds = orders.stream().map(x -> x.getId()).collect(Collectors.toList());

                Map<Integer, LineItem> lineItemMap = orders.stream().collect(Collectors.toMap(x -> x.getLineItem().getId(), x -> x.getLineItem()));

                List<WarehouseScan> warehouseScans = warehouseScanRepository.selectAllByOrderIds(orderIds);

                List<Integer> inventoryItemIds = warehouseScans.stream().collect(Collectors.groupingBy(x -> x.getInventoryItemId())).entrySet()

                        .stream().filter(x -> x.getValue().size() == 1).map(x -> x.getKey()).collect(Collectors.toList());

                Set<String> serialNumbers;

                LOGGER.info("inventoryItemIds {}", inventoryItemIds);

                if (inventoryItemIds.size() > 0) {

                    List<WarehouseInventoryItem> warehouseInventoryItems = warehouseInventoryItemRepository.selectAllByIds(inventoryItemIds);

                    serialNumbers = warehouseInventoryItems.stream().map(x -> x.getSerialNumber()).collect(Collectors.toSet());

                } else {

                    serialNumbers = new HashSet<>();

                }

                LOGGER.info("SerialNumbers {}", serialNumbers);

                Map<String, Long> serialNumberCountMap = lineItemImeisRepository.selectByLineItemIds(new ArrayList<>(lineItemMap.keySet()))

                        .stream().collect(Collectors.groupingBy(x -> x.getSerialNumber(), Collectors.counting()));

                LOGGER.info("SerialNumbers Count Map {}", serialNumberCountMap);

                Map<String, LineItem> serialNumberMap = lineItemImeisRepository.selectByLineItemIds(new ArrayList<>(lineItemMap.keySet()))

                        .stream().collect(Collectors.toMap(x -> x.getSerialNumber(), x -> lineItemMap.get(x.getLineItemId()), (x1, x2) -> x1.getId() > x2.getId() ? x1 : x2));

                serialNumberMap = serialNumberMap.entrySet().stream().filter(x -> serialNumbers.contains(x.getKey())).collect(Collectors.toMap(x -> x.getKey(), x -> x.getValue()));

                LOGGER.info("serialNumberMap {}", serialNumberMap);

                double amount = 0;

                int lineItemsValue = serialNumberMap.values().stream().collect(Collectors.summingInt(x -> x.getUnitPrice().intValue()));

                LOGGER.info("lineItemsValue - {}, totalValue - {}", lineItemsValue, totalValue);

                for (Map.Entry<String, LineItem> entry : serialNumberMap.entrySet()) {

                    LOGGER.info("Serial no - {}", entry.getKey());

                    LineItem lineItem = entry.getValue();

                    if (AmountType.PERCENTAGE.equals(itemCriteriaPayout.getAmountType())) {

                        float percentageAmount = currentSlab.getPayoutAmount();

                        amount = entry.getValue().getUnitPrice() * (percentageAmount / 100);

                    } else if (AmountType.SLAB_FIXED.equals(itemCriteriaPayout.getAmountType())) {

                        float totalAmount = currentSlab.getPayoutAmount();

                        amount = Math.round((totalAmount / totalValue) * lineItem.getUnitPrice());

                        LOGGER.info("Serial no - {}, unitPrice - {}, amount - {}", entry.getKey(), lineItem.getUnitPrice(), amount);

                    } else {

                        //per unit amount

                        amount = currentSlab.getPayoutAmount();

                    }

                    if (fofoIds.contains(Long.valueOf(fofoId))) continue;

                    OfferPayout offerPayout = new OfferPayout(fofoId, createOfferRequest.getId(), criteriaId, currentSlab.getPayoutAmount(), entry.getKey(), amount, SchemePayoutStatus.CREDITED, createOfferRequest.getDescription(), LocalDateTime.now());

                    //offerPayout.setLineItemId();

                    offerPayoutRepository.persist(offerPayout);

                    offerPayoutsNew.add(offerPayout);

                }

            }

        }

        Map<Long, Double> offerPayoutMap = offerPayoutsNew.stream().collect(Collectors.groupingBy(x -> x.getFofoId(), Collectors.summingDouble(x -> x.getAmount())));

        for (Map.Entry<Long, Double> offerPayoutEntry : offerPayoutMap.entrySet()) {

            long fofoId = offerPayoutEntry.getKey();

            double amountToCredit = offerPayoutEntry.getValue();

            walletService.addAmountToWallet((int) fofoId, createOfferRequest.getId(), WalletReferenceType.ADDITIONAL_SCHEME, createOfferRequest.getDescription(), (float) amountToCredit, LocalDateTime.now());

        }

        Offer offer = offerRepository.selectById(createOfferRequest.getId());

        offer.setProcessedTimestamp(LocalDateTime.now());

    }