Subversion Repositories SmartDukaan

Rev

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

Rev Author Line No. Line
28217 tejbeer 1 
package com.smartdukaan.cron.scheduled;
23723 amit.gupta 2 
 
24542 amit.gupta 3 
import com.google.common.collect.Lists;
25300 tejbeer 4 
import com.google.gson.Gson;
29488 manish 5 
import com.razorpay.Payment;
6 
import com.smartdukaan.cron.itelImeiActivation.ItelImeiActivationService;
7 
import com.smartdukaan.cron.itelImeiActivation.TecnoImeiActivation;
25721 tejbeer 8 
import com.spice.profitmandi.common.enumuration.MessageType;
23724 amit.gupta 9 
import com.spice.profitmandi.common.enumuration.RechargeStatus;
24681 amit.gupta 10 
import com.spice.profitmandi.common.enumuration.ReporticoProject;
24121 govind 11 
import com.spice.profitmandi.common.exception.ProfitMandiBusinessException;
31123 amit.gupta 12 
import com.spice.profitmandi.common.model.*;
24681 amit.gupta 13 
import com.spice.profitmandi.common.services.ReporticoService;
29814 tejbeer 14 
import com.spice.profitmandi.common.services.mandii.AccountStatusResponseOut;
15 
import com.spice.profitmandi.common.services.mandii.EligibilityStatusEnum;
16 
import com.spice.profitmandi.common.services.mandii.MandiiService;
24002 amit.gupta 17 
import com.spice.profitmandi.common.util.FileUtil;
23929 amit.gupta 18 
import com.spice.profitmandi.common.util.FormattingUtils;
27678 amit.gupta 19 
import com.spice.profitmandi.common.util.PdfUtils;
23929 amit.gupta 20 
import com.spice.profitmandi.common.util.Utils;
24592 amit.gupta 21 
import com.spice.profitmandi.common.util.Utils.Attachment;
29308 tejbeer 22 
import com.spice.profitmandi.common.web.client.RestClient;
25300 tejbeer 23 
import com.spice.profitmandi.dao.Interface.Campaign;
25590 amit.gupta 24 
import com.spice.profitmandi.dao.entity.auth.AuthUser;
30421 tejbeer 25 
import com.spice.profitmandi.dao.entity.auth.PartnerCollectionRemark;
25800 tejbeer 26 
import com.spice.profitmandi.dao.entity.catalog.FocusedModel;
25609 amit.gupta 27 
import com.spice.profitmandi.dao.entity.catalog.Item;
24590 amit.gupta 28 
import com.spice.profitmandi.dao.entity.catalog.Scheme;
31388 amit.gupta 29 
import com.spice.profitmandi.dao.entity.catalog.TagListing;
25590 amit.gupta 30 
import com.spice.profitmandi.dao.entity.cs.Position;
26283 tejbeer 31 
import com.spice.profitmandi.dao.entity.cs.Ticket;
28769 amit.gupta 32 
import com.spice.profitmandi.dao.entity.dtr.User;
31123 amit.gupta 33 
import com.spice.profitmandi.dao.entity.dtr.*;
34 
import com.spice.profitmandi.dao.entity.fofo.*;
30390 amit.gupta 35 
import com.spice.profitmandi.dao.entity.inventory.ReporticoCacheTable;
27208 tejbeer 36 
import com.spice.profitmandi.dao.entity.inventory.SaholicCIS;
37 
import com.spice.profitmandi.dao.entity.inventory.SaholicPOItem;
31123 amit.gupta 38 
import com.spice.profitmandi.dao.entity.transaction.*;
39 
import com.spice.profitmandi.dao.entity.user.*;
30421 tejbeer 40 
import com.spice.profitmandi.dao.enumuration.auth.CollectionRemark;
24250 amit.gupta 41 
import com.spice.profitmandi.dao.enumuration.catalog.SchemeType;
25598 amit.gupta 42 
import com.spice.profitmandi.dao.enumuration.cs.EscalationType;
26790 tejbeer 43 
import com.spice.profitmandi.dao.enumuration.dtr.RefferalStatus;
29814 tejbeer 44 
import com.spice.profitmandi.dao.enumuration.fofo.Gateway;
31332 amit.gupta 45 
import com.spice.profitmandi.dao.enumuration.fofo.PaymentStatus;
24242 amit.gupta 46 
import com.spice.profitmandi.dao.enumuration.fofo.ScanType;
30913 tejbeer 47 
import com.spice.profitmandi.dao.enumuration.transaction.CreditRisk;
30859 tejbeer 48 
import com.spice.profitmandi.dao.enumuration.transaction.LoanReferenceType;
25609 amit.gupta 49 
import com.spice.profitmandi.dao.enumuration.transaction.PriceDropImeiStatus;
30390 amit.gupta 50 
import com.spice.profitmandi.dao.model.PartnerDetailModel;
25300 tejbeer 51 
import com.spice.profitmandi.dao.model.SimpleCampaign;
52 
import com.spice.profitmandi.dao.model.SimpleCampaignParams;
25590 amit.gupta 53 
import com.spice.profitmandi.dao.repository.auth.AuthRepository;
30421 tejbeer 54 
import com.spice.profitmandi.dao.repository.auth.PartnerCollectionRemarkRepository;
31638 tejbeer 55 
import com.spice.profitmandi.dao.repository.catalog.CustomerOfferItemRepository;
56 
import com.spice.profitmandi.dao.repository.catalog.CustomerOfferRepository;
57 
import com.spice.profitmandi.dao.repository.catalog.DeviceRepository;
58 
import com.spice.profitmandi.dao.repository.catalog.FocusedModelRepository;
59 
import com.spice.profitmandi.dao.repository.catalog.ItemRepository;
60 
import com.spice.profitmandi.dao.repository.catalog.SchemeRepository;
61 
import com.spice.profitmandi.dao.repository.catalog.StateGstRateRepository;
62 
import com.spice.profitmandi.dao.repository.catalog.TagListingRepository;
63 
import com.spice.profitmandi.dao.repository.cs.CsService;
64 
import com.spice.profitmandi.dao.repository.cs.PartnerRegionRepository;
65 
import com.spice.profitmandi.dao.repository.cs.PositionRepository;
66 
import com.spice.profitmandi.dao.repository.cs.RegionRepository;
67 
import com.spice.profitmandi.dao.repository.cs.TicketRepository;
68 
import com.spice.profitmandi.dao.repository.dtr.CreditAccountRepository;
69 
import com.spice.profitmandi.dao.repository.dtr.DailyRechargeRepository;
70 
import com.spice.profitmandi.dao.repository.dtr.EmployeeAttendanceRepository;
71 
import com.spice.profitmandi.dao.repository.dtr.FofoStoreRepository;
72 
import com.spice.profitmandi.dao.repository.dtr.FranchiseeActivityRepository;
73 
import com.spice.profitmandi.dao.repository.dtr.FranchiseeVisitRepository;
74 
import com.spice.profitmandi.dao.repository.dtr.InsurancePolicyRepository;
75 
import com.spice.profitmandi.dao.repository.dtr.LeadRepository;
76 
import com.spice.profitmandi.dao.repository.dtr.Mongo;
77 
import com.spice.profitmandi.dao.repository.dtr.NotificationCampaignRepository;
78 
import com.spice.profitmandi.dao.repository.dtr.PartnerProblemRepository;
79 
import com.spice.profitmandi.dao.repository.dtr.PushNotificationRepository;
80 
import com.spice.profitmandi.dao.repository.dtr.RechargeProviderCreditWalletHistoryRepository;
81 
import com.spice.profitmandi.dao.repository.dtr.RechargeProviderRepository;
82 
import com.spice.profitmandi.dao.repository.dtr.RechargeTransactionRepository;
83 
import com.spice.profitmandi.dao.repository.dtr.RefferalRepository;
84 
import com.spice.profitmandi.dao.repository.dtr.RetailerRegisteredAddressRepository;
85 
import com.spice.profitmandi.dao.repository.dtr.UserAccountRepository;
86 
import com.spice.profitmandi.dao.repository.dtr.UserCampaignRepository;
87 
import com.spice.profitmandi.dao.repository.dtr.WebListingRepository;
88 
import com.spice.profitmandi.dao.repository.dtr.WebProductListingRepository;
89 
import com.spice.profitmandi.dao.repository.fofo.ActivatedImeiRepository;
90 
import com.spice.profitmandi.dao.repository.fofo.CurrentInventorySnapshotRepository;
91 
import com.spice.profitmandi.dao.repository.fofo.CurrentPartnerDailyInvestmentRepository;
92 
import com.spice.profitmandi.dao.repository.fofo.CustomerAddressRepository;
93 
import com.spice.profitmandi.dao.repository.fofo.CustomerRepository;
94 
import com.spice.profitmandi.dao.repository.fofo.FofoLineItemRepository;
95 
import com.spice.profitmandi.dao.repository.fofo.FofoOrderItemRepository;
96 
import com.spice.profitmandi.dao.repository.fofo.FofoOrderRepository;
97 
import com.spice.profitmandi.dao.repository.fofo.FofoPaymentRepository;
98 
import com.spice.profitmandi.dao.repository.fofo.HygieneDataRepository;
99 
import com.spice.profitmandi.dao.repository.fofo.InventoryItemRepository;
100 
import com.spice.profitmandi.dao.repository.fofo.MonthlyTargetRepository;
101 
import com.spice.profitmandi.dao.repository.fofo.PartnerDailyInvestmentRepository;
102 
import com.spice.profitmandi.dao.repository.fofo.PartnerTargetRepository;
103 
import com.spice.profitmandi.dao.repository.fofo.PartnerTypeChangeRepository;
104 
import com.spice.profitmandi.dao.repository.fofo.PartnerTypeChangeService;
105 
import com.spice.profitmandi.dao.repository.fofo.PendingOrderItemRepository;
106 
import com.spice.profitmandi.dao.repository.fofo.PendingOrderRepository;
107 
import com.spice.profitmandi.dao.repository.fofo.PendingOrderService;
108 
import com.spice.profitmandi.dao.repository.fofo.PurchaseRepository;
109 
import com.spice.profitmandi.dao.repository.fofo.RazorPayRepository;
110 
import com.spice.profitmandi.dao.repository.fofo.ScanRecordRepository;
111 
import com.spice.profitmandi.dao.repository.fofo.SchemeInOutRepository;
112 
import com.spice.profitmandi.dao.repository.fofo.SchemeItemRepository;
113 
import com.spice.profitmandi.dao.repository.fofo.ServiceConfigRepository;
30390 amit.gupta 114 
import com.spice.profitmandi.dao.repository.inventory.ReporticoCacheTableRepository;
28990 amit.gupta 115 
import com.spice.profitmandi.dao.repository.inventory.StateRepository;
28775 amit.gupta 116 
import com.spice.profitmandi.dao.repository.inventory.WarehouseRepository;
31638 tejbeer 117 
import com.spice.profitmandi.dao.repository.transaction.HdfcPaymentRepository;
118 
import com.spice.profitmandi.dao.repository.transaction.LineItemRepository;
119 
import com.spice.profitmandi.dao.repository.transaction.LoanRepository;
120 
import com.spice.profitmandi.dao.repository.transaction.LoanStatementRepository;
121 
import com.spice.profitmandi.dao.repository.transaction.OrderRepository;
122 
import com.spice.profitmandi.dao.repository.transaction.PriceDropIMEIRepository;
123 
import com.spice.profitmandi.dao.repository.transaction.PriceDropRepository;
124 
import com.spice.profitmandi.dao.repository.transaction.SDCreditRequirementRepository;
125 
import com.spice.profitmandi.dao.repository.transaction.SanctionRequestRepository;
126 
import com.spice.profitmandi.dao.repository.transaction.TransactionRepository;
127 
import com.spice.profitmandi.dao.repository.transaction.UserWalletHistoryRepository;
128 
import com.spice.profitmandi.dao.repository.transaction.UserWalletRepository;
24542 amit.gupta 129 
import com.spice.profitmandi.dao.repository.user.AddressRepository;
25721 tejbeer 130 
import com.spice.profitmandi.dao.repository.user.UserRepository;
31618 amit.gupta 131 
import com.spice.profitmandi.dao.repository.warehouse.BilledImeiModel;
132 
import com.spice.profitmandi.dao.repository.warehouse.WarehouseInventoryItemRepository;
31604 tejbeer 133 
import com.spice.profitmandi.dao.service.solr.FofoSolr;
25854 amit.gupta 134 
import com.spice.profitmandi.service.NotificationService;
24337 amit.gupta 135 
import com.spice.profitmandi.service.PartnerInvestmentService;
30390 amit.gupta 136 
import com.spice.profitmandi.service.PartnerStatsService;
31332 amit.gupta 137 
import com.spice.profitmandi.service.integrations.CCAvenuePaymentService;
28368 tejbeer 138 
import com.spice.profitmandi.service.integrations.RazorpayPaymentService;
30858 amit.gupta 139 
import com.spice.profitmandi.service.integrations.bharti.model.BAGInsuranceModel;
25694 amit.gupta 140 
import com.spice.profitmandi.service.integrations.toffee.ToffeeService;
23929 amit.gupta 141 
import com.spice.profitmandi.service.inventory.InventoryService;
27208 tejbeer 142 
import com.spice.profitmandi.service.inventory.SaholicInventoryService;
25335 amit.gupta 143 
import com.spice.profitmandi.service.order.OrderService;
24431 amit.gupta 144 
import com.spice.profitmandi.service.pricing.PriceDropService;
23724 amit.gupta 145 
import com.spice.profitmandi.service.recharge.provider.OxigenRechargeProviderService;
146 
import com.spice.profitmandi.service.recharge.provider.ThinkWalnutDigitalRechargeProviderService;
147 
import com.spice.profitmandi.service.scheme.SchemeService;
29668 tejbeer 148 
import com.spice.profitmandi.service.serviceConfig.ServiceConfigService;
31008 amit.gupta 149 
import com.spice.profitmandi.service.transaction.CreditNoteService;
30859 tejbeer 150 
import com.spice.profitmandi.service.transaction.SDCreditService;
23929 amit.gupta 151 
import com.spice.profitmandi.service.transaction.TransactionService;
152 
import com.spice.profitmandi.service.user.RetailerService;
23739 amit.gupta 153 
import com.spice.profitmandi.service.wallet.WalletService;
31638 tejbeer 154 
 
25721 tejbeer 155 
import in.shop2020.model.v1.order.OrderStatus;
29308 tejbeer 156 
import in.shop2020.model.v1.order.WalletReferenceType;
157 
import okhttp3.OkHttpClient;
158 
import okhttp3.Request;
30119 amit.gupta 159 
import okhttp3.Response;
23739 amit.gupta 160 
 
23723 amit.gupta 161 
@Component
23724 amit.gupta 162 
@Transactional(rollbackFor = Throwable.class)
23723 amit.gupta 163 
public class ScheduledTasks {
164 
 
23724 amit.gupta 165 
	@Value("${oxigen.recharge.transaction.url}")
166 
	private String oxigenRechargeTransactionUrl;
23723 amit.gupta 167 
 
23724 amit.gupta 168 
	@Value("${oxigen.recharge.enquiry.url}")
169 
	private String oxigenRechargeEnquiryUrl;
24533 govind 170 
 
24431 amit.gupta 171 
	@Autowired
27088 tejbeer 172 
	private RegionRepository regionRepository;
29668 tejbeer 173 
 
29488 manish 174 
	@Autowired
29801 manish 175 
	private ServiceConfigService serviceConfigService;
176 
 
177 
	@Autowired
29488 manish 178 
	private TecnoImeiActivation tecnoImeiActivation;
28205 tejbeer 179 
 
27795 amit.gupta 180 
	private static final DateTimeFormatter leadTimeFormatter = DateTimeFormatter.ofPattern("d LLL, hh:mm a");
27088 tejbeer 181 
 
182 
	@Autowired
183 
	private PartnerRegionRepository partnerRegionRepository;
28790 amit.gupta 184 
 
28769 amit.gupta 185 
	@Autowired
186 
	private EmployeeAttendanceRepository employeeAttendanceRepository;
27088 tejbeer 187 
 
188 
	@Autowired
29451 manish 189 
	VivoImeiActivationService vivoImeiActivationService;
29488 manish 190 
 
29451 manish 191 
	@Autowired
29488 manish 192 
	ItelImeiActivationService itelImeiActivationService;
193 
 
194 
	@Autowired
25503 amit.gupta 195 
	private PartnerTypeChangeService partnerTypeChangeService;
25598 amit.gupta 196 
 
25590 amit.gupta 197 
	@Autowired
26408 amit.gupta 198 
	private ActivatedImeiRepository activatedImeiRepository;
199 
 
200 
	@Autowired
29451 manish 201 
	private LineItemRepository lineItemRepository;
202 
 
203 
	@Autowired
25910 amit.gupta 204 
	private LeadRepository leadRepository;
25927 amit.gupta 205 
 
25910 amit.gupta 206 
	@Autowired
25590 amit.gupta 207 
	private AuthRepository authRepository;
25503 amit.gupta 208 
 
209 
	@Autowired
24431 amit.gupta 210 
	private PriceDropService priceDropService;
26283 tejbeer 211 
 
25590 amit.gupta 212 
	@Autowired
25927 amit.gupta 213 
	private FranchiseeVisitRepository franchiseeVisitRepository;
26790 tejbeer 214 
 
25927 amit.gupta 215 
	@Autowired
216 
	private FranchiseeActivityRepository franchiseeActivityRepository;
26790 tejbeer 217 
 
25927 amit.gupta 218 
	@Autowired
25982 amit.gupta 219 
	private HdfcPaymentRepository hdfcPaymentRepository;
26790 tejbeer 220 
 
25982 amit.gupta 221 
	@Autowired
25590 amit.gupta 222 
	private CsService csService;
25846 amit.gupta 223 
 
25837 amit.gupta 224 
	@Autowired
27208 tejbeer 225 
	private SaholicInventoryService saholicInventoryService;
226 
 
227 
	@Autowired
25837 amit.gupta 228 
	private InsurancePolicyRepository insurancePolicyRepository;
23723 amit.gupta 229 
 
25694 amit.gupta 230 
	@Autowired
231 
	private ToffeeService toffeeService;
232 
 
23724 amit.gupta 233 
	@Value("${oxigen.recharge.auth.key}")
234 
	private String oxigenRechargeAuthKey;
235 
 
236 
	@Value("${oxigen.recharge.validation.url}")
237 
	private String oxigenRechargeValidationUrl;
238 
 
239 
	@Value("${oxigen.recharge.validation.auth.key}")
240 
	private String oxigenRechargeValidationAuthKey;
241 
 
242 
	@Value("${think.walnut.digital.recharge.transaction.mobile.url}")
243 
	private String thinkWalnutDigitalRechargeTransactionMobileUrl;
244 
 
245 
	@Value("${think.walnut.digital.recharge.transaction.dth.url}")
246 
	private String thinkWalnutDigitalRechargeTransactionDthUrl;
247 
 
248 
	@Value("${think.walnut.digital.recharge.enquiry.url}")
249 
	private String thinkWalnutDigitalRechargeEnquiryUrl;
250 
 
251 
	@Value("${think.walnut.digital.recharge.balance.url}")
252 
	private String thinkWalnutDigitalRechargeBalanceUrl;
253 
 
254 
	@Value("${think.walnut.digital.recharge.username}")
255 
	private String thinkWalnutDigitalRechargeUserName;
256 
 
257 
	@Value("${think.walnut.digital.recharge.password}")
258 
	private String thinkWalnutDigitalRechargePassword;
259 
 
260 
	@Value("${think.walnut.digital.recharge.auth.key}")
261 
	private String thinkWalnutDigitalRechargeAuthKey;
262 
 
23723 amit.gupta 263 
	@Autowired
23724 amit.gupta 264 
	private PurchaseRepository purchaseRepository;
265 
 
266 
	@Autowired
25609 amit.gupta 267 
	private PriceDropIMEIRepository priceDropIMEIRepository;
268 
 
269 
	@Autowired
270 
	PriceDropRepository priceDropRepository;
271 
 
272 
	@Autowired
27086 tejbeer 273 
	private PartnerTypeChangeRepository partnerTypeChangeRepository;
28368 tejbeer 274 
 
27086 tejbeer 275 
	@Autowired
23724 amit.gupta 276 
	private SchemeService schemeService;
24683 amit.gupta 277 
 
29668 tejbeer 278 
	@Autowired
279 
	private ServiceConfigRepository serviceConfigRepository;
280 
 
29308 tejbeer 281 
	@Value("${delhivery.tracking.token}")
282 
	private String token;
283 
 
30752 tejbeer 284 
	private static final String[] STOCK_AGEING_MAIL_LIST = new String[] { "uday.singh@smartudkaan.com",
29160 amit.gupta 285 
			"mohinder.mutreja@smartdukaan.com", "ankit.bhatia@smartdukaan.com", "tarun.verma@smartdukaan.com",
30752 tejbeer 286 
			"kuldeep.kumar@smartdukaan.com", "manish.gupta@smartdukaan.com" };
25609 amit.gupta 287 
 
30752 tejbeer 288 
	private static final String[] ITEMWISE_PENDING_INDENT_MAIL_LIST = new String[] { "kamini.sharma@smartdukaan.com",
28205 tejbeer 289 
			"tarun.verma@smartdukaan.com", "uday.singh@smartdukaan.com", "kuldeep.kumar@smartdukaan.com",
30752 tejbeer 290 
			"niranjan.kala@smartdukaan.com" };
25609 amit.gupta 291 
 
30752 tejbeer 292 
	private static final String[] INDENT_TERTIARY_MAIL_LIST = new String[] { "uday.singh@smartdukaan.com",
293 
			"kuldeep.kumar@smartdukaan.com" };
28709 amit.gupta 294 
 
30752 tejbeer 295 
	private static final String[] EMPLOYEE_ATTENDANCE_MAIL_LIST = new String[] { "sm@smartdukaan.com",
296 
			"sm@smartdukaan.com" };
28790 amit.gupta 297 
 
25721 tejbeer 298 
	private List<OrderStatus> orderStatusList = Arrays.asList(OrderStatus.SUBMITTED_FOR_PROCESSING);
299 
 
24681 amit.gupta 300 
	@Autowired
301 
	private ReporticoService reporticoService;
23724 amit.gupta 302 
 
303 
	@Autowired
24337 amit.gupta 304 
	private PartnerInvestmentService partnerInvestmentService;
25598 amit.gupta 305 
 
25590 amit.gupta 306 
	@Autowired
307 
	private PositionRepository positionRepository;
24337 amit.gupta 308 
 
309 
	@Autowired
24542 amit.gupta 310 
	private FofoOrderItemRepository fofoOrderItemRepository;
25865 amit.gupta 311 
 
25854 amit.gupta 312 
	@Autowired
313 
	private NotificationService notificationService;
24542 amit.gupta 314 
 
315 
	@Autowired
24277 amit.gupta 316 
	private PartnerDailyInvestmentRepository partnerDailyInvestmentRepository;
317 
 
318 
	@Autowired
24241 amit.gupta 319 
	private SchemeInOutRepository schemeInOutRepository;
320 
 
321 
	@Autowired
23724 amit.gupta 322 
	private RechargeTransactionRepository rechargeTransactionRepository;
323 
 
324 
	@Autowired
24542 amit.gupta 325 
	private CustomerAddressRepository customerAddressRepository;
326 
 
327 
	@Autowired
23724 amit.gupta 328 
	private RechargeProviderCreditWalletHistoryRepository rechargeProviderCreditWalletHistoryRepository;
329 
 
330 
	@Autowired
24590 amit.gupta 331 
	private FofoLineItemRepository fofoLineItemRepository;
332 
 
333 
	@Autowired
23724 amit.gupta 334 
	private FofoOrderRepository fofoOrderRepository;
24587 amit.gupta 335 
 
24580 amit.gupta 336 
	@Autowired
337 
	private UserWalletHistoryRepository userWalletHistoryRepository;
24250 amit.gupta 338 
 
24249 amit.gupta 339 
	@Autowired
24587 amit.gupta 340 
	private UserWalletRepository userWalletRepository;
341 
 
342 
	@Autowired
24249 amit.gupta 343 
	private InventoryItemRepository inventoryItemRepository;
23929 amit.gupta 344 
 
23739 amit.gupta 345 
	@Autowired
346 
	private WalletService walletService;
23724 amit.gupta 347 
 
348 
	@Autowired
349 
	private ThinkWalnutDigitalRechargeProviderService thinkWalnutDigitalRechargeProviderService;
350 
 
351 
	@Autowired
352 
	private OxigenRechargeProviderService oxigenRechargeProviderService;
353 
 
354 
	@Autowired
355 
	private RechargeProviderRepository rechargeProviderRepository;
356 
 
357 
	@Autowired
24242 amit.gupta 358 
	private ScanRecordRepository scanRecordRepository;
359 
 
360 
	@Autowired
23724 amit.gupta 361 
	private DailyRechargeRepository dailyRechargeRepository;
362 
 
23929 amit.gupta 363 
	@Autowired
364 
	private FofoStoreRepository fofoStoreRepository;
24177 govind 365 
 
23724 amit.gupta 366 
	@Value("${prod}")
367 
	private boolean prod;
26945 amit.gupta 368 
 
26929 amit.gupta 369 
	@Autowired
370 
	private StateGstRateRepository stateGstRateRepository;
23724 amit.gupta 371 
 
23929 amit.gupta 372 
	@Autowired
373 
	private RetailerService retailerService;
374 
 
375 
	@Autowired
376 
	private TransactionService transactionService;
24250 amit.gupta 377 
 
24249 amit.gupta 378 
	@Autowired
379 
	private ItemRepository itemRepository;
23929 amit.gupta 380 
 
381 
	@Autowired
382 
	private OrderRepository orderRepository;
25351 tejbeer 383 
 
25335 amit.gupta 384 
	@Autowired
385 
	private OrderService orderService;
23929 amit.gupta 386 
 
387 
	@Autowired
24241 amit.gupta 388 
	private SchemeRepository schemeRepository;
389 
 
390 
	@Autowired
31612 tejbeer 391 
	private SchemeItemRepository schemeItemRepository;
392 
 
393 
	@Autowired
23929 amit.gupta 394 
	private JavaMailSender mailSender;
24177 govind 395 
 
24174 govind 396 
	@Autowired
397 
	private PartnerTargetRepository partnerTargetRepository;
24002 amit.gupta 398 
 
399 
	@Autowired
400 
	@Qualifier(value = "googleMailSender")
23932 amit.gupta 401 
	private JavaMailSender googleMailSender;
23929 amit.gupta 402 
 
403 
	@Autowired
404 
	private InventoryService inventoryService;
405 
 
24533 govind 406 
	@Autowired
24542 amit.gupta 407 
	private AddressRepository addressRepository;
408 
 
409 
	@Autowired
410 
	private RetailerRegisteredAddressRepository retailerRegisteredAddressRepository;
411 
 
24653 govind 412 
	@Autowired
413 
	private Mongo mongoClient;
24683 amit.gupta 414 
 
24669 govind 415 
	@Autowired
25300 tejbeer 416 
	private DeviceRepository deviceRepository;
417 
 
418 
	@Autowired
419 
	private PushNotificationRepository pushNotificationRepository;
420 
 
421 
	@Autowired
422 
	private NotificationCampaignRepository notificationCampaignRepository;
423 
 
424 
	@Autowired
25721 tejbeer 425 
	private CurrentInventorySnapshotRepository currentInventorySnapshotRepository;
426 
 
427 
	@Autowired
428 
	private FocusedModelRepository focusedModelRepository;
429 
 
430 
	@Autowired
24669 govind 431 
	private UserAccountRepository userAccountRepository;
24653 govind 432 
 
25721 tejbeer 433 
	@Autowired
25927 amit.gupta 434 
	private UserRepository userUserRepository;
25721 tejbeer 435 
 
436 
	@Autowired
25927 amit.gupta 437 
	private com.spice.profitmandi.dao.repository.dtr.UserRepository dtrUserRepository;
438 
 
439 
	@Autowired
25721 tejbeer 440 
	private UserCampaignRepository userCampaignRepository;
441 
 
442 
	@Autowired
443 
	private Gson gson;
444 
 
26283 tejbeer 445 
	@Autowired
446 
	private TicketRepository ticketRepository;
447 
 
26790 tejbeer 448 
	@Autowired
449 
	private RefferalRepository refferalRepository;
450 
 
28205 tejbeer 451 
	@Autowired
452 
	private PartnerProblemRepository partnerProblemRepository;
453 
 
28368 tejbeer 454 
	@Autowired
455 
	private PendingOrderRepository pendingOrderRepository;
456 
 
457 
	@Autowired
458 
	private PendingOrderItemRepository pendingOrderItemRepository;
459 
 
460 
	@Value("${razorpay.account.keyId}")
461 
	private String keyId;
462 
 
463 
	@Value("${razorpay.account.keySecret}")
464 
	private String keySecret;
465 
 
28369 tejbeer 466 
	@Autowired
467 
	private RazorpayPaymentService razorPaymentService;
468 
 
469 
	@Autowired
470 
	private RazorPayRepository razorPayRepository;
471 
 
28377 tejbeer 472 
	@Autowired
473 
	private PendingOrderService pendingOrderService;
474 
 
475 
	@Autowired
476 
	private CustomerRepository customerRepository;
477 
 
29308 tejbeer 478 
	@Autowired
479 
	private RestClient restClient;
480 
 
29814 tejbeer 481 
	@Autowired
482 
	private MandiiService mandiiService;
483 
 
484 
	@Autowired
485 
	CreditAccountRepository creditAccountRepository;
31604 tejbeer 486 
 
487 
	@Autowired
31612 tejbeer 488 
	CustomerOfferRepository customerOfferRepository;
489 
 
490 
	@Autowired
491 
	CustomerOfferItemRepository customerOfferItemRepository;
492 
	@Autowired
31604 tejbeer 493 
	private FofoSolr fofoSolr;
31618 amit.gupta 494 
 
495 
 
23755 amit.gupta 496 
	private static final Logger LOGGER = LogManager.getLogger(ScheduledTasks.class);
23724 amit.gupta 497 
 
25300 tejbeer 498 
	private String FCM_URL = "https://fcm.googleapis.com/fcm/send";
499 
	private String FCM_API_KEY = "AAAASAjNcn4:APA91bG6fWRIgYJI0L9gCjP5ynaXz2hJHYKtD9dfH7Depdv31Nd9APJwhx-OPkAJ1WSz4BGNYG8lHThLFSjDGFxIwUZv241YcAJEGDLgt86mxq9FXJe-yBRu-S0_ZwHqmX-QaVKl5F_A";
500 
 
31388 amit.gupta 501 
	@Autowired
502 
	private TagListingRepository tagListingRepository;
503 
 
23724 amit.gupta 504 
	public void generateDailyRecharge() {
505 
		List<RechargeProviderCreditWalletHistory> allCreditHistory = rechargeProviderCreditWalletHistoryRepository
506 
				.selectAll(0, 2000);
507 
		List<RechargeProvider> rechargeProviders = rechargeProviderRepository.selectAll();
508 
		rechargeProviders.stream().forEach(x -> x.setAmount(0));
509 
 
510 
		rechargeProviders.stream().forEach(x -> {
511 
			Map<LocalDate, List<RechargeProviderCreditWalletHistory>> dateWiseProviderCreditsMap = allCreditHistory
512 
					.stream().filter(z -> z.getProviderId() == x.getId())
513 
					.collect(Collectors.groupingBy(x1 -> x1.getReceiveTimestamp().toLocalDate()));
514 
 
29252 amit.gupta 515 
			LOGGER.info("dateWiseProviderCreditsMap -{}", dateWiseProviderCreditsMap);
23724 amit.gupta 516 
			LocalDate endDate = LocalDate.now().plusDays(1);
517 
			float previousDayClosing = 0;
518 
			LocalDate date = LocalDate.of(2018, 4, 6);
519 
			while (date.isBefore(endDate)) {
520 
				List<RechargeTransaction> dateWiseRechargeTransactions = rechargeTransactionRepository
521 
						.selectAllBetweenTimestamp(Arrays.asList(RechargeStatus.values()), date.atStartOfDay(),
522 
								date.plusDays(1).atStartOfDay());
523 
 
524 
				List<RechargeTransaction> successfulTransactions = dateWiseRechargeTransactions.stream()
525 
						.filter(y -> y.getStatus().equals(RechargeStatus.SUCCESS)).collect(Collectors.toList());
526 
 
527 
				float dailyAmount = 0;
528 
				float totalCommission = 0;
529 
				for (RechargeTransaction rechargeTransaction : successfulTransactions) {
530 
					if (rechargeTransaction.getProviderId() == x.getId()) {
531 
						dailyAmount += rechargeTransaction.getAmount();
532 
						totalCommission += rechargeTransaction.getCommission();
533 
					}
534 
				}
535 
 
536 
				List<RechargeProviderCreditWalletHistory> rechargeHistoryList = dateWiseProviderCreditsMap.get(date);
537 
				float dailyWalletRecharge = 0;
538 
				if (rechargeHistoryList != null) {
539 
					for (RechargeProviderCreditWalletHistory rechargeProviderCreditWalletHistory : rechargeHistoryList) {
540 
						if (rechargeProviderCreditWalletHistory.getProviderId() == x.getId()) {
541 
							dailyWalletRecharge += rechargeProviderCreditWalletHistory.getAmount();
542 
						}
543 
					}
544 
				}
545 
				if (dailyAmount > 0 || dailyWalletRecharge > 0) {
546 
					DailyRecharge dailyRecharge = null;
547 
					try {
548 
						dailyRecharge = dailyRechargeRepository.selectByProviderIdAndCreateDate(x.getId(), date);
549 
					} catch (Exception e) {
550 
						LOGGER.info("Could not find Recharge entry");
551 
					}
552 
					if (dailyRecharge == null) {
553 
						dailyRecharge = new DailyRecharge();
554 
						dailyRecharge.setCreateDate(date);
555 
					}
556 
					dailyRecharge.setOpeningBalance(previousDayClosing);
557 
					dailyRecharge.setProviderId(x.getId());
558 
					dailyRecharge.setWalletRechargeAmount(dailyWalletRecharge);
559 
					dailyRecharge.setTotalAmount(dailyAmount);
560 
					dailyRecharge.setTotalCommission(totalCommission);
561 
					float closingBalance = dailyRecharge.getOpeningBalance() + dailyWalletRecharge - dailyAmount;
562 
					dailyRecharge.setClosingBalance(closingBalance);
563 
					dailyRechargeRepository.persist(dailyRecharge);
564 
					x.setAmount(x.getAmount() + dailyRecharge.getClosingBalance() - dailyRecharge.getOpeningBalance());
565 
					previousDayClosing = dailyRecharge.getClosingBalance();
566 
				}
567 
				date = date.plusDays(1);
568 
			}
569 
			rechargeProviderRepository.persist(x);
570 
		});
23761 amit.gupta 571 
		LOGGER.info("finished generating daily recharge");
23724 amit.gupta 572 
	}
573 
 
23738 amit.gupta 574 
	public void reconcileRecharge() throws Exception {
23724 amit.gupta 575 
		LocalDateTime fromDate = LocalDateTime.now().truncatedTo(ChronoUnit.DAYS).minusDays(30);
576 
		LocalDateTime toDate = LocalDateTime.now().truncatedTo(ChronoUnit.DAYS);
577 
		List<RechargeStatus> nonSuccessRechargeStatuses = new ArrayList<>(Arrays.asList(RechargeStatus.values()));
578 
		LOGGER.info("nonSuccessRechargeStatuses {} ", nonSuccessRechargeStatuses);
579 
		nonSuccessRechargeStatuses.remove(RechargeStatus.SUCCESS);
580 
		nonSuccessRechargeStatuses.remove(RechargeStatus.FAILED);
581 
		RechargeCredential thinkWalnutDigitalRechargeEnquiryCredential = new RechargeCredential();
582 
		thinkWalnutDigitalRechargeEnquiryCredential.setRechargeUrl(thinkWalnutDigitalRechargeEnquiryUrl);
583 
		thinkWalnutDigitalRechargeEnquiryCredential.setRechargeUserName(thinkWalnutDigitalRechargeUserName);
584 
		thinkWalnutDigitalRechargeEnquiryCredential.setRechargePassword(thinkWalnutDigitalRechargePassword);
585 
		thinkWalnutDigitalRechargeEnquiryCredential.setRechargeAuthKey(thinkWalnutDigitalRechargeAuthKey);
586 
		Map<String, RechargeStatus> requestRechargeStatusChanged = new HashMap<>();
587 
		List<RechargeTransaction> rechargeTransactions = rechargeTransactionRepository
588 
				.selectAllBetweenTimestamp(nonSuccessRechargeStatuses, fromDate, toDate);
589 
		for (RechargeTransaction rechargeTransaction : rechargeTransactions) {
590 
			try {
591 
				int providerId = rechargeTransaction.getProviderId();
592 
				if (providerId == 1) {
593 
					oxigenRechargeProviderService.doCheckStatusRequest(oxigenRechargeEnquiryUrl, oxigenRechargeAuthKey,
594 
							rechargeTransaction);
595 
				} else if (providerId == 2) {
596 
					thinkWalnutDigitalRechargeProviderService
597 
							.doCheckStatusRequest(thinkWalnutDigitalRechargeEnquiryCredential, rechargeTransaction);
598 
				}
599 
				if (rechargeTransaction.getStatus().equals(RechargeStatus.SUCCESS)
600 
						|| rechargeTransaction.getStatus().equals(RechargeStatus.FAILED)) {
601 
					requestRechargeStatusChanged.put(rechargeTransaction.getRequestId(),
602 
							rechargeTransaction.getStatus());
603 
				}
604 
			} catch (Exception e) {
605 
				LOGGER.info("Could not check status for Request {}", rechargeTransaction.getRequestId());
606 
			}
607 
		}
23738 amit.gupta 608 
		LOGGER.info("Reconcile recharge ran successfully");
23724 amit.gupta 609 
	}
28205 tejbeer 610 
 
27438 amit.gupta 611 
	public void processActivation() throws Exception {
612 
		schemeService.processActivation();
613 
	}
24240 amit.gupta 614 
 
615 
	// TemporaryMethod
24237 amit.gupta 616 
	public void migrateInvoice() {
617 
		List<FofoOrder> fofoOrders = fofoOrderRepository.selectFromSaleDate(LocalDateTime.now().minusDays(3));
618 
		Map<Integer, List<FofoOrder>> partnerOrdersMap = new HashMap<>();
24241 amit.gupta 619 
		partnerOrdersMap = fofoOrders.stream()
620 
				.collect(Collectors.groupingBy(FofoOrder::getFofoId, Collectors.toList()));
24237 amit.gupta 621 
		for (List<FofoOrder> orderList : partnerOrdersMap.values()) {
24240 amit.gupta 622 
			int sequence = 0;
623 
			String prefix = "";
24241 amit.gupta 624 
			List<FofoOrder> sortedList = orderList.stream().sorted((x1, x2) -> x1.getId() - x2.getId())
625 
					.collect(Collectors.toList());
626 
			for (FofoOrder order : sortedList) {
627 
 
24240 amit.gupta 628 
				LOGGER.info("Order Id is {}, partner Id is {}", order.getId(), order.getFofoId());
24241 amit.gupta 629 
				if (!order.getInvoiceNumber().contains("SEC")) {
24240 amit.gupta 630 
					sequence = Integer.parseInt(order.getInvoiceNumber().split("/")[1]);
631 
					prefix = order.getInvoiceNumber().split("/")[0];
632 
				} else {
633 
					sequence += 1;
24241 amit.gupta 634 
					String invoiceNumber = prefix + "/" + sequence;
24240 amit.gupta 635 
					order.setInvoiceNumber(invoiceNumber);
636 
					fofoOrderRepository.persist(order);
637 
				}
638 
			}
24241 amit.gupta 639 
 
24237 amit.gupta 640 
		}
641 
	}
23724 amit.gupta 642 
 
30393 amit.gupta 643 
	@Autowired
644 
	private ReporticoCacheTableRepository reporticoCacheTableRepository;
24252 amit.gupta 645 
 
25584 amit.gupta 646 
	public void processScheme(int offset, boolean dryRun) throws Exception {
24462 amit.gupta 647 
		LocalDateTime startDate = LocalDateTime.of(LocalDate.now(), LocalTime.MIDNIGHT).minusDays(offset);
24259 amit.gupta 648 
		LocalDateTime endDate = startDate.plusDays(30);
25584 amit.gupta 649 
		processScheme(startDate, endDate, dryRun);
24256 amit.gupta 650 
	}
28205 tejbeer 651 
 
27892 amit.gupta 652 
	public void processSchemeOut(List<String> invoiceNumbers) throws Exception {
28205 tejbeer 653 
		for (String invoiceNumber : invoiceNumbers) {
654 
			System.out.println("Invoice Number - " + invoiceNumber);
27892 amit.gupta 655 
			FofoOrder fofoOrder = fofoOrderRepository.selectByInvoiceNumber(invoiceNumber);
30972 amit.gupta 656 
			orderService.reverseScheme(fofoOrder);
27892 amit.gupta 657 
			schemeService.processSchemeOut(fofoOrder.getId(), fofoOrder.getFofoId());
658 
		}
659 
	}
28205 tejbeer 660 
 
27987 amit.gupta 661 
	public void processSchemeIn(List<String> invoiceNumbers) throws Exception {
28205 tejbeer 662 
		for (String invoiceNumber : invoiceNumbers) {
663 
			System.out.println("Invoice Number - " + invoiceNumber);
27987 amit.gupta 664 
			Purchase purchase = purchaseRepository.selectByPurchaseReference(invoiceNumber);
665 
			schemeService.processSchemeIn(purchase.getId(), purchase.getFofoId());
666 
		}
667 
	}
24533 govind 668 
 
25584 amit.gupta 669 
	public void processScheme(int offset, int durationDays, boolean dryRun) throws Exception {
24462 amit.gupta 670 
		LocalDateTime startDate = LocalDateTime.of(LocalDate.now(), LocalTime.MIDNIGHT).minusDays(offset);
24461 amit.gupta 671 
		LocalDateTime endDate = startDate.plusDays(durationDays);
25584 amit.gupta 672 
		processScheme(startDate, endDate, dryRun);
24461 amit.gupta 673 
	}
24271 amit.gupta 674 
 
25584 amit.gupta 675 
	public void processScheme(boolean dryRun) throws Exception {
24256 amit.gupta 676 
		LocalDateTime fromDate = LocalDateTime.now().minusDays(30);
25584 amit.gupta 677 
		processScheme(fromDate, LocalDateTime.now(), dryRun);
24256 amit.gupta 678 
	}
24271 amit.gupta 679 
 
25584 amit.gupta 680 
	public void processScheme(LocalDateTime startDate, LocalDateTime endDate, boolean dryRun) throws Exception {
23724 amit.gupta 681 
		LOGGER.info("Started execution at {}", LocalDateTime.now());
25312 amit.gupta 682 
		System.out.println(
683 
				"InventoryId\tSerialNumber\tItem Id\tScheme Id\tScheme Name\tScheme Type\tAmount Type\tDP\tTaxable\tScheme Amount\tAmount Paid");
24561 amit.gupta 684 
		try {
24587 amit.gupta 685 
			List<Purchase> purchases = purchaseRepository.selectAllBetweenPurchaseDate(startDate, endDate);
686 
			for (Purchase purchase : purchases) {
687 
				schemeService.processSchemeIn(purchase.getId(), purchase.getFofoId());
688 
			}
24271 amit.gupta 689 
 
24587 amit.gupta 690 
			List<FofoOrder> fofoOrders = fofoOrderRepository.selectBetweenSaleDate(startDate, endDate);
691 
			for (FofoOrder fofoOrder : fofoOrders) {
692 
				schemeService.processSchemeOut(fofoOrder.getId(), fofoOrder.getFofoId());
693 
			}
694 
		} catch (Exception e) {
24561 amit.gupta 695 
			e.printStackTrace();
24565 amit.gupta 696 
			throw e;
24561 amit.gupta 697 
		}
28205 tejbeer 698 
		List<UserWalletHistory> uwhs = userWalletHistoryRepository.selectAllByDateType(LocalDate.now().atStartOfDay(),
699 
				endDate, Arrays.asList(WalletReferenceType.SCHEME_IN, WalletReferenceType.SCHEME_OUT));
25043 amit.gupta 700 
		System.out.println("Amount\tReference\tReferenceType\tTimestamp\tDescription");
25312 amit.gupta 701 
		for (UserWalletHistory uwh : uwhs) {
702 
			System.out.println(String.format("%d\t%d\t%s\t%s\t%s", uwh.getAmount(), uwh.getReference(),
703 
					uwh.getReferenceType(), uwh.getTimestamp().toString(), uwh.getDescription()));
25043 amit.gupta 704 
		}
30644 amit.gupta 705 
		LOGGER.info("Schemes processed successfully.");
25598 amit.gupta 706 
		if (dryRun) {
25584 amit.gupta 707 
			throw new Exception();
708 
		}
23724 amit.gupta 709 
	}
23929 amit.gupta 710 
 
23739 amit.gupta 711 
	public void processRechargeCashback() throws Throwable {
23761 amit.gupta 712 
		LocalDateTime cashbackTime = LocalDateTime.now();
23929 amit.gupta 713 
		int referenceId = (int) Timestamp.valueOf(cashbackTime).getTime() / 1000;
714 
		List<RechargeTransaction> pendingTransactions = rechargeTransactionRepository
715 
				.getPendingCashBackRehargeTransactions();
716 
		Map<Object, Double> totalRetailerCashbacks = pendingTransactions.stream().collect(
717 
				Collectors.groupingBy(x -> x.getRetailerId(), Collectors.summingDouble(x -> x.getCommission())));
718 
		for (Map.Entry<Object, Double> totalRetailerCashback : totalRetailerCashbacks.entrySet()) {
719 
			int retailerId = (Integer) totalRetailerCashback.getKey();
23739 amit.gupta 720 
			float amount = totalRetailerCashback.getValue().floatValue();
23929 amit.gupta 721 
			if (Math.round(amount) > 0) {
722 
				walletService.addAmountToWallet(retailerId, referenceId, WalletReferenceType.CASHBACK,
26565 amit.gupta 723 
						"Recharge Cashback", Math.round(amount), LocalDateTime.now());
23762 amit.gupta 724 
			}
23739 amit.gupta 725 
		}
23929 amit.gupta 726 
		for (RechargeTransaction rt : pendingTransactions) {
23761 amit.gupta 727 
			rt.setCashbackTimestamp(cashbackTime);
728 
			rt.setCashbackReference(referenceId);
729 
			rechargeTransactionRepository.persist(rt);
730 
		}
23739 amit.gupta 731 
		LOGGER.info("Cashbacks for Recharge processed Successfully");
732 
	}
29160 amit.gupta 733 
 
734 
	public void rollOutUpgardedMarginsNextMonth() throws Exception {
29107 amit.gupta 735 
		LocalDate startOfPreviousMonth = LocalDate.now().with(ChronoField.DAY_OF_MONTH, 1).minusMonths(1);
29160 amit.gupta 736 
 
28971 amit.gupta 737 
		List<FofoStore> stores = fofoStoreRepository.selectActiveStores();
29160 amit.gupta 738 
		for (FofoStore store : stores) {
739 
			int fofoId = store.getId();
740 
 
30752 tejbeer 741 
			PartnerType startOfPreviousMonthPartnerType = partnerTypeChangeService.getTypeOnDate(fofoId,
742 
					startOfPreviousMonth);
29160 amit.gupta 743 
			PartnerType todayPartnerType = partnerTypeChangeService.getTypeOnMonth(fofoId,
744 
					YearMonth.from(startOfPreviousMonth.atStartOfDay()));
30119 amit.gupta 745 
			if (!startOfPreviousMonthPartnerType.nextPartnerTypes().contains(todayPartnerType)) {
29160 amit.gupta 746 
				continue;
747 
			}
30119 amit.gupta 748 
			if (!startOfPreviousMonthPartnerType.equals(todayPartnerType)) {
29160 amit.gupta 749 
				LOGGER.info("Partner Type has been changed for code {} from {} to {}", store.getCode(),
30119 amit.gupta 750 
						startOfPreviousMonthPartnerType, todayPartnerType);
29160 amit.gupta 751 
				List<FofoOrder> fofoOrders = fofoOrderRepository.selectByFofoId(fofoId,
752 
						startOfPreviousMonth.atStartOfDay(), startOfPreviousMonth.plusMonths(1).atStartOfDay(), 0, 0);
753 
				for (FofoOrder fofoOrder : fofoOrders) {
754 
					schemeService.processSchemeOut(fofoOrder.getId(), fofoId);
28974 amit.gupta 755 
				}
29160 amit.gupta 756 
 
757 
			}
28971 amit.gupta 758 
		}
759 
	}
29252 amit.gupta 760 
 
29160 amit.gupta 761 
	public void rollOutUpgardedMargins() throws Exception {
762 
		LocalDate today = LocalDate.now();
763 
		LocalDate yesterday = today.minusDays(1);
764 
		int upgradedCount = 0;
765 
		List<FofoStore> stores = fofoStoreRepository.selectActiveStores();
766 
		StringBuilder sb = new StringBuilder();
767 
		for (FofoStore store : stores) {
768 
			int fofoId = store.getId();
29252 amit.gupta 769 
 
30215 amit.gupta 770 
			PartnerType yesterdayPartnerType = partnerTypeChangeService.getTypeOnDate(fofoId, yesterday);
771 
			PartnerType todayPartnerType = partnerTypeChangeService.getTypeOnDate(fofoId, today);
29160 amit.gupta 772 
			if (!yesterdayPartnerType.nextPartnerTypes().contains(todayPartnerType)) {
773 
				continue;
774 
			}
775 
			if (!yesterdayPartnerType.equals(todayPartnerType)) {
776 
				upgradedCount++;
29252 amit.gupta 777 
				sb.append(String.format("Partner Type has been changed for code %s from %s to %s", store.getCode(),
778 
						yesterdayPartnerType.toString(), todayPartnerType.toString()));
29160 amit.gupta 779 
				sb.append("<br>");
780 
				LOGGER.info("Partner Type has been changed for code {} from {} to {}", store.getCode(),
781 
						yesterdayPartnerType, todayPartnerType);
782 
				List<FofoOrder> fofoOrders = fofoOrderRepository.selectByFofoId(fofoId,
783 
						yesterday.withDayOfMonth(1).atStartOfDay(), yesterday.atStartOfDay(), 0, 0);
784 
				for (FofoOrder fofoOrder : fofoOrders) {
785 
					schemeService.processSchemeOut(fofoOrder.getId(), fofoId);
786 
				}
29252 amit.gupta 787 
 
29160 amit.gupta 788 
			}
789 
		}
29252 amit.gupta 790 
		if (upgradedCount > 0) {
791 
			sendMailHtmlFormat(
30752 tejbeer 792 
					new String[] { "amit.gupta@smartdukaan.com", "tarun.verma@smartdukaan.com",
793 
							"neeraj.gupta@smartdukaan.com" },
29252 amit.gupta 794 
					sb.toString(), null, "Few Partners Category have been Upgraded");
29160 amit.gupta 795 
		} else {
29252 amit.gupta 796 
			sendMailHtmlFormat(
30752 tejbeer 797 
					new String[] { "amit.gupta@smartdukaan.com", "tarun.verma@smartdukaan.com",
798 
							"neeraj.gupta@smartdukaan.com" },
29252 amit.gupta 799 
					sb.toString(), null, "No partners Category have been upgraded today");
29160 amit.gupta 800 
		}
801 
	}
23724 amit.gupta 802 
 
30390 amit.gupta 803 
	@Autowired
804 
	private PartnerStatsService partnerStatsService;
805 
 
30393 amit.gupta 806 
	// Temporary Method
807 
	public void evaluateExcessSchemeOut() throws Exception {
808 
		Map<Integer, String> userNameMap = retailerService.getAllFofoRetailerIdNameMap();
809 
		Map<Integer, Float> userAmountMap = new HashMap<>();
810 
 
811 
		List<List<?>> rows = new ArrayList<>();
812 
		List<String> headers = Arrays.asList("Scheme", "Item", "Partner", "Amount", "Credited On", "Invoice Number",
813 
				"Sale On", "Scheme Start", "Scheme End", "Active On", "Expired On");
814 
		schemeRepository.selectAll().stream().forEach(x -> {
815 
			if (x.getType().equals(SchemeType.OUT)) {
816 
				List<SchemeInOut> sioList = schemeInOutRepository
817 
						.selectBySchemeIds(new HashSet<>(Arrays.asList(x.getId())));
818 
				if (x.getActiveTimestamp() != null) {
819 
					LocalDateTime endDateTime = x.getEndDateTime();
820 
					if (x.getExpireTimestamp() != null && x.getExpireTimestamp().isBefore(x.getEndDateTime())) {
821 
						endDateTime = x.getExpireTimestamp();
822 
					}
823 
					for (SchemeInOut sio : sioList) {
824 
						InventoryItem inventoryItem = null;
825 
						inventoryItem = inventoryItemRepository.selectById(sio.getInventoryItemId());
826 
						FofoOrder fofoOrder = fofoOrderRepository.selectByFofoIdAndSerialNumber(
827 
								inventoryItem.getFofoId(), inventoryItem.getSerialNumber(), null, null, 0, 1).get(0);
828 
						Optional<ScanRecord> record = scanRecordRepository
829 
								.selectByInventoryItemId(sio.getInventoryItemId()).stream()
830 
								.filter(y -> y.getType().equals(ScanType.SALE)).findFirst();
831 
						if (record.isPresent()) {
832 
							int fofoId = record.get().getFofoId();
833 
							if (record.get().getCreateTimestamp().isAfter(endDateTime)
834 
									|| record.get().getCreateTimestamp().isBefore(x.getStartDateTime())) {
835 
								if (!userAmountMap.containsKey(fofoId)) {
836 
									userAmountMap.put(fofoId, 0f);
837 
								}
838 
								userAmountMap.put(fofoId, sio.getAmount() + userAmountMap.get(fofoId));
839 
								try {
840 
									rows.add(Arrays.asList(x.getDescription(),
841 
											itemRepository.selectById(inventoryItem.getItemId()).getItemDescription(),
842 
											userNameMap.get(fofoId), sio.getAmount(),
843 
											FormattingUtils.formatDate(sio.getCreateTimestamp()),
844 
											fofoOrder.getInvoiceNumber(),
845 
											FormattingUtils.formatDate(record.get().getCreateTimestamp()),
846 
											FormattingUtils.formatDate(x.getStartDateTime()),
847 
											FormattingUtils.formatDate(x.getEndDateTime()),
848 
											FormattingUtils.formatDate(x.getActiveTimestamp()),
849 
											FormattingUtils.formatDate(x.getExpireTimestamp())));
850 
								} catch (Exception e) {
851 
									e.printStackTrace();
852 
								}
853 
							}
854 
						}
855 
					}
856 
				}
857 
			}
858 
		});
859 
		userAmountMap.entrySet().stream()
860 
				.forEach(x -> LOGGER.info("{} to be deducted from {}({}) for wrongly disbursed due to technical error.",
861 
						x.getValue(), userNameMap.get(x.getKey())));
862 
 
863 
		ByteArrayOutputStream baos = FileUtil.getCSVByteStream(headers, rows);
864 
		Utils.sendMailWithAttachment(googleMailSender,
30752 tejbeer 865 
				new String[] { "amit.gupta@shop2020.in", "adeel.yazdani@smartdukaan.com" }, null,
30393 amit.gupta 866 
				"Partner Excess Amount", "PFA", "ListofSchemes.csv", new ByteArrayResource(baos.toByteArray()));
867 
 
868 
	}
869 
 
30390 amit.gupta 870 
	public void fetchParnterStats() throws Exception {
871 
		Map<Integer, PartnerDetailModel> partnerStats = partnerStatsService.getAllPartnerStats();
872 
		ObjectOutputStream oos = null;
873 
		FileOutputStream fout = null;
874 
		try {
875 
			fout = new FileOutputStream("/tmp/partnerStat.tmp", false);
876 
			oos = new ObjectOutputStream(fout);
877 
			oos.writeObject(partnerStats);
878 
 
879 
		} catch (Exception ex) {
880 
			ex.printStackTrace();
881 
		} finally {
882 
			if (oos != null) {
883 
				oos.close();
884 
			}
885 
		}
886 
		ReporticoCacheTable rct = reporticoCacheTableRepository.selectByTableName("partnerStat");
887 
		if (rct == null) {
888 
			rct = new ReporticoCacheTable();
889 
			rct.setTableName("partnerStat");
30393 amit.gupta 890 
			rct.setLastCreatedTimestamp(LocalDateTime.now());
891 
			reporticoCacheTableRepository.persist(rct);
892 
		} else {
893 
			rct.setLastCreatedTimestamp(LocalDateTime.now());
30390 amit.gupta 894 
		}
895 
	}
896 
 
30637 amit.gupta 897 
	public void processPriceDrop() throws Exception {
30752 tejbeer 898 
		List<PriceDrop> priceDrops = priceDropRepository.selectAllByDatesBetween(LocalDateTime.now(),
899 
				LocalDateTime.now().minusYears(1));
30637 amit.gupta 900 
		for (PriceDrop priceDrop : priceDrops) {
901 
			if (priceDrop.getDropAmount() > 0) {
902 
				priceDropService.processPriceDrop(priceDrop.getId(), true);
903 
			}
904 
		}
905 
	}
906 
 
31008 amit.gupta 907 
	@Autowired
908 
	CreditNoteService creditNoteService;
909 
 
910 
	public void sendCreditNote(YearMonth yearMonth) throws Exception {
911 
		creditNoteService.issueMonthlyMarginsCN(yearMonth);
912 
	}
913 
 
25598 amit.gupta 914 
	private class SaleRoles {
915 
 
916 
		private List<String> l1;
917 
		private List<String> l2;
918 
 
919 
		public SaleRoles() {
920 
			l1 = new ArrayList<>();
921 
			l2 = new ArrayList<>();
922 
		}
923 
 
924 
		public List<String> getL1() {
925 
			return l1;
926 
		}
927 
 
928 
		public List<String> getL2() {
929 
			return l2;
930 
		}
931 
 
932 
	}
933 
 
26945 amit.gupta 934 
	private class FofoReportingModel {
935 
		private String code;
936 
		private int fofoId;
937 
		private String businessName;
938 
		private String territoryManager;
939 
		private String regionalManager;
940 
 
941 
		@Override
942 
		public String toString() {
943 
			return "FofoReportingModel [code=" + code + ", fofoId=" + fofoId + ", businessName=" + businessName
944 
					+ ", territoryManager=" + territoryManager + ", regionalManager=" + regionalManager + "]";
945 
		}
946 
 
947 
		public String getCode() {
948 
			return code;
949 
		}
950 
 
951 
		public void setCode(String code) {
952 
			this.code = code;
953 
		}
954 
 
955 
		public String getBusinessName() {
956 
			return businessName;
957 
		}
958 
 
959 
		public void setBusinessName(String businessName) {
960 
			this.businessName = businessName;
961 
		}
962 
 
963 
		public String getTerritoryManager() {
964 
			return territoryManager;
965 
		}
966 
 
967 
		public void setTerritoryManager(String territoryManager) {
968 
			this.territoryManager = territoryManager;
969 
		}
970 
 
971 
		public String getRegionalManager() {
972 
			return regionalManager;
973 
		}
974 
 
975 
		public void setRegionalManager(String regionalManager) {
976 
			this.regionalManager = regionalManager;
977 
		}
978 
 
979 
		private ScheduledTasks getOuterType() {
980 
			return ScheduledTasks.this;
981 
		}
982 
 
983 
		@Override
984 
		public int hashCode() {
985 
			final int prime = 31;
986 
			int result = 1;
987 
			result = prime * result + getOuterType().hashCode();
988 
			result = prime * result + ((businessName == null) ? 0 : businessName.hashCode());
989 
			result = prime * result + ((code == null) ? 0 : code.hashCode());
990 
			result = prime * result + fofoId;
991 
			result = prime * result + ((regionalManager == null) ? 0 : regionalManager.hashCode());
992 
			result = prime * result + ((territoryManager == null) ? 0 : territoryManager.hashCode());
993 
			return result;
994 
		}
995 
 
996 
		@Override
997 
		public boolean equals(Object obj) {
998 
			if (this == obj)
999 
				return true;
1000 
			if (obj == null)
1001 
				return false;
1002 
			if (getClass() != obj.getClass())
1003 
				return false;
1004 
			FofoReportingModel other = (FofoReportingModel) obj;
1005 
			if (!getOuterType().equals(other.getOuterType()))
1006 
				return false;
1007 
			if (businessName == null) {
1008 
				if (other.businessName != null)
1009 
					return false;
1010 
			} else if (!businessName.equals(other.businessName))
1011 
				return false;
1012 
			if (code == null) {
1013 
				if (other.code != null)
1014 
					return false;
1015 
			} else if (!code.equals(other.code))
1016 
				return false;
1017 
			if (fofoId != other.fofoId)
1018 
				return false;
1019 
			if (regionalManager == null) {
1020 
				if (other.regionalManager != null)
1021 
					return false;
1022 
			} else if (!regionalManager.equals(other.regionalManager))
1023 
				return false;
1024 
			if (territoryManager == null) {
1025 
				if (other.territoryManager != null)
1026 
					return false;
1027 
			} else if (!territoryManager.equals(other.territoryManager))
1028 
				return false;
1029 
			return true;
1030 
		}
1031 
 
1032 
		public int getFofoId() {
1033 
			return fofoId;
1034 
		}
1035 
 
1036 
		public void setFofoId(int fofoId) {
1037 
			this.fofoId = fofoId;
1038 
		}
1039 
 
1040 
	}
1041 
 
31618 amit.gupta 1042 
	@Autowired
1043 
	WarehouseInventoryItemRepository warehouseInventoryItemRepository;
1044 
	public void test() throws Exception {
31619 amit.gupta 1045 
		this.sendMailForSamsungRebilling();
31618 amit.gupta 1046 
	}
1047 
 
1048 
	public void sendMailForSamsungRebilling() throws Exception {
1049 
		List<BilledImeiModel> samsungModels = warehouseInventoryItemRepository.findByBillingDateBrand(LocalDate.now(), "Samsung");
1050 
		LOGGER.info("SamsungModels {}", samsungModels);
1051 
		samsungModels = samsungModels.stream().sorted(Comparator.comparing(x-> x.getPcmDate()==null ? -1:1)).collect(Collectors.toList());
1052 
		if(samsungModels.size() > 0) {
1053 
			List<String> headers = Arrays.asList("Partner Id", "Code", "Name", "City", "Brand", "Model Name", "Model Number", "Color", "Serial Number", "Remarks");
1054 
			List<List<?>> rows = new ArrayList<>();
1055 
			for(BilledImeiModel billedImeiModel : samsungModels) {
1056 
				List<Serializable> row = Arrays.asList(billedImeiModel.getFofoId(), billedImeiModel.getStoreCode(), billedImeiModel.getStoreName(),
1057 
						billedImeiModel.getStoreCity(), billedImeiModel.getBrand(), billedImeiModel.getModelName(), billedImeiModel.getModelNumber(),
1058 
						billedImeiModel.getColor(), billedImeiModel.getSerialNumber(), billedImeiModel.getPcmDate()==null ? "PCM date Missing" : "Rebill Imeis");
1059 
				rows.add(row);
1060 
			}
1061 
			ByteArrayOutputStream baos = FileUtil.getCSVByteStream(headers, rows);
1062 
			String[] sendToArray = new String[]{"kamini.sharma@smartdukaan.com", "praveen.sharma@smartdukaan.com"};
1063 
			String fileName = "Imeis need Rebilling -" + FormattingUtils.formatDate(LocalDateTime.now()) + ".csv";
1064 
			Utils.sendMailWithAttachment(googleMailSender, sendToArray, new String[]{"tarun.verma@smartdukaan.com"}, "Samsung Rebilling IMEI Summary", "PFA",
1065 
					fileName, new ByteArrayResource(baos.toByteArray()));
1066 
		}
1067 
	}
1068 
 
24271 amit.gupta 1069 
	public void sendPartnerInvestmentDetails(List<String> sendTo) throws Exception {
24277 amit.gupta 1070 
		LocalDate yesterDay = LocalDate.now().minusDays(1);
25267 amit.gupta 1071 
		List<FofoStore> fofoStores = fofoStoreRepository.selectActiveStores();
23929 amit.gupta 1072 
		Map<Integer, CustomRetailer> customRetailerMap = retailerService
1073 
				.getFofoRetailers(fofoStores.stream().map(x -> x.getId()).collect(Collectors.toList()));
25351 tejbeer 1074 
 
26957 amit.gupta 1075 
		List<String> headers = Arrays.asList("Code", "Outlet name", "State Manager", "Teritory/Team Lead",
26945 amit.gupta 1076 
				"Wallet Amount", "In Stock Amount", "Activated Stock", "Return In Transit Stock", "Unbilled Amount",
1077 
				"Grn Pending Amount", "Min Investment", "Investment Amount", "Investment Short", "Unbilled Qty",
1078 
				"Short Days");
25837 amit.gupta 1079 
		List<List<?>> rows = new ArrayList<>();
25895 amit.gupta 1080 
		Map<Integer, List<?>> partnerRowsMap = new HashMap<>();
25598 amit.gupta 1081 
 
26945 amit.gupta 1082 
		Map<Integer, FofoReportingModel> partnerIdSalesHeaderMap = this.getPartnerIdSalesHeaders();
25598 amit.gupta 1083 
 
26945 amit.gupta 1084 
		Map<Integer, Integer> shortDaysMap = partnerDailyInvestmentRepository
1085 
				.selectAll(LocalDate.now().withDayOfMonth(1), LocalDate.now()).stream().collect(Collectors.groupingBy(
1086 
						x -> x.getFofoId(), Collectors.summingInt(x -> x.getShortPercentage() > 10 ? 1 : 0)));
1087 
 
24002 amit.gupta 1088 
		for (FofoStore fofoStore : fofoStores) {
27750 amit.gupta 1089 
			LOGGER.info("Fofo Store {},  {}", fofoStore.getId(), fofoStore.getCode());
26376 amit.gupta 1090 
			int fofoId = fofoStore.getId();
26945 amit.gupta 1091 
			PartnerDailyInvestment partnerDailyInvestment = partnerInvestmentService.getInvestment(fofoId, 1);
25598 amit.gupta 1092 
			partnerDailyInvestment.setDate(yesterDay);
26945 amit.gupta 1093 
 
25598 amit.gupta 1094 
			try {
1095 
				partnerDailyInvestmentRepository.persist(partnerDailyInvestment);
26945 amit.gupta 1096 
				shortDaysMap.put(fofoId,
1097 
						shortDaysMap.get(fofoId) + (partnerDailyInvestment.getShortPercentage() > 10 ? 1 : 0));
25598 amit.gupta 1098 
			} catch (Exception e) {
1099 
				// ignore the exceptions during persist
1100 
			}
1101 
 
24002 amit.gupta 1102 
			CustomRetailer retailer = customRetailerMap.get(fofoStore.getId());
25837 amit.gupta 1103 
			if (retailer == null || partnerIdSalesHeaderMap.get(fofoStore.getId()) == null) {
24002 amit.gupta 1104 
				LOGGER.info("Could not find retailer with retailer Id {}", fofoStore.getId());
1105 
				continue;
1106 
			}
26945 amit.gupta 1107 
			FofoReportingModel reportingModel = partnerIdSalesHeaderMap.get(fofoStore.getId());
1108 
			List<Serializable> row = new ArrayList<>();
1109 
			row.addAll(Arrays.asList(reportingModel.getCode(), reportingModel.getBusinessName(),
1110 
					reportingModel.getRegionalManager(), reportingModel.getTerritoryManager()));
25927 amit.gupta 1111 
			row.addAll(
1112 
					Arrays.asList(partnerDailyInvestment.getWalletAmount(), partnerDailyInvestment.getInStockAmount(),
26945 amit.gupta 1113 
							partnerDailyInvestment.getActivatedStockAmount() == 0 ? "-"
1114 
									: "(" + partnerDailyInvestment.getActivatedStockAmount() + ")",
25927 amit.gupta 1115 
							0, partnerDailyInvestment.getUnbilledAmount(), partnerDailyInvestment.getGrnPendingAmount(),
1116 
							partnerDailyInvestment.getMinInvestment(), partnerDailyInvestment.getTotalInvestment(),
26945 amit.gupta 1117 
							partnerDailyInvestment.getShortInvestment(), partnerDailyInvestment.getUnbilledQty(),
1118 
							shortDaysMap.get(fofoId)));
25837 amit.gupta 1119 
			partnerRowsMap.put(fofoStore.getId(), row);
24002 amit.gupta 1120 
			rows.add(row);
1121 
 
23929 amit.gupta 1122 
		}
25312 amit.gupta 1123 
 
24271 amit.gupta 1124 
		String fileName = "InvestmentSummary-" + FormattingUtils.formatDate(LocalDateTime.now()) + ".csv";
25598 amit.gupta 1125 
 
25927 amit.gupta 1126 
		if (sendTo == null) {
30215 amit.gupta 1127 
			for (Map.Entry<String, Set<Integer>> storeGuyEntry : csService.getAuthUserPartnerIdMapping().entrySet()) {
25895 amit.gupta 1128 
				List<List<?>> filteredRows = storeGuyEntry.getValue().stream().map(x -> partnerRowsMap.get(x))
1129 
						.filter(x -> x != null).collect(Collectors.toList());
1130 
				ByteArrayOutputStream baos = FileUtil.getCSVByteStream(headers, filteredRows);
30752 tejbeer 1131 
				String[] sendToArray = new String[] { storeGuyEntry.getKey() };
25895 amit.gupta 1132 
				Utils.sendMailWithAttachment(googleMailSender, sendToArray, null, "Franchise Investment Summary", "PFA",
1133 
						fileName, new ByteArrayResource(baos.toByteArray()));
1134 
			}
27210 tejbeer 1135 
			sendTo = Arrays.asList("tarun.verma@smartdukaan.com", "kamini.sharma@smartdukaan.com",
28467 tejbeer 1136 
					"neeraj.gupta@smartdukaan.com", "amit.gupta@shop2020.in", "manish.gupta@smartdukaan.com",
1137 
					"niranjan.kala@smartdukaan.com");
25341 amit.gupta 1138 
		}
25312 amit.gupta 1139 
 
25604 amit.gupta 1140 
		ByteArrayOutputStream baos = FileUtil.getCSVByteStream(headers, rows);
1141 
		String[] sendToArray = sendTo.toArray(new String[sendTo.size()]);
25609 amit.gupta 1142 
		Utils.sendMailWithAttachment(googleMailSender, sendToArray, null, "Franchise Investment Summary", "PFA",
1143 
				fileName, new ByteArrayResource(baos.toByteArray()));
24271 amit.gupta 1144 
 
23929 amit.gupta 1145 
	}
24177 govind 1146 
 
26945 amit.gupta 1147 
	private Map<Integer, FofoReportingModel> getPartnerIdSalesHeaders() {
25598 amit.gupta 1148 
		Map<String, SaleRoles> partnerEmailSalesMap = new HashMap<>();
1149 
 
1150 
		List<Position> positions = positionRepository
1151 
				.selectPositionByCategoryId(ProfitMandiConstants.TICKET_CATEGORY_SALES);
1152 
		Map<Integer, AuthUser> authUsersMap = authRepository.selectAllActiveUser().stream()
1153 
				.collect(Collectors.toMap(x -> x.getId(), x -> x));
1154 
		Map<Integer, List<CustomRetailer>> positionIdRetailerMap = csService.getPositionCustomRetailerMap(positions);
1155 
		for (Position position : positions) {
1156 
			List<CustomRetailer> crList = positionIdRetailerMap.get(position.getId());
25609 amit.gupta 1157 
			if (crList == null)
1158 
				continue;
25598 amit.gupta 1159 
			for (CustomRetailer cr : crList) {
1160 
				if (!partnerEmailSalesMap.containsKey(cr.getEmail())) {
1161 
					partnerEmailSalesMap.put(cr.getEmail(), new SaleRoles());
1162 
				}
1163 
				SaleRoles saleRoles = partnerEmailSalesMap.get(cr.getEmail());
1164 
				AuthUser authUser = authUsersMap.get(position.getAuthUserId());
26945 amit.gupta 1165 
				if (authUser == null) {
26059 amit.gupta 1166 
					continue;
1167 
				}
25598 amit.gupta 1168 
				String name = authUser.getFirstName() + " " + authUser.getLastName();
1169 
				if (position.getEscalationType().equals(EscalationType.L1)) {
1170 
					saleRoles.getL1().add(name);
1171 
				} else if (position.getEscalationType().equals(EscalationType.L2)) {
1172 
					saleRoles.getL2().add(name);
1173 
				}
1174 
			}
1175 
		}
25837 amit.gupta 1176 
 
1177 
		Set<CustomRetailer> allCrList = new HashSet<>();
1178 
		for (List<CustomRetailer> cr : positionIdRetailerMap.values()) {
1179 
			allCrList.addAll(cr);
1180 
		}
1181 
 
1182 
		Map<Integer, FofoStore> fofoStoresMap = fofoStoreRepository.selectActiveStores().stream()
1183 
				.collect(Collectors.toMap(x -> x.getId(), x -> x));
1184 
 
26945 amit.gupta 1185 
		Map<Integer, FofoReportingModel> partnerIdSalesHeadersMap = new HashMap<>();
25837 amit.gupta 1186 
 
1187 
		for (CustomRetailer cr : allCrList) {
1188 
			FofoStore fofoStore = fofoStoresMap.get(cr.getPartnerId());
25927 amit.gupta 1189 
			if (fofoStore == null) {
25870 amit.gupta 1190 
				LOGGER.info("Could not find Store {} in active Store", cr.getBusinessName());
1191 
				continue;
1192 
			}
26945 amit.gupta 1193 
			String code = fofoStore.getCode();
1194 
			// String storeName = "SmartDukaan-" +
1195 
			// fofoStore.getCode().replaceAll("[a-zA-Z]", "");
25837 amit.gupta 1196 
			String businessName = cr.getBusinessName();
1197 
			try {
1198 
				String stateManager = StringUtils.join(partnerEmailSalesMap.get(cr.getEmail()).getL2(), ", ");
1199 
				String territoryManager = StringUtils.join(partnerEmailSalesMap.get(cr.getEmail()).getL1(), ", ");
26945 amit.gupta 1200 
				FofoReportingModel reportingModel = new FofoReportingModel();
1201 
				reportingModel.setBusinessName(businessName);
1202 
				reportingModel.setCode(code);
1203 
				reportingModel.setFofoId(fofoStore.getId());
1204 
				reportingModel.setRegionalManager(stateManager);
1205 
				reportingModel.setTerritoryManager(territoryManager);
1206 
				partnerIdSalesHeadersMap.put(fofoStore.getId(), reportingModel);
25837 amit.gupta 1207 
			} catch (Exception e) {
1208 
				LOGGER.warn("Could not find partner with email - {}", cr.getEmail());
1209 
			}
1210 
		}
1211 
		return partnerIdSalesHeadersMap;
1212 
 
25598 amit.gupta 1213 
	}
1214 
 
24271 amit.gupta 1215 
	public void sendPartnerInvestmentDetails() throws Exception {
25565 amit.gupta 1216 
		this.sendPartnerInvestmentDetails(null);
24271 amit.gupta 1217 
	}
1218 
 
24697 amit.gupta 1219 
	public void sendAgeingReport(String... sendTo) throws Exception {
24692 amit.gupta 1220 
 
1221 
		InputStreamSource isr = reporticoService.getReportInputStreamSource(ReporticoProject.WAREHOUSENEW,
1222 
				"itemstockageing.xml");
24708 amit.gupta 1223 
		InputStreamSource isr1 = reporticoService.getReportInputStreamSource(ReporticoProject.FOCO,
24754 amit.gupta 1224 
				"ItemwiseOverallPendingIndent.xml");
24683 amit.gupta 1225 
		Attachment attachment = new Attachment(
25445 amit.gupta 1226 
				"ageing-report-" + FormattingUtils.formatDate(LocalDateTime.now().minusDays(1)) + ".csv", isr);
24707 amit.gupta 1227 
		Attachment attachment1 = new Attachment(
25445 amit.gupta 1228 
				"pending-indent-" + FormattingUtils.formatDate(LocalDateTime.now().minusDays(1)) + ".csv", isr1);
25418 amit.gupta 1229 
 
25609 amit.gupta 1230 
		Utils.sendMailWithAttachments(googleMailSender, STOCK_AGEING_MAIL_LIST, null, "Stock Ageing Report", "PFA",
1231 
				attachment);
1232 
		Utils.sendMailWithAttachments(googleMailSender, ITEMWISE_PENDING_INDENT_MAIL_LIST, null,
1233 
				"Itemwise Pending indent", "PFA", attachment1);
1234 
 
25598 amit.gupta 1235 
		// Reports to be sent to mapped partners
25597 amit.gupta 1236 
		Map<String, Set<String>> storeGuysMap = csService.getAuthUserPartnerEmailMapping();
25503 amit.gupta 1237 
 
1238 
		for (Map.Entry<String, Set<String>> storeGuyEntry : storeGuysMap.entrySet()) {
25418 amit.gupta 1239 
			Map<String, String> params = new HashMap<>();
25503 amit.gupta 1240 
			if (storeGuyEntry.getValue().size() == 0)
1241 
				continue;
25418 amit.gupta 1242 
			params.put("MANUAL_email", String.join(",", storeGuyEntry.getValue()));
1243 
			InputStreamSource isr3 = reporticoService.getReportInputStreamSource(ReporticoProject.FOCO,
1244 
					"focostockreport.xml", params);
1245 
			Attachment attache = new Attachment(
25609 amit.gupta 1246 
					"Franchise-stock-report" + FormattingUtils.formatDate(LocalDateTime.now()) + ".csv", isr3);
25584 amit.gupta 1247 
			System.out.println(storeGuyEntry.getValue());
30752 tejbeer 1248 
			Utils.sendMailWithAttachments(googleMailSender, new String[] { storeGuyEntry.getKey() }, null,
25609 amit.gupta 1249 
					"Franchise Stock Report", "PFA", attache);
25418 amit.gupta 1250 
		}
25503 amit.gupta 1251 
 
24681 amit.gupta 1252 
	}
24533 govind 1253 
 
28632 amit.gupta 1254 
	public void sendIndentTertiary() throws Exception {
28709 amit.gupta 1255 
 
28632 amit.gupta 1256 
		InputStreamSource isr = reporticoService.getReportInputStreamSource(ReporticoProject.FOCO,
1257 
				"indentandtertiary.xml");
1258 
		Attachment attachment = new Attachment(
28839 tejbeer 1259 
				"indentandtertiary-report-" + FormattingUtils.formatDate(LocalDateTime.now()) + ".csv", isr);
28709 amit.gupta 1260 
		Utils.sendMailWithAttachments(googleMailSender, INDENT_TERTIARY_MAIL_LIST, null, "Indent Tertiary Report",
1261 
				"PFA", attachment);
1262 
 
28632 amit.gupta 1263 
	}
28790 amit.gupta 1264 
 
28769 amit.gupta 1265 
	public void sendAttendanceMorningAlert() throws Exception {
28793 amit.gupta 1266 
		LocalDateTime moriningTime = LocalDate.now().atTime(10, 31);
28775 amit.gupta 1267 
		List<AuthUser> authUsers = authRepository.selectAllActiveUser();
28790 amit.gupta 1268 
		Map<String, AuthUser> authUserEmailMap = authUsers.stream().filter(x -> x.isActive())
1269 
				.collect(Collectors.toMap(x -> x.getEmailId(), x -> x));
1270 
 
28769 amit.gupta 1271 
		List<User> users = dtrUserRepository.selectAllByEmailIds(new ArrayList<>(authUserEmailMap.keySet()));
28790 amit.gupta 1272 
		Map<String, User> userMap = users.stream().collect(Collectors.toMap(x -> x.getEmailId(), x -> x));
1273 
 
1274 
		List<EmployeeAttendance> employeeAttendances = employeeAttendanceRepository
1275 
				.selectAllByDatesBetween(LocalDate.now().atStartOfDay(), LocalDateTime.now());
1276 
 
1277 
		Map<Integer, Optional<EmployeeAttendance>> employeeMorningAttendance = employeeAttendances.stream()
1278 
				.collect(Collectors.groupingBy(EmployeeAttendance::getUserId,
1279 
						Collectors.minBy(Comparator.comparing(EmployeeAttendance::getCreateTimestamp))));
1280 
		for (AuthUser authUser : authUsers) {
28769 amit.gupta 1281 
			User user = userMap.get(authUser.getEmailId());
1282 
			Optional<EmployeeAttendance> employeeAttendanceOptional = employeeMorningAttendance.get(user.getId());
28817 amit.gupta 1283 
			LOGGER.info("AuthUser - {}, employeeAttendanceOptional {}", authUser.getName(), employeeAttendanceOptional);
28839 tejbeer 1284 
			if (employeeAttendanceOptional != null) {
28818 amit.gupta 1285 
				LOGGER.info("employeeAttendanceOptional.orElse {}", employeeAttendanceOptional.orElse(null));
28839 tejbeer 1286 
				if (employeeAttendanceOptional.orElse(null) != null) {
1287 
					LOGGER.info("employeeAttendanceOptional.get().getCreateTimestamp() {}",
1288 
							employeeAttendanceOptional.get().getCreateTimestamp());
28818 amit.gupta 1289 
				}
1290 
			}
28790 amit.gupta 1291 
			if (employeeAttendanceOptional == null || employeeAttendanceOptional.orElse(null) == null
28769 amit.gupta 1292 
					|| employeeAttendanceOptional.get().getCreateTimestamp().isAfter(moriningTime)) {
28819 amit.gupta 1293 
				LOGGER.info("Will Send Email to {}", authUser.getFullName());
28790 amit.gupta 1294 
				String body = String.format(
28806 amit.gupta 1295 
						"Dear %s,\n Pls note that you haven't punched your attendance by 10:30am%s. You have been marked absent for half the day.\n\nRegards\nHR Team",
28839 tejbeer 1296 
						authUser.getFullName(),
1297 
						(employeeAttendanceOptional == null || employeeAttendanceOptional.orElse(null) == null) ? ""
1298 
								: "(Punched at "
30752 tejbeer 1299 
										+ FormattingUtils.format(employeeAttendanceOptional.get().getCreateTimestamp())
1300 
										+ ")");
28839 tejbeer 1301 
 
30752 tejbeer 1302 
				Utils.sendMailWithAttachments(googleMailSender, new String[] { authUser.getEmailId() },
31120 tejbeer 1303 
						new String[] { "kangan.monga@smartdukaan.com" }, "Attendance Alert", body);
28839 tejbeer 1304 
 
28769 amit.gupta 1305 
			}
1306 
		}
28790 amit.gupta 1307 
 
28769 amit.gupta 1308 
	}
28790 amit.gupta 1309 
 
28775 amit.gupta 1310 
	public void sendAttendanceEveningAlert() throws Exception {
1311 
		List<AuthUser> authUsers = authRepository.selectAllActiveUser();
28790 amit.gupta 1312 
		Map<String, AuthUser> authUserEmailMap = authUsers.stream().filter(x -> x.isActive())
1313 
				.collect(Collectors.toMap(x -> x.getEmailId(), x -> x));
1314 
 
28775 amit.gupta 1315 
		List<User> users = dtrUserRepository.selectAllByEmailIds(new ArrayList<>(authUserEmailMap.keySet()));
28790 amit.gupta 1316 
		Map<String, User> userMap = users.stream().collect(Collectors.toMap(x -> x.getEmailId(), x -> x));
28775 amit.gupta 1317 
 
28790 amit.gupta 1318 
		Map<Integer, List<EmployeeAttendance>> employeeAttendancesMap = employeeAttendanceRepository
1319 
				.selectAllByDatesBetween(LocalDate.now().atStartOfDay(), LocalDateTime.now()).stream()
1320 
				.collect(Collectors.groupingBy(x -> x.getUserId()));
1321 
 
1322 
		for (AuthUser authUser : authUsers) {
28775 amit.gupta 1323 
			User user = userMap.get(authUser.getEmailId());
28784 amit.gupta 1324 
			String body = null;
1325 
			List<EmployeeAttendance> employeeAttendances = employeeAttendancesMap.get(user.getId());
28790 amit.gupta 1326 
			if (employeeAttendances == null) {
1327 
				body = String.format(
28806 amit.gupta 1328 
						"Dear %s,\n No attendance has been registered by you today. You have been marked absent for the day.\n\nRegards\nHR Team",
28790 amit.gupta 1329 
						authUser.getFullName());
28784 amit.gupta 1330 
			} else {
28790 amit.gupta 1331 
				List<LocalDateTime> punchTimes = employeeAttendances.stream()
1332 
						.sorted(Comparator.comparing(EmployeeAttendance::getCreateTimestamp))
1333 
						.map(x -> x.getCreateTimestamp()).collect(Collectors.toList());
1334 
				if (punchTimes.size() == 1) {
1335 
					// body = String.format("Dear %s,\n Pls note that you haven't punched out yet.
1336 
					// You have been marked absent for half the day. You may contact your manager
1337 
					// and get it regularise.\n\nRegards\nHR Team", authUser.getFullName());
28784 amit.gupta 1338 
				} else {
1339 
					LocalDateTime firstPunch = punchTimes.get(0);
28790 amit.gupta 1340 
					LocalDateTime lastPunch = punchTimes.get(punchTimes.size() - 1);
28805 amit.gupta 1341 
					Duration duration = Duration.between(firstPunch, lastPunch);
28784 amit.gupta 1342 
					boolean hoursCompleted = lastPunch.isAfter(firstPunch.plusHours(8).plusMinutes(30));
28790 amit.gupta 1343 
					if (!hoursCompleted) {
1344 
						body = String.format(
28806 amit.gupta 1345 
								"Dear %s,\n Pls note that you haven't completed 8.30 Hrs (%d.%d Hrs). You have been marked absent for half the day.\n\nRegards\nHR Team",
28839 tejbeer 1346 
								authUser.getFullName(), duration.toHours(),
1347 
								duration.toMinutes() - duration.toHours() * 60);
28784 amit.gupta 1348 
					}
1349 
				}
1350 
 
1351 
			}
28790 amit.gupta 1352 
			if (body != null) {
30752 tejbeer 1353 
				Utils.sendMailWithAttachments(googleMailSender, new String[] { authUser.getEmailId() },
31120 tejbeer 1354 
						new String[] { "kangan.monga@smartdukaan.com" }, "Attendance Alert", body);
28775 amit.gupta 1355 
			}
1356 
		}
28790 amit.gupta 1357 
 
1358 
		this.sendMailToHR();
1359 
 
28775 amit.gupta 1360 
	}
28790 amit.gupta 1361 
 
1362 
	private void sendMailToHR() throws Exception {
1363 
		Map<String, String> map = new HashMap<>();
1364 
		String reporticoDate = FormattingUtils.formatReporitcoDate(LocalDateTime.now());
1365 
		map.put("MANUAL_datesBetween_FROMDATE", reporticoDate);
1366 
		map.put("MANUAL_datesBetween_FROMDATE", reporticoDate);
1367 
		InputStreamSource isr = reporticoService.getReportInputStreamSource(ReporticoProject.FOCO,
1368 
				"employeeattendance.xml");
1369 
		Attachment attachment = new Attachment("attendance-" + FormattingUtils.formatDate(LocalDateTime.now()) + ".csv",
1370 
				isr);
1371 
		Utils.sendMailWithAttachments(googleMailSender, EMPLOYEE_ATTENDANCE_MAIL_LIST, null,
1372 
				"Attendance - " + FormattingUtils.formatDate(LocalDateTime.now()), "PFA Attendance", attachment);
1373 
	}
1374 
 
28709 amit.gupta 1375 
	public void checkPartnerActiveStore() throws Exception {
1376 
 
1377 
		List<FofoStore> fofoStores = fofoStoreRepository.selectByStatus(true);
1378 
 
1379 
		LocalDateTime currentDate = LocalDate.now().atStartOfDay();
28712 amit.gupta 1380 
		if (!fofoStores.isEmpty()) {
1381 
			for (FofoStore fofoStore : fofoStores) {
28709 amit.gupta 1382 
 
28712 amit.gupta 1383 
				if (currentDate.isBefore(fofoStore.getActiveTimeStamp())) {
28709 amit.gupta 1384 
 
28712 amit.gupta 1385 
					fofoStore.setActive(true);
1386 
					fofoStoreRepository.persist(fofoStore);
1387 
					LOGGER.info("inserted into InActiveFofoStore successfully");
28709 amit.gupta 1388 
 
30393 amit.gupta 1389 
				} else {
28712 amit.gupta 1390 
					fofoStore.setActive(false);
1391 
					fofoStore.setActiveTimeStamp(null);
1392 
					fofoStoreRepository.persist(fofoStore);
1393 
					LOGGER.info("inserted into InActiveFofoStore successfully");
1394 
				}
28709 amit.gupta 1395 
 
1396 
			}
1397 
		}
1398 
 
1399 
	}
1400 
 
24697 amit.gupta 1401 
	public void sendAgeingReport() throws Exception {
30593 amit.gupta 1402 
		sendAgeingReport("kamini.sharma@smartdukaan.com", "tarun.verma@smartdukaan.com",
28467 tejbeer 1403 
				"niranjan.kala@smartdukaan.com", "manish.gupta@smartdukaan.com", "kuldeep.kumar@smartdukaan.com");
24697 amit.gupta 1404 
	}
1405 
 
24533 govind 1406 
	public void moveImeisToPriceDropImeis() throws Exception {
24431 amit.gupta 1407 
		List<PriceDrop> priceDrops = priceDropRepository.selectAll();
24533 govind 1408 
		for (PriceDrop priceDrop : priceDrops) {
24431 amit.gupta 1409 
			priceDropService.priceDropStatus(priceDrop.getId());
1410 
		}
1411 
	}
23929 amit.gupta 1412 
 
24542 amit.gupta 1413 
	public void walletmismatch() throws Exception {
1414 
		LocalDate curDate = LocalDate.now();
24553 amit.gupta 1415 
		List<PartnerDailyInvestment> pdis = partnerDailyInvestmentRepository.selectAll(curDate.minusDays(2));
24552 amit.gupta 1416 
		System.out.println(pdis.size());
24542 amit.gupta 1417 
		for (PartnerDailyInvestment pdi : pdis) {
24549 amit.gupta 1418 
			int fofoId = pdi.getFofoId();
24542 amit.gupta 1419 
			for (PartnerDailyInvestment investment : Lists
1420 
					.reverse(partnerDailyInvestmentRepository.selectAll(fofoId, null, null))) {
24552 amit.gupta 1421 
				float statementAmount = walletService.getOpeningTill(fofoId,
24555 amit.gupta 1422 
						investment.getDate().plusDays(1).atTime(LocalTime.of(4, 0)));
24552 amit.gupta 1423 
				CustomRetailer retailer = retailerService.getFofoRetailer(fofoId);
24841 govind 1424 
				LOGGER.info("{}\t{}\t{}\t{}\t{}", fofoId, retailer.getBusinessName(), retailer.getMobileNumber(),
1425 
						investment.getDate().toString(), investment.getWalletAmount(), statementAmount);
24551 amit.gupta 1426 
 
24542 amit.gupta 1427 
			}
24549 amit.gupta 1428 
		}
24542 amit.gupta 1429 
 
1430 
	}
29160 amit.gupta 1431 
 
28990 amit.gupta 1432 
	@Autowired
1433 
	StateRepository stateRepository;
24542 amit.gupta 1434 
 
1435 
	public void gst() throws Exception {
28995 amit.gupta 1436 
		List<FofoOrder> fofoOrders = fofoOrderRepository.selectBetweenSaleDate(LocalDate.of(2021, 8, 16).atStartOfDay(),
28990 amit.gupta 1437 
				LocalDateTime.now());
24548 amit.gupta 1438 
		for (FofoOrder fofoOrder : fofoOrders) {
1439 
			int retailerAddressId = retailerRegisteredAddressRepository
1440 
					.selectAddressIdByRetailerId(fofoOrder.getFofoId());
24542 amit.gupta 1441 
 
1442 
			Address retailerAddress = addressRepository.selectById(retailerAddressId);
1443 
			CustomerAddress customerAddress = customerAddressRepository.selectById(fofoOrder.getCustomerAddressId());
1444 
			Integer stateId = null;
1445 
			if (customerAddress.getState().equals(retailerAddress.getState())) {
1446 
				try {
28990 amit.gupta 1447 
					stateId = stateRepository.selectByName(customerAddress.getState()).getId();
24542 amit.gupta 1448 
				} catch (Exception e) {
28990 amit.gupta 1449 
					LOGGER.error("Cannot found state named {}", customerAddress.getState());
1450 
					continue;
24542 amit.gupta 1451 
				}
1452 
			}
1453 
			Map<Integer, GstRate> itemIdStateTaxRateMap = null;
1454 
			Map<Integer, Float> itemIdIgstTaxRateMap = null;
24548 amit.gupta 1455 
 
1456 
			List<FofoOrderItem> fofoOrderItems = fofoOrderItemRepository.selectByOrderId(fofoOrder.getId());
26929 amit.gupta 1457 
			List<Integer> itemIds = fofoOrderItems.stream().map(x -> x.getItemId()).collect(Collectors.toList());
24542 amit.gupta 1458 
			if (stateId != null) {
26929 amit.gupta 1459 
				itemIdStateTaxRateMap = stateGstRateRepository.getStateTaxRate(itemIds, stateId);
24542 amit.gupta 1460 
			} else {
26929 amit.gupta 1461 
				itemIdIgstTaxRateMap = stateGstRateRepository.getIgstTaxRate(itemIds);
24542 amit.gupta 1462 
			}
1463 
 
24548 amit.gupta 1464 
			for (FofoOrderItem foi : fofoOrderItems) {
28990 amit.gupta 1465 
				float sgstRate = foi.getSgstRate();
1466 
				float cgstRate = foi.getCgstRate();
1467 
				float igstRate = foi.getIgstRate();
29160 amit.gupta 1468 
				if (stateId == null && igstRate == 0) {
1469 
 
1470 
					foi.setSgstRate(0);
1471 
					foi.setCgstRate(0);
1472 
					foi.setIgstRate(itemIdIgstTaxRateMap.get(foi.getItemId()));
1473 
 
28993 amit.gupta 1474 
					LOGGER.info("Invoice {}, Date {}", fofoOrder.getInvoiceNumber(), fofoOrder.getCreateTimestamp());
29160 amit.gupta 1475 
					LOGGER.info("customerAddress.getState() {}, retailerAddress.getState() {}",
1476 
							customerAddress.getState(), retailerAddress.getState());
28990 amit.gupta 1477 
					LOGGER.info("Rates getIgstRate() {}", itemIdIgstTaxRateMap.get(foi.getItemId()));
29160 amit.gupta 1478 
 
1479 
				} else if (stateId != null && sgstRate == 0 && cgstRate == 0) {
1480 
 
1481 
					foi.setIgstRate(0);
1482 
					foi.setCgstRate(itemIdStateTaxRateMap.get(foi.getItemId()).getCgstRate());
1483 
					foi.setSgstRate(itemIdStateTaxRateMap.get(foi.getItemId()).getSgstRate());
1484 
 
28993 amit.gupta 1485 
					LOGGER.info("Invoice {}, Date {}", fofoOrder.getInvoiceNumber(), fofoOrder.getCreateTimestamp());
29160 amit.gupta 1486 
					LOGGER.info("customerAddress.getState() {}, retailerAddress.getState() {}",
1487 
							customerAddress.getState(), retailerAddress.getState());
1488 
					LOGGER.info("Rates getCgstRate() {}, getSgstRate() {}",
1489 
							itemIdStateTaxRateMap.get(foi.getItemId()).getCgstRate(),
1490 
							itemIdStateTaxRateMap.get(foi.getItemId()).getSgstRate());
24542 amit.gupta 1491 
				}
1492 
			}
1493 
		}
24548 amit.gupta 1494 
 
24542 amit.gupta 1495 
	}
1496 
 
24580 amit.gupta 1497 
	public void schemewalletmismatch() {
1498 
		LocalDate dateToReconcile = LocalDate.of(2018, 4, 1);
24587 amit.gupta 1499 
		while (dateToReconcile.isBefore(LocalDate.now())) {
24580 amit.gupta 1500 
			reconcileSchemes(dateToReconcile);
24587 amit.gupta 1501 
			// reconcileOrders(dateTime);
1502 
			// reconcileRecharges(dateTime);
24580 amit.gupta 1503 
			dateToReconcile = dateToReconcile.plusDays(1);
1504 
		}
1505 
	}
1506 
 
1507 
	private void reconcileSchemes(LocalDate date) {
1508 
		LocalDateTime startDate = date.atStartOfDay();
1509 
		LocalDateTime endDate = startDate.plusDays(1);
1510 
		List<SchemeInOut> siosCreated = schemeInOutRepository.selectAllByCreateDate(startDate, endDate);
1511 
		List<SchemeInOut> siosRefunded = schemeInOutRepository.selectAllByRefundDate(startDate, endDate);
24587 amit.gupta 1512 
		double totalSchemeDisbursed = siosCreated.stream().mapToDouble(x -> x.getAmount()).sum();
1513 
		double totalSchemeRolledback = siosRefunded.stream().mapToDouble(x -> x.getAmount()).sum();
24580 amit.gupta 1514 
		double netSchemeDisbursed = totalSchemeDisbursed - totalSchemeRolledback;
24587 amit.gupta 1515 
		List<WalletReferenceType> walletReferenceTypes = Arrays.asList(WalletReferenceType.SCHEME_IN,
1516 
				WalletReferenceType.SCHEME_OUT);
1517 
		List<UserWalletHistory> history = userWalletHistoryRepository.selectAllByDateType(startDate, endDate,
1518 
				walletReferenceTypes);
1519 
		double schemeAmountWalletTotal = history.stream().mapToDouble(x -> x.getAmount()).sum();
1520 
		if (Math.abs(netSchemeDisbursed - schemeAmountWalletTotal) > 10d) {
24580 amit.gupta 1521 
			LOGGER.info("Scheme Amount mismatched for Date {}", date);
24587 amit.gupta 1522 
 
1523 
			Map<Integer, Double> inventoryItemSchemeIO = siosCreated.stream().collect(Collectors
1524 
					.groupingBy(x -> x.getInventoryItemId(), Collectors.summingDouble(SchemeInOut::getAmount)));
1525 
 
1526 
			Map<Integer, Double> userSchemeMap = inventoryItemRepository.selectByIds(inventoryItemSchemeIO.keySet())
1527 
					.stream().collect(Collectors.groupingBy(x -> x.getFofoId(),
1528 
							Collectors.summingDouble(x -> inventoryItemSchemeIO.get(x.getId()))));
1529 
 
1530 
			Map<Integer, Double> inventoryItemSchemeIORefunded = siosRefunded.stream().collect(Collectors
1531 
					.groupingBy(x -> x.getInventoryItemId(), Collectors.summingDouble(SchemeInOut::getAmount)));
1532 
 
1533 
			Map<Integer, Double> userSchemeRefundedMap = inventoryItemRepository
1534 
					.selectByIds(inventoryItemSchemeIORefunded.keySet()).stream()
1535 
					.collect(Collectors.groupingBy(x -> x.getFofoId(),
1536 
							Collectors.summingDouble(x -> inventoryItemSchemeIORefunded.get(x.getId()))));
1537 
 
1538 
			Map<Integer, Double> finalUserSchemeAmountMap = new HashMap<>();
26092 amit.gupta 1539 
 
24587 amit.gupta 1540 
			for (Map.Entry<Integer, Double> schemeAmount : userSchemeRefundedMap.entrySet()) {
1541 
				if (!finalUserSchemeAmountMap.containsKey(schemeAmount.getKey())) {
1542 
					finalUserSchemeAmountMap.put(schemeAmount.getKey(), schemeAmount.getValue());
1543 
				} else {
1544 
					finalUserSchemeAmountMap.put(schemeAmount.getKey(),
1545 
							finalUserSchemeAmountMap.get(schemeAmount.getKey()) + schemeAmount.getValue());
1546 
				}
1547 
			}
24590 amit.gupta 1548 
			Map<Integer, Integer> userWalletMap = userWalletRepository
1549 
					.selectByRetailerIds(finalUserSchemeAmountMap.keySet()).stream()
1550 
					.collect(Collectors.toMap(UserWallet::getUserId, UserWallet::getId));
1551 
 
24587 amit.gupta 1552 
			Map<Integer, Double> walletAmountMap = history.stream().collect(Collectors.groupingBy(
1553 
					UserWalletHistory::getWalletId, Collectors.summingDouble((UserWalletHistory::getAmount))));
1554 
			for (Map.Entry<Integer, Double> userAmount : walletAmountMap.entrySet()) {
1555 
				double diff = Math.abs(finalUserSchemeAmountMap.get(userAmount.getKey()) - userAmount.getValue());
1556 
				if (diff > 5) {
1557 
					LOGGER.info("Partner scheme mismatched for Userid {}", userWalletMap.get(userAmount.getKey()));
1558 
				}
1559 
			}
24580 amit.gupta 1560 
		}
24587 amit.gupta 1561 
 
24580 amit.gupta 1562 
	}
24590 amit.gupta 1563 
 
24592 amit.gupta 1564 
	public void dryRunSchemeReco() throws Exception {
24635 amit.gupta 1565 
		Map<Integer, Integer> userWalletMap = userWalletRepository.selectAll().stream()
1566 
				.collect(Collectors.toMap(UserWallet::getUserId, UserWallet::getId));
1567 
 
24592 amit.gupta 1568 
		List<UserWalletHistory> userWalletHistory = new ArrayList<>();
1569 
		List<SchemeInOut> rolledbackSios = new ArrayList<>();
24635 amit.gupta 1570 
		Map<Integer, SchemeType> schemeTypeMap = schemeRepository.selectAll().stream()
1571 
				.collect(Collectors.toMap(Scheme::getId, Scheme::getType));
1572 
		Set<String> serialNumbersConsidered = new HashSet<>();
1573 
 
25096 amit.gupta 1574 
		LocalDateTime startDate = LocalDate.of(2018, 3, 1).atStartOfDay();
24635 amit.gupta 1575 
		LocalDateTime endDate = LocalDate.now().atStartOfDay();
1576 
		List<Purchase> purchases = purchaseRepository.selectAllBetweenPurchaseDate(startDate, endDate);
1577 
 
24683 amit.gupta 1578 
		Map<Integer, String> storeNameMap = fofoStoreRepository.getStoresMap();
24635 amit.gupta 1579 
		purchases.stream().forEach(purchase -> {
1580 
			float amountToRollback = 0;
1581 
			String description = "Adjustment of Duplicate Scheme for Purchase Invoice "
1582 
					+ purchase.getPurchaseReference();
1583 
			Map<Integer, String> inventorySerialNumberMap = inventoryItemRepository.selectByPurchaseId(purchase.getId())
1584 
					.stream().filter(ii -> ii.getSerialNumber() != null)
1585 
					.collect(Collectors.toMap(InventoryItem::getId, InventoryItem::getSerialNumber));
1586 
			if (inventorySerialNumberMap.size() > 0) {
1587 
				for (Map.Entry<Integer, String> inventorySerialNumberEntry : inventorySerialNumberMap.entrySet()) {
1588 
					String serialNumber = inventorySerialNumberEntry.getValue();
1589 
					int inventoryItemId = inventorySerialNumberEntry.getKey();
1590 
					if (serialNumbersConsidered.contains(serialNumber)) {
1591 
						// This will rollback scheme for differenct orders for same serial
1592 
						List<SchemeInOut> sios = schemeInOutRepository
1593 
								.selectByInventoryItemIds(new HashSet<>(Arrays.asList(inventoryItemId))).stream()
1594 
								.filter(x -> x.getRolledBackTimestamp() == null
1595 
										&& schemeTypeMap.get(x.getSchemeId()).equals(SchemeType.IN))
1596 
								.collect(Collectors.toList());
1597 
						Collections.reverse(sios);
1598 
						for (SchemeInOut sio : sios) {
1599 
							sio.setRolledBackTimestamp(LocalDateTime.now());
1600 
							amountToRollback += sio.getAmount();
1601 
							// sio.setSchemeType(SchemeType.OUT);
1602 
							sio.setSerialNumber(serialNumber);
1603 
							rolledbackSios.add(sio);
1604 
						}
1605 
						description = description.concat(" " + serialNumber + " ");
1606 
					} else {
1607 
						serialNumbersConsidered.add(serialNumber);
1608 
						List<Integer> schemesConsidered = new ArrayList<>();
1609 
						List<SchemeInOut> sios = schemeInOutRepository
1610 
								.selectByInventoryItemIds(new HashSet<>(Arrays.asList(inventoryItemId))).stream()
1611 
								.filter(x -> x.getRolledBackTimestamp() == null
1612 
										&& schemeTypeMap.get(x.getSchemeId()).equals(SchemeType.IN))
1613 
								.collect(Collectors.toList());
1614 
						Collections.reverse(sios);
1615 
						for (SchemeInOut sio : sios) {
1616 
							if (!schemesConsidered.contains(sio.getSchemeId())) {
1617 
								schemesConsidered.add(sio.getSchemeId());
1618 
								continue;
1619 
							}
1620 
							sio.setRolledBackTimestamp(LocalDateTime.now());
1621 
							amountToRollback += sio.getAmount();
1622 
							// sio.setSchemeType(SchemeType.OUT);
1623 
							sio.setSerialNumber(serialNumber);
24681 amit.gupta 1624 
							sio.setStoreCode(storeNameMap.get(purchase.getFofoId()));
1625 
							sio.setReference(purchase.getId());
24635 amit.gupta 1626 
							rolledbackSios.add(sio);
1627 
						}
1628 
					}
1629 
 
1630 
				}
1631 
			}
1632 
			if (amountToRollback > 0) {
24683 amit.gupta 1633 
				// Address address =
1634 
				// addressRepository.selectAllByRetailerId(purchase.getFofoId(), 0, 10).get(0);
24635 amit.gupta 1635 
				UserWalletHistory uwh = new UserWalletHistory();
1636 
				uwh.setAmount(Math.round(amountToRollback));
1637 
				uwh.setDescription(description);
1638 
				uwh.setTimestamp(LocalDateTime.now());
24681 amit.gupta 1639 
				uwh.setReferenceType(WalletReferenceType.SCHEME_IN);
24635 amit.gupta 1640 
				uwh.setReference(purchase.getId());
1641 
				uwh.setWalletId(userWalletMap.get(purchase.getFofoId()));
1642 
				uwh.setFofoId(purchase.getFofoId());
24681 amit.gupta 1643 
				uwh.setStoreCode(storeNameMap.get(purchase.getFofoId()));
24635 amit.gupta 1644 
				userWalletHistory.add(uwh);
1645 
			}
1646 
		});
1647 
		ByteArrayOutputStream baos = FileUtil.getCSVByteStream(
1648 
				Arrays.asList("User Id", "Store Code", "Reference Type", "Reference", "Amount", "Description",
1649 
						"Timestamp"),
1650 
				userWalletHistory.stream()
1651 
						.map(x -> Arrays.asList(x.getWalletId(), x.getStoreCode(), x.getReferenceType(),
1652 
								x.getReference(), x.getAmount(), x.getDescription(), x.getTimestamp()))
1653 
						.collect(Collectors.toList()));
1654 
 
1655 
		ByteArrayOutputStream baosOuts = FileUtil.getCSVByteStream(
24683 amit.gupta 1656 
				Arrays.asList("Scheme ID", "SchemeType", "Reference", "Store Code", "Serial Number", "Amount",
1657 
						"Created", "Rolledback"),
24635 amit.gupta 1658 
				rolledbackSios.stream()
24681 amit.gupta 1659 
						.map(x -> Arrays.asList(x.getSchemeId(), x.getSchemeType(), x.getReference(), x.getStoreCode(),
24635 amit.gupta 1660 
								x.getSerialNumber(), x.getAmount(), x.getCreateTimestamp(), x.getRolledBackTimestamp()))
1661 
						.collect(Collectors.toList()));
1662 
 
30752 tejbeer 1663 
		Utils.sendMailWithAttachments(googleMailSender, new String[] { "amit.gupta@shop2020.in" }, null,
24636 amit.gupta 1664 
				"Partner Excess Amount Scheme In", "PFA",
30752 tejbeer 1665 
				new Attachment[] { new Attachment("WalletSummary.csv", new ByteArrayResource(baos.toByteArray())),
1666 
						new Attachment("SchemeInRolledback.csv", new ByteArrayResource(baosOuts.toByteArray())) });
24635 amit.gupta 1667 
 
25096 amit.gupta 1668 
		throw new Exception();
24635 amit.gupta 1669 
 
1670 
	}
1671 
 
1672 
	public void dryRunOutSchemeReco() throws Exception {
1673 
		List<UserWalletHistory> userWalletHistory = new ArrayList<>();
1674 
		List<SchemeInOut> rolledbackSios = new ArrayList<>();
24606 amit.gupta 1675 
		Map<Integer, Integer> userWalletMap = userWalletRepository.selectAll().stream()
1676 
				.collect(Collectors.toMap(UserWallet::getUserId, UserWallet::getId));
24590 amit.gupta 1677 
		Map<Integer, SchemeType> schemeTypeMap = schemeRepository.selectAll().stream()
1678 
				.collect(Collectors.toMap(Scheme::getId, Scheme::getType));
25028 amit.gupta 1679 
		LocalDateTime startDate = LocalDate.of(2019, 5, 1).atStartOfDay();
24632 amit.gupta 1680 
		LocalDateTime endDate = LocalDate.now().atStartOfDay();
24631 amit.gupta 1681 
		List<FofoOrder> allOrders = fofoOrderRepository.selectBetweenSaleDate(startDate, endDate);
1682 
		// Collections.reverse(allOrders);
1683 
		// List<FofoOrder> allOrders =
24653 govind 1684 
		// List<FofoOrder> allOrders =
24631 amit.gupta 1685 
		// Arrays.asList(fofoOrderRepository.selectByInvoiceNumber("UPGZ019/25"));
24625 amit.gupta 1686 
		Set<String> serialNumbersConsidered = new HashSet<>();
24590 amit.gupta 1687 
		allOrders.stream().forEach(fofoOrder -> {
24592 amit.gupta 1688 
			String description = "Adjustment of Duplicate Scheme for Sale Invoice " + fofoOrder.getInvoiceNumber();
24598 amit.gupta 1689 
			Map<Integer, String> inventorySerialNumberMap = new HashMap<>();
24592 amit.gupta 1690 
			float amountToRollback = 0;
24590 amit.gupta 1691 
			List<FofoOrderItem> orderItems = fofoOrderItemRepository.selectByOrderId(fofoOrder.getId());
1692 
			orderItems.forEach(x -> {
24606 amit.gupta 1693 
				inventorySerialNumberMap.putAll(x.getFofoLineItems().stream().filter(li -> li.getSerialNumber() != null)
24598 amit.gupta 1694 
						.collect(Collectors.toMap(FofoLineItem::getInventoryItemId, FofoLineItem::getSerialNumber)));
24590 amit.gupta 1695 
			});
24606 amit.gupta 1696 
			if (inventorySerialNumberMap.size() > 0) {
24631 amit.gupta 1697 
				for (Map.Entry<Integer, String> inventorySerialNumberEntry : inventorySerialNumberMap.entrySet()) {
1698 
					String serialNumber = inventorySerialNumberEntry.getValue();
1699 
					int inventoryItemId = inventorySerialNumberEntry.getKey();
1700 
					if (serialNumbersConsidered.contains(serialNumber)) {
1701 
						// This will rollback scheme for differenct orders for same serial
1702 
						List<SchemeInOut> sios = schemeInOutRepository
24633 amit.gupta 1703 
								.selectByInventoryItemIds(new HashSet<>(Arrays.asList(inventoryItemId))).stream()
24635 amit.gupta 1704 
								.filter(x -> x.getRolledBackTimestamp() == null
1705 
										&& schemeTypeMap.get(x.getSchemeId()).equals(SchemeType.OUT))
24631 amit.gupta 1706 
								.collect(Collectors.toList());
1707 
						Collections.reverse(sios);
1708 
						for (SchemeInOut sio : sios) {
1709 
							sio.setRolledBackTimestamp(LocalDateTime.now());
1710 
							amountToRollback += sio.getAmount();
1711 
							// sio.setSchemeType(SchemeType.OUT);
1712 
							sio.setSerialNumber(serialNumber);
1713 
							sio.setStoreCode(fofoOrder.getInvoiceNumber().split("/")[0]);
24681 amit.gupta 1714 
							sio.setReference(fofoOrder.getId());
24631 amit.gupta 1715 
							rolledbackSios.add(sio);
24623 amit.gupta 1716 
						}
24635 amit.gupta 1717 
						description = description.concat(" " + serialNumber + " ");
24631 amit.gupta 1718 
					} else {
1719 
						serialNumbersConsidered.add(serialNumber);
1720 
						List<Integer> schemesConsidered = new ArrayList<>();
1721 
						List<SchemeInOut> sios = schemeInOutRepository
24633 amit.gupta 1722 
								.selectByInventoryItemIds(new HashSet<>(Arrays.asList(inventoryItemId))).stream()
24635 amit.gupta 1723 
								.filter(x -> x.getRolledBackTimestamp() == null
1724 
										&& schemeTypeMap.get(x.getSchemeId()).equals(SchemeType.OUT))
24631 amit.gupta 1725 
								.collect(Collectors.toList());
1726 
						Collections.reverse(sios);
1727 
						for (SchemeInOut sio : sios) {
1728 
							if (!schemesConsidered.contains(sio.getSchemeId())) {
1729 
								schemesConsidered.add(sio.getSchemeId());
1730 
								continue;
1731 
							}
1732 
							sio.setRolledBackTimestamp(LocalDateTime.now());
1733 
							amountToRollback += sio.getAmount();
1734 
							// sio.setSchemeType(SchemeType.OUT);
24681 amit.gupta 1735 
							sio.setReference(fofoOrder.getId());
24631 amit.gupta 1736 
							sio.setSerialNumber(serialNumber);
1737 
							sio.setStoreCode(fofoOrder.getInvoiceNumber().split("/")[0]);
1738 
							rolledbackSios.add(sio);
1739 
						}
24615 amit.gupta 1740 
					}
24631 amit.gupta 1741 
 
24604 amit.gupta 1742 
				}
24590 amit.gupta 1743 
			}
24631 amit.gupta 1744 
			if (amountToRollback > 0) {
1745 
				UserWalletHistory uwh = new UserWalletHistory();
1746 
				uwh.setAmount(Math.round(amountToRollback));
1747 
				uwh.setDescription(description);
1748 
				uwh.setTimestamp(LocalDateTime.now());
1749 
				uwh.setReferenceType(WalletReferenceType.SCHEME_OUT);
1750 
				uwh.setReference(fofoOrder.getId());
1751 
				uwh.setWalletId(userWalletMap.get(fofoOrder.getFofoId()));
1752 
				uwh.setFofoId(fofoOrder.getFofoId());
1753 
				uwh.setStoreCode(fofoOrder.getInvoiceNumber().split("/")[0]);
1754 
				userWalletHistory.add(uwh);
1755 
			}
24590 amit.gupta 1756 
		});
24598 amit.gupta 1757 
 
24592 amit.gupta 1758 
		ByteArrayOutputStream baos = FileUtil.getCSVByteStream(
24681 amit.gupta 1759 
				Arrays.asList("Wallet Id", "Store Code", "Reference Type", "Reference", "Amount", "Description",
24615 amit.gupta 1760 
						"Timestamp"),
1761 
				userWalletHistory.stream()
1762 
						.map(x -> Arrays.asList(x.getWalletId(), x.getStoreCode(), x.getReferenceType(),
1763 
								x.getReference(), x.getAmount(), x.getDescription(), x.getTimestamp()))
24592 amit.gupta 1764 
						.collect(Collectors.toList()));
1765 
 
1766 
		ByteArrayOutputStream baosOuts = FileUtil.getCSVByteStream(
1767 
				Arrays.asList("Scheme ID", "SchemeType", "Store Code", "Serial Number", "Amount", "Created",
1768 
						"Rolledback"),
1769 
				rolledbackSios.stream()
1770 
						.map(x -> Arrays.asList(x.getSchemeId(), x.getSchemeType(), x.getStoreCode(),
1771 
								x.getSerialNumber(), x.getAmount(), x.getCreateTimestamp(), x.getRolledBackTimestamp()))
1772 
						.collect(Collectors.toList()));
1773 
 
30752 tejbeer 1774 
		Utils.sendMailWithAttachments(googleMailSender, new String[] { "amit.gupta@shop2020.in" }, null,
24681 amit.gupta 1775 
				"Partner Excess Amount Scheme Out", "PFA",
30752 tejbeer 1776 
				new Attachment[] { new Attachment("WalletSummary.csv", new ByteArrayResource(baos.toByteArray())),
1777 
						new Attachment("SchemeOutRolledback.csv", new ByteArrayResource(baosOuts.toByteArray())) });
24631 amit.gupta 1778 
 
25267 amit.gupta 1779 
		throw new Exception();
24590 amit.gupta 1780 
	}
24615 amit.gupta 1781 
 
24611 amit.gupta 1782 
	public void dryRunSchemeOutReco1() throws Exception {
24615 amit.gupta 1783 
		List<Integer> references = Arrays.asList(6744, 7347, 8320, 8891, 9124, 9217, 9263, 9379);
24611 amit.gupta 1784 
		List<UserWalletHistory> userWalletHistory = new ArrayList<>();
1785 
		List<SchemeInOut> rolledbackSios = new ArrayList<>();
1786 
		Map<Integer, Integer> userWalletMap = userWalletRepository.selectAll().stream()
1787 
				.collect(Collectors.toMap(UserWallet::getUserId, UserWallet::getId));
1788 
		Map<Integer, SchemeType> schemeTypeMap = schemeRepository.selectAll().stream()
1789 
				.collect(Collectors.toMap(Scheme::getId, Scheme::getType));
1790 
		references.stream().forEach(reference -> {
1791 
			FofoOrder fofoOrder = null;
1792 
			try {
1793 
				fofoOrder = fofoOrderRepository.selectByOrderId(reference);
24615 amit.gupta 1794 
			} catch (Exception e) {
1795 
 
24611 amit.gupta 1796 
			}
1797 
			String description = "Adjustment of Duplicate Scheme for Sale Invoice " + fofoOrder.getInvoiceNumber();
1798 
			Map<Integer, String> inventorySerialNumberMap = new HashMap<>();
1799 
			float amountToRollback = 0;
1800 
			List<FofoOrderItem> orderItems = fofoOrderItemRepository.selectByOrderId(fofoOrder.getId());
1801 
			orderItems.forEach(x -> {
1802 
				inventorySerialNumberMap.putAll(x.getFofoLineItems().stream().filter(li -> li.getSerialNumber() != null)
1803 
						.collect(Collectors.toMap(FofoLineItem::getInventoryItemId, FofoLineItem::getSerialNumber)));
1804 
			});
1805 
			if (inventorySerialNumberMap.size() > 0) {
24615 amit.gupta 1806 
				List<SchemeInOut> sios = schemeInOutRepository
1807 
						.selectByInventoryItemIds(inventorySerialNumberMap.keySet()).stream()
1808 
						.filter(x -> schemeTypeMap.get(x.getSchemeId()).equals(SchemeType.OUT))
24611 amit.gupta 1809 
						.collect(Collectors.toList());
1810 
				LOGGER.info("Found {} duplicate schemeouts for Orderid {}", sios.size(), fofoOrder.getId());
1811 
				UserWalletHistory uwh = new UserWalletHistory();
24615 amit.gupta 1812 
				Map<Integer, List<SchemeInOut>> inventoryIdSouts = sios.stream()
1813 
						.collect(Collectors.groupingBy(SchemeInOut::getInventoryItemId, Collectors.toList()));
24611 amit.gupta 1814 
				for (Map.Entry<Integer, List<SchemeInOut>> inventorySioEntry : inventoryIdSouts.entrySet()) {
1815 
					List<SchemeInOut> outList = inventorySioEntry.getValue();
24615 amit.gupta 1816 
					if (outList.size() > 1) {
1817 
 
24611 amit.gupta 1818 
					}
1819 
				}
1820 
				uwh.setAmount(Math.round(amountToRollback));
1821 
				uwh.setDescription(description);
1822 
				uwh.setTimestamp(LocalDateTime.now());
1823 
				uwh.setReferenceType(WalletReferenceType.SCHEME_OUT);
1824 
				uwh.setReference(fofoOrder.getId());
1825 
				uwh.setWalletId(userWalletMap.get(fofoOrder.getFofoId()));
1826 
				uwh.setFofoId(fofoOrder.getFofoId());
1827 
				uwh.setStoreCode(fofoOrder.getInvoiceNumber().split("/")[0]);
1828 
				userWalletHistory.add(uwh);
1829 
			}
1830 
		});
24615 amit.gupta 1831 
 
24611 amit.gupta 1832 
		ByteArrayOutputStream baos = FileUtil.getCSVByteStream(
1833 
				Arrays.asList("User Id", "Reference Type", "Reference", "Amount", "Description", "Timestamp"),
1834 
				userWalletHistory.stream().map(x -> Arrays.asList(x.getWalletId(), x.getReferenceType(),
30752 tejbeer 1835 
						x.getReference(), x.getAmount(), x.getDescription(), x.getTimestamp()))
24615 amit.gupta 1836 
						.collect(Collectors.toList()));
1837 
 
24611 amit.gupta 1838 
		ByteArrayOutputStream baosOuts = FileUtil.getCSVByteStream(
1839 
				Arrays.asList("Scheme ID", "SchemeType", "Store Code", "Serial Number", "Amount", "Created",
1840 
						"Rolledback"),
1841 
				rolledbackSios.stream()
24615 amit.gupta 1842 
						.map(x -> Arrays.asList(x.getSchemeId(), x.getSchemeType(), x.getStoreCode(),
1843 
								x.getSerialNumber(), x.getAmount(), x.getCreateTimestamp(), x.getRolledBackTimestamp()))
1844 
						.collect(Collectors.toList()));
1845 
 
24623 amit.gupta 1846 
		Utils.sendMailWithAttachments(googleMailSender,
30752 tejbeer 1847 
				new String[] { "amit.gupta@shop2020.in", "neeraj.gupta@smartdukaan.com" }, null,
24611 amit.gupta 1848 
				"Partner Excess Amount", "PFA",
30752 tejbeer 1849 
				new Attachment[] { new Attachment("WalletSummary.csv", new ByteArrayResource(baos.toByteArray())),
1850 
						new Attachment("SchemeOutRolledback.csv", new ByteArrayResource(baosOuts.toByteArray())) });
24631 amit.gupta 1851 
 
24628 amit.gupta 1852 
		throw new Exception();
24615 amit.gupta 1853 
 
24611 amit.gupta 1854 
	}
24615 amit.gupta 1855 
 
26945 amit.gupta 1856 
	public void sendDailySalesNotificationToPartner(Integer fofoIdInt) throws Exception {
25927 amit.gupta 1857 
 
24653 govind 1858 
		LocalDateTime now = LocalDateTime.now();
25837 amit.gupta 1859 
		LocalDateTime from = now.with(LocalTime.MIN);
25925 amit.gupta 1860 
		String timeString = "Today %s";
25927 amit.gupta 1861 
		// Send yesterday's report
27007 amit.gupta 1862 
		/*
1863 
		 * if (now.getHour() < 13) { timeString = "Yesterday %s"; from =
1864 
		 * now.minusDays(1).; now = from.with(LocalTime.MAX);
30393 amit.gupta 1865 
		 *
27007 amit.gupta 1866 
		 * }
1867 
		 */
24855 amit.gupta 1868 
		List<Integer> fofoIds = null;
25043 amit.gupta 1869 
		if (fofoIdInt == null) {
1870 
			fofoIds = fofoStoreRepository.selectAll().stream().filter(x -> x.isActive()).map(x -> x.getId())
1871 
					.collect(Collectors.toList());
24856 amit.gupta 1872 
		} else {
24855 amit.gupta 1873 
			fofoIds = Arrays.asList(fofoIdInt);
1874 
		}
25912 amit.gupta 1875 
		DateTimeFormatter timeFormatter = DateTimeFormatter.ofPattern("h:m a");
24683 amit.gupta 1876 
 
25865 amit.gupta 1877 
		Map<Integer, Float> partnerPolicyAmountMap = insurancePolicyRepository.selectAmountSumGroupByRetailerId(now,
1878 
				null);
1879 
		Map<Integer, Long> partnerPolicyQtyMap = insurancePolicyRepository.selectQtyGroupByRetailerId(now, null);
26945 amit.gupta 1880 
 
1881 
		Map<Integer, Double> spPartnerOrderValMap = fofoOrderItemRepository.selectSumAmountGroupByRetailer(from, now, 0,
1882 
				true);
1883 
 
1884 
		Map<Integer, Double> spPartner3DaysOrderValMap = fofoOrderItemRepository
1885 
				.selectSumAmountGroupByRetailer(from.minusDays(3), now, 0, true);
26941 amit.gupta 1886 
		Map<Integer, Long> spPartnerOrderQtyMap = fofoOrderItemRepository.selectQtyGroupByRetailer(from, now, 0, true);
1887 
 
26945 amit.gupta 1888 
		Map<Integer, Double> partnerOrderValMap = fofoOrderItemRepository.selectSumAmountGroupByRetailer(from, now, 0,
1889 
				false);
26941 amit.gupta 1890 
		Map<Integer, Long> partnerOrderQtyMap = fofoOrderItemRepository.selectQtyGroupByRetailer(from, now, 0, false);
26945 amit.gupta 1891 
 
25865 amit.gupta 1892 
		Map<Integer, SaleTargetReportModel> saleTargetReportModelMap = new HashMap<>();
1893 
		for (int fofoId : fofoIds) {
1894 
			SaleTargetReportModel model = new SaleTargetReportModel();
25927 amit.gupta 1895 
			model.setInsuranceSale(
1896 
					partnerPolicyAmountMap.containsKey(fofoId) ? partnerPolicyAmountMap.get(fofoId).doubleValue() : 0);
25865 amit.gupta 1897 
			model.setInsruanceQty(partnerPolicyQtyMap.containsKey(fofoId) ? partnerPolicyQtyMap.get(fofoId) : 0);
26941 amit.gupta 1898 
			model.setSmartphoneSale(spPartnerOrderValMap.containsKey(fofoId) ? spPartnerOrderValMap.get(fofoId) : 0);
1899 
			model.setSmartphoneQty(spPartnerOrderQtyMap.containsKey(fofoId) ? spPartnerOrderQtyMap.get(fofoId) : 0);
1900 
			model.setTotalSale(partnerOrderValMap.containsKey(fofoId) ? partnerOrderValMap.get(fofoId) : 0);
1901 
			model.setTotalQty(partnerOrderQtyMap.containsKey(fofoId) ? partnerOrderQtyMap.get(fofoId) : 0);
26945 amit.gupta 1902 
			model.setPast3daysSale(
1903 
					spPartner3DaysOrderValMap.containsKey(fofoId) ? spPartner3DaysOrderValMap.get(fofoId) : 0);
25880 amit.gupta 1904 
			model.setFofoId(fofoId);
25865 amit.gupta 1905 
			saleTargetReportModelMap.put(fofoId, model);
1906 
		}
25880 amit.gupta 1907 
 
26945 amit.gupta 1908 
		Map<Integer, FofoReportingModel> partnerSalesHeadersMap = this.getPartnerIdSalesHeaders();
24653 govind 1909 
		for (Integer fofoId : fofoIds) {
25865 amit.gupta 1910 
			SaleTargetReportModel model = saleTargetReportModelMap.get(fofoId);
30982 tejbeer 1911 
 
31169 tejbeer 1912 
			// com.spice.profitmandi.dao.entity.user.User user =
1913 
			// userUserRepository.selectById(fofoId);
30982 tejbeer 1914 
 
31169 tejbeer 1915 
			// Address address = addressRepository.selectById(user.getAddressId());
30982 tejbeer 1916 
 
1917 
			String title = "Sale Update";
1918 
			String messageTemplate = String.format("Smartphones Rs.%.0f, Insurance Rs.%.0f, Total Rs.%.0f till %s.",
1919 
					model.getSmartphoneSale(), model.getInsuranceSale(), model.getTotalSale(),
1920 
					String.format(timeString, now.format(timeFormatter)));
25821 amit.gupta 1921 
			SendNotificationModel sendNotificationModel = new SendNotificationModel();
1922 
			sendNotificationModel.setCampaignName("Sales update alert");
30982 tejbeer 1923 
			sendNotificationModel.setTitle(title);
1924 
			sendNotificationModel.setMessage(messageTemplate);
25821 amit.gupta 1925 
			sendNotificationModel.setType("url");
27206 tejbeer 1926 
			sendNotificationModel.setUrl("https://app.smartdukaan.com/pages/home/notifications");
25821 amit.gupta 1927 
			sendNotificationModel.setExpiresat(LocalDateTime.now().plusDays(1));
1928 
			sendNotificationModel.setMessageType(MessageType.notification);
25872 tejbeer 1929 
			int userId = userAccountRepository.selectUserIdByRetailerId(fofoId);
1930 
			sendNotificationModel.setUserIds(Arrays.asList(userId));
25854 amit.gupta 1931 
			notificationService.sendNotification(sendNotificationModel);
30999 tejbeer 1932 
			String whatsappMessageTemplate = String.format(
1933 
					"Dear Partner, Your sale update is Smartphones Rs.%.0f, Insurance Rs.%.0f, Total Rs.%.0f till %s.",
1934 
					model.getSmartphoneSale(), model.getInsuranceSale(), model.getTotalSale(),
1935 
					String.format(timeString, now.format(timeFormatter)));
31169 tejbeer 1936 
			// notificationService.sendWhatsappMessage(whatsappMessageTemplate, title,
1937 
			// address.getPhoneNumber());
30982 tejbeer 1938 
 
24653 govind 1939 
		}
26945 amit.gupta 1940 
		// String saleReport = this.getDailySalesReportHtml(partnerSalesHeadersMap,
1941 
		// saleTargetReportModelMap);
31169 tejbeer 1942 
		this.getStateWiseSales(saleTargetReportModelMap, partnerSalesHeadersMap);
1943 
		/*
1944 
		 * String cc[] = { "tarun.verma@smartdukaan.com",
1945 
		 * "kamini.sharma@smartdukaan.com", "niranjan.kala@smartdukaan.com",
1946 
		 * "sm@smartdukaan.com" };
1947 
		 *
1948 
		 * String subject = String.format("Sale till %s", String.format(timeString,
1949 
		 * now.format(timeFormatter))); //
1950 
		 * this.sendMailOfHtmlFomat("amit.gupta@smartukaan.com", saleReport, cc, //
1951 
		 * subject); this.sendMailOfHtmlFormat("amit.gupta@smartdukaan.com",
1952 
		 * statewiseSaleReport, cc, "Statewise" + subject);
1953 
		 */
24653 govind 1954 
	}
1955 
 
28377 tejbeer 1956 
	public void checkRazorPayPaymentStatus() throws Exception {
28368 tejbeer 1957 
		List<PendingOrder> pendingOrder = pendingOrderRepository
1958 
				.selectAllByStatus(com.spice.profitmandi.dao.enumuration.transaction.OrderStatus.PENDING);
1959 
 
1960 
		for (PendingOrder po : pendingOrder) {
1961 
			RazorPay razorPay = razorPayRepository.selectByOrdeId(po.getId());
28377 tejbeer 1962 
			List<PendingOrderItem> poItems = pendingOrderItemRepository.selectByOrderId(po.getId());
28368 tejbeer 1963 
 
28369 tejbeer 1964 
			LOGGER.info("razorPay" + razorPay);
1965 
			if (razorPay != null) {
1966 
				List<Payment> payments = razorPaymentService.fetchOrderForPayment(razorPay.getRazorOrderId());
28377 tejbeer 1967 
 
28369 tejbeer 1968 
				if (!payments.isEmpty()) {
28377 tejbeer 1969 
					List<String> statusList = new ArrayList<>();
28369 tejbeer 1970 
					for (Payment payment : payments) {
28368 tejbeer 1971 
 
28377 tejbeer 1972 
						JSONObject jsonObj = new JSONObject(payment.toString());
1973 
 
1974 
						String status = jsonObj.getString("status");
1975 
 
1976 
						statusList.add(status);
1977 
 
28369 tejbeer 1978 
					}
28377 tejbeer 1979 
					LOGGER.info("statusList" + statusList);
28368 tejbeer 1980 
 
28377 tejbeer 1981 
					if (statusList.contains("authorized") || statusList.contains("captured")) {
1982 
						po.setStatus(com.spice.profitmandi.dao.enumuration.transaction.OrderStatus.PROCESSING);
1983 
						po.setPaidAmount(po.getTotalAmount());
1984 
						for (PendingOrderItem poi : poItems) {
1985 
							poi.setStatus(com.spice.profitmandi.dao.enumuration.transaction.OrderStatus.PROCESSING);
1986 
						}
1987 
						Map<String, Object> emailModel = pendingOrderService.sendCreateOrderMail(po);
1988 
 
1989 
						CustomRetailer customRetailer = retailerService.getFofoRetailer(po.getFofoId());
1990 
						Customer customer = customerRepository.selectById(po.getCustomerId());
1991 
						String[] customerEmail = null;
1992 
						if (customer.getEmailId() != null) {
30752 tejbeer 1993 
							customerEmail = new String[] { customer.getEmailId() };
28377 tejbeer 1994 
						}
1995 
						List<String> bccTo = Arrays.asList("kamini.sharma@smartdukaan.com",
28467 tejbeer 1996 
								"tarun.verma@smartdukaan.com", "niranjan.kala@smartdukaan.com", "sm@smartdukaan.com",
1997 
								"tejbeer.kaur@shop2020.in", customRetailer.getEmail());
28377 tejbeer 1998 
						List<String> authUserEmails = csService.getAuthUserByPartnerId(customRetailer.getPartnerId());
1999 
						if (authUserEmails != null) {
2000 
							authUserEmails = new ArrayList<>();
2001 
						}
2002 
						authUserEmails.addAll(bccTo);
2003 
 
28382 tejbeer 2004 
						// emailService.sendMailWithAttachments("Order Created with SmartDukaan",
2005 
						// "order-confirm.vm",
2006 
						// emailModel, customerEmail, null, authUserEmails.toArray(new String[0]));
28377 tejbeer 2007 
 
2008 
					} else if (statusList.contains("refunded") || statusList.contains("failed")) {
2009 
						for (PendingOrderItem poi : poItems) {
2010 
							poi.setStatus(com.spice.profitmandi.dao.enumuration.transaction.OrderStatus.FAILED);
2011 
						}
2012 
 
2013 
						po.setStatus(com.spice.profitmandi.dao.enumuration.transaction.OrderStatus.FAILED);
2014 
					}
2015 
 
28369 tejbeer 2016 
				}
28377 tejbeer 2017 
				// LOGGER.info("payment" + payments);
28369 tejbeer 2018 
 
2019 
			}
28368 tejbeer 2020 
		}
2021 
	}
2022 
 
25865 amit.gupta 2023 
	public static class SaleTargetReportModel {
2024 
		private double totalSale;
26941 amit.gupta 2025 
		private long totalQty;
26945 amit.gupta 2026 
		private double past3daysSale;
25880 amit.gupta 2027 
		private int fofoId;
2028 
 
2029 
		public int getFofoId() {
2030 
			return fofoId;
2031 
		}
2032 
 
2033 
		public void setFofoId(int fofoId) {
2034 
			this.fofoId = fofoId;
2035 
		}
2036 
 
25865 amit.gupta 2037 
		private double smartphoneSale;
2038 
		private long smartphoneQty;
2039 
		private double insuranceSale;
2040 
		private long insruanceQty;
2041 
 
26941 amit.gupta 2042 
		public long getTotalQty() {
2043 
			return totalQty;
2044 
		}
2045 
 
2046 
		public void setTotalQty(long totalQty) {
2047 
			this.totalQty = totalQty;
2048 
		}
2049 
 
26945 amit.gupta 2050 
		public double getPast3daysSale() {
2051 
			return past3daysSale;
2052 
		}
2053 
 
2054 
		public void setPast3daysSale(double past3daysSale) {
2055 
			this.past3daysSale = past3daysSale;
2056 
		}
2057 
 
25865 amit.gupta 2058 
		@Override
2059 
		public int hashCode() {
2060 
			final int prime = 31;
2061 
			int result = 1;
25880 amit.gupta 2062 
			result = prime * result + fofoId;
25865 amit.gupta 2063 
			result = prime * result + (int) (insruanceQty ^ (insruanceQty >>> 32));
2064 
			long temp;
2065 
			temp = Double.doubleToLongBits(insuranceSale);
2066 
			result = prime * result + (int) (temp ^ (temp >>> 32));
2067 
			result = prime * result + (int) (smartphoneQty ^ (smartphoneQty >>> 32));
2068 
			temp = Double.doubleToLongBits(smartphoneSale);
2069 
			result = prime * result + (int) (temp ^ (temp >>> 32));
26941 amit.gupta 2070 
			result = prime * result + (int) (totalQty ^ (totalQty >>> 32));
25865 amit.gupta 2071 
			temp = Double.doubleToLongBits(totalSale);
2072 
			result = prime * result + (int) (temp ^ (temp >>> 32));
2073 
			return result;
2074 
		}
2075 
 
2076 
		@Override
2077 
		public boolean equals(Object obj) {
2078 
			if (this == obj)
2079 
				return true;
2080 
			if (obj == null)
2081 
				return false;
2082 
			if (getClass() != obj.getClass())
2083 
				return false;
2084 
			SaleTargetReportModel other = (SaleTargetReportModel) obj;
25880 amit.gupta 2085 
			if (fofoId != other.fofoId)
2086 
				return false;
25865 amit.gupta 2087 
			if (insruanceQty != other.insruanceQty)
2088 
				return false;
2089 
			if (Double.doubleToLongBits(insuranceSale) != Double.doubleToLongBits(other.insuranceSale))
2090 
				return false;
2091 
			if (smartphoneQty != other.smartphoneQty)
2092 
				return false;
2093 
			if (Double.doubleToLongBits(smartphoneSale) != Double.doubleToLongBits(other.smartphoneSale))
2094 
				return false;
26941 amit.gupta 2095 
			if (totalQty != other.totalQty)
2096 
				return false;
25865 amit.gupta 2097 
			if (Double.doubleToLongBits(totalSale) != Double.doubleToLongBits(other.totalSale))
2098 
				return false;
2099 
			return true;
2100 
		}
2101 
 
2102 
		public double getTotalSale() {
2103 
			return totalSale;
2104 
		}
2105 
 
2106 
		public void setTotalSale(double totalSale) {
2107 
			this.totalSale = totalSale;
2108 
		}
2109 
 
2110 
		public double getSmartphoneSale() {
2111 
			return smartphoneSale;
2112 
		}
2113 
 
2114 
		public void setSmartphoneSale(double smartphoneSale) {
2115 
			this.smartphoneSale = smartphoneSale;
2116 
		}
2117 
 
2118 
		public long getSmartphoneQty() {
2119 
			return smartphoneQty;
2120 
		}
2121 
 
2122 
		public void setSmartphoneQty(long smartphoneQty) {
2123 
			this.smartphoneQty = smartphoneQty;
2124 
		}
2125 
 
2126 
		public double getInsuranceSale() {
2127 
			return insuranceSale;
2128 
		}
2129 
 
2130 
		public void setInsuranceSale(double insuranceSale) {
2131 
			this.insuranceSale = insuranceSale;
2132 
		}
2133 
 
2134 
		public long getInsruanceQty() {
2135 
			return insruanceQty;
2136 
		}
2137 
 
2138 
		public void setInsruanceQty(long insruanceQty) {
2139 
			this.insruanceQty = insruanceQty;
2140 
		}
2141 
 
2142 
		@Override
2143 
		public String toString() {
26945 amit.gupta 2144 
			return "SaleTargetReportModel [totalSale=" + totalSale + ", totalQty=" + totalQty + ", past3daysSale="
2145 
					+ past3daysSale + ", fofoId=" + fofoId + ", smartphoneSale=" + smartphoneSale + ", smartphoneQty="
2146 
					+ smartphoneQty + ", insuranceSale=" + insuranceSale + ", insruanceQty=" + insruanceQty + "]";
25865 amit.gupta 2147 
		}
2148 
 
2149 
	}
2150 
 
31169 tejbeer 2151 
	private void getStateWiseSales(Map<Integer, SaleTargetReportModel> saleTargetReportModelMap,
30752 tejbeer 2152 
			Map<Integer, FofoReportingModel> partnerSalesHeadersMap) throws Exception {
31169 tejbeer 2153 
		String timeString = "Today %s";
2154 
		LocalDateTime now = LocalDateTime.now();
25872 tejbeer 2155 
 
31169 tejbeer 2156 
		DateTimeFormatter timeFormatter = DateTimeFormatter.ofPattern("h:m a");
2157 
		List<Integer> categoryIds = Arrays.asList(ProfitMandiConstants.TICKET_CATEGORY_LOGISTICS,
2158 
				ProfitMandiConstants.TICKET_CATEGORY_FINANCIAL_SERVICES, ProfitMandiConstants.TICKET_CATEGORY_CATEGORY,
2159 
				ProfitMandiConstants.TICKET_CATEGORY_RBM, ProfitMandiConstants.TICKET_CATEGORY_SALES,
2160 
				ProfitMandiConstants.TICKET_CATEGORY_MARKETING, ProfitMandiConstants.TICKET_CATEGORY_ACCOUNTS,
2161 
				ProfitMandiConstants.TICKET_CATEGORY_BUSINESSINTELLIGENT,
2162 
				ProfitMandiConstants.TICKET_CATEGORY_TECHNOLOGY);
26945 amit.gupta 2163 
 
31518 amit.gupta 2164 
		Map<String, Set<Integer>> storeGuyMap = csService.getAuthUserPartnerIdMappingByCategoryIds(categoryIds, false);
30765 tejbeer 2165 
 
31169 tejbeer 2166 
		for (Entry<String, Set<Integer>> storeGuyEntry : storeGuyMap.entrySet()) {
2167 
			String email = storeGuyEntry.getKey();
2168 
			Set<Integer> fofoIds = storeGuyEntry.getValue();
2169 
			LOGGER.info("fofoIds {}", fofoIds);
24683 amit.gupta 2170 
 
31169 tejbeer 2171 
			if (!fofoIds.isEmpty()) {
2172 
				List<FofoStore> stores = fofoStoreRepository
2173 
						.selectActivePartnersByRetailerIds(new ArrayList<>(fofoIds));
26945 amit.gupta 2174 
 
31169 tejbeer 2175 
				Map<String, List<Integer>> stateMap = stores.stream().collect(Collectors.groupingBy(
2176 
						x -> x.getCode().substring(0, 2), Collectors.mapping(x -> x.getId(), Collectors.toList())));
2177 
				List<List<Serializable>> stateWiseSales = new ArrayList<>();
2178 
				for (Map.Entry<String, List<Integer>> stateMapEntry : stateMap.entrySet()) {
2179 
					long totalQty = stateMapEntry.getValue().stream()
2180 
							.collect(Collectors.summingLong(x -> saleTargetReportModelMap.get(x).getTotalQty()));
2181 
					double totalSale = stateMapEntry.getValue().stream()
2182 
							.collect(Collectors.summingDouble(x -> saleTargetReportModelMap.get(x).getTotalSale()));
2183 
					long smartPhoneQty = stateMapEntry.getValue().stream()
2184 
							.collect(Collectors.summingLong(x -> saleTargetReportModelMap.get(x).getSmartphoneQty()));
2185 
					double smartPhoneSale = stateMapEntry.getValue().stream().collect(
2186 
							Collectors.summingDouble(x -> saleTargetReportModelMap.get(x).getSmartphoneSale()));
2187 
					stateWiseSales.add(
2188 
							Arrays.asList(stateMapEntry.getKey(), smartPhoneQty, smartPhoneSale, totalQty, totalSale));
2189 
				}
2190 
				StringBuilder sb = new StringBuilder();
2191 
				sb.append("<html><body>");
2192 
				sb.append("<p>Statewise Sale Report:</p><br/><table style='border:1px solid black';cellspacing=0>");
2193 
				sb.append("<tbody>\n" + "	    <tr>"
2194 
						+ "	    					<th style='border:1px solid black;padding: 5px'>State</th>"
2195 
						+ "	    					<th style='border:1px solid black;padding: 5px'>SmartPhone Qty</th>"
2196 
						+ "	    					<th style='border:1px solid black;padding: 5px'>SmartPhone Value</th>"
2197 
						+ "	    					<th style='border:1px solid black;padding: 5px'>Total Qty</th>"
2198 
						+ "	    					<th style='border:1px solid black;padding: 5px'>Total Value</th>"
2199 
						+ "	    				</tr>");
2200 
				for (List<Serializable> stateSale : stateWiseSales) {
2201 
					sb.append("<tr>");
2202 
					sb.append("<td style='border:1px solid black;padding: 5px'>" + stateSale.get(0) + "</td>");
2203 
					sb.append("<td style='border:1px solid black;padding: 5px'>" + stateSale.get(1) + "</td>");
2204 
					sb.append("<td style='border:1px solid black;padding: 5px'>" + stateSale.get(2) + "</td>");
2205 
					sb.append("<td style='border:1px solid black;padding: 5px'>" + stateSale.get(3) + "</td>");
2206 
					sb.append("<td style='border:1px solid black;padding: 5px'>" + stateSale.get(4) + "</td>");
2207 
					sb.append("</tr>");
2208 
				}
2209 
				sb.append("</tbody></table><br><br>");
26945 amit.gupta 2210 
 
31169 tejbeer 2211 
				sb.append("<p>Sale Report:</p><br/><table style='border:1px solid black';cellspacing=0>");
2212 
				sb.append("<tbody>\n" + "	    				<tr>\n"
2213 
						+ "	    					<th style='border:1px solid black;padding: 5px'>Code</th>"
2214 
						+ "	    					<th style='border:1px solid black;padding: 5px'>Business Name</th>"
2215 
						+ "	    					<th style='border:1px solid black;padding: 5px'>Regional Manager</th>"
2216 
						+ "	    					<th style='border:1px solid black;padding: 5px'>Territory Manager</th>"
2217 
						+ "	    					<th style='border:1px solid black;padding: 5px'>Sale</th>"
2218 
						+ "	    					<th style='border:1px solid black;padding: 5px'>Smartphone Sale</th>"
2219 
						+ "	    					<th style='border:1px solid black;padding: 5px'>SmartPhone Qty</th>"
2220 
						+ "	    				</tr>");
2221 
 
2222 
				/*
2223 
				 * List<Integer> sortedPartnerSalesHeaders =
2224 
				 * partnerSalesHeadersMap.values().stream()
2225 
				 * .sorted(Comparator.comparing(FofoReportingModel::getCode)
2226 
				 * .thenComparing(FofoReportingModel::getRegionalManager)
2227 
				 * .thenComparing(FofoReportingModel::getTerritoryManager))
2228 
				 * .map(FofoReportingModel::getFofoId).collect(Collectors.toList());
2229 
				 */
2230 
 
2231 
				List<Integer> sortedSaleTargetReport = saleTargetReportModelMap.values().stream()
2232 
						.filter(x -> fofoIds.contains(x.getFofoId()))
2233 
						.sorted(Comparator.comparing(SaleTargetReportModel::getTotalSale))
2234 
						.map(SaleTargetReportModel::getFofoId).collect(Collectors.toList());
2235 
				for (Integer fofoId : sortedSaleTargetReport) {
2236 
					if (saleTargetReportModelMap.get(fofoId).getPast3daysSale() == 0) {
2237 
						sb.append("<tr style='background-color:red'>");
2238 
					} else {
2239 
						sb.append("<tr>");
2240 
					}
2241 
					sb.append("<td style='border:1px solid black;padding: 5px'>"
2242 
							+ partnerSalesHeadersMap.get(fofoId).getCode() + "</td>");
2243 
					sb.append("<td style='border:1px solid black;padding: 5px'>"
2244 
							+ partnerSalesHeadersMap.get(fofoId).getBusinessName() + "</td>");
2245 
					sb.append("<td style='border:1px solid black;padding: 5px'>"
2246 
							+ partnerSalesHeadersMap.get(fofoId).getRegionalManager() + "</td>");
2247 
					sb.append("<td style='border:1px solid black;padding: 5px'>"
2248 
							+ partnerSalesHeadersMap.get(fofoId).getTerritoryManager() + "</td>");
2249 
					sb.append("<td style='border:1px solid black;padding: 5px'>"
2250 
							+ saleTargetReportModelMap.get(fofoId).getTotalSale() + "</td>");
2251 
					sb.append("<td style='border:1px solid black;padding: 5px'>"
2252 
							+ saleTargetReportModelMap.get(fofoId).getSmartphoneSale() + "</td>");
2253 
					sb.append("<td style='border:1px solid black;padding: 5px'>"
2254 
							+ saleTargetReportModelMap.get(fofoId).getSmartphoneQty() + "</td>");
2255 
					sb.append("</tr>");
2256 
				}
2257 
 
2258 
				sb.append("</tr>");
2259 
 
2260 
				sb.append("</body></html>");
2261 
 
2262 
				String statewiseSaleReport = sb.toString();
2263 
 
2264 
				String subject = String.format("Sale till %s", String.format(timeString, now.format(timeFormatter)));
2265 
				// this.sendMailOfHtmlFomat("amit.gupta@smartukaan.com", saleReport, cc,
2266 
				// subject);
2267 
				this.sendMailOfHtmlFormat(email, statewiseSaleReport, null, "Statewise" + subject);
2268 
			}
2269 
		}
24653 govind 2270 
	}
24841 govind 2271 
 
26945 amit.gupta 2272 
	private void sendMailOfHtmlFormat(String email, String body, String cc[], String subject)
24841 govind 2273 
			throws MessagingException, ProfitMandiBusinessException, IOException {
2274 
		MimeMessage message = mailSender.createMimeMessage();
2275 
		MimeMessageHelper helper = new MimeMessageHelper(message);
2276 
		helper.setSubject(subject);
2277 
		helper.setText(body, true);
2278 
		helper.setTo(email);
2279 
		if (cc != null) {
2280 
			helper.setCc(cc);
2281 
		}
2282 
		InternetAddress senderAddress = new InternetAddress("noreply@smartdukaan.com", "Smart Dukaan");
2283 
		helper.setFrom(senderAddress);
2284 
		mailSender.send(message);
2285 
	}
25300 tejbeer 2286 
 
25351 tejbeer 2287 
	public void sendNotification() throws Exception {
25300 tejbeer 2288 
		List<PushNotifications> pushNotifications = pushNotificationRepository.selectAllByTimestamp();
2289 
		if (!pushNotifications.isEmpty()) {
2290 
			for (PushNotifications pushNotification : pushNotifications) {
25351 tejbeer 2291 
				Device device = deviceRepository.selectById(pushNotification.getDeviceId());
25300 tejbeer 2292 
				NotificationCampaign notificationCampaign = notificationCampaignRepository
2293 
						.selectById(pushNotification.getNotificationCampaignid());
2294 
				SimpleCampaignParams scp = gson.fromJson(notificationCampaign.getImplementationParams(),
2295 
						SimpleCampaignParams.class);
2296 
				Campaign campaign = new SimpleCampaign(scp);
25351 tejbeer 2297 
				String result_url = campaign.getUrl() + "&user_id=" + device.getUser_id();
25300 tejbeer 2298 
				JSONObject json = new JSONObject();
25351 tejbeer 2299 
				json.put("to", device.getFcmId());
25300 tejbeer 2300 
				JSONObject jsonObj = new JSONObject();
2301 
				jsonObj.put("message", campaign.getMessage());
2302 
				jsonObj.put("title", campaign.getTitle());
2303 
				jsonObj.put("type", campaign.getType());
2304 
				jsonObj.put("url", result_url);
2305 
				jsonObj.put("time_to_live", campaign.getExpireTimestamp());
2306 
				jsonObj.put("image", campaign.getImageUrl());
2307 
				jsonObj.put("largeIcon", "large_icon");
2308 
				jsonObj.put("smallIcon", "small_icon");
2309 
				jsonObj.put("vibrate", 1);
2310 
				jsonObj.put("pid", pushNotification.getId());
2311 
				jsonObj.put("sound", 1);
2312 
				jsonObj.put("priority", "high");
2313 
				json.put("data", jsonObj);
25351 tejbeer 2314 
				try {
2315 
					CloseableHttpClient client = HttpClients.createDefault();
2316 
					HttpPost httpPost = new HttpPost(FCM_URL);
25300 tejbeer 2317 
 
25351 tejbeer 2318 
					httpPost.setHeader("Content-Type", "application/json; utf-8");
2319 
					httpPost.setHeader("authorization", "key=" + FCM_API_KEY);
2320 
					StringEntity entity = new StringEntity(json.toString());
2321 
					httpPost.setEntity(entity);
2322 
					CloseableHttpResponse response = client.execute(httpPost);
25300 tejbeer 2323 
 
25351 tejbeer 2324 
					if (response.getStatusLine().getStatusCode() == 200) {
2325 
						pushNotification.setSentTimestamp(LocalDateTime.now());
2326 
					} else {
25356 tejbeer 2327 
						pushNotification.setSentTimestamp(LocalDateTime.of(1970, 1, 1, 00, 00));
25778 amit.gupta 2328 
						LOGGER.info("message" + "not sent");
26945 amit.gupta 2329 
						response.toString();
25351 tejbeer 2330 
					}
25300 tejbeer 2331 
 
25351 tejbeer 2332 
				} catch (Exception e) {
2333 
					e.printStackTrace();
26443 amit.gupta 2334 
					pushNotification.setSentTimestamp(LocalDateTime.of(1970, 1, 1, 00, 00));
26436 amit.gupta 2335 
					LOGGER.info("message " + "not sent " + e.getMessage());
25300 tejbeer 2336 
				}
2337 
			}
2338 
		}
2339 
	}
2340 
 
25553 amit.gupta 2341 
	public void grouping() throws Exception {
25609 amit.gupta 2342 
		DateTimeFormatter dtf = DateTimeFormatter.ofPattern("MM-dd-yyyy hh:mm");
2343 
		List<PriceDropIMEI> priceDropImeis = priceDropIMEIRepository.selectByStatus(PriceDropImeiStatus.APPROVED);
2344 
		System.out.println(String.join("\t",
2345 
				Arrays.asList("IMEI", "ItemId", "Brand", "Model Name", "Model Number", "Franchise Id", "Franchise Name",
25694 amit.gupta 2346 
						"Grn On", "Price Dropped On", "Approved On", "Returned On", "Price Drop Paid", "Is Doa")));
26963 amit.gupta 2347 
		Map<Integer, CustomRetailer> retailersMap = retailerService.getFofoRetailers(false);
25609 amit.gupta 2348 
		for (PriceDropIMEI priceDropIMEI : priceDropImeis) {
25694 amit.gupta 2349 
			if (priceDropIMEI.getPartnerId() == 0)
2350 
				continue;
25609 amit.gupta 2351 
			HashSet<String> imeis = new HashSet<>();
2352 
			PriceDrop priceDrop = priceDropRepository.selectById(priceDropIMEI.getPriceDropId());
2353 
			imeis.add(priceDropIMEI.getImei());
2354 
			List<InventoryItem> inventoryItems = inventoryItemRepository
2355 
					.selectByFofoIdSerialNumbers(priceDropIMEI.getPartnerId(), imeis, false);
25694 amit.gupta 2356 
			if (inventoryItems.size() == 0) {
2357 
				LOGGER.info("Need to investigate partnerId - {} imeis - {}", priceDropIMEI.getPartnerId(), imeis);
25613 amit.gupta 2358 
				continue;
25612 amit.gupta 2359 
			}
25609 amit.gupta 2360 
			InventoryItem inventoryItem = inventoryItems.get(0);
2361 
			CustomRetailer customRetailer = retailersMap.get(inventoryItem.getFofoId());
2362 
			if (inventoryItem.getLastScanType().equals(ScanType.DOA_OUT)
2363 
					|| inventoryItem.getLastScanType().equals(ScanType.PURCHASE_RET)) {
2364 
				// check if pricedrop has been rolled out
2365 
				List<UserWalletHistory> uwh = walletService.getAllByReference(inventoryItem.getFofoId(),
2366 
						priceDropIMEI.getPriceDropId(), WalletReferenceType.PRICE_DROP);
2367 
				if (uwh.size() > 0) {
25615 amit.gupta 2368 
					Item item = itemRepository.selectById(inventoryItem.getItemId());
30965 tejbeer 2369 
					System.out.println(String.join("\t",
2370 
							Arrays.asList(priceDropIMEI.getImei(), inventoryItem.getItemId() + "", item.getBrand(),
2371 
									item.getModelName(), item.getModelNumber(), inventoryItem.getFofoId() + "",
2372 
									customRetailer.getBusinessName(), inventoryItem.getCreateTimestamp().format(dtf),
2373 
									priceDrop.getAffectedOn().format(dtf),
2374 
									priceDropIMEI.getUpdateTimestamp().format(dtf),
2375 
									inventoryItem.getUpdateTimestamp().format(dtf),
2376 
									priceDrop.getAutoPartnerPayout(inventoryItem.getUpdateTimestamp()) + "",
2377 
									inventoryItem.getLastScanType().equals(ScanType.DOA_OUT) + "")));
25609 amit.gupta 2378 
				}
2379 
			}
2380 
		}
25503 amit.gupta 2381 
	}
29668 tejbeer 2382 
 
29566 amit.gupta 2383 
	public void toffeeRollback() throws Exception {
2384 
		toffeeService.cancelPolicyCopy("110143521986");
2385 
		toffeeService.getOrderId("110143521986");
2386 
	}
25694 amit.gupta 2387 
 
27686 amit.gupta 2388 
	public void attachToffeeInvoices() throws Exception {
28205 tejbeer 2389 
		List<InsurancePolicy> insurancePolicies = insurancePolicyRepository.selectAllByProviderId(3,
2390 
				Optional.of(false));
2391 
		for (InsurancePolicy insurancePolicy : insurancePolicies) {
27678 amit.gupta 2392 
			String invoiceNumber = insurancePolicy.getInvoiceNumber();
2393 
			FofoOrder fofoOrder = fofoOrderRepository.selectByInvoiceNumber(invoiceNumber);
30321 amit.gupta 2394 
			InvoicePdfModel pdfModel = orderService.getInvoicePdfModel(fofoOrder.getId());
27678 amit.gupta 2395 
			java.io.ByteArrayOutputStream byteArrayOutputStream = new java.io.ByteArrayOutputStream();
2396 
			PdfUtils.generateAndWrite(Arrays.asList(pdfModel), byteArrayOutputStream);
28205 tejbeer 2397 
			String pdfInvoiceString = "data:application/pdf;base64,"
2398 
					+ Base64.getEncoder().encodeToString(byteArrayOutputStream.toByteArray());
2399 
			boolean attached = toffeeService.attachInvoice(insurancePolicy.getPolicyNumber().split("#")[1],
2400 
					pdfInvoiceString);
2401 
			if (attached) {
27678 amit.gupta 2402 
				insurancePolicy.setPosted(true);
2403 
			}
2404 
		}
25694 amit.gupta 2405 
	}
2406 
 
30858 amit.gupta 2407 
	public void sendBAGPendingPolicies() throws Exception {
2408 
		List<InsurancePolicy> insurancePolicies = insurancePolicyRepository.selectAllByProviderId(4,
2409 
				Optional.of(false));
2410 
		for (InsurancePolicy insurancePolicy : insurancePolicies) {
2411 
			String invoiceNumber = insurancePolicy.getInvoiceNumber();
2412 
			FofoOrder fofoOrder = fofoOrderRepository.selectByInvoiceNumber(invoiceNumber);
2413 
			FofoOrderItem fofoOrderItem = fofoOrderItemRepository.selectByOrderId(fofoOrder.getId()).get(0);
2414 
			CustomerAddress customerAddress = customerAddressRepository.selectById(fofoOrder.getCustomerAddressId());
2415 
			Customer customer = customerRepository.selectById(fofoOrder.getCustomerId());
2416 
			BAGInsuranceModel bagInsuranceModel = new BAGInsuranceModel();
30913 tejbeer 2417 
			// bagInsuranceModel.setModelId();
30858 amit.gupta 2418 
			bagInsuranceModel.setAddressLine1(customerAddress.getLine1());
2419 
			bagInsuranceModel.setAddressLine2(customerAddress.getLine2());
2420 
			bagInsuranceModel.setCity(customerAddress.getCity());
2421 
			bagInsuranceModel.setBrandWarranty("1 Year");
2422 
			Item item = itemRepository.selectById(fofoOrderItem.getId());
2423 
			bagInsuranceModel.setModelName(item.getItemDescription());
2424 
			bagInsuranceModel.setDateOfPurchase(fofoOrder.getFormattedDate());
2425 
			bagInsuranceModel.setEmail(customer.getEmailId());
2426 
			bagInsuranceModel.setImei1(insurancePolicy.getSerialNumber());
2427 
			bagInsuranceModel.setFirstName(customer.getFirstName());
2428 
			bagInsuranceModel.setLastName(customer.getLastName());
2429 
			bagInsuranceModel.setMobileNumber(customer.getMobileNumber());
2430 
			bagInsuranceModel.setPlanId("");
2431 
			insurancePolicy.setPosted(true);
2432 
		}
2433 
	}
2434 
 
25694 amit.gupta 2435 
	public void schemeRollback(List<String> schemeIds) throws Exception {
2436 
		List<Integer> schemeIdsInt = schemeIds.stream().map(x -> Integer.parseInt(x)).collect(Collectors.toList());
25708 amit.gupta 2437 
		Map<Integer, Scheme> schemesMap = schemeRepository.selectBySchemeIds(schemeIdsInt, 0, schemeIds.size()).stream()
25694 amit.gupta 2438 
				.collect(Collectors.toMap(x -> x.getId(), x -> x));
2439 
		List<SchemeInOut> schemeInOuts = schemeInOutRepository.selectBySchemeIds(new HashSet<>(schemeIdsInt));
2440 
		for (SchemeInOut sio : schemeInOuts) {
2441 
			Scheme scheme = schemesMap.get(sio.getSchemeId());
2442 
			if (scheme.getType().equals(SchemeType.IN)) {
2443 
 
2444 
			} else if (scheme.getType().equals(SchemeType.OUT)) {
2445 
				InventoryItem inventoryItem = inventoryItemRepository.selectById(sio.getInventoryItemId());
2446 
				List<ScanRecord> sr = scanRecordRepository.selectByInventoryItemId(sio.getInventoryItemId());
2447 
				ScanRecord scanRecord = sr.stream().filter(x -> x.getType().equals(ScanType.SALE))
2448 
						.max((x1, x2) -> x1.getCreateTimestamp().compareTo(x2.getCreateTimestamp())).get();
2449 
				if (scanRecord.getCreateTimestamp().isAfter(scheme.getEndDateTime())
2450 
						|| scanRecord.getCreateTimestamp().isBefore(scheme.getStartDateTime())) {
2451 
					sio.setRolledBackTimestamp(LocalDateTime.now());
2452 
					FofoOrder fofoOrder = fofoOrderRepository.selectByOrderId(scanRecord.getOrderId());
25709 amit.gupta 2453 
					String rollbackReason = "Scheme reversed for "
2454 
							+ itemRepository.selectById(inventoryItem.getItemId()).getItemDescription() + "/Inv - "
25694 amit.gupta 2455 
							+ fofoOrder.getInvoiceNumber();
2456 
					walletService.rollbackAmountFromWallet(scanRecord.getFofoId(), sio.getAmount(),
26945 amit.gupta 2457 
							scanRecord.getOrderId(), WalletReferenceType.SCHEME_OUT, rollbackReason,
2458 
							LocalDateTime.now());
25694 amit.gupta 2459 
					System.out.printf("Amount %f,SchemeId %d,Reason %s\n", sio.getAmount(), sio.getSchemeId(),
2460 
							rollbackReason);
2461 
				}
2462 
			}
2463 
		}
25721 tejbeer 2464 
		// throw new Exception();
25694 amit.gupta 2465 
	}
25721 tejbeer 2466 
 
2467 
	public void checkfocusedModelInPartnerStock() throws Exception {
2468 
 
2469 
		List<Integer> fofoIds = fofoStoreRepository.selectAll().stream().filter(x -> x.isActive()).map(x -> x.getId())
2470 
				.collect(Collectors.toList());
27212 tejbeer 2471 
		Map<Integer, Map<Integer, List<SaholicCIS>>> warehouseItemAvailabilityMap = saholicInventoryService
2472 
				.getSaholicStock();
27213 tejbeer 2473 
		Map<Integer, String> warehouseMap = ProfitMandiConstants.WAREHOUSE_MAP;
2474 
		Map<Integer, FofoReportingModel> partnerIdSalesHeadersMap = this.getPartnerIdSalesHeaders();
27212 tejbeer 2475 
 
2476 
		Map<Integer, Map<Integer, List<SaholicPOItem>>> warehousePoItemAvailabilityMap = saholicInventoryService
2477 
				.getSaholicPOItems();
25721 tejbeer 2478 
		Map<Integer, List<FocusedModelShortageModel>> focusedModelShortageReportMap = new HashMap<>();
2479 
		for (Integer fofoId : fofoIds) {
27102 amit.gupta 2480 
			List<FocusedModelShortageModel> focusedModelShortageList = new ArrayList<>();
2481 
			focusedModelShortageReportMap.put(fofoId, focusedModelShortageList);
25721 tejbeer 2482 
			CustomRetailer customRetailer = retailerService.getFofoRetailer(fofoId);
2483 
			Map<Integer, Integer> processingOrderMap = null;
2484 
			Map<Integer, Integer> catalogIdAndQtyMap = null;
2485 
			Map<Integer, Integer> grnPendingOrdersMap = null;
2486 
 
2487 
			Map<Integer, Integer> currentInventorySnapshot = currentInventorySnapshotRepository.selectByFofoId(fofoId)
2488 
					.stream().collect(Collectors.toMap(x -> x.getItemId(), x -> x.getAvailability()));
2489 
 
2490 
			if (!currentInventorySnapshot.isEmpty()) {
2491 
				catalogIdAndQtyMap = itemRepository.selectByIds(currentInventorySnapshot.keySet()).stream()
2492 
						.collect(Collectors.groupingBy(x -> x.getCatalogItemId(),
2493 
								Collectors.summingInt(x -> currentInventorySnapshot.get(x.getId()))));
2494 
 
2495 
			}
2496 
 
2497 
			Map<Integer, Integer> grnPendingOrders = orderRepository.selectPendingGrnOrders(fofoId).stream()
2498 
					.collect(Collectors.groupingBy(x -> x.getLineItem().getItemId(),
2499 
							Collectors.summingInt(x -> x.getLineItem().getQuantity())));
2500 
			if (!grnPendingOrders.isEmpty()) {
2501 
				grnPendingOrdersMap = itemRepository.selectByIds(grnPendingOrders.keySet()).stream()
2502 
						.collect(Collectors.groupingBy(x -> x.getCatalogItemId(),
2503 
								Collectors.summingInt(x -> grnPendingOrders.get(x.getId()))));
2504 
 
2505 
			}
2506 
 
2507 
			Map<Integer, Integer> processingOrder = orderRepository.selectOrders(fofoId, orderStatusList).stream()
2508 
					.collect(Collectors.groupingBy(x -> x.getLineItem().getItemId(),
2509 
							Collectors.summingInt(x -> x.getLineItem().getQuantity())));
2510 
			if (!processingOrder.isEmpty()) {
2511 
				processingOrderMap = itemRepository.selectByIds(processingOrder.keySet()).stream()
2512 
						.collect(Collectors.groupingBy(x -> x.getCatalogItemId(),
2513 
								Collectors.summingInt(x -> processingOrder.get(x.getId()))));
2514 
 
2515 
			}
2516 
 
25800 tejbeer 2517 
			List<String> brands = mongoClient.getMongoBrands(fofoId, null, 3).stream().map(x -> (String) x.get("name"))
2518 
					.collect(Collectors.toList());
2519 
 
27088 tejbeer 2520 
			List<Integer> regionIds = partnerRegionRepository.selectByfofoId(fofoId).stream().map(x -> x.getRegionId())
2521 
					.collect(Collectors.toList());
27095 tejbeer 2522 
			LOGGER.info("regionIds" + regionIds);
27102 amit.gupta 2523 
			if (regionIds.size() == 0) {
2524 
				LOGGER.info("No region found for partner {}", fofoId);
2525 
				continue;
2526 
			}
27100 amit.gupta 2527 
			Map<Integer, Optional<Integer>> focusedCatalogIdAndQtyMap = focusedModelRepository
27102 amit.gupta 2528 
					.selectAllByRegionIds(regionIds).stream().collect(Collectors.groupingBy(FocusedModel::getCatalogId,
29668 tejbeer 2529 
							Collectors.mapping(FocusedModel::getObsMinimumQty, Collectors.maxBy(Integer::compareTo))));
25800 tejbeer 2530 
 
25721 tejbeer 2531 
			LOGGER.info("focusedCatalogIdAndQtyMap" + focusedCatalogIdAndQtyMap);
2532 
 
27100 amit.gupta 2533 
			for (Map.Entry<Integer, Optional<Integer>> entry : focusedCatalogIdAndQtyMap.entrySet()) {
2534 
				int minQty = entry.getValue().get();
25721 tejbeer 2535 
				int inStockQty = 0;
2536 
				int processingQty = 0;
2537 
				int grnPendingQty = 0;
27208 tejbeer 2538 
				int allColorNetAvailability = 0;
27253 tejbeer 2539 
				int allColorPoAvailability = 0;
25721 tejbeer 2540 
				if (processingOrderMap != null) {
2541 
					processingQty = (processingOrderMap.get(entry.getKey()) == null) ? 0
2542 
							: processingOrderMap.get(entry.getKey());
2543 
 
2544 
				}
2545 
				if (grnPendingOrdersMap != null) {
2546 
					grnPendingQty = (grnPendingOrdersMap.get(entry.getKey()) == null) ? 0
2547 
							: grnPendingOrdersMap.get(entry.getKey());
2548 
 
2549 
				}
2550 
				if (catalogIdAndQtyMap != null) {
2551 
					inStockQty = (catalogIdAndQtyMap.get(entry.getKey()) == null) ? 0
2552 
							: catalogIdAndQtyMap.get(entry.getKey());
2553 
 
2554 
				}
28526 tejbeer 2555 
 
2556 
				int grnStockQty = grnPendingQty + inStockQty;
25721 tejbeer 2557 
				int totalQty = processingQty + grnPendingQty + inStockQty;
2558 
 
29801 manish 2559 
				int shortageQty = minQty - totalQty;
31328 amit.gupta 2560 
				List<Item> items = itemRepository.selectAllByCatalogItemId(entry.getKey());
31388 amit.gupta 2561 
 
2562 
				TagListing tagListing = tagListingRepository.selectByCatalogId(entry.getKey());
2563 
 
29801 manish 2564 
				FofoStore fofoStore = fofoStoreRepository.selectByRetailerId(fofoId);
25721 tejbeer 2565 
 
29801 manish 2566 
				Map<Integer, List<SaholicCIS>> itemAvailabilityMap = warehouseItemAvailabilityMap
2567 
						.get(fofoStore.getWarehouseId());
27213 tejbeer 2568 
 
29801 manish 2569 
				Map<Integer, List<SaholicPOItem>> poItemAvailabilityMap = warehousePoItemAvailabilityMap
2570 
						.get(fofoStore.getWarehouseId());
25721 tejbeer 2571 
 
31328 amit.gupta 2572 
				for (Item item : items) {
29801 manish 2573 
					List<SaholicCIS> currentAvailability = null;
2574 
					List<SaholicPOItem> poItemAvailability = null;
2575 
					if (itemAvailabilityMap != null) {
31328 amit.gupta 2576 
						currentAvailability = itemAvailabilityMap.get(item.getId());
29801 manish 2577 
					}
27208 tejbeer 2578 
 
29801 manish 2579 
					if (poItemAvailabilityMap != null) {
31328 amit.gupta 2580 
						poItemAvailability = poItemAvailabilityMap.get(item.getId());
29801 manish 2581 
					}
2582 
					if (currentAvailability != null) {
2583 
						allColorNetAvailability += currentAvailability.stream()
2584 
								.collect(Collectors.summingInt(SaholicCIS::getNetavailability));
2585 
					}
28528 tejbeer 2586 
 
29801 manish 2587 
					if (poItemAvailability != null) {
2588 
						allColorPoAvailability += poItemAvailability.stream()
2589 
								.collect(Collectors.summingInt(SaholicPOItem::getUnfulfilledQty));
27208 tejbeer 2590 
					}
2591 
 
25721 tejbeer 2592 
				}
2593 
 
29801 manish 2594 
				FocusedModelShortageModel fm = new FocusedModelShortageModel();
2595 
				fm.setFofoId(fofoId);
2596 
				fm.setStoreCode(fofoStore.getCode());
2597 
				fm.setStoreName(customRetailer.getBusinessName());
31328 amit.gupta 2598 
				fm.setBrandName(items.get(0).getBrand());
2599 
				fm.setModelName(items.get(0).getModelName());
2600 
				fm.setModelNumber(items.get(0).getModelNumber());
29801 manish 2601 
				fm.setGrnStockQty(grnStockQty);
2602 
				fm.setPendingIndentQty(processingQty);
2603 
				fm.setShortageQty(shortageQty);
31388 amit.gupta 2604 
				fm.setPoAvailability(allColorPoAvailability);
2605 
				fm.setDp(tagListing.getSellingPrice());
29801 manish 2606 
				fm.setWarehouseName(warehouseMap.get(customRetailer.getWarehouseId()));
2607 
				fm.setStateManager(partnerIdSalesHeadersMap.get(fofoId).getRegionalManager());
2608 
				fm.setTerritoryManager(partnerIdSalesHeadersMap.get(fofoId).getTerritoryManager());
31328 amit.gupta 2609 
				fm.setItemName(items.get(0).getBrand() + items.get(0).getModelNumber() + items.get(0).getModelName());
31388 amit.gupta 2610 
				fm.setAvailability(allColorNetAvailability);
27233 tejbeer 2611 
 
29801 manish 2612 
				focusedModelShortageList.add(fm);
2613 
			}
2614 
 
25721 tejbeer 2615 
		}
27102 amit.gupta 2616 
		if (!focusedModelShortageReportMap.isEmpty()) {
25800 tejbeer 2617 
			String fileName = "Stock Alert-" + FormattingUtils.formatDate(LocalDateTime.now()) + ".csv";
30215 amit.gupta 2618 
			Map<String, Set<Integer>> storeGuyMap = csService.getAuthUserPartnerIdMapping();
25837 amit.gupta 2619 
			Map<String, List<List<?>>> emailRowsMap = new HashMap<>();
25721 tejbeer 2620 
 
25800 tejbeer 2621 
			focusedModelShortageReportMap.entrySet().forEach(x -> {
2622 
				storeGuyMap.entrySet().forEach(y -> {
2623 
 
2624 
					if (y.getValue().contains(x.getKey())) {
2625 
						if (!emailRowsMap.containsKey(y.getKey())) {
2626 
							emailRowsMap.put(y.getKey(), new ArrayList<>());
2627 
						}
27208 tejbeer 2628 
						List<List<? extends Serializable>> fms = x.getValue().stream()
2629 
								.map(r -> Arrays.asList(r.getStoreCode(), r.getStoreName(), r.getBrandName(),
31604 tejbeer 2630 
										r.getModelName(), r.getModelNumber(), r.getDp(), r.getWarehouseName(),
2631 
										r.getStateManager(), r.getTerritoryManager(), r.getPendingIndentQty(),
2632 
										r.getGrnStockQty(), r.getShortageQty(), r.getAvailability()))
25800 tejbeer 2633 
								.collect(Collectors.toList());
2634 
						emailRowsMap.get(y.getKey()).addAll(fms);
2635 
 
25721 tejbeer 2636 
					}
2637 
 
25800 tejbeer 2638 
				});
25721 tejbeer 2639 
 
2640 
			});
2641 
 
31604 tejbeer 2642 
			List<String> headers = Arrays.asList("Store Code", "Store Name", "Brand", "Model Name", "Model Number",
2643 
					"DP", "Warehouse Name", "State Manager", "Territory Manager", "Pending Indent", "InStock",
2644 
					"Shortage Qty", "Availability");
25837 amit.gupta 2645 
			emailRowsMap.entrySet().forEach(entry -> {
25721 tejbeer 2646 
 
25800 tejbeer 2647 
				ByteArrayOutputStream baos = null;
2648 
				try {
25837 amit.gupta 2649 
					baos = FileUtil.getCSVByteStream(headers, entry.getValue());
25800 tejbeer 2650 
				} catch (Exception e2) {
2651 
					e2.printStackTrace();
2652 
				}
30752 tejbeer 2653 
				String[] sendToArray = new String[] {
28526 tejbeer 2654 
 
29996 tejbeer 2655 
						entry.getKey()
29995 tejbeer 2656 
 
2657 
				};
2658 
 
25800 tejbeer 2659 
				try {
2660 
					Utils.sendMailWithAttachment(googleMailSender, sendToArray, null, "Stock Alert", "PFA", fileName,
2661 
							new ByteArrayResource(baos.toByteArray()));
2662 
				} catch (Exception e1) { // TODO Auto-generated catch block
2663 
					e1.printStackTrace();
2664 
				}
25721 tejbeer 2665 
 
25800 tejbeer 2666 
			});
2667 
		}
25721 tejbeer 2668 
	}
2669 
 
2670 
	private String getNotificationMessage(List<FocusedModelShortageModel> focusedModelShortageModel) {
2671 
		StringBuilder sb = new StringBuilder();
2672 
		sb.append("Focused Model Shortage in Your Stock : \n");
2673 
		for (FocusedModelShortageModel entry : focusedModelShortageModel) {
2674 
 
2675 
			sb.append(entry.getItemName() + "-" + entry.getShortageQty());
2676 
			sb.append(String.format("%n", ""));
2677 
		}
2678 
		return sb.toString();
2679 
	}
2680 
 
2681 
	private void sendMailWithAttachments(String subject, String messageText, String email) throws Exception {
2682 
		MimeMessage message = mailSender.createMimeMessage();
2683 
		MimeMessageHelper helper = new MimeMessageHelper(message, true);
2684 
 
2685 
		helper.setSubject(subject);
2686 
		helper.setText(messageText, true);
2687 
		helper.setTo(email);
27116 amit.gupta 2688 
		InternetAddress senderAddress = new InternetAddress("noreply@smartdukaan.com", "Smartdukaan Alerts");
25721 tejbeer 2689 
		helper.setFrom(senderAddress);
2690 
		mailSender.send(message);
2691 
 
2692 
	}
2693 
 
2694 
	private String getMessage(List<FocusedModelShortageModel> focusedModelShortageModel) {
2695 
		StringBuilder sb = new StringBuilder();
2696 
		sb.append("<html><body><p>Alert</p><p>Focused Model Shortage in Your Stock:-</p>"
2697 
				+ "<br/><table style='border:1px solid black ;padding: 5px';>");
2698 
		sb.append("<tbody>\n" + "	    				<tr>\n"
2699 
				+ "	    					<th style='border:1px solid black;padding: 5px'>Item</th>\n"
2700 
				+ "	    					<th style='border:1px solid black;padding: 5px'>Shortage Qty</th>\n"
2701 
				+ "	    				</tr>");
2702 
		for (FocusedModelShortageModel entry : focusedModelShortageModel) {
2703 
 
2704 
			sb.append("<tr>");
2705 
			sb.append("<td style='border:1px solid black;padding: 5px'>" + entry.getItemName() + "</td>");
2706 
 
2707 
			sb.append("<td style='border:1px solid black;padding: 5px'>" + entry.getShortageQty() + "</td>");
2708 
 
2709 
			sb.append("</tr>");
2710 
 
2711 
		}
2712 
 
2713 
		sb.append("</tbody></table></body></html>");
2714 
 
2715 
		return sb.toString();
2716 
	}
2717 
 
25927 amit.gupta 2718 
	public void notifyLead() throws Exception {
29488 manish 2719 
		List<Lead> leadsToNotify = leadRepository.selectLeadsScheduledBetweenDate(null,
2720 
				LocalDateTime.now().minusDays(15), LocalDateTime.now().plusHours(4));
25927 amit.gupta 2721 
		Map<Integer, String> authUserEmailMap = authRepository.selectAllActiveUser().stream()
2722 
				.collect(Collectors.toMap(x -> x.getId(), x -> x.getEmailId()));
27477 amit.gupta 2723 
		LOGGER.info("authUserEmailMap {}", authUserEmailMap);
25927 amit.gupta 2724 
		Map<String, Integer> dtrEmailMap = dtrUserRepository
2725 
				.selectAllByEmailIds(new ArrayList<>(authUserEmailMap.values())).stream()
2726 
				.collect(Collectors.toMap(x -> x.getEmailId(), x -> x.getId()));
25936 amit.gupta 2727 
 
27477 amit.gupta 2728 
		LOGGER.info("dtrEmailMap {}", dtrEmailMap);
26790 tejbeer 2729 
 
25927 amit.gupta 2730 
		Map<Integer, Integer> authUserKeyMap = new HashMap<>();
2731 
 
2732 
		for (Map.Entry<Integer, String> authUserEmail : authUserEmailMap.entrySet()) {
2733 
			int authId = authUserEmail.getKey();
2734 
			String email = authUserEmail.getValue();
2735 
			authUserKeyMap.put(authId, dtrEmailMap.get(email));
2736 
		}
27477 amit.gupta 2737 
		LOGGER.info("authUserKeyMap", authUserKeyMap);
2738 
		LOGGER.info("leadsToNotify {}", leadsToNotify);
26790 tejbeer 2739 
 
29308 tejbeer 2740 
		String templateMessage = "Lead followup for %s %s, %s, %s is due by %s";
25927 amit.gupta 2741 
		for (Lead lead : leadsToNotify) {
27217 amit.gupta 2742 
			if (authUserKeyMap.get(lead.getAssignTo()) == null) {
2743 
				LOGGER.info("Assignee no longer part of system {}", lead.getAssignTo());
25927 amit.gupta 2744 
				continue;
2745 
			}
30982 tejbeer 2746 
			String title = "Leads followup Reminder";
25927 amit.gupta 2747 
			String notificationMessage = String.format(templateMessage, lead.getFirstName(), lead.getLastName(),
29308 tejbeer 2748 
					lead.getAddress(), lead.getLeadMobile(), leadTimeFormatter.format(lead.getScheduledTimestamp()));
30982 tejbeer 2749 
			String url = "https://app.smartdukaan.com/pages/home/leadUpdate?leadId=" + lead.getId();
25927 amit.gupta 2750 
			SendNotificationModel sendNotificationModel = new SendNotificationModel();
2751 
			sendNotificationModel.setCampaignName("Lead Reminder");
30982 tejbeer 2752 
			sendNotificationModel.setTitle(title);
25927 amit.gupta 2753 
			sendNotificationModel.setMessage(notificationMessage);
2754 
			sendNotificationModel.setType("url");
30982 tejbeer 2755 
			sendNotificationModel.setUrl(url);
25927 amit.gupta 2756 
			sendNotificationModel.setExpiresat(LocalDateTime.now().plusDays(2));
2757 
			sendNotificationModel.setMessageType(MessageType.reminder);
26320 tejbeer 2758 
			sendNotificationModel.setUserIds(Arrays.asList(authUserKeyMap.get(lead.getAssignTo())));
25929 amit.gupta 2759 
			System.out.println(sendNotificationModel);
25927 amit.gupta 2760 
			notificationService.sendNotification(sendNotificationModel);
30982 tejbeer 2761 
			AuthUser authUser = authRepository.selectById(lead.getAssignTo());
30991 tejbeer 2762 
			// notificationService.sendWhatsappMessage(notificationMessage, title,
2763 
			// authUser.getMobileNumber());
25927 amit.gupta 2764 
		}
2765 
	}
26945 amit.gupta 2766 
 
25927 amit.gupta 2767 
	public void notifyVisits() throws Exception {
26945 amit.gupta 2768 
		List<FranchiseeVisit> franchiseeVisits = franchiseeVisitRepository
2769 
				.selectVisitsScheduledBetweenDate(LocalDateTime.now().minusDays(15), LocalDateTime.now().plusHours(4));
25927 amit.gupta 2770 
		Map<Integer, String> authUserEmailMap = authRepository.selectAllActiveUser().stream()
2771 
				.collect(Collectors.toMap(x -> x.getId(), x -> x.getEmailId()));
2772 
		Map<String, Integer> dtrEmailMap = dtrUserRepository
2773 
				.selectAllByEmailIds(new ArrayList<>(authUserEmailMap.values())).stream()
2774 
				.collect(Collectors.toMap(x -> x.getEmailId(), x -> x.getId()));
2775 
		Map<Integer, Integer> authUserKeyMap = new HashMap<>();
26945 amit.gupta 2776 
 
25927 amit.gupta 2777 
		for (Map.Entry<Integer, String> authUserEmail : authUserEmailMap.entrySet()) {
2778 
			int authId = authUserEmail.getKey();
2779 
			String email = authUserEmail.getValue();
2780 
			authUserKeyMap.put(authId, dtrEmailMap.get(email));
2781 
		}
2782 
		String visitTemplate = "Planned visit to franchisee %s is due by %s";
2783 
		String followupTemplate = "Lead followup for franchisee %s is due by %s";
2784 
		DateTimeFormatter timeFormatter = DateTimeFormatter.ofPattern("MMM 7, EEEE h:m a");
2785 
		for (FranchiseeVisit visit : franchiseeVisits) {
2786 
			if (authUserKeyMap.containsKey(visit.getAuthId())) {
2787 
				continue;
2788 
			}
2789 
			SendNotificationModel sendNotificationModel = new SendNotificationModel();
2790 
			String message = null;
26945 amit.gupta 2791 
			if (visit.getFranchiseActivityId() == 0) {
2792 
				message = String.format(visitTemplate, visit.getPartnerName(),
30574 amit.gupta 2793 
						timeFormatter.format(visit.getScheduleTimestamp()));
26945 amit.gupta 2794 
				sendNotificationModel.setCampaignName("Franchisee visit Reminder");
25927 amit.gupta 2795 
			} else {
26945 amit.gupta 2796 
				message = String.format(followupTemplate, visit.getPartnerName(),
30574 amit.gupta 2797 
						timeFormatter.format(visit.getScheduleTimestamp()));
25927 amit.gupta 2798 
				sendNotificationModel.setCampaignName("Franchisee followup Reminder");
2799 
			}
2800 
			sendNotificationModel.setMessage(message);
2801 
			sendNotificationModel.setType("url");
26482 tejbeer 2802 
			sendNotificationModel.setUrl("https://app.smartdukaan.com/pages/home/notifications");
25927 amit.gupta 2803 
			sendNotificationModel.setExpiresat(LocalDateTime.now().plusDays(2));
2804 
			sendNotificationModel.setMessageType(MessageType.reminder);
2805 
			sendNotificationModel.setUserIds(Arrays.asList(authUserKeyMap.get(visit.getAuthId())));
30991 tejbeer 2806 
			// notificationService.sendNotification(sendNotificationModel);
25927 amit.gupta 2807 
		}
25910 amit.gupta 2808 
	}
25982 amit.gupta 2809 
 
26283 tejbeer 2810 
	public void ticketClosed() throws Exception {
2811 
 
2812 
		List<Ticket> tickets = ticketRepository.selectAllNotClosedTicketsWithStatus(ActivityType.RESOLVED);
2813 
		for (Ticket ticket : tickets) {
2814 
			if (ticket.getUpdateTimestamp().toLocalDate().isBefore(LocalDate.now().minusDays(7))) {
2815 
				ticket.setCloseTimestamp(LocalDateTime.now());
2816 
				ticket.setLastActivity(ActivityType.RESOLVED_ACCEPTED);
2817 
				ticket.setUpdateTimestamp(LocalDateTime.now());
2818 
				ticketRepository.persist(ticket);
2819 
			}
2820 
		}
2821 
 
2822 
	}
2823 
 
26790 tejbeer 2824 
	public void checkValidateReferral() throws Exception {
2825 
 
2826 
		List<Refferal> referrals = refferalRepository.selectByStatus(RefferalStatus.pending);
26791 tejbeer 2827 
		LOGGER.info("referrals" + referrals);
26790 tejbeer 2828 
		if (!referrals.isEmpty()) {
2829 
			String subject = "Referral Request";
2830 
			String messageText = this.getMessageForReferral(referrals);
2831 
 
26792 tejbeer 2832 
			MimeMessage message = mailSender.createMimeMessage();
2833 
			MimeMessageHelper helper = new MimeMessageHelper(message, true);
30752 tejbeer 2834 
			String[] email = { "kamini.sharma@smartdukaan.com", "tarun.verma@smartdukaan.com" };
26792 tejbeer 2835 
			helper.setSubject(subject);
2836 
			helper.setText(messageText, true);
2837 
			helper.setTo(email);
2838 
			InternetAddress senderAddress = new InternetAddress("noreply@smartdukaan.com", "Smartdukaan Alerts");
2839 
			helper.setFrom(senderAddress);
2840 
			mailSender.send(message);
2841 
 
26790 tejbeer 2842 
		}
2843 
	}
2844 
 
2845 
	private String getMessageForReferral(List<Refferal> referrals) {
2846 
		StringBuilder sb = new StringBuilder();
2847 
		sb.append("<html><body><p>Alert</p><p>Pending Referrals:-</p>"
2848 
				+ "<br/><table style='border:1px solid black ;padding: 5px';>");
2849 
		sb.append("<tbody>\n" + "	    				<tr>\n"
2850 
				+ "	    					<th style='border:1px solid black;padding: 5px'>RefereeName</th>\n"
2851 
				+ "	    					<th style='border:1px solid black;padding: 5px'>Referee Email</th>\n"
2852 
				+ "	    					<th style='border:1px solid black;padding: 5px'>Referral Name</th>\n"
2853 
				+ "	    					<th style='border:1px solid black;padding: 5px'>Refferal Mobile</th>\n"
2854 
				+ "	    					<th style='border:1px solid black;padding: 5px'>city</th>\n"
2855 
				+ "	    					<th style='border:1px solid black;padding: 5px'>state</th>\n"
2856 
				+ "	    				</tr>");
2857 
		for (Refferal entry : referrals) {
2858 
 
2859 
			sb.append("<tr>");
2860 
			sb.append("<td style='border:1px solid black;padding: 5px'>" + entry.getRefereeName() + "</td>");
2861 
 
2862 
			sb.append("<td style='border:1px solid black;padding: 5px'>" + entry.getRefereeEmail() + "</td>");
2863 
			sb.append("<td style='border:1px solid black;padding: 5px'>" + entry.getFirstName() + "</td>");
2864 
			sb.append("<td style='border:1px solid black;padding: 5px'>" + entry.getMobile() + "</td>");
2865 
			sb.append("<td style='border:1px solid black;padding: 5px'>" + entry.getCity() + "</td>");
2866 
			sb.append("<td style='border:1px solid black;padding: 5px'>" + entry.getState() + "</td>");
2867 
 
2868 
			sb.append("</tr>");
2869 
 
2870 
		}
2871 
 
2872 
		sb.append("</tbody></table></body></html>");
2873 
 
2874 
		return sb.toString();
2875 
	}
2876 
 
30421 tejbeer 2877 
	private String getMessageForUncontacblePartner(List<PartnerCollectionRemark> pcrs)
2878 
			throws ProfitMandiBusinessException {
2879 
		StringBuilder sb = new StringBuilder();
2880 
		sb.append("<html><body><p>Alert</p><p>Not Responding Partner:-</p>"
2881 
				+ "<br/><table style='border:1px solid black ;padding: 5px';>");
2882 
		sb.append("<tbody>\n" + "	    				<tr>\n"
2883 
				+ "	    					<th style='border:1px solid black;padding: 5px'>PartnerName</th>\n"
2884 
				+ "	    					<th style='border:1px solid black;padding: 5px'>from</th>\n"
2885 
 
2886 
				+ "	    				</tr>");
2887 
		for (PartnerCollectionRemark entry : pcrs) {
2888 
 
2889 
			CustomRetailer customRetailer = retailerService.getFofoRetailer(entry.getFofoId());
2890 
 
2891 
			sb.append("<tr>");
2892 
			sb.append("<td style='border:1px solid black;padding: 5px'>" + customRetailer.getBusinessName() + "("
2893 
					+ customRetailer.getCode() + ")" + "</td>");
2894 
 
2895 
			sb.append("<td style='border:1px solid black;padding: 5px'>"
2896 
					+ entry.getCreateTimestamp().format(DateTimeFormatter.ofPattern("dd/MM/yyyy")) + "</td>");
2897 
 
2898 
			sb.append("</tr>");
2899 
 
2900 
		}
2901 
 
2902 
		sb.append("</tbody></table></body></html>");
2903 
 
2904 
		return sb.toString();
2905 
	}
2906 
 
27271 amit.gupta 2907 
	public void reverseWallet() throws Exception {
2908 
		LocalDate localDate = LocalDate.of(2020, 10, 28);
28205 tejbeer 2909 
		List<UserWalletHistory> uwhList = userWalletHistoryRepository.selectAllByDateType(localDate.atStartOfDay(),
2910 
				localDate.plusDays(1).atStartOfDay(),
27271 amit.gupta 2911 
				Arrays.asList(WalletReferenceType.SCHEME_IN, WalletReferenceType.SCHEME_OUT));
2912 
		for (UserWalletHistory uwh : uwhList) {
28205 tejbeer 2913 
			if (uwh.getBusinessTimestamp().getMonth().equals(Month.SEPTEMBER)) {
27275 amit.gupta 2914 
				UserWallet uw = userWalletRepository.selectById(uwh.getWalletId());
28205 tejbeer 2915 
				// LOGGER.info("UWH - {}", uwh);
2916 
				// amount += uwh.getAmount();
2917 
				// System.out.println("Amount is - " + amount);
2918 
				// walletService.rollbackAmountFromWallet(uw.getUserId(), uwh.getAmount(),
2919 
				// uwh.getReference(), uwh.getReferenceType(), "Margin reversal for error prone
2920 
				// run", uwh.getBusinessTimestamp());
27313 amit.gupta 2921 
				int orderId = uwh.getReference();
2922 
				FofoOrder fofoOrder = fofoOrderRepository.selectByOrderId(orderId);
2923 
				int inventoryItemId = 0;
28205 tejbeer 2924 
				// fofoOrderRepository.delete(fofoOrder);
27313 amit.gupta 2925 
				List<FofoOrderItem> fofoOrderItems = fofoOrderItemRepository.selectByOrderId(fofoOrder.getId());
28205 tejbeer 2926 
				/*
2927 
				 * List<PaymentOptionTransaction> paymentOptionTransactions =
2928 
				 * paymentOptionTransactionRepository.selectByReferenceIdAndType(fofoOrder.getId
2929 
				 * (), PaymentOptionReferenceType.ORDER); for(PaymentOptionTransaction
2930 
				 * paymentOptionTransaction : paymentOptionTransactions) {
2931 
				 * //paymentOptionTransactionRepository.delete(paymentOptionTransaction); }
2932 
				 */
2933 
				for (FofoOrderItem foi : fofoOrderItems) {
2934 
					// fofoOrderItemRepository.delete(foi);
27313 amit.gupta 2935 
					List<FofoLineItem> flis = fofoLineItemRepository.selectByFofoOrderItemId(foi.getId());
28205 tejbeer 2936 
					for (FofoLineItem fli : flis) {
2937 
						// fofoLineItemRepository.delete(fli);
27313 amit.gupta 2938 
						inventoryItemId = fli.getInventoryItemId();
2939 
					}
2940 
				}
28205 tejbeer 2941 
				List<SchemeInOut> schemeInOuts = schemeInOutRepository.selectByInventoryItemIds(
2942 
						java.util.stream.Stream.of(inventoryItemId).collect(Collectors.toSet()));
2943 
				for (SchemeInOut sio : schemeInOuts) {
2944 
					if (sio.getCreateTimestamp().toLocalDate().equals(localDate)) {
27314 amit.gupta 2945 
						LOGGER.info("SIO - {}", sio);
27315 amit.gupta 2946 
						sio.setRolledBackTimestamp(LocalDateTime.now());
27313 amit.gupta 2947 
					}
2948 
				}
28205 tejbeer 2949 
 
27271 amit.gupta 2950 
			}
2951 
		}
28205 tejbeer 2952 
 
27271 amit.gupta 2953 
	}
28205 tejbeer 2954 
 
2955 
	public void partnerProblemAlert() throws Exception {
2956 
		LocalDateTime curDate = LocalDate.now().atStartOfDay();
2957 
		Map<Integer, Double> lmtdSale = fofoOrderItemRepository.selectSumMopGroupByRetailer(
2958 
				curDate.withDayOfMonth(1).minusMonths(1), curDate.with(LocalTime.MAX).minusMonths(1), 0, false);
2959 
		Map<Integer, Double> mtdSales = fofoOrderItemRepository.selectSumMopGroupByRetailer(curDate.withDayOfMonth(1),
2960 
				curDate.with(LocalTime.MAX), 0, false);
2961 
		Map<Integer, PartnerDailyInvestment> pdi = partnerDailyInvestmentRepository.selectAll(LocalDate.now()).stream()
2962 
				.collect(Collectors.toMap(x -> x.getFofoId(), x -> x));
2963 
 
2964 
		for (Entry<Integer, Double> ls : lmtdSale.entrySet()) {
2965 
 
2966 
			double lmtdTwentyPercentSale = ls.getValue() * 0.2;
28208 tejbeer 2967 
 
2968 
			LOGGER.info("lmtdTwentyPercentSale" + lmtdTwentyPercentSale);
2969 
 
28211 tejbeer 2970 
			double mtdSale = mtdSales.get(ls.getKey()) == null ? 0 : mtdSales.get(ls.getKey());
28208 tejbeer 2971 
 
2972 
			LOGGER.info("mtdSale" + mtdSale);
2973 
 
28209 tejbeer 2974 
			double totalSixtyPercentInvestment = pdi.get(ls.getKey()) == null ? 0
2975 
					: pdi.get(ls.getKey()).getTotalInvestment() * 0.6;
28205 tejbeer 2976 
 
28208 tejbeer 2977 
			LOGGER.info("totalSixtyPercentInvestment" + totalSixtyPercentInvestment);
2978 
 
28209 tejbeer 2979 
			double stockInvestment = pdi.get(ls.getKey()) == null ? 0 : pdi.get(ls.getKey()).getInStockAmount();
28208 tejbeer 2980 
 
2981 
			LOGGER.info("stockInvestment" + stockInvestment);
2982 
 
28205 tejbeer 2983 
			boolean Investmentvalue = partnerInvestmentService.isInvestmentBelow(ls.getKey(), 25);
2984 
 
2985 
			PartnerProblem partnerProblem = partnerProblemRepository.selectByFofoId(ls.getKey());
2986 
 
28210 tejbeer 2987 
			if (partnerProblem == null) {
28205 tejbeer 2988 
				partnerProblem = new PartnerProblem();
2989 
				partnerProblem.setFofoId(ls.getKey());
2990 
				if (mtdSale < lmtdTwentyPercentSale) {
2991 
					partnerProblem.setMtd(1);
2992 
				}
2993 
				if (Investmentvalue) {
2994 
					partnerProblem.setInvestment(1);
2995 
				}
2996 
 
2997 
				if (stockInvestment < totalSixtyPercentInvestment) {
2998 
					partnerProblem.setInvestment(1);
2999 
				}
3000 
 
3001 
				partnerProblemRepository.persist(partnerProblem);
3002 
			} else {
3003 
				if (mtdSale < lmtdTwentyPercentSale) {
3004 
					partnerProblem.setMtd(partnerProblem.getMtd() + 1);
3005 
 
3006 
				} else {
3007 
					partnerProblem.setMtd(0);
3008 
 
3009 
				}
3010 
				if (Investmentvalue) {
3011 
					partnerProblem.setInvestment(partnerProblem.getInvestment() + 1);
3012 
				} else {
3013 
					partnerProblem.setInvestment(0);
3014 
 
3015 
				}
3016 
				if (stockInvestment < totalSixtyPercentInvestment) {
3017 
					partnerProblem.setStockInvestment(partnerProblem.getStockInvestment() + 1);
3018 
				} else {
3019 
					partnerProblem.setStockInvestment(0);
3020 
				}
3021 
 
3022 
			}
3023 
 
3024 
		}
3025 
 
28213 tejbeer 3026 
		List<PartnerProblem> partnerProblems = partnerProblemRepository.selectAll().stream()
3027 
				.filter(x -> x.getMtd() + x.getInvestment() + x.getStockInvestment() > 0).collect(Collectors.toList());
3028 
 
28223 tejbeer 3029 
		partnerProblems = partnerProblems.stream().sorted((x1, x2) -> {
28224 tejbeer 3030 
			return x1.getMtd() + x1.getInvestment() + x1.getStockInvestment() < x2.getMtd() + x2.getInvestment()
28223 tejbeer 3031 
					+ x2.getStockInvestment() ? 1 : -1;
3032 
		}).collect(Collectors.toList());
28227 tejbeer 3033 
 
3034 
		Map<Integer, PartnerProblem> partnerProblemMap = partnerProblems.stream().sorted((x1, x2) -> {
3035 
			return x1.getMtd() + x1.getInvestment() + x1.getStockInvestment() < x2.getMtd() + x2.getInvestment()
3036 
					+ x2.getStockInvestment() ? 1 : -1;
3037 
		}).collect(Collectors.toMap(x -> x.getFofoId(), x -> x));
3038 
 
28212 tejbeer 3039 
		Map<Integer, CustomRetailer> customRetailers = retailerService.getAllFofoRetailers();
28213 tejbeer 3040 
 
28467 tejbeer 3041 
		List<Integer> assignTo = Arrays.asList(15, 9, 54, 53);
28213 tejbeer 3042 
 
3043 
		Map<Integer, AuthUser> assignAuthUserMap = authRepository.selectAllAuthUserByIds(assignTo).stream()
3044 
				.collect(Collectors.toMap(x -> x.getId(), x -> x));
3045 
 
31604 tejbeer 3046 
		List<String> sendTo = Arrays.asList("kamini.sharma@smartdukaan.com", "tarun.verma@smartdukaan.com",
3047 
				"sm@smartdukaan.com");
28208 tejbeer 3048 
		LOGGER.info("partnerProblem" + partnerProblems);
28205 tejbeer 3049 
		StringBuilder sb = new StringBuilder();
28218 tejbeer 3050 
		sb.append("<htl><body>");
28222 tejbeer 3051 
		sb.append(
3052 
				"<p>Number against MTD or Investment are the count of days the MTD is low VS LMTD OR Investment is below 75%.</p><br/><p>These partners needs immediate attention.</p><br/><table style='border:1px solid black';cellspacing=0>");
28205 tejbeer 3053 
		sb.append("<tbody>\n" + "	    <tr>"
3054 
				+ "	    					<th style='border:1px solid black;padding: 5px'>Partner Name</th>"
3055 
				+ "                         <th style='border:1px solid black;padding: 5px'>Assign TO</th>"
3056 
				+ "	    					<th style='border:1px solid black;padding: 5px'>Mtd</th>"
3057 
				+ "	    					<th style='border:1px solid black;padding: 5px'>Investment</th>"
3058 
				+ "	    					<th style='border:1px solid black;padding: 5px'>Stock</th>"
3059 
				+ "	    					<th style='border:1px solid black;padding: 5px'>Manager</th>"
3060 
 
3061 
				+ "	    				</tr>");
3062 
 
3063 
		for (PartnerProblem pp : partnerProblems) {
28467 tejbeer 3064 
			int value = pp.getFofoId() % 4;
28205 tejbeer 3065 
 
3066 
			Map<EscalationType, AuthUser> authUserMap = csService.getAuthUserAndEsclationByPartnerId(pp.getFofoId());
28217 tejbeer 3067 
			LOGGER.info("authUserMap" + authUserMap);
28205 tejbeer 3068 
			sb.append("<tr>");
3069 
			sb.append("<td style='border:1px solid black;padding: 5px'>"
3070 
					+ customRetailers.get(pp.getFofoId()).getBusinessName() + "</td>");
28213 tejbeer 3071 
			sb.append("<td style='border:1px solid black;padding: 5px'>"
3072 
					+ assignAuthUserMap.get(assignTo.get(value)).getName() + "</td>");
28205 tejbeer 3073 
			sb.append("<td style='border:1px solid black;padding: 5px'>" + pp.getMtd() + "</td>");
3074 
			sb.append("<td style='border:1px solid black;padding: 5px'>" + pp.getInvestment() + "</td>");
3075 
			sb.append("<td style='border:1px solid black;padding: 5px'>" + pp.getStockInvestment() + "</td>");
28216 tejbeer 3076 
			sb.append("<td style='border:1px solid black;padding: 5px'>"
28224 tejbeer 3077 
					+ (authUserMap.get(EscalationType.L1) == null ? "N/A"
30752 tejbeer 3078 
							: authUserMap.get(EscalationType.L1).getFirstName())
28224 tejbeer 3079 
					+ " ," + (authUserMap.get(EscalationType.L2) == null ? "N/A"
30752 tejbeer 3080 
							: authUserMap.get(EscalationType.L2).getFirstName())
28216 tejbeer 3081 
					+ "</td>");
28205 tejbeer 3082 
 
3083 
			sb.append("</tr>");
3084 
		}
3085 
		sb.append("</tbody></table><br><br>");
3086 
		String subject = "Partner Problem Alert!";
3087 
		String[] email = sendTo.toArray(new String[sendTo.size()]);
3088 
 
28222 tejbeer 3089 
		this.sendMailHtmlFormat(email, sb.toString(), null, subject);
3090 
 
28218 tejbeer 3091 
		Map<Integer, List<Integer>> authUserPartnerMapping = csService.getAuthUserIdPartnerIdMapping();
3092 
 
3093 
		for (Entry<Integer, List<Integer>> authUserPartner : authUserPartnerMapping.entrySet()) {
28222 tejbeer 3094 
			AuthUser authUser = authRepository.selectById(authUserPartner.getKey());
28227 tejbeer 3095 
			for (Integer patnerId : authUserPartner.getValue()) {
3096 
				if (partnerProblemMap.get(patnerId) != null) {
28218 tejbeer 3097 
 
28227 tejbeer 3098 
					StringBuilder sbbuilder = new StringBuilder();
3099 
					sbbuilder.append("<hml><body>");
3100 
					sb.append(
3101 
							"<p>Number against MTD or Investment are the count of days the MTD is low VS LMTD OR Investment is below 75%.</p><br/><p>These partners needs immediate attention.</p><br/><table style='border:1px solid black';cellspacing=0>");
3102 
					sbbuilder.append("<tbody>\n" + "	    <tr>"
3103 
							+ "	    					<th style='border:1px solid black;padding: 5px'>Partner Name</th>"
3104 
							+ "	    					<th style='border:1px solid black;padding: 5px'>Mtd</th>"
3105 
							+ "	    					<th style='border:1px solid black;padding: 5px'>Investment</th>"
3106 
							+ "	    					<th style='border:1px solid black;padding: 5px'>Stock</th>"
28218 tejbeer 3107 
 
28227 tejbeer 3108 
							+ "	    				</tr>");
28218 tejbeer 3109 
 
28227 tejbeer 3110 
					for (Integer partnerId : authUserPartner.getValue()) {
3111 
						if (partnerProblemMap.get(partnerId) != null) {
3112 
							PartnerProblem pp = partnerProblemMap.get(partnerId);
3113 
							sbbuilder.append("<tr>");
3114 
							sbbuilder.append("<td style='border:1px solid black;padding: 5px'>"
3115 
									+ customRetailers.get(pp.getFofoId()).getBusinessName() + "</td>");
3116 
							sbbuilder
3117 
									.append("<td style='border:1px solid black;padding: 5px'>" + pp.getMtd() + "</td>");
3118 
							sbbuilder.append(
3119 
									"<td style='border:1px solid black;padding: 5px'>" + pp.getInvestment() + "</td>");
3120 
							sbbuilder.append("<td style='border:1px solid black;padding: 5px'>"
3121 
									+ pp.getStockInvestment() + "</td>");
3122 
 
3123 
							sbbuilder.append("</tr>");
3124 
						}
3125 
 
28224 tejbeer 3126 
					}
28227 tejbeer 3127 
					sbbuilder.append("</tbody></table><br><br>");
28224 tejbeer 3128 
 
28286 tejbeer 3129 
					this.sendMailOfHtmlFormat(authUser.getEmailId(), sbbuilder.toString(), null, subject);
28230 tejbeer 3130 
					break;
28218 tejbeer 3131 
				}
28230 tejbeer 3132 
 
28223 tejbeer 3133 
			}
28222 tejbeer 3134 
		}
3135 
	}
28218 tejbeer 3136 
 
28222 tejbeer 3137 
	private void sendMailHtmlFormat(String email[], String body, String cc[], String subject)
3138 
			throws MessagingException, ProfitMandiBusinessException, IOException {
3139 
		MimeMessage message = mailSender.createMimeMessage();
3140 
		MimeMessageHelper helper = new MimeMessageHelper(message);
3141 
		helper.setSubject(subject);
3142 
		helper.setText(body, true);
3143 
		helper.setTo(email);
3144 
		if (cc != null) {
3145 
			helper.setCc(cc);
28218 tejbeer 3146 
		}
28222 tejbeer 3147 
		InternetAddress senderAddress = new InternetAddress("noreply@smartdukaan.com", "Smart Dukaan");
3148 
		helper.setFrom(senderAddress);
3149 
		mailSender.send(message);
28205 tejbeer 3150 
	}
3151 
 
28775 amit.gupta 3152 
	@Autowired
3153 
	WarehouseRepository warehouseRepository;
28790 amit.gupta 3154 
 
28775 amit.gupta 3155 
	public void getVendorWarehouses(int warehouseId) {
28778 amit.gupta 3156 
		LOGGER.info("Warehouses - {}", warehouseRepository.getVendorWarehouses().get(warehouseId));
28790 amit.gupta 3157 
 
28775 amit.gupta 3158 
	}
29488 manish 3159 
 
29451 manish 3160 
	public void checkImeiActivation() {
29488 manish 3161 
 
29451 manish 3162 
		try {
3163 
			vivoImeiActivationService.checkImeiActivation();
3164 
		} catch (ProfitMandiBusinessException e) {
3165 
			// TODO Auto-generated catch block
3166 
			e.printStackTrace();
3167 
		} catch (IOException e) {
3168 
			// TODO Auto-generated catch block
3169 
			e.printStackTrace();
3170 
		} catch (Exception e) {
3171 
			// TODO Auto-generated catch block
3172 
			e.printStackTrace();
3173 
		}
28775 amit.gupta 3174 
 
29451 manish 3175 
	}
3176 
 
29668 tejbeer 3177 
	public void checkItelImeiActivation(LocalDate date, Integer day) {
29488 manish 3178 
		LOGGER.info("Hello - {}", "hhh");
3179 
 
3180 
		try {
29668 tejbeer 3181 
			itelImeiActivationService.checkItelImeiActivation(date, day);
29488 manish 3182 
		} catch (ProfitMandiBusinessException e) {
3183 
			// TODO Auto-generated catch block
3184 
			e.printStackTrace();
3185 
		} catch (IOException e) {
3186 
			// TODO Auto-generated catch block
3187 
			e.printStackTrace();
3188 
		} catch (Exception e) {
3189 
			// TODO Auto-generated catch block
3190 
			e.printStackTrace();
3191 
		}
3192 
 
3193 
	}
3194 
 
29807 manish 3195 
	public void selectFinServiceFollowUpDateByCurrDate(LocalDate currentDate)
3196 
			throws MessagingException, ProfitMandiBusinessException, IOException {
29801 manish 3197 
		LOGGER.info("selectfinServiceFollow - {}", "selectfinServiceFollowUpDateByCurrDate");
3198 
 
29807 manish 3199 
		serviceConfigService.selectFinServicePartnerfollowUpDateByCurrentDate(currentDate);
3200 
 
29801 manish 3201 
	}
3202 
 
29668 tejbeer 3203 
	public void checkTecnoImeiActivation(LocalDate date, Integer day) {
29488 manish 3204 
		LOGGER.info("Hello - {}", "hhh");
3205 
 
3206 
		try {
29668 tejbeer 3207 
			tecnoImeiActivation.checkTecnoImeiActivation(date, day);
29488 manish 3208 
		} catch (ProfitMandiBusinessException e) {
3209 
			// TODO Auto-generated catch block
3210 
			e.printStackTrace();
3211 
		} catch (IOException e) {
3212 
			// TODO Auto-generated catch block
3213 
			e.printStackTrace();
3214 
		} catch (Exception e) {
3215 
			// TODO Auto-generated catch block
3216 
			e.printStackTrace();
3217 
		}
3218 
 
3219 
	}
3220 
 
29252 amit.gupta 3221 
	public void checkCancellationMargin() throws Exception {
3222 
		LocalDateTime startDate = LocalDate.of(2021, 4, 1).atStartOfDay();
3223 
		List<FofoOrder> fofoOrders = fofoOrderRepository.selectCancelledBetweenSaleDate(startDate, LocalDateTime.now());
3224 
		LOGGER.info("Total Orders =  {}", fofoOrders.size());
29308 tejbeer 3225 
		for (FofoOrder fofoOrder : fofoOrders) {
3226 
			List<UserWalletHistory> history = userWalletHistoryRepository
3227 
					.selectAllByreferenceIdandreferenceType(fofoOrder.getId(), WalletReferenceType.SCHEME_OUT);
3228 
			history.addAll(userWalletHistoryRepository.selectAllByreferenceIdandreferenceType(fofoOrder.getId(),
3229 
					WalletReferenceType.ACTIVATION_SCHEME));
3230 
			int walletSum = history.stream().mapToInt(x -> x.getAmount()).sum();
3231 
			if (Math.abs(walletSum) > 1) {
3232 
				// LOGGER.info("Cancelled invoice {}, Order Id = {}, = havent rolledback, Value
3233 
				// = {}", fofoOrder.getInvoiceNumber(), fofoOrder.getId(), walletSum);
29252 amit.gupta 3234 
				List<FofoOrderItem> fofoOrderItems = fofoOrderItemRepository.selectByOrderId(fofoOrder.getId());
3235 
				List<FofoLineItem> flis = fofoLineItemRepository.selectByFofoOrderItemId(fofoOrderItems.get(0).getId());
3236 
				FofoLineItem fli = flis.get(0);
29308 tejbeer 3237 
				if (StringUtils.isEmpty(fli.getSerialNumber()))
3238 
					continue;
3239 
				List<SchemeInOut> schemeInOuts = schemeInOutRepository
3240 
						.selectByInventoryItemIds(new HashSet<>(Arrays.asList(fli.getInventoryItemId())));
29252 amit.gupta 3241 
				InventoryItem inventoryItem = inventoryItemRepository.selectById(fli.getInventoryItemId());
29308 tejbeer 3242 
				double schemeSum = schemeInOuts.stream().filter(x -> x.getRolledBackTimestamp() == null)
3243 
						.mapToDouble(x -> x.getAmount()).sum();
3244 
				/*
3245 
				 * if(inventoryItem.getGoodQuantity()==1) {
3246 
				 * LOGGER.info("GoodQty, Serial Number {}, InventoryItem = {}, Billed on {}",
3247 
				 * inventoryItem.getSerialNumber(), inventoryItem.getId(),
3248 
				 * inventoryItem.getUpdateTimestamp()); } else
3249 
				 * if(inventoryItem.getBadQuantity()==1){
3250 
				 * LOGGER.info("Bad Qty, Serial Number {}, InventoryItem = {}, Billed on {}",
3251 
				 * inventoryItem.getSerialNumber(), inventoryItem.getId(),
3252 
				 * inventoryItem.getUpdateTimestamp()); } else if
3253 
				 * (inventoryItem.getLastScanType().equals(ScanType.SALE)) { LOGGER.
3254 
				 * info("Problem Sold, Serial Number {}, InventoryItem = {}, Billed on {}",
3255 
				 * inventoryItem.getSerialNumber(), inventoryItem.getId(),
3256 
				 * inventoryItem.getUpdateTimestamp()); }
3257 
				 */
3258 
				if (inventoryItem.getLastScanType().equals(ScanType.SALE)
3259 
						|| inventoryItem.getLastScanType().equals(ScanType.SALE_RET)) {
3260 
					Map<String, Double> map = schemeInOuts.stream()
3261 
							.collect(
3262 
									Collectors.groupingBy(
3263 
											x -> DateTimeFormatter.ofPattern("yyyyMMddHH")
3264 
													.format(x.getCreateTimestamp()) + "- " + x.getSchemeId(),
3265 
											Collectors.summingDouble(x -> x.getAmount())));
3266 
					for (Map.Entry<String, Double> entry : map.entrySet()) {
3267 
						LOGGER.info("{} = {}", entry.getKey(), entry.getValue());
29252 amit.gupta 3268 
					}
29308 tejbeer 3269 
					LOGGER.info("id- {}, imei- {}, lastScan = {}, Scheme sum - {}", inventoryItem.getId(),
3270 
							inventoryItem.getSerialNumber(), inventoryItem.getLastScanType(), schemeSum);
29252 amit.gupta 3271 
				}
3272 
			}
3273 
		}
29308 tejbeer 3274 
 
29252 amit.gupta 3275 
	}
3276 
 
29488 manish 3277 
	public static String readFileAsString(String file) throws Exception {
3278 
		String data = "";
3279 
		data = new String(Files.readAllBytes(Paths.get(file)));
3280 
		return data;
3281 
	}
29451 manish 3282 
 
29308 tejbeer 3283 
	public void markDelhiveryOrderDelivered() throws ProfitMandiBusinessException, IOException {
3284 
		List<Order> orders = orderRepository.selectOrderByProviderIdAndStatus(ProfitMandiConstants.DELHIVERY_PROVIDERID,
3285 
				OrderStatus.SHIPPED_FROM_WH);
3286 
 
3287 
		if (!orders.isEmpty()) {
29441 tejbeer 3288 
			Set<String> airwayBill = orders.stream().map(x -> x.getAirwayBillNumber()).collect(Collectors.toSet());
29308 tejbeer 3289 
 
29441 tejbeer 3290 
			int arraylength = airwayBill.size();
3291 
 
3292 
			if (arraylength >= 75) {
3293 
 
3294 
				airwayBill = airwayBill.stream().limit(74).collect(Collectors.toSet());
3295 
			}
29308 tejbeer 3296 
			LOGGER.info("airwayBill" + airwayBill);
3297 
			String url = "https://track.delhivery.com/api/v1/packages/json/";
3298 
 
3299 
			OkHttpClient client = new OkHttpClient();
3300 
 
3301 
			Request request1 = new Request.Builder()
3302 
					.url(url + "?waybill=" + String.join(",", airwayBill) + "&token=" + token).get().build();
3303 
 
3304 
			LOGGER.info("request1" + request1);
3305 
 
3306 
			Response response = client.newCall(request1).execute();
3307 
 
3308 
			LOGGER.info("jsonbj" + response.body());
3309 
 
3310 
			JSONObject jsonObj = new JSONObject(response.body().string());
3311 
 
3312 
			LOGGER.info("jsonObj" + jsonObj);
3313 
 
29403 tejbeer 3314 
			JSONArray shipmentData = jsonObj.getJSONArray("ShipmentData");
29308 tejbeer 3315 
			Set<String> airwaybillStatus = new HashSet<>();
29403 tejbeer 3316 
			for (int i = 0; i < shipmentData.length(); i++) {
3317 
				JSONObject jsonObject = shipmentData.getJSONObject(i);
29308 tejbeer 3318 
				JSONObject shipment = jsonObject.getJSONObject("Shipment");
3319 
 
3320 
				LOGGER.info("shipment" + shipment);
3321 
				JSONObject statusDescription = shipment.getJSONObject("Status");
3322 
				String awb = shipment.getString("AWB");
3323 
 
3324 
				String status = statusDescription.getString("Status");
3325 
				LOGGER.info("status" + status);
3326 
 
3327 
				LOGGER.info("awb" + awb);
3328 
				if (status.equals("Delivered")) {
3329 
					airwaybillStatus.add(awb);
3330 
				}
3331 
 
3332 
			}
31117 tejbeer 3333 
			markOrderDelivered(airwaybillStatus);
3334 
		}
3335 
	}
29308 tejbeer 3336 
 
31117 tejbeer 3337 
	public void markBlueDartOrderDelivered() throws ProfitMandiBusinessException, IOException {
29308 tejbeer 3338 
 
31117 tejbeer 3339 
		String loginId = "DEL81122";
30982 tejbeer 3340 
 
31117 tejbeer 3341 
		String licencekey = "uhfhlg2jpmnqfhfrlsgzfr1nhu1qfvel";
30982 tejbeer 3342 
 
31117 tejbeer 3343 
		List<Order> orders = orderRepository.selectOrderByProviderIdAndStatus(ProfitMandiConstants.BLUEDART_PROVIDERID,
3344 
				OrderStatus.SHIPPED_FROM_WH);
30982 tejbeer 3345 
 
31117 tejbeer 3346 
		if (!orders.isEmpty()) {
30982 tejbeer 3347 
 
31118 tejbeer 3348 
			Set<String> airwayBillNo = orders.stream().map(x -> x.getAirwayBillNumber()).collect(Collectors.toSet());
29308 tejbeer 3349 
 
31117 tejbeer 3350 
			LOGGER.info("airwayBill" + airwayBillNo);
3351 
			String url = "https://api.bluedart.com/servlet/RoutingServlet?handler=tnt&action=custawbquery";
30982 tejbeer 3352 
 
31117 tejbeer 3353 
			String response = restClient.get(url + "&loginid=" + loginId + "&awb=awb&numbers="
3354 
					+ String.join(",", airwayBillNo) + "&format=xml&lickey=" + licencekey + "&verno=1.3&scan=1", null,
3355 
					null);
3356 
 
3357 
			JSONObject updateJson = XML.toJSONObject(response);
3358 
 
3359 
			JSONObject shipmentData = updateJson.getJSONObject("ShipmentData");
3360 
			Object shipmentObject = shipmentData.get("Shipment");
3361 
 
3362 
			Set<String> airwaybillStatus = new HashSet<>();
3363 
 
3364 
			if (shipmentObject instanceof JSONArray) {
3365 
				JSONArray shipments = (JSONArray) shipmentObject;
3366 
				for (int i = 0; i < shipments.length(); i++) {
3367 
					JSONObject jsonObject = shipments.getJSONObject(i);
3368 
 
3369 
					Number awb = jsonObject.getNumber("WaybillNo");
3370 
					String status = jsonObject.getString("Status");
3371 
 
3372 
					if (status.equals("SHIPMENT DELIVERED")) {
3373 
						airwaybillStatus.add(awb.toString());
3374 
					}
3375 
 
29308 tejbeer 3376 
				}
31117 tejbeer 3377 
			} else {
3378 
				JSONObject jsonObject = (JSONObject) shipmentObject;
3379 
				Number awb = jsonObject.getNumber("WaybillNo");
3380 
				String status = jsonObject.getString("Status");
3381 
 
3382 
				if (status.equals("SHIPMENT DELIVERED")) {
3383 
					airwaybillStatus.add(awb.toString());
3384 
				}
3385 
 
29308 tejbeer 3386 
			}
3387 
 
31117 tejbeer 3388 
			LOGGER.info("airwaybillStatus" + airwaybillStatus);
3389 
 
31118 tejbeer 3390 
			markOrderDelivered(airwaybillStatus);
29308 tejbeer 3391 
		}
31117 tejbeer 3392 
 
29308 tejbeer 3393 
	}
3394 
 
31117 tejbeer 3395 
	private void markOrderDelivered(Set<String> airwaybillStatus)
3396 
			throws ProfitMandiBusinessException, HttpHostConnectException {
3397 
		if (!airwaybillStatus.isEmpty()) {
3398 
			for (String aws : airwaybillStatus) {
3399 
 
3400 
				List<Order> deliverdOrders = orderRepository.selectByAirwayBillNumber(aws);
3401 
 
3402 
				int fofoId = deliverdOrders.get(0).getRetailerId();
3403 
				for (Order dlo : deliverdOrders) {
3404 
					dlo.setStatus(OrderStatus.DELIVERY_SUCCESS);
3405 
					dlo.setStatusDescription("Order Delivered");
3406 
					dlo.setDeliveryTimestamp(LocalDateTime.now());
3407 
				}
3408 
 
3409 
				com.spice.profitmandi.dao.entity.user.User user = userUserRepository.selectById(fofoId);
3410 
 
3411 
				Address address = addressRepository.selectById(user.getAddressId());
3412 
 
3413 
				String title = "Order Delivered";
3414 
 
3415 
				String message = String.format("Dear partner, Your SmartDukaan Order " + aws
3416 
						+ " has been delivered to you in a safe sealed bag.");
3417 
 
3418 
				SendNotificationModel sendNotificationModel = new SendNotificationModel();
3419 
				sendNotificationModel.setCampaignName("Order Delivered");
3420 
				sendNotificationModel.setTitle(title);
3421 
				sendNotificationModel.setMessage(message);
3422 
				sendNotificationModel.setType("url");
3423 
				sendNotificationModel.setUrl("https://app.smartdukaan.com/pages/home/notifications");
3424 
				sendNotificationModel.setExpiresat(LocalDateTime.now().plusDays(1));
3425 
				sendNotificationModel.setMessageType(MessageType.notification);
3426 
				int userId = userAccountRepository.selectUserIdByRetailerId(fofoId);
3427 
				sendNotificationModel.setUserIds(Arrays.asList(userId));
3428 
				notificationService.sendNotification(sendNotificationModel);
3429 
 
3430 
				notificationService.sendWhatsappMessage(message, title, address.getPhoneNumber());
3431 
 
3432 
			}
3433 
		}
3434 
	}
3435 
 
29814 tejbeer 3436 
	public void partnerWiseCreditAccount() throws Exception {
3437 
 
3438 
		List<FofoStore> fofoStores = fofoStoreRepository.selectActiveStores();
3439 
 
3440 
		for (FofoStore fs : fofoStores) {
3441 
 
3442 
			if (fs.getPan() != null) {
3443 
				AccountStatusResponseOut accountStatusResponseOut = mandiiService.getStatus(fs.getPan());
29815 tejbeer 3444 
 
3445 
				LOGGER.info("accountStatusResponseOut" + accountStatusResponseOut);
29814 tejbeer 3446 
				CreditAccount creditAccount = creditAccountRepository.selectByFofoIdAndGateway(fs.getId(),
3447 
						Gateway.MANDII);
3448 
 
3449 
				if (creditAccount == null) {
3450 
 
3451 
					creditAccount = new CreditAccount();
3452 
 
3453 
					creditAccount.setFofoId(fs.getId());
3454 
					creditAccount.setGateway(Gateway.MANDII);
3455 
 
3456 
				}
29835 tejbeer 3457 
 
3458 
				if (accountStatusResponseOut == null) {
3459 
					creditAccount.setCreditStatus(CreditStatus.UNKNOWN);
3460 
					creditAccount.setDescription("User company not found");
3461 
 
29817 tejbeer 3462 
				} else {
29835 tejbeer 3463 
					if (accountStatusResponseOut.getSanctionLimit() != null) {
3464 
						creditAccount.setSanctionedAmount(accountStatusResponseOut.getSanctionLimit().floatValue());
3465 
					} else {
3466 
						creditAccount.setSanctionedAmount(0);
3467 
					}
29817 tejbeer 3468 
 
29835 tejbeer 3469 
					creditAccount.setInterestRate(accountStatusResponseOut.getRateOfInterest());
3470 
					if (accountStatusResponseOut.getBalanceAmount() != null) {
3471 
						creditAccount.setAvailableAmount(accountStatusResponseOut.getBalanceAmount().floatValue());
3472 
					} else {
3473 
						creditAccount.setAvailableAmount(0);
3474 
					}
3475 
 
3476 
					if (accountStatusResponseOut.getCurrentStage() != null) {
3477 
						creditAccount.setDescription(accountStatusResponseOut.getCurrentStage().toString());
3478 
					}
3479 
					if (accountStatusResponseOut.getStatus().equals(EligibilityStatusEnum.SANCTION_AVAILABLE)) {
3480 
						creditAccount.setCreditStatus(CreditStatus.SANCTIONED);
3481 
					} else if (accountStatusResponseOut.getStatus().equals(EligibilityStatusEnum.IN_ELIGIBLE)) {
3482 
						creditAccount.setCreditStatus(CreditStatus.INELIGIBLE);
3483 
					} else {
3484 
 
3485 
						creditAccount.setCreditStatus(CreditStatus.TO_BE_EVALUATED);
3486 
					}
29817 tejbeer 3487 
				}
3488 
 
29814 tejbeer 3489 
				creditAccount.setUpdatedOn(LocalDateTime.now());
3490 
				creditAccountRepository.persist(creditAccount);
3491 
			}
3492 
		}
3493 
	}
3494 
 
30421 tejbeer 3495 
	@Autowired
3496 
	private PartnerCollectionRemarkRepository partnerCollectionRemarkRepository;
3497 
 
3498 
	public void reviewUncontactablePartner()
3499 
			throws ProfitMandiBusinessException, MessagingException, UnsupportedEncodingException {
3500 
 
3501 
		Map<Integer, CustomRetailer> customRetailerMap = retailerService.getFofoRetailers(true);
3502 
 
3503 
		List<Integer> pcrms = partnerCollectionRemarkRepository
3504 
				.selectMaxRemarkId(new ArrayList<>(customRetailerMap.keySet()));
3505 
 
3506 
		if (!pcrms.isEmpty()) {
3507 
			Map<Integer, PartnerCollectionRemark> partnerCollectionRemarksMap = partnerCollectionRemarkRepository
3508 
					.selectByIds(pcrms).stream().filter(x -> x.getRemark().equals(CollectionRemark.NOT_RESPONDING))
3509 
					.collect(Collectors.toMap(x -> x.getFofoId(), x -> x));
3510 
 
3511 
			if (!partnerCollectionRemarksMap.isEmpty()) {
3512 
				for (Map.Entry<String, Set<Integer>> storeGuyEntry : csService.getAuthUserPartnerIdMapping()
3513 
						.entrySet()) {
3514 
					List<PartnerCollectionRemark> filteredRows = storeGuyEntry.getValue().stream()
3515 
							.map(x -> partnerCollectionRemarksMap.get(x)).filter(x -> x != null)
3516 
							.collect(Collectors.toList());
30752 tejbeer 3517 
					String subject = "UNCONTACTABLE PARTNERS";
30421 tejbeer 3518 
					String messageText = this.getMessageForUncontacblePartner(filteredRows);
3519 
 
3520 
					MimeMessage message = mailSender.createMimeMessage();
3521 
					MimeMessageHelper helper = new MimeMessageHelper(message, true);
30752 tejbeer 3522 
					String[] email = new String[] { storeGuyEntry.getKey() };
30421 tejbeer 3523 
 
3524 
					helper.setSubject(subject);
3525 
					helper.setText(messageText, true);
3526 
					helper.setTo(email);
3527 
					InternetAddress senderAddress = new InternetAddress("noreply@smartdukaan.com",
3528 
							"Smartdukaan Alerts");
3529 
					helper.setFrom(senderAddress);
3530 
					mailSender.send(message);
3531 
 
3532 
					LOGGER.info("filteredRows {}", filteredRows);
3533 
 
3534 
				}
3535 
			}
30859 tejbeer 3536 
 
30421 tejbeer 3537 
		}
3538 
	}
3539 
 
30859 tejbeer 3540 
	@Autowired
3541 
	private LoanRepository loanRepository;
3542 
 
3543 
	@Autowired
3544 
	private LoanStatementRepository loanStatementRepository;
3545 
 
3546 
	@Autowired
3547 
	private SDCreditService sdCreditService;
3548 
 
3549 
	@Autowired
3550 
	private SDCreditRequirementRepository sdCreditRequirementRepository;
3551 
 
30936 tejbeer 3552 
	@Autowired
3553 
	private CurrentPartnerDailyInvestmentRepository currentPartnerDailyInvestmentRepository;
3554 
 
3555 
	@Autowired
3556 
	private TransactionRepository transactionRepository;
3557 
 
3558 
	@Autowired
31020 tejbeer 3559 
	private SanctionRequestRepository sanctionRequestRepository;
3560 
 
30859 tejbeer 3561 
	public void calculateInterestAccured() throws ProfitMandiBusinessException {
3562 
 
3563 
		List<Loan> loans = loanRepository.selectAllActiveLoan();
3564 
 
3565 
		if (!loans.isEmpty()) {
3566 
 
3567 
			for (Loan loan : loans) {
3568 
 
3569 
				List<LoanStatement> loanStatements = loanStatementRepository.selectByLoanId(loan.getId());
3570 
 
3571 
				Map<LoanReferenceType, Double> loanStatusAmount = loanStatements.stream().collect(Collectors.groupingBy(
3572 
						x -> x.getLoanReferenceType(), Collectors.summingDouble(x -> x.getAmount().doubleValue())));
3573 
 
3574 
				if (loan.getFreeDays() > 0) {
3575 
					LocalDateTime freeDaysLimitDate = loan.getCreatedOn().plusDays(loan.getFreeDays() - 1);
30936 tejbeer 3576 
 
3577 
					LOGGER.info("freeDaysLimitDate {}", freeDaysLimitDate);
30859 tejbeer 3578 
					if (LocalDateTime.now().isAfter(freeDaysLimitDate)) {
30936 tejbeer 3579 
						int loanStatementId = loanStatementRepository.selectLatestLoanSatement(loan.getFofoId(),
3580 
								loan.getId());
3581 
						LOGGER.info("loanStatementId {}", loanStatementId);
30859 tejbeer 3582 
 
30936 tejbeer 3583 
						if (loanStatementId != 0) {
3584 
 
3585 
							this.calculateInterest(loan, loanStatusAmount, loanStatementId);
3586 
 
3587 
						} else {
3588 
							sdCreditService.addInterest(freeDaysLimitDate.toLocalDate(), LocalDate.now(), loan,
3589 
									loanStatusAmount);
3590 
						}
3591 
 
30859 tejbeer 3592 
					}
3593 
				} else {
3594 
 
3595 
					int loanStatementId = loanStatementRepository.selectLatestLoanSatement(loan.getFofoId(),
3596 
							loan.getId());
30936 tejbeer 3597 
					LOGGER.info("loanStatementId2 {}", loanStatementId);
30859 tejbeer 3598 
 
30936 tejbeer 3599 
					this.calculateInterest(loan, loanStatusAmount, loanStatementId);
30859 tejbeer 3600 
 
3601 
				}
3602 
 
3603 
			}
3604 
		}
3605 
 
3606 
	}
3607 
 
31332 amit.gupta 3608 
	@Autowired
3609 
	FofoPaymentRepository fofoPaymentRepository;
3610 
 
3611 
	@Autowired
3612 
	CCAvenuePaymentService ccAvenuePaymentService;
31604 tejbeer 3613 
 
31332 amit.gupta 3614 
	public void settleCCAvePayments() throws Exception {
31604 tejbeer 3615 
		List<FofoPayment> fofoPayments = fofoPaymentRepository
3616 
				.selectAllByGatewayStatus(Gateway.CCAVENUE, PaymentStatus.INIT).stream()
3617 
				.filter(x -> x.getCreateTimestamp().isBefore(LocalDateTime.now().minusMinutes(30l)))
3618 
				.collect(Collectors.toList());
31332 amit.gupta 3619 
		for (FofoPayment fofoPayment : fofoPayments) {
3620 
			ccAvenuePaymentService.updatePayment(fofoPayment);
3621 
		}
3622 
	}
3623 
 
31604 tejbeer 3624 
	/*
3625 
	 * public void getCCAvenuePendingOrderStatus(int pendingOrderId) { PendingOrder
3626 
	 * pendingOrder = pendingOrderRepository.selectById(pendingOrderId);
3627 
	 * ccAvenuePaymentService.getPaymentStatusMap(pendingOrder); }
3628 
	 */
31518 amit.gupta 3629 
 
30936 tejbeer 3630 
	private void calculateInterest(Loan loan, Map<LoanReferenceType, Double> loanStatusAmount, int loanStatementId)
3631 
			throws ProfitMandiBusinessException {
3632 
		LoanStatement loanStatement = loanStatementRepository.selectById(loanStatementId);
3633 
 
3634 
		if (loanStatement.getLoanId() == loan.getId()) {
3635 
 
3636 
			sdCreditService.addInterest(loanStatement.getCreatedAt().toLocalDate(), LocalDate.now(), loan,
3637 
					loanStatusAmount);
3638 
 
3639 
		} else {
3640 
			throw new ProfitMandiBusinessException("loanstament", loanStatement.getLoanId(), "Invalid LoanId");
3641 
		}
3642 
	}
3643 
 
31020 tejbeer 3644 
	public void loanSettlement() throws Exception {
30859 tejbeer 3645 
		List<Loan> loans = loanRepository.selectAllActiveLoan();
3646 
 
3647 
		if (!loans.isEmpty()) {
3648 
 
3649 
			for (Loan loan : loans) {
3650 
 
3651 
				UserWallet userWallet = userWalletRepository.selectByRetailerId(loan.getFofoId());
3652 
				SDCreditRequirement sdCreditRequirement = sdCreditRequirementRepository
3653 
						.selectByFofoId(loan.getFofoId());
3654 
 
3655 
				if (userWallet.getAmount() >= 100) {
3656 
					List<LoanStatement> loanStatements = loanStatementRepository.selectByLoanId(loan.getId());
3657 
 
31175 tejbeer 3658 
					LOGGER.info("loanStatements {}", loanStatements);
3659 
 
30859 tejbeer 3660 
					Map<LoanReferenceType, Double> loanStatusAmount = loanStatements.stream()
3661 
							.collect(Collectors.groupingBy(x -> x.getLoanReferenceType(),
31177 tejbeer 3662 
									Collectors.summingDouble(x -> FormattingUtils.serialize(x.getAmount()))));
30859 tejbeer 3663 
 
3664 
					LOGGER.info("loanStatusAmount {}", loanStatusAmount);
31020 tejbeer 3665 
					Double interestAmount = loanStatusAmount.get(LoanReferenceType.INTEREST);
30859 tejbeer 3666 
 
31020 tejbeer 3667 
					if (interestAmount == null) {
3668 
						interestAmount = (double) 0;
3669 
					}
3670 
 
30859 tejbeer 3671 
					double principalAmount = loanStatusAmount.get(LoanReferenceType.PRINCIPAL);
3672 
					double paidAmount = 0;
3673 
					if (userWallet.getAmount() > Math.abs(interestAmount)) {
3674 
 
31175 tejbeer 3675 
						LOGGER.info("interestAmount b {}", interestAmount);
3676 
 
31177 tejbeer 3677 
						if (interestAmount < 0) {
31175 tejbeer 3678 
							LOGGER.info("interestAmount a {}", interestAmount);
30859 tejbeer 3679 
 
3680 
							settledLoanStatement(LoanReferenceType.INTEREST, BigDecimal.valueOf(interestAmount),
3681 
									loan.getFofoId(), loan.getId(), "Amount adjusted against loan",
3682 
									LocalDateTime.now());
3683 
							loan.setInterestPaid(loan.getInterestPaid().add(BigDecimal.valueOf(interestAmount).abs()));
3684 
 
3685 
							paidAmount += Math.abs(interestAmount);
3686 
						}
3687 
 
3688 
						double userWalletAmount = userWallet.getAmount() - Math.abs(interestAmount);
3689 
 
31177 tejbeer 3690 
						if (userWalletAmount > Math.abs(principalAmount) && principalAmount < 0) {
30859 tejbeer 3691 
 
3692 
							settledLoanStatement(LoanReferenceType.PRINCIPAL, BigDecimal.valueOf(principalAmount),
3693 
									loan.getFofoId(), loan.getId(), "Amount adjusted against loan",
3694 
									LocalDateTime.now());
3695 
							double amount = userWalletAmount - Math.abs(principalAmount);
3696 
 
3697 
							paidAmount += Math.abs(principalAmount);
3698 
 
3699 
							userWallet.setAmount((int) amount);
3700 
 
31020 tejbeer 3701 
							BigDecimal utilizationAmount = sdCreditRequirement.getUtilizedAmount()
3702 
									.subtract(BigDecimal.valueOf(principalAmount).abs());
3703 
 
31110 tejbeer 3704 
							sdCreditRequirement.setUtilizedAmount(utilizationAmount);
3705 
 
3706 
							CreditAccount creditAccount = creditAccountRepository
3707 
									.selectByFofoIdAndGateway(loan.getFofoId(), Gateway.SDDIRECT);
3708 
 
3709 
							creditAccount.setAvailableAmount(sdCreditRequirement.getAvailableLimit().floatValue());
3710 
							creditAccount.setUpdatedOn(LocalDateTime.now());
3711 
 
30859 tejbeer 3712 
							loan.setPendingAmount(BigDecimal.ZERO);
3713 
 
31177 tejbeer 3714 
						} else if (principalAmount < 0) {
30859 tejbeer 3715 
 
3716 
							settledLoanStatement(LoanReferenceType.PRINCIPAL, BigDecimal.valueOf(userWalletAmount),
3717 
									loan.getFofoId(), loan.getId(), "Amount adjusted against loan",
3718 
									LocalDateTime.now());
3719 
 
3720 
							paidAmount += Math.abs(userWalletAmount);
3721 
 
31020 tejbeer 3722 
							BigDecimal availableLimit = sdCreditRequirement.getAvailableLimit()
3723 
									.add(BigDecimal.valueOf(userWalletAmount)).abs();
3724 
 
3725 
							BigDecimal utilizationAmount = sdCreditRequirement.getUtilizedAmount()
3726 
									.subtract(BigDecimal.valueOf(userWalletAmount)).abs();
3727 
 
31110 tejbeer 3728 
							sdCreditRequirement.setUtilizedAmount(utilizationAmount);
31020 tejbeer 3729 
 
31110 tejbeer 3730 
							CreditAccount creditAccount = creditAccountRepository
3731 
									.selectByFofoIdAndGateway(loan.getFofoId(), Gateway.SDDIRECT);
3732 
 
3733 
							creditAccount.setAvailableAmount(sdCreditRequirement.getAvailableLimit().floatValue());
3734 
							creditAccount.setUpdatedOn(LocalDateTime.now());
30859 tejbeer 3735 
							userWallet.setAmount(0);
3736 
 
3737 
							loan.setPendingAmount(
3738 
									loan.getPendingAmount().subtract(BigDecimal.valueOf(userWalletAmount)));
3739 
 
3740 
						}
3741 
 
3742 
						createUserWalletHistory(userWallet.getId(), userWallet.getUserId(),
3743 
								WalletReferenceType.LOAN_REPAYMENT, loan.getId(), Math.abs(paidAmount));
3744 
 
3745 
					} else {
3746 
 
3747 
						settledLoanStatement(LoanReferenceType.INTEREST, BigDecimal.valueOf(userWallet.getAmount()),
3748 
								loan.getFofoId(), loan.getId(), "Amount adjusted against loan", LocalDateTime.now());
3749 
 
3750 
						paidAmount += Math.abs(userWallet.getAmount());
3751 
 
3752 
						createUserWalletHistory(userWallet.getId(), userWallet.getUserId(),
3753 
								WalletReferenceType.LOAN_REPAYMENT, loan.getId(), Math.abs(paidAmount));
3754 
 
3755 
						loan.setInterestPaid(
3756 
								loan.getInterestPaid().add(BigDecimal.valueOf(userWallet.getAmount()).abs()));
3757 
 
3758 
						userWallet.setAmount(0);
3759 
					}
3760 
 
3761 
				}
3762 
			}
30999 tejbeer 3763 
 
31020 tejbeer 3764 
			List<Order> allOrders = orderRepository.selectHoldOrder();
3765 
 
3766 
			LOGGER.info("allOrders {}", allOrders);
3767 
 
3768 
			if (!allOrders.isEmpty()) {
3769 
				Map<Integer, List<Order>> transactionOrdersMap = allOrders.stream()
3770 
						.collect(Collectors.groupingBy(Order::getTransactionId, Collectors.toList()));
3771 
				LinkedHashMap<Integer, List<Order>> sortedTransactionOrdersMap = new LinkedHashMap<>();
3772 
				transactionOrdersMap.entrySet().stream().sorted(Map.Entry.comparingByKey())
3773 
						.forEachOrdered(x -> sortedTransactionOrdersMap.put(x.getKey(), x.getValue()));
3774 
				LOGGER.info("sortedTransactionOrdersMap {}", sortedTransactionOrdersMap);
3775 
 
3776 
				for (Entry<Integer, List<Order>> transactionOrdersEntry : sortedTransactionOrdersMap.entrySet()) {
3777 
 
3778 
					List<Order> orders = transactionOrdersEntry.getValue();
3779 
 
3780 
					double totalAmount = orders.stream().collect(Collectors.summingDouble(x -> x.getTotalAmount()));
3781 
 
3782 
					LocalDateTime createDate = orders.get(0).getCreateTimestamp();
3783 
 
3784 
					int fofoId = orders.get(0).getRetailerId();
3785 
 
3786 
					int transactionId = transactionOrdersEntry.getKey();
3787 
 
3788 
					SanctionRequest sanctionRequest = sanctionRequestRepository.selectByTransactionId(transactionId);
3789 
 
3790 
					double loanSettleAmount = loanStatementRepository.selectByDateAndFofoId(createDate, fofoId).stream()
3791 
							.filter(x -> x.getAmount().doubleValue() > 0)
3792 
							.collect(Collectors.summingDouble(x -> x.getAmount().doubleValue()));
3793 
 
3794 
					LOGGER.info("loanSettleAmount {}", loanSettleAmount);
3795 
 
3796 
					LOGGER.info("totalAmount {}", totalAmount);
3797 
					if (loanSettleAmount >= sanctionRequest.getUtilizationAmount().doubleValue()) {
3798 
 
3799 
						LOGGER.info("totalAmount {}", totalAmount);
3800 
 
3801 
						orders.forEach(x -> x.setShipmentHold(false));
3802 
 
3803 
						List<String> authUserEmail = csService.getAuthUserIdByPartnerId(orders.get(0).getRetailerId())
3804 
								.stream().map(x -> x.getEmailId()).collect(Collectors.toList());
3805 
						authUserEmail.add("vinay.p@smartdukaan.com");
3806 
						authUserEmail.add("shivam.gupta@smartdukaan.com");
3807 
 
3808 
						String[] emailTo = authUserEmail.toArray(new String[authUserEmail.size()]);
3809 
 
3810 
						String[] ccTo = { "tarun.verma@smartdukaan.com", "kamini.sharma@smartdukaan.com" };
3811 
 
3812 
						String subject = "Dispatched " + (orders.get(0).getRetailerName());
31218 tejbeer 3813 
						String message = String.format("Dear Team, \n" + "kindly note the material for the "
31020 tejbeer 3814 
								+ orders.get(0).getRetailerName() + "of Rs." + totalAmount + "is dispatched.");
3815 
 
3816 
						Utils.sendMailWithAttachments(mailSender, emailTo, ccTo, subject, message);
3817 
 
3818 
					}
3819 
 
3820 
				}
3821 
			}
3822 
 
30859 tejbeer 3823 
		}
3824 
 
3825 
	}
3826 
 
3827 
	private void settledLoanStatement(LoanReferenceType loanReferneceType, BigDecimal amount, int fofoId, int loanId,
3828 
			String description, LocalDateTime now) {
3829 
 
3830 
		sdCreditService.createLoanStatement(loanReferneceType, amount.abs(), fofoId, loanId, description,
3831 
				LocalDateTime.now());
3832 
 
3833 
	}
3834 
 
3835 
	private void createUserWalletHistory(int walletId, int userId, WalletReferenceType referenceType, int loanId,
3836 
			double interestAmount) {
3837 
		UserWalletHistory uwh = new UserWalletHistory();
3838 
		uwh.setWalletId(walletId);
3839 
		uwh.setFofoId(userId);
3840 
		uwh.setBusinessTimestamp(LocalDateTime.now());
3841 
		uwh.setReferenceType(referenceType);
3842 
		uwh.setReference(loanId);
3843 
		uwh.setTimestamp(LocalDateTime.now());
3844 
		uwh.setAmount((int) -(interestAmount));
30908 tejbeer 3845 
		uwh.setDescription("Amount adjusted against loan");
30859 tejbeer 3846 
		userWalletHistoryRepository.persist(uwh);
3847 
 
3848 
	}
3849 
 
30965 tejbeer 3850 
	public void dailyLoanAlert()
3851 
			throws ProfitMandiBusinessException, HttpHostConnectException, UnsupportedEncodingException {
30859 tejbeer 3852 
		List<Loan> loans = loanRepository.selectAllActiveLoan();
3853 
 
3854 
		Map<Integer, Double> partnerLoanAmount = new HashMap<>();
3855 
 
3856 
		if (!loans.isEmpty()) {
3857 
 
3858 
			for (Loan loan : loans) {
3859 
 
3860 
				List<LoanStatement> loanStatements = loanStatementRepository.selectByLoanId(loan.getId());
3861 
 
3862 
				double amount = loanStatements.stream().map(x -> x.getAmount())
3863 
						.collect(Collectors.summingDouble(x -> x.doubleValue()));
3864 
				if (partnerLoanAmount.get(loan.getFofoId()) != null) {
3865 
					amount += partnerLoanAmount.get(loan.getFofoId());
3866 
					partnerLoanAmount.put(loan.getFofoId(), amount);
3867 
				} else {
3868 
					partnerLoanAmount.put(loan.getFofoId(), amount);
3869 
				}
3870 
 
3871 
			}
3872 
 
3873 
		}
3874 
 
3875 
		if (!partnerLoanAmount.isEmpty()) {
3876 
 
3877 
			for (Entry<Integer, Double> partnerLoanAmountEnrty : partnerLoanAmount.entrySet()) {
3878 
 
3879 
				int fofoId = partnerLoanAmountEnrty.getKey();
3880 
 
30965 tejbeer 3881 
				com.spice.profitmandi.dao.entity.user.User user = userUserRepository.selectById(fofoId);
3882 
 
3883 
				Address address = addressRepository.selectById(user.getAddressId());
3884 
 
3885 
				String title = "Alert Credit Outstanding!";
30859 tejbeer 3886 
				String url = "http://app.smartdukaan.com/pages/home/credit";
30989 tejbeer 3887 
				String message = "Your total pending Loan amount is Rs."
3888 
						+ FormattingUtils.formatDecimal(Math.abs(partnerLoanAmountEnrty.getValue())) + ".";
30859 tejbeer 3889 
				notificationService.sendNotification(fofoId, title, MessageType.notification, title, message, url);
3890 
 
30989 tejbeer 3891 
				notificationService.sendWhatsappMessage(message, title, address.getPhoneNumber());
30965 tejbeer 3892 
 
30859 tejbeer 3893 
			}
3894 
 
3895 
		}
3896 
 
3897 
	}
3898 
 
30896 amit.gupta 3899 
	public void processActivatedImeisForSchemes() throws ProfitMandiBusinessException {
3900 
		schemeService.processActivatedImeisForSchemes();
3901 
	}
3902 
 
30913 tejbeer 3903 
	public void updatePartnerLimit() throws ProfitMandiBusinessException {
3904 
		Map<Integer, CustomRetailer> customRetailerMap = retailerService.getFofoRetailers(true);
3905 
 
3906 
		Map<Integer, SDCreditRequirement> sdCreditRequirementMap = sdCreditRequirementRepository.selectAll().stream()
3907 
				.collect(Collectors.toMap(x -> x.getFofoId(), x -> x));
3908 
		Map<Integer, CurrentPartnerDailyInvestment> currentPartnerDailyInvestmentMap = currentPartnerDailyInvestmentRepository
3909 
				.selectAll().stream().collect(Collectors.toMap(x -> x.getFofoId(), x -> x));
30933 tejbeer 3910 
		double limitValue = 100000;
30913 tejbeer 3911 
		for (Entry<Integer, CustomRetailer> customRetailerEntry : customRetailerMap.entrySet()) {
3912 
			int fofoId = customRetailerEntry.getKey();
3913 
			SDCreditRequirement sdCreditRequirement = sdCreditRequirementMap.get(customRetailerEntry.getKey());
30929 tejbeer 3914 
			LocalDateTime firstBillingDate = transactionRepository.getFirstBillingDate(fofoId);
30913 tejbeer 3915 
			CurrentPartnerDailyInvestment currentPartnerDailyInvestment = currentPartnerDailyInvestmentMap.get(fofoId);
3916 
			BigDecimal suggestedAmount = BigDecimal.ZERO;
3917 
			if (currentPartnerDailyInvestment != null) {
3918 
				suggestedAmount = BigDecimal.valueOf(currentPartnerDailyInvestment.getTotalInvestment() * 0.1);
3919 
			}
3920 
 
30933 tejbeer 3921 
			if (suggestedAmount.doubleValue() > limitValue) {
30917 tejbeer 3922 
 
30933 tejbeer 3923 
				suggestedAmount = BigDecimal.valueOf(limitValue);
30917 tejbeer 3924 
 
3925 
			}
30920 tejbeer 3926 
 
3927 
			if (suggestedAmount.doubleValue() < 0) {
3928 
				suggestedAmount = BigDecimal.ZERO;
3929 
			}
3930 
 
30913 tejbeer 3931 
			LOGGER.info("suggestedAmount {} ", suggestedAmount);
3932 
 
3933 
			if (sdCreditRequirement == null) {
3934 
				sdCreditRequirement = new SDCreditRequirement();
3935 
				sdCreditRequirement.setFofoId(fofoId);
3936 
				sdCreditRequirement.setCreditDays(15);
3937 
				sdCreditRequirement.setInterestRate(BigDecimal.valueOf(0.05));
3938 
				sdCreditRequirement.setSuggestedLimit(suggestedAmount);
30929 tejbeer 3939 
				sdCreditRequirement.setRisk(CreditRisk.HIGH_RISK);
30913 tejbeer 3940 
				sdCreditRequirement.setLimit(suggestedAmount);
3941 
				sdCreditRequirement.setUtilizedAmount(BigDecimal.ZERO);
3942 
				sdCreditRequirement.setCreateTimestamp(LocalDateTime.now());
3943 
				sdCreditRequirement.setUpdateTimestamp(LocalDateTime.now());
3944 
				sdCreditRequirementRepository.persist(sdCreditRequirement);
3945 
			}
30929 tejbeer 3946 
 
30936 tejbeer 3947 
			CreditRisk creditRisk = sdCreditService.getCurrentRisk(sdCreditRequirement, firstBillingDate);
30929 tejbeer 3948 
 
3949 
			sdCreditRequirement.setRisk(creditRisk);
3950 
 
30913 tejbeer 3951 
			sdCreditRequirement.setSuggestedLimit(suggestedAmount);
3952 
			sdCreditRequirement.setLimit(suggestedAmount);
3953 
			BigDecimal utilizedLimit = new BigDecimal(sdCreditService.getUtilizationAmount(fofoId));
3954 
 
3955 
			BigDecimal availableLimit = sdCreditRequirement.getLimit().subtract(utilizedLimit);
3956 
 
3957 
			LOGGER.info("utilizedLimit {} ", utilizedLimit);
3958 
 
3959 
			LOGGER.info("availableLimit {} ", availableLimit);
3960 
 
3961 
			sdCreditRequirement.setUtilizedAmount(utilizedLimit);
3962 
 
3963 
			sdCreditRequirement.setUpdateTimestamp(LocalDateTime.now());
3964 
 
30934 tejbeer 3965 
			CreditAccount creditAccount = creditAccountRepository
3966 
					.selectByFofoIdAndGateway(sdCreditRequirement.getFofoId(), Gateway.SDDIRECT);
30965 tejbeer 3967 
			if (creditAccount != null) {
30934 tejbeer 3968 
 
30965 tejbeer 3969 
				creditAccount.setInterestRate(sdCreditRequirement.getInterestRate().floatValue());
3970 
				creditAccount.setSanctionedAmount(sdCreditRequirement.getLimit().floatValue());
3971 
				creditAccount.setAvailableAmount(availableLimit.floatValue());
3972 
				creditAccount.setFreeDays(sdCreditRequirement.getFreeDays());
30934 tejbeer 3973 
				creditAccount.setUpdatedOn(LocalDateTime.now());
3974 
			}
3975 
 
30913 tejbeer 3976 
		}
3977 
 
3978 
	}
3979 
 
30936 tejbeer 3980 
	public void notifyDefaultLoans() throws ProfitMandiBusinessException, MessagingException, IOException {
30929 tejbeer 3981 
 
30936 tejbeer 3982 
		sdCreditService.updateRisk();
3983 
		List<Loan> defaultLoans = sdCreditService.getDefaultLoan();
3984 
		if (!defaultLoans.isEmpty()) {
3985 
			this.sendDefaultLoanAlert(defaultLoans);
30929 tejbeer 3986 
		}
3987 
 
3988 
	}
3989 
 
30936 tejbeer 3990 
	public void sendDefaultLoanAlert(List<Loan> defaultLoans)
3991 
			throws ProfitMandiBusinessException, MessagingException, IOException {
3992 
		String subject = "Default Partners";
30929 tejbeer 3993 
 
31218 tejbeer 3994 
		List<Integer> categoryIds = Arrays.asList(ProfitMandiConstants.TICKET_CATEGORY_CATEGORY,
3995 
				ProfitMandiConstants.TICKET_CATEGORY_RBM, ProfitMandiConstants.TICKET_CATEGORY_SALES,
3996 
				ProfitMandiConstants.TICKET_CATEGORY_ACCOUNTS,
3997 
				ProfitMandiConstants.TICKET_CATEGORY_BUSINESSINTELLIGENT);
31177 tejbeer 3998 
 
31218 tejbeer 3999 
		for (Map.Entry<String, Set<Integer>> storeGuyEntry : csService
31518 amit.gupta 4000 
				.getAuthUserPartnerIdMappingByCategoryIds(categoryIds, false).entrySet()) {
30936 tejbeer 4001 
			List<Loan> filteredRows = new ArrayList<>();
4002 
			for (Loan loan : defaultLoans) {
30929 tejbeer 4003 
 
30936 tejbeer 4004 
				if (storeGuyEntry.getValue().contains(loan.getFofoId())) {
30929 tejbeer 4005 
 
30936 tejbeer 4006 
					filteredRows.add(loan);
30929 tejbeer 4007 
				}
4008 
			}
30936 tejbeer 4009 
			if (!filteredRows.isEmpty()) {
4010 
				String messageText = this.getMessageForDueDateExtend(filteredRows);
4011 
				String[] email = new String[] { storeGuyEntry.getKey() };
30929 tejbeer 4012 
 
30936 tejbeer 4013 
				this.sendMailHtmlFormat(email, messageText, null, subject);
30929 tejbeer 4014 
 
30931 tejbeer 4015 
			}
4016 
 
30936 tejbeer 4017 
		}
30929 tejbeer 4018 
 
30936 tejbeer 4019 
		for (Loan defaultLoan : defaultLoans) {
4020 
			List<LoanStatement> loanStatements = loanStatementRepository.selectByLoanId(defaultLoan.getId());
30929 tejbeer 4021 
 
30936 tejbeer 4022 
			double amount = loanStatements.stream().map(x -> x.getAmount())
4023 
					.collect(Collectors.summingDouble(x -> x.doubleValue()));
30929 tejbeer 4024 
 
30982 tejbeer 4025 
			com.spice.profitmandi.dao.entity.user.User user = userUserRepository.selectById(defaultLoan.getFofoId());
4026 
 
4027 
			Address address = addressRepository.selectById(user.getAddressId());
4028 
 
30989 tejbeer 4029 
			String title = "Loan Amount Overdue!";
30936 tejbeer 4030 
			String url = "http://app.smartdukaan.com/pages/home/credit";
30989 tejbeer 4031 
			String message = "Your loan due date "
30936 tejbeer 4032 
					+ defaultLoan.getDueDate().toLocalDate().format(DateTimeFormatter.ofPattern("dd-MM-yyyy"))
30991 tejbeer 4033 
					+ " has been exceeded. Additional penal interest of "
4034 
					+ defaultLoan.getInterestRate().setScale(2, RoundingMode.HALF_UP)
30989 tejbeer 4035 
					+ "%  and Rs.100 shall be levied on daily basis." + " Your total pending Loan amount is Rs."
30991 tejbeer 4036 
					+ FormattingUtils.formatDecimal(Math.abs(amount)) + ". !!Pay Now!!";
30936 tejbeer 4037 
			notificationService.sendNotification(defaultLoan.getFofoId(), title, MessageType.notification, title,
4038 
					message, url);
4039 
 
31397 tejbeer 4040 
			// notificationService.sendWhatsappMessage(message, title,
4041 
			// address.getPhoneNumber());
30982 tejbeer 4042 
 
30929 tejbeer 4043 
		}
4044 
	}
4045 
 
4046 
	private String getMessageForDueDateExtend(List<Loan> loans) throws ProfitMandiBusinessException {
4047 
		StringBuilder sb = new StringBuilder();
30936 tejbeer 4048 
		sb.append(
4049 
				"<html><body><p>Alert</p><p>Default Partners :-</p>" + "<br/><p>EveryDay Rs.100 charged as Penalty</p>"
4050 
						+ "<br/><table style='border:1px solid black ;padding: 5px';>");
30929 tejbeer 4051 
		sb.append("<tbody>\n" + "	    				<tr>\n"
4052 
				+ "	    					<th style='border:1px solid black;padding: 5px'>PartnerName</th>\n"
4053 
				+ "	    					<th style='border:1px solid black;padding: 5px'>due date</th>\n"
4054 
				+ "	    					<th style='border:1px solid black;padding: 5px'>Days</th>\n"
30936 tejbeer 4055 
				+ "	    					<th style='border:1px solid black;padding: 5px'>Pending Amount</th>\n"
30929 tejbeer 4056 
 
4057 
				+ "	    				</tr>");
4058 
		for (Loan entry : loans) {
30936 tejbeer 4059 
 
4060 
			List<LoanStatement> loanStatements = loanStatementRepository.selectByLoanId(entry.getId());
4061 
 
4062 
			double amount = loanStatements.stream().map(x -> x.getAmount())
4063 
					.collect(Collectors.summingDouble(x -> x.doubleValue()));
4064 
 
30929 tejbeer 4065 
			long noOfdaysBetween = ChronoUnit.DAYS.between(entry.getDueDate().toLocalDate(), LocalDateTime.now());
4066 
 
4067 
			CustomRetailer customRetailer = retailerService.getFofoRetailer(entry.getFofoId());
4068 
 
4069 
			sb.append("<tr>");
4070 
			sb.append("<td style='border:1px solid black;padding: 5px'>" + customRetailer.getBusinessName() + "("
4071 
					+ customRetailer.getCode() + ")" + "</td>");
4072 
 
4073 
			sb.append("<td style='border:1px solid black;padding: 5px'>"
4074 
					+ entry.getDueDate().format(DateTimeFormatter.ofPattern("dd/MM/yyyy")) + "</td>");
4075 
			sb.append("<td style='border:1px solid black;padding: 5px'>" + noOfdaysBetween + "</td>");
30936 tejbeer 4076 
			sb.append("<td style='border:1px solid black;padding: 5px'>"
4077 
					+ new DecimalFormat("#.##").format(Math.abs(amount)) + "</td>");
30929 tejbeer 4078 
 
4079 
			sb.append("</tr>");
4080 
 
4081 
		}
4082 
 
4083 
		sb.append("</tbody></table></body></html>");
4084 
 
4085 
		return sb.toString();
4086 
	}
4087 
 
31397 tejbeer 4088 
	private String getMessageForDueDateCross(List<Loan> loans) throws ProfitMandiBusinessException {
4089 
		StringBuilder sb = new StringBuilder();
4090 
		sb.append("<html><body><p>Alert</p><p>Due Date Cross Partners :-</p>"
4091 
				+ "<br/><p>Additional penal interest of  shall be levied on daily basis.</p>"
4092 
				+ "<br/><table style='border:1px solid black ;padding: 5px';>");
4093 
		sb.append("<tbody>\n" + "	    				<tr>\n"
4094 
				+ "	    					<th style='border:1px solid black;padding: 5px'>PartnerName</th>\n"
4095 
				+ "	    					<th style='border:1px solid black;padding: 5px'>due date</th>\n"
4096 
				+ "	    					<th style='border:1px solid black;padding: 5px'>Days</th>\n"
4097 
				+ "	    					<th style='border:1px solid black;padding: 5px'>Pending Amount</th>\n"
4098 
 
4099 
				+ "	    				</tr>");
4100 
		for (Loan entry : loans) {
4101 
 
4102 
			List<LoanStatement> loanStatements = loanStatementRepository.selectByLoanId(entry.getId());
4103 
 
4104 
			double amount = loanStatements.stream().map(x -> x.getAmount())
4105 
					.collect(Collectors.summingDouble(x -> x.doubleValue()));
4106 
 
4107 
			long noOfdaysBetween = ChronoUnit.DAYS.between(entry.getDueDate().toLocalDate(), LocalDateTime.now());
4108 
 
4109 
			CustomRetailer customRetailer = retailerService.getFofoRetailer(entry.getFofoId());
4110 
 
4111 
			sb.append("<tr>");
4112 
			sb.append("<td style='border:1px solid black;padding: 5px'>" + customRetailer.getBusinessName() + "("
4113 
					+ customRetailer.getCode() + ")" + "</td>");
4114 
 
4115 
			sb.append("<td style='border:1px solid black;padding: 5px'>"
4116 
					+ entry.getDueDate().format(DateTimeFormatter.ofPattern("dd/MM/yyyy")) + "</td>");
4117 
			sb.append("<td style='border:1px solid black;padding: 5px'>" + noOfdaysBetween + "</td>");
4118 
			sb.append("<td style='border:1px solid black;padding: 5px'>"
4119 
					+ new DecimalFormat("#.##").format(Math.abs(amount)) + "</td>");
4120 
 
4121 
			sb.append("</tr>");
4122 
 
4123 
		}
4124 
 
4125 
		sb.append("</tbody></table></body></html>");
4126 
 
4127 
		return sb.toString();
4128 
	}
4129 
 
30936 tejbeer 4130 
	public void notifyLoanDueDateCross() throws ProfitMandiBusinessException, MessagingException, IOException {
4131 
 
31397 tejbeer 4132 
		List<Loan> dueDateCrossLoans = sdCreditService.getDueDateCrossLoan();
4133 
		if (!dueDateCrossLoans.isEmpty()) {
4134 
			this.sendDueDateCrossLoanAlert(dueDateCrossLoans);
4135 
		}
30936 tejbeer 4136 
 
31397 tejbeer 4137 
	}
4138 
 
4139 
	private void sendDueDateCrossLoanAlert(List<Loan> dueDateCrossLoans)
4140 
			throws ProfitMandiBusinessException, MessagingException, IOException {
4141 
		List<Integer> categoryIds = Arrays.asList(ProfitMandiConstants.TICKET_CATEGORY_CATEGORY,
4142 
				ProfitMandiConstants.TICKET_CATEGORY_RBM, ProfitMandiConstants.TICKET_CATEGORY_SALES,
4143 
				ProfitMandiConstants.TICKET_CATEGORY_ACCOUNTS,
4144 
				ProfitMandiConstants.TICKET_CATEGORY_BUSINESSINTELLIGENT);
4145 
 
4146 
		for (Map.Entry<String, Set<Integer>> storeGuyEntry : csService
31518 amit.gupta 4147 
				.getAuthUserPartnerIdMappingByCategoryIds(categoryIds, false).entrySet()) {
31397 tejbeer 4148 
			List<Loan> filteredRows = new ArrayList<>();
4149 
			for (Loan loan : dueDateCrossLoans) {
4150 
 
4151 
				if (storeGuyEntry.getValue().contains(loan.getFofoId())) {
4152 
 
4153 
					filteredRows.add(loan);
4154 
				}
4155 
			}
4156 
			if (!filteredRows.isEmpty()) {
4157 
				String messageText = this.getMessageForDueDateCross(filteredRows);
4158 
				String[] email = new String[] { storeGuyEntry.getKey() };
4159 
 
4160 
				this.sendMailHtmlFormat(email, messageText, null, "Due Date Cross");
4161 
 
4162 
			}
4163 
 
4164 
		}
4165 
		if (!dueDateCrossLoans.isEmpty()) {
4166 
			for (Loan loan : dueDateCrossLoans) {
4167 
 
30936 tejbeer 4168 
				long noOfdaysBetween = ChronoUnit.DAYS.between(loan.getDueDate().toLocalDate(), LocalDate.now());
4169 
 
30982 tejbeer 4170 
				com.spice.profitmandi.dao.entity.user.User user = userUserRepository.selectById(loan.getFofoId());
4171 
 
4172 
				Address address = addressRepository.selectById(user.getAddressId());
4173 
 
30936 tejbeer 4174 
				LOGGER.info("noOfdaysBetween {} ", noOfdaysBetween);
4175 
 
31397 tejbeer 4176 
				List<LoanStatement> loanStatements = loanStatementRepository.selectByLoanId(loan.getId());
30936 tejbeer 4177 
 
31397 tejbeer 4178 
				double amount = loanStatements.stream().map(x -> x.getAmount())
4179 
						.collect(Collectors.summingDouble(x -> x.doubleValue()));
30936 tejbeer 4180 
 
31397 tejbeer 4181 
				String url = "http://app.smartdukaan.com/pages/home/credit";
30989 tejbeer 4182 
 
31397 tejbeer 4183 
				String title = "Alert!";
4184 
				String message = "Your loan due date "
4185 
						+ loan.getDueDate().toLocalDate().format(DateTimeFormatter.ofPattern("dd-MM-yyyy"))
4186 
						+ " has been exceeded. Additional penal interest of "
4187 
						+ loan.getInterestRate().setScale(2, RoundingMode.HALF_UP)
4188 
						+ "% shall be levied on daily basis. Your total pending loan amount is Rs."
4189 
						+ FormattingUtils.formatDecimal(Math.abs(amount)) + ". !!Pay Now!!";
30989 tejbeer 4190 
 
31397 tejbeer 4191 
				notificationService.sendNotification(loan.getFofoId(), title, MessageType.notification, title, message,
4192 
						url);
30982 tejbeer 4193 
 
31397 tejbeer 4194 
				notificationService.sendWhatsappMessage(message, title, address.getPhoneNumber());
30982 tejbeer 4195 
 
30936 tejbeer 4196 
			}
4197 
		}
4198 
 
4199 
	}
4200 
 
4201 
	public void alertForDueDate() throws ProfitMandiBusinessException, MessagingException, IOException {
4202 
 
4203 
		List<Loan> loans = loanRepository.selectAllActiveLoan();
4204 
 
4205 
		if (!loans.isEmpty()) {
4206 
			for (Loan loan : loans) {
4207 
 
30982 tejbeer 4208 
				com.spice.profitmandi.dao.entity.user.User user = userUserRepository.selectById(loan.getFofoId());
4209 
 
4210 
				Address address = addressRepository.selectById(user.getAddressId());
4211 
 
30936 tejbeer 4212 
				long noOfdaysBetween = ChronoUnit.DAYS.between(LocalDate.now(), loan.getDueDate().toLocalDate());
4213 
 
4214 
				LOGGER.info("noOfdaysBetween {} ", noOfdaysBetween);
4215 
 
4216 
				if (noOfdaysBetween <= 4 && noOfdaysBetween >= 0) {
4217 
					List<LoanStatement> loanStatements = loanStatementRepository.selectByLoanId(loan.getId());
4218 
					double amount = loanStatements.stream().map(x -> x.getAmount())
4219 
							.collect(Collectors.summingDouble(x -> x.doubleValue()));
4220 
 
30965 tejbeer 4221 
					String title = "Alert!";
30936 tejbeer 4222 
					String url = "http://app.smartdukaan.com/pages/home/credit";
4223 
					String message = null;
4224 
					if (noOfdaysBetween == 0) {
4225 
 
4226 
						message = "Your total pending Loan amount is Rs."
4227 
								+ FormattingUtils.formatDecimal(Math.abs(amount)) + " is due for Today, Pay Now!!";
4228 
 
4229 
					} else {
4230 
 
4231 
						message = "Your total pending Loan amount is Rs."
4232 
								+ FormattingUtils.formatDecimal(Math.abs(amount)) + " is due by "
4233 
								+ loan.getDueDate().toLocalDate().format(DateTimeFormatter.ofPattern("dd-MM-yyyy"))
30989 tejbeer 4234 
								+ " , Pay Now!!";
30936 tejbeer 4235 
 
4236 
					}
4237 
					notificationService.sendNotification(loan.getFofoId(), title, MessageType.notification, title,
4238 
							message, url);
30989 tejbeer 4239 
					notificationService.sendWhatsappMessage(message, title, address.getPhoneNumber());
30982 tejbeer 4240 
 
30936 tejbeer 4241 
				}
4242 
			}
4243 
		}
4244 
 
4245 
	}
4246 
 
30982 tejbeer 4247 
	public void userMobileNumberOptIn() throws HttpHostConnectException, ProfitMandiBusinessException {
4248 
 
4249 
		List<FofoStore> fofoStores = fofoStoreRepository.selectActiveStores();
4250 
 
4251 
		List<com.spice.profitmandi.dao.entity.user.User> users = userUserRepository
4252 
				.selectByIds(fofoStores.stream().map(x -> x.getId()).collect(Collectors.toList()));
4253 
 
4254 
		List<Address> addresses = addressRepository
4255 
				.selectByIds(users.stream().map(x -> x.getAddressId()).collect(Collectors.toList()));
4256 
 
30984 tejbeer 4257 
		LOGGER.info("addresses" + addresses);
4258 
 
30982 tejbeer 4259 
		for (Address address : addresses) {
4260 
			Map<String, String> requestheaders = new HashMap<>();
4261 
			requestheaders.put("Content-Type", "application/x-www-form-urlencoded");
4262 
			Map<String, String> requestParams = new HashMap<>();
4263 
			requestParams.put("userid", String.valueOf(2000215976));
4264 
			requestParams.put("password", "MFRd!BBL");
30983 tejbeer 4265 
			requestParams.put("phone_number", address.getPhoneNumber());
30982 tejbeer 4266 
			requestParams.put("auth_scheme", "plain");
4267 
			requestParams.put("v", "1.1");
30983 tejbeer 4268 
			requestParams.put("format", "json");
30982 tejbeer 4269 
 
4270 
			requestParams.put("method", "OPT_IN");
4271 
 
4272 
			requestParams.put("channel", "WHATSAPP");
4273 
			String response = restClient.get("https://media.smsgupshup.com/GatewayAPI/rest", requestParams,
4274 
					requestheaders);
4275 
			LOGGER.info("response" + response);
4276 
		}
4277 
 
4278 
	}
4279 
 
4280 
	public void authUserMobileNumberOptIn() throws HttpHostConnectException, ProfitMandiBusinessException {
4281 
 
4282 
		List<AuthUser> authUsers = authRepository.selectAllActiveUser();
30984 tejbeer 4283 
		LOGGER.info("authUsers" + authUsers);
4284 
 
30982 tejbeer 4285 
		for (AuthUser authUser : authUsers) {
4286 
			Map<String, String> requestheaders = new HashMap<>();
4287 
			requestheaders.put("Content-Type", "application/x-www-form-urlencoded");
4288 
			Map<String, String> requestParams = new HashMap<>();
4289 
			requestParams.put("userid", String.valueOf(2000215976));
4290 
			requestParams.put("password", "MFRd!BBL");
30983 tejbeer 4291 
			requestParams.put("phone_number", authUser.getMobileNumber());
30982 tejbeer 4292 
			requestParams.put("auth_scheme", "plain");
4293 
			requestParams.put("v", "1.1");
30983 tejbeer 4294 
			requestParams.put("format", "json");
30982 tejbeer 4295 
 
4296 
			requestParams.put("method", "OPT_IN");
4297 
 
4298 
			requestParams.put("channel", "WHATSAPP");
4299 
			String response = restClient.get("https://media.smsgupshup.com/GatewayAPI/rest", requestParams,
4300 
					requestheaders);
4301 
			LOGGER.info("response" + response);
4302 
		}
4303 
 
4304 
	}
4305 
 
31206 tejbeer 4306 
	@Autowired
4307 
	private HygieneDataRepository hygieneDataRepository;
4308 
 
4309 
	public void hygineAlertForPartner() throws ProfitMandiBusinessException, MessagingException, IOException {
4310 
 
4311 
		List<String> remarks = new ArrayList<>();
4312 
		remarks.add("Out of Service");
4313 
		remarks.add("Duplicate number");
4314 
		remarks.add("Partner number");
4315 
		List<HygieneData> hygieneData = hygieneDataRepository.selectAllByDisposedDateAndRemark(LocalDate.now(),
4316 
				remarks);
4317 
 
4318 
		if (!hygieneData.isEmpty()) {
4319 
 
4320 
			Map<Integer, List<HygieneData>> partnerHygieneDataMap = hygieneData.stream()
4321 
					.collect(Collectors.groupingBy(x -> x.getFofoId()));
4322 
 
4323 
			for (Entry<Integer, List<HygieneData>> partnerHygieneDataMapEntry : partnerHygieneDataMap.entrySet()) {
4324 
 
31209 tejbeer 4325 
				CustomRetailer customRetailer = retailerService.getFofoRetailer(partnerHygieneDataMapEntry.getKey());
4326 
 
31206 tejbeer 4327 
				StringBuilder sb = new StringBuilder();
4328 
				sb.append("<html><body><p>Dear Partner,"
4329 
						+ "</p><br/><p>It has been observed in our calls to the respective customers that the contact no is either not correct or does not have incoming calls.\n"
4330 
 
4331 
						+ " </p>"
4332 
						+ "<p>We would like to inform you that this will hinder all our marketing initiatives to bring this customer back to our smartdukaan or cross sell any product from your inventory."
4333 
						+ "</p><p>Kindly ensure going forward that the details are correct so to avoid 1% margin loss.\n"
4334 
						+ "</p><p>In case the data is found to be incorrect there is a loss of 1% margin on this sales under SmartDukaan hygiene guidelines.\n"
4335 
						+ "				" + "</p>"
4336 
 
4337 
						+ "<br/><table style='border:1px solid black ;padding: 5px';>");
4338 
				sb.append("<tbody>\n" + "	" + "    				" + "<tr>\n");
4339 
				sb.append("<th style='border:1px solid black;padding: 5px'>Invoice Number</th>\n");
4340 
				sb.append("<th style='border:1px solid black;padding: 5px'>Customer Name</th>\n");
4341 
				sb.append("<th style='border:1px solid black;padding: 5px'>Customer Number</th>\n");
4342 
				sb.append("</tr>\n");
4343 
 
4344 
				List<HygieneData> hygienes = partnerHygieneDataMapEntry.getValue();
4345 
 
4346 
				List<Integer> orderIds = hygienes.stream().map(x -> x.getOrderId()).collect(Collectors.toList());
4347 
 
4348 
				List<FofoOrder> fofoOrders = fofoOrderRepository.selectAllByOrderIds(orderIds);
4349 
 
4350 
				for (FofoOrder fofoOrder : fofoOrders) {
4351 
					Customer customer = customerRepository.selectById(fofoOrder.getCustomerId());
4352 
					sb.append("<tr>");
4353 
					sb.append("<td style='border:1px solid black;padding: 5px'>" + fofoOrder.getInvoiceNumber()
4354 
							+ "</td>\n");
4355 
					sb.append("<td style='border:1px solid black;padding: 5px'>" + customer.getFirstName() + ""
4356 
							+ customer.getLastName() + "</td>\n");
4357 
					sb.append("<td style='border:1px solid black;padding: 5px'>" + customer.getMobileNumber()
4358 
							+ "</td>\n");
4359 
 
4360 
					sb.append("</tr>\n");
4361 
				}
4362 
 
4363 
				sb.append("</tbody></table></body></html>");
4364 
				String subject = "Customer Info - Hygiene Alert";
4365 
 
31209 tejbeer 4366 
				this.sendMailOfHtmlFormat(customRetailer.getEmail(), sb.toString(), null, subject);
31206 tejbeer 4367 
 
4368 
			}
4369 
 
4370 
		}
4371 
 
4372 
	}
4373 
 
4374 
	public void hygineAlertForInternalTeam() throws ProfitMandiBusinessException, MessagingException, IOException {
4375 
 
4376 
		List<String> remarks = new ArrayList<>();
4377 
		remarks.add("Out of Service");
4378 
		remarks.add("Duplicate number");
4379 
		remarks.add("Partner number");
4380 
		List<HygieneData> hygieneDataLastThreeMonth = hygieneDataRepository
4381 
				.selectDisposedDateAndRemarks(
4382 
						LocalDate.now().withDayOfMonth(1).minusMonths(3).atStartOfDay(), LocalDate.now().minusMonths(1)
4383 
								.withDayOfMonth(LocalDate.now().minusMonths(1).lengthOfMonth()).atTime(LocalTime.MAX),
4384 
						remarks);
4385 
 
4386 
		List<HygieneData> hygieneDataRecentMonth = hygieneDataRepository
4387 
				.selectDisposedDateAndRemarks(LocalDate.now().withDayOfMonth(1), remarks);
4388 
		Map<String, Set<Integer>> storeGuyMap = csService.getAuthUserPartnerIdMapping();
4389 
		Map<Integer, List<HygieneData>> partnerHygieneLastThreeMonthMap = null;
4390 
 
4391 
		Map<Integer, List<HygieneData>> partnerHygieneDataRecentMonth = null;
4392 
 
4393 
		if (!hygieneDataLastThreeMonth.isEmpty()) {
4394 
			partnerHygieneLastThreeMonthMap = hygieneDataLastThreeMonth.stream()
4395 
					.collect(Collectors.groupingBy(x -> x.getFofoId()));
4396 
 
4397 
		}
4398 
 
4399 
		if (!hygieneDataRecentMonth.isEmpty()) {
4400 
			partnerHygieneDataRecentMonth = hygieneDataRecentMonth.stream()
4401 
					.collect(Collectors.groupingBy(x -> x.getFofoId()));
4402 
		}
4403 
 
4404 
		for (Entry<String, Set<Integer>> storeGuyEntry : storeGuyMap.entrySet()) {
4405 
 
4406 
			String email = storeGuyEntry.getKey();
4407 
 
4408 
			List<Integer> fofoIds = new ArrayList<>(storeGuyEntry.getValue());
4409 
 
4410 
			Map<Integer, Map<YearMonth, List<HygieneData>>> partnerYearMonthData = new HashMap<>();
4411 
			Map<Integer, Map<LocalDate, List<HygieneData>>> partnerDateWiseData = new HashMap<>();
4412 
			for (Integer fofoId : fofoIds) {
4413 
 
4414 
				partnerYearMonthData.put(fofoId, null);
4415 
				partnerDateWiseData.put(fofoId, null);
4416 
				if (!partnerHygieneLastThreeMonthMap.isEmpty()) {
4417 
					List<HygieneData> hygienes = partnerHygieneLastThreeMonthMap.get(fofoId);
4418 
 
4419 
					if (hygienes != null) {
4420 
						Map<YearMonth, List<HygieneData>> yearMonthData = hygienes.stream()
4421 
								.collect(Collectors.groupingBy(x -> YearMonth.from(x.getDisposedTimestamp())));
4422 
 
4423 
						partnerYearMonthData.put(fofoId, yearMonthData);
4424 
 
4425 
					}
4426 
					List<HygieneData> dateWiseHygienes = partnerHygieneDataRecentMonth.get(fofoId);
4427 
 
4428 
					if (dateWiseHygienes != null) {
4429 
 
4430 
						Map<LocalDate, List<HygieneData>> dateWiseData = hygienes.stream()
4431 
								.collect(Collectors.groupingBy(x -> (x.getDisposedTimestamp()).toLocalDate()));
4432 
 
4433 
						partnerDateWiseData.put(fofoId, dateWiseData);
4434 
 
4435 
					}
4436 
 
4437 
				}
4438 
 
4439 
			}
4440 
 
4441 
			String subject = "Customer Info - Hygiene Alert";
4442 
 
4443 
			LOGGER.info("hygieneData {}", partnerDateWiseData.values());
4444 
 
4445 
			boolean partnerDateWise = partnerDateWiseData.values().stream().allMatch(Objects::isNull);
4446 
 
4447 
			boolean partnerYearMonth = partnerYearMonthData.values().stream().allMatch(Objects::isNull);
4448 
 
4449 
			if (!partnerDateWise && !partnerYearMonth) {
4450 
				String sb = this.getMessageHygieneAlertForPartner(partnerYearMonthData, partnerDateWiseData);
31209 tejbeer 4451 
				this.sendMailOfHtmlFormat(email, sb, null, subject);
31206 tejbeer 4452 
			}
4453 
 
4454 
		}
4455 
 
4456 
	}
4457 
 
4458 
	private String getMessageHygieneAlertForPartner(
4459 
			Map<Integer, Map<YearMonth, List<HygieneData>>> partnerYearMonthData,
4460 
			Map<Integer, Map<LocalDate, List<HygieneData>>> partnerDateWiseData) {
4461 
 
4462 
		Map<Integer, CustomRetailer> customeRetailerMap = retailerService.getAllFofoRetailers();
4463 
 
4464 
		LocalDateTime startDate = LocalDate.now().withDayOfMonth(1).atStartOfDay();
4465 
		LocalDateTime endDate = LocalDateTime.now();
4466 
 
4467 
		LocalDateTime startYearMonth = LocalDate.now().withDayOfMonth(1).minusMonths(3).atStartOfDay();
4468 
		LocalDateTime endYearMonth = LocalDate.now().minusMonths(1)
4469 
				.withDayOfMonth(LocalDate.now().minusMonths(1).lengthOfMonth()).atTime(LocalTime.MAX);
4470 
 
4471 
		DateTimeFormatter dateYearMonthFormatter = DateTimeFormatter.ofPattern("MMM''uu");
4472 
 
4473 
		List<YearMonth> yearMonthRange = new ArrayList<>();
4474 
		yearMonthRange.add(YearMonth.from(startYearMonth));
4475 
 
4476 
		yearMonthRange.add(YearMonth.from(startYearMonth.plusMonths(1)));
4477 
 
4478 
		yearMonthRange.add(YearMonth.from(endYearMonth));
4479 
 
4480 
		long noOfDaysBetween = ChronoUnit.DAYS.between(startDate, endDate.plusDays(1));
4481 
 
4482 
		List<LocalDate> dateRange = Stream.iterate(startDate.toLocalDate(), date -> date.plusDays(1))
4483 
				.limit(noOfDaysBetween).collect(Collectors.toList());
4484 
 
4485 
		StringBuilder sb = new StringBuilder();
4486 
		sb.append("<html><body><p>Hi,"
4487 
				+ "</p><br/><p>Kindly advise below mentioned partner to input correct details in the system else this will hinder all our marketing initiatives to bring this customer back to our smartdukaan or cross sell any product from partner's inventory.\n"
4488 
				+ " </p>" + "<p>Kindly ensure going forward that the details are correct so to avoid 1% margin loss.\n"
4489 
				+ "</p><p>In case the data is found to be incorrect there is a loss of 1% margin on this sales under SmartDukaan hygiene guidelines.\n</p>"
4490 
 
4491 
				+ "<table style='border:1px solid black ;padding: 5px';>");
4492 
		sb.append("<tbody>\n" + "	" + "    				" + "<tr>\n");
4493 
		sb.append("<th style='border:1px solid black;padding: 5px'>Partner Name</th>\n");
4494 
 
4495 
		for (YearMonth yearMonth : yearMonthRange) {
4496 
			sb.append("<th style='border:1px solid black;padding: 5px'>" + yearMonth.format(dateYearMonthFormatter)
4497 
					+ "</th>\n");
4498 
		}
4499 
 
4500 
		for (LocalDate localDate : dateRange) {
4501 
			sb.append("<th style='border:1px solid black;padding: 5px'>" + localDate + "</th>\n");
4502 
		}
4503 
 
4504 
		sb.append("</tr>\n");
4505 
 
4506 
		for (Entry<Integer, Map<YearMonth, List<HygieneData>>> partnerYearMonthEntry : partnerYearMonthData
4507 
				.entrySet()) {
4508 
 
4509 
			int fofoId = partnerYearMonthEntry.getKey();
4510 
 
4511 
			Map<YearMonth, List<HygieneData>> yearMonthData = partnerYearMonthEntry.getValue();
4512 
 
4513 
			Map<LocalDate, List<HygieneData>> dateWiseData = partnerDateWiseData.get(fofoId);
4514 
 
4515 
			if (yearMonthData == null && dateWiseData == null) {
4516 
				continue;
4517 
			}
4518 
 
4519 
			sb.append("<tr>");
4520 
			sb.append("<td style='border:1px solid black;padding: 5px'>"
4521 
					+ customeRetailerMap.get(fofoId).getBusinessName() + "</td>\n");
4522 
			for (YearMonth yearMonth : yearMonthRange) {
4523 
 
4524 
				if (yearMonthData == null) {
4525 
					sb.append("<td style='border:1px solid black;padding: 5px'>-</td>\n");
4526 
 
4527 
				} else {
4528 
					List<HygieneData> hygieneList = yearMonthData.get(yearMonth);
4529 
 
4530 
					if (hygieneList != null) {
4531 
						sb.append("<td style='border:1px solid black;padding: 5px'>" + hygieneList.size() + "</td>\n");
4532 
 
4533 
					} else {
4534 
						sb.append("<td style='border:1px solid black;padding: 5px'>-</td>\n");
4535 
 
4536 
					}
4537 
				}
4538 
			}
4539 
 
4540 
			for (LocalDate localDate : dateRange) {
4541 
 
4542 
				if (dateWiseData == null) {
4543 
					sb.append("<td style='border:1px solid black;padding: 5px'>-</td>\n");
4544 
 
4545 
				} else {
4546 
					List<HygieneData> hygieneList = dateWiseData.get(localDate);
4547 
 
4548 
					if (hygieneList != null) {
4549 
						sb.append("<td style='border:1px solid black;padding: 5px'>" + hygieneList.size() + "</td>\n");
4550 
 
4551 
					} else {
4552 
						sb.append("<td style='border:1px solid black;padding: 5px'>-</td>\n");
4553 
 
4554 
					}
4555 
				}
4556 
			}
4557 
			sb.append("</tr>");
4558 
 
4559 
		}
4560 
 
4561 
		sb.append("</tbody></table></body></html>");
4562 
 
4563 
		return sb.toString();
4564 
	}
4565 
 
31218 tejbeer 4566 
	@Autowired
4567 
	private MonthlyTargetRepository monthlyTargetRepository;
4568 
 
4569 
	public void monthlyTargetForPartner() throws MessagingException, ProfitMandiBusinessException, IOException {
4570 
 
4571 
		LocalDateTime curDate = LocalDateTime.now();
4572 
		List<MonthlyTarget> monthlyTargets = monthlyTargetRepository.selectByDate(YearMonth.now());
4573 
 
4574 
		Map<Integer, MonthlyTarget> partnersMonthlyTarget = monthlyTargets.stream()
4575 
				.collect(Collectors.toMap(x -> x.getFofoId(), x -> x));
4576 
 
4577 
		Map<Integer, Double> secondaryMtd = orderRepository
4578 
				.selectBillingDatesBetweenSumGroupByRetailerId(curDate.withDayOfMonth(1), curDate.with(LocalTime.MAX));
4579 
		Map<Integer, Double> todaytertiary = fofoOrderItemRepository.selectSumMopGroupByRetailer(curDate,
4580 
				curDate.with(LocalTime.MAX), 0, false);
4581 
 
31249 tejbeer 4582 
		String subject = "Monthly Target Vs Achievement";
31218 tejbeer 4583 
 
4584 
		for (Entry<Integer, MonthlyTarget> partnerMonthlyTargetEntry : partnersMonthlyTarget.entrySet()) {
4585 
 
4586 
			int fofoId = partnerMonthlyTargetEntry.getKey();
4587 
 
4588 
			CustomRetailer customRetailer = retailerService.getFofoRetailer(fofoId);
4589 
 
4590 
			Double purchaseTarget = partnerMonthlyTargetEntry.getValue().getPurchaseTarget();
4591 
 
4592 
			Double saleTarget = partnerMonthlyTargetEntry.getValue().getSaleTarget();
4593 
 
4594 
			if (purchaseTarget > 0) {
4595 
				Double purchase = secondaryMtd.get(fofoId);
4596 
 
31249 tejbeer 4597 
				if (purchase == null) {
4598 
					purchase = 0.0;
4599 
				}
4600 
 
4601 
				Double balanceTarget = purchaseTarget - purchase;
4602 
 
4603 
				if (balanceTarget <= 0) {
4604 
					balanceTarget = 0.0;
4605 
				}
4606 
 
31218 tejbeer 4607 
				StringBuilder sb = new StringBuilder();
31249 tejbeer 4608 
				sb.append("<html><body><p>Dear Partner,\n");
4609 
				sb.append("<p>Pls note your agreed monthly target is Rs." + purchaseTarget
4610 
						+ " and your achievement till date is Rs." + purchase + "</p>");
4611 
				sb.append("<p>Pls note that your balance target is Rs." + balanceTarget + "</p>\n");
4612 
				sb.append(
4613 
						"<p>We wish you all the best and we are confident that this focussed approach towards our outlet sales will help us take our outlet to the best SmartDukaan in your city.\n"
4614 
								+ "</p>\n");
31218 tejbeer 4615 
 
4616 
				this.sendMailOfHtmlFormat(customRetailer.getEmail(), sb.toString(), null, subject);
4617 
 
31249 tejbeer 4618 
				// this.sendMailOfHtmlFormat("tejbeer.kaur@smartdukaan.com", sb.toString(),
4619 
				// null, subject);
4620 
 
31218 tejbeer 4621 
			}
4622 
 
4623 
		}
4624 
 
4625 
	}
4626 
 
4627 
	public void monthlyTargetForInternalTeam() throws MessagingException, ProfitMandiBusinessException, IOException {
4628 
 
4629 
		LocalDateTime curDate = LocalDateTime.now();
4630 
 
4631 
		List<Integer> categoryIds = Arrays.asList(ProfitMandiConstants.TICKET_CATEGORY_CATEGORY,
4632 
				ProfitMandiConstants.TICKET_CATEGORY_RBM, ProfitMandiConstants.TICKET_CATEGORY_SALES,
4633 
				ProfitMandiConstants.TICKET_CATEGORY_MARKETING, ProfitMandiConstants.TICKET_CATEGORY_ACCOUNTS,
4634 
				ProfitMandiConstants.TICKET_CATEGORY_BUSINESSINTELLIGENT);
4635 
 
31518 amit.gupta 4636 
		Map<String, Set<Integer>> storeGuyMap = csService.getAuthUserPartnerIdMappingByCategoryIds(categoryIds, false);
31218 tejbeer 4637 
 
4638 
		List<MonthlyTarget> monthlyTargets = monthlyTargetRepository.selectByDate(YearMonth.now());
4639 
 
4640 
		Map<Integer, CustomRetailer> customeRetailerMap = retailerService.getAllFofoRetailers();
4641 
 
4642 
		Map<Integer, MonthlyTarget> partnersMonthlyTarget = monthlyTargets.stream()
4643 
				.collect(Collectors.toMap(x -> x.getFofoId(), x -> x));
4644 
 
4645 
		Map<Integer, Double> secondaryMtd = orderRepository
4646 
				.selectBillingDatesBetweenSumGroupByRetailerId(curDate.withDayOfMonth(1), curDate.with(LocalTime.MAX));
4647 
		Map<Integer, Double> todaytertiary = fofoOrderItemRepository.selectSumMopGroupByRetailer(curDate,
4648 
				curDate.with(LocalTime.MAX), 0, false);
4649 
 
31249 tejbeer 4650 
		String subject = "Monthly Target Vs Achievement";
31218 tejbeer 4651 
 
4652 
		for (Entry<String, Set<Integer>> storeGuyEntry : storeGuyMap.entrySet()) {
4653 
 
4654 
			String email = storeGuyEntry.getKey();
4655 
 
4656 
			List<Integer> fofoIds = new ArrayList<>(storeGuyEntry.getValue());
4657 
			Map<Integer, MonthlyTarget> monthlyTargetAchievement = new HashMap<>();
4658 
			for (Integer fofoId : fofoIds) {
4659 
 
4660 
				MonthlyTarget monthlyTarget = partnersMonthlyTarget.get(fofoId);
31249 tejbeer 4661 
				if (monthlyTarget != null) {
4662 
					Double purchaseTarget = monthlyTarget.getPurchaseTarget();
31218 tejbeer 4663 
 
31249 tejbeer 4664 
					Double saleTarget = monthlyTarget.getSaleTarget();
31218 tejbeer 4665 
 
31249 tejbeer 4666 
					if (purchaseTarget != null && purchaseTarget > 0) {
4667 
						Double purchase = secondaryMtd.get(fofoId);
4668 
						if (purchase == null) {
4669 
							purchase = 0.0;
4670 
						}
4671 
						monthlyTarget.setPurchaseAchievement(purchase);
4672 
						monthlyTargetAchievement.put(fofoId, monthlyTarget);
31218 tejbeer 4673 
 
31249 tejbeer 4674 
					}
31218 tejbeer 4675 
				}
4676 
			}
4677 
 
4678 
			if (!monthlyTargetAchievement.isEmpty()) {
4679 
 
4680 
				StringBuilder sb = new StringBuilder();
4681 
 
31249 tejbeer 4682 
				sb.append("<html><body><p>Hi,\n");
4683 
				sb.append("<p>Pls note your Partners agreed monthly target foolowing are :</p>\n"
4684 
						+ " <table style='border:1px solid black ;padding: 5px';>");
31218 tejbeer 4685 
				sb.append("<tbody>\n" + "	" + "    				" + "<tr>\n");
4686 
				sb.append("<th style='border:1px solid black;padding: 5px'>Partner Name</th>\n");
4687 
 
4688 
				sb.append("<th style='border:1px solid black;padding: 5px'>Purchase Target</th>\n");
4689 
 
4690 
				sb.append("<th style='border:1px solid black;padding: 5px'>Purchase Achievement</th>\n");
4691 
				sb.append("</tr>\n");
4692 
 
4693 
				for (Entry<Integer, MonthlyTarget> monthlyTargetAchievementEntry : monthlyTargetAchievement
4694 
						.entrySet()) {
4695 
					sb.append("<tr>");
4696 
					int fofoId = monthlyTargetAchievementEntry.getKey();
4697 
 
4698 
					MonthlyTarget monthlyTarget = monthlyTargetAchievementEntry.getValue();
4699 
					sb.append("<td style='border:1px solid black;padding: 5px'>"
4700 
							+ customeRetailerMap.get(fofoId).getBusinessName() + "</td>\n");
4701 
 
4702 
					sb.append("<td style='border:1px solid black;padding: 5px'>" + monthlyTarget.getPurchaseTarget()
4703 
							+ "</td>\n");
4704 
 
4705 
					sb.append("<td style='border:1px solid black;padding: 5px'>"
4706 
							+ monthlyTarget.getPurchaseAchievement() + "</td>\n");
4707 
 
4708 
					sb.append("</tr>\n");
4709 
 
4710 
				}
4711 
 
4712 
				this.sendMailOfHtmlFormat(email, sb.toString(), null, subject);
31249 tejbeer 4713 
				// this.sendMailOfHtmlFormat("tejbeer.kaur@smartdukaan.com", sb.toString(),
4714 
				// null, subject);
31218 tejbeer 4715 
 
4716 
			}
4717 
 
4718 
		}
4719 
 
4720 
	}
4721 
 
31604 tejbeer 4722 
	@Autowired
4723 
	private WebListingRepository webListingRepository;
4724 
 
4725 
	@Autowired
4726 
	private WebProductListingRepository webProductListingRepository;
4727 
 
4728 
	public void pushDataToSolr() throws Exception {
4729 
		fofoSolr.pushData();
4730 
	}
4731 
 
4732 
	public void getBestSeller() throws ProfitMandiBusinessException {
4733 
		WebListing webListing = webListingRepository.selectByUrl("partner-best-sellers");
4734 
 
4735 
		List<WebProductListing> webProductListings = webProductListingRepository
4736 
				.selectAllByWebListingId(webListing.getId());
4737 
 
4738 
		List<Integer> catalogItemIds = orderRepository.selectAllOrderWeight(LocalDateTime.now().minusDays(30),
4739 
				LocalDateTime.now(), OrderStatus.DELIVERY_SUCCESS);
4740 
 
4741 
		LOGGER.info("catalogItemIds {}", catalogItemIds);
4742 
		if (!catalogItemIds.isEmpty()) {
4743 
			webProductListingRepository.deleteByEqual(webListing.getId());
4744 
			int count = 0;
4745 
			for (Integer catalogItemId : catalogItemIds) {
4746 
 
4747 
				WebProductListing webProductListing = new WebProductListing();
4748 
				webProductListing.setEntityId(catalogItemId);
4749 
				webProductListing.setWebListingId(webListing.getId());
31612 tejbeer 4750 
				count = count + 1;
31604 tejbeer 4751 
 
4752 
				webProductListing.setRank(count + 1);
4753 
				webProductListingRepository.persist(webProductListing);
4754 
 
4755 
			}
4756 
 
4757 
		}
4758 
	}
4759 
 
4760 
	public void getPriceDrop() throws ProfitMandiBusinessException {
4761 
		WebListing webListing = webListingRepository.selectByUrl("partner-price-drop");
4762 
 
4763 
		List<WebProductListing> webProductListings = webProductListingRepository
4764 
				.selectAllByWebListingId(webListing.getId());
4765 
 
31612 tejbeer 4766 
		Set<Integer> catalogItemIds = priceDropRepository
31604 tejbeer 4767 
				.selectAllByDatesBetweenSortByDate(LocalDateTime.now().minusDays(30), LocalDateTime.now()).stream()
31612 tejbeer 4768 
				.map(x -> x.getCatalogItemId()).collect(Collectors.toSet());
31604 tejbeer 4769 
 
4770 
		LOGGER.info("catalogItemIds {}", catalogItemIds);
4771 
		if (!catalogItemIds.isEmpty()) {
4772 
			webProductListingRepository.deleteByEqual(webListing.getId());
4773 
			int count = 0;
4774 
			for (Integer catalogItemId : catalogItemIds) {
4775 
 
4776 
				WebProductListing webProductListing = new WebProductListing();
4777 
				webProductListing.setEntityId(catalogItemId);
4778 
				webProductListing.setWebListingId(webListing.getId());
31612 tejbeer 4779 
				count = count + 1;
4780 
				webProductListing.setRank(count);
4781 
				webProductListingRepository.persist(webProductListing);
31604 tejbeer 4782 
 
31612 tejbeer 4783 
			}
4784 
 
4785 
		}
4786 
	}
4787 
 
4788 
	public void getNewLaunches() throws ProfitMandiBusinessException {
4789 
		WebListing webListing = webListingRepository.selectByUrl("new-launches");
4790 
 
4791 
		Set<Integer> itemIds = tagListingRepository
4792 
				.selectAllByDatesBetweenSortByDate(LocalDateTime.now().minusDays(30), LocalDateTime.now()).stream()
4793 
				.map(x -> x.getItemId()).collect(Collectors.toSet());
4794 
 
31638 tejbeer 4795 
		LOGGER.info("itemIds {}", itemIds);
31612 tejbeer 4796 
 
31638 tejbeer 4797 
		List<Integer> catalogItemIds = itemRepository.selectByIds(itemIds).stream().map(x -> x.getCatalogItemId())
4798 
				.distinct().collect(Collectors.toList());
4799 
 
31612 tejbeer 4800 
		LOGGER.info("catalogItemIds {}", catalogItemIds);
4801 
		if (!catalogItemIds.isEmpty()) {
4802 
			webProductListingRepository.deleteByEqual(webListing.getId());
4803 
			int count = 0;
4804 
			for (Integer catalogItemId : catalogItemIds) {
4805 
 
4806 
				WebProductListing webProductListing = new WebProductListing();
4807 
				webProductListing.setEntityId(catalogItemId);
4808 
				webProductListing.setWebListingId(webListing.getId());
4809 
				count = count + 1;
4810 
				webProductListing.setRank(count);
31604 tejbeer 4811 
				webProductListingRepository.persist(webProductListing);
4812 
 
4813 
			}
4814 
 
4815 
		}
4816 
	}
4817 
 
31612 tejbeer 4818 
	public void getSpecialSupport() throws ProfitMandiBusinessException {
4819 
		WebListing webListing = webListingRepository.selectByUrl("special-support");
4820 
 
4821 
		Set<Integer> schemeIds = schemeRepository.selectActiveAll(Arrays.asList(SchemeType.SPECIAL_SUPPORT),
4822 
				LocalDate.now().minusDays(30), LocalDate.now().plusDays(1), false).stream().map(x -> x.getId())
4823 
				.collect(Collectors.toSet());
4824 
 
4825 
		Set<Integer> catalogItemIds = schemeItemRepository.selectBySchemeIds(schemeIds).stream()
4826 
				.map(x -> x.getCatalogId()).collect(Collectors.toSet());
4827 
 
4828 
		LOGGER.info("catalogItemIds {}", catalogItemIds);
4829 
		if (!catalogItemIds.isEmpty()) {
4830 
			webProductListingRepository.deleteByEqual(webListing.getId());
4831 
			int count = 0;
4832 
			for (Integer catalogItemId : catalogItemIds) {
4833 
 
4834 
				WebProductListing webProductListing = new WebProductListing();
4835 
				webProductListing.setEntityId(catalogItemId);
4836 
				webProductListing.setWebListingId(webListing.getId());
4837 
				count = count + 1;
4838 
				webProductListing.setRank(count);
4839 
				webProductListingRepository.persist(webProductListing);
4840 
 
4841 
			}
4842 
 
4843 
		}
4844 
	}
4845 
 
4846 
	public void getUpgradeOffer() throws ProfitMandiBusinessException {
4847 
		WebListing webListing = webListingRepository.selectByUrl("upgrade-offer");
4848 
 
4849 
		List<Integer> customerOfferIds = customerOfferRepository
4850 
				.selectOffers(LocalDateTime.now().minusDays(30), LocalDateTime.now().plusDays(1)).stream()
4851 
				.map(x -> x.getId()).collect(Collectors.toList());
4852 
 
4853 
		Set<Integer> catalogItemIds = customerOfferItemRepository
4854 
				.selectByOfferIdsRange(customerOfferIds, LocalDate.now().minusDays(30), LocalDate.now().plusDays(1))
4855 
				.stream().map(x -> x.getCatalogId()).collect(Collectors.toSet());
4856 
 
4857 
		LOGGER.info("catalogItemIds {}", catalogItemIds);
4858 
		if (!catalogItemIds.isEmpty()) {
4859 
			webProductListingRepository.deleteByEqual(webListing.getId());
4860 
			int count = 0;
4861 
			for (Integer catalogItemId : catalogItemIds) {
4862 
 
4863 
				WebProductListing webProductListing = new WebProductListing();
4864 
				webProductListing.setEntityId(catalogItemId);
4865 
				webProductListing.setWebListingId(webListing.getId());
4866 
				count = count + 1;
4867 
				webProductListing.setRank(count);
4868 
				webProductListingRepository.persist(webProductListing);
4869 
 
4870 
			}
4871 
 
4872 
		}
4873 
	}
4874 
 
26418 tejbeer 4875 
}
31206 tejbeer 4876 
// 2284'