Subversion Repositories SmartDukaan

Rev

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