Subversion Repositories SmartDukaan

Rev

Rev 34173 | Rev 34221 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
22653 ashik.ali 1 
package com.spice.profitmandi.service.scheme;
2 
 
24307 amit.gupta 3 
import com.spice.profitmandi.common.enumuration.ItemType;
29927 amit.gupta 4 
import com.spice.profitmandi.common.enumuration.MessageType;
22653 ashik.ali 5 
import com.spice.profitmandi.common.exception.ProfitMandiBusinessException;
6 
import com.spice.profitmandi.common.model.ProfitMandiConstants;
23019 ashik.ali 7 
import com.spice.profitmandi.common.model.SchemeModel;
29927 amit.gupta 8 
import com.spice.profitmandi.common.model.SendNotificationModel;
29584 manish 9 
import com.spice.profitmandi.common.services.ReporticoService;
27395 amit.gupta 10 
import com.spice.profitmandi.common.util.FormattingUtils;
22859 ashik.ali 11 
import com.spice.profitmandi.common.util.StringUtils;
30121 amit.gupta 12 
import com.spice.profitmandi.common.util.Utils;
31969 amit.gupta 13 
import com.spice.profitmandi.dao.entity.catalog.Item;
14 
import com.spice.profitmandi.dao.entity.catalog.Scheme;
15 
import com.spice.profitmandi.dao.entity.catalog.SchemeRegion;
16 
import com.spice.profitmandi.dao.entity.catalog.SchemesImeisModel;
29927 amit.gupta 17 
import com.spice.profitmandi.dao.entity.fofo.*;
31903 amit.gupta 18 
import com.spice.profitmandi.dao.entity.inventory.PartnerAgeingModel;
26498 amit.gupta 19 
import com.spice.profitmandi.dao.entity.transaction.PriceDrop;
32060 amit.gupta 20 
import com.spice.profitmandi.dao.entity.transaction.UserWallet;
31609 amit.gupta 21 
import com.spice.profitmandi.dao.entity.transaction.UserWalletHistory;
23527 ashik.ali 22 
import com.spice.profitmandi.dao.enumuration.catalog.AmountType;
22653 ashik.ali 23 
import com.spice.profitmandi.dao.enumuration.catalog.SchemeType;
25111 amit.gupta 24 
import com.spice.profitmandi.dao.enumuration.fofo.ScanType;
27377 amit.gupta 25 
import com.spice.profitmandi.dao.enumuration.transaction.SchemePayoutStatus;
31903 amit.gupta 26 
import com.spice.profitmandi.dao.model.AmountModel;
25503 amit.gupta 27 
import com.spice.profitmandi.dao.model.CreateSchemeRequest;
31170 amit.gupta 28 
import com.spice.profitmandi.dao.repository.catalog.*;
32309 amit.gupta 29 
import com.spice.profitmandi.dao.repository.dtr.FofoStoreRepository;
23968 amit.gupta 30 
import com.spice.profitmandi.dao.repository.dtr.RetailerRepository;
29927 amit.gupta 31 
import com.spice.profitmandi.dao.repository.fofo.*;
26498 amit.gupta 32 
import com.spice.profitmandi.dao.repository.transaction.PriceDropRepository;
31609 amit.gupta 33 
import com.spice.profitmandi.dao.repository.transaction.UserWalletHistoryRepository;
32060 amit.gupta 34 
import com.spice.profitmandi.dao.repository.transaction.UserWalletRepository;
33087 amit.gupta 35 
import com.spice.profitmandi.dao.repository.warehouse.AgeingSummaryModel;
36 
import com.spice.profitmandi.dao.repository.warehouse.WarehouseInventoryItemRepository;
29927 amit.gupta 37 
import com.spice.profitmandi.service.NotificationService;
23798 amit.gupta 38 
import com.spice.profitmandi.service.authentication.RoleManager;
31903 amit.gupta 39 
import com.spice.profitmandi.service.inventory.AgeingService;
26722 amit.gupta 40 
import com.spice.profitmandi.service.inventory.PurchaseService;
31903 amit.gupta 41 
import com.spice.profitmandi.service.pricecircular.CatalogSummaryModel;
31921 amit.gupta 42 
import com.spice.profitmandi.service.pricecircular.PriceCircularService;
31903 amit.gupta 43 
import com.spice.profitmandi.service.pricecircular.SchemeSummaryModel;
22859 ashik.ali 44 
import com.spice.profitmandi.service.wallet.WalletService;
45 
import in.shop2020.model.v1.order.WalletReferenceType;
29927 amit.gupta 46 
import org.apache.logging.log4j.LogManager;
47 
import org.apache.logging.log4j.Logger;
48 
import org.hibernate.Session;
49 
import org.hibernate.SessionFactory;
50 
import org.hibernate.query.Query;
51 
import org.springframework.beans.factory.annotation.Autowired;
52 
import org.springframework.beans.factory.annotation.Qualifier;
53 
import org.springframework.cache.annotation.Cacheable;
54 
import org.springframework.stereotype.Component;
22859 ashik.ali 55 
 
31170 amit.gupta 56 
import javax.persistence.TypedQuery;
29927 amit.gupta 57 
import javax.persistence.criteria.CriteriaBuilder;
58 
import javax.persistence.criteria.CriteriaQuery;
59 
import javax.persistence.criteria.Predicate;
60 
import javax.persistence.criteria.Root;
61 
import java.text.MessageFormat;
34115 ranu 62 
import java.time.LocalDate;
63 
import java.time.LocalDateTime;
64 
import java.time.LocalTime;
65 
import java.time.YearMonth;
29927 amit.gupta 66 
import java.util.*;
67 
import java.util.stream.Collectors;
68 
 
22653 ashik.ali 69 
@Component
70 
public class SchemeServiceImpl implements SchemeService {
71 
 
31410 amit.gupta 72 
    private static final Logger LOGGER = LogManager.getLogger(SchemeServiceImpl.class);
31916 amit.gupta 73 
    private static final Set<Integer> tagIds = new HashSet<>(Arrays.asList(4));
34017 amit.gupta 74 
    private static final List<String> BLOCKED_IMEIS = Arrays.asList("864883056397593", "864883054606656", "864883056567815", "861950056518271", "869175055649511", "861362058924574", "866009066803036", "866009066816699", "866009066816137", "866009066815873", "866009066805536", "866009066803010", "866009066821939", "866009066802756", "866009066820592", "866009066820311", "866009066816491", "866009066816376", "866009066815899", "866009066815774", "866009066817937", "866009066819859", "866009066817655", "866009066820691", "866009066820832", "866009066803291", "866009066820733", "866009066814496", "866009066820451", "866009066820659", "866009066804976", "866009066820717", "866009066816095", "861362054898434", "869599051117852", "869599056695332", "869599056695894", "864883057389656", "862661052418692", "860118051929254", "862888051664998", "862680054625831", "862888051666316", "860118051738895", "868066050447970", "868066052424399", "865084051552576", "865084050755097", "865084050755295", "865084050754819", "864883057487278", "864883057389599", "864883057437455", "864883057388278", "862680058278058", "869599056810139", "862200053994193", "861932057188916", "861175050581774", "863933065909093", "863933065635391", "861362054889177", "864004062055154", "864004062069239", "862661050221676", "862661052416993", "866812058631475", "869599051118173", "869599051504273", "868066052729250", "864883057701397", "864883054123033", "864883054947316", "864883056235694", "868066052727692", "866030052139896", "866030052140175", "860588051522053", "860588051513193", "861932056969779", "869599056171995", "865594061074932", "863935059410491", "866088059072718", "869599055375894", "869599054306916", "863782054006472", "863782054012371", "860588053486992", "868066052726835", "868066052726694", "860688053876430", "860688053869674", "868494054682394", "869599053512357"
75 
            //Imeis provided by deena
34173 ranu 76 
            , "863132060568430", "357737717299925", "863132060568471", "869663062661835", "869663062659458", "863132061326994", "863132061326796", "863132060906770", "869663064230795", "869663064231876", "869663064230670", "869663064231819", "865303063431276", "865303063431391", "865303064031315", "865303064031273", "865303064030994", "865303064031091", "865303063689113", "865303063689576", "865303063688636", "865303063689055"
34115 ranu 77 
            , "868386069690414", "868386069688533", "864288066323771", "864288066330156", "869657061613797", "864288065002178", "867791065108199", "867791065069839", "867791065069474", "867791065114395", "867791065113918", "867791065088318", "862814069767037", "867791063493114", "861433069356815", "861433069357359", "861433066654055", "861433066748675", "861433065712136", "861433065712656", "867791062605650", "867791062593559", "867791062593112", "867791062804436", "867791062798455", "867791062805177", "862965069680636", "862807060752412", "862807060752214", "865626066329117", "861433069357011", "861433066749319", "861433068904698", "861433068906057", "861433065714017", "861433065712177", "867791062804279", "866670064793915", "868386063007672", "865626064418557", "861433069357110", "864179066094829", "866382065031176", "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"
34017 amit.gupta 78 
    );
79 
 
31450 amit.gupta 80 
    private static final List<SchemeType> ACTIVATION_SCHEME_TYPES = Arrays.asList(SchemeType.ACTIVATION, SchemeType.SPECIAL_SUPPORT, SchemeType.SELLOUT);
33600 ranu 81 
 
31410 amit.gupta 82 
    @Autowired
83 
    StateGstRateRepository stateGstRateRepository;
84 
    @Autowired
85 
    NotificationService notificationService;
86 
    @Autowired
87 
    @Qualifier("fofoInventoryItemRepository")
88 
    private InventoryItemRepository inventoryItemRepository;
89 
    @Autowired
90 
    private ActivatedImeiRepository activatedImeiRepository;
91 
    @Autowired
92 
    private PartnerTypeChangeService partnerTypeChangeService;
93 
    @Autowired
94 
    private PurchaseService purchaseService;
95 
    @Autowired
96 
    private ScanRecordRepository scanRecordRepository;
97 
    @Autowired
98 
    private SessionFactory sessionFactory;
99 
    @Autowired
100 
    private SchemeRepository schemeRepository;
101 
    @Autowired
102 
    private PriceDropRepository priceDropRepository;
103 
    @Autowired
104 
    private RoleManager roleManager;
105 
    @Autowired
106 
    private RetailerRepository retailerRepository;
107 
    @Autowired
108 
    private ReporticoService reporticoService;
109 
    @Autowired
110 
    private TagListingRepository tagListingRepository;
111 
    @Autowired
112 
    private SchemeInOutRepository schemeInOutRepository;
113 
    @Autowired
114 
    @Qualifier("catalogItemRepository")
115 
    private ItemRepository itemRepository;
116 
    @Autowired
117 
    private SchemeItemRepository schemeItemRepository;
118 
    @Autowired
119 
    private SchemeRegionRepository schemeRegionRepository;
120 
    @Autowired
121 
    private WalletService walletService;
122 
    @Autowired
123 
    private PurchaseRepository purchaseRepository;
124 
    @Autowired
125 
    private FofoOrderRepository fofoOrderRepository;
23444 amit.gupta 126 
 
31921 amit.gupta 127 
    @Autowired
128 
    private PriceCircularService priceCircularService;
129 
 
33600 ranu 130 
    @Autowired
131 
    private SamsungExceptionRepository samsungExceptionRepository;
132 
 
31410 amit.gupta 133 
    @Override
134 
    public void saveScheme(int creatorId, CreateSchemeRequest createSchemeRequest) throws ProfitMandiBusinessException {
23444 amit.gupta 135 
 
31410 amit.gupta 136 
        this.validateCreateSchemeRequest(createSchemeRequest);
27898 amit.gupta 137 
 
31410 amit.gupta 138 
        Scheme scheme = this.toScheme(creatorId, createSchemeRequest);
25503 amit.gupta 139 
 
31410 amit.gupta 140 
        if (scheme.getStartDateTime().isAfter(scheme.getEndDateTime())) {
141 
            throw new ProfitMandiBusinessException(
142 
                    ProfitMandiConstants.START_DATE + ", " + ProfitMandiConstants.END_DATE,
143 
                    scheme.getStartDateTime() + ", " + scheme.getEndDateTime(), "SCHM_VE_1005");
144 
        }
26722 amit.gupta 145 
 
31410 amit.gupta 146 
        // this.validateItemIds(createSchemeRequest);
147 
        schemeRepository.persist(scheme);
148 
        for (int catalogId : createSchemeRequest.getCatalogIds()) {
149 
            SchemeItem schemeItem = new SchemeItem();
150 
            schemeItem.setSchemeId(scheme.getId());
151 
            schemeItem.setCatalogId(catalogId);
152 
            schemeItemRepository.persist(schemeItem);
153 
        }
23444 amit.gupta 154 
 
31410 amit.gupta 155 
        for (int regionId : createSchemeRequest.getRegionIds()) {
156 
            SchemeRegion schemeRegion = new SchemeRegion();
157 
            schemeRegion.setSchemeId(scheme.getId());
158 
            schemeRegion.setRegionId(regionId);
159 
            schemeRegionRepository.persist(schemeRegion);
160 
        }
26332 amit.gupta 161 
 
31410 amit.gupta 162 
    }
26722 amit.gupta 163 
 
31410 amit.gupta 164 
    private void validateCreateSchemeRequest(CreateSchemeRequest createSchemeRequest)
165 
            throws ProfitMandiBusinessException {
166 
        if (createSchemeRequest.getName() == null || createSchemeRequest.getName().isEmpty()) {
167 
            throw new ProfitMandiBusinessException(ProfitMandiConstants.NAME, createSchemeRequest.getName(),
168 
                    "SCHM_VE_1000");
169 
        }
170 
        if (createSchemeRequest.getAmount() <= 0) {
171 
            throw new ProfitMandiBusinessException(ProfitMandiConstants.AMOUNT, createSchemeRequest.getAmount(),
172 
                    "SCHM_VE_1001");
173 
        }
26684 amit.gupta 174 
 
31410 amit.gupta 175 
        if (createSchemeRequest.getAmountType().equals(AmountType.PERCENTAGE)
176 
                && createSchemeRequest.getAmount() > 100) {
177 
            throw new ProfitMandiBusinessException(ProfitMandiConstants.AMOUNT, createSchemeRequest.getAmount(),
178 
                    "SCHM_VE_1002");
179 
        }
23444 amit.gupta 180 
 
31410 amit.gupta 181 
        if (createSchemeRequest.getStartDate() == null) {
182 
            throw new ProfitMandiBusinessException(ProfitMandiConstants.START_DATE, createSchemeRequest.getStartDate(),
183 
                    "SCHM_VE_1003");
184 
        }
185 
        if (createSchemeRequest.getEndDate() == null) {
186 
            throw new ProfitMandiBusinessException(ProfitMandiConstants.END_DATE, createSchemeRequest.getEndDate(),
187 
                    "SCHM_VE_1004");
188 
        }
189 
    }
23798 amit.gupta 190 
 
31410 amit.gupta 191 
    private void validateItemIds(CreateSchemeRequest createSchemeRequest) throws ProfitMandiBusinessException {
192 
        if (createSchemeRequest.getCatalogIds() == null || createSchemeRequest.getCatalogIds().isEmpty()) {
193 
            throw new ProfitMandiBusinessException(ProfitMandiConstants.ITEM_ID, createSchemeRequest.getCatalogIds(),
194 
                    "SCHM_1003");
195 
        }
196 
        List<Integer> foundItemIds = itemRepository.selectIdsByIdsAndType(createSchemeRequest.getCatalogIds(),
197 
                ItemType.SERIALIZED);
198 
        if (foundItemIds.size() != createSchemeRequest.getCatalogIds().size()) {
199 
            createSchemeRequest.getCatalogIds().removeAll(foundItemIds);
200 
            throw new ProfitMandiBusinessException(ProfitMandiConstants.ITEM_ID, createSchemeRequest.getCatalogIds(),
201 
                    "SCHM_1004");
202 
        }
203 
    }
29927 amit.gupta 204 
 
31410 amit.gupta 205 
    @Override
206 
    public Scheme getSchemeById(int schemeId) throws ProfitMandiBusinessException {
207 
        Scheme scheme = schemeRepository.selectById(schemeId);
208 
        List<Integer> catalogIds = schemeItemRepository.selectCatalogIdsBySchemeId(scheme.getId());
209 
        if (catalogIds.size() > 0) {
210 
            List<Item> items = itemRepository.selectAllByCatalogIds(new HashSet<>(catalogIds));
211 
            scheme.setCatalogStringMap(this.toCatalogStringMap(items));
212 
        }
213 
        return scheme;
214 
    }
24562 amit.gupta 215 
 
31410 amit.gupta 216 
    public Map<Integer, String> toCatalogStringMap(List<Item> items) {
217 
        Map<Integer, String> catalogMap = new HashMap<>();
218 
        for (Item item : items) {
219 
            if (!catalogMap.containsKey(item.getCatalogItemId())) {
220 
                catalogMap.put(item.getCatalogItemId(), item.getItemDescriptionNoColor());
221 
            }
222 
        }
223 
        return catalogMap;
224 
    }
29927 amit.gupta 225 
 
31410 amit.gupta 226 
    private Set<Integer> schemeItemsToCatalogIds(List<SchemeItem> schemeItems) {
227 
        Set<Integer> catalogId = new HashSet<>();
228 
        for (SchemeItem schemeItem : schemeItems) {
229 
            catalogId.add(schemeItem.getCatalogId());
230 
        }
231 
        return catalogId;
232 
    }
23444 amit.gupta 233 
 
31410 amit.gupta 234 
    @Override
33248 ranu 235 
    public List<SchemeModel> getAllSchemeModels(LocalDateTime startDateTime, LocalDateTime endDateTime) throws ProfitMandiBusinessException {
31410 amit.gupta 236 
        List<Scheme> schemes = schemeRepository.selectAllBetweenCreateTimestamp(startDateTime, endDateTime);
237 
        Map<Integer, Scheme> schemeIdSchemeMap = schemes.stream().collect(Collectors.toMap(x -> x.getId(), x -> x));
238 
        List<SchemeItem> schemeItems = schemeItemRepository.selectBySchemeIds(schemeIdSchemeMap.keySet());
239 
        Set<Integer> catalogIds = schemeItems.stream().map(x -> x.getCatalogId()).collect(Collectors.toSet());
240 
        List<Item> items = itemRepository.selectAllByCatalogIds(catalogIds);
241 
        Map<Integer, String> catalogStringMap = this.toCatalogStringMap(items);
242 
        this.addCatalogIdsToSchemes(schemeItems, schemeIdSchemeMap, catalogStringMap);
243 
        return this.toSchemeModels(schemeIdSchemeMap);
244 
    }
23444 amit.gupta 245 
 
31410 amit.gupta 246 
    private List<SchemeModel> toSchemeModels(Map<Integer, Scheme> schemeIdSchemeMap) {
247 
        List<SchemeModel> schemeModels = new ArrayList<>();
248 
        for (Map.Entry<Integer, Scheme> schemeIdSchemeEntry : schemeIdSchemeMap.entrySet()) {
249 
            schemeModels.add(this.toSchemeModel(schemeIdSchemeEntry.getValue()));
250 
        }
251 
        return schemeModels;
252 
    }
23444 amit.gupta 253 
 
31410 amit.gupta 254 
    private SchemeModel toSchemeModel(Scheme scheme) {
255 
        SchemeModel schemeModel = new SchemeModel();
256 
        schemeModel.setSchemeId(scheme.getId());
257 
        schemeModel.setName(scheme.getName());
258 
        schemeModel.setDescription(scheme.getDescription());
259 
        schemeModel.setSchemeType(scheme.getType().toString());
260 
        schemeModel.setAmountType(scheme.getAmountType().toString());
261 
        schemeModel.setAmount(scheme.getAmount());
262 
        schemeModel.setStartDateTime(StringUtils.toString(scheme.getStartDateTime()));
263 
        schemeModel.setEndDateTime(StringUtils.toString(scheme.getEndDateTime()));
264 
        schemeModel.setCreateTimestamp(StringUtils.toString(scheme.getCreateTimestamp()));
265 
        schemeModel.setActiveTimestamp(StringUtils.toString(scheme.getActiveTimestamp()));
266 
        schemeModel.setExpireTimestamp(StringUtils.toString(scheme.getExpireTimestamp()));
267 
        schemeModel.setCreatedBy(scheme.getCreatedBy());
268 
        schemeModel.setCatalogStringMap(scheme.getCatalogStringMap());
269 
        schemeModel.setRetailerIds(scheme.getRetailerIds());
270 
        return schemeModel;
271 
    }
23444 amit.gupta 272 
 
31410 amit.gupta 273 
    private void addCatalogIdsToSchemes(List<SchemeItem> schemeItems, Map<Integer, Scheme> schemeIdSchemeMap,
274 
                                        Map<Integer, String> catalogStringMap) {
275 
        for (SchemeItem schemeItem : schemeItems) {
276 
            Scheme scheme = schemeIdSchemeMap.get(schemeItem.getSchemeId());
277 
            scheme.getCatalogStringMap().put(schemeItem.getCatalogId(), catalogStringMap.get(schemeItem.getCatalogId()));
278 
        }
279 
    }
31170 amit.gupta 280 
 
31410 amit.gupta 281 
    @Override
282 
    public void activeSchemeById(int schemeId) throws ProfitMandiBusinessException {
283 
        Scheme scheme = schemeRepository.selectById(schemeId);
284 
        if (scheme.getActiveTimestamp() != null) {
285 
            throw new ProfitMandiBusinessException(ProfitMandiConstants.ACTIVE_TIMESTAMP, scheme.getActiveTimestamp(),
286 
                    "SCHM_1005");
287 
        }
288 
        if (scheme.getExpireTimestamp() != null) {
289 
            throw new ProfitMandiBusinessException(ProfitMandiConstants.EXPIRE_TIMESTAMP, scheme.getExpireTimestamp(),
290 
                    "SCHM_1006");
291 
        }
292 
        scheme.setActiveTimestamp(LocalDateTime.now());
293 
        this.sendSchemeNotification(scheme);
23444 amit.gupta 294 
 
295 
 
31410 amit.gupta 296 
        /*
297 
         * if (scheme.getType() == SchemeType.IN) {
298 
         * this.processPreviousPurchases(scheme); } else if (scheme.getType() ==
299 
         * SchemeType.OUT) { this.processPreviousSales(scheme); }
300 
         */
301 
    }
23796 amit.gupta 302 
 
31410 amit.gupta 303 
    private void sendSchemeNotification(Scheme scheme) throws ProfitMandiBusinessException {
304 
        if (ACTIVATION_SCHEME_TYPES.contains(scheme.getType())) {
31336 amit.gupta 305 
 
31410 amit.gupta 306 
            SendNotificationModel sendNotificationModel = new SendNotificationModel();
307 
            List<SchemeItem> schemeItems = schemeItemRepository.selectBySchemeIds(Collections.singleton(scheme.getId()));
308 
            Set<Integer> catalogIds = schemeItems.stream().map(x -> x.getCatalogId()).collect(Collectors.toSet());
309 
            List<String> itemDescriptions = itemRepository.selectAllByCatalogIds(catalogIds).stream().filter(Utils.distinctByKey(Item::getCatalogItemId))
310 
                    .map(x -> x.getItemDescriptionNoColor()).collect(Collectors.toList());
311 
            String titleTemplate = "%s of Rs.%s for %s";
312 
            String schemeString = "Activation scheme";
313 
            if (scheme.getType().equals(SchemeType.SPECIAL_SUPPORT)) {
314 
                schemeString = "Special Support";
315 
            }
30957 amit.gupta 316 
 
31410 amit.gupta 317 
            String message = "Duration from - " + FormattingUtils.formatDateMonth(scheme.getStartDateTime()) + " - " + FormattingUtils.formatDateMonth(scheme.getEndDateTime());
318 
            sendNotificationModel.setCampaignName("activationscheme");
32602 amit.gupta 319 
            sendNotificationModel.setUrl("https://app.smartdukaan.com/pages/home/notifications");
31410 amit.gupta 320 
            sendNotificationModel.setExpiresat(LocalDateTime.now().plusDays(1));
321 
            sendNotificationModel.setMessage(message);
322 
            sendNotificationModel.setTitle(String.format(titleTemplate, schemeString, FormattingUtils.formatDecimal(scheme.getAmount()), org.apache.commons.lang3.StringUtils.abbreviate(String.join(", ", itemDescriptions), 25)));
323 
            sendNotificationModel.setType("url");
324 
            sendNotificationModel.setMessageType(MessageType.scheme);
325 
            notificationService.sendNotificationToAll(sendNotificationModel);
326 
        }
327 
    }
23444 amit.gupta 328 
 
31410 amit.gupta 329 
    @Override
330 
    public void expireSchemeById(int schemeId, LocalDateTime expiryTime) throws ProfitMandiBusinessException {
331 
        Scheme scheme = schemeRepository.selectById(schemeId);
332 
        if (scheme == null || scheme.getActiveTimestamp() == null) {
333 
            throw new ProfitMandiBusinessException(ProfitMandiConstants.ACTIVE_TIMESTAMP, scheme.getActiveTimestamp(),
334 
                    "SCHM_1007");
335 
        }
336 
        if (scheme.getExpireTimestamp() != null) {
337 
            throw new ProfitMandiBusinessException(ProfitMandiConstants.EXPIRE_TIMESTAMP, scheme.getExpireTimestamp(),
338 
                    "SCHM_1008");
339 
        }
340 
        scheme.setExpireTimestamp(LocalDateTime.now());
341 
        if (expiryTime.isAfter(scheme.getEndDateTime())) {
342 
            throw new ProfitMandiBusinessException(ProfitMandiConstants.EXPIRE_TIMESTAMP, scheme.getExpireTimestamp(),
343 
                    "End Date cant be extended during expiry");
344 
        }
345 
        scheme.setEndDateTime(expiryTime);
346 
        schemeRepository.persist(scheme);
347 
    }
23444 amit.gupta 348 
 
31410 amit.gupta 349 
    private Map<Integer, Scheme> toSchemeIdSchemeMap(List<Scheme> schemes) {
350 
        Map<Integer, Scheme> schemeIdSchemeMap = new HashMap<>();
351 
        for (Scheme scheme : schemes) {
352 
            schemeIdSchemeMap.put(scheme.getId(), scheme);
353 
        }
354 
        return schemeIdSchemeMap;
355 
    }
23444 amit.gupta 356 
 
31410 amit.gupta 357 
    private Map<Integer, Set<Scheme>> toCatalogIdSchemesMap(List<SchemeItem> schemeItems, List<Scheme> schemes) {
358 
        Map<Integer, Scheme> schemesMap = schemes.stream().collect(Collectors.toMap(x -> x.getId(), x -> x));
359 
        Map<Integer, Set<Scheme>> catalogSchemesMap = new HashMap<>();
360 
        for (SchemeItem schemeItem : schemeItems) {
361 
            if (!catalogSchemesMap.containsKey(schemeItem.getCatalogId())) {
362 
                catalogSchemesMap.put(schemeItem.getCatalogId(), new HashSet<>());
363 
            }
364 
            Set<Scheme> schemesSet = catalogSchemesMap.get(schemeItem.getCatalogId());
365 
            schemesSet.add(schemesMap.get(schemeItem.getSchemeId()));
366 
        }
367 
        return catalogSchemesMap;
368 
    }
23444 amit.gupta 369 
 
31410 amit.gupta 370 
    private Map<InventoryItem, Set<Scheme>> toInventoryItemSchemesMap(List<Scheme> schemes,
33248 ranu 371 
                                                                      List<InventoryItem> inventoryItems) throws ProfitMandiBusinessException {
31410 amit.gupta 372 
        Set<Integer> schemeIds = schemes.stream().map(x -> x.getId()).collect(Collectors.toSet());
373 
        Set<Integer> itemIds = inventoryItems.stream().map(x -> x.getItemId()).collect(Collectors.toSet());
374 
        Set<Integer> catalogIds = itemRepository.selectByIds(itemIds).stream().map(x -> x.getCatalogItemId()).collect(Collectors.toSet());
375 
        List<SchemeItem> schemeItems = schemeItemRepository.selectBySchemeIdsAndCatalogIds(schemeIds, catalogIds);
23444 amit.gupta 376 
 
31410 amit.gupta 377 
        Map<Integer, Set<Scheme>> catalogIdSchemesMap = this.toCatalogIdSchemesMap(schemeItems, schemes);
378 
        Map<InventoryItem, Set<Scheme>> inventoryItemSchemesMap = new HashMap<>();
379 
        for (InventoryItem inventoryItem : inventoryItems) {
380 
            LOGGER.info("inventoryItem {}", inventoryItem);
381 
            LOGGER.info("inventoryItem.getItem() {}", inventoryItem.getItem());
382 
            LOGGER.info("catalogIdSchemesMap {}", catalogIdSchemesMap);
383 
            if (catalogIdSchemesMap.containsKey(inventoryItem.getItem().getCatalogItemId())) {
384 
                inventoryItemSchemesMap.put(inventoryItem, catalogIdSchemesMap.get(inventoryItem.getItem().getCatalogItemId()));
385 
            }
386 
        }
387 
        return inventoryItemSchemesMap;
388 
    }
31170 amit.gupta 389 
 
31903 amit.gupta 390 
    @Autowired
391 
    OfferTargetSlabRepository offerTargetSlabRepository;
392 
 
31410 amit.gupta 393 
    private Scheme toScheme(int creatorId, CreateSchemeRequest createSchemeRequest) {
394 
        Scheme scheme = new Scheme();
395 
        scheme.setName(createSchemeRequest.getName());
396 
        scheme.setDescription(createSchemeRequest.getDescription());
397 
        scheme.setType(createSchemeRequest.getType());
398 
        scheme.setAmountType(createSchemeRequest.getAmountType());
399 
        scheme.setAmount(createSchemeRequest.getAmount());
400 
        scheme.setPartnerType(createSchemeRequest.getPartnerType());
401 
        scheme.setStartDateTime(createSchemeRequest.getStartDate());
402 
        scheme.setEndDateTime(createSchemeRequest.getEndDate());
403 
        scheme.setCreatedBy(creatorId);
404 
        scheme.setCashback(createSchemeRequest.isCashback());
405 
        return scheme;
406 
    }
23444 amit.gupta 407 
 
31903 amit.gupta 408 
    @Autowired
409 
    OfferRepository offerRepository;
410 
    @Autowired
411 
    OfferPayoutRepository offerPayoutRepository;
412 
    @Autowired
413 
    AgeingService ageingService;
31588 amit.gupta 414 
 
34139 amit.gupta 415 
 
31903 amit.gupta 416 
    public void processSchemeIn(int purchaseId, int retailerId) throws ProfitMandiBusinessException {
33432 amit.gupta 417 
        LOGGER.info("Processing scheme in  for purchaseId - {}", purchaseId);
31903 amit.gupta 418 
        Purchase purchase = purchaseRepository.selectByIdAndFofoId(purchaseId, retailerId);
34139 amit.gupta 419 
        List<InventoryItem> inventoryItems = inventoryItemRepository.selectByPurchaseId(purchaseId);
420 
        processSchemeIn(purchase, inventoryItems);
421 
 
422 
    }
423 
 
424 
    private void processSchemeIn(Purchase purchase, List<InventoryItem> inventoryItems) throws ProfitMandiBusinessException {
425 
        if (inventoryItems.stream().filter(x -> x.getPurchaseId() != purchase.getId()).collect(Collectors.toList()).size() > 0) {
426 
            throw new ProfitMandiBusinessException("", "Invalid purchase id for inventory item", "SCHM_1009");
427 
        }
428 
        PartnerType partnerType = partnerTypeChangeService.getTypeOnMonth(purchase.getFofoId(),
31903 amit.gupta 429 
                YearMonth.from(purchase.getCreateTimestamp()));
430 
        //Remove imeis from blocked imeis list
431 
        inventoryItems = inventoryItems.stream().filter(inventoryItem -> !BLOCKED_IMEIS.contains(inventoryItem.getSerialNumber())).collect(Collectors.toList());
432 
        if (inventoryItems.size() == 0) return;
23444 amit.gupta 433 
 
31903 amit.gupta 434 
        Set<Integer> itemIds = inventoryItems.stream().map(x -> x.getItemId()).collect(Collectors.toSet());
435 
        Map<Integer, Item> itemsMap = itemRepository.selectByIds(itemIds).stream().collect(Collectors.toMap(x -> x.getId(), x -> x));
436 
        inventoryItems.stream().forEach(x -> x.setItem(itemsMap.get(x.getItemId())));
23444 amit.gupta 437 
 
438 
 
34139 amit.gupta 439 
        LocalDateTime billingDate = purchaseService.getBillingDateOfPurchase(purchase.getId());
31903 amit.gupta 440 
        Set<Integer> itemIdsSet = tagListingRepository.selectByItemIdsAndTagIds(itemIds, tagIds).stream()
441 
                .filter(x -> x.getEolDate() == null || x.getEolDate().isAfter(billingDate)).map(x -> x.getItemId())
442 
                .collect(Collectors.toSet());
443 
        // Only consider inventory items that were not returned and not eol
444 
        inventoryItems = inventoryItems.stream().filter(x -> itemIdsSet.contains(x.getItemId()))
445 
                .filter(x -> !x.getLastScanType().equals(ScanType.PURCHASE_RET_BAD))
446 
                .filter(x -> !x.getLastScanType().equals(ScanType.PURCHASE_RET)).collect(Collectors.toList());
447 
 
448 
        if (inventoryItems.size() == 0) return;
449 
 
450 
        Map<Integer, List<InventoryItem>> catalogInventoryItemMap = inventoryItems.stream().collect(Collectors.groupingBy(x -> x.getItem().getCatalogItemId()));
34139 amit.gupta 451 
        Map<CatalogSummaryModel, List<SchemeSummaryModel>> catalogSchemeSummaryMap = tagListingRepository.getModelSchemesByCatalogIdsAndType(purchase.getFofoId(),
32454 amit.gupta 452 
                partnerType, new ArrayList<>(catalogInventoryItemMap.keySet()), billingDate);
31903 amit.gupta 453 
 
454 
 
455 
        int itemsCount = 0;
456 
        float totalCashback = 0;
457 
        for (Map.Entry<CatalogSummaryModel, List<SchemeSummaryModel>> catalogSummaryModelListEntry : catalogSchemeSummaryMap.entrySet()) {
458 
            CatalogSummaryModel catalogSummaryModel = catalogSummaryModelListEntry.getKey();
32058 amit.gupta 459 
            List<SchemeSummaryModel> schemeSummaryModels = catalogSummaryModelListEntry.getValue().stream().filter(x -> x != null).collect(Collectors.toList());
460 
            schemeSummaryModels.stream().filter(x -> x != null && x.getSchemeType().equals(SchemeType.IN)).forEach(x -> x.setProcess(true));
31903 amit.gupta 461 
            if (schemeSummaryModels.stream().filter(x -> x.isProcess()).count() == 0) continue;
462 
            List<InventoryItem> modelInventoryItems = catalogInventoryItemMap.get(catalogSummaryModel.getCatalogId());
463 
            for (InventoryItem inventoryItem : modelInventoryItems) {
32165 amit.gupta 464 
                float inventoryItemCashback = this.createSchemeInOut(schemeSummaryModels, inventoryItem);
31903 amit.gupta 465 
                if (inventoryItemCashback > 0) {
466 
                    itemsCount++;
467 
                    totalCashback += inventoryItemCashback;
31410 amit.gupta 468 
                }
469 
            }
31903 amit.gupta 470 
        }
22653 ashik.ali 471 
 
29927 amit.gupta 472 
 
34139 amit.gupta 473 
        LOGGER.info("Items count for purchase id {} is {}", purchase.getId(), itemsCount);
31903 amit.gupta 474 
        if (itemsCount > 0) {
475 
            walletService.addAmountToWallet(
34139 amit.gupta 476 
                    purchase.getFofoId(), purchase.getId(), WalletReferenceType.SCHEME_IN, "Added for SCHEME IN against invoice "
31903 amit.gupta 477 
                            + purchase.getPurchaseReference() + " (total " + itemsCount + " pcs)",
478 
                    totalCashback, purchase.getCreateTimestamp());
479 
            LOGGER.info("Added Rs.{} for SCHEME IN against invoice {} total pcs({}) {}", totalCashback,
480 
                    purchase.getPurchaseReference(), itemsCount);
481 
        }
482 
    }
483 
 
484 
 
31410 amit.gupta 485 
    // We are maintaining price drop after grn
486 
    private float getAmount(InventoryItem inventoryItem, Scheme scheme) throws ProfitMandiBusinessException {
487 
        if (BLOCKED_IMEIS.contains(inventoryItem.getSerialNumber())) {
488 
            return 0;
489 
        }
490 
        float amount = 0;
491 
        float dpForCalc = 0;
492 
        float taxableSellingPrice = 0;
29927 amit.gupta 493 
 
31410 amit.gupta 494 
        //float totalTaxRate = stateGstRateRepository.getTotalTaxRate(inventoryItem.getItemId());
495 
        if (scheme.getAmountType().equals(AmountType.PERCENTAGE)) {
496 
            if (scheme.getType().equals(SchemeType.IN)) {
497 
                dpForCalc = inventoryItem.getUnitPrice() - inventoryItem.getPriceDropAmount();
498 
            } else {
499 
                try {
500 
                    dpForCalc = Math.min(inventoryItem.getUnitPrice() - inventoryItem.getPriceDropAmount(),
501 
                            tagListingRepository.selectByItemId(inventoryItem.getItemId()).getSellingPrice());
502 
                } catch (Exception e) {
503 
                    LOGGER.info("Could not find tag Listing entry in {}", inventoryItem.getItemId());
504 
                    e.printStackTrace();
505 
                }
506 
            }
507 
            //TODO:Should be calculated on unit price
508 
            //taxableSellingPrice = dpForCalc / (1 + totalTaxRate / 100);
509 
            //amount = taxableSellingPrice * scheme.getAmount() / 100;
510 
            amount = dpForCalc * scheme.getAmount() / 100;
511 
            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(),
512 
                    inventoryItem.getSerialNumber(), inventoryItem.getItemId(), scheme.getId(), scheme.getName(),
513 
                    scheme.getType(), scheme.getAmountType(), scheme.getPartnerType(), dpForCalc, taxableSellingPrice,
514 
                    scheme.getAmount(), amount));
515 
        } else if (scheme.getType().equals(SchemeType.IN)) {
516 
            amount = scheme.getAmount();
517 
        }
518 
        return amount;
519 
    }
23444 amit.gupta 520 
 
31903 amit.gupta 521 
    //Only in and activation margins are allowed to be rolled out more than twice
32165 amit.gupta 522 
    private float createSchemeInOut(List<SchemeSummaryModel> schemeSummaryModels, InventoryItem inventoryItem) throws ProfitMandiBusinessException {
33614 amit.gupta 523 
        LOGGER.info("schemeSummaryModels - {}", schemeSummaryModels);
31921 amit.gupta 524 
        InventoryPayoutModel inventoryPayoutModel = priceCircularService.getPayouts(inventoryItem);
34174 ranu 525 
 
526 
        LOGGER.info("inventoryPayoutModel - {}", inventoryPayoutModel);
527 
 
31903 amit.gupta 528 
        //Get all schemes
529 
        List<SchemeSummaryModel> inventoryPayoutModelToProcess = schemeSummaryModels.stream().filter(x -> x.isProcess()).collect(Collectors.toList());
530 
 
32165 amit.gupta 531 
        List<SchemeInOut> paidSios = inventoryPayoutModel.getPaidSios();
532 
        List<SchemeInOut> pendingSios = inventoryPayoutModel.getPendingSios();
533 
        Map<SchemeType, List<SchemeInOut>> paidSchemeTypesMap = inventoryPayoutModel.getPaidSios().stream().collect(Collectors.groupingBy(x -> x.getScheme().getType()));
534 
        Map<Integer, SchemeInOut> paidSchemesMap = paidSios.stream().collect(Collectors.toMap(x -> x.getSchemeId(), x -> x));
535 
        Map<Integer, SchemeInOut> pendingSchemesMap = pendingSios.stream().collect(Collectors.toMap(x -> x.getSchemeId(), x -> x));
32155 amit.gupta 536 
        Map<SchemeType, Float> schemeTypeCancelledAmountMap = new HashMap<>();
31903 amit.gupta 537 
 
538 
        double percentageToPay = 0d;
539 
        double fixedToPay = 0d;
540 
        Map<SchemeSummaryModel, AmountModel> payoutSchemeSummaryModelMap = new HashMap<>();
541 
        for (SchemeSummaryModel schemeSummaryModelToProcess : inventoryPayoutModelToProcess) {
32972 amit.gupta 542 
            if (paidSchemesMap.containsKey(schemeSummaryModelToProcess.getSchemeId()) || pendingSchemesMap.containsKey(schemeSummaryModelToProcess.getSchemeId()))
543 
                continue;
31903 amit.gupta 544 
            //If different type but on higher side provide the higher margin
545 
            if (Arrays.asList(SchemeType.ACTIVATION, SchemeType.SPECIAL_SUPPORT).contains(schemeSummaryModelToProcess.getSchemeType())) {
32165 amit.gupta 546 
                Scheme scheme = schemeRepository.selectById(schemeSummaryModelToProcess.getSchemeId());
547 
                //Create only if the activation if the activation date is not known
548 
                ActivatedImei activatedImei = activatedImeiRepository.selectBySerialNumber(inventoryItem.getSerialNumber());
32972 amit.gupta 549 
                if (activatedImei == null || activatedImei.getActivationTimestamp() == null) {
32165 amit.gupta 550 
                    SchemeInOut sio = new SchemeInOut();
551 
                    sio.setAmount(0);
552 
                    sio.setInventoryItemId(inventoryItem.getId());
553 
                    sio.setSchemeId(schemeSummaryModelToProcess.getSchemeId());
554 
                    sio.setStatusDescription("Activation pending for IMEI#" + inventoryItem.getSerialNumber());
555 
                    sio.setStatus(SchemePayoutStatus.PENDING);
556 
                    schemeInOutRepository.persist(sio);
557 
                }
31903 amit.gupta 558 
            } else if (!SchemeType.IN.equals(schemeSummaryModelToProcess.getSchemeType())) {
559 
                //We have got non repeating scheme type
560 
                if (paidSchemeTypesMap.containsKey(schemeSummaryModelToProcess.getSchemeType())) {
561 
                    SchemeInOut sio = paidSchemeTypesMap.get(schemeSummaryModelToProcess.getSchemeType()).get(0);
562 
                    Scheme paidScheme = sio.getScheme();
563 
                    //Don't entertain if amount types do not match for same type
564 
                    if (paidScheme.getAmountType().equals(schemeSummaryModelToProcess.getAmountType()) &&
565 
                            schemeSummaryModelToProcess.getAmount() > paidScheme.getAmount() + Utils.DOUBLE_EPSILON) {
566 
                        sio.setRolledBackTimestamp(LocalDateTime.now());
567 
                        sio.setStatus(SchemePayoutStatus.REJECTED);
32155 amit.gupta 568 
                        sio.setStatusDescription("Eligible for higher margin for " + schemeSummaryModelToProcess.getSchemeType() + ", new entry added");
569 
                        schemeTypeCancelledAmountMap.put(schemeSummaryModelToProcess.getSchemeType(), sio.getAmount());
31903 amit.gupta 570 
                        if (paidScheme.getAmountType().equals(AmountType.PERCENTAGE)) {
571 
                            percentageToPay += schemeSummaryModelToProcess.getAmount() - paidScheme.getAmount();
572 
                        } else {
573 
                            fixedToPay += schemeSummaryModelToProcess.getAmount() - paidScheme.getAmount();
574 
                        }
575 
                        payoutSchemeSummaryModelMap.put(schemeSummaryModelToProcess, new AmountModel(schemeSummaryModelToProcess.getAmount() - paidScheme.getAmount(), schemeSummaryModelToProcess.getAmountType()));
576 
                    }
577 
                } else {
578 
                    if (schemeSummaryModelToProcess.getAmountType().equals(AmountType.PERCENTAGE)) {
579 
                        percentageToPay += schemeSummaryModelToProcess.getAmount();
580 
                    } else {
581 
                        fixedToPay += schemeSummaryModelToProcess.getAmount();
582 
                    }
583 
                    payoutSchemeSummaryModelMap.put(schemeSummaryModelToProcess, new AmountModel(schemeSummaryModelToProcess.getAmount(), schemeSummaryModelToProcess.getAmountType()));
584 
                }
585 
            } else {
586 
                if (schemeSummaryModelToProcess.getAmountType().equals(AmountType.PERCENTAGE)) {
587 
                    percentageToPay += schemeSummaryModelToProcess.getAmount();
588 
                } else {
589 
                    fixedToPay += schemeSummaryModelToProcess.getAmount();
590 
                }
591 
                payoutSchemeSummaryModelMap.put(schemeSummaryModelToProcess, new AmountModel(schemeSummaryModelToProcess.getAmount(), schemeSummaryModelToProcess.getAmountType()));
592 
            }
593 
        }
594 
        double walletCredit = 0d;
595 
        if (fixedToPay > 0) {
31913 amit.gupta 596 
            double fixedRollout = fixedToPay * (100 / (100 + inventoryPayoutModel.getPercentageAmount()));
31903 amit.gupta 597 
            for (Map.Entry<SchemeSummaryModel, AmountModel> schemeSummaryModelAmountModelEntry : payoutSchemeSummaryModelMap.entrySet()) {
598 
                SchemeSummaryModel schemeSummaryModel = schemeSummaryModelAmountModelEntry.getKey();
599 
                AmountModel amountModel = schemeSummaryModelAmountModelEntry.getValue();
600 
                if (amountModel.getAmountType().equals(AmountType.FIXED)) {
601 
                    SchemeInOut sio = new SchemeInOut();
602 
                    sio.setSchemeId(schemeSummaryModel.getSchemeId());
603 
                    sio.setInventoryItemId(inventoryItem.getId());
604 
                    sio.setStatus(SchemePayoutStatus.CREDITED);
605 
                    sio.setCreditTimestamp(LocalDateTime.now());
32155 amit.gupta 606 
                    sio.setAmount((float) (fixedRollout * amountModel.getAmount() / fixedToPay) + schemeTypeCancelledAmountMap.getOrDefault(schemeSummaryModel.getSchemeType(), 0f));
31903 amit.gupta 607 
                    if (schemeSummaryModel.getSchemeType().equals(SchemeType.IN))
608 
                        sio.setStatusDescription("Credited for GRN of IMEI-" + inventoryItem.getSerialNumber());
609 
                    else
610 
                        sio.setStatusDescription("Credited for Sale of IMEI-" + inventoryItem.getSerialNumber());
611 
                    schemeInOutRepository.persist(sio);
612 
                }
613 
            }
614 
            walletCredit += fixedRollout;
615 
        }
616 
 
617 
        if (percentageToPay > 0) {
31987 amit.gupta 618 
            LOGGER.info("inventoryPayoutModel.getFixedAmount() ----> {}", inventoryPayoutModel.getFixedAmount());
31914 amit.gupta 619 
            double effectiveDP = inventoryPayoutModel.getDp() - (inventoryPayoutModel.getFixedAmount() + fixedToPay);
31903 amit.gupta 620 
            double totalPercentage = inventoryPayoutModel.getPercentageAmount() + percentageToPay;
621 
            double percentageRollout = effectiveDP * (totalPercentage / (100 + totalPercentage) - (inventoryPayoutModel.getPercentageAmount() / (100 + inventoryPayoutModel.getPercentageAmount())));
622 
            for (Map.Entry<SchemeSummaryModel, AmountModel> schemeSummaryModelAmountModelEntry : payoutSchemeSummaryModelMap.entrySet()) {
623 
                SchemeSummaryModel schemeSummaryModel = schemeSummaryModelAmountModelEntry.getKey();
624 
                AmountModel amountModel = schemeSummaryModelAmountModelEntry.getValue();
625 
                if (amountModel.getAmountType().equals(AmountType.PERCENTAGE)) {
626 
                    SchemeInOut sio = new SchemeInOut();
627 
                    sio.setInventoryItemId(inventoryItem.getId());
628 
                    sio.setSchemeId(schemeSummaryModel.getSchemeId());
629 
                    sio.setStatus(SchemePayoutStatus.CREDITED);
630 
                    sio.setCreditTimestamp(LocalDateTime.now());
32155 amit.gupta 631 
                    sio.setAmount((float) (percentageRollout * amountModel.getAmount() / percentageToPay) +
632 
                            schemeTypeCancelledAmountMap.getOrDefault(schemeSummaryModel.getSchemeType(), 0f));
31903 amit.gupta 633 
                    if (schemeSummaryModel.getSchemeType().equals(SchemeType.IN))
634 
                        sio.setStatusDescription("Credited for GRN of IMEI-" + inventoryItem.getSerialNumber());
635 
                    else
636 
                        sio.setStatusDescription("Credited for Sale of IMEI-" + inventoryItem.getSerialNumber());
637 
                    schemeInOutRepository.persist(sio);
638 
                }
639 
            }
640 
            walletCredit += percentageRollout;
641 
        }
642 
 
643 
        return (float) walletCredit;
644 
    }
645 
 
646 
    private Set<Integer> filterImeisByAgeing(Set<Integer> inventoryItemIds, FofoOrder fofoOrder) {
647 
        Set<Integer> filteredInventoryIds = new HashSet<>();
648 
        List<PartnerAgeingModel> partnerAgeingModels = ageingService.filterAgedInventory(inventoryItemIds);
649 
        for (PartnerAgeingModel partnerAgeingModel : partnerAgeingModels) {
650 
            LOGGER.info("Serial Number - {}", partnerAgeingModel.getSerialNumber());
651 
            if (partnerAgeingModel.getBrand().equalsIgnoreCase("Samsung")) {
652 
                ActivatedImei activatedImei = activatedImeiRepository.selectBySerialNumber(partnerAgeingModel.getSerialNumber());
653 
                if (activatedImei != null && activatedImei.getActivationTimestamp().toLocalDate()
654 
                        .isBefore(partnerAgeingModel.getBillingDate().plusDays(partnerAgeingModel.getMaxAgeingDays()))) {
655 
                    //Lets give money if activation is there and is before the ageing limit of that brand.
656 
                    filteredInventoryIds.add(partnerAgeingModel.getInventoryItemId());
657 
                } else {
658 
                    //If billing happens before ageing expiry
659 
                    if (fofoOrder.getCreateTimestamp().toLocalDate().isBefore(partnerAgeingModel.getBillingDate().plusDays(partnerAgeingModel.getMaxAgeingDays()))) {
660 
                        filteredInventoryIds.add(partnerAgeingModel.getInventoryItemId());
661 
                    }
662 
                }
663 
            } else {
664 
                filteredInventoryIds.add(partnerAgeingModel.getInventoryItemId());
665 
            }
666 
        }
667 
        return filteredInventoryIds;
668 
    }
669 
 
33087 amit.gupta 670 
    @Autowired
671 
    WarehouseInventoryItemRepository warehouseInventoryItemRepository;
672 
 
31410 amit.gupta 673 
    @Override
674 
    public float processSchemeOut(int fofoOrderId, int retailerId) throws ProfitMandiBusinessException {
675 
        float totalCashback = 0;
676 
        FofoOrder fofoOrder = fofoOrderRepository.selectByFofoIdAndOrderId(retailerId, fofoOrderId);
677 
        // Process only if order is not cancelled
678 
        if (fofoOrder.getCancelledTimestamp() == null) {
679 
            // PartnerType partnerType = partnerTypeChangeService.getTypeOnDate(retailerId,
680 
            // fofoOrder.getCreateTimestamp().toLocalDate());
681 
            // TODO - SCHEME
682 
            PartnerType partnerType = partnerTypeChangeService.getTypeOnMonth(retailerId,
683 
                    YearMonth.from(fofoOrder.getCreateTimestamp()));
29927 amit.gupta 684 
 
31410 amit.gupta 685 
            List<ScanRecord> scanRecords = scanRecordRepository.selectAllByOrderId(fofoOrderId);
686 
            if (scanRecords.size() == 0) return 0;
687 
            Set<Integer> inventoryItemIds = scanRecords.stream().map(x -> x.getInventoryItemId())
688 
                    .collect(Collectors.toSet());
31903 amit.gupta 689 
            //Check for ageing
31912 amit.gupta 690 
            //inventoryItemIds = this.filterImeisByAgeing(inventoryItemIds, fofoOrder);
31903 amit.gupta 691 
            //ageingService.filterAgedInventory(inventoryItemIds);
31410 amit.gupta 692 
            LOGGER.info("fofoOrderId --- {}", fofoOrderId);
693 
            LOGGER.info("scanRecords --- {}", scanRecords);
694 
            LOGGER.info("inventoryItemIds --- {}", inventoryItemIds);
31903 amit.gupta 695 
 
696 
            if (inventoryItemIds.size() == 0) return 0;
697 
 
31410 amit.gupta 698 
            Set<InventoryItem> inventoryItems = inventoryItemRepository.selectByIds(inventoryItemIds).stream()
699 
                    .filter(x -> x.getSerialNumber() != null && !x.getSerialNumber().equals(""))
700 
                    .collect(Collectors.toSet());
701 
            inventoryItems = inventoryItems.stream().filter(inventoryItem -> !BLOCKED_IMEIS.contains(inventoryItem.getSerialNumber())).collect(Collectors.toSet());
29927 amit.gupta 702 
 
33087 amit.gupta 703 
            //Do not consider imei above 90 days for samsung
33432 amit.gupta 704 
            List<String> samsungSerialNumbers = inventoryItems.stream().filter(x -> x.getItem().getBrand().equalsIgnoreCase("samsung")).map(x -> x.getSerialNumber()).collect(Collectors.toList());
33600 ranu 705 
 
33432 amit.gupta 706 
            if (samsungSerialNumbers.size() > 0) {
33087 amit.gupta 707 
                List<AgeingSummaryModel> billedImeiModels = warehouseInventoryItemRepository.findStockAgeingByFofoIdSerialNumbers(retailerId, samsungSerialNumbers);
33606 ranu 708 
                List<String> agedSerialNumbers = billedImeiModels.stream().filter(x -> x.isAgedAbove(365)).map(x -> x.getSerialNumber()).collect(Collectors.toList());
709 
                if (agedSerialNumbers.size() > 0) {
710 
                    List<String> samsungExceptionsSerialNumbers = samsungExceptionRepository.selectAllBySerialNumber(agedSerialNumbers).stream().map(x -> x.getSerialNumber()).collect(Collectors.toList());
711 
                    agedSerialNumbers.removeAll(samsungExceptionsSerialNumbers);
712 
                }
33432 amit.gupta 713 
                inventoryItems = inventoryItems.stream().filter(x -> !agedSerialNumbers.contains(x.getSerialNumber())).collect(Collectors.toSet());
33087 amit.gupta 714 
            }
715 
 
31903 amit.gupta 716 
            if (inventoryItems.size() == 0) return 0;
29927 amit.gupta 717 
 
31903 amit.gupta 718 
            Map<Integer, List<InventoryItem>> catalogInventoryItemMap = inventoryItems.stream().collect(Collectors.groupingBy(x -> x.getItem().getCatalogItemId()));
719 
            Map<CatalogSummaryModel, List<SchemeSummaryModel>> catalogSchemeSummaryMap = tagListingRepository.getModelSchemesByCatalogIdsAndType(retailerId,
720 
                    partnerType, new ArrayList<>(catalogInventoryItemMap.keySet()), fofoOrder.getCreateTimestamp());
23444 amit.gupta 721 
 
31903 amit.gupta 722 
 
31410 amit.gupta 723 
            int count = 0;
31903 amit.gupta 724 
            for (Map.Entry<CatalogSummaryModel, List<SchemeSummaryModel>> catalogSummaryModelListEntry : catalogSchemeSummaryMap.entrySet()) {
725 
                CatalogSummaryModel catalogSummaryModel = catalogSummaryModelListEntry.getKey();
32058 amit.gupta 726 
                List<SchemeSummaryModel> schemeSummaryModels = catalogSummaryModelListEntry.getValue().stream().filter(x -> x != null).collect(Collectors.toList());
31903 amit.gupta 727 
                List<SchemeType> allOutSchemeTypes = new ArrayList<>();
728 
                allOutSchemeTypes.addAll(Arrays.asList(SchemeType.ACTIVATION, SchemeType.INVESTMENT, SchemeType.SPECIAL_SUPPORT, SchemeType.SELLOUT));
729 
                allOutSchemeTypes.addAll(OUT_SCHEME_TYPES);
730 
                schemeSummaryModels.stream().filter(x -> allOutSchemeTypes.contains(x.getSchemeType())).forEach(x -> x.setProcess(true));
731 
                if (schemeSummaryModels.stream().filter(x -> x.isProcess()).count() == 0) continue;
23444 amit.gupta 732 
 
31903 amit.gupta 733 
                List<InventoryItem> modelInventoryItems = catalogInventoryItemMap.get(catalogSummaryModel.getCatalogId());
734 
                for (InventoryItem inventoryItem : modelInventoryItems) {
32165 amit.gupta 735 
                    float inventoryItemCashback = this.createSchemeInOut(schemeSummaryModels, inventoryItem);
31903 amit.gupta 736 
                    if (inventoryItemCashback > 0) {
737 
                        count++;
738 
                        totalCashback += inventoryItemCashback;
739 
                    }
31410 amit.gupta 740 
                }
741 
            }
31903 amit.gupta 742 
 
31410 amit.gupta 743 
            if (count > 0) {
744 
                walletService.addAmountToWallet(
745 
                        retailerId, fofoOrderId, WalletReferenceType.SCHEME_OUT, "Sales margin for invoice number "
746 
                                + fofoOrder.getInvoiceNumber() + ". Total " + count + " pc(s)",
747 
                        totalCashback, fofoOrder.getCreateTimestamp());
748 
                fofoOrder.setCashback(totalCashback + fofoOrder.getCashback());
749 
            }
750 
        }
751 
        return totalCashback;
752 
    }
22653 ashik.ali 753 
 
31410 amit.gupta 754 
    @Override
755 
    //Tax rate has been passed to 0 to ensure no tax deduction
756 
    public float getSpecialSupportAmount(float supportAmount, PartnerType partnerType, LocalDate onDate,
757 
                                         int catalogId) throws ProfitMandiBusinessException {
758 
        //int itemId = itemRepository.selectAllByCatalogItemId(catalogId).stream().findAny().get().getId();
759 
        //float totalTaxRate = stateGstRateRepository.getTotalTaxRate(itemId);
760 
        return this.getSpecialSupportAmount(supportAmount, partnerType, onDate, catalogId, 0);
761 
    }
23444 amit.gupta 762 
 
31410 amit.gupta 763 
    @Override
764 
    public float getSpecialSupportAmount(float supportAmount, PartnerType partnerType, LocalDate onDate,
765 
                                         int catalogId, float taxRate) throws ProfitMandiBusinessException {
766 
        float totalMargin = this.selectPercentageScheme(partnerType, onDate, catalogId, false, 0, 0).stream().collect(Collectors.summingDouble(x -> x.getAmount())).floatValue();
767 
        float amountToCredit = supportAmount * (1 - (totalMargin / (100 + taxRate)));
768 
        return amountToCredit;
769 
    }
23444 amit.gupta 770 
 
31410 amit.gupta 771 
    @Override
33614 amit.gupta 772 
    public void rollbackSchemes(List<Integer> inventoryItemIds, String rollbackReason)
31410 amit.gupta 773 
            throws Exception {
33614 amit.gupta 774 
        List<InventoryItem> inventoryItems = inventoryItemRepository.selectAllByIds(inventoryItemIds);
775 
        Map<Integer, InventoryItem> inventoryItemMap = inventoryItems.stream().collect(Collectors.toMap(x -> x.getId(), x -> x));
776 
        Map<Integer, Integer> purchasePartnerMap = inventoryItems.stream().collect(Collectors.toMap(x -> x.getPurchaseId(), x -> x.getFofoId(), (u, v) -> u));
777 
 
778 
        LOGGER.info("inventoryItemIds - {}", inventoryItemIds);
779 
        List<SchemeInOut> schemeInOuts = schemeInOutRepository.selectByInventoryItemIds(new HashSet<>(inventoryItemIds));
780 
        List<Integer> schemeIds = schemeInOuts.stream().map(x -> x.getSchemeId()).distinct().collect(Collectors.toList());
34139 amit.gupta 781 
        if (schemeIds.size() == 0) return;
33614 amit.gupta 782 
        List<Scheme> schemes = schemeRepository.selectBySchemeIds(schemeIds);
783 
        Map<Integer, Float> inSchemesMap = new HashMap<>();
784 
        Map<Integer, Float> outSchemesMap = new HashMap<>();
785 
        Map<Integer, Scheme> schemesMap = schemes.stream().collect(Collectors.toMap(x -> x.getId(), x -> x));
786 
        for (SchemeInOut schemeInOut : schemeInOuts) {
787 
            Map<Integer, Float> schemePayoutMap;
788 
            int inventoryItemId = schemeInOut.getInventoryItemId();
31410 amit.gupta 789 
            if (schemeInOut.getRolledBackTimestamp() == null) {
790 
                schemeInOut.setRolledBackTimestamp(LocalDateTime.now());
791 
                if (schemeInOut.getStatus() == null || schemeInOut.getStatus().equals(SchemePayoutStatus.CREDITED)) {
33614 amit.gupta 792 
                    Scheme scheme = schemesMap.get(schemeInOut.getSchemeId());
793 
                    if (scheme.getType().equals(SchemeType.IN)) {
794 
                        schemePayoutMap = inSchemesMap;
795 
                    } else {
796 
                        schemePayoutMap = outSchemesMap;
797 
                    }
798 
                    if (!schemePayoutMap.containsKey(inventoryItemId)) {
799 
                        schemePayoutMap.put(inventoryItemId, 0f);
800 
                    }
34139 amit.gupta 801 
                    schemePayoutMap.put(inventoryItemId, inSchemesMap.get(inventoryItemId) == null ? 0 : inSchemesMap.get(inventoryItemId) + schemeInOut.getAmount());
31410 amit.gupta 802 
                }
803 
                schemeInOut.setStatus(SchemePayoutStatus.REJECTED);
804 
                schemeInOut.setStatusDescription(rollbackReason);
805 
            }
806 
        }
33614 amit.gupta 807 
        Map<Integer, Double> purchaseRollbackAmountMap = inSchemesMap.entrySet().stream().collect(Collectors.groupingBy(x -> inventoryItemMap.get(x.getKey()).getPurchaseId(), Collectors.summingDouble(x -> x.getValue())));
808 
 
809 
        for (Map.Entry<Integer, Double> purchaseRollbackAmountEntry : purchaseRollbackAmountMap.entrySet()) {
810 
            int purchaseId = purchaseRollbackAmountEntry.getKey();
811 
            Double amountToRollback = purchaseRollbackAmountEntry.getValue();
812 
            if (amountToRollback != null && amountToRollback > 0) {
813 
                walletService.rollbackAmountFromWallet(purchasePartnerMap.get(purchaseId), amountToRollback.floatValue(), purchaseId,
814 
                        WalletReferenceType.SCHEME_IN, rollbackReason, LocalDateTime.now());
815 
            }
31410 amit.gupta 816 
        }
817 
    }
23444 amit.gupta 818 
 
31410 amit.gupta 819 
    @Override
820 
    public Map<String, Object> getSchemes(Set<Integer> roleIds, int offset, int limit)
821 
            throws ProfitMandiBusinessException {
822 
        Map<String, Object> map = new HashMap<>();
823 
        List<Scheme> schemes = null;
824 
        long size = 0;
825 
        if (roleManager.isAdmin(roleIds)) {
826 
            schemes = schemeRepository.selectAll(offset, limit);
827 
            size = schemeRepository.selectAllCount();
828 
        } else {
829 
            schemes = schemeRepository.selectActiveAll(offset, limit);
830 
            size = schemeRepository.selectAllActiveCount();
831 
        }
832 
        map.put("schemes", schemes);
833 
        map.put("start", offset + 1);
834 
        map.put("size", size);
835 
        if (schemes.size() < limit) {
836 
            map.put("end", offset + schemes.size());
837 
        } else {
838 
            map.put("end", offset + limit);
839 
        }
840 
        return map;
841 
    }
26722 amit.gupta 842 
 
31410 amit.gupta 843 
    @Override
844 
    public List<Scheme> getPaginatedSchemes(Set<Integer> roleIds, int offset, int limit)
845 
            throws ProfitMandiBusinessException {
846 
        LOGGER.info("requested offset=[{}], limit = [{}]", offset, limit);
847 
        List<Scheme> schemes = null;
848 
        if (roleManager.isAdmin(roleIds)) {
849 
            schemes = schemeRepository.selectAll(offset, limit);
850 
        } else {
851 
            schemes = schemeRepository.selectActiveAll(offset, limit);
852 
        }
853 
        return schemes;
854 
    }
27898 amit.gupta 855 
 
31410 amit.gupta 856 
    @Override
857 
    // This is being called to reverse schemes while processing price Drop
858 
    public void reverseSchemes(List<InventoryItem> inventoryItems, int priceDropId, String reversalReason)
859 
            throws ProfitMandiBusinessException {
860 
        PriceDrop priceDrop = priceDropRepository.selectById(priceDropId);
861 
        Map<Integer, List<InventoryItem>> purchaseInventoryListMap = inventoryItems.stream()
862 
                .collect(Collectors.groupingBy(InventoryItem::getPurchaseId, Collectors.toList()));
29927 amit.gupta 863 
 
31410 amit.gupta 864 
        for (Map.Entry<Integer, List<InventoryItem>> purchaseEntry : purchaseInventoryListMap.entrySet()) {
865 
            float amountToCredit = 0;
866 
            float amountToDebit = 0;
867 
            int purchaseId = purchaseEntry.getKey();
868 
            List<InventoryItem> purchaseInventoryItemList = purchaseEntry.getValue();
30454 amit.gupta 869 
 
31410 amit.gupta 870 
            Map<Integer, InventoryItem> inventoryItemsMap = purchaseInventoryItemList.stream()
871 
                    .collect(Collectors.toMap(x -> x.getId(), x -> x));
29927 amit.gupta 872 
 
31410 amit.gupta 873 
            List<SchemeInOut> schemeInOuts = schemeInOutRepository.selectByInventoryItemIds(inventoryItemsMap.keySet());
874 
            LOGGER.info("Scheme InOuts , {}", schemeInOuts);
875 
            if (schemeInOuts.size() == 0) {
876 
                continue;
877 
            }
878 
            List<Integer> schemeIds = schemeInOuts.stream().map(x -> x.getSchemeId()).collect(Collectors.toList());
879 
            Map<Integer, Scheme> schemesMap = schemeRepository.selectBySchemeIds(schemeIds, 0, schemeIds.size())
880 
                    .stream().collect(Collectors.toMap(x -> x.getId(), x -> x));
881 
            for (SchemeInOut schemeInOut : schemeInOuts) {
882 
                InventoryItem ii = inventoryItemsMap.get(schemeInOut.getInventoryItemId());
883 
                Scheme scheme = schemesMap.get(schemeInOut.getSchemeId());
884 
                if (scheme.getAmountType().equals(AmountType.FIXED)) {
885 
                    continue;
886 
                }
887 
                if (scheme.getType().equals(SchemeType.IN) && schemeInOut.getRolledBackTimestamp() == null) {
33432 amit.gupta 888 
                    schemeInOut.setRolledBackTimestamp(LocalDateTime.now());
889 
                    schemeInOut.setStatus(SchemePayoutStatus.REJECTED);
890 
                    schemeInOut.setStatusDescription("Margin reversed due to price drop");
891 
                    // IF not credited then dont consider any credit/debit for that sio entry
892 
                    if (schemeInOut.getCreditTimestamp() != null) {
893 
                        amountToDebit += schemeInOut.getAmount();
31410 amit.gupta 894 
                    }
895 
                }
896 
            }
897 
            int fofoId = inventoryItems.get(0).getFofoId();
898 
            if (amountToDebit > 0) {
899 
                walletService.addAmountToWallet(fofoId, purchaseId, WalletReferenceType.SCHEME_IN,
900 
                        MessageFormat.format(reversalReason, purchaseInventoryItemList.size()), -amountToDebit,
901 
                        priceDrop.getAffectedOn());
902 
            }
903 
        }
904 
    }
29231 amit.gupta 905 
 
31609 amit.gupta 906 
    @Autowired
32060 amit.gupta 907 
    UserWalletRepository userWalletRepository;
908 
    @Autowired
31609 amit.gupta 909 
    UserWalletHistoryRepository userWalletHistoryRepository;
910 
 
31410 amit.gupta 911 
    @Override
912 
    // Always being called from cancel order/bad return means no SCHEME IN is considered
913 
    public void reverseSchemes(List<InventoryItem> inventoryItems, int reversalReference, String reversalReason,
914 
                               List<SchemeType> schemeTypes) throws ProfitMandiBusinessException {
915 
        Map<Integer, InventoryItem> inventoryItemsMap = inventoryItems.stream()
916 
                .collect(Collectors.toMap(x -> x.getId(), x -> x));
917 
        LOGGER.info("inventoryItems" + inventoryItems);
23444 amit.gupta 918 
 
31410 amit.gupta 919 
        Map<SchemeType, SchemeInOut> schemeTypeMap = new HashMap<>();
30454 amit.gupta 920 
 
31410 amit.gupta 921 
        List<SchemeInOut> schemeInOuts = schemeInOutRepository.selectByInventoryItemIds(inventoryItemsMap.keySet());
32060 amit.gupta 922 
        List<SchemeInOut> rolledBacks = schemeInOuts.stream().filter(x -> x.getStatusDescription().equals(reversalReason)).collect(Collectors.toList());
31410 amit.gupta 923 
        float amountToRollback = 0;
23444 amit.gupta 924 
 
31410 amit.gupta 925 
        if (!schemeInOuts.isEmpty()) {
926 
            List<Integer> schemeIds = schemeInOuts.stream().map(x -> x.getSchemeId()).collect(Collectors.toList());
927 
            LOGGER.info("schemeIds" + schemeIds);
29231 amit.gupta 928 
 
31410 amit.gupta 929 
            Map<Integer, Scheme> schemesMap = schemeRepository.selectBySchemeIds(schemeIds, 0, schemeIds.size())
930 
                    .stream().collect(Collectors.toMap(x -> x.getId(), x -> x));
32060 amit.gupta 931 
            if (rolledBacks.size() > 0) {
932 
                for (SchemeInOut schemeInOut : rolledBacks) {
933 
                    Scheme scheme = schemesMap.get(schemeInOut.getSchemeId());
934 
                    if (schemeTypes.contains(scheme.getType())) {
935 
                        schemeTypeMap.put(scheme.getType(), schemeInOut);
936 
                        if (schemeInOut.getCreditTimestamp() != null) {
31410 amit.gupta 937 
                            amountToRollback += schemeInOut.getAmount();
938 
                        }
939 
                    }
940 
                }
32060 amit.gupta 941 
            } else {
942 
                for (SchemeInOut schemeInOut : schemeInOuts) {
943 
                    Scheme scheme = schemesMap.get(schemeInOut.getSchemeId());
944 
                    if (schemeTypes.contains(scheme.getType())) {
945 
                        if (schemeInOut.getRolledBackTimestamp() == null) {
946 
                            schemeInOut.setRolledBackTimestamp(LocalDateTime.now());
947 
                            if (schemeInOut.getStatus().equals(SchemePayoutStatus.CREDITED)) {
948 
                                amountToRollback += schemeInOut.getAmount();
949 
                            }
950 
                            schemeInOut.setStatus(SchemePayoutStatus.REJECTED);
951 
                            schemeInOut.setStatusDescription(reversalReason);
952 
                        }
953 
                    }
954 
                }
31410 amit.gupta 955 
            }
956 
        }
32060 amit.gupta 957 
 
31410 amit.gupta 958 
        int fofoId = inventoryItems.get(0).getFofoId();
31609 amit.gupta 959 
        WalletReferenceType walletReferenceType = schemeTypes.containsAll(SchemeService.OUT_SCHEME_TYPES) ? WalletReferenceType.SCHEME_OUT
960 
                : schemeTypes.contains(SchemeType.ACTIVATION) ? WalletReferenceType.ACTIVATION_SCHEME
961 
                : schemeTypes.contains(SchemeType.SPECIAL_SUPPORT) ? WalletReferenceType.SPECIAL_SUPPORT
32060 amit.gupta 962 
                : schemeTypes.contains(SchemeType.INVESTMENT) ? WalletReferenceType.SCHEME_OUT : null;
963 
        List<UserWalletHistory> userWalletHistoryList = null;
32058 amit.gupta 964 
        if (amountToRollback > 0 && walletReferenceType != null) {
965 
            // Mark appropriate reference of rollback investment margin
32060 amit.gupta 966 
            if (schemeTypes.contains(SchemeType.INVESTMENT) && schemeTypeMap.containsKey(SchemeType.INVESTMENT)) {
967 
                LocalDateTime creditTime = schemeTypeMap.get(SchemeType.INVESTMENT).getCreditTimestamp();
968 
                if (creditTime == null) return;
969 
                int investmentReversalReference = Integer.parseInt(FormattingUtils.getYearMonth(creditTime.minusMonths(1)));
970 
                UserWallet userWallet = userWalletRepository.selectByRetailerId(fofoId);
971 
                userWalletHistoryList = userWalletHistoryRepository.selectAllByreferenceIdandreferenceType(userWallet.getUserId(), investmentReversalReference, WalletReferenceType.INVESTMENT_PAYOUT);
972 
                if (userWalletHistoryList.size() > 0) {
973 
                    walletReferenceType = WalletReferenceType.INVESTMENT_PAYOUT;
974 
                } else {
975 
                    userWalletHistoryList = null;
32058 amit.gupta 976 
                }
32060 amit.gupta 977 
            }
978 
            if (userWalletHistoryList == null) {
979 
                userWalletHistoryList = userWalletHistoryRepository.selectAllByreferenceIdandreferenceType(reversalReference, walletReferenceType);
980 
            }
981 
            if (userWalletHistoryList.size() > 0) {
982 
                int maxDeductible = userWalletHistoryList.stream().collect(Collectors.summingInt(x -> x.getAmount()));
983 
                if (maxDeductible > 0) {
32165 amit.gupta 984 
                    LOGGER.info("----------> maxDeductible {}, amountToRollback {}, reversalReference {}, walletReferenceType {} ", maxDeductible, amountToRollback, reversalReference, walletReferenceType);
32060 amit.gupta 985 
                    walletService.rollbackAmountFromWallet(fofoId, Math.min(maxDeductible, amountToRollback), reversalReference, walletReferenceType,
986 
                            reversalReason, LocalDateTime.now());
987 
                }
31609 amit.gupta 988 
 
31903 amit.gupta 989 
            }
32058 amit.gupta 990 
        }
31410 amit.gupta 991 
    }
29231 amit.gupta 992 
 
32060 amit.gupta 993 
 
31410 amit.gupta 994 
    @Override
995 
    public double getTotalMargin(int itemId, PartnerType partnerType, LocalDateTime dateTime) {
996 
        Session session = sessionFactory.getCurrentSession();
997 
        CriteriaBuilder cb = session.getCriteriaBuilder();
998 
        CriteriaQuery<Double> criteriaQuery = cb.createQuery(Double.class);
999 
        Root<SchemeItem> schemeItem = criteriaQuery.from(SchemeItem.class);
1000 
        Root<Scheme> scheme = criteriaQuery.from(Scheme.class);
1001 
        Predicate schemePredicate = cb.equal(scheme.get(ProfitMandiConstants.AMOUNT_TYPE), AmountType.PERCENTAGE);
1002 
        Predicate lessThanPredicate = cb.lessThanOrEqualTo(scheme.get(ProfitMandiConstants.END_DATE_TIME), dateTime);
1003 
        Predicate greaterThanPredicate = cb.greaterThanOrEqualTo(scheme.get(ProfitMandiConstants.START_DATE_TIME),
1004 
                dateTime);
1005 
        Predicate joinPredicate = cb.equal(scheme.get("id"), schemeItem.get("schemeId"));
1006 
        Predicate schemeItemPredicate = cb.equal(schemeItem.get(ProfitMandiConstants.ITEM_ID), itemId);
1007 
        criteriaQuery.select(cb.sum(scheme.get(ProfitMandiConstants.AMOUNT))).where(schemePredicate, lessThanPredicate,
1008 
                greaterThanPredicate, schemeItemPredicate, joinPredicate);
29231 amit.gupta 1009 
 
31410 amit.gupta 1010 
        Query<Double> query = session.createQuery(criteriaQuery);
1011 
        return query.getSingleResult() + ProfitMandiConstants.SCHEME_INVESTMENT_MARGIN;
29231 amit.gupta 1012 
 
31410 amit.gupta 1013 
    }
23444 amit.gupta 1014 
 
32972 amit.gupta 1015 
 
31410 amit.gupta 1016 
    @Override
33614 amit.gupta 1017 
    public Map<Integer, Float> getCatalogSchemeCashBack(int fofoId, List<Integer> catalogIds) throws
1018 
            ProfitMandiBusinessException {
32972 amit.gupta 1019 
        PartnerType partnerType = partnerTypeChangeService.getTypeOnDate(fofoId, LocalDate.now());
1020 
        Map<CatalogSummaryModel, List<SchemeSummaryModel>> catalogModelMap = tagListingRepository.getModelSchemesByCatalogIdsAndType(fofoId, partnerType, catalogIds, LocalDate.now().atStartOfDay());
1021 
 
1022 
        Map<Integer, Float> catalogCashbackMap = new HashMap<>();
1023 
        for (Map.Entry<CatalogSummaryModel, List<SchemeSummaryModel>> catalogSummaryModelListEntry : catalogModelMap.entrySet()) {
1024 
            int catalogItemId = catalogSummaryModelListEntry.getKey().getCatalogId();
1025 
            List<SchemeSummaryModel> schemeSummaryModels = catalogSummaryModelListEntry.getValue();
1026 
 
1027 
            float totalCashback = schemeSummaryModels.stream()
1028 
                    .filter(x -> Arrays.asList(SchemeType.ACTIVATION, SchemeType.SPECIAL_SUPPORT, SchemeType.SELLOUT).contains(x.getSchemeType())
1029 
                            && x.getAmountType().equals(AmountType.FIXED))
1030 
                    .collect(Collectors.summingDouble(x -> x.getAmount())).floatValue();
1031 
            catalogCashbackMap.put(catalogItemId, totalCashback);
31410 amit.gupta 1032 
        }
32972 amit.gupta 1033 
        return catalogCashbackMap;
31410 amit.gupta 1034 
    }
30572 amit.gupta 1035 
 
31410 amit.gupta 1036 
    @Override
31903 amit.gupta 1037 
    public List<Scheme> selectSchemeByPartnerTypeFofoId(PartnerType partnerType, LocalDate onDate, int catalogId,
1038 
                                                        int fofoId, int offset, int limit) throws ProfitMandiBusinessException {
31410 amit.gupta 1039 
        Session session = sessionFactory.getCurrentSession();
1040 
        final TypedQuery<Scheme> typedQuery = session.createNamedQuery(
1041 
                "Scheme.selectSchemeByModelsPartnerTypeFofoId", Scheme.class);
1042 
        typedQuery.setParameter("catalogIds", Arrays.asList(catalogId));
1043 
        typedQuery.setParameter("fofoIds", Arrays.asList(fofoId, 0));
1044 
        typedQuery.setParameter("onDate", onDate.atStartOfDay());
1045 
        typedQuery.setParameter("partnerTypes", Arrays.asList(partnerType, partnerType.ALL));
1046 
        typedQuery.setFirstResult(offset);
1047 
        if (limit != 0) {
1048 
            typedQuery.setMaxResults(limit);
1049 
        }
1050 
        return typedQuery.getResultList();
1051 
    }
30463 amit.gupta 1052 
 
33432 amit.gupta 1053 
    @Override
1054 
    public void processSchemeIn(List<InventoryItem> inventoryItems) throws ProfitMandiBusinessException {
1055 
        Map<Integer, List<InventoryItem>> purchaseIdInventoryItemsMap = inventoryItems.stream().collect(Collectors.groupingBy(x -> x.getPurchaseId()));
1056 
        for (Map.Entry<Integer, List<InventoryItem>> purchaseIdInventoryItemEntry : purchaseIdInventoryItemsMap.entrySet()) {
34139 amit.gupta 1057 
            Purchase purchase = purchaseRepository.selectById(purchaseIdInventoryItemEntry.getKey());
1058 
            this.processSchemeIn(purchase, purchaseIdInventoryItemEntry.getValue());
33432 amit.gupta 1059 
        }
1060 
    }
1061 
 
32309 amit.gupta 1062 
    @Autowired
1063 
    FofoStoreRepository fofoStoreRepository;
1064 
 
1065 
 
31410 amit.gupta 1066 
    @Override
32309 amit.gupta 1067 
    @Cacheable(value = "staticscheme", cacheManager = "oneDayCacheManager")
1068 
    public Scheme getStaticScheme(int fofoId) throws ProfitMandiBusinessException {
33165 amit.gupta 1069 
        FofoStore fofoStore = fofoStoreRepository.selectByRetailerId(fofoId);
32504 amit.gupta 1070 
        Scheme scheme = null;
1071 
        if (fofoStore.getTarget() > 0) {
1072 
            scheme = new Scheme();
33704 amit.gupta 1073 
            scheme.setName("Super Retailer - Club 3");
1074 
            scheme.setStartDateTime(LocalDate.of(2024, 8, 1).atStartOfDay());
1075 
            scheme.setEndDateTime(LocalDate.of(2024, 11, 30).atTime(LocalTime.MAX));
32504 amit.gupta 1076 
            scheme.setTarget(fofoStore.getTarget());
33548 amit.gupta 1077 
 
33704 amit.gupta 1078 
            if (scheme.getEndDateTime().plusDays(5).isBefore(LocalDateTime.now())) return null;
32504 amit.gupta 1079 
        }
33165 amit.gupta 1080 
        return scheme;
32309 amit.gupta 1081 
    }
1082 
 
1083 
    @Override
31410 amit.gupta 1084 
    public List<Scheme> selectSchemeByPartnerType(PartnerType partnerType, LocalDate onDate, int catalogId,
1085 
                                                  boolean isAdmin, int offset, int limit) throws ProfitMandiBusinessException {
1086 
        Session session = sessionFactory.getCurrentSession();
1087 
        List<Predicate> andPredicates = new ArrayList<>();
1088 
        CriteriaBuilder cb = session.getCriteriaBuilder();
1089 
        CriteriaQuery<Scheme> query = cb.createQuery(Scheme.class);
1090 
        Root<Scheme> scheme = query.from(Scheme.class);
1091 
        if (!partnerType.equals(PartnerType.ALL)) {
1092 
            List<PartnerType> pt = new ArrayList<>();
1093 
            pt.add(PartnerType.ALL);
1094 
            pt.add(partnerType);
1095 
            andPredicates.add(cb.in(scheme.get("partnerType")).value(pt));
1096 
        }
1097 
        cb.desc(cb.isNull(scheme.get("expireTimestamp")));
1098 
        if (catalogId > 0) {
30454 amit.gupta 1099 
 
31410 amit.gupta 1100 
            List<Integer> schemeIds = schemeItemRepository.selectSchemeIdByCatalogId(catalogId);
1101 
            LOGGER.info("schemeId" + schemeIds);
1102 
            if (schemeIds.isEmpty()) {
1103 
                return new ArrayList<>();
1104 
            }
1105 
            andPredicates.add(cb.in(scheme.get("id")).value(schemeIds));
1106 
            if (onDate != null) {
1107 
                andPredicates.add(cb.greaterThan(scheme.get("endDateTime"), onDate.atStartOfDay()));
1108 
                andPredicates.add(cb.lessThanOrEqualTo(scheme.get("startDateTime"), onDate.atStartOfDay()));
1109 
            }
1110 
        }
1111 
        if (!isAdmin) {
1112 
            andPredicates.add(cb.isNotNull(scheme.get("activeTimestamp")));
1113 
        }
1114 
        query.where(cb.and(andPredicates.toArray(new Predicate[0])));
1115 
        query.orderBy(cb.desc(cb.function("isnull", Boolean.class, scheme.get("expireTimestamp"))));
1116 
        if (limit == 0) {
1117 
            return session.createQuery(query).setFirstResult(offset).getResultList();
1118 
        }
1119 
        return session.createQuery(query).setFirstResult(offset).setMaxResults(limit).getResultList();
30454 amit.gupta 1120 
 
31410 amit.gupta 1121 
    }
30454 amit.gupta 1122 
 
31410 amit.gupta 1123 
    @Override
1124 
    public List<Scheme> selectPercentageScheme(PartnerType partnerType, LocalDate onDate, int catalogId,
1125 
                                               boolean isAdmin, int offset, int limit) throws ProfitMandiBusinessException {
1126 
        List<Scheme> schemes = this.selectSchemeByPartnerType(partnerType, onDate, catalogId, isAdmin, offset, limit);
1127 
        return schemes.stream().filter(x -> x.getAmountType().equals(AmountType.PERCENTAGE)).collect(Collectors.toList());
1128 
    }
30454 amit.gupta 1129 
 
31410 amit.gupta 1130 
    @Override
1131 
    public void processActivation() throws ProfitMandiBusinessException {
1132 
        List<SchemeInOut> pendingPayouts = schemeInOutRepository.selectAllPending();
1133 
        List<Integer> schemeIds = new ArrayList<>();
1134 
        Set<Integer> inventoryIds = new HashSet<>();
1135 
        for (SchemeInOut pendingPayout : pendingPayouts) {
1136 
            schemeIds.add(pendingPayout.getSchemeId());
1137 
        }
1138 
        Map<Integer, Scheme> schemesMap = schemeRepository.selectBySchemeIds(schemeIds, 0, 0).stream()
1139 
                .filter(x -> x.getType().equals(SchemeType.ACTIVATION) || x.getType().equals(SchemeType.SPECIAL_SUPPORT))
1140 
                .collect(Collectors.toMap(x -> x.getId(), x -> x));
1141 
        pendingPayouts = pendingPayouts.stream().filter(x -> schemesMap.get(x.getSchemeId()) != null)
1142 
                .collect(Collectors.toList());
23884 amit.gupta 1143 
 
31410 amit.gupta 1144 
        for (SchemeInOut pendingPayout : pendingPayouts) {
1145 
            inventoryIds.add(pendingPayout.getInventoryItemId());
1146 
        }
1147 
        Map<Integer, InventoryItem> inventoryItemMap = inventoryItemRepository.selectByIds(inventoryIds).stream()
1148 
                .collect(Collectors.toMap(x -> x.getId(), x -> x));
1149 
        Map<String, InventoryItem> serialNumberMap = inventoryItemMap.values().stream()
1150 
                .collect(Collectors.toMap(x -> x.getSerialNumber(), x -> x));
23796 amit.gupta 1151 
 
31410 amit.gupta 1152 
        List<ActivatedImei> activatedImeis = activatedImeiRepository
1153 
                .selectBySerialNumbers(new ArrayList<>(serialNumberMap.keySet())).stream().collect(Collectors.toList());
23508 amit.gupta 1154 
 
31410 amit.gupta 1155 
        Map<String, ActivatedImei> activatedImeiMap = activatedImeis.stream()
1156 
                .collect(Collectors.toMap(x -> x.getSerialNumber().toLowerCase(), x -> x));
1157 
        for (SchemeInOut pendingPayout : pendingPayouts) {
31914 amit.gupta 1158 
            Scheme scheme = schemesMap.get(pendingPayout.getSchemeId());
31410 amit.gupta 1159 
            InventoryItem ii = inventoryItemMap.get(pendingPayout.getInventoryItemId());
1160 
            String serialNumber = ii.getSerialNumber().toLowerCase();
1161 
            ActivatedImei activatedImei = activatedImeiMap.get(serialNumber);
1162 
            if (activatedImei == null) {
1163 
                continue;
1164 
            }
1165 
            if (scheme.isWithinRange(activatedImei.getActivationTimestamp())) {
1166 
                int fofoId = ii.getFofoId();
1167 
                // Get latest order Id
1168 
                int orderId = scanRecordRepository.selectByInventoryItemId(ii.getId()).stream()
1169 
                        .filter(x -> x.getOrderId() > 0)
1170 
                        .sorted(Comparator.comparing(ScanRecord::getCreateTimestamp).reversed()).findFirst().get()
1171 
                        .getOrderId();
1172 
                FofoOrder fofoOrder = fofoOrderRepository.selectByOrderId(orderId);
31916 amit.gupta 1173 
 
31921 amit.gupta 1174 
                InventoryPayoutModel inventoryPayoutModel = priceCircularService.getPayouts(ii);
31916 amit.gupta 1175 
                AmountModel amountModel = new AmountModel();
1176 
                amountModel.setAmount(scheme.getAmount());
1177 
                amountModel.setAmountType(scheme.getAmountType());
31921 amit.gupta 1178 
                double amountToRollout = inventoryPayoutModel.getRolloutAmount(amountModel);
32058 amit.gupta 1179 
                pendingPayout.setAmount((float) amountToRollout);
31410 amit.gupta 1180 
                if (scheme.getType().equals(SchemeType.ACTIVATION)) {
1181 
                    walletService.addAmountToWallet(fofoId, orderId, WalletReferenceType.ACTIVATION_SCHEME,
31914 amit.gupta 1182 
                            "Activation margin for " + ii.getItem().getItemDescriptionNoColor() + ", Imei - " + serialNumber, (float) amountToRollout,
31410 amit.gupta 1183 
                            fofoOrder.getCreateTimestamp());
1184 
                    pendingPayout.setStatusDescription("Activation margin credited, activated on " + FormattingUtils.formatDate(activatedImei.getActivationTimestamp()));
1185 
                } else {
1186 
                    walletService.addAmountToWallet(fofoId, orderId, WalletReferenceType.SPECIAL_SUPPORT,
31914 amit.gupta 1187 
                            "Special Support for " + ii.getItem().getItemDescriptionNoColor() + ", Imei - " + serialNumber, (float) amountToRollout,
31410 amit.gupta 1188 
                            fofoOrder.getCreateTimestamp());
1189 
                    pendingPayout.setStatusDescription("Special support credited, activated on " + FormattingUtils.formatDate(activatedImei.getActivationTimestamp()));
1190 
                }
1191 
                pendingPayout.setCreditTimestamp(LocalDateTime.now());
1192 
                pendingPayout.setStatus(SchemePayoutStatus.CREDITED);
1193 
            } else {
1194 
                pendingPayout.setStatus(SchemePayoutStatus.REJECTED);
1195 
                pendingPayout.setRolledBackTimestamp(LocalDateTime.now());
1196 
                ;
1197 
                pendingPayout.setStatusDescription(
1198 
                        "Rejected, activated on " + FormattingUtils.formatDate(activatedImei.getActivationTimestamp()));
1199 
            }
1200 
        }
1201 
    }
24976 amit.gupta 1202 
 
31410 amit.gupta 1203 
    @Override
1204 
    public void processActivatedImeisForSchemes() throws ProfitMandiBusinessException {
1205 
        List<SchemesImeisModel> schemesImeisModels = schemeRepository.selectSelectUnpaidSchemes();
1206 
        LOGGER.info("Total Size - " + schemesImeisModels.size());
1207 
        List<Integer> orderIds = schemesImeisModels.stream().map(x -> x.getOrderId()).collect(Collectors.toList());
1208 
        List<FofoOrder> fofoOrders = fofoOrderRepository.selectAllByOrderIds(orderIds);
1209 
        Map<Integer, FofoOrder> validOrdersMap = fofoOrders.stream().filter(x -> x.getCancelledTimestamp() == null).collect(Collectors.toMap(x -> x.getId(), x -> x));
1210 
        Map<String, List<SchemesImeisModel>> validImeiSchemesModelMap = schemesImeisModels.stream().filter(x -> validOrdersMap.containsKey(x.getOrderId())).collect(Collectors.groupingBy(x -> x.getImei()));
1211 
        for (Map.Entry<String, List<SchemesImeisModel>> imeiListEntry : validImeiSchemesModelMap.entrySet()) {
1212 
            SchemesImeisModel schemesImeisModel = imeiListEntry.getValue().get(0);
1213 
            List<Integer> schemeIds = imeiListEntry.getValue().stream().map(x -> x.getSchemeId()).collect(Collectors.toList());
1214 
            LOGGER.info("Serial Number  - {}, Scheme IDs - {}", schemesImeisModel.getImei(), schemeIds);
1215 
            InventoryItem inventoryItem = inventoryItemRepository.selectById(schemesImeisModel.getInventoryItemId());
1216 
            List<Scheme> schemes = schemeRepository.selectBySchemeIds(schemeIds);
1217 
            List<Scheme> supportSchemes = schemes.stream().filter(x -> Arrays.asList(SchemeType.SPECIAL_SUPPORT, SchemeType.ACTIVATION).contains(x.getType())).collect(Collectors.toList());
1218 
            if (supportSchemes.size() > 0) {
32165 amit.gupta 1219 
                for (Scheme scheme : supportSchemes) {
1220 
                    List<SchemeInOut> schemeInOuts = schemeInOutRepository.selectByScheme(scheme.getId(), inventoryItem.getId());
32972 amit.gupta 1221 
                    if (schemeInOuts.stream().filter(x -> Arrays.asList(SchemePayoutStatus.CREDITED, SchemePayoutStatus.PENDING).contains(x.getStatus())).count() > 0) {
32165 amit.gupta 1222 
                        continue;
1223 
                    }
1224 
                    SchemeInOut sio = new SchemeInOut();
1225 
                    sio.setAmount(0);
1226 
                    sio.setInventoryItemId(inventoryItem.getId());
1227 
                    sio.setSchemeId(scheme.getId());
1228 
                    sio.setStatusDescription("Activation pending for IMEI#" + inventoryItem.getSerialNumber());
1229 
                    sio.setStatus(SchemePayoutStatus.PENDING);
1230 
                    schemeInOutRepository.persist(sio);
1231 
                }
31410 amit.gupta 1232 
            }
1233 
        }
1234 
    }
22653 ashik.ali 1235 
}