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



import com.spice.profitmandi.dao.entity.transaction.PriceDrop;
import com.spice.profitmandi.dao.entity.transaction.UserWallet;
import com.spice.profitmandi.dao.entity.transaction.UserWalletHistory;
import com.spice.profitmandi.dao.enumuration.catalog.AmountType;
import com.spice.profitmandi.dao.enumuration.catalog.SchemeType;
import com.spice.profitmandi.dao.enumuration.catalog.StockTransactionType;
import com.spice.profitmandi.dao.enumuration.fofo.ScanType;
import com.spice.profitmandi.dao.enumuration.transaction.SchemePayoutStatus;
import com.spice.profitmandi.dao.model.AmountModel;
import com.spice.profitmandi.dao.model.CreateSchemeRequest;
 
import com.spice.profitmandi.dao.repository.catalog.*;
import com.spice.profitmandi.dao.repository.dtr.FofoStoreRepository;
import com.spice.profitmandi.dao.repository.dtr.RetailerRepository;
import com.spice.profitmandi.dao.repository.fofo.*;
import com.spice.profitmandi.dao.repository.transaction.PriceDropRepository;

//                    "864562072802477", "864562072801651", "864562072801917", "864288066786274", "864562070789478", "864562070785930", "864562070788330", "864179066116929", "864470060972569", "867492065820095",
//                    "867940069618279", "863718065007331", "863718065001417", "860948069657616", "860948069562733", "860948069563939", "860948068569838", "860948068569598", "860948067443092", "860948067442912",
//                    "860948067442573", "860948069561750", "860948069561479", "860948069561974", "860948069562550", "860948069560679", "860948069560190", "860948069562691", "860948069735859"
//    );
 
    private static final List<SchemeType> ACTIVATION_SCHEME_TYPES = Arrays.asList(SchemeType.SPECIAL_SUPPORT, SchemeType.SELLOUT);
 
    @Autowired
    SchemeBlockedImeiRepository schemeBlockedImeiRepository;
    @Autowired
    StateGstRateRepository stateGstRateRepository;

        schemeRepository.persist(scheme);
        for (int catalogId : createSchemeRequest.getCatalogIds()) {
            SchemeItem schemeItem = new SchemeItem();
            schemeItem.setSchemeId(scheme.getId());
            schemeItem.setCatalogId(catalogId);
            schemeItem.setStartDate(createSchemeRequest.getStartDate());
            schemeItem.setEndDate(createSchemeRequest.getEndDate());
            schemeItemRepository.persist(schemeItem);
        }
 
        for (int regionId : createSchemeRequest.getRegionIds()) {
            SchemeRegion schemeRegion = new SchemeRegion();

    @Autowired
    OfferPayoutRepository offerPayoutRepository;
    @Autowired
    AgeingService ageingService;
 
 
    public void processSchemeIn(int purchaseId, int retailerId) throws ProfitMandiBusinessException {
        LOGGER.info("Processing scheme in  for purchaseId - {}", purchaseId);
        Purchase purchase = purchaseRepository.selectByIdAndFofoId(purchaseId, retailerId);
 
 
 
 
 
 
 
 
 
        PartnerType partnerType = partnerTypeChangeService.getTypeOnMonth(retailerId,
                YearMonth.from(purchase.getCreateTimestamp()));
        List<InventoryItem> inventoryItems = inventoryItemRepository.selectByPurchaseId(purchaseId);
        //Remove imeis from blocked imeis list
        List<String> blockedImeis = this.getBlockedImeis();
        inventoryItems = inventoryItems.stream().filter(inventoryItem -> !blockedImeis.contains(inventoryItem.getSerialNumber())).collect(Collectors.toList());
        if (inventoryItems.size() == 0) return;
 
        Set<Integer> itemIds = inventoryItems.stream().map(x -> x.getItemId()).collect(Collectors.toSet());
        Map<Integer, Item> itemsMap = itemRepository.selectByIds(itemIds).stream().collect(Collectors.toMap(x -> x.getId(), x -> x));
        inventoryItems.stream().forEach(x -> x.setItem(itemsMap.get(x.getItemId())));
 
 
        LocalDateTime billingDate = purchaseService.getBillingDateOfPurchase(purchaseId);
        Set<Integer> itemIdsSet = tagListingRepository.selectByItemIdsAndTagIds(itemIds, tagIds).stream()
                .filter(x -> x.getEolDate() == null || x.getEolDate().isAfter(billingDate)).map(x -> x.getItemId())
                .collect(Collectors.toSet());
        // Only consider inventory items that were not returned and not eol
        inventoryItems = inventoryItems.stream().filter(x -> itemIdsSet.contains(x.getItemId()))

                .filter(x -> !x.getLastScanType().equals(ScanType.PURCHASE_RET)).collect(Collectors.toList());
 
        if (inventoryItems.size() == 0) return;
 
        Map<Integer, List<InventoryItem>> catalogInventoryItemMap = inventoryItems.stream().collect(Collectors.groupingBy(x -> x.getItem().getCatalogItemId()));
        Map<CatalogSummaryModel, List<SchemeSummaryModel>> catalogSchemeSummaryMap = tagListingRepository.getModelSchemesByCatalogIdsAndType(retailerId,
                partnerType, new ArrayList<>(catalogInventoryItemMap.keySet()), billingDate);
 
 
        int itemsCount = 0;
        float totalCashback = 0;
        for (Map.Entry<CatalogSummaryModel, List<SchemeSummaryModel>> catalogSummaryModelListEntry : catalogSchemeSummaryMap.entrySet()) {
            CatalogSummaryModel catalogSummaryModel = catalogSummaryModelListEntry.getKey();
            List<SchemeSummaryModel> schemeSummaryModels = catalogSummaryModelListEntry.getValue().stream().filter(x -> x != null).collect(Collectors.toList());
            schemeSummaryModels.stream().filter(x -> x != null && x.getSchemeType().getTransactionType().equals(StockTransactionType.IN)).forEach(x -> x.setProcess(true));
            if (schemeSummaryModels.stream().filter(x -> x.isProcess()).count() == 0) continue;
            List<InventoryItem> modelInventoryItems = catalogInventoryItemMap.get(catalogSummaryModel.getCatalogId());
            for (InventoryItem inventoryItem : modelInventoryItems) {
                float inventoryItemCashback = this.createSchemeInOut(schemeSummaryModels, inventoryItem);
                if (inventoryItemCashback > 0) {

                }
            }
        }
 
 
        LOGGER.info("Items count for purchase id {} is {}", purchaseId, itemsCount);
        if (itemsCount > 0) {
            walletService.addAmountToWallet(
                    retailerId, purchaseId, WalletReferenceType.SCHEME_IN, "Added for SCHEME IN against invoice "
                            + purchase.getPurchaseReference() + " (total " + itemsCount + " pcs)",
                    totalCashback, purchase.getCreateTimestamp());
            LOGGER.info("Added Rs.{} for SCHEME IN against invoice {} total pcs({}) {}", totalCashback,
                    purchase.getPurchaseReference(), itemsCount);
        }
 
    }
 
 
    // We are maintaining price drop after grn
    private float getAmount(InventoryItem inventoryItem, Scheme scheme) throws ProfitMandiBusinessException {

        float dpForCalc = 0;
        float taxableSellingPrice = 0;
 
        //float totalTaxRate = stateGstRateRepository.getTotalTaxRate(inventoryItem.getItemId());
        if (scheme.getAmountType().equals(AmountType.PERCENTAGE)) {
            if (scheme.getType().getTransactionType().equals(StockTransactionType.IN)) {
                dpForCalc = inventoryItem.getUnitPrice() - inventoryItem.getPriceDropAmount();
            } else {
                try {
                    dpForCalc = Math.min(inventoryItem.getUnitPrice() - inventoryItem.getPriceDropAmount(),
                            tagListingRepository.selectByItemId(inventoryItem.getItemId()).getSellingPrice());

            amount = dpForCalc * scheme.getAmount() / 100;
            System.out.println(String.format("%d\t%s\t%d\t%d\t%s\t%s\t%s\t%s\t%f\t%f\t%f\t%f", inventoryItem.getId(),
                    inventoryItem.getSerialNumber(), inventoryItem.getItemId(), scheme.getId(), scheme.getName(),
                    scheme.getType(), scheme.getAmountType(), scheme.getPartnerType(), dpForCalc, taxableSellingPrice,
                    scheme.getAmount(), amount));
        } else if (scheme.getType().getTransactionType().equals(StockTransactionType.IN)) {
            amount = scheme.getAmount();
        }
        return amount;
    }
 
    //Only in and activation margins are allowed to be rolled out more than twice
    private float createSchemeInOut(List<SchemeSummaryModel> schemeSummaryModels, InventoryItem inventoryItem) throws ProfitMandiBusinessException {
        LOGGER.info("schemeSummaryModels - {}", schemeSummaryModels);
        InventoryPayoutModel inventoryPayoutModel = priceCircularService.getPayouts(inventoryItem);
 
 
 
        //Get all schemes
        List<SchemeSummaryModel> inventoryPayoutModelToProcess = schemeSummaryModels.stream().filter(x -> x.isProcess()).collect(Collectors.toList());
 
        List<SchemeInOut> paidSios = inventoryPayoutModel.getPaidSios();
        List<SchemeInOut> pendingSios = inventoryPayoutModel.getPendingSios();

        Map<SchemeSummaryModel, AmountModel> payoutSchemeSummaryModelMap = new HashMap<>();
        for (SchemeSummaryModel schemeSummaryModelToProcess : inventoryPayoutModelToProcess) {
            if (paidSchemesMap.containsKey(schemeSummaryModelToProcess.getSchemeId()) || pendingSchemesMap.containsKey(schemeSummaryModelToProcess.getSchemeId()))
                continue;
            //If different type but on higher side provide the higher margin
            if (Arrays.asList(SchemeType.SPECIAL_SUPPORT).contains(schemeSummaryModelToProcess.getSchemeType())) {
                Scheme scheme = schemeRepository.selectById(schemeSummaryModelToProcess.getSchemeId());
                //Create only if the activation if the activation date is not known
                ActivatedImei activatedImei = activatedImeiRepository.selectBySerialNumber(inventoryItem.getSerialNumber());
                if (activatedImei == null || activatedImei.getActivationTimestamp() == null) {
                    SchemeInOut sio = new SchemeInOut();

                    sio.setSchemeId(schemeSummaryModelToProcess.getSchemeId());
                    sio.setStatusDescription("Activation pending for IMEI#" + inventoryItem.getSerialNumber());
                    sio.setStatus(SchemePayoutStatus.PENDING);
                    schemeInOutRepository.persist(sio);
                }
            } else if (!StockTransactionType.IN.equals(schemeSummaryModelToProcess.getSchemeType().getTransactionType())) {
                //We have got non repeating scheme type
                if (paidSchemeTypesMap.containsKey(schemeSummaryModelToProcess.getSchemeType())) {
                    SchemeInOut sio = paidSchemeTypesMap.get(schemeSummaryModelToProcess.getSchemeType()).get(0);
                    Scheme paidScheme = sio.getScheme();
                    //Don't entertain if amount types do not match for same type

                    sio.setSchemeId(schemeSummaryModel.getSchemeId());
                    sio.setInventoryItemId(inventoryItem.getId());
                    sio.setStatus(SchemePayoutStatus.CREDITED);
                    sio.setCreditTimestamp(LocalDateTime.now());
                    sio.setAmount((float) (fixedRollout * amountModel.getAmount() / fixedToPay) + schemeTypeCancelledAmountMap.getOrDefault(schemeSummaryModel.getSchemeType(), 0f));
                    if (schemeSummaryModel.getSchemeType().getTransactionType().equals(StockTransactionType.IN))
                        sio.setStatusDescription("Credited for GRN of IMEI-" + inventoryItem.getSerialNumber());
                    else
                        sio.setStatusDescription("Credited for Sale of IMEI-" + inventoryItem.getSerialNumber());
                    schemeInOutRepository.persist(sio);
                }

                    sio.setSchemeId(schemeSummaryModel.getSchemeId());
                    sio.setStatus(SchemePayoutStatus.CREDITED);
                    sio.setCreditTimestamp(LocalDateTime.now());
                    sio.setAmount((float) (percentageRollout * amountModel.getAmount() / percentageToPay) +
                            schemeTypeCancelledAmountMap.getOrDefault(schemeSummaryModel.getSchemeType(), 0f));
                    if (schemeSummaryModel.getSchemeType().getTransactionType().equals(StockTransactionType.IN))
                        sio.setStatusDescription("Credited for GRN of IMEI-" + inventoryItem.getSerialNumber());
                    else
                        sio.setStatusDescription("Credited for Sale of IMEI-" + inventoryItem.getSerialNumber());
                    schemeInOutRepository.persist(sio);
                }

 
            Map<Integer, List<InventoryItem>> catalogInventoryItemMap = inventoryItems.stream().collect(Collectors.groupingBy(x -> x.getItem().getCatalogItemId()));
            Map<CatalogSummaryModel, List<SchemeSummaryModel>> catalogSchemeSummaryMap = tagListingRepository.getModelSchemesByCatalogIdsAndType(retailerId,
                    partnerType, new ArrayList<>(catalogInventoryItemMap.keySet()), fofoOrder.getCreateTimestamp());
 
            LOGGER.info("catalogSchemeSummaryMap - {}", catalogSchemeSummaryMap);
 
 
            int count = 0;
            for (Map.Entry<CatalogSummaryModel, List<SchemeSummaryModel>> catalogSummaryModelListEntry : catalogSchemeSummaryMap.entrySet()) {
                CatalogSummaryModel catalogSummaryModel = catalogSummaryModelListEntry.getKey();
                List<SchemeSummaryModel> schemeSummaryModels = catalogSummaryModelListEntry.getValue().stream().filter(x -> x != null).collect(Collectors.toList());
 
 
 
 
                schemeSummaryModels.stream().filter(x -> x.getSchemeType().getTransactionType().equals(StockTransactionType.OUT)).forEach(x -> x.setProcess(true));
                if (schemeSummaryModels.stream().filter(x -> x.isProcess()).count() == 0) continue;
 
                List<InventoryItem> modelInventoryItems = catalogInventoryItemMap.get(catalogSummaryModel.getCatalogId());
                for (InventoryItem inventoryItem : modelInventoryItems) {
                    float inventoryItemCashback = this.createSchemeInOut(schemeSummaryModels, inventoryItem);

            int inventoryItemId = schemeInOut.getInventoryItemId();
            if (schemeInOut.getRolledBackTimestamp() == null) {
                schemeInOut.setRolledBackTimestamp(LocalDateTime.now());
                if (schemeInOut.getStatus() == null || schemeInOut.getStatus().equals(SchemePayoutStatus.CREDITED)) {
                    Scheme scheme = schemesMap.get(schemeInOut.getSchemeId());
                    if (scheme.getType().getTransactionType().equals(StockTransactionType.IN)) {
                        schemePayoutMap = inSchemesMap;
                    } else {
                        schemePayoutMap = outSchemesMap;
                    }
                    if (!schemePayoutMap.containsKey(inventoryItemId)) {

                InventoryItem ii = inventoryItemsMap.get(schemeInOut.getInventoryItemId());
                Scheme scheme = schemesMap.get(schemeInOut.getSchemeId());
                if (scheme.getAmountType().equals(AmountType.FIXED)) {
                    continue;
                }
                if (scheme.getType().getTransactionType().equals(StockTransactionType.IN) && schemeInOut.getRolledBackTimestamp() == null) {
                    schemeInOut.setRolledBackTimestamp(LocalDateTime.now());
                    schemeInOut.setStatus(SchemePayoutStatus.REJECTED);
                    schemeInOut.setStatusDescription("Margin reversed due to price drop");
                    // IF not credited then dont consider any credit/debit for that sio entry
                    if (schemeInOut.getCreditTimestamp() != null) {

                }
            }
        }
 
        int fofoId = inventoryItems.get(0).getFofoId();
        WalletReferenceType walletReferenceType = WalletReferenceType.ACTIVATION_SCHEME;
 
                /*schemeTypes.containsAll(SchemeService.OUT_SCHEME_TYPES) ? WalletReferenceType.SCHEME_OUT
                : schemeTypes.contains(SchemeType.ACTIVATION) ? WalletReferenceType.ACTIVATION_SCHEME
                : schemeTypes.contains(SchemeType.SPECIAL_SUPPORT) ? WalletReferenceType.SPECIAL_SUPPORT
                : schemeTypes.contains(SchemeType.INVESTMENT) ? WalletReferenceType.SCHEME_OUT : null;*/
        List<UserWalletHistory> userWalletHistoryList = null;
        if (amountToRollback > 0 && walletReferenceType != null) {
            // Mark appropriate reference of rollback investment margin
            if (schemeTypes.contains(SchemeType.INVESTMENT) && schemeTypeMap.containsKey(SchemeType.INVESTMENT)) {
                LocalDateTime creditTime = schemeTypeMap.get(SchemeType.INVESTMENT).getCreditTimestamp();

        for (Map.Entry<CatalogSummaryModel, List<SchemeSummaryModel>> catalogSummaryModelListEntry : catalogModelMap.entrySet()) {
            int catalogItemId = catalogSummaryModelListEntry.getKey().getCatalogId();
            List<SchemeSummaryModel> schemeSummaryModels = catalogSummaryModelListEntry.getValue();
 
            float totalCashback = schemeSummaryModels.stream()
                    .filter(x -> Arrays.asList(SchemeType.SPECIAL_SUPPORT, SchemeType.SELLOUT).contains(x.getSchemeType())
                            && x.getAmountType().equals(AmountType.FIXED))
                    .collect(Collectors.summingDouble(x -> x.getAmount())).floatValue();
            catalogCashbackMap.put(catalogItemId, totalCashback);
        }
        return catalogCashbackMap;

 
    @Override
    public void processSchemeIn(List<InventoryItem> inventoryItems) throws ProfitMandiBusinessException {
        Map<Integer, List<InventoryItem>> purchaseIdInventoryItemsMap = inventoryItems.stream().collect(Collectors.groupingBy(x -> x.getPurchaseId()));
        for (Map.Entry<Integer, List<InventoryItem>> purchaseIdInventoryItemEntry : purchaseIdInventoryItemsMap.entrySet()) {
            int retailerId = purchaseIdInventoryItemEntry.getValue().get(0).getFofoId();
            this.processSchemeIn(purchaseIdInventoryItemEntry.getKey(), retailerId);
        }
    }
 
    @Autowired
    FofoStoreRepository fofoStoreRepository;

        Set<Integer> inventoryIds = new HashSet<>();
        for (SchemeInOut pendingPayout : pendingPayouts) {
            schemeIds.add(pendingPayout.getSchemeId());
        }
        Map<Integer, Scheme> schemesMap = schemeRepository.selectBySchemeIds(schemeIds, 0, 0).stream()
                .filter(x -> x.getType().equals(SchemeType.SPECIAL_SUPPORT))
                .collect(Collectors.toMap(x -> x.getId(), x -> x));
        pendingPayouts = pendingPayouts.stream().filter(x -> schemesMap.get(x.getSchemeId()) != null)
                .collect(Collectors.toList());
 
        for (SchemeInOut pendingPayout : pendingPayouts) {

                AmountModel amountModel = new AmountModel();
                amountModel.setAmount(scheme.getAmount());
                amountModel.setAmountType(scheme.getAmountType());
                double amountToRollout = inventoryPayoutModel.getRolloutAmount(amountModel);
                pendingPayout.setAmount((float) amountToRollout);
 
 
 
 
 
 
                walletService.addAmountToWallet(fofoId, orderId, WalletReferenceType.SPECIAL_SUPPORT,
                        "Special Support for " + ii.getItem().getItemDescriptionNoColor() + ", Imei - " + serialNumber, (float) amountToRollout,
                        fofoOrder.getCreateTimestamp());
                pendingPayout.setStatusDescription("Special support credited, activated on " + FormattingUtils.formatDate(activatedImei.getActivationTimestamp()));
 
 
                pendingPayout.setCreditTimestamp(LocalDateTime.now());
                pendingPayout.setStatus(SchemePayoutStatus.CREDITED);
            } else {
                pendingPayout.setStatus(SchemePayoutStatus.REJECTED);
                pendingPayout.setRolledBackTimestamp(LocalDateTime.now());

            SchemesImeisModel schemesImeisModel = imeiListEntry.getValue().get(0);
            List<Integer> schemeIds = imeiListEntry.getValue().stream().map(x -> x.getSchemeId()).collect(Collectors.toList());
            LOGGER.info("Serial Number  - {}, Scheme IDs - {}", schemesImeisModel.getImei(), schemeIds);
            InventoryItem inventoryItem = inventoryItemRepository.selectById(schemesImeisModel.getInventoryItemId());
            List<Scheme> schemes = schemeRepository.selectBySchemeIds(schemeIds);
            List<Scheme> supportSchemes = schemes.stream().filter(x -> Arrays.asList(SchemeType.SPECIAL_SUPPORT).contains(x.getType())).collect(Collectors.toList());
            if (supportSchemes.size() > 0) {
                for (Scheme scheme : supportSchemes) {
                    List<SchemeInOut> schemeInOuts = schemeInOutRepository.selectByScheme(scheme.getId(), inventoryItem.getId());
                    if (schemeInOuts.stream().filter(x -> Arrays.asList(SchemePayoutStatus.CREDITED, SchemePayoutStatus.PENDING).contains(x.getStatus())).count() > 0) {
                        continue;

Subversion Repositories SmartDukaan

(root)/trunk/profitmandi-dao/src/main/java/com/spice/profitmandi/service/scheme/SchemeServiceImpl.java – Rev 34254 → 34317

Rev 34254		Rev 34317
Line 16...		Line 16...
16	`import com.spice.profitmandi.dao.entity.transaction.PriceDrop;`	16	`import com.spice.profitmandi.dao.entity.transaction.PriceDrop;`
17	`import com.spice.profitmandi.dao.entity.transaction.UserWallet;`	17	`import com.spice.profitmandi.dao.entity.transaction.UserWallet;`
18	`import com.spice.profitmandi.dao.entity.transaction.UserWalletHistory;`	18	`import com.spice.profitmandi.dao.entity.transaction.UserWalletHistory;`
19	`import com.spice.profitmandi.dao.enumuration.catalog.AmountType;`	19	`import com.spice.profitmandi.dao.enumuration.catalog.AmountType;`
20	`import com.spice.profitmandi.dao.enumuration.catalog.SchemeType;`	20	`import com.spice.profitmandi.dao.enumuration.catalog.SchemeType;`
-		21	`import com.spice.profitmandi.dao.enumuration.catalog.StockTransactionType;`
21	`import com.spice.profitmandi.dao.enumuration.fofo.ScanType;`	22	`import com.spice.profitmandi.dao.enumuration.fofo.ScanType;`
22	`import com.spice.profitmandi.dao.enumuration.transaction.SchemePayoutStatus;`	23	`import com.spice.profitmandi.dao.enumuration.transaction.SchemePayoutStatus;`
23	`import com.spice.profitmandi.dao.model.AmountModel;`	24	`import com.spice.profitmandi.dao.model.AmountModel;`
24	`import com.spice.profitmandi.dao.model.CreateSchemeRequest;`	25	`import com.spice.profitmandi.dao.model.CreateSchemeRequest;`
25	`import com.spice.profitmandi.dao.model.DateRangeModel;`	-
26	`import com.spice.profitmandi.dao.repository.catalog.*;`	26	`import com.spice.profitmandi.dao.repository.catalog.*;`
27	`import com.spice.profitmandi.dao.repository.dtr.FofoStoreRepository;`	27	`import com.spice.profitmandi.dao.repository.dtr.FofoStoreRepository;`
28	`import com.spice.profitmandi.dao.repository.dtr.RetailerRepository;`	28	`import com.spice.profitmandi.dao.repository.dtr.RetailerRepository;`
29	`import com.spice.profitmandi.dao.repository.fofo.*;`	29	`import com.spice.profitmandi.dao.repository.fofo.*;`
30	`import com.spice.profitmandi.dao.repository.transaction.PriceDropRepository;`	30	`import com.spice.profitmandi.dao.repository.transaction.PriceDropRepository;`
Line 91...		Line 91...
91	`// "864562072802477", "864562072801651", "864562072801917", "864288066786274", "864562070789478", "864562070785930", "864562070788330", "864179066116929", "864470060972569", "867492065820095",`	91	`// "864562072802477", "864562072801651", "864562072801917", "864288066786274", "864562070789478", "864562070785930", "864562070788330", "864179066116929", "864470060972569", "867492065820095",`
92	`// "867940069618279", "863718065007331", "863718065001417", "860948069657616", "860948069562733", "860948069563939", "860948068569838", "860948068569598", "860948067443092", "860948067442912",`	92	`// "867940069618279", "863718065007331", "863718065001417", "860948069657616", "860948069562733", "860948069563939", "860948068569838", "860948068569598", "860948067443092", "860948067442912",`
93	`// "860948067442573", "860948069561750", "860948069561479", "860948069561974", "860948069562550", "860948069560679", "860948069560190", "860948069562691", "860948069735859"`	93	`// "860948067442573", "860948069561750", "860948069561479", "860948069561974", "860948069562550", "860948069560679", "860948069560190", "860948069562691", "860948069735859"`
94	`// );`	94	`// );`
95		95
96	`private static final List<SchemeType> ACTIVATION_SCHEME_TYPES = Arrays.asList(SchemeType.ACTIVATION, SchemeType.SPECIAL_SUPPORT, SchemeType.SELLOUT);`	96	`private static final List<SchemeType> ACTIVATION_SCHEME_TYPES = Arrays.asList(SchemeType.SPECIAL_SUPPORT, SchemeType.SELLOUT);`
97		97
98	`@Autowired`	98	`@Autowired`
99	`SchemeBlockedImeiRepository schemeBlockedImeiRepository;`	99	`SchemeBlockedImeiRepository schemeBlockedImeiRepository;`
100	`@Autowired`	100	`@Autowired`
101	`StateGstRateRepository stateGstRateRepository;`	101	`StateGstRateRepository stateGstRateRepository;`
Line 169...		Line 169...
169	`schemeRepository.persist(scheme);`	169	`schemeRepository.persist(scheme);`
170	`for (int catalogId : createSchemeRequest.getCatalogIds()) {`	170	`for (int catalogId : createSchemeRequest.getCatalogIds()) {`
171	`SchemeItem schemeItem = new SchemeItem();`	171	`SchemeItem schemeItem = new SchemeItem();`
172	`schemeItem.setSchemeId(scheme.getId());`	172	`schemeItem.setSchemeId(scheme.getId());`
173	`schemeItem.setCatalogId(catalogId);`	173	`schemeItem.setCatalogId(catalogId);`
-		174	`schemeItem.setStartDate(createSchemeRequest.getStartDate());`
-		175	`schemeItem.setEndDate(createSchemeRequest.getEndDate());`
174	`schemeItemRepository.persist(schemeItem);`	176	`schemeItemRepository.persist(schemeItem);`
175	`}`	177	`}`
176		178