Subversion Repositories SmartDukaan

Rev

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

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