Subversion Repositories SmartDukaan

Rev

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