Subversion Repositories SmartDukaan

Rev

Rev 29107 | Rev 29252 | 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 
 
24121 govind 3 
import java.io.IOException;
24807 amit.gupta 4 
import java.io.Serializable;
23739 amit.gupta 5 
import java.sql.Timestamp;
28805 amit.gupta 6 
import java.time.Duration;
23724 amit.gupta 7 
import java.time.LocalDate;
8 
import java.time.LocalDateTime;
24256 amit.gupta 9 
import java.time.LocalTime;
27271 amit.gupta 10 
import java.time.Month;
29107 amit.gupta 11 
import java.time.YearMonth;
24653 govind 12 
import java.time.format.DateTimeFormatter;
29107 amit.gupta 13 
import java.time.temporal.ChronoField;
23724 amit.gupta 14 
import java.time.temporal.ChronoUnit;
15 
import java.util.ArrayList;
16 
import java.util.Arrays;
27683 amit.gupta 17 
import java.util.Base64;
24627 amit.gupta 18 
import java.util.Collections;
26945 amit.gupta 19 
import java.util.Comparator;
23723 amit.gupta 20 
import java.util.HashMap;
24241 amit.gupta 21 
import java.util.HashSet;
23724 amit.gupta 22 
import java.util.List;
23723 amit.gupta 23 
import java.util.Map;
28205 tejbeer 24 
import java.util.Map.Entry;
24242 amit.gupta 25 
import java.util.Optional;
24542 amit.gupta 26 
import java.util.Set;
23724 amit.gupta 27 
import java.util.stream.Collectors;
23723 amit.gupta 28 
 
24121 govind 29 
import javax.mail.MessagingException;
30 
import javax.mail.internet.InternetAddress;
31 
import javax.mail.internet.MimeMessage;
32 
 
23929 amit.gupta 33 
import org.apache.commons.io.output.ByteArrayOutputStream;
25598 amit.gupta 34 
import org.apache.commons.lang.StringUtils;
25300 tejbeer 35 
import org.apache.http.client.methods.CloseableHttpResponse;
36 
import org.apache.http.client.methods.HttpPost;
37 
import org.apache.http.entity.StringEntity;
38 
import org.apache.http.impl.client.CloseableHttpClient;
39 
import org.apache.http.impl.client.HttpClients;
23755 amit.gupta 40 
import org.apache.logging.log4j.LogManager;
41 
import org.apache.logging.log4j.Logger;
25300 tejbeer 42 
import org.json.JSONObject;
23723 amit.gupta 43 
import org.springframework.beans.factory.annotation.Autowired;
23933 amit.gupta 44 
import org.springframework.beans.factory.annotation.Qualifier;
23724 amit.gupta 45 
import org.springframework.beans.factory.annotation.Value;
23929 amit.gupta 46 
import org.springframework.core.io.ByteArrayResource;
24692 amit.gupta 47 
import org.springframework.core.io.InputStreamSource;
23929 amit.gupta 48 
import org.springframework.mail.javamail.JavaMailSender;
24121 govind 49 
import org.springframework.mail.javamail.MimeMessageHelper;
23723 amit.gupta 50 
import org.springframework.stereotype.Component;
23724 amit.gupta 51 
import org.springframework.transaction.annotation.Transactional;
23723 amit.gupta 52 
 
24542 amit.gupta 53 
import com.google.common.collect.Lists;
25300 tejbeer 54 
import com.google.gson.Gson;
28369 tejbeer 55 
import com.razorpay.Payment;
25721 tejbeer 56 
import com.spice.profitmandi.common.enumuration.MessageType;
23724 amit.gupta 57 
import com.spice.profitmandi.common.enumuration.RechargeStatus;
24681 amit.gupta 58 
import com.spice.profitmandi.common.enumuration.ReporticoProject;
24121 govind 59 
import com.spice.profitmandi.common.exception.ProfitMandiBusinessException;
23929 amit.gupta 60 
import com.spice.profitmandi.common.model.CustomRetailer;
25721 tejbeer 61 
import com.spice.profitmandi.common.model.FocusedModelShortageModel;
24542 amit.gupta 62 
import com.spice.profitmandi.common.model.GstRate;
27678 amit.gupta 63 
import com.spice.profitmandi.common.model.PdfModel;
25590 amit.gupta 64 
import com.spice.profitmandi.common.model.ProfitMandiConstants;
23724 amit.gupta 65 
import com.spice.profitmandi.common.model.RechargeCredential;
25821 amit.gupta 66 
import com.spice.profitmandi.common.model.SendNotificationModel;
24681 amit.gupta 67 
import com.spice.profitmandi.common.services.ReporticoService;
24002 amit.gupta 68 
import com.spice.profitmandi.common.util.FileUtil;
23929 amit.gupta 69 
import com.spice.profitmandi.common.util.FormattingUtils;
27678 amit.gupta 70 
import com.spice.profitmandi.common.util.PdfUtils;
23929 amit.gupta 71 
import com.spice.profitmandi.common.util.Utils;
24592 amit.gupta 72 
import com.spice.profitmandi.common.util.Utils.Attachment;
25300 tejbeer 73 
import com.spice.profitmandi.dao.Interface.Campaign;
25590 amit.gupta 74 
import com.spice.profitmandi.dao.entity.auth.AuthUser;
25800 tejbeer 75 
import com.spice.profitmandi.dao.entity.catalog.FocusedModel;
25609 amit.gupta 76 
import com.spice.profitmandi.dao.entity.catalog.Item;
24590 amit.gupta 77 
import com.spice.profitmandi.dao.entity.catalog.Scheme;
25590 amit.gupta 78 
import com.spice.profitmandi.dao.entity.cs.Position;
26283 tejbeer 79 
import com.spice.profitmandi.dao.entity.cs.Ticket;
23724 amit.gupta 80 
import com.spice.profitmandi.dao.entity.dtr.DailyRecharge;
28769 amit.gupta 81 
import com.spice.profitmandi.dao.entity.dtr.EmployeeAttendance;
27678 amit.gupta 82 
import com.spice.profitmandi.dao.entity.dtr.InsurancePolicy;
25300 tejbeer 83 
import com.spice.profitmandi.dao.entity.dtr.NotificationCampaign;
84 
import com.spice.profitmandi.dao.entity.dtr.PushNotifications;
23724 amit.gupta 85 
import com.spice.profitmandi.dao.entity.dtr.RechargeProvider;
86 
import com.spice.profitmandi.dao.entity.dtr.RechargeProviderCreditWalletHistory;
87 
import com.spice.profitmandi.dao.entity.dtr.RechargeTransaction;
28769 amit.gupta 88 
import com.spice.profitmandi.dao.entity.dtr.User;
26283 tejbeer 89 
import com.spice.profitmandi.dao.entity.fofo.ActivityType;
28368 tejbeer 90 
import com.spice.profitmandi.dao.entity.fofo.Customer;
24542 amit.gupta 91 
import com.spice.profitmandi.dao.entity.fofo.CustomerAddress;
24590 amit.gupta 92 
import com.spice.profitmandi.dao.entity.fofo.FofoLineItem;
23724 amit.gupta 93 
import com.spice.profitmandi.dao.entity.fofo.FofoOrder;
24542 amit.gupta 94 
import com.spice.profitmandi.dao.entity.fofo.FofoOrderItem;
23929 amit.gupta 95 
import com.spice.profitmandi.dao.entity.fofo.FofoStore;
24249 amit.gupta 96 
import com.spice.profitmandi.dao.entity.fofo.InventoryItem;
24277 amit.gupta 97 
import com.spice.profitmandi.dao.entity.fofo.PartnerDailyInvestment;
28205 tejbeer 98 
import com.spice.profitmandi.dao.entity.fofo.PartnerProblem;
28971 amit.gupta 99 
import com.spice.profitmandi.dao.entity.fofo.PartnerType;
28368 tejbeer 100 
import com.spice.profitmandi.dao.entity.fofo.PendingOrder;
101 
import com.spice.profitmandi.dao.entity.fofo.PendingOrderItem;
23724 amit.gupta 102 
import com.spice.profitmandi.dao.entity.fofo.Purchase;
28368 tejbeer 103 
import com.spice.profitmandi.dao.entity.fofo.RazorPay;
24242 amit.gupta 104 
import com.spice.profitmandi.dao.entity.fofo.ScanRecord;
24241 amit.gupta 105 
import com.spice.profitmandi.dao.entity.fofo.SchemeInOut;
27208 tejbeer 106 
import com.spice.profitmandi.dao.entity.inventory.SaholicCIS;
107 
import com.spice.profitmandi.dao.entity.inventory.SaholicPOItem;
24431 amit.gupta 108 
import com.spice.profitmandi.dao.entity.transaction.PriceDrop;
25609 amit.gupta 109 
import com.spice.profitmandi.dao.entity.transaction.PriceDropIMEI;
24587 amit.gupta 110 
import com.spice.profitmandi.dao.entity.transaction.UserWallet;
24580 amit.gupta 111 
import com.spice.profitmandi.dao.entity.transaction.UserWalletHistory;
24542 amit.gupta 112 
import com.spice.profitmandi.dao.entity.user.Address;
25300 tejbeer 113 
import com.spice.profitmandi.dao.entity.user.Device;
25927 amit.gupta 114 
import com.spice.profitmandi.dao.entity.user.FranchiseeVisit;
25910 amit.gupta 115 
import com.spice.profitmandi.dao.entity.user.Lead;
26790 tejbeer 116 
import com.spice.profitmandi.dao.entity.user.Refferal;
24250 amit.gupta 117 
import com.spice.profitmandi.dao.enumuration.catalog.SchemeType;
25598 amit.gupta 118 
import com.spice.profitmandi.dao.enumuration.cs.EscalationType;
26790 tejbeer 119 
import com.spice.profitmandi.dao.enumuration.dtr.RefferalStatus;
24242 amit.gupta 120 
import com.spice.profitmandi.dao.enumuration.fofo.ScanType;
25609 amit.gupta 121 
import com.spice.profitmandi.dao.enumuration.transaction.PriceDropImeiStatus;
25300 tejbeer 122 
import com.spice.profitmandi.dao.model.SimpleCampaign;
123 
import com.spice.profitmandi.dao.model.SimpleCampaignParams;
25590 amit.gupta 124 
import com.spice.profitmandi.dao.repository.auth.AuthRepository;
25300 tejbeer 125 
import com.spice.profitmandi.dao.repository.catalog.DeviceRepository;
25721 tejbeer 126 
import com.spice.profitmandi.dao.repository.catalog.FocusedModelRepository;
24249 amit.gupta 127 
import com.spice.profitmandi.dao.repository.catalog.ItemRepository;
24241 amit.gupta 128 
import com.spice.profitmandi.dao.repository.catalog.SchemeRepository;
26929 amit.gupta 129 
import com.spice.profitmandi.dao.repository.catalog.StateGstRateRepository;
25590 amit.gupta 130 
import com.spice.profitmandi.dao.repository.cs.CsService;
27088 tejbeer 131 
import com.spice.profitmandi.dao.repository.cs.PartnerRegionRepository;
25590 amit.gupta 132 
import com.spice.profitmandi.dao.repository.cs.PositionRepository;
27088 tejbeer 133 
import com.spice.profitmandi.dao.repository.cs.RegionRepository;
26283 tejbeer 134 
import com.spice.profitmandi.dao.repository.cs.TicketRepository;
23724 amit.gupta 135 
import com.spice.profitmandi.dao.repository.dtr.DailyRechargeRepository;
28769 amit.gupta 136 
import com.spice.profitmandi.dao.repository.dtr.EmployeeAttendanceRepository;
23929 amit.gupta 137 
import com.spice.profitmandi.dao.repository.dtr.FofoStoreRepository;
25927 amit.gupta 138 
import com.spice.profitmandi.dao.repository.dtr.FranchiseeActivityRepository;
139 
import com.spice.profitmandi.dao.repository.dtr.FranchiseeVisitRepository;
25837 amit.gupta 140 
import com.spice.profitmandi.dao.repository.dtr.InsurancePolicyRepository;
25910 amit.gupta 141 
import com.spice.profitmandi.dao.repository.dtr.LeadRepository;
24653 govind 142 
import com.spice.profitmandi.dao.repository.dtr.Mongo;
25300 tejbeer 143 
import com.spice.profitmandi.dao.repository.dtr.NotificationCampaignRepository;
28205 tejbeer 144 
import com.spice.profitmandi.dao.repository.dtr.PartnerProblemRepository;
25300 tejbeer 145 
import com.spice.profitmandi.dao.repository.dtr.PushNotificationRepository;
23724 amit.gupta 146 
import com.spice.profitmandi.dao.repository.dtr.RechargeProviderCreditWalletHistoryRepository;
147 
import com.spice.profitmandi.dao.repository.dtr.RechargeProviderRepository;
148 
import com.spice.profitmandi.dao.repository.dtr.RechargeTransactionRepository;
26790 tejbeer 149 
import com.spice.profitmandi.dao.repository.dtr.RefferalRepository;
24542 amit.gupta 150 
import com.spice.profitmandi.dao.repository.dtr.RetailerRegisteredAddressRepository;
24669 govind 151 
import com.spice.profitmandi.dao.repository.dtr.UserAccountRepository;
25721 tejbeer 152 
import com.spice.profitmandi.dao.repository.dtr.UserCampaignRepository;
26408 amit.gupta 153 
import com.spice.profitmandi.dao.repository.fofo.ActivatedImeiRepository;
25721 tejbeer 154 
import com.spice.profitmandi.dao.repository.fofo.CurrentInventorySnapshotRepository;
24542 amit.gupta 155 
import com.spice.profitmandi.dao.repository.fofo.CustomerAddressRepository;
28377 tejbeer 156 
import com.spice.profitmandi.dao.repository.fofo.CustomerRepository;
24590 amit.gupta 157 
import com.spice.profitmandi.dao.repository.fofo.FofoLineItemRepository;
24542 amit.gupta 158 
import com.spice.profitmandi.dao.repository.fofo.FofoOrderItemRepository;
23724 amit.gupta 159 
import com.spice.profitmandi.dao.repository.fofo.FofoOrderRepository;
24249 amit.gupta 160 
import com.spice.profitmandi.dao.repository.fofo.InventoryItemRepository;
24277 amit.gupta 161 
import com.spice.profitmandi.dao.repository.fofo.PartnerDailyInvestmentRepository;
24174 govind 162 
import com.spice.profitmandi.dao.repository.fofo.PartnerTargetRepository;
27086 tejbeer 163 
import com.spice.profitmandi.dao.repository.fofo.PartnerTypeChangeRepository;
25503 amit.gupta 164 
import com.spice.profitmandi.dao.repository.fofo.PartnerTypeChangeService;
28368 tejbeer 165 
import com.spice.profitmandi.dao.repository.fofo.PendingOrderItemRepository;
166 
import com.spice.profitmandi.dao.repository.fofo.PendingOrderRepository;
28377 tejbeer 167 
import com.spice.profitmandi.dao.repository.fofo.PendingOrderService;
23724 amit.gupta 168 
import com.spice.profitmandi.dao.repository.fofo.PurchaseRepository;
28368 tejbeer 169 
import com.spice.profitmandi.dao.repository.fofo.RazorPayRepository;
24242 amit.gupta 170 
import com.spice.profitmandi.dao.repository.fofo.ScanRecordRepository;
24241 amit.gupta 171 
import com.spice.profitmandi.dao.repository.fofo.SchemeInOutRepository;
28990 amit.gupta 172 
import com.spice.profitmandi.dao.repository.inventory.StateRepository;
28775 amit.gupta 173 
import com.spice.profitmandi.dao.repository.inventory.WarehouseRepository;
25982 amit.gupta 174 
import com.spice.profitmandi.dao.repository.transaction.HdfcPaymentRepository;
23929 amit.gupta 175 
import com.spice.profitmandi.dao.repository.transaction.OrderRepository;
25609 amit.gupta 176 
import com.spice.profitmandi.dao.repository.transaction.PriceDropIMEIRepository;
24431 amit.gupta 177 
import com.spice.profitmandi.dao.repository.transaction.PriceDropRepository;
24580 amit.gupta 178 
import com.spice.profitmandi.dao.repository.transaction.UserWalletHistoryRepository;
24587 amit.gupta 179 
import com.spice.profitmandi.dao.repository.transaction.UserWalletRepository;
24542 amit.gupta 180 
import com.spice.profitmandi.dao.repository.user.AddressRepository;
25721 tejbeer 181 
import com.spice.profitmandi.dao.repository.user.UserRepository;
25854 amit.gupta 182 
import com.spice.profitmandi.service.NotificationService;
24337 amit.gupta 183 
import com.spice.profitmandi.service.PartnerInvestmentService;
28368 tejbeer 184 
import com.spice.profitmandi.service.integrations.RazorpayPaymentService;
25694 amit.gupta 185 
import com.spice.profitmandi.service.integrations.toffee.ToffeeService;
23929 amit.gupta 186 
import com.spice.profitmandi.service.inventory.InventoryService;
27208 tejbeer 187 
import com.spice.profitmandi.service.inventory.SaholicInventoryService;
25335 amit.gupta 188 
import com.spice.profitmandi.service.order.OrderService;
24431 amit.gupta 189 
import com.spice.profitmandi.service.pricing.PriceDropService;
23724 amit.gupta 190 
import com.spice.profitmandi.service.recharge.provider.OxigenRechargeProviderService;
191 
import com.spice.profitmandi.service.recharge.provider.ThinkWalnutDigitalRechargeProviderService;
192 
import com.spice.profitmandi.service.scheme.SchemeService;
23929 amit.gupta 193 
import com.spice.profitmandi.service.transaction.TransactionService;
194 
import com.spice.profitmandi.service.user.RetailerService;
23739 amit.gupta 195 
import com.spice.profitmandi.service.wallet.WalletService;
23723 amit.gupta 196 
 
25721 tejbeer 197 
import in.shop2020.model.v1.order.OrderStatus;
28388 amit.gupta 198 
import in.shop2020.model.v1.order.WalletReferenceType;;
23739 amit.gupta 199 
 
23723 amit.gupta 200 
@Component
23724 amit.gupta 201 
@Transactional(rollbackFor = Throwable.class)
23723 amit.gupta 202 
public class ScheduledTasks {
203 
 
23724 amit.gupta 204 
	@Value("${oxigen.recharge.transaction.url}")
205 
	private String oxigenRechargeTransactionUrl;
23723 amit.gupta 206 
 
23724 amit.gupta 207 
	@Value("${oxigen.recharge.enquiry.url}")
208 
	private String oxigenRechargeEnquiryUrl;
24533 govind 209 
 
24431 amit.gupta 210 
	@Autowired
27088 tejbeer 211 
	private RegionRepository regionRepository;
28205 tejbeer 212 
 
27795 amit.gupta 213 
	private static final DateTimeFormatter leadTimeFormatter = DateTimeFormatter.ofPattern("d LLL, hh:mm a");
27088 tejbeer 214 
 
215 
	@Autowired
216 
	private PartnerRegionRepository partnerRegionRepository;
28790 amit.gupta 217 
 
28769 amit.gupta 218 
	@Autowired
219 
	private EmployeeAttendanceRepository employeeAttendanceRepository;
27088 tejbeer 220 
 
221 
	@Autowired
25503 amit.gupta 222 
	private PartnerTypeChangeService partnerTypeChangeService;
25598 amit.gupta 223 
 
25590 amit.gupta 224 
	@Autowired
26408 amit.gupta 225 
	private ActivatedImeiRepository activatedImeiRepository;
226 
 
227 
	@Autowired
25910 amit.gupta 228 
	private LeadRepository leadRepository;
25927 amit.gupta 229 
 
25910 amit.gupta 230 
	@Autowired
25590 amit.gupta 231 
	private AuthRepository authRepository;
25503 amit.gupta 232 
 
233 
	@Autowired
24431 amit.gupta 234 
	private PriceDropService priceDropService;
26283 tejbeer 235 
 
25590 amit.gupta 236 
	@Autowired
25927 amit.gupta 237 
	private FranchiseeVisitRepository franchiseeVisitRepository;
26790 tejbeer 238 
 
25927 amit.gupta 239 
	@Autowired
240 
	private FranchiseeActivityRepository franchiseeActivityRepository;
26790 tejbeer 241 
 
25927 amit.gupta 242 
	@Autowired
25982 amit.gupta 243 
	private HdfcPaymentRepository hdfcPaymentRepository;
26790 tejbeer 244 
 
25982 amit.gupta 245 
	@Autowired
25590 amit.gupta 246 
	private CsService csService;
25846 amit.gupta 247 
 
25837 amit.gupta 248 
	@Autowired
27208 tejbeer 249 
	private SaholicInventoryService saholicInventoryService;
250 
 
251 
	@Autowired
25837 amit.gupta 252 
	private InsurancePolicyRepository insurancePolicyRepository;
23723 amit.gupta 253 
 
25694 amit.gupta 254 
	@Autowired
255 
	private ToffeeService toffeeService;
256 
 
23724 amit.gupta 257 
	@Value("${oxigen.recharge.auth.key}")
258 
	private String oxigenRechargeAuthKey;
259 
 
260 
	@Value("${oxigen.recharge.validation.url}")
261 
	private String oxigenRechargeValidationUrl;
262 
 
263 
	@Value("${oxigen.recharge.validation.auth.key}")
264 
	private String oxigenRechargeValidationAuthKey;
265 
 
266 
	@Value("${think.walnut.digital.recharge.transaction.mobile.url}")
267 
	private String thinkWalnutDigitalRechargeTransactionMobileUrl;
268 
 
269 
	@Value("${think.walnut.digital.recharge.transaction.dth.url}")
270 
	private String thinkWalnutDigitalRechargeTransactionDthUrl;
271 
 
272 
	@Value("${think.walnut.digital.recharge.enquiry.url}")
273 
	private String thinkWalnutDigitalRechargeEnquiryUrl;
274 
 
275 
	@Value("${think.walnut.digital.recharge.balance.url}")
276 
	private String thinkWalnutDigitalRechargeBalanceUrl;
277 
 
278 
	@Value("${think.walnut.digital.recharge.username}")
279 
	private String thinkWalnutDigitalRechargeUserName;
280 
 
281 
	@Value("${think.walnut.digital.recharge.password}")
282 
	private String thinkWalnutDigitalRechargePassword;
283 
 
284 
	@Value("${think.walnut.digital.recharge.auth.key}")
285 
	private String thinkWalnutDigitalRechargeAuthKey;
286 
 
23723 amit.gupta 287 
	@Autowired
23724 amit.gupta 288 
	private PurchaseRepository purchaseRepository;
289 
 
290 
	@Autowired
25609 amit.gupta 291 
	private PriceDropIMEIRepository priceDropIMEIRepository;
292 
 
293 
	@Autowired
294 
	PriceDropRepository priceDropRepository;
295 
 
296 
	@Autowired
27086 tejbeer 297 
	private PartnerTypeChangeRepository partnerTypeChangeRepository;
28368 tejbeer 298 
 
27086 tejbeer 299 
	@Autowired
23724 amit.gupta 300 
	private SchemeService schemeService;
24683 amit.gupta 301 
 
29160 amit.gupta 302 
	private static final String[] STOCK_AGEING_MAIL_LIST = new String[] { "uday.singh@smartudkaan.com",
303 
			"mohinder.mutreja@smartdukaan.com", "ankit.bhatia@smartdukaan.com", "tarun.verma@smartdukaan.com",
28467 tejbeer 304 
			"kuldeep.kumar@smartdukaan.com", "manish.gupta@smartdukaan.com" };
25609 amit.gupta 305 
 
306 
	private static final String[] ITEMWISE_PENDING_INDENT_MAIL_LIST = new String[] { "kamini.sharma@smartdukaan.com",
28205 tejbeer 307 
			"tarun.verma@smartdukaan.com", "uday.singh@smartdukaan.com", "kuldeep.kumar@smartdukaan.com",
308 
			"niranjan.kala@smartdukaan.com" };
25609 amit.gupta 309 
 
28709 amit.gupta 310 
	private static final String[] INDENT_TERTIARY_MAIL_LIST = new String[] { "uday.singh@smartdukaan.com",
311 
			"kuldeep.kumar@smartdukaan.com" };
312 
 
28790 amit.gupta 313 
	private static final String[] EMPLOYEE_ATTENDANCE_MAIL_LIST = new String[] { "jyoti.rawat@smartdukaan.com",
314 
			"sm@smartdukaan.com" };
315 
 
25721 tejbeer 316 
	private List<OrderStatus> orderStatusList = Arrays.asList(OrderStatus.SUBMITTED_FOR_PROCESSING);
317 
 
24681 amit.gupta 318 
	@Autowired
319 
	private ReporticoService reporticoService;
23724 amit.gupta 320 
 
321 
	@Autowired
24337 amit.gupta 322 
	private PartnerInvestmentService partnerInvestmentService;
25598 amit.gupta 323 
 
25590 amit.gupta 324 
	@Autowired
325 
	private PositionRepository positionRepository;
24337 amit.gupta 326 
 
327 
	@Autowired
24542 amit.gupta 328 
	private FofoOrderItemRepository fofoOrderItemRepository;
25865 amit.gupta 329 
 
25854 amit.gupta 330 
	@Autowired
331 
	private NotificationService notificationService;
24542 amit.gupta 332 
 
333 
	@Autowired
24277 amit.gupta 334 
	private PartnerDailyInvestmentRepository partnerDailyInvestmentRepository;
335 
 
336 
	@Autowired
24241 amit.gupta 337 
	private SchemeInOutRepository schemeInOutRepository;
338 
 
339 
	@Autowired
23724 amit.gupta 340 
	private RechargeTransactionRepository rechargeTransactionRepository;
341 
 
342 
	@Autowired
24542 amit.gupta 343 
	private CustomerAddressRepository customerAddressRepository;
344 
 
345 
	@Autowired
23724 amit.gupta 346 
	private RechargeProviderCreditWalletHistoryRepository rechargeProviderCreditWalletHistoryRepository;
347 
 
348 
	@Autowired
24590 amit.gupta 349 
	private FofoLineItemRepository fofoLineItemRepository;
350 
 
351 
	@Autowired
23724 amit.gupta 352 
	private FofoOrderRepository fofoOrderRepository;
24587 amit.gupta 353 
 
24580 amit.gupta 354 
	@Autowired
355 
	private UserWalletHistoryRepository userWalletHistoryRepository;
24250 amit.gupta 356 
 
24249 amit.gupta 357 
	@Autowired
24587 amit.gupta 358 
	private UserWalletRepository userWalletRepository;
359 
 
360 
	@Autowired
24249 amit.gupta 361 
	private InventoryItemRepository inventoryItemRepository;
23929 amit.gupta 362 
 
23739 amit.gupta 363 
	@Autowired
364 
	private WalletService walletService;
23724 amit.gupta 365 
 
366 
	@Autowired
367 
	private ThinkWalnutDigitalRechargeProviderService thinkWalnutDigitalRechargeProviderService;
368 
 
369 
	@Autowired
370 
	private OxigenRechargeProviderService oxigenRechargeProviderService;
371 
 
372 
	@Autowired
373 
	private RechargeProviderRepository rechargeProviderRepository;
374 
 
375 
	@Autowired
24242 amit.gupta 376 
	private ScanRecordRepository scanRecordRepository;
377 
 
378 
	@Autowired
23724 amit.gupta 379 
	private DailyRechargeRepository dailyRechargeRepository;
380 
 
23929 amit.gupta 381 
	@Autowired
382 
	private FofoStoreRepository fofoStoreRepository;
24177 govind 383 
 
23724 amit.gupta 384 
	@Value("${prod}")
385 
	private boolean prod;
26945 amit.gupta 386 
 
26929 amit.gupta 387 
	@Autowired
388 
	private StateGstRateRepository stateGstRateRepository;
23724 amit.gupta 389 
 
23929 amit.gupta 390 
	@Autowired
391 
	private RetailerService retailerService;
392 
 
393 
	@Autowired
394 
	private TransactionService transactionService;
24250 amit.gupta 395 
 
24249 amit.gupta 396 
	@Autowired
397 
	private ItemRepository itemRepository;
23929 amit.gupta 398 
 
399 
	@Autowired
400 
	private OrderRepository orderRepository;
25351 tejbeer 401 
 
25335 amit.gupta 402 
	@Autowired
403 
	private OrderService orderService;
23929 amit.gupta 404 
 
405 
	@Autowired
24241 amit.gupta 406 
	private SchemeRepository schemeRepository;
407 
 
408 
	@Autowired
23929 amit.gupta 409 
	private JavaMailSender mailSender;
24177 govind 410 
 
24174 govind 411 
	@Autowired
412 
	private PartnerTargetRepository partnerTargetRepository;
24002 amit.gupta 413 
 
414 
	@Autowired
415 
	@Qualifier(value = "googleMailSender")
23932 amit.gupta 416 
	private JavaMailSender googleMailSender;
23929 amit.gupta 417 
 
418 
	@Autowired
419 
	private InventoryService inventoryService;
420 
 
24533 govind 421 
	@Autowired
24542 amit.gupta 422 
	private AddressRepository addressRepository;
423 
 
424 
	@Autowired
425 
	private RetailerRegisteredAddressRepository retailerRegisteredAddressRepository;
426 
 
24653 govind 427 
	@Autowired
428 
	private Mongo mongoClient;
24683 amit.gupta 429 
 
24669 govind 430 
	@Autowired
25300 tejbeer 431 
	private DeviceRepository deviceRepository;
432 
 
433 
	@Autowired
434 
	private PushNotificationRepository pushNotificationRepository;
435 
 
436 
	@Autowired
437 
	private NotificationCampaignRepository notificationCampaignRepository;
438 
 
439 
	@Autowired
25721 tejbeer 440 
	private CurrentInventorySnapshotRepository currentInventorySnapshotRepository;
441 
 
442 
	@Autowired
443 
	private FocusedModelRepository focusedModelRepository;
444 
 
445 
	@Autowired
24669 govind 446 
	private UserAccountRepository userAccountRepository;
24653 govind 447 
 
25721 tejbeer 448 
	@Autowired
25927 amit.gupta 449 
	private UserRepository userUserRepository;
25721 tejbeer 450 
 
451 
	@Autowired
25927 amit.gupta 452 
	private com.spice.profitmandi.dao.repository.dtr.UserRepository dtrUserRepository;
453 
 
454 
	@Autowired
25721 tejbeer 455 
	private UserCampaignRepository userCampaignRepository;
456 
 
457 
	@Autowired
458 
	private Gson gson;
459 
 
26283 tejbeer 460 
	@Autowired
461 
	private TicketRepository ticketRepository;
462 
 
26790 tejbeer 463 
	@Autowired
464 
	private RefferalRepository refferalRepository;
465 
 
28205 tejbeer 466 
	@Autowired
467 
	private PartnerProblemRepository partnerProblemRepository;
468 
 
28368 tejbeer 469 
	@Autowired
470 
	private PendingOrderRepository pendingOrderRepository;
471 
 
472 
	@Autowired
473 
	private PendingOrderItemRepository pendingOrderItemRepository;
474 
 
475 
	@Value("${razorpay.account.keyId}")
476 
	private String keyId;
477 
 
478 
	@Value("${razorpay.account.keySecret}")
479 
	private String keySecret;
480 
 
28369 tejbeer 481 
	@Autowired
482 
	private RazorpayPaymentService razorPaymentService;
483 
 
484 
	@Autowired
485 
	private RazorPayRepository razorPayRepository;
486 
 
28377 tejbeer 487 
	@Autowired
488 
	private PendingOrderService pendingOrderService;
489 
 
490 
	@Autowired
491 
	private CustomerRepository customerRepository;
492 
 
23755 amit.gupta 493 
	private static final Logger LOGGER = LogManager.getLogger(ScheduledTasks.class);
23724 amit.gupta 494 
 
25300 tejbeer 495 
	private String FCM_URL = "https://fcm.googleapis.com/fcm/send";
496 
	private String FCM_API_KEY = "AAAASAjNcn4:APA91bG6fWRIgYJI0L9gCjP5ynaXz2hJHYKtD9dfH7Depdv31Nd9APJwhx-OPkAJ1WSz4BGNYG8lHThLFSjDGFxIwUZv241YcAJEGDLgt86mxq9FXJe-yBRu-S0_ZwHqmX-QaVKl5F_A";
497 
 
23724 amit.gupta 498 
	public void generateDailyRecharge() {
499 
		List<RechargeProviderCreditWalletHistory> allCreditHistory = rechargeProviderCreditWalletHistoryRepository
500 
				.selectAll(0, 2000);
501 
		List<RechargeProvider> rechargeProviders = rechargeProviderRepository.selectAll();
502 
		rechargeProviders.stream().forEach(x -> x.setAmount(0));
503 
 
504 
		rechargeProviders.stream().forEach(x -> {
505 
			Map<LocalDate, List<RechargeProviderCreditWalletHistory>> dateWiseProviderCreditsMap = allCreditHistory
506 
					.stream().filter(z -> z.getProviderId() == x.getId())
507 
					.collect(Collectors.groupingBy(x1 -> x1.getReceiveTimestamp().toLocalDate()));
508 
 
509 
			LOGGER.info("dateWiseProviderCreditsMap -- {}", dateWiseProviderCreditsMap);
510 
			LocalDate endDate = LocalDate.now().plusDays(1);
511 
			float previousDayClosing = 0;
512 
			LocalDate date = LocalDate.of(2018, 4, 6);
513 
			while (date.isBefore(endDate)) {
514 
				List<RechargeTransaction> dateWiseRechargeTransactions = rechargeTransactionRepository
515 
						.selectAllBetweenTimestamp(Arrays.asList(RechargeStatus.values()), date.atStartOfDay(),
516 
								date.plusDays(1).atStartOfDay());
517 
 
518 
				List<RechargeTransaction> successfulTransactions = dateWiseRechargeTransactions.stream()
519 
						.filter(y -> y.getStatus().equals(RechargeStatus.SUCCESS)).collect(Collectors.toList());
520 
 
521 
				float dailyAmount = 0;
522 
				float totalCommission = 0;
523 
				for (RechargeTransaction rechargeTransaction : successfulTransactions) {
524 
					if (rechargeTransaction.getProviderId() == x.getId()) {
525 
						dailyAmount += rechargeTransaction.getAmount();
526 
						totalCommission += rechargeTransaction.getCommission();
527 
					}
528 
				}
529 
 
530 
				List<RechargeProviderCreditWalletHistory> rechargeHistoryList = dateWiseProviderCreditsMap.get(date);
531 
				float dailyWalletRecharge = 0;
532 
				if (rechargeHistoryList != null) {
533 
					for (RechargeProviderCreditWalletHistory rechargeProviderCreditWalletHistory : rechargeHistoryList) {
534 
						if (rechargeProviderCreditWalletHistory.getProviderId() == x.getId()) {
535 
							dailyWalletRecharge += rechargeProviderCreditWalletHistory.getAmount();
536 
						}
537 
					}
538 
				}
539 
				if (dailyAmount > 0 || dailyWalletRecharge > 0) {
540 
					DailyRecharge dailyRecharge = null;
541 
					try {
542 
						dailyRecharge = dailyRechargeRepository.selectByProviderIdAndCreateDate(x.getId(), date);
543 
					} catch (Exception e) {
544 
						LOGGER.info("Could not find Recharge entry");
545 
					}
546 
					if (dailyRecharge == null) {
547 
						dailyRecharge = new DailyRecharge();
548 
						dailyRecharge.setCreateDate(date);
549 
					}
550 
					dailyRecharge.setOpeningBalance(previousDayClosing);
551 
					dailyRecharge.setProviderId(x.getId());
552 
					dailyRecharge.setWalletRechargeAmount(dailyWalletRecharge);
553 
					dailyRecharge.setTotalAmount(dailyAmount);
554 
					dailyRecharge.setTotalCommission(totalCommission);
555 
					float closingBalance = dailyRecharge.getOpeningBalance() + dailyWalletRecharge - dailyAmount;
556 
					dailyRecharge.setClosingBalance(closingBalance);
557 
					dailyRechargeRepository.persist(dailyRecharge);
558 
					x.setAmount(x.getAmount() + dailyRecharge.getClosingBalance() - dailyRecharge.getOpeningBalance());
559 
					previousDayClosing = dailyRecharge.getClosingBalance();
560 
				}
561 
				date = date.plusDays(1);
562 
			}
563 
			rechargeProviderRepository.persist(x);
564 
		});
23761 amit.gupta 565 
		LOGGER.info("finished generating daily recharge");
23724 amit.gupta 566 
	}
567 
 
23738 amit.gupta 568 
	public void reconcileRecharge() throws Exception {
23724 amit.gupta 569 
		LocalDateTime fromDate = LocalDateTime.now().truncatedTo(ChronoUnit.DAYS).minusDays(30);
570 
		LocalDateTime toDate = LocalDateTime.now().truncatedTo(ChronoUnit.DAYS);
571 
		List<RechargeStatus> nonSuccessRechargeStatuses = new ArrayList<>(Arrays.asList(RechargeStatus.values()));
572 
		LOGGER.info("nonSuccessRechargeStatuses {} ", nonSuccessRechargeStatuses);
573 
		nonSuccessRechargeStatuses.remove(RechargeStatus.SUCCESS);
574 
		nonSuccessRechargeStatuses.remove(RechargeStatus.FAILED);
575 
		RechargeCredential thinkWalnutDigitalRechargeEnquiryCredential = new RechargeCredential();
576 
		thinkWalnutDigitalRechargeEnquiryCredential.setRechargeUrl(thinkWalnutDigitalRechargeEnquiryUrl);
577 
		thinkWalnutDigitalRechargeEnquiryCredential.setRechargeUserName(thinkWalnutDigitalRechargeUserName);
578 
		thinkWalnutDigitalRechargeEnquiryCredential.setRechargePassword(thinkWalnutDigitalRechargePassword);
579 
		thinkWalnutDigitalRechargeEnquiryCredential.setRechargeAuthKey(thinkWalnutDigitalRechargeAuthKey);
580 
		Map<String, RechargeStatus> requestRechargeStatusChanged = new HashMap<>();
581 
		List<RechargeTransaction> rechargeTransactions = rechargeTransactionRepository
582 
				.selectAllBetweenTimestamp(nonSuccessRechargeStatuses, fromDate, toDate);
583 
		for (RechargeTransaction rechargeTransaction : rechargeTransactions) {
584 
			try {
585 
				int providerId = rechargeTransaction.getProviderId();
586 
				if (providerId == 1) {
587 
					oxigenRechargeProviderService.doCheckStatusRequest(oxigenRechargeEnquiryUrl, oxigenRechargeAuthKey,
588 
							rechargeTransaction);
589 
				} else if (providerId == 2) {
590 
					thinkWalnutDigitalRechargeProviderService
591 
							.doCheckStatusRequest(thinkWalnutDigitalRechargeEnquiryCredential, rechargeTransaction);
592 
				}
593 
				if (rechargeTransaction.getStatus().equals(RechargeStatus.SUCCESS)
594 
						|| rechargeTransaction.getStatus().equals(RechargeStatus.FAILED)) {
595 
					requestRechargeStatusChanged.put(rechargeTransaction.getRequestId(),
596 
							rechargeTransaction.getStatus());
597 
				}
598 
			} catch (Exception e) {
599 
				LOGGER.info("Could not check status for Request {}", rechargeTransaction.getRequestId());
600 
			}
601 
		}
23738 amit.gupta 602 
		LOGGER.info("Reconcile recharge ran successfully");
23724 amit.gupta 603 
	}
28205 tejbeer 604 
 
27438 amit.gupta 605 
	public void processActivation() throws Exception {
606 
		schemeService.processActivation();
607 
	}
24240 amit.gupta 608 
 
609 
	// TemporaryMethod
24237 amit.gupta 610 
	public void migrateInvoice() {
611 
		List<FofoOrder> fofoOrders = fofoOrderRepository.selectFromSaleDate(LocalDateTime.now().minusDays(3));
612 
		Map<Integer, List<FofoOrder>> partnerOrdersMap = new HashMap<>();
24241 amit.gupta 613 
		partnerOrdersMap = fofoOrders.stream()
614 
				.collect(Collectors.groupingBy(FofoOrder::getFofoId, Collectors.toList()));
24237 amit.gupta 615 
		for (List<FofoOrder> orderList : partnerOrdersMap.values()) {
24240 amit.gupta 616 
			int sequence = 0;
617 
			String prefix = "";
24241 amit.gupta 618 
			List<FofoOrder> sortedList = orderList.stream().sorted((x1, x2) -> x1.getId() - x2.getId())
619 
					.collect(Collectors.toList());
620 
			for (FofoOrder order : sortedList) {
621 
 
24240 amit.gupta 622 
				LOGGER.info("Order Id is {}, partner Id is {}", order.getId(), order.getFofoId());
24241 amit.gupta 623 
				if (!order.getInvoiceNumber().contains("SEC")) {
24240 amit.gupta 624 
					sequence = Integer.parseInt(order.getInvoiceNumber().split("/")[1]);
625 
					prefix = order.getInvoiceNumber().split("/")[0];
626 
				} else {
627 
					sequence += 1;
24241 amit.gupta 628 
					String invoiceNumber = prefix + "/" + sequence;
24240 amit.gupta 629 
					order.setInvoiceNumber(invoiceNumber);
630 
					fofoOrderRepository.persist(order);
631 
				}
632 
			}
24241 amit.gupta 633 
 
24237 amit.gupta 634 
		}
635 
	}
23724 amit.gupta 636 
 
24241 amit.gupta 637 
	// Temporary Method
24252 amit.gupta 638 
	public void evaluateExcessSchemeOut() throws Exception {
24244 amit.gupta 639 
		Map<Integer, String> userNameMap = retailerService.getAllFofoRetailerIdNameMap();
640 
		Map<Integer, Float> userAmountMap = new HashMap<>();
24252 amit.gupta 641 
 
25837 amit.gupta 642 
		List<List<?>> rows = new ArrayList<>();
24271 amit.gupta 643 
		List<String> headers = Arrays.asList("Scheme", "Item", "Partner", "Amount", "Credited On", "Invoice Number",
644 
				"Sale On", "Scheme Start", "Scheme End", "Active On", "Expired On");
24241 amit.gupta 645 
		schemeRepository.selectAll().stream().forEach(x -> {
24250 amit.gupta 646 
			if (x.getType().equals(SchemeType.OUT)) {
647 
				List<SchemeInOut> sioList = schemeInOutRepository
648 
						.selectBySchemeIds(new HashSet<>(Arrays.asList(x.getId())));
649 
				if (x.getActiveTimestamp() != null) {
650 
					LocalDateTime endDateTime = x.getEndDateTime();
651 
					if (x.getExpireTimestamp() != null && x.getExpireTimestamp().isBefore(x.getEndDateTime())) {
652 
						endDateTime = x.getExpireTimestamp();
24249 amit.gupta 653 
					}
24250 amit.gupta 654 
					for (SchemeInOut sio : sioList) {
655 
						InventoryItem inventoryItem = null;
24266 amit.gupta 656 
						inventoryItem = inventoryItemRepository.selectById(sio.getInventoryItemId());
24271 amit.gupta 657 
						FofoOrder fofoOrder = fofoOrderRepository.selectByFofoIdAndSerialNumber(
658 
								inventoryItem.getFofoId(), inventoryItem.getSerialNumber(), null, null, 0, 1).get(0);
24250 amit.gupta 659 
						Optional<ScanRecord> record = scanRecordRepository
660 
								.selectByInventoryItemId(sio.getInventoryItemId()).stream()
661 
								.filter(y -> y.getType().equals(ScanType.SALE)).findFirst();
662 
						if (record.isPresent()) {
663 
							int fofoId = record.get().getFofoId();
664 
							if (record.get().getCreateTimestamp().isAfter(endDateTime)
665 
									|| record.get().getCreateTimestamp().isBefore(x.getStartDateTime())) {
666 
								if (!userAmountMap.containsKey(fofoId)) {
667 
									userAmountMap.put(fofoId, 0f);
668 
								}
669 
								userAmountMap.put(fofoId, sio.getAmount() + userAmountMap.get(fofoId));
670 
								try {
24252 amit.gupta 671 
									rows.add(Arrays.asList(x.getDescription(),
24250 amit.gupta 672 
											itemRepository.selectById(inventoryItem.getItemId()).getItemDescription(),
24252 amit.gupta 673 
											userNameMap.get(fofoId), sio.getAmount(),
24253 amit.gupta 674 
											FormattingUtils.formatDate(sio.getCreateTimestamp()),
675 
											fofoOrder.getInvoiceNumber(),
676 
											FormattingUtils.formatDate(record.get().getCreateTimestamp()),
677 
											FormattingUtils.formatDate(x.getStartDateTime()),
678 
											FormattingUtils.formatDate(x.getEndDateTime()),
679 
											FormattingUtils.formatDate(x.getActiveTimestamp()),
680 
											FormattingUtils.formatDate(x.getExpireTimestamp())));
24250 amit.gupta 681 
								} catch (Exception e) {
682 
									e.printStackTrace();
683 
								}
24242 amit.gupta 684 
							}
24241 amit.gupta 685 
						}
686 
					}
687 
				}
688 
			}
689 
		});
24246 amit.gupta 690 
		userAmountMap.entrySet().stream()
691 
				.forEach(x -> LOGGER.info("{} to be deducted from {}({}) for wrongly disbursed due to technical error.",
692 
						x.getValue(), userNameMap.get(x.getKey())));
24241 amit.gupta 693 
 
24252 amit.gupta 694 
		ByteArrayOutputStream baos = FileUtil.getCSVByteStream(headers, rows);
24271 amit.gupta 695 
		Utils.sendMailWithAttachment(googleMailSender,
696 
				new String[] { "amit.gupta@shop2020.in", "adeel.yazdani@smartdukaan.com" }, null,
697 
				"Partner Excess Amount", "PFA", "ListofSchemes.csv", new ByteArrayResource(baos.toByteArray()));
24252 amit.gupta 698 
 
24241 amit.gupta 699 
	}
24271 amit.gupta 700 
 
25584 amit.gupta 701 
	public void processScheme(int offset, boolean dryRun) throws Exception {
24462 amit.gupta 702 
		LocalDateTime startDate = LocalDateTime.of(LocalDate.now(), LocalTime.MIDNIGHT).minusDays(offset);
24259 amit.gupta 703 
		LocalDateTime endDate = startDate.plusDays(30);
25584 amit.gupta 704 
		processScheme(startDate, endDate, dryRun);
24256 amit.gupta 705 
	}
28205 tejbeer 706 
 
27892 amit.gupta 707 
	public void processSchemeOut(List<String> invoiceNumbers) throws Exception {
28205 tejbeer 708 
		for (String invoiceNumber : invoiceNumbers) {
709 
			System.out.println("Invoice Number - " + invoiceNumber);
27892 amit.gupta 710 
			FofoOrder fofoOrder = fofoOrderRepository.selectByInvoiceNumber(invoiceNumber);
711 
			schemeService.processSchemeOut(fofoOrder.getId(), fofoOrder.getFofoId());
712 
		}
713 
	}
28205 tejbeer 714 
 
27987 amit.gupta 715 
	public void processSchemeIn(List<String> invoiceNumbers) throws Exception {
28205 tejbeer 716 
		for (String invoiceNumber : invoiceNumbers) {
717 
			System.out.println("Invoice Number - " + invoiceNumber);
27987 amit.gupta 718 
			Purchase purchase = purchaseRepository.selectByPurchaseReference(invoiceNumber);
719 
			schemeService.processSchemeIn(purchase.getId(), purchase.getFofoId());
720 
		}
721 
	}
24533 govind 722 
 
25584 amit.gupta 723 
	public void processScheme(int offset, int durationDays, boolean dryRun) throws Exception {
24462 amit.gupta 724 
		LocalDateTime startDate = LocalDateTime.of(LocalDate.now(), LocalTime.MIDNIGHT).minusDays(offset);
24461 amit.gupta 725 
		LocalDateTime endDate = startDate.plusDays(durationDays);
25584 amit.gupta 726 
		processScheme(startDate, endDate, dryRun);
24461 amit.gupta 727 
	}
24271 amit.gupta 728 
 
25584 amit.gupta 729 
	public void processScheme(boolean dryRun) throws Exception {
24256 amit.gupta 730 
		LocalDateTime fromDate = LocalDateTime.now().minusDays(30);
25584 amit.gupta 731 
		processScheme(fromDate, LocalDateTime.now(), dryRun);
24256 amit.gupta 732 
	}
24271 amit.gupta 733 
 
25584 amit.gupta 734 
	public void processScheme(LocalDateTime startDate, LocalDateTime endDate, boolean dryRun) throws Exception {
23724 amit.gupta 735 
		LOGGER.info("Started execution at {}", LocalDateTime.now());
25312 amit.gupta 736 
		System.out.println(
737 
				"InventoryId\tSerialNumber\tItem Id\tScheme Id\tScheme Name\tScheme Type\tAmount Type\tDP\tTaxable\tScheme Amount\tAmount Paid");
24561 amit.gupta 738 
		try {
24587 amit.gupta 739 
			List<Purchase> purchases = purchaseRepository.selectAllBetweenPurchaseDate(startDate, endDate);
740 
			for (Purchase purchase : purchases) {
741 
				schemeService.processSchemeIn(purchase.getId(), purchase.getFofoId());
742 
			}
24271 amit.gupta 743 
 
24587 amit.gupta 744 
			List<FofoOrder> fofoOrders = fofoOrderRepository.selectBetweenSaleDate(startDate, endDate);
745 
			for (FofoOrder fofoOrder : fofoOrders) {
746 
				schemeService.processSchemeOut(fofoOrder.getId(), fofoOrder.getFofoId());
747 
			}
748 
		} catch (Exception e) {
24561 amit.gupta 749 
			e.printStackTrace();
24565 amit.gupta 750 
			throw e;
24561 amit.gupta 751 
		}
28205 tejbeer 752 
		List<UserWalletHistory> uwhs = userWalletHistoryRepository.selectAllByDateType(LocalDate.now().atStartOfDay(),
753 
				endDate, Arrays.asList(WalletReferenceType.SCHEME_IN, WalletReferenceType.SCHEME_OUT));
25043 amit.gupta 754 
		System.out.println("Amount\tReference\tReferenceType\tTimestamp\tDescription");
25312 amit.gupta 755 
		for (UserWalletHistory uwh : uwhs) {
756 
			System.out.println(String.format("%d\t%d\t%s\t%s\t%s", uwh.getAmount(), uwh.getReference(),
757 
					uwh.getReferenceType(), uwh.getTimestamp().toString(), uwh.getDescription()));
25043 amit.gupta 758 
		}
23724 amit.gupta 759 
		LOGGER.info("Schemes process successfully.");
25598 amit.gupta 760 
		if (dryRun) {
25584 amit.gupta 761 
			throw new Exception();
762 
		}
23724 amit.gupta 763 
	}
23929 amit.gupta 764 
 
23739 amit.gupta 765 
	public void processRechargeCashback() throws Throwable {
23761 amit.gupta 766 
		LocalDateTime cashbackTime = LocalDateTime.now();
23929 amit.gupta 767 
		int referenceId = (int) Timestamp.valueOf(cashbackTime).getTime() / 1000;
768 
		List<RechargeTransaction> pendingTransactions = rechargeTransactionRepository
769 
				.getPendingCashBackRehargeTransactions();
770 
		Map<Object, Double> totalRetailerCashbacks = pendingTransactions.stream().collect(
771 
				Collectors.groupingBy(x -> x.getRetailerId(), Collectors.summingDouble(x -> x.getCommission())));
772 
		for (Map.Entry<Object, Double> totalRetailerCashback : totalRetailerCashbacks.entrySet()) {
773 
			int retailerId = (Integer) totalRetailerCashback.getKey();
23739 amit.gupta 774 
			float amount = totalRetailerCashback.getValue().floatValue();
23929 amit.gupta 775 
			if (Math.round(amount) > 0) {
776 
				walletService.addAmountToWallet(retailerId, referenceId, WalletReferenceType.CASHBACK,
26565 amit.gupta 777 
						"Recharge Cashback", Math.round(amount), LocalDateTime.now());
23762 amit.gupta 778 
			}
23739 amit.gupta 779 
		}
23929 amit.gupta 780 
		for (RechargeTransaction rt : pendingTransactions) {
23761 amit.gupta 781 
			rt.setCashbackTimestamp(cashbackTime);
782 
			rt.setCashbackReference(referenceId);
783 
			rechargeTransactionRepository.persist(rt);
784 
		}
23739 amit.gupta 785 
		LOGGER.info("Cashbacks for Recharge processed Successfully");
786 
	}
29160 amit.gupta 787 
 
788 
	public void rollOutUpgardedMarginsNextMonth() throws Exception {
29107 amit.gupta 789 
		LocalDate startOfPreviousMonth = LocalDate.now().with(ChronoField.DAY_OF_MONTH, 1).minusMonths(1);
29160 amit.gupta 790 
 
28971 amit.gupta 791 
		List<FofoStore> stores = fofoStoreRepository.selectActiveStores();
29160 amit.gupta 792 
		for (FofoStore store : stores) {
793 
			int fofoId = store.getId();
794 
 
795 
			PartnerType startOfMonthPartnerType = partnerTypeChangeService.getTypeOnDate(fofoId, startOfPreviousMonth);
796 
			PartnerType todayPartnerType = partnerTypeChangeService.getTypeOnMonth(fofoId,
797 
					YearMonth.from(startOfPreviousMonth.atStartOfDay()));
798 
			if (!startOfMonthPartnerType.nextPartnerTypes().contains(todayPartnerType)) {
799 
				continue;
800 
			}
801 
			if (!startOfMonthPartnerType.equals(todayPartnerType)) {
802 
				LOGGER.info("Partner Type has been changed for code {} from {} to {}", store.getCode(),
803 
						startOfMonthPartnerType, todayPartnerType);
804 
				List<FofoOrder> fofoOrders = fofoOrderRepository.selectByFofoId(fofoId,
805 
						startOfPreviousMonth.atStartOfDay(), startOfPreviousMonth.plusMonths(1).atStartOfDay(), 0, 0);
806 
				for (FofoOrder fofoOrder : fofoOrders) {
807 
					schemeService.processSchemeOut(fofoOrder.getId(), fofoId);
28974 amit.gupta 808 
				}
29160 amit.gupta 809 
 
810 
			}
28971 amit.gupta 811 
		}
812 
	}
29160 amit.gupta 813 
	public void rollOutUpgardedMargins() throws Exception {
814 
		LocalDate today = LocalDate.now();
815 
		LocalDate yesterday = today.minusDays(1);
816 
		int upgradedCount = 0;
817 
		List<FofoStore> stores = fofoStoreRepository.selectActiveStores();
818 
		StringBuilder sb = new StringBuilder();
819 
		for (FofoStore store : stores) {
820 
			int fofoId = store.getId();
821 
 
822 
			PartnerType yesterdayPartnerType = partnerTypeChangeService.getTypeOnDate(fofoId, yesterday);
823 
			PartnerType todayPartnerType = partnerTypeChangeService.getTypeOnDate(fofoId, today);
824 
			if (!yesterdayPartnerType.nextPartnerTypes().contains(todayPartnerType)) {
825 
				continue;
826 
			}
827 
			if (!yesterdayPartnerType.equals(todayPartnerType)) {
828 
				upgradedCount++;
829 
				sb.append(String.format("Partner Type has been changed for code %s from %s to %s", store.getCode(), yesterdayPartnerType.toString(), todayPartnerType.toString()));
830 
				sb.append("<br>");
831 
				LOGGER.info("Partner Type has been changed for code {} from {} to {}", store.getCode(),
832 
						yesterdayPartnerType, todayPartnerType);
833 
				List<FofoOrder> fofoOrders = fofoOrderRepository.selectByFofoId(fofoId,
834 
						yesterday.withDayOfMonth(1).atStartOfDay(), yesterday.atStartOfDay(), 0, 0);
835 
				for (FofoOrder fofoOrder : fofoOrders) {
836 
					schemeService.processSchemeOut(fofoOrder.getId(), fofoId);
837 
				}
838 
 
839 
			}
840 
		}
841 
		if(upgradedCount > 0) {
842 
			sendMailHtmlFormat(new String[] {"amit.gupta@smartdukaan.com", "tarun.verma@smartdukaan.com", "neeraj.gupta@smartdukaan.com"}, sb.toString(), null, "Few Partners Category have been Upgraded");
843 
		} else {
844 
			sendMailHtmlFormat(new String[] {"amit.gupta@smartdukaan.com", "tarun.verma@smartdukaan.com", "neeraj.gupta@smartdukaan.com"}, sb.toString(), null, "No partners Category have been upgraded today");
845 
		}
846 
	}
23724 amit.gupta 847 
 
25598 amit.gupta 848 
	private class SaleRoles {
849 
 
850 
		private List<String> l1;
851 
		private List<String> l2;
852 
 
853 
		public SaleRoles() {
854 
			l1 = new ArrayList<>();
855 
			l2 = new ArrayList<>();
856 
		}
857 
 
858 
		public List<String> getL1() {
859 
			return l1;
860 
		}
861 
 
862 
		public List<String> getL2() {
863 
			return l2;
864 
		}
865 
 
866 
	}
867 
 
26945 amit.gupta 868 
	private class FofoReportingModel {
869 
		private String code;
870 
		private int fofoId;
871 
		private String businessName;
872 
		private String territoryManager;
873 
		private String regionalManager;
874 
 
875 
		@Override
876 
		public String toString() {
877 
			return "FofoReportingModel [code=" + code + ", fofoId=" + fofoId + ", businessName=" + businessName
878 
					+ ", territoryManager=" + territoryManager + ", regionalManager=" + regionalManager + "]";
879 
		}
880 
 
881 
		public String getCode() {
882 
			return code;
883 
		}
884 
 
885 
		public void setCode(String code) {
886 
			this.code = code;
887 
		}
888 
 
889 
		public String getBusinessName() {
890 
			return businessName;
891 
		}
892 
 
893 
		public void setBusinessName(String businessName) {
894 
			this.businessName = businessName;
895 
		}
896 
 
897 
		public String getTerritoryManager() {
898 
			return territoryManager;
899 
		}
900 
 
901 
		public void setTerritoryManager(String territoryManager) {
902 
			this.territoryManager = territoryManager;
903 
		}
904 
 
905 
		public String getRegionalManager() {
906 
			return regionalManager;
907 
		}
908 
 
909 
		public void setRegionalManager(String regionalManager) {
910 
			this.regionalManager = regionalManager;
911 
		}
912 
 
913 
		private ScheduledTasks getOuterType() {
914 
			return ScheduledTasks.this;
915 
		}
916 
 
917 
		@Override
918 
		public int hashCode() {
919 
			final int prime = 31;
920 
			int result = 1;
921 
			result = prime * result + getOuterType().hashCode();
922 
			result = prime * result + ((businessName == null) ? 0 : businessName.hashCode());
923 
			result = prime * result + ((code == null) ? 0 : code.hashCode());
924 
			result = prime * result + fofoId;
925 
			result = prime * result + ((regionalManager == null) ? 0 : regionalManager.hashCode());
926 
			result = prime * result + ((territoryManager == null) ? 0 : territoryManager.hashCode());
927 
			return result;
928 
		}
929 
 
930 
		@Override
931 
		public boolean equals(Object obj) {
932 
			if (this == obj)
933 
				return true;
934 
			if (obj == null)
935 
				return false;
936 
			if (getClass() != obj.getClass())
937 
				return false;
938 
			FofoReportingModel other = (FofoReportingModel) obj;
939 
			if (!getOuterType().equals(other.getOuterType()))
940 
				return false;
941 
			if (businessName == null) {
942 
				if (other.businessName != null)
943 
					return false;
944 
			} else if (!businessName.equals(other.businessName))
945 
				return false;
946 
			if (code == null) {
947 
				if (other.code != null)
948 
					return false;
949 
			} else if (!code.equals(other.code))
950 
				return false;
951 
			if (fofoId != other.fofoId)
952 
				return false;
953 
			if (regionalManager == null) {
954 
				if (other.regionalManager != null)
955 
					return false;
956 
			} else if (!regionalManager.equals(other.regionalManager))
957 
				return false;
958 
			if (territoryManager == null) {
959 
				if (other.territoryManager != null)
960 
					return false;
961 
			} else if (!territoryManager.equals(other.territoryManager))
962 
				return false;
963 
			return true;
964 
		}
965 
 
966 
		public int getFofoId() {
967 
			return fofoId;
968 
		}
969 
 
970 
		public void setFofoId(int fofoId) {
971 
			this.fofoId = fofoId;
972 
		}
973 
 
974 
	}
975 
 
24271 amit.gupta 976 
	public void sendPartnerInvestmentDetails(List<String> sendTo) throws Exception {
24277 amit.gupta 977 
		LocalDate yesterDay = LocalDate.now().minusDays(1);
25267 amit.gupta 978 
		List<FofoStore> fofoStores = fofoStoreRepository.selectActiveStores();
23929 amit.gupta 979 
		Map<Integer, CustomRetailer> customRetailerMap = retailerService
980 
				.getFofoRetailers(fofoStores.stream().map(x -> x.getId()).collect(Collectors.toList()));
25351 tejbeer 981 
 
26957 amit.gupta 982 
		List<String> headers = Arrays.asList("Code", "Outlet name", "State Manager", "Teritory/Team Lead",
26945 amit.gupta 983 
				"Wallet Amount", "In Stock Amount", "Activated Stock", "Return In Transit Stock", "Unbilled Amount",
984 
				"Grn Pending Amount", "Min Investment", "Investment Amount", "Investment Short", "Unbilled Qty",
985 
				"Short Days");
25837 amit.gupta 986 
		List<List<?>> rows = new ArrayList<>();
25895 amit.gupta 987 
		Map<Integer, List<?>> partnerRowsMap = new HashMap<>();
25598 amit.gupta 988 
 
26945 amit.gupta 989 
		Map<Integer, FofoReportingModel> partnerIdSalesHeaderMap = this.getPartnerIdSalesHeaders();
25598 amit.gupta 990 
 
26945 amit.gupta 991 
		Map<Integer, Integer> shortDaysMap = partnerDailyInvestmentRepository
992 
				.selectAll(LocalDate.now().withDayOfMonth(1), LocalDate.now()).stream().collect(Collectors.groupingBy(
993 
						x -> x.getFofoId(), Collectors.summingInt(x -> x.getShortPercentage() > 10 ? 1 : 0)));
994 
 
24002 amit.gupta 995 
		for (FofoStore fofoStore : fofoStores) {
27750 amit.gupta 996 
			LOGGER.info("Fofo Store {},  {}", fofoStore.getId(), fofoStore.getCode());
26376 amit.gupta 997 
			int fofoId = fofoStore.getId();
26945 amit.gupta 998 
			PartnerDailyInvestment partnerDailyInvestment = partnerInvestmentService.getInvestment(fofoId, 1);
25598 amit.gupta 999 
			partnerDailyInvestment.setDate(yesterDay);
26945 amit.gupta 1000 
 
25598 amit.gupta 1001 
			try {
1002 
				partnerDailyInvestmentRepository.persist(partnerDailyInvestment);
26945 amit.gupta 1003 
				shortDaysMap.put(fofoId,
1004 
						shortDaysMap.get(fofoId) + (partnerDailyInvestment.getShortPercentage() > 10 ? 1 : 0));
25598 amit.gupta 1005 
			} catch (Exception e) {
1006 
				// ignore the exceptions during persist
1007 
			}
1008 
 
24002 amit.gupta 1009 
			CustomRetailer retailer = customRetailerMap.get(fofoStore.getId());
25837 amit.gupta 1010 
			if (retailer == null || partnerIdSalesHeaderMap.get(fofoStore.getId()) == null) {
24002 amit.gupta 1011 
				LOGGER.info("Could not find retailer with retailer Id {}", fofoStore.getId());
1012 
				continue;
1013 
			}
26945 amit.gupta 1014 
			FofoReportingModel reportingModel = partnerIdSalesHeaderMap.get(fofoStore.getId());
1015 
			List<Serializable> row = new ArrayList<>();
1016 
			row.addAll(Arrays.asList(reportingModel.getCode(), reportingModel.getBusinessName(),
1017 
					reportingModel.getRegionalManager(), reportingModel.getTerritoryManager()));
25927 amit.gupta 1018 
			row.addAll(
1019 
					Arrays.asList(partnerDailyInvestment.getWalletAmount(), partnerDailyInvestment.getInStockAmount(),
26945 amit.gupta 1020 
							partnerDailyInvestment.getActivatedStockAmount() == 0 ? "-"
1021 
									: "(" + partnerDailyInvestment.getActivatedStockAmount() + ")",
25927 amit.gupta 1022 
							0, partnerDailyInvestment.getUnbilledAmount(), partnerDailyInvestment.getGrnPendingAmount(),
1023 
							partnerDailyInvestment.getMinInvestment(), partnerDailyInvestment.getTotalInvestment(),
26945 amit.gupta 1024 
							partnerDailyInvestment.getShortInvestment(), partnerDailyInvestment.getUnbilledQty(),
1025 
							shortDaysMap.get(fofoId)));
25837 amit.gupta 1026 
			partnerRowsMap.put(fofoStore.getId(), row);
24002 amit.gupta 1027 
			rows.add(row);
1028 
 
23929 amit.gupta 1029 
		}
25312 amit.gupta 1030 
 
24271 amit.gupta 1031 
		String fileName = "InvestmentSummary-" + FormattingUtils.formatDate(LocalDateTime.now()) + ".csv";
25598 amit.gupta 1032 
 
25927 amit.gupta 1033 
		if (sendTo == null) {
25895 amit.gupta 1034 
			for (Map.Entry<String, Set<Integer>> storeGuyEntry : csService.getAuthUserPartnerIdMapping().entrySet()) {
1035 
				List<List<?>> filteredRows = storeGuyEntry.getValue().stream().map(x -> partnerRowsMap.get(x))
1036 
						.filter(x -> x != null).collect(Collectors.toList());
1037 
				ByteArrayOutputStream baos = FileUtil.getCSVByteStream(headers, filteredRows);
1038 
				String[] sendToArray = new String[] { storeGuyEntry.getKey() };
1039 
				Utils.sendMailWithAttachment(googleMailSender, sendToArray, null, "Franchise Investment Summary", "PFA",
1040 
						fileName, new ByteArrayResource(baos.toByteArray()));
1041 
			}
27210 tejbeer 1042 
			sendTo = Arrays.asList("tarun.verma@smartdukaan.com", "kamini.sharma@smartdukaan.com",
28467 tejbeer 1043 
					"neeraj.gupta@smartdukaan.com", "amit.gupta@shop2020.in", "manish.gupta@smartdukaan.com",
1044 
					"niranjan.kala@smartdukaan.com");
25341 amit.gupta 1045 
		}
25312 amit.gupta 1046 
 
25604 amit.gupta 1047 
		ByteArrayOutputStream baos = FileUtil.getCSVByteStream(headers, rows);
1048 
		String[] sendToArray = sendTo.toArray(new String[sendTo.size()]);
25609 amit.gupta 1049 
		Utils.sendMailWithAttachment(googleMailSender, sendToArray, null, "Franchise Investment Summary", "PFA",
1050 
				fileName, new ByteArrayResource(baos.toByteArray()));
24271 amit.gupta 1051 
 
23929 amit.gupta 1052 
	}
24177 govind 1053 
 
26945 amit.gupta 1054 
	private Map<Integer, FofoReportingModel> getPartnerIdSalesHeaders() {
25598 amit.gupta 1055 
		Map<String, SaleRoles> partnerEmailSalesMap = new HashMap<>();
1056 
 
1057 
		List<Position> positions = positionRepository
1058 
				.selectPositionByCategoryId(ProfitMandiConstants.TICKET_CATEGORY_SALES);
1059 
		Map<Integer, AuthUser> authUsersMap = authRepository.selectAllActiveUser().stream()
1060 
				.collect(Collectors.toMap(x -> x.getId(), x -> x));
1061 
		Map<Integer, List<CustomRetailer>> positionIdRetailerMap = csService.getPositionCustomRetailerMap(positions);
1062 
		for (Position position : positions) {
1063 
			List<CustomRetailer> crList = positionIdRetailerMap.get(position.getId());
25609 amit.gupta 1064 
			if (crList == null)
1065 
				continue;
25598 amit.gupta 1066 
			for (CustomRetailer cr : crList) {
1067 
				if (!partnerEmailSalesMap.containsKey(cr.getEmail())) {
1068 
					partnerEmailSalesMap.put(cr.getEmail(), new SaleRoles());
1069 
				}
1070 
				SaleRoles saleRoles = partnerEmailSalesMap.get(cr.getEmail());
1071 
				AuthUser authUser = authUsersMap.get(position.getAuthUserId());
26945 amit.gupta 1072 
				if (authUser == null) {
26059 amit.gupta 1073 
					continue;
1074 
				}
25598 amit.gupta 1075 
				String name = authUser.getFirstName() + " " + authUser.getLastName();
1076 
				if (position.getEscalationType().equals(EscalationType.L1)) {
1077 
					saleRoles.getL1().add(name);
1078 
				} else if (position.getEscalationType().equals(EscalationType.L2)) {
1079 
					saleRoles.getL2().add(name);
1080 
				}
1081 
			}
1082 
		}
25837 amit.gupta 1083 
 
1084 
		Set<CustomRetailer> allCrList = new HashSet<>();
1085 
		for (List<CustomRetailer> cr : positionIdRetailerMap.values()) {
1086 
			allCrList.addAll(cr);
1087 
		}
1088 
 
1089 
		Map<Integer, FofoStore> fofoStoresMap = fofoStoreRepository.selectActiveStores().stream()
1090 
				.collect(Collectors.toMap(x -> x.getId(), x -> x));
1091 
 
26945 amit.gupta 1092 
		Map<Integer, FofoReportingModel> partnerIdSalesHeadersMap = new HashMap<>();
25837 amit.gupta 1093 
 
1094 
		for (CustomRetailer cr : allCrList) {
1095 
			FofoStore fofoStore = fofoStoresMap.get(cr.getPartnerId());
25927 amit.gupta 1096 
			if (fofoStore == null) {
25870 amit.gupta 1097 
				LOGGER.info("Could not find Store {} in active Store", cr.getBusinessName());
1098 
				continue;
1099 
			}
26945 amit.gupta 1100 
			String code = fofoStore.getCode();
1101 
			// String storeName = "SmartDukaan-" +
1102 
			// fofoStore.getCode().replaceAll("[a-zA-Z]", "");
25837 amit.gupta 1103 
			String businessName = cr.getBusinessName();
1104 
			try {
1105 
				String stateManager = StringUtils.join(partnerEmailSalesMap.get(cr.getEmail()).getL2(), ", ");
1106 
				String territoryManager = StringUtils.join(partnerEmailSalesMap.get(cr.getEmail()).getL1(), ", ");
26945 amit.gupta 1107 
				FofoReportingModel reportingModel = new FofoReportingModel();
1108 
				reportingModel.setBusinessName(businessName);
1109 
				reportingModel.setCode(code);
1110 
				reportingModel.setFofoId(fofoStore.getId());
1111 
				reportingModel.setRegionalManager(stateManager);
1112 
				reportingModel.setTerritoryManager(territoryManager);
1113 
				partnerIdSalesHeadersMap.put(fofoStore.getId(), reportingModel);
25837 amit.gupta 1114 
			} catch (Exception e) {
1115 
				LOGGER.warn("Could not find partner with email - {}", cr.getEmail());
1116 
			}
1117 
		}
1118 
		return partnerIdSalesHeadersMap;
1119 
 
25598 amit.gupta 1120 
	}
1121 
 
24271 amit.gupta 1122 
	public void sendPartnerInvestmentDetails() throws Exception {
25565 amit.gupta 1123 
		this.sendPartnerInvestmentDetails(null);
24271 amit.gupta 1124 
	}
1125 
 
24697 amit.gupta 1126 
	public void sendAgeingReport(String... sendTo) throws Exception {
24692 amit.gupta 1127 
 
1128 
		InputStreamSource isr = reporticoService.getReportInputStreamSource(ReporticoProject.WAREHOUSENEW,
1129 
				"itemstockageing.xml");
24708 amit.gupta 1130 
		InputStreamSource isr1 = reporticoService.getReportInputStreamSource(ReporticoProject.FOCO,
24754 amit.gupta 1131 
				"ItemwiseOverallPendingIndent.xml");
24683 amit.gupta 1132 
		Attachment attachment = new Attachment(
25445 amit.gupta 1133 
				"ageing-report-" + FormattingUtils.formatDate(LocalDateTime.now().minusDays(1)) + ".csv", isr);
24707 amit.gupta 1134 
		Attachment attachment1 = new Attachment(
25445 amit.gupta 1135 
				"pending-indent-" + FormattingUtils.formatDate(LocalDateTime.now().minusDays(1)) + ".csv", isr1);
25418 amit.gupta 1136 
 
25609 amit.gupta 1137 
		Utils.sendMailWithAttachments(googleMailSender, STOCK_AGEING_MAIL_LIST, null, "Stock Ageing Report", "PFA",
1138 
				attachment);
1139 
		Utils.sendMailWithAttachments(googleMailSender, ITEMWISE_PENDING_INDENT_MAIL_LIST, null,
1140 
				"Itemwise Pending indent", "PFA", attachment1);
1141 
 
25598 amit.gupta 1142 
		// Reports to be sent to mapped partners
25597 amit.gupta 1143 
		Map<String, Set<String>> storeGuysMap = csService.getAuthUserPartnerEmailMapping();
25503 amit.gupta 1144 
 
1145 
		for (Map.Entry<String, Set<String>> storeGuyEntry : storeGuysMap.entrySet()) {
25418 amit.gupta 1146 
			Map<String, String> params = new HashMap<>();
25503 amit.gupta 1147 
			if (storeGuyEntry.getValue().size() == 0)
1148 
				continue;
25418 amit.gupta 1149 
			params.put("MANUAL_email", String.join(",", storeGuyEntry.getValue()));
1150 
			InputStreamSource isr3 = reporticoService.getReportInputStreamSource(ReporticoProject.FOCO,
1151 
					"focostockreport.xml", params);
1152 
			Attachment attache = new Attachment(
25609 amit.gupta 1153 
					"Franchise-stock-report" + FormattingUtils.formatDate(LocalDateTime.now()) + ".csv", isr3);
25584 amit.gupta 1154 
			System.out.println(storeGuyEntry.getValue());
25609 amit.gupta 1155 
			Utils.sendMailWithAttachments(googleMailSender, new String[] { storeGuyEntry.getKey() }, null,
1156 
					"Franchise Stock Report", "PFA", attache);
25418 amit.gupta 1157 
		}
25503 amit.gupta 1158 
 
24681 amit.gupta 1159 
	}
24533 govind 1160 
 
28632 amit.gupta 1161 
	public void sendIndentTertiary() throws Exception {
28709 amit.gupta 1162 
 
28632 amit.gupta 1163 
		InputStreamSource isr = reporticoService.getReportInputStreamSource(ReporticoProject.FOCO,
1164 
				"indentandtertiary.xml");
1165 
		Attachment attachment = new Attachment(
28839 tejbeer 1166 
				"indentandtertiary-report-" + FormattingUtils.formatDate(LocalDateTime.now()) + ".csv", isr);
28709 amit.gupta 1167 
		Utils.sendMailWithAttachments(googleMailSender, INDENT_TERTIARY_MAIL_LIST, null, "Indent Tertiary Report",
1168 
				"PFA", attachment);
1169 
 
28632 amit.gupta 1170 
	}
28790 amit.gupta 1171 
 
28769 amit.gupta 1172 
	public void sendAttendanceMorningAlert() throws Exception {
28793 amit.gupta 1173 
		LocalDateTime moriningTime = LocalDate.now().atTime(10, 31);
28775 amit.gupta 1174 
		List<AuthUser> authUsers = authRepository.selectAllActiveUser();
28790 amit.gupta 1175 
		Map<String, AuthUser> authUserEmailMap = authUsers.stream().filter(x -> x.isActive())
1176 
				.collect(Collectors.toMap(x -> x.getEmailId(), x -> x));
1177 
 
28769 amit.gupta 1178 
		List<User> users = dtrUserRepository.selectAllByEmailIds(new ArrayList<>(authUserEmailMap.keySet()));
28790 amit.gupta 1179 
		Map<String, User> userMap = users.stream().collect(Collectors.toMap(x -> x.getEmailId(), x -> x));
1180 
 
1181 
		List<EmployeeAttendance> employeeAttendances = employeeAttendanceRepository
1182 
				.selectAllByDatesBetween(LocalDate.now().atStartOfDay(), LocalDateTime.now());
1183 
 
1184 
		Map<Integer, Optional<EmployeeAttendance>> employeeMorningAttendance = employeeAttendances.stream()
1185 
				.collect(Collectors.groupingBy(EmployeeAttendance::getUserId,
1186 
						Collectors.minBy(Comparator.comparing(EmployeeAttendance::getCreateTimestamp))));
1187 
		for (AuthUser authUser : authUsers) {
28769 amit.gupta 1188 
			User user = userMap.get(authUser.getEmailId());
1189 
			Optional<EmployeeAttendance> employeeAttendanceOptional = employeeMorningAttendance.get(user.getId());
28817 amit.gupta 1190 
			LOGGER.info("AuthUser - {}, employeeAttendanceOptional {}", authUser.getName(), employeeAttendanceOptional);
28839 tejbeer 1191 
			if (employeeAttendanceOptional != null) {
28818 amit.gupta 1192 
				LOGGER.info("employeeAttendanceOptional.orElse {}", employeeAttendanceOptional.orElse(null));
28839 tejbeer 1193 
				if (employeeAttendanceOptional.orElse(null) != null) {
1194 
					LOGGER.info("employeeAttendanceOptional.get().getCreateTimestamp() {}",
1195 
							employeeAttendanceOptional.get().getCreateTimestamp());
28818 amit.gupta 1196 
				}
1197 
			}
28790 amit.gupta 1198 
			if (employeeAttendanceOptional == null || employeeAttendanceOptional.orElse(null) == null
28769 amit.gupta 1199 
					|| employeeAttendanceOptional.get().getCreateTimestamp().isAfter(moriningTime)) {
28819 amit.gupta 1200 
				LOGGER.info("Will Send Email to {}", authUser.getFullName());
28790 amit.gupta 1201 
				String body = String.format(
28806 amit.gupta 1202 
						"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 1203 
						authUser.getFullName(),
1204 
						(employeeAttendanceOptional == null || employeeAttendanceOptional.orElse(null) == null) ? ""
1205 
								: "(Punched at "
1206 
										+ FormattingUtils.format(employeeAttendanceOptional.get().getCreateTimestamp())
1207 
										+ ")");
1208 
 
1209 
				Utils.sendMailWithAttachments(googleMailSender, new String[] { authUser.getEmailId() },
1210 
						new String[] { "jyoti.rawat@smartdukaan.com" }, "Attendance Alert", body);
1211 
 
28769 amit.gupta 1212 
			}
1213 
		}
28790 amit.gupta 1214 
 
28769 amit.gupta 1215 
	}
28790 amit.gupta 1216 
 
28775 amit.gupta 1217 
	public void sendAttendanceEveningAlert() throws Exception {
1218 
		List<AuthUser> authUsers = authRepository.selectAllActiveUser();
28790 amit.gupta 1219 
		Map<String, AuthUser> authUserEmailMap = authUsers.stream().filter(x -> x.isActive())
1220 
				.collect(Collectors.toMap(x -> x.getEmailId(), x -> x));
1221 
 
28775 amit.gupta 1222 
		List<User> users = dtrUserRepository.selectAllByEmailIds(new ArrayList<>(authUserEmailMap.keySet()));
28790 amit.gupta 1223 
		Map<String, User> userMap = users.stream().collect(Collectors.toMap(x -> x.getEmailId(), x -> x));
28775 amit.gupta 1224 
 
28790 amit.gupta 1225 
		Map<Integer, List<EmployeeAttendance>> employeeAttendancesMap = employeeAttendanceRepository
1226 
				.selectAllByDatesBetween(LocalDate.now().atStartOfDay(), LocalDateTime.now()).stream()
1227 
				.collect(Collectors.groupingBy(x -> x.getUserId()));
1228 
 
1229 
		for (AuthUser authUser : authUsers) {
28775 amit.gupta 1230 
			User user = userMap.get(authUser.getEmailId());
28784 amit.gupta 1231 
			String body = null;
1232 
			List<EmployeeAttendance> employeeAttendances = employeeAttendancesMap.get(user.getId());
28790 amit.gupta 1233 
			if (employeeAttendances == null) {
1234 
				body = String.format(
28806 amit.gupta 1235 
						"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 1236 
						authUser.getFullName());
28784 amit.gupta 1237 
			} else {
28790 amit.gupta 1238 
				List<LocalDateTime> punchTimes = employeeAttendances.stream()
1239 
						.sorted(Comparator.comparing(EmployeeAttendance::getCreateTimestamp))
1240 
						.map(x -> x.getCreateTimestamp()).collect(Collectors.toList());
1241 
				if (punchTimes.size() == 1) {
1242 
					// body = String.format("Dear %s,\n Pls note that you haven't punched out yet.
1243 
					// You have been marked absent for half the day. You may contact your manager
1244 
					// and get it regularise.\n\nRegards\nHR Team", authUser.getFullName());
28784 amit.gupta 1245 
				} else {
1246 
					LocalDateTime firstPunch = punchTimes.get(0);
28790 amit.gupta 1247 
					LocalDateTime lastPunch = punchTimes.get(punchTimes.size() - 1);
28805 amit.gupta 1248 
					Duration duration = Duration.between(firstPunch, lastPunch);
28784 amit.gupta 1249 
					boolean hoursCompleted = lastPunch.isAfter(firstPunch.plusHours(8).plusMinutes(30));
28790 amit.gupta 1250 
					if (!hoursCompleted) {
1251 
						body = String.format(
28806 amit.gupta 1252 
								"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 1253 
								authUser.getFullName(), duration.toHours(),
1254 
								duration.toMinutes() - duration.toHours() * 60);
28784 amit.gupta 1255 
					}
1256 
				}
1257 
 
1258 
			}
28790 amit.gupta 1259 
			if (body != null) {
1260 
				Utils.sendMailWithAttachments(googleMailSender, new String[] { authUser.getEmailId() },
1261 
						new String[] { "jyoti.rawat@smartdukaan.com" }, "Attendance Alert", body);
28775 amit.gupta 1262 
			}
1263 
		}
28790 amit.gupta 1264 
 
1265 
		this.sendMailToHR();
1266 
 
28775 amit.gupta 1267 
	}
28790 amit.gupta 1268 
 
1269 
	private void sendMailToHR() throws Exception {
1270 
		Map<String, String> map = new HashMap<>();
1271 
		String reporticoDate = FormattingUtils.formatReporitcoDate(LocalDateTime.now());
1272 
		map.put("MANUAL_datesBetween_FROMDATE", reporticoDate);
1273 
		map.put("MANUAL_datesBetween_FROMDATE", reporticoDate);
1274 
		InputStreamSource isr = reporticoService.getReportInputStreamSource(ReporticoProject.FOCO,
1275 
				"employeeattendance.xml");
1276 
		Attachment attachment = new Attachment("attendance-" + FormattingUtils.formatDate(LocalDateTime.now()) + ".csv",
1277 
				isr);
1278 
		Utils.sendMailWithAttachments(googleMailSender, EMPLOYEE_ATTENDANCE_MAIL_LIST, null,
1279 
				"Attendance - " + FormattingUtils.formatDate(LocalDateTime.now()), "PFA Attendance", attachment);
1280 
	}
1281 
 
28709 amit.gupta 1282 
	public void checkPartnerActiveStore() throws Exception {
1283 
 
1284 
		List<FofoStore> fofoStores = fofoStoreRepository.selectByStatus(true);
1285 
 
1286 
		LocalDateTime currentDate = LocalDate.now().atStartOfDay();
28712 amit.gupta 1287 
		if (!fofoStores.isEmpty()) {
1288 
			for (FofoStore fofoStore : fofoStores) {
28709 amit.gupta 1289 
 
28712 amit.gupta 1290 
				if (currentDate.isBefore(fofoStore.getActiveTimeStamp())) {
28709 amit.gupta 1291 
 
28712 amit.gupta 1292 
					fofoStore.setActive(true);
1293 
					fofoStoreRepository.persist(fofoStore);
1294 
					LOGGER.info("inserted into InActiveFofoStore successfully");
28709 amit.gupta 1295 
 
28712 amit.gupta 1296 
				}
28709 amit.gupta 1297 
 
28712 amit.gupta 1298 
				else {
1299 
					fofoStore.setActive(false);
1300 
					fofoStore.setActiveTimeStamp(null);
1301 
					fofoStoreRepository.persist(fofoStore);
1302 
					LOGGER.info("inserted into InActiveFofoStore successfully");
1303 
				}
28709 amit.gupta 1304 
 
1305 
			}
1306 
		}
1307 
 
1308 
	}
1309 
 
24697 amit.gupta 1310 
	public void sendAgeingReport() throws Exception {
27210 tejbeer 1311 
		sendAgeingReport("kamini.sharma@smartdukaan.com", "amit.babu@smartdukaan.com", "tarun.verma@smartdukaan.com",
28467 tejbeer 1312 
				"niranjan.kala@smartdukaan.com", "manish.gupta@smartdukaan.com", "kuldeep.kumar@smartdukaan.com");
24697 amit.gupta 1313 
	}
1314 
 
24533 govind 1315 
	public void moveImeisToPriceDropImeis() throws Exception {
24431 amit.gupta 1316 
		List<PriceDrop> priceDrops = priceDropRepository.selectAll();
24533 govind 1317 
		for (PriceDrop priceDrop : priceDrops) {
24431 amit.gupta 1318 
			priceDropService.priceDropStatus(priceDrop.getId());
1319 
		}
1320 
	}
23929 amit.gupta 1321 
 
24542 amit.gupta 1322 
	public void walletmismatch() throws Exception {
1323 
		LocalDate curDate = LocalDate.now();
24553 amit.gupta 1324 
		List<PartnerDailyInvestment> pdis = partnerDailyInvestmentRepository.selectAll(curDate.minusDays(2));
24552 amit.gupta 1325 
		System.out.println(pdis.size());
24542 amit.gupta 1326 
		for (PartnerDailyInvestment pdi : pdis) {
24549 amit.gupta 1327 
			int fofoId = pdi.getFofoId();
24542 amit.gupta 1328 
			for (PartnerDailyInvestment investment : Lists
1329 
					.reverse(partnerDailyInvestmentRepository.selectAll(fofoId, null, null))) {
24552 amit.gupta 1330 
				float statementAmount = walletService.getOpeningTill(fofoId,
24555 amit.gupta 1331 
						investment.getDate().plusDays(1).atTime(LocalTime.of(4, 0)));
24552 amit.gupta 1332 
				CustomRetailer retailer = retailerService.getFofoRetailer(fofoId);
24841 govind 1333 
				LOGGER.info("{}\t{}\t{}\t{}\t{}", fofoId, retailer.getBusinessName(), retailer.getMobileNumber(),
1334 
						investment.getDate().toString(), investment.getWalletAmount(), statementAmount);
24551 amit.gupta 1335 
 
24542 amit.gupta 1336 
			}
24549 amit.gupta 1337 
		}
24542 amit.gupta 1338 
 
1339 
	}
29160 amit.gupta 1340 
 
28990 amit.gupta 1341 
	@Autowired
1342 
	StateRepository stateRepository;
24542 amit.gupta 1343 
 
1344 
	public void gst() throws Exception {
28995 amit.gupta 1345 
		List<FofoOrder> fofoOrders = fofoOrderRepository.selectBetweenSaleDate(LocalDate.of(2021, 8, 16).atStartOfDay(),
28990 amit.gupta 1346 
				LocalDateTime.now());
24548 amit.gupta 1347 
		for (FofoOrder fofoOrder : fofoOrders) {
1348 
			int retailerAddressId = retailerRegisteredAddressRepository
1349 
					.selectAddressIdByRetailerId(fofoOrder.getFofoId());
24542 amit.gupta 1350 
 
1351 
			Address retailerAddress = addressRepository.selectById(retailerAddressId);
1352 
			CustomerAddress customerAddress = customerAddressRepository.selectById(fofoOrder.getCustomerAddressId());
1353 
			Integer stateId = null;
1354 
			if (customerAddress.getState().equals(retailerAddress.getState())) {
1355 
				try {
28990 amit.gupta 1356 
					stateId = stateRepository.selectByName(customerAddress.getState()).getId();
24542 amit.gupta 1357 
				} catch (Exception e) {
28990 amit.gupta 1358 
					LOGGER.error("Cannot found state named {}", customerAddress.getState());
1359 
					continue;
24542 amit.gupta 1360 
				}
1361 
			}
1362 
			Map<Integer, GstRate> itemIdStateTaxRateMap = null;
1363 
			Map<Integer, Float> itemIdIgstTaxRateMap = null;
24548 amit.gupta 1364 
 
1365 
			List<FofoOrderItem> fofoOrderItems = fofoOrderItemRepository.selectByOrderId(fofoOrder.getId());
26929 amit.gupta 1366 
			List<Integer> itemIds = fofoOrderItems.stream().map(x -> x.getItemId()).collect(Collectors.toList());
24542 amit.gupta 1367 
			if (stateId != null) {
26929 amit.gupta 1368 
				itemIdStateTaxRateMap = stateGstRateRepository.getStateTaxRate(itemIds, stateId);
24542 amit.gupta 1369 
			} else {
26929 amit.gupta 1370 
				itemIdIgstTaxRateMap = stateGstRateRepository.getIgstTaxRate(itemIds);
24542 amit.gupta 1371 
			}
1372 
 
24548 amit.gupta 1373 
			for (FofoOrderItem foi : fofoOrderItems) {
28990 amit.gupta 1374 
				float sgstRate = foi.getSgstRate();
1375 
				float cgstRate = foi.getCgstRate();
1376 
				float igstRate = foi.getIgstRate();
29160 amit.gupta 1377 
				if (stateId == null && igstRate == 0) {
1378 
 
1379 
					foi.setSgstRate(0);
1380 
					foi.setCgstRate(0);
1381 
					foi.setIgstRate(itemIdIgstTaxRateMap.get(foi.getItemId()));
1382 
 
28993 amit.gupta 1383 
					LOGGER.info("Invoice {}, Date {}", fofoOrder.getInvoiceNumber(), fofoOrder.getCreateTimestamp());
29160 amit.gupta 1384 
					LOGGER.info("customerAddress.getState() {}, retailerAddress.getState() {}",
1385 
							customerAddress.getState(), retailerAddress.getState());
28990 amit.gupta 1386 
					LOGGER.info("Rates getIgstRate() {}", itemIdIgstTaxRateMap.get(foi.getItemId()));
29160 amit.gupta 1387 
 
1388 
				} else if (stateId != null && sgstRate == 0 && cgstRate == 0) {
1389 
 
1390 
					foi.setIgstRate(0);
1391 
					foi.setCgstRate(itemIdStateTaxRateMap.get(foi.getItemId()).getCgstRate());
1392 
					foi.setSgstRate(itemIdStateTaxRateMap.get(foi.getItemId()).getSgstRate());
1393 
 
28993 amit.gupta 1394 
					LOGGER.info("Invoice {}, Date {}", fofoOrder.getInvoiceNumber(), fofoOrder.getCreateTimestamp());
29160 amit.gupta 1395 
					LOGGER.info("customerAddress.getState() {}, retailerAddress.getState() {}",
1396 
							customerAddress.getState(), retailerAddress.getState());
1397 
					LOGGER.info("Rates getCgstRate() {}, getSgstRate() {}",
1398 
							itemIdStateTaxRateMap.get(foi.getItemId()).getCgstRate(),
1399 
							itemIdStateTaxRateMap.get(foi.getItemId()).getSgstRate());
24542 amit.gupta 1400 
				}
1401 
			}
1402 
		}
24548 amit.gupta 1403 
 
24542 amit.gupta 1404 
	}
1405 
 
24580 amit.gupta 1406 
	public void schemewalletmismatch() {
1407 
		LocalDate dateToReconcile = LocalDate.of(2018, 4, 1);
24587 amit.gupta 1408 
		while (dateToReconcile.isBefore(LocalDate.now())) {
24580 amit.gupta 1409 
			reconcileSchemes(dateToReconcile);
24587 amit.gupta 1410 
			// reconcileOrders(dateTime);
1411 
			// reconcileRecharges(dateTime);
24580 amit.gupta 1412 
			dateToReconcile = dateToReconcile.plusDays(1);
1413 
		}
1414 
	}
1415 
 
1416 
	private void reconcileSchemes(LocalDate date) {
1417 
		LocalDateTime startDate = date.atStartOfDay();
1418 
		LocalDateTime endDate = startDate.plusDays(1);
1419 
		List<SchemeInOut> siosCreated = schemeInOutRepository.selectAllByCreateDate(startDate, endDate);
1420 
		List<SchemeInOut> siosRefunded = schemeInOutRepository.selectAllByRefundDate(startDate, endDate);
24587 amit.gupta 1421 
		double totalSchemeDisbursed = siosCreated.stream().mapToDouble(x -> x.getAmount()).sum();
1422 
		double totalSchemeRolledback = siosRefunded.stream().mapToDouble(x -> x.getAmount()).sum();
24580 amit.gupta 1423 
		double netSchemeDisbursed = totalSchemeDisbursed - totalSchemeRolledback;
24587 amit.gupta 1424 
		List<WalletReferenceType> walletReferenceTypes = Arrays.asList(WalletReferenceType.SCHEME_IN,
1425 
				WalletReferenceType.SCHEME_OUT);
1426 
		List<UserWalletHistory> history = userWalletHistoryRepository.selectAllByDateType(startDate, endDate,
1427 
				walletReferenceTypes);
1428 
		double schemeAmountWalletTotal = history.stream().mapToDouble(x -> x.getAmount()).sum();
1429 
		if (Math.abs(netSchemeDisbursed - schemeAmountWalletTotal) > 10d) {
24580 amit.gupta 1430 
			LOGGER.info("Scheme Amount mismatched for Date {}", date);
24587 amit.gupta 1431 
 
1432 
			Map<Integer, Double> inventoryItemSchemeIO = siosCreated.stream().collect(Collectors
1433 
					.groupingBy(x -> x.getInventoryItemId(), Collectors.summingDouble(SchemeInOut::getAmount)));
1434 
 
1435 
			Map<Integer, Double> userSchemeMap = inventoryItemRepository.selectByIds(inventoryItemSchemeIO.keySet())
1436 
					.stream().collect(Collectors.groupingBy(x -> x.getFofoId(),
1437 
							Collectors.summingDouble(x -> inventoryItemSchemeIO.get(x.getId()))));
1438 
 
1439 
			Map<Integer, Double> inventoryItemSchemeIORefunded = siosRefunded.stream().collect(Collectors
1440 
					.groupingBy(x -> x.getInventoryItemId(), Collectors.summingDouble(SchemeInOut::getAmount)));
1441 
 
1442 
			Map<Integer, Double> userSchemeRefundedMap = inventoryItemRepository
1443 
					.selectByIds(inventoryItemSchemeIORefunded.keySet()).stream()
1444 
					.collect(Collectors.groupingBy(x -> x.getFofoId(),
1445 
							Collectors.summingDouble(x -> inventoryItemSchemeIORefunded.get(x.getId()))));
1446 
 
1447 
			Map<Integer, Double> finalUserSchemeAmountMap = new HashMap<>();
26092 amit.gupta 1448 
 
24587 amit.gupta 1449 
			for (Map.Entry<Integer, Double> schemeAmount : userSchemeRefundedMap.entrySet()) {
1450 
				if (!finalUserSchemeAmountMap.containsKey(schemeAmount.getKey())) {
1451 
					finalUserSchemeAmountMap.put(schemeAmount.getKey(), schemeAmount.getValue());
1452 
				} else {
1453 
					finalUserSchemeAmountMap.put(schemeAmount.getKey(),
1454 
							finalUserSchemeAmountMap.get(schemeAmount.getKey()) + schemeAmount.getValue());
1455 
				}
1456 
			}
24590 amit.gupta 1457 
			Map<Integer, Integer> userWalletMap = userWalletRepository
1458 
					.selectByRetailerIds(finalUserSchemeAmountMap.keySet()).stream()
1459 
					.collect(Collectors.toMap(UserWallet::getUserId, UserWallet::getId));
1460 
 
24587 amit.gupta 1461 
			Map<Integer, Double> walletAmountMap = history.stream().collect(Collectors.groupingBy(
1462 
					UserWalletHistory::getWalletId, Collectors.summingDouble((UserWalletHistory::getAmount))));
1463 
			for (Map.Entry<Integer, Double> userAmount : walletAmountMap.entrySet()) {
1464 
				double diff = Math.abs(finalUserSchemeAmountMap.get(userAmount.getKey()) - userAmount.getValue());
1465 
				if (diff > 5) {
1466 
					LOGGER.info("Partner scheme mismatched for Userid {}", userWalletMap.get(userAmount.getKey()));
1467 
				}
1468 
			}
24580 amit.gupta 1469 
		}
24587 amit.gupta 1470 
 
24580 amit.gupta 1471 
	}
24590 amit.gupta 1472 
 
24592 amit.gupta 1473 
	public void dryRunSchemeReco() throws Exception {
24635 amit.gupta 1474 
		Map<Integer, Integer> userWalletMap = userWalletRepository.selectAll().stream()
1475 
				.collect(Collectors.toMap(UserWallet::getUserId, UserWallet::getId));
1476 
 
24592 amit.gupta 1477 
		List<UserWalletHistory> userWalletHistory = new ArrayList<>();
1478 
		List<SchemeInOut> rolledbackSios = new ArrayList<>();
24635 amit.gupta 1479 
		Map<Integer, SchemeType> schemeTypeMap = schemeRepository.selectAll().stream()
1480 
				.collect(Collectors.toMap(Scheme::getId, Scheme::getType));
1481 
		Set<String> serialNumbersConsidered = new HashSet<>();
1482 
 
25096 amit.gupta 1483 
		LocalDateTime startDate = LocalDate.of(2018, 3, 1).atStartOfDay();
24635 amit.gupta 1484 
		LocalDateTime endDate = LocalDate.now().atStartOfDay();
1485 
		List<Purchase> purchases = purchaseRepository.selectAllBetweenPurchaseDate(startDate, endDate);
1486 
 
24683 amit.gupta 1487 
		Map<Integer, String> storeNameMap = fofoStoreRepository.getStoresMap();
24635 amit.gupta 1488 
		purchases.stream().forEach(purchase -> {
1489 
			float amountToRollback = 0;
1490 
			String description = "Adjustment of Duplicate Scheme for Purchase Invoice "
1491 
					+ purchase.getPurchaseReference();
1492 
			Map<Integer, String> inventorySerialNumberMap = inventoryItemRepository.selectByPurchaseId(purchase.getId())
1493 
					.stream().filter(ii -> ii.getSerialNumber() != null)
1494 
					.collect(Collectors.toMap(InventoryItem::getId, InventoryItem::getSerialNumber));
1495 
			if (inventorySerialNumberMap.size() > 0) {
1496 
				for (Map.Entry<Integer, String> inventorySerialNumberEntry : inventorySerialNumberMap.entrySet()) {
1497 
					String serialNumber = inventorySerialNumberEntry.getValue();
1498 
					int inventoryItemId = inventorySerialNumberEntry.getKey();
1499 
					if (serialNumbersConsidered.contains(serialNumber)) {
1500 
						// This will rollback scheme for differenct orders for same serial
1501 
						List<SchemeInOut> sios = schemeInOutRepository
1502 
								.selectByInventoryItemIds(new HashSet<>(Arrays.asList(inventoryItemId))).stream()
1503 
								.filter(x -> x.getRolledBackTimestamp() == null
1504 
										&& schemeTypeMap.get(x.getSchemeId()).equals(SchemeType.IN))
1505 
								.collect(Collectors.toList());
1506 
						Collections.reverse(sios);
1507 
						for (SchemeInOut sio : sios) {
1508 
							sio.setRolledBackTimestamp(LocalDateTime.now());
1509 
							amountToRollback += sio.getAmount();
1510 
							// sio.setSchemeType(SchemeType.OUT);
1511 
							sio.setSerialNumber(serialNumber);
1512 
							rolledbackSios.add(sio);
1513 
						}
1514 
						description = description.concat(" " + serialNumber + " ");
1515 
					} else {
1516 
						serialNumbersConsidered.add(serialNumber);
1517 
						List<Integer> schemesConsidered = new ArrayList<>();
1518 
						List<SchemeInOut> sios = schemeInOutRepository
1519 
								.selectByInventoryItemIds(new HashSet<>(Arrays.asList(inventoryItemId))).stream()
1520 
								.filter(x -> x.getRolledBackTimestamp() == null
1521 
										&& schemeTypeMap.get(x.getSchemeId()).equals(SchemeType.IN))
1522 
								.collect(Collectors.toList());
1523 
						Collections.reverse(sios);
1524 
						for (SchemeInOut sio : sios) {
1525 
							if (!schemesConsidered.contains(sio.getSchemeId())) {
1526 
								schemesConsidered.add(sio.getSchemeId());
1527 
								continue;
1528 
							}
1529 
							sio.setRolledBackTimestamp(LocalDateTime.now());
1530 
							amountToRollback += sio.getAmount();
1531 
							// sio.setSchemeType(SchemeType.OUT);
1532 
							sio.setSerialNumber(serialNumber);
24681 amit.gupta 1533 
							sio.setStoreCode(storeNameMap.get(purchase.getFofoId()));
1534 
							sio.setReference(purchase.getId());
24635 amit.gupta 1535 
							rolledbackSios.add(sio);
1536 
						}
1537 
					}
1538 
 
1539 
				}
1540 
			}
1541 
			if (amountToRollback > 0) {
24683 amit.gupta 1542 
				// Address address =
1543 
				// addressRepository.selectAllByRetailerId(purchase.getFofoId(), 0, 10).get(0);
24635 amit.gupta 1544 
				UserWalletHistory uwh = new UserWalletHistory();
1545 
				uwh.setAmount(Math.round(amountToRollback));
1546 
				uwh.setDescription(description);
1547 
				uwh.setTimestamp(LocalDateTime.now());
24681 amit.gupta 1548 
				uwh.setReferenceType(WalletReferenceType.SCHEME_IN);
24635 amit.gupta 1549 
				uwh.setReference(purchase.getId());
1550 
				uwh.setWalletId(userWalletMap.get(purchase.getFofoId()));
1551 
				uwh.setFofoId(purchase.getFofoId());
24681 amit.gupta 1552 
				uwh.setStoreCode(storeNameMap.get(purchase.getFofoId()));
24635 amit.gupta 1553 
				userWalletHistory.add(uwh);
1554 
			}
1555 
		});
1556 
		ByteArrayOutputStream baos = FileUtil.getCSVByteStream(
1557 
				Arrays.asList("User Id", "Store Code", "Reference Type", "Reference", "Amount", "Description",
1558 
						"Timestamp"),
1559 
				userWalletHistory.stream()
1560 
						.map(x -> Arrays.asList(x.getWalletId(), x.getStoreCode(), x.getReferenceType(),
1561 
								x.getReference(), x.getAmount(), x.getDescription(), x.getTimestamp()))
1562 
						.collect(Collectors.toList()));
1563 
 
1564 
		ByteArrayOutputStream baosOuts = FileUtil.getCSVByteStream(
24683 amit.gupta 1565 
				Arrays.asList("Scheme ID", "SchemeType", "Reference", "Store Code", "Serial Number", "Amount",
1566 
						"Created", "Rolledback"),
24635 amit.gupta 1567 
				rolledbackSios.stream()
24681 amit.gupta 1568 
						.map(x -> Arrays.asList(x.getSchemeId(), x.getSchemeType(), x.getReference(), x.getStoreCode(),
24635 amit.gupta 1569 
								x.getSerialNumber(), x.getAmount(), x.getCreateTimestamp(), x.getRolledBackTimestamp()))
1570 
						.collect(Collectors.toList()));
1571 
 
25043 amit.gupta 1572 
		Utils.sendMailWithAttachments(googleMailSender, new String[] { "amit.gupta@shop2020.in" }, null,
24636 amit.gupta 1573 
				"Partner Excess Amount Scheme In", "PFA",
24635 amit.gupta 1574 
				new Attachment[] { new Attachment("WalletSummary.csv", new ByteArrayResource(baos.toByteArray())),
24636 amit.gupta 1575 
						new Attachment("SchemeInRolledback.csv", new ByteArrayResource(baosOuts.toByteArray())) });
24635 amit.gupta 1576 
 
25096 amit.gupta 1577 
		throw new Exception();
24635 amit.gupta 1578 
 
1579 
	}
1580 
 
1581 
	public void dryRunOutSchemeReco() throws Exception {
1582 
		List<UserWalletHistory> userWalletHistory = new ArrayList<>();
1583 
		List<SchemeInOut> rolledbackSios = new ArrayList<>();
24606 amit.gupta 1584 
		Map<Integer, Integer> userWalletMap = userWalletRepository.selectAll().stream()
1585 
				.collect(Collectors.toMap(UserWallet::getUserId, UserWallet::getId));
24590 amit.gupta 1586 
		Map<Integer, SchemeType> schemeTypeMap = schemeRepository.selectAll().stream()
1587 
				.collect(Collectors.toMap(Scheme::getId, Scheme::getType));
25028 amit.gupta 1588 
		LocalDateTime startDate = LocalDate.of(2019, 5, 1).atStartOfDay();
24632 amit.gupta 1589 
		LocalDateTime endDate = LocalDate.now().atStartOfDay();
24631 amit.gupta 1590 
		List<FofoOrder> allOrders = fofoOrderRepository.selectBetweenSaleDate(startDate, endDate);
1591 
		// Collections.reverse(allOrders);
1592 
		// List<FofoOrder> allOrders =
24653 govind 1593 
		// List<FofoOrder> allOrders =
24631 amit.gupta 1594 
		// Arrays.asList(fofoOrderRepository.selectByInvoiceNumber("UPGZ019/25"));
24625 amit.gupta 1595 
		Set<String> serialNumbersConsidered = new HashSet<>();
24590 amit.gupta 1596 
		allOrders.stream().forEach(fofoOrder -> {
24592 amit.gupta 1597 
			String description = "Adjustment of Duplicate Scheme for Sale Invoice " + fofoOrder.getInvoiceNumber();
24598 amit.gupta 1598 
			Map<Integer, String> inventorySerialNumberMap = new HashMap<>();
24592 amit.gupta 1599 
			float amountToRollback = 0;
24590 amit.gupta 1600 
			List<FofoOrderItem> orderItems = fofoOrderItemRepository.selectByOrderId(fofoOrder.getId());
1601 
			orderItems.forEach(x -> {
24606 amit.gupta 1602 
				inventorySerialNumberMap.putAll(x.getFofoLineItems().stream().filter(li -> li.getSerialNumber() != null)
24598 amit.gupta 1603 
						.collect(Collectors.toMap(FofoLineItem::getInventoryItemId, FofoLineItem::getSerialNumber)));
24590 amit.gupta 1604 
			});
24606 amit.gupta 1605 
			if (inventorySerialNumberMap.size() > 0) {
24631 amit.gupta 1606 
				for (Map.Entry<Integer, String> inventorySerialNumberEntry : inventorySerialNumberMap.entrySet()) {
1607 
					String serialNumber = inventorySerialNumberEntry.getValue();
1608 
					int inventoryItemId = inventorySerialNumberEntry.getKey();
1609 
					if (serialNumbersConsidered.contains(serialNumber)) {
1610 
						// This will rollback scheme for differenct orders for same serial
1611 
						List<SchemeInOut> sios = schemeInOutRepository
24633 amit.gupta 1612 
								.selectByInventoryItemIds(new HashSet<>(Arrays.asList(inventoryItemId))).stream()
24635 amit.gupta 1613 
								.filter(x -> x.getRolledBackTimestamp() == null
1614 
										&& schemeTypeMap.get(x.getSchemeId()).equals(SchemeType.OUT))
24631 amit.gupta 1615 
								.collect(Collectors.toList());
1616 
						Collections.reverse(sios);
1617 
						for (SchemeInOut sio : sios) {
1618 
							sio.setRolledBackTimestamp(LocalDateTime.now());
1619 
							amountToRollback += sio.getAmount();
1620 
							// sio.setSchemeType(SchemeType.OUT);
1621 
							sio.setSerialNumber(serialNumber);
1622 
							sio.setStoreCode(fofoOrder.getInvoiceNumber().split("/")[0]);
24681 amit.gupta 1623 
							sio.setReference(fofoOrder.getId());
24631 amit.gupta 1624 
							rolledbackSios.add(sio);
24623 amit.gupta 1625 
						}
24635 amit.gupta 1626 
						description = description.concat(" " + serialNumber + " ");
24631 amit.gupta 1627 
					} else {
1628 
						serialNumbersConsidered.add(serialNumber);
1629 
						List<Integer> schemesConsidered = new ArrayList<>();
1630 
						List<SchemeInOut> sios = schemeInOutRepository
24633 amit.gupta 1631 
								.selectByInventoryItemIds(new HashSet<>(Arrays.asList(inventoryItemId))).stream()
24635 amit.gupta 1632 
								.filter(x -> x.getRolledBackTimestamp() == null
1633 
										&& schemeTypeMap.get(x.getSchemeId()).equals(SchemeType.OUT))
24631 amit.gupta 1634 
								.collect(Collectors.toList());
1635 
						Collections.reverse(sios);
1636 
						for (SchemeInOut sio : sios) {
1637 
							if (!schemesConsidered.contains(sio.getSchemeId())) {
1638 
								schemesConsidered.add(sio.getSchemeId());
1639 
								continue;
1640 
							}
1641 
							sio.setRolledBackTimestamp(LocalDateTime.now());
1642 
							amountToRollback += sio.getAmount();
1643 
							// sio.setSchemeType(SchemeType.OUT);
24681 amit.gupta 1644 
							sio.setReference(fofoOrder.getId());
24631 amit.gupta 1645 
							sio.setSerialNumber(serialNumber);
1646 
							sio.setStoreCode(fofoOrder.getInvoiceNumber().split("/")[0]);
1647 
							rolledbackSios.add(sio);
1648 
						}
24615 amit.gupta 1649 
					}
24631 amit.gupta 1650 
 
24604 amit.gupta 1651 
				}
24590 amit.gupta 1652 
			}
24631 amit.gupta 1653 
			if (amountToRollback > 0) {
1654 
				UserWalletHistory uwh = new UserWalletHistory();
1655 
				uwh.setAmount(Math.round(amountToRollback));
1656 
				uwh.setDescription(description);
1657 
				uwh.setTimestamp(LocalDateTime.now());
1658 
				uwh.setReferenceType(WalletReferenceType.SCHEME_OUT);
1659 
				uwh.setReference(fofoOrder.getId());
1660 
				uwh.setWalletId(userWalletMap.get(fofoOrder.getFofoId()));
1661 
				uwh.setFofoId(fofoOrder.getFofoId());
1662 
				uwh.setStoreCode(fofoOrder.getInvoiceNumber().split("/")[0]);
1663 
				userWalletHistory.add(uwh);
1664 
			}
24590 amit.gupta 1665 
		});
24598 amit.gupta 1666 
 
24592 amit.gupta 1667 
		ByteArrayOutputStream baos = FileUtil.getCSVByteStream(
24681 amit.gupta 1668 
				Arrays.asList("Wallet Id", "Store Code", "Reference Type", "Reference", "Amount", "Description",
24615 amit.gupta 1669 
						"Timestamp"),
1670 
				userWalletHistory.stream()
1671 
						.map(x -> Arrays.asList(x.getWalletId(), x.getStoreCode(), x.getReferenceType(),
1672 
								x.getReference(), x.getAmount(), x.getDescription(), x.getTimestamp()))
24592 amit.gupta 1673 
						.collect(Collectors.toList()));
1674 
 
1675 
		ByteArrayOutputStream baosOuts = FileUtil.getCSVByteStream(
1676 
				Arrays.asList("Scheme ID", "SchemeType", "Store Code", "Serial Number", "Amount", "Created",
1677 
						"Rolledback"),
1678 
				rolledbackSios.stream()
1679 
						.map(x -> Arrays.asList(x.getSchemeId(), x.getSchemeType(), x.getStoreCode(),
1680 
								x.getSerialNumber(), x.getAmount(), x.getCreateTimestamp(), x.getRolledBackTimestamp()))
1681 
						.collect(Collectors.toList()));
1682 
 
25043 amit.gupta 1683 
		Utils.sendMailWithAttachments(googleMailSender, new String[] { "amit.gupta@shop2020.in" }, null,
24681 amit.gupta 1684 
				"Partner Excess Amount Scheme Out", "PFA",
24598 amit.gupta 1685 
				new Attachment[] { new Attachment("WalletSummary.csv", new ByteArrayResource(baos.toByteArray())),
1686 
						new Attachment("SchemeOutRolledback.csv", new ByteArrayResource(baosOuts.toByteArray())) });
24631 amit.gupta 1687 
 
25267 amit.gupta 1688 
		throw new Exception();
24590 amit.gupta 1689 
	}
24615 amit.gupta 1690 
 
24611 amit.gupta 1691 
	public void dryRunSchemeOutReco1() throws Exception {
24615 amit.gupta 1692 
		List<Integer> references = Arrays.asList(6744, 7347, 8320, 8891, 9124, 9217, 9263, 9379);
24611 amit.gupta 1693 
		List<UserWalletHistory> userWalletHistory = new ArrayList<>();
1694 
		List<SchemeInOut> rolledbackSios = new ArrayList<>();
1695 
		Map<Integer, Integer> userWalletMap = userWalletRepository.selectAll().stream()
1696 
				.collect(Collectors.toMap(UserWallet::getUserId, UserWallet::getId));
1697 
		Map<Integer, SchemeType> schemeTypeMap = schemeRepository.selectAll().stream()
1698 
				.collect(Collectors.toMap(Scheme::getId, Scheme::getType));
1699 
		references.stream().forEach(reference -> {
1700 
			FofoOrder fofoOrder = null;
1701 
			try {
1702 
				fofoOrder = fofoOrderRepository.selectByOrderId(reference);
24615 amit.gupta 1703 
			} catch (Exception e) {
1704 
 
24611 amit.gupta 1705 
			}
1706 
			String description = "Adjustment of Duplicate Scheme for Sale Invoice " + fofoOrder.getInvoiceNumber();
1707 
			Map<Integer, String> inventorySerialNumberMap = new HashMap<>();
1708 
			float amountToRollback = 0;
1709 
			List<FofoOrderItem> orderItems = fofoOrderItemRepository.selectByOrderId(fofoOrder.getId());
1710 
			orderItems.forEach(x -> {
1711 
				inventorySerialNumberMap.putAll(x.getFofoLineItems().stream().filter(li -> li.getSerialNumber() != null)
1712 
						.collect(Collectors.toMap(FofoLineItem::getInventoryItemId, FofoLineItem::getSerialNumber)));
1713 
			});
1714 
			if (inventorySerialNumberMap.size() > 0) {
24615 amit.gupta 1715 
				List<SchemeInOut> sios = schemeInOutRepository
1716 
						.selectByInventoryItemIds(inventorySerialNumberMap.keySet()).stream()
1717 
						.filter(x -> schemeTypeMap.get(x.getSchemeId()).equals(SchemeType.OUT))
24611 amit.gupta 1718 
						.collect(Collectors.toList());
1719 
				LOGGER.info("Found {} duplicate schemeouts for Orderid {}", sios.size(), fofoOrder.getId());
1720 
				UserWalletHistory uwh = new UserWalletHistory();
24615 amit.gupta 1721 
				Map<Integer, List<SchemeInOut>> inventoryIdSouts = sios.stream()
1722 
						.collect(Collectors.groupingBy(SchemeInOut::getInventoryItemId, Collectors.toList()));
24611 amit.gupta 1723 
				for (Map.Entry<Integer, List<SchemeInOut>> inventorySioEntry : inventoryIdSouts.entrySet()) {
1724 
					List<SchemeInOut> outList = inventorySioEntry.getValue();
24615 amit.gupta 1725 
					if (outList.size() > 1) {
1726 
 
24611 amit.gupta 1727 
					}
1728 
				}
1729 
				uwh.setAmount(Math.round(amountToRollback));
1730 
				uwh.setDescription(description);
1731 
				uwh.setTimestamp(LocalDateTime.now());
1732 
				uwh.setReferenceType(WalletReferenceType.SCHEME_OUT);
1733 
				uwh.setReference(fofoOrder.getId());
1734 
				uwh.setWalletId(userWalletMap.get(fofoOrder.getFofoId()));
1735 
				uwh.setFofoId(fofoOrder.getFofoId());
1736 
				uwh.setStoreCode(fofoOrder.getInvoiceNumber().split("/")[0]);
1737 
				userWalletHistory.add(uwh);
1738 
			}
1739 
		});
24615 amit.gupta 1740 
 
24611 amit.gupta 1741 
		ByteArrayOutputStream baos = FileUtil.getCSVByteStream(
1742 
				Arrays.asList("User Id", "Reference Type", "Reference", "Amount", "Description", "Timestamp"),
1743 
				userWalletHistory.stream().map(x -> Arrays.asList(x.getWalletId(), x.getReferenceType(),
1744 
						x.getReference(), x.getAmount(), x.getDescription(), x.getTimestamp()))
24615 amit.gupta 1745 
						.collect(Collectors.toList()));
1746 
 
24611 amit.gupta 1747 
		ByteArrayOutputStream baosOuts = FileUtil.getCSVByteStream(
1748 
				Arrays.asList("Scheme ID", "SchemeType", "Store Code", "Serial Number", "Amount", "Created",
1749 
						"Rolledback"),
1750 
				rolledbackSios.stream()
24615 amit.gupta 1751 
						.map(x -> Arrays.asList(x.getSchemeId(), x.getSchemeType(), x.getStoreCode(),
1752 
								x.getSerialNumber(), x.getAmount(), x.getCreateTimestamp(), x.getRolledBackTimestamp()))
1753 
						.collect(Collectors.toList()));
1754 
 
24623 amit.gupta 1755 
		Utils.sendMailWithAttachments(googleMailSender,
1756 
				new String[] { "amit.gupta@shop2020.in", "neeraj.gupta@smartdukaan.com" }, null,
24611 amit.gupta 1757 
				"Partner Excess Amount", "PFA",
1758 
				new Attachment[] { new Attachment("WalletSummary.csv", new ByteArrayResource(baos.toByteArray())),
1759 
						new Attachment("SchemeOutRolledback.csv", new ByteArrayResource(baosOuts.toByteArray())) });
24631 amit.gupta 1760 
 
24628 amit.gupta 1761 
		throw new Exception();
24615 amit.gupta 1762 
 
24611 amit.gupta 1763 
	}
24615 amit.gupta 1764 
 
26945 amit.gupta 1765 
	public void sendDailySalesNotificationToPartner(Integer fofoIdInt) throws Exception {
25927 amit.gupta 1766 
 
24653 govind 1767 
		LocalDateTime now = LocalDateTime.now();
25837 amit.gupta 1768 
		LocalDateTime from = now.with(LocalTime.MIN);
25925 amit.gupta 1769 
		String timeString = "Today %s";
25927 amit.gupta 1770 
		// Send yesterday's report
27007 amit.gupta 1771 
		/*
1772 
		 * if (now.getHour() < 13) { timeString = "Yesterday %s"; from =
1773 
		 * now.minusDays(1).; now = from.with(LocalTime.MAX);
1774 
		 *
1775 
		 * }
1776 
		 */
24855 amit.gupta 1777 
		List<Integer> fofoIds = null;
25043 amit.gupta 1778 
		if (fofoIdInt == null) {
1779 
			fofoIds = fofoStoreRepository.selectAll().stream().filter(x -> x.isActive()).map(x -> x.getId())
1780 
					.collect(Collectors.toList());
24856 amit.gupta 1781 
		} else {
24855 amit.gupta 1782 
			fofoIds = Arrays.asList(fofoIdInt);
1783 
		}
25912 amit.gupta 1784 
		DateTimeFormatter timeFormatter = DateTimeFormatter.ofPattern("h:m a");
24683 amit.gupta 1785 
 
25865 amit.gupta 1786 
		Map<Integer, Float> partnerPolicyAmountMap = insurancePolicyRepository.selectAmountSumGroupByRetailerId(now,
1787 
				null);
1788 
		Map<Integer, Long> partnerPolicyQtyMap = insurancePolicyRepository.selectQtyGroupByRetailerId(now, null);
26945 amit.gupta 1789 
 
1790 
		Map<Integer, Double> spPartnerOrderValMap = fofoOrderItemRepository.selectSumAmountGroupByRetailer(from, now, 0,
1791 
				true);
1792 
 
1793 
		Map<Integer, Double> spPartner3DaysOrderValMap = fofoOrderItemRepository
1794 
				.selectSumAmountGroupByRetailer(from.minusDays(3), now, 0, true);
26941 amit.gupta 1795 
		Map<Integer, Long> spPartnerOrderQtyMap = fofoOrderItemRepository.selectQtyGroupByRetailer(from, now, 0, true);
1796 
 
26945 amit.gupta 1797 
		Map<Integer, Double> partnerOrderValMap = fofoOrderItemRepository.selectSumAmountGroupByRetailer(from, now, 0,
1798 
				false);
26941 amit.gupta 1799 
		Map<Integer, Long> partnerOrderQtyMap = fofoOrderItemRepository.selectQtyGroupByRetailer(from, now, 0, false);
26945 amit.gupta 1800 
 
25865 amit.gupta 1801 
		Map<Integer, SaleTargetReportModel> saleTargetReportModelMap = new HashMap<>();
1802 
		for (int fofoId : fofoIds) {
1803 
			SaleTargetReportModel model = new SaleTargetReportModel();
25927 amit.gupta 1804 
			model.setInsuranceSale(
1805 
					partnerPolicyAmountMap.containsKey(fofoId) ? partnerPolicyAmountMap.get(fofoId).doubleValue() : 0);
25865 amit.gupta 1806 
			model.setInsruanceQty(partnerPolicyQtyMap.containsKey(fofoId) ? partnerPolicyQtyMap.get(fofoId) : 0);
26941 amit.gupta 1807 
			model.setSmartphoneSale(spPartnerOrderValMap.containsKey(fofoId) ? spPartnerOrderValMap.get(fofoId) : 0);
1808 
			model.setSmartphoneQty(spPartnerOrderQtyMap.containsKey(fofoId) ? spPartnerOrderQtyMap.get(fofoId) : 0);
1809 
			model.setTotalSale(partnerOrderValMap.containsKey(fofoId) ? partnerOrderValMap.get(fofoId) : 0);
1810 
			model.setTotalQty(partnerOrderQtyMap.containsKey(fofoId) ? partnerOrderQtyMap.get(fofoId) : 0);
26945 amit.gupta 1811 
			model.setPast3daysSale(
1812 
					spPartner3DaysOrderValMap.containsKey(fofoId) ? spPartner3DaysOrderValMap.get(fofoId) : 0);
25880 amit.gupta 1813 
			model.setFofoId(fofoId);
25865 amit.gupta 1814 
			saleTargetReportModelMap.put(fofoId, model);
1815 
		}
25880 amit.gupta 1816 
 
26945 amit.gupta 1817 
		Map<Integer, FofoReportingModel> partnerSalesHeadersMap = this.getPartnerIdSalesHeaders();
24653 govind 1818 
		for (Integer fofoId : fofoIds) {
25865 amit.gupta 1819 
			SaleTargetReportModel model = saleTargetReportModelMap.get(fofoId);
25821 amit.gupta 1820 
			SendNotificationModel sendNotificationModel = new SendNotificationModel();
1821 
			sendNotificationModel.setCampaignName("Sales update alert");
25884 tejbeer 1822 
			sendNotificationModel.setTitle("Sale Update");
25927 amit.gupta 1823 
			sendNotificationModel
1824 
					.setMessage(String.format("Smartphones Rs.%.0f, Insurance Rs.%.0f, Total Rs.%.0f till %s.",
1825 
							model.getSmartphoneSale(), model.getInsuranceSale(), model.getTotalSale(),
1826 
							String.format(timeString, now.format(timeFormatter))));
25821 amit.gupta 1827 
			sendNotificationModel.setType("url");
27206 tejbeer 1828 
			sendNotificationModel.setUrl("https://app.smartdukaan.com/pages/home/notifications");
25821 amit.gupta 1829 
			sendNotificationModel.setExpiresat(LocalDateTime.now().plusDays(1));
1830 
			sendNotificationModel.setMessageType(MessageType.notification);
25872 tejbeer 1831 
			int userId = userAccountRepository.selectUserIdByRetailerId(fofoId);
1832 
			sendNotificationModel.setUserIds(Arrays.asList(userId));
25854 amit.gupta 1833 
			notificationService.sendNotification(sendNotificationModel);
24653 govind 1834 
		}
26945 amit.gupta 1835 
		// String saleReport = this.getDailySalesReportHtml(partnerSalesHeadersMap,
1836 
		// saleTargetReportModelMap);
1837 
		String statewiseSaleReport = this.getStateWiseSales(saleTargetReportModelMap, partnerSalesHeadersMap);
27116 amit.gupta 1838 
		String cc[] = { "tarun.verma@smartdukaan.com", "kamini.sharma@smartdukaan.com", "amit.babu@smartdukaan.com",
26945 amit.gupta 1839 
				"niranjan.kala@smartdukaan.com", "up.singh@smartdukaan.com", "sm@smartdukaan.com" };
25837 amit.gupta 1840 
 
25912 amit.gupta 1841 
		String subject = String.format("Sale till %s", String.format(timeString, now.format(timeFormatter)));
26945 amit.gupta 1842 
		// this.sendMailOfHtmlFomat("amit.gupta@smartukaan.com", saleReport, cc,
1843 
		// subject);
1844 
		this.sendMailOfHtmlFormat("amit.gupta@smartdukaan.com", statewiseSaleReport, cc, "Statewise" + subject);
24653 govind 1845 
	}
1846 
 
28377 tejbeer 1847 
	public void checkRazorPayPaymentStatus() throws Exception {
28368 tejbeer 1848 
		List<PendingOrder> pendingOrder = pendingOrderRepository
1849 
				.selectAllByStatus(com.spice.profitmandi.dao.enumuration.transaction.OrderStatus.PENDING);
1850 
 
1851 
		for (PendingOrder po : pendingOrder) {
1852 
			RazorPay razorPay = razorPayRepository.selectByOrdeId(po.getId());
28377 tejbeer 1853 
			List<PendingOrderItem> poItems = pendingOrderItemRepository.selectByOrderId(po.getId());
28368 tejbeer 1854 
 
28369 tejbeer 1855 
			LOGGER.info("razorPay" + razorPay);
1856 
			if (razorPay != null) {
1857 
				List<Payment> payments = razorPaymentService.fetchOrderForPayment(razorPay.getRazorOrderId());
28377 tejbeer 1858 
 
28369 tejbeer 1859 
				if (!payments.isEmpty()) {
28377 tejbeer 1860 
					List<String> statusList = new ArrayList<>();
28369 tejbeer 1861 
					for (Payment payment : payments) {
28368 tejbeer 1862 
 
28377 tejbeer 1863 
						JSONObject jsonObj = new JSONObject(payment.toString());
1864 
 
1865 
						String status = jsonObj.getString("status");
1866 
 
1867 
						statusList.add(status);
1868 
 
28369 tejbeer 1869 
					}
28377 tejbeer 1870 
					LOGGER.info("statusList" + statusList);
28368 tejbeer 1871 
 
28377 tejbeer 1872 
					if (statusList.contains("authorized") || statusList.contains("captured")) {
1873 
						po.setStatus(com.spice.profitmandi.dao.enumuration.transaction.OrderStatus.PROCESSING);
1874 
						po.setPaidAmount(po.getTotalAmount());
1875 
						for (PendingOrderItem poi : poItems) {
1876 
							poi.setStatus(com.spice.profitmandi.dao.enumuration.transaction.OrderStatus.PROCESSING);
1877 
						}
1878 
						Map<String, Object> emailModel = pendingOrderService.sendCreateOrderMail(po);
1879 
 
1880 
						CustomRetailer customRetailer = retailerService.getFofoRetailer(po.getFofoId());
1881 
						Customer customer = customerRepository.selectById(po.getCustomerId());
1882 
						String[] customerEmail = null;
1883 
						if (customer.getEmailId() != null) {
1884 
							customerEmail = new String[] { customer.getEmailId() };
1885 
						}
1886 
						List<String> bccTo = Arrays.asList("kamini.sharma@smartdukaan.com",
28467 tejbeer 1887 
								"tarun.verma@smartdukaan.com", "niranjan.kala@smartdukaan.com", "sm@smartdukaan.com",
1888 
								"tejbeer.kaur@shop2020.in", customRetailer.getEmail());
28377 tejbeer 1889 
						List<String> authUserEmails = csService.getAuthUserByPartnerId(customRetailer.getPartnerId());
1890 
						if (authUserEmails != null) {
1891 
							authUserEmails = new ArrayList<>();
1892 
						}
1893 
						authUserEmails.addAll(bccTo);
1894 
 
28382 tejbeer 1895 
						// emailService.sendMailWithAttachments("Order Created with SmartDukaan",
1896 
						// "order-confirm.vm",
1897 
						// emailModel, customerEmail, null, authUserEmails.toArray(new String[0]));
28377 tejbeer 1898 
 
1899 
					} else if (statusList.contains("refunded") || statusList.contains("failed")) {
1900 
						for (PendingOrderItem poi : poItems) {
1901 
							poi.setStatus(com.spice.profitmandi.dao.enumuration.transaction.OrderStatus.FAILED);
1902 
						}
1903 
 
1904 
						po.setStatus(com.spice.profitmandi.dao.enumuration.transaction.OrderStatus.FAILED);
1905 
					}
1906 
 
28369 tejbeer 1907 
				}
28377 tejbeer 1908 
				// LOGGER.info("payment" + payments);
28369 tejbeer 1909 
 
1910 
			}
28368 tejbeer 1911 
		}
1912 
	}
1913 
 
25865 amit.gupta 1914 
	public static class SaleTargetReportModel {
1915 
		private double totalSale;
26941 amit.gupta 1916 
		private long totalQty;
26945 amit.gupta 1917 
		private double past3daysSale;
25880 amit.gupta 1918 
		private int fofoId;
1919 
 
1920 
		public int getFofoId() {
1921 
			return fofoId;
1922 
		}
1923 
 
1924 
		public void setFofoId(int fofoId) {
1925 
			this.fofoId = fofoId;
1926 
		}
1927 
 
25865 amit.gupta 1928 
		private double smartphoneSale;
1929 
		private long smartphoneQty;
1930 
		private double insuranceSale;
1931 
		private long insruanceQty;
1932 
 
26941 amit.gupta 1933 
		public long getTotalQty() {
1934 
			return totalQty;
1935 
		}
1936 
 
1937 
		public void setTotalQty(long totalQty) {
1938 
			this.totalQty = totalQty;
1939 
		}
1940 
 
26945 amit.gupta 1941 
		public double getPast3daysSale() {
1942 
			return past3daysSale;
1943 
		}
1944 
 
1945 
		public void setPast3daysSale(double past3daysSale) {
1946 
			this.past3daysSale = past3daysSale;
1947 
		}
1948 
 
25865 amit.gupta 1949 
		@Override
1950 
		public int hashCode() {
1951 
			final int prime = 31;
1952 
			int result = 1;
25880 amit.gupta 1953 
			result = prime * result + fofoId;
25865 amit.gupta 1954 
			result = prime * result + (int) (insruanceQty ^ (insruanceQty >>> 32));
1955 
			long temp;
1956 
			temp = Double.doubleToLongBits(insuranceSale);
1957 
			result = prime * result + (int) (temp ^ (temp >>> 32));
1958 
			result = prime * result + (int) (smartphoneQty ^ (smartphoneQty >>> 32));
1959 
			temp = Double.doubleToLongBits(smartphoneSale);
1960 
			result = prime * result + (int) (temp ^ (temp >>> 32));
26941 amit.gupta 1961 
			result = prime * result + (int) (totalQty ^ (totalQty >>> 32));
25865 amit.gupta 1962 
			temp = Double.doubleToLongBits(totalSale);
1963 
			result = prime * result + (int) (temp ^ (temp >>> 32));
1964 
			return result;
1965 
		}
1966 
 
1967 
		@Override
1968 
		public boolean equals(Object obj) {
1969 
			if (this == obj)
1970 
				return true;
1971 
			if (obj == null)
1972 
				return false;
1973 
			if (getClass() != obj.getClass())
1974 
				return false;
1975 
			SaleTargetReportModel other = (SaleTargetReportModel) obj;
25880 amit.gupta 1976 
			if (fofoId != other.fofoId)
1977 
				return false;
25865 amit.gupta 1978 
			if (insruanceQty != other.insruanceQty)
1979 
				return false;
1980 
			if (Double.doubleToLongBits(insuranceSale) != Double.doubleToLongBits(other.insuranceSale))
1981 
				return false;
1982 
			if (smartphoneQty != other.smartphoneQty)
1983 
				return false;
1984 
			if (Double.doubleToLongBits(smartphoneSale) != Double.doubleToLongBits(other.smartphoneSale))
1985 
				return false;
26941 amit.gupta 1986 
			if (totalQty != other.totalQty)
1987 
				return false;
25865 amit.gupta 1988 
			if (Double.doubleToLongBits(totalSale) != Double.doubleToLongBits(other.totalSale))
1989 
				return false;
1990 
			return true;
1991 
		}
1992 
 
1993 
		public double getTotalSale() {
1994 
			return totalSale;
1995 
		}
1996 
 
1997 
		public void setTotalSale(double totalSale) {
1998 
			this.totalSale = totalSale;
1999 
		}
2000 
 
2001 
		public double getSmartphoneSale() {
2002 
			return smartphoneSale;
2003 
		}
2004 
 
2005 
		public void setSmartphoneSale(double smartphoneSale) {
2006 
			this.smartphoneSale = smartphoneSale;
2007 
		}
2008 
 
2009 
		public long getSmartphoneQty() {
2010 
			return smartphoneQty;
2011 
		}
2012 
 
2013 
		public void setSmartphoneQty(long smartphoneQty) {
2014 
			this.smartphoneQty = smartphoneQty;
2015 
		}
2016 
 
2017 
		public double getInsuranceSale() {
2018 
			return insuranceSale;
2019 
		}
2020 
 
2021 
		public void setInsuranceSale(double insuranceSale) {
2022 
			this.insuranceSale = insuranceSale;
2023 
		}
2024 
 
2025 
		public long getInsruanceQty() {
2026 
			return insruanceQty;
2027 
		}
2028 
 
2029 
		public void setInsruanceQty(long insruanceQty) {
2030 
			this.insruanceQty = insruanceQty;
2031 
		}
2032 
 
2033 
		@Override
2034 
		public String toString() {
26945 amit.gupta 2035 
			return "SaleTargetReportModel [totalSale=" + totalSale + ", totalQty=" + totalQty + ", past3daysSale="
2036 
					+ past3daysSale + ", fofoId=" + fofoId + ", smartphoneSale=" + smartphoneSale + ", smartphoneQty="
2037 
					+ smartphoneQty + ", insuranceSale=" + insuranceSale + ", insruanceQty=" + insruanceQty + "]";
25865 amit.gupta 2038 
		}
2039 
 
2040 
	}
2041 
 
26945 amit.gupta 2042 
	private String getStateWiseSales(Map<Integer, SaleTargetReportModel> saleTargetReportModelMap,
2043 
			Map<Integer, FofoReportingModel> partnerSalesHeadersMap) throws Exception {
26940 amit.gupta 2044 
		List<FofoStore> stores = fofoStoreRepository.selectActiveStores();
26945 amit.gupta 2045 
		Map<String, List<Integer>> stateMap = stores.stream().collect(Collectors
2046 
				.groupingBy(x -> x.getCode().substring(0, 2), Collectors.mapping(x -> x.getId(), Collectors.toList())));
26940 amit.gupta 2047 
		List<List<Serializable>> stateWiseSales = new ArrayList<>();
2048 
		for (Map.Entry<String, List<Integer>> stateMapEntry : stateMap.entrySet()) {
26945 amit.gupta 2049 
			long totalQty = stateMapEntry.getValue().stream()
2050 
					.collect(Collectors.summingLong(x -> saleTargetReportModelMap.get(x).getTotalQty()));
2051 
			double totalSale = stateMapEntry.getValue().stream()
2052 
					.collect(Collectors.summingDouble(x -> saleTargetReportModelMap.get(x).getTotalSale()));
2053 
			long smartPhoneQty = stateMapEntry.getValue().stream()
2054 
					.collect(Collectors.summingLong(x -> saleTargetReportModelMap.get(x).getSmartphoneQty()));
2055 
			double smartPhoneSale = stateMapEntry.getValue().stream()
2056 
					.collect(Collectors.summingDouble(x -> saleTargetReportModelMap.get(x).getSmartphoneSale()));
2057 
			stateWiseSales
2058 
					.add(Arrays.asList(stateMapEntry.getKey(), smartPhoneQty, smartPhoneSale, totalQty, totalSale));
26940 amit.gupta 2059 
		}
2060 
		StringBuilder sb = new StringBuilder();
26945 amit.gupta 2061 
		sb.append("<html><body>");
2062 
		sb.append("<p>Statewise Sale Report:</p><br/><table style='border:1px solid black';cellspacing=0>");
26940 amit.gupta 2063 
		sb.append("<tbody>\n" + "	    <tr>"
2064 
				+ "	    					<th style='border:1px solid black;padding: 5px'>State</th>"
26941 amit.gupta 2065 
				+ "	    					<th style='border:1px solid black;padding: 5px'>SmartPhone Qty</th>"
2066 
				+ "	    					<th style='border:1px solid black;padding: 5px'>SmartPhone Value</th>"
2067 
				+ "	    					<th style='border:1px solid black;padding: 5px'>Total Qty</th>"
2068 
				+ "	    					<th style='border:1px solid black;padding: 5px'>Total Value</th>"
26940 amit.gupta 2069 
				+ "	    				</tr>");
2070 
		for (List<Serializable> stateSale : stateWiseSales) {
2071 
			sb.append("<tr>");
2072 
			sb.append("<td style='border:1px solid black;padding: 5px'>" + stateSale.get(0) + "</td>");
2073 
			sb.append("<td style='border:1px solid black;padding: 5px'>" + stateSale.get(1) + "</td>");
2074 
			sb.append("<td style='border:1px solid black;padding: 5px'>" + stateSale.get(2) + "</td>");
26941 amit.gupta 2075 
			sb.append("<td style='border:1px solid black;padding: 5px'>" + stateSale.get(3) + "</td>");
2076 
			sb.append("<td style='border:1px solid black;padding: 5px'>" + stateSale.get(4) + "</td>");
26940 amit.gupta 2077 
			sb.append("</tr>");
2078 
		}
26945 amit.gupta 2079 
		sb.append("</tbody></table><br><br>");
25872 tejbeer 2080 
 
26945 amit.gupta 2081 
		sb.append("<p>Sale Report:</p><br/><table style='border:1px solid black';cellspacing=0>");
24653 govind 2082 
		sb.append("<tbody>\n" + "	    				<tr>\n"
26945 amit.gupta 2083 
				+ "	    					<th style='border:1px solid black;padding: 5px'>Code</th>"
2084 
				+ "	    					<th style='border:1px solid black;padding: 5px'>Business Name</th>"
2085 
				+ "	    					<th style='border:1px solid black;padding: 5px'>Regional Manager</th>"
2086 
				+ "	    					<th style='border:1px solid black;padding: 5px'>Territory Manager</th>"
2087 
				+ "	    					<th style='border:1px solid black;padding: 5px'>Sale</th>"
2088 
				+ "	    					<th style='border:1px solid black;padding: 5px'>Smartphone Sale</th>"
2089 
				+ "	    					<th style='border:1px solid black;padding: 5px'>SmartPhone Qty</th>"
24653 govind 2090 
				+ "	    				</tr>");
26945 amit.gupta 2091 
 
2092 
		List<Integer> sortedPartnerSalesHeaders = partnerSalesHeadersMap.values().stream()
26947 amit.gupta 2093 
				.sorted(Comparator.comparing(FofoReportingModel::getCode)
2094 
						.thenComparing(FofoReportingModel::getRegionalManager)
26948 amit.gupta 2095 
						.thenComparing(FofoReportingModel::getTerritoryManager))
26945 amit.gupta 2096 
				.map(FofoReportingModel::getFofoId).collect(Collectors.toList());
25927 amit.gupta 2097 
		for (Integer fofoId : sortedPartnerSalesHeaders) {
27007 amit.gupta 2098 
			if (saleTargetReportModelMap.get(fofoId).getPast3daysSale() == 0) {
26947 amit.gupta 2099 
				sb.append("<tr style='background-color:red'>");
2100 
			} else {
26945 amit.gupta 2101 
				sb.append("<tr>");
2102 
			}
2103 
			sb.append("<td style='border:1px solid black;padding: 5px'>" + partnerSalesHeadersMap.get(fofoId).getCode()
25880 amit.gupta 2104 
					+ "</td>");
2105 
			sb.append("<td style='border:1px solid black;padding: 5px'>"
27007 amit.gupta 2106 
					+ partnerSalesHeadersMap.get(fofoId).getBusinessName() + "</td>");
2107 
			sb.append("<td style='border:1px solid black;padding: 5px'>"
2108 
					+ partnerSalesHeadersMap.get(fofoId).getRegionalManager() + "</td>");
2109 
			sb.append("<td style='border:1px solid black;padding: 5px'>"
2110 
					+ partnerSalesHeadersMap.get(fofoId).getTerritoryManager() + "</td>");
2111 
			sb.append("<td style='border:1px solid black;padding: 5px'>"
26945 amit.gupta 2112 
					+ saleTargetReportModelMap.get(fofoId).getTotalSale() + "</td>");
25880 amit.gupta 2113 
			sb.append("<td style='border:1px solid black;padding: 5px'>"
26945 amit.gupta 2114 
					+ saleTargetReportModelMap.get(fofoId).getSmartphoneSale() + "</td>");
25880 amit.gupta 2115 
			sb.append("<td style='border:1px solid black;padding: 5px'>"
26945 amit.gupta 2116 
					+ saleTargetReportModelMap.get(fofoId).getSmartphoneQty() + "</td>");
25865 amit.gupta 2117 
			sb.append("</tr>");
24653 govind 2118 
		}
24683 amit.gupta 2119 
 
26945 amit.gupta 2120 
		sb.append("</tr>");
2121 
 
2122 
		sb.append("</body></html>");
2123 
 
2124 
		return sb.toString();
24653 govind 2125 
	}
24841 govind 2126 
 
26945 amit.gupta 2127 
	private void sendMailOfHtmlFormat(String email, String body, String cc[], String subject)
24841 govind 2128 
			throws MessagingException, ProfitMandiBusinessException, IOException {
2129 
		MimeMessage message = mailSender.createMimeMessage();
2130 
		MimeMessageHelper helper = new MimeMessageHelper(message);
2131 
		helper.setSubject(subject);
2132 
		helper.setText(body, true);
2133 
		helper.setTo(email);
2134 
		if (cc != null) {
2135 
			helper.setCc(cc);
2136 
		}
2137 
		InternetAddress senderAddress = new InternetAddress("noreply@smartdukaan.com", "Smart Dukaan");
2138 
		helper.setFrom(senderAddress);
2139 
		mailSender.send(message);
2140 
	}
25300 tejbeer 2141 
 
25351 tejbeer 2142 
	public void sendNotification() throws Exception {
25300 tejbeer 2143 
		List<PushNotifications> pushNotifications = pushNotificationRepository.selectAllByTimestamp();
2144 
		if (!pushNotifications.isEmpty()) {
2145 
			for (PushNotifications pushNotification : pushNotifications) {
25351 tejbeer 2146 
				Device device = deviceRepository.selectById(pushNotification.getDeviceId());
25300 tejbeer 2147 
				NotificationCampaign notificationCampaign = notificationCampaignRepository
2148 
						.selectById(pushNotification.getNotificationCampaignid());
2149 
				SimpleCampaignParams scp = gson.fromJson(notificationCampaign.getImplementationParams(),
2150 
						SimpleCampaignParams.class);
2151 
				Campaign campaign = new SimpleCampaign(scp);
25351 tejbeer 2152 
				String result_url = campaign.getUrl() + "&user_id=" + device.getUser_id();
25300 tejbeer 2153 
				JSONObject json = new JSONObject();
25351 tejbeer 2154 
				json.put("to", device.getFcmId());
25300 tejbeer 2155 
				JSONObject jsonObj = new JSONObject();
2156 
				jsonObj.put("message", campaign.getMessage());
2157 
				jsonObj.put("title", campaign.getTitle());
2158 
				jsonObj.put("type", campaign.getType());
2159 
				jsonObj.put("url", result_url);
2160 
				jsonObj.put("time_to_live", campaign.getExpireTimestamp());
2161 
				jsonObj.put("image", campaign.getImageUrl());
2162 
				jsonObj.put("largeIcon", "large_icon");
2163 
				jsonObj.put("smallIcon", "small_icon");
2164 
				jsonObj.put("vibrate", 1);
2165 
				jsonObj.put("pid", pushNotification.getId());
2166 
				jsonObj.put("sound", 1);
2167 
				jsonObj.put("priority", "high");
2168 
				json.put("data", jsonObj);
25351 tejbeer 2169 
				try {
2170 
					CloseableHttpClient client = HttpClients.createDefault();
2171 
					HttpPost httpPost = new HttpPost(FCM_URL);
25300 tejbeer 2172 
 
25351 tejbeer 2173 
					httpPost.setHeader("Content-Type", "application/json; utf-8");
2174 
					httpPost.setHeader("authorization", "key=" + FCM_API_KEY);
2175 
					StringEntity entity = new StringEntity(json.toString());
2176 
					httpPost.setEntity(entity);
2177 
					CloseableHttpResponse response = client.execute(httpPost);
25300 tejbeer 2178 
 
25351 tejbeer 2179 
					if (response.getStatusLine().getStatusCode() == 200) {
2180 
						pushNotification.setSentTimestamp(LocalDateTime.now());
2181 
					} else {
25356 tejbeer 2182 
						pushNotification.setSentTimestamp(LocalDateTime.of(1970, 1, 1, 00, 00));
25778 amit.gupta 2183 
						LOGGER.info("message" + "not sent");
26945 amit.gupta 2184 
						response.toString();
25351 tejbeer 2185 
					}
25300 tejbeer 2186 
 
25351 tejbeer 2187 
				} catch (Exception e) {
2188 
					e.printStackTrace();
26443 amit.gupta 2189 
					pushNotification.setSentTimestamp(LocalDateTime.of(1970, 1, 1, 00, 00));
26436 amit.gupta 2190 
					LOGGER.info("message " + "not sent " + e.getMessage());
25300 tejbeer 2191 
				}
2192 
			}
2193 
		}
2194 
	}
2195 
 
25553 amit.gupta 2196 
	public void grouping() throws Exception {
25609 amit.gupta 2197 
		DateTimeFormatter dtf = DateTimeFormatter.ofPattern("MM-dd-yyyy hh:mm");
2198 
		List<PriceDropIMEI> priceDropImeis = priceDropIMEIRepository.selectByStatus(PriceDropImeiStatus.APPROVED);
2199 
		System.out.println(String.join("\t",
2200 
				Arrays.asList("IMEI", "ItemId", "Brand", "Model Name", "Model Number", "Franchise Id", "Franchise Name",
25694 amit.gupta 2201 
						"Grn On", "Price Dropped On", "Approved On", "Returned On", "Price Drop Paid", "Is Doa")));
26963 amit.gupta 2202 
		Map<Integer, CustomRetailer> retailersMap = retailerService.getFofoRetailers(false);
25609 amit.gupta 2203 
		for (PriceDropIMEI priceDropIMEI : priceDropImeis) {
25694 amit.gupta 2204 
			if (priceDropIMEI.getPartnerId() == 0)
2205 
				continue;
25609 amit.gupta 2206 
			HashSet<String> imeis = new HashSet<>();
2207 
			PriceDrop priceDrop = priceDropRepository.selectById(priceDropIMEI.getPriceDropId());
2208 
			imeis.add(priceDropIMEI.getImei());
2209 
			List<InventoryItem> inventoryItems = inventoryItemRepository
2210 
					.selectByFofoIdSerialNumbers(priceDropIMEI.getPartnerId(), imeis, false);
25694 amit.gupta 2211 
			if (inventoryItems.size() == 0) {
2212 
				LOGGER.info("Need to investigate partnerId - {} imeis - {}", priceDropIMEI.getPartnerId(), imeis);
25613 amit.gupta 2213 
				continue;
25612 amit.gupta 2214 
			}
25609 amit.gupta 2215 
			InventoryItem inventoryItem = inventoryItems.get(0);
2216 
			CustomRetailer customRetailer = retailersMap.get(inventoryItem.getFofoId());
2217 
			if (inventoryItem.getLastScanType().equals(ScanType.DOA_OUT)
2218 
					|| inventoryItem.getLastScanType().equals(ScanType.PURCHASE_RET)) {
2219 
				// check if pricedrop has been rolled out
2220 
				List<UserWalletHistory> uwh = walletService.getAllByReference(inventoryItem.getFofoId(),
2221 
						priceDropIMEI.getPriceDropId(), WalletReferenceType.PRICE_DROP);
2222 
				if (uwh.size() > 0) {
25615 amit.gupta 2223 
					Item item = itemRepository.selectById(inventoryItem.getItemId());
26945 amit.gupta 2224 
					System.out.println(String.join("\t", Arrays.asList(priceDropIMEI.getImei(),
2225 
							inventoryItem.getItemId() + "", item.getBrand(), item.getModelName(), item.getModelNumber(),
2226 
							inventoryItem.getFofoId() + "", customRetailer.getBusinessName(),
2227 
							inventoryItem.getCreateTimestamp().format(dtf), priceDrop.getAffectedOn().format(dtf),
2228 
							priceDropIMEI.getUpdateTimestamp().format(dtf),
2229 
							inventoryItem.getUpdateTimestamp().format(dtf), priceDrop.getAutoPartnerPayout() + "",
2230 
							inventoryItem.getLastScanType().equals(ScanType.DOA_OUT) + "")));
25609 amit.gupta 2231 
				}
2232 
			}
2233 
		}
25503 amit.gupta 2234 
	}
25694 amit.gupta 2235 
 
27686 amit.gupta 2236 
	public void attachToffeeInvoices() throws Exception {
28205 tejbeer 2237 
		/*
2238 
		 * LOGGER.info("Insurance Sum Summary --- {}",
2239 
		 * insurancePolicyRepository.selectAmountSumGroupByRetailerId(LocalDateTime.MIN,
2240 
		 * LocalDateTime.MAX)); LOGGER.info("Insurance Qty Summary --- {}",
2241 
		 * insurancePolicyRepository.selectQtyGroupByRetailerId(LocalDateTime.MIN,
2242 
		 * LocalDateTime.MAX)); LOGGER.info("SmartPhone Amount Summary --- {}",
2243 
		 * fofoOrderItemRepository.selectSumAmountGroupByRetailer(LocalDateTime.MIN,
2244 
		 * LocalDateTime.MAX, 0, true)); LOGGER.info("Smartphone Qty Summary --- {}",
2245 
		 * fofoOrderItemRepository.selectQtyGroupByRetailer(LocalDateTime.MIN,
2246 
		 * LocalDateTime.MAX, 0, true));
2247 
		 */
2248 
		List<InsurancePolicy> insurancePolicies = insurancePolicyRepository.selectAllByProviderId(3,
2249 
				Optional.of(false));
2250 
		for (InsurancePolicy insurancePolicy : insurancePolicies) {
27678 amit.gupta 2251 
			String invoiceNumber = insurancePolicy.getInvoiceNumber();
2252 
			FofoOrder fofoOrder = fofoOrderRepository.selectByInvoiceNumber(invoiceNumber);
2253 
			PdfModel pdfModel = orderService.getInvoicePdfModel(fofoOrder.getId());
2254 
			java.io.ByteArrayOutputStream byteArrayOutputStream = new java.io.ByteArrayOutputStream();
2255 
			PdfUtils.generateAndWrite(Arrays.asList(pdfModel), byteArrayOutputStream);
28205 tejbeer 2256 
			String pdfInvoiceString = "data:application/pdf;base64,"
2257 
					+ Base64.getEncoder().encodeToString(byteArrayOutputStream.toByteArray());
2258 
			boolean attached = toffeeService.attachInvoice(insurancePolicy.getPolicyNumber().split("#")[1],
2259 
					pdfInvoiceString);
2260 
			if (attached) {
27678 amit.gupta 2261 
				insurancePolicy.setPosted(true);
2262 
			}
2263 
		}
25694 amit.gupta 2264 
	}
2265 
 
2266 
	public void schemeRollback(List<String> schemeIds) throws Exception {
2267 
		List<Integer> schemeIdsInt = schemeIds.stream().map(x -> Integer.parseInt(x)).collect(Collectors.toList());
25708 amit.gupta 2268 
		Map<Integer, Scheme> schemesMap = schemeRepository.selectBySchemeIds(schemeIdsInt, 0, schemeIds.size()).stream()
25694 amit.gupta 2269 
				.collect(Collectors.toMap(x -> x.getId(), x -> x));
2270 
		List<SchemeInOut> schemeInOuts = schemeInOutRepository.selectBySchemeIds(new HashSet<>(schemeIdsInt));
2271 
		for (SchemeInOut sio : schemeInOuts) {
2272 
			Scheme scheme = schemesMap.get(sio.getSchemeId());
2273 
			if (scheme.getType().equals(SchemeType.IN)) {
2274 
 
2275 
			} else if (scheme.getType().equals(SchemeType.OUT)) {
2276 
				InventoryItem inventoryItem = inventoryItemRepository.selectById(sio.getInventoryItemId());
2277 
				List<ScanRecord> sr = scanRecordRepository.selectByInventoryItemId(sio.getInventoryItemId());
2278 
				ScanRecord scanRecord = sr.stream().filter(x -> x.getType().equals(ScanType.SALE))
2279 
						.max((x1, x2) -> x1.getCreateTimestamp().compareTo(x2.getCreateTimestamp())).get();
2280 
				if (scanRecord.getCreateTimestamp().isAfter(scheme.getEndDateTime())
2281 
						|| scanRecord.getCreateTimestamp().isBefore(scheme.getStartDateTime())) {
2282 
					sio.setRolledBackTimestamp(LocalDateTime.now());
2283 
					FofoOrder fofoOrder = fofoOrderRepository.selectByOrderId(scanRecord.getOrderId());
25709 amit.gupta 2284 
					String rollbackReason = "Scheme reversed for "
2285 
							+ itemRepository.selectById(inventoryItem.getItemId()).getItemDescription() + "/Inv - "
25694 amit.gupta 2286 
							+ fofoOrder.getInvoiceNumber();
2287 
					walletService.rollbackAmountFromWallet(scanRecord.getFofoId(), sio.getAmount(),
26945 amit.gupta 2288 
							scanRecord.getOrderId(), WalletReferenceType.SCHEME_OUT, rollbackReason,
2289 
							LocalDateTime.now());
25694 amit.gupta 2290 
					System.out.printf("Amount %f,SchemeId %d,Reason %s\n", sio.getAmount(), sio.getSchemeId(),
2291 
							rollbackReason);
2292 
				}
2293 
			}
2294 
		}
25721 tejbeer 2295 
		// throw new Exception();
25694 amit.gupta 2296 
	}
25721 tejbeer 2297 
 
2298 
	public void checkfocusedModelInPartnerStock() throws Exception {
2299 
 
2300 
		List<Integer> fofoIds = fofoStoreRepository.selectAll().stream().filter(x -> x.isActive()).map(x -> x.getId())
2301 
				.collect(Collectors.toList());
27212 tejbeer 2302 
		Map<Integer, Map<Integer, List<SaholicCIS>>> warehouseItemAvailabilityMap = saholicInventoryService
2303 
				.getSaholicStock();
27213 tejbeer 2304 
		Map<Integer, String> warehouseMap = ProfitMandiConstants.WAREHOUSE_MAP;
2305 
		Map<Integer, FofoReportingModel> partnerIdSalesHeadersMap = this.getPartnerIdSalesHeaders();
27212 tejbeer 2306 
 
2307 
		Map<Integer, Map<Integer, List<SaholicPOItem>>> warehousePoItemAvailabilityMap = saholicInventoryService
2308 
				.getSaholicPOItems();
25721 tejbeer 2309 
		Map<Integer, List<FocusedModelShortageModel>> focusedModelShortageReportMap = new HashMap<>();
2310 
		for (Integer fofoId : fofoIds) {
27102 amit.gupta 2311 
			List<FocusedModelShortageModel> focusedModelShortageList = new ArrayList<>();
2312 
			focusedModelShortageReportMap.put(fofoId, focusedModelShortageList);
25721 tejbeer 2313 
			CustomRetailer customRetailer = retailerService.getFofoRetailer(fofoId);
2314 
			Map<Integer, Integer> processingOrderMap = null;
2315 
			Map<Integer, Integer> catalogIdAndQtyMap = null;
2316 
			Map<Integer, Integer> grnPendingOrdersMap = null;
2317 
 
2318 
			Map<Integer, Integer> currentInventorySnapshot = currentInventorySnapshotRepository.selectByFofoId(fofoId)
2319 
					.stream().collect(Collectors.toMap(x -> x.getItemId(), x -> x.getAvailability()));
2320 
 
2321 
			if (!currentInventorySnapshot.isEmpty()) {
2322 
				catalogIdAndQtyMap = itemRepository.selectByIds(currentInventorySnapshot.keySet()).stream()
2323 
						.collect(Collectors.groupingBy(x -> x.getCatalogItemId(),
2324 
								Collectors.summingInt(x -> currentInventorySnapshot.get(x.getId()))));
2325 
 
2326 
			}
2327 
 
2328 
			Map<Integer, Integer> grnPendingOrders = orderRepository.selectPendingGrnOrders(fofoId).stream()
2329 
					.collect(Collectors.groupingBy(x -> x.getLineItem().getItemId(),
2330 
							Collectors.summingInt(x -> x.getLineItem().getQuantity())));
2331 
			if (!grnPendingOrders.isEmpty()) {
2332 
				grnPendingOrdersMap = itemRepository.selectByIds(grnPendingOrders.keySet()).stream()
2333 
						.collect(Collectors.groupingBy(x -> x.getCatalogItemId(),
2334 
								Collectors.summingInt(x -> grnPendingOrders.get(x.getId()))));
2335 
 
2336 
			}
2337 
 
2338 
			Map<Integer, Integer> processingOrder = orderRepository.selectOrders(fofoId, orderStatusList).stream()
2339 
					.collect(Collectors.groupingBy(x -> x.getLineItem().getItemId(),
2340 
							Collectors.summingInt(x -> x.getLineItem().getQuantity())));
2341 
			if (!processingOrder.isEmpty()) {
2342 
				processingOrderMap = itemRepository.selectByIds(processingOrder.keySet()).stream()
2343 
						.collect(Collectors.groupingBy(x -> x.getCatalogItemId(),
2344 
								Collectors.summingInt(x -> processingOrder.get(x.getId()))));
2345 
 
2346 
			}
2347 
 
25800 tejbeer 2348 
			List<String> brands = mongoClient.getMongoBrands(fofoId, null, 3).stream().map(x -> (String) x.get("name"))
2349 
					.collect(Collectors.toList());
2350 
 
27088 tejbeer 2351 
			List<Integer> regionIds = partnerRegionRepository.selectByfofoId(fofoId).stream().map(x -> x.getRegionId())
2352 
					.collect(Collectors.toList());
27095 tejbeer 2353 
			LOGGER.info("regionIds" + regionIds);
27102 amit.gupta 2354 
			if (regionIds.size() == 0) {
2355 
				LOGGER.info("No region found for partner {}", fofoId);
2356 
				continue;
2357 
			}
27100 amit.gupta 2358 
			Map<Integer, Optional<Integer>> focusedCatalogIdAndQtyMap = focusedModelRepository
27102 amit.gupta 2359 
					.selectAllByRegionIds(regionIds).stream().collect(Collectors.groupingBy(FocusedModel::getCatalogId,
2360 
							Collectors.mapping(FocusedModel::getMinimumQty, Collectors.maxBy(Integer::compareTo))));
25800 tejbeer 2361 
 
25721 tejbeer 2362 
			LOGGER.info("focusedCatalogIdAndQtyMap" + focusedCatalogIdAndQtyMap);
2363 
 
27100 amit.gupta 2364 
			for (Map.Entry<Integer, Optional<Integer>> entry : focusedCatalogIdAndQtyMap.entrySet()) {
2365 
				int minQty = entry.getValue().get();
25721 tejbeer 2366 
				int inStockQty = 0;
2367 
				int processingQty = 0;
2368 
				int grnPendingQty = 0;
27208 tejbeer 2369 
				int allColorNetAvailability = 0;
27253 tejbeer 2370 
				int allColorPoAvailability = 0;
25721 tejbeer 2371 
				if (processingOrderMap != null) {
2372 
					processingQty = (processingOrderMap.get(entry.getKey()) == null) ? 0
2373 
							: processingOrderMap.get(entry.getKey());
2374 
 
2375 
				}
2376 
				if (grnPendingOrdersMap != null) {
2377 
					grnPendingQty = (grnPendingOrdersMap.get(entry.getKey()) == null) ? 0
2378 
							: grnPendingOrdersMap.get(entry.getKey());
2379 
 
2380 
				}
2381 
				if (catalogIdAndQtyMap != null) {
2382 
					inStockQty = (catalogIdAndQtyMap.get(entry.getKey()) == null) ? 0
2383 
							: catalogIdAndQtyMap.get(entry.getKey());
2384 
 
2385 
				}
28526 tejbeer 2386 
 
2387 
				int grnStockQty = grnPendingQty + inStockQty;
25721 tejbeer 2388 
				int totalQty = processingQty + grnPendingQty + inStockQty;
2389 
 
27100 amit.gupta 2390 
				if (totalQty < minQty) {
25721 tejbeer 2391 
 
27100 amit.gupta 2392 
					int shortageQty = minQty - totalQty;
25721 tejbeer 2393 
					List<Item> item = itemRepository.selectAllByCatalogItemId(entry.getKey());
27212 tejbeer 2394 
					FofoStore fofoStore = fofoStoreRepository.selectByRetailerId(fofoId);
27213 tejbeer 2395 
 
27212 tejbeer 2396 
					Map<Integer, List<SaholicCIS>> itemAvailabilityMap = warehouseItemAvailabilityMap
2397 
							.get(fofoStore.getWarehouseId());
25721 tejbeer 2398 
 
27212 tejbeer 2399 
					Map<Integer, List<SaholicPOItem>> poItemAvailabilityMap = warehousePoItemAvailabilityMap
2400 
							.get(fofoStore.getWarehouseId());
27208 tejbeer 2401 
 
2402 
					for (Item it : item) {
28527 tejbeer 2403 
						List<SaholicCIS> currentAvailability = null;
28528 tejbeer 2404 
						List<SaholicPOItem> poItemAvailability = null;
28527 tejbeer 2405 
						if (itemAvailabilityMap != null) {
2406 
							currentAvailability = itemAvailabilityMap.get(it.getId());
2407 
						}
28528 tejbeer 2408 
 
2409 
						if (poItemAvailabilityMap != null) {
2410 
							poItemAvailability = poItemAvailabilityMap.get(it.getId());
2411 
						}
27208 tejbeer 2412 
						if (currentAvailability != null) {
2413 
							allColorNetAvailability += currentAvailability.stream()
2414 
									.collect(Collectors.summingInt(SaholicCIS::getNetavailability));
2415 
						}
27253 tejbeer 2416 
 
27208 tejbeer 2417 
						if (poItemAvailability != null) {
27253 tejbeer 2418 
							allColorPoAvailability += poItemAvailability.stream()
27208 tejbeer 2419 
									.collect(Collectors.summingInt(SaholicPOItem::getUnfulfilledQty));
2420 
						}
27253 tejbeer 2421 
 
27208 tejbeer 2422 
					}
2423 
 
25721 tejbeer 2424 
					FocusedModelShortageModel fm = new FocusedModelShortageModel();
2425 
					fm.setFofoId(fofoId);
27212 tejbeer 2426 
					fm.setStoreCode(fofoStore.getCode());
25721 tejbeer 2427 
					fm.setStoreName(customRetailer.getBusinessName());
27208 tejbeer 2428 
					fm.setBrandName(item.get(0).getBrand());
2429 
					fm.setModelName(item.get(0).getModelName());
2430 
					fm.setModelNumber(item.get(0).getModelNumber());
28526 tejbeer 2431 
					fm.setGrnStockQty(grnStockQty);
2432 
					fm.setPendingIndentQty(processingQty);
25721 tejbeer 2433 
					fm.setShortageQty(shortageQty);
27253 tejbeer 2434 
					fm.setPoAvailabitiy(allColorPoAvailability);
27208 tejbeer 2435 
					fm.setWarehouseName(warehouseMap.get(customRetailer.getWarehouseId()));
27213 tejbeer 2436 
					fm.setStateManager(partnerIdSalesHeadersMap.get(fofoId).getRegionalManager());
2437 
					fm.setTerritoryManager(partnerIdSalesHeadersMap.get(fofoId).getTerritoryManager());
27246 tejbeer 2438 
					fm.setItemName(item.get(0).getBrand() + item.get(0).getModelNumber() + item.get(0).getModelName());
27208 tejbeer 2439 
					fm.setAvailabitiy(allColorNetAvailability);
25721 tejbeer 2440 
 
27102 amit.gupta 2441 
					focusedModelShortageList.add(fm);
25721 tejbeer 2442 
				}
2443 
 
2444 
			}
27233 tejbeer 2445 
 
28529 tejbeer 2446 
			if (!focusedModelShortageList.isEmpty()) {
2447 
				String subject = "Stock Alert";
2448 
				String messageText = this.getMessage(focusedModelShortageList);
27233 tejbeer 2449 
 
28529 tejbeer 2450 
				this.sendMailWithAttachments(subject, messageText, customRetailer.getEmail());
2451 
				String notificationMessage = this.getNotificationMessage(focusedModelShortageList);
2452 
 
2453 
				LOGGER.info("notificationMessage" + notificationMessage);
2454 
 
2455 
				SendNotificationModel sendNotificationModel = new SendNotificationModel();
2456 
				sendNotificationModel.setCampaignName("Stock Alert");
2457 
				sendNotificationModel.setTitle("Alert");
2458 
				sendNotificationModel.setMessage(notificationMessage);
2459 
				sendNotificationModel.setType("url");
2460 
				sendNotificationModel.setUrl("https://app.smartdukaan.com/pages/home/notifications");
2461 
				sendNotificationModel.setExpiresat(LocalDateTime.now().plusDays(2));
2462 
				sendNotificationModel.setMessageType(MessageType.notification);
2463 
				int userId = userAccountRepository.selectUserIdByRetailerId(fofoId);
2464 
				sendNotificationModel.setUserIds(Arrays.asList(userId));
2465 
				notificationService.sendNotification(sendNotificationModel);
2466 
 
2467 
			}
2468 
 
25721 tejbeer 2469 
		}
27102 amit.gupta 2470 
		if (!focusedModelShortageReportMap.isEmpty()) {
25800 tejbeer 2471 
			String fileName = "Stock Alert-" + FormattingUtils.formatDate(LocalDateTime.now()) + ".csv";
2472 
			Map<String, Set<Integer>> storeGuyMap = csService.getAuthUserPartnerIdMapping();
25837 amit.gupta 2473 
			Map<String, List<List<?>>> emailRowsMap = new HashMap<>();
25721 tejbeer 2474 
 
25800 tejbeer 2475 
			focusedModelShortageReportMap.entrySet().forEach(x -> {
2476 
				storeGuyMap.entrySet().forEach(y -> {
2477 
 
2478 
					if (y.getValue().contains(x.getKey())) {
2479 
						if (!emailRowsMap.containsKey(y.getKey())) {
2480 
							emailRowsMap.put(y.getKey(), new ArrayList<>());
2481 
						}
27208 tejbeer 2482 
						List<List<? extends Serializable>> fms = x.getValue().stream()
2483 
								.map(r -> Arrays.asList(r.getStoreCode(), r.getStoreName(), r.getBrandName(),
27213 tejbeer 2484 
										r.getModelName(), r.getModelNumber(), r.getWarehouseName(), r.getStateManager(),
28526 tejbeer 2485 
										r.getTerritoryManager(), r.getPendingIndentQty(), r.getGrnStockQty(),
2486 
										r.getShortageQty(), r.getAvailabitiy()))
25800 tejbeer 2487 
								.collect(Collectors.toList());
2488 
						emailRowsMap.get(y.getKey()).addAll(fms);
2489 
 
25721 tejbeer 2490 
					}
2491 
 
25800 tejbeer 2492 
				});
25721 tejbeer 2493 
 
2494 
			});
2495 
 
27212 tejbeer 2496 
			List<String> headers = Arrays.asList("Store Code", "Store Name", "Brand", "Model Name", "Model Number",
28526 tejbeer 2497 
					"Warehouse Name", "State Manager", "Territory Manager", "Pending Indent", "InStock", "Shortage Qty",
2498 
					"Availability");
25837 amit.gupta 2499 
			emailRowsMap.entrySet().forEach(entry -> {
25721 tejbeer 2500 
 
25800 tejbeer 2501 
				ByteArrayOutputStream baos = null;
2502 
				try {
25837 amit.gupta 2503 
					baos = FileUtil.getCSVByteStream(headers, entry.getValue());
25800 tejbeer 2504 
				} catch (Exception e2) {
2505 
					e2.printStackTrace();
2506 
				}
28529 tejbeer 2507 
				String[] sendToArray = new String[] { entry.getKey() };
28526 tejbeer 2508 
 
25800 tejbeer 2509 
				try {
2510 
					Utils.sendMailWithAttachment(googleMailSender, sendToArray, null, "Stock Alert", "PFA", fileName,
2511 
							new ByteArrayResource(baos.toByteArray()));
2512 
				} catch (Exception e1) { // TODO Auto-generated catch block
2513 
					e1.printStackTrace();
2514 
				}
25721 tejbeer 2515 
 
25800 tejbeer 2516 
			});
2517 
		}
25721 tejbeer 2518 
	}
2519 
 
2520 
	private String getNotificationMessage(List<FocusedModelShortageModel> focusedModelShortageModel) {
2521 
		StringBuilder sb = new StringBuilder();
2522 
		sb.append("Focused Model Shortage in Your Stock : \n");
2523 
		for (FocusedModelShortageModel entry : focusedModelShortageModel) {
2524 
 
2525 
			sb.append(entry.getItemName() + "-" + entry.getShortageQty());
2526 
			sb.append(String.format("%n", ""));
2527 
		}
2528 
		return sb.toString();
2529 
	}
2530 
 
2531 
	private void sendMailWithAttachments(String subject, String messageText, String email) throws Exception {
2532 
		MimeMessage message = mailSender.createMimeMessage();
2533 
		MimeMessageHelper helper = new MimeMessageHelper(message, true);
2534 
 
2535 
		helper.setSubject(subject);
2536 
		helper.setText(messageText, true);
2537 
		helper.setTo(email);
27116 amit.gupta 2538 
		InternetAddress senderAddress = new InternetAddress("noreply@smartdukaan.com", "Smartdukaan Alerts");
25721 tejbeer 2539 
		helper.setFrom(senderAddress);
2540 
		mailSender.send(message);
2541 
 
2542 
	}
2543 
 
2544 
	private String getMessage(List<FocusedModelShortageModel> focusedModelShortageModel) {
2545 
		StringBuilder sb = new StringBuilder();
2546 
		sb.append("<html><body><p>Alert</p><p>Focused Model Shortage in Your Stock:-</p>"
2547 
				+ "<br/><table style='border:1px solid black ;padding: 5px';>");
2548 
		sb.append("<tbody>\n" + "	    				<tr>\n"
2549 
				+ "	    					<th style='border:1px solid black;padding: 5px'>Item</th>\n"
2550 
				+ "	    					<th style='border:1px solid black;padding: 5px'>Shortage Qty</th>\n"
2551 
				+ "	    				</tr>");
2552 
		for (FocusedModelShortageModel entry : focusedModelShortageModel) {
2553 
 
2554 
			sb.append("<tr>");
2555 
			sb.append("<td style='border:1px solid black;padding: 5px'>" + entry.getItemName() + "</td>");
2556 
 
2557 
			sb.append("<td style='border:1px solid black;padding: 5px'>" + entry.getShortageQty() + "</td>");
2558 
 
2559 
			sb.append("</tr>");
2560 
 
2561 
		}
2562 
 
2563 
		sb.append("</tbody></table></body></html>");
2564 
 
2565 
		return sb.toString();
2566 
	}
2567 
 
25927 amit.gupta 2568 
	public void notifyLead() throws Exception {
2569 
		List<Lead> leadsToNotify = leadRepository.selectLeadsScheduledBetweenDate(LocalDateTime.now().minusDays(15),
2570 
				LocalDateTime.now().plusHours(4));
2571 
		Map<Integer, String> authUserEmailMap = authRepository.selectAllActiveUser().stream()
2572 
				.collect(Collectors.toMap(x -> x.getId(), x -> x.getEmailId()));
27477 amit.gupta 2573 
		LOGGER.info("authUserEmailMap {}", authUserEmailMap);
25927 amit.gupta 2574 
		Map<String, Integer> dtrEmailMap = dtrUserRepository
2575 
				.selectAllByEmailIds(new ArrayList<>(authUserEmailMap.values())).stream()
2576 
				.collect(Collectors.toMap(x -> x.getEmailId(), x -> x.getId()));
25936 amit.gupta 2577 
 
27477 amit.gupta 2578 
		LOGGER.info("dtrEmailMap {}", dtrEmailMap);
26790 tejbeer 2579 
 
25927 amit.gupta 2580 
		Map<Integer, Integer> authUserKeyMap = new HashMap<>();
2581 
 
2582 
		for (Map.Entry<Integer, String> authUserEmail : authUserEmailMap.entrySet()) {
2583 
			int authId = authUserEmail.getKey();
2584 
			String email = authUserEmail.getValue();
2585 
			authUserKeyMap.put(authId, dtrEmailMap.get(email));
2586 
		}
27477 amit.gupta 2587 
		LOGGER.info("authUserKeyMap", authUserKeyMap);
2588 
		LOGGER.info("leadsToNotify {}", leadsToNotify);
26790 tejbeer 2589 
 
25927 amit.gupta 2590 
		String templateMessage = "Lead followup for %s %s, %s is due by %s";
2591 
		for (Lead lead : leadsToNotify) {
27217 amit.gupta 2592 
			if (authUserKeyMap.get(lead.getAssignTo()) == null) {
2593 
				LOGGER.info("Assignee no longer part of system {}", lead.getAssignTo());
25927 amit.gupta 2594 
				continue;
2595 
			}
2596 
			String notificationMessage = String.format(templateMessage, lead.getFirstName(), lead.getLastName(),
27795 amit.gupta 2597 
					lead.getAddress(), leadTimeFormatter.format(lead.getScheduledTimestamp()));
25927 amit.gupta 2598 
			SendNotificationModel sendNotificationModel = new SendNotificationModel();
2599 
			sendNotificationModel.setCampaignName("Lead Reminder");
2600 
			sendNotificationModel.setTitle("Leads followup Reminder");
2601 
			sendNotificationModel.setMessage(notificationMessage);
2602 
			sendNotificationModel.setType("url");
27206 tejbeer 2603 
			sendNotificationModel.setUrl("https://app.smartdukaan.com/pages/home/notifications");
25927 amit.gupta 2604 
			sendNotificationModel.setExpiresat(LocalDateTime.now().plusDays(2));
2605 
			sendNotificationModel.setMessageType(MessageType.reminder);
26320 tejbeer 2606 
			sendNotificationModel.setUserIds(Arrays.asList(authUserKeyMap.get(lead.getAssignTo())));
25929 amit.gupta 2607 
			System.out.println(sendNotificationModel);
25927 amit.gupta 2608 
			notificationService.sendNotification(sendNotificationModel);
2609 
		}
2610 
	}
26945 amit.gupta 2611 
 
25927 amit.gupta 2612 
	public void notifyVisits() throws Exception {
26945 amit.gupta 2613 
		List<FranchiseeVisit> franchiseeVisits = franchiseeVisitRepository
2614 
				.selectVisitsScheduledBetweenDate(LocalDateTime.now().minusDays(15), LocalDateTime.now().plusHours(4));
25927 amit.gupta 2615 
		Map<Integer, String> authUserEmailMap = authRepository.selectAllActiveUser().stream()
2616 
				.collect(Collectors.toMap(x -> x.getId(), x -> x.getEmailId()));
2617 
		Map<String, Integer> dtrEmailMap = dtrUserRepository
2618 
				.selectAllByEmailIds(new ArrayList<>(authUserEmailMap.values())).stream()
2619 
				.collect(Collectors.toMap(x -> x.getEmailId(), x -> x.getId()));
2620 
		Map<Integer, Integer> authUserKeyMap = new HashMap<>();
26945 amit.gupta 2621 
 
25927 amit.gupta 2622 
		for (Map.Entry<Integer, String> authUserEmail : authUserEmailMap.entrySet()) {
2623 
			int authId = authUserEmail.getKey();
2624 
			String email = authUserEmail.getValue();
2625 
			authUserKeyMap.put(authId, dtrEmailMap.get(email));
2626 
		}
2627 
		String visitTemplate = "Planned visit to franchisee %s is due by %s";
2628 
		String followupTemplate = "Lead followup for franchisee %s is due by %s";
2629 
		DateTimeFormatter timeFormatter = DateTimeFormatter.ofPattern("MMM 7, EEEE h:m a");
2630 
		for (FranchiseeVisit visit : franchiseeVisits) {
2631 
			if (authUserKeyMap.containsKey(visit.getAuthId())) {
2632 
				continue;
2633 
			}
2634 
			SendNotificationModel sendNotificationModel = new SendNotificationModel();
2635 
			String message = null;
26945 amit.gupta 2636 
			if (visit.getFranchiseActivityId() == 0) {
2637 
				message = String.format(visitTemplate, visit.getPartnerName(),
2638 
						timeFormatter.format(visit.getSchelduleTimestamp()));
2639 
				sendNotificationModel.setCampaignName("Franchisee visit Reminder");
25927 amit.gupta 2640 
			} else {
26945 amit.gupta 2641 
				message = String.format(followupTemplate, visit.getPartnerName(),
2642 
						timeFormatter.format(visit.getSchelduleTimestamp()));
25927 amit.gupta 2643 
				sendNotificationModel.setCampaignName("Franchisee followup Reminder");
2644 
			}
2645 
			sendNotificationModel.setMessage(message);
2646 
			sendNotificationModel.setType("url");
26482 tejbeer 2647 
			sendNotificationModel.setUrl("https://app.smartdukaan.com/pages/home/notifications");
25927 amit.gupta 2648 
			sendNotificationModel.setExpiresat(LocalDateTime.now().plusDays(2));
2649 
			sendNotificationModel.setMessageType(MessageType.reminder);
2650 
			sendNotificationModel.setUserIds(Arrays.asList(authUserKeyMap.get(visit.getAuthId())));
2651 
			notificationService.sendNotification(sendNotificationModel);
2652 
		}
25910 amit.gupta 2653 
	}
25982 amit.gupta 2654 
 
26283 tejbeer 2655 
	public void ticketClosed() throws Exception {
2656 
 
2657 
		List<Ticket> tickets = ticketRepository.selectAllNotClosedTicketsWithStatus(ActivityType.RESOLVED);
2658 
		for (Ticket ticket : tickets) {
2659 
			if (ticket.getUpdateTimestamp().toLocalDate().isBefore(LocalDate.now().minusDays(7))) {
2660 
				ticket.setCloseTimestamp(LocalDateTime.now());
2661 
				ticket.setLastActivity(ActivityType.RESOLVED_ACCEPTED);
2662 
				ticket.setUpdateTimestamp(LocalDateTime.now());
2663 
				ticketRepository.persist(ticket);
2664 
			}
2665 
		}
2666 
 
2667 
	}
2668 
 
26790 tejbeer 2669 
	public void checkValidateReferral() throws Exception {
2670 
 
2671 
		List<Refferal> referrals = refferalRepository.selectByStatus(RefferalStatus.pending);
26791 tejbeer 2672 
		LOGGER.info("referrals" + referrals);
26790 tejbeer 2673 
		if (!referrals.isEmpty()) {
2674 
			String subject = "Referral Request";
2675 
			String messageText = this.getMessageForReferral(referrals);
2676 
 
26792 tejbeer 2677 
			MimeMessage message = mailSender.createMimeMessage();
2678 
			MimeMessageHelper helper = new MimeMessageHelper(message, true);
2679 
			String[] email = { "kamini.sharma@smartdukaan.com", "tarun.verma@smartdukaan.com" };
2680 
			helper.setSubject(subject);
2681 
			helper.setText(messageText, true);
2682 
			helper.setTo(email);
2683 
			InternetAddress senderAddress = new InternetAddress("noreply@smartdukaan.com", "Smartdukaan Alerts");
2684 
			helper.setFrom(senderAddress);
2685 
			mailSender.send(message);
2686 
 
26790 tejbeer 2687 
		}
2688 
	}
2689 
 
2690 
	private String getMessageForReferral(List<Refferal> referrals) {
2691 
		StringBuilder sb = new StringBuilder();
2692 
		sb.append("<html><body><p>Alert</p><p>Pending Referrals:-</p>"
2693 
				+ "<br/><table style='border:1px solid black ;padding: 5px';>");
2694 
		sb.append("<tbody>\n" + "	    				<tr>\n"
2695 
				+ "	    					<th style='border:1px solid black;padding: 5px'>RefereeName</th>\n"
2696 
				+ "	    					<th style='border:1px solid black;padding: 5px'>Referee Email</th>\n"
2697 
				+ "	    					<th style='border:1px solid black;padding: 5px'>Referral Name</th>\n"
2698 
				+ "	    					<th style='border:1px solid black;padding: 5px'>Refferal Mobile</th>\n"
2699 
				+ "	    					<th style='border:1px solid black;padding: 5px'>city</th>\n"
2700 
				+ "	    					<th style='border:1px solid black;padding: 5px'>state</th>\n"
2701 
				+ "	    				</tr>");
2702 
		for (Refferal entry : referrals) {
2703 
 
2704 
			sb.append("<tr>");
2705 
			sb.append("<td style='border:1px solid black;padding: 5px'>" + entry.getRefereeName() + "</td>");
2706 
 
2707 
			sb.append("<td style='border:1px solid black;padding: 5px'>" + entry.getRefereeEmail() + "</td>");
2708 
			sb.append("<td style='border:1px solid black;padding: 5px'>" + entry.getFirstName() + "</td>");
2709 
			sb.append("<td style='border:1px solid black;padding: 5px'>" + entry.getMobile() + "</td>");
2710 
			sb.append("<td style='border:1px solid black;padding: 5px'>" + entry.getCity() + "</td>");
2711 
			sb.append("<td style='border:1px solid black;padding: 5px'>" + entry.getState() + "</td>");
2712 
 
2713 
			sb.append("</tr>");
2714 
 
2715 
		}
2716 
 
2717 
		sb.append("</tbody></table></body></html>");
2718 
 
2719 
		return sb.toString();
2720 
	}
2721 
 
27271 amit.gupta 2722 
	public void reverseWallet() throws Exception {
2723 
		LocalDate localDate = LocalDate.of(2020, 10, 28);
28205 tejbeer 2724 
		List<UserWalletHistory> uwhList = userWalletHistoryRepository.selectAllByDateType(localDate.atStartOfDay(),
2725 
				localDate.plusDays(1).atStartOfDay(),
27271 amit.gupta 2726 
				Arrays.asList(WalletReferenceType.SCHEME_IN, WalletReferenceType.SCHEME_OUT));
2727 
		for (UserWalletHistory uwh : uwhList) {
28205 tejbeer 2728 
			if (uwh.getBusinessTimestamp().getMonth().equals(Month.SEPTEMBER)) {
27275 amit.gupta 2729 
				UserWallet uw = userWalletRepository.selectById(uwh.getWalletId());
28205 tejbeer 2730 
				// LOGGER.info("UWH - {}", uwh);
2731 
				// amount += uwh.getAmount();
2732 
				// System.out.println("Amount is - " + amount);
2733 
				// walletService.rollbackAmountFromWallet(uw.getUserId(), uwh.getAmount(),
2734 
				// uwh.getReference(), uwh.getReferenceType(), "Margin reversal for error prone
2735 
				// run", uwh.getBusinessTimestamp());
27313 amit.gupta 2736 
				int orderId = uwh.getReference();
2737 
				FofoOrder fofoOrder = fofoOrderRepository.selectByOrderId(orderId);
2738 
				int inventoryItemId = 0;
28205 tejbeer 2739 
				// fofoOrderRepository.delete(fofoOrder);
27313 amit.gupta 2740 
				List<FofoOrderItem> fofoOrderItems = fofoOrderItemRepository.selectByOrderId(fofoOrder.getId());
28205 tejbeer 2741 
				/*
2742 
				 * List<PaymentOptionTransaction> paymentOptionTransactions =
2743 
				 * paymentOptionTransactionRepository.selectByReferenceIdAndType(fofoOrder.getId
2744 
				 * (), PaymentOptionReferenceType.ORDER); for(PaymentOptionTransaction
2745 
				 * paymentOptionTransaction : paymentOptionTransactions) {
2746 
				 * //paymentOptionTransactionRepository.delete(paymentOptionTransaction); }
2747 
				 */
2748 
				for (FofoOrderItem foi : fofoOrderItems) {
2749 
					// fofoOrderItemRepository.delete(foi);
27313 amit.gupta 2750 
					List<FofoLineItem> flis = fofoLineItemRepository.selectByFofoOrderItemId(foi.getId());
28205 tejbeer 2751 
					for (FofoLineItem fli : flis) {
2752 
						// fofoLineItemRepository.delete(fli);
27313 amit.gupta 2753 
						inventoryItemId = fli.getInventoryItemId();
2754 
					}
2755 
				}
28205 tejbeer 2756 
				List<SchemeInOut> schemeInOuts = schemeInOutRepository.selectByInventoryItemIds(
2757 
						java.util.stream.Stream.of(inventoryItemId).collect(Collectors.toSet()));
2758 
				for (SchemeInOut sio : schemeInOuts) {
2759 
					if (sio.getCreateTimestamp().toLocalDate().equals(localDate)) {
27314 amit.gupta 2760 
						LOGGER.info("SIO - {}", sio);
27315 amit.gupta 2761 
						sio.setRolledBackTimestamp(LocalDateTime.now());
27313 amit.gupta 2762 
					}
2763 
				}
28205 tejbeer 2764 
 
27271 amit.gupta 2765 
			}
2766 
		}
28205 tejbeer 2767 
 
27271 amit.gupta 2768 
	}
28205 tejbeer 2769 
 
2770 
	public void partnerProblemAlert() throws Exception {
2771 
		LocalDateTime curDate = LocalDate.now().atStartOfDay();
2772 
		Map<Integer, Double> lmtdSale = fofoOrderItemRepository.selectSumMopGroupByRetailer(
2773 
				curDate.withDayOfMonth(1).minusMonths(1), curDate.with(LocalTime.MAX).minusMonths(1), 0, false);
2774 
		Map<Integer, Double> mtdSales = fofoOrderItemRepository.selectSumMopGroupByRetailer(curDate.withDayOfMonth(1),
2775 
				curDate.with(LocalTime.MAX), 0, false);
2776 
		Map<Integer, PartnerDailyInvestment> pdi = partnerDailyInvestmentRepository.selectAll(LocalDate.now()).stream()
2777 
				.collect(Collectors.toMap(x -> x.getFofoId(), x -> x));
2778 
 
2779 
		for (Entry<Integer, Double> ls : lmtdSale.entrySet()) {
2780 
 
2781 
			double lmtdTwentyPercentSale = ls.getValue() * 0.2;
28208 tejbeer 2782 
 
2783 
			LOGGER.info("lmtdTwentyPercentSale" + lmtdTwentyPercentSale);
2784 
 
28211 tejbeer 2785 
			double mtdSale = mtdSales.get(ls.getKey()) == null ? 0 : mtdSales.get(ls.getKey());
28208 tejbeer 2786 
 
2787 
			LOGGER.info("mtdSale" + mtdSale);
2788 
 
28209 tejbeer 2789 
			double totalSixtyPercentInvestment = pdi.get(ls.getKey()) == null ? 0
2790 
					: pdi.get(ls.getKey()).getTotalInvestment() * 0.6;
28205 tejbeer 2791 
 
28208 tejbeer 2792 
			LOGGER.info("totalSixtyPercentInvestment" + totalSixtyPercentInvestment);
2793 
 
28209 tejbeer 2794 
			double stockInvestment = pdi.get(ls.getKey()) == null ? 0 : pdi.get(ls.getKey()).getInStockAmount();
28208 tejbeer 2795 
 
2796 
			LOGGER.info("stockInvestment" + stockInvestment);
2797 
 
28205 tejbeer 2798 
			boolean Investmentvalue = partnerInvestmentService.isInvestmentBelow(ls.getKey(), 25);
2799 
 
2800 
			PartnerProblem partnerProblem = partnerProblemRepository.selectByFofoId(ls.getKey());
2801 
 
28210 tejbeer 2802 
			if (partnerProblem == null) {
28205 tejbeer 2803 
				partnerProblem = new PartnerProblem();
2804 
				partnerProblem.setFofoId(ls.getKey());
2805 
				if (mtdSale < lmtdTwentyPercentSale) {
2806 
					partnerProblem.setMtd(1);
2807 
				}
2808 
				if (Investmentvalue) {
2809 
					partnerProblem.setInvestment(1);
2810 
				}
2811 
 
2812 
				if (stockInvestment < totalSixtyPercentInvestment) {
2813 
					partnerProblem.setInvestment(1);
2814 
				}
2815 
 
2816 
				partnerProblemRepository.persist(partnerProblem);
2817 
			} else {
2818 
				if (mtdSale < lmtdTwentyPercentSale) {
2819 
					partnerProblem.setMtd(partnerProblem.getMtd() + 1);
2820 
 
2821 
				} else {
2822 
					partnerProblem.setMtd(0);
2823 
 
2824 
				}
2825 
				if (Investmentvalue) {
2826 
					partnerProblem.setInvestment(partnerProblem.getInvestment() + 1);
2827 
				} else {
2828 
					partnerProblem.setInvestment(0);
2829 
 
2830 
				}
2831 
				if (stockInvestment < totalSixtyPercentInvestment) {
2832 
					partnerProblem.setStockInvestment(partnerProblem.getStockInvestment() + 1);
2833 
				} else {
2834 
					partnerProblem.setStockInvestment(0);
2835 
				}
2836 
 
2837 
			}
2838 
 
2839 
		}
2840 
 
28213 tejbeer 2841 
		List<PartnerProblem> partnerProblems = partnerProblemRepository.selectAll().stream()
2842 
				.filter(x -> x.getMtd() + x.getInvestment() + x.getStockInvestment() > 0).collect(Collectors.toList());
2843 
 
28223 tejbeer 2844 
		partnerProblems = partnerProblems.stream().sorted((x1, x2) -> {
28224 tejbeer 2845 
			return x1.getMtd() + x1.getInvestment() + x1.getStockInvestment() < x2.getMtd() + x2.getInvestment()
28223 tejbeer 2846 
					+ x2.getStockInvestment() ? 1 : -1;
2847 
		}).collect(Collectors.toList());
28227 tejbeer 2848 
 
2849 
		Map<Integer, PartnerProblem> partnerProblemMap = partnerProblems.stream().sorted((x1, x2) -> {
2850 
			return x1.getMtd() + x1.getInvestment() + x1.getStockInvestment() < x2.getMtd() + x2.getInvestment()
2851 
					+ x2.getStockInvestment() ? 1 : -1;
2852 
		}).collect(Collectors.toMap(x -> x.getFofoId(), x -> x));
2853 
 
28212 tejbeer 2854 
		Map<Integer, CustomRetailer> customRetailers = retailerService.getAllFofoRetailers();
28213 tejbeer 2855 
 
28467 tejbeer 2856 
		List<Integer> assignTo = Arrays.asList(15, 9, 54, 53);
28213 tejbeer 2857 
 
2858 
		Map<Integer, AuthUser> assignAuthUserMap = authRepository.selectAllAuthUserByIds(assignTo).stream()
2859 
				.collect(Collectors.toMap(x -> x.getId(), x -> x));
2860 
 
28286 tejbeer 2861 
		List<String> sendTo = Arrays.asList("kamini.sharma@smartdukaan.com", "tarun.verma@smartdukaan.com",
28467 tejbeer 2862 
				"niranjan.kala@smartdukaan.com", "sm@smartdukaan.com", "tejbeer.kaur@shop2020.in");
28208 tejbeer 2863 
		LOGGER.info("partnerProblem" + partnerProblems);
28205 tejbeer 2864 
		StringBuilder sb = new StringBuilder();
28218 tejbeer 2865 
		sb.append("<htl><body>");
28222 tejbeer 2866 
		sb.append(
2867 
				"<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 2868 
		sb.append("<tbody>\n" + "	    <tr>"
2869 
				+ "	    					<th style='border:1px solid black;padding: 5px'>Partner Name</th>"
2870 
				+ "                         <th style='border:1px solid black;padding: 5px'>Assign TO</th>"
2871 
				+ "	    					<th style='border:1px solid black;padding: 5px'>Mtd</th>"
2872 
				+ "	    					<th style='border:1px solid black;padding: 5px'>Investment</th>"
2873 
				+ "	    					<th style='border:1px solid black;padding: 5px'>Stock</th>"
2874 
				+ "	    					<th style='border:1px solid black;padding: 5px'>Manager</th>"
2875 
 
2876 
				+ "	    				</tr>");
2877 
 
2878 
		for (PartnerProblem pp : partnerProblems) {
28467 tejbeer 2879 
			int value = pp.getFofoId() % 4;
28205 tejbeer 2880 
 
2881 
			Map<EscalationType, AuthUser> authUserMap = csService.getAuthUserAndEsclationByPartnerId(pp.getFofoId());
28217 tejbeer 2882 
			LOGGER.info("authUserMap" + authUserMap);
28205 tejbeer 2883 
			sb.append("<tr>");
2884 
			sb.append("<td style='border:1px solid black;padding: 5px'>"
2885 
					+ customRetailers.get(pp.getFofoId()).getBusinessName() + "</td>");
28213 tejbeer 2886 
			sb.append("<td style='border:1px solid black;padding: 5px'>"
2887 
					+ assignAuthUserMap.get(assignTo.get(value)).getName() + "</td>");
28205 tejbeer 2888 
			sb.append("<td style='border:1px solid black;padding: 5px'>" + pp.getMtd() + "</td>");
2889 
			sb.append("<td style='border:1px solid black;padding: 5px'>" + pp.getInvestment() + "</td>");
2890 
			sb.append("<td style='border:1px solid black;padding: 5px'>" + pp.getStockInvestment() + "</td>");
28216 tejbeer 2891 
			sb.append("<td style='border:1px solid black;padding: 5px'>"
28224 tejbeer 2892 
					+ (authUserMap.get(EscalationType.L1) == null ? "N/A"
28216 tejbeer 2893 
							: authUserMap.get(EscalationType.L1).getFirstName())
28224 tejbeer 2894 
					+ " ," + (authUserMap.get(EscalationType.L2) == null ? "N/A"
28218 tejbeer 2895 
							: authUserMap.get(EscalationType.L2).getFirstName())
28216 tejbeer 2896 
					+ "</td>");
28205 tejbeer 2897 
 
2898 
			sb.append("</tr>");
2899 
		}
2900 
		sb.append("</tbody></table><br><br>");
2901 
		String subject = "Partner Problem Alert!";
2902 
		String[] email = sendTo.toArray(new String[sendTo.size()]);
2903 
 
28222 tejbeer 2904 
		this.sendMailHtmlFormat(email, sb.toString(), null, subject);
2905 
 
28218 tejbeer 2906 
		Map<Integer, List<Integer>> authUserPartnerMapping = csService.getAuthUserIdPartnerIdMapping();
2907 
 
2908 
		for (Entry<Integer, List<Integer>> authUserPartner : authUserPartnerMapping.entrySet()) {
28222 tejbeer 2909 
			AuthUser authUser = authRepository.selectById(authUserPartner.getKey());
28227 tejbeer 2910 
			for (Integer patnerId : authUserPartner.getValue()) {
2911 
				if (partnerProblemMap.get(patnerId) != null) {
28218 tejbeer 2912 
 
28227 tejbeer 2913 
					StringBuilder sbbuilder = new StringBuilder();
2914 
					sbbuilder.append("<hml><body>");
2915 
					sb.append(
2916 
							"<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>");
2917 
					sbbuilder.append("<tbody>\n" + "	    <tr>"
2918 
							+ "	    					<th style='border:1px solid black;padding: 5px'>Partner Name</th>"
2919 
							+ "	    					<th style='border:1px solid black;padding: 5px'>Mtd</th>"
2920 
							+ "	    					<th style='border:1px solid black;padding: 5px'>Investment</th>"
2921 
							+ "	    					<th style='border:1px solid black;padding: 5px'>Stock</th>"
28218 tejbeer 2922 
 
28227 tejbeer 2923 
							+ "	    				</tr>");
28218 tejbeer 2924 
 
28227 tejbeer 2925 
					for (Integer partnerId : authUserPartner.getValue()) {
2926 
						if (partnerProblemMap.get(partnerId) != null) {
2927 
							PartnerProblem pp = partnerProblemMap.get(partnerId);
2928 
							sbbuilder.append("<tr>");
2929 
							sbbuilder.append("<td style='border:1px solid black;padding: 5px'>"
2930 
									+ customRetailers.get(pp.getFofoId()).getBusinessName() + "</td>");
2931 
							sbbuilder
2932 
									.append("<td style='border:1px solid black;padding: 5px'>" + pp.getMtd() + "</td>");
2933 
							sbbuilder.append(
2934 
									"<td style='border:1px solid black;padding: 5px'>" + pp.getInvestment() + "</td>");
2935 
							sbbuilder.append("<td style='border:1px solid black;padding: 5px'>"
2936 
									+ pp.getStockInvestment() + "</td>");
2937 
 
2938 
							sbbuilder.append("</tr>");
2939 
						}
2940 
 
28224 tejbeer 2941 
					}
28227 tejbeer 2942 
					sbbuilder.append("</tbody></table><br><br>");
28224 tejbeer 2943 
 
28286 tejbeer 2944 
					this.sendMailOfHtmlFormat(authUser.getEmailId(), sbbuilder.toString(), null, subject);
28230 tejbeer 2945 
					break;
28218 tejbeer 2946 
				}
28230 tejbeer 2947 
 
28223 tejbeer 2948 
			}
28222 tejbeer 2949 
		}
2950 
	}
28218 tejbeer 2951 
 
28222 tejbeer 2952 
	private void sendMailHtmlFormat(String email[], String body, String cc[], String subject)
2953 
			throws MessagingException, ProfitMandiBusinessException, IOException {
2954 
		MimeMessage message = mailSender.createMimeMessage();
2955 
		MimeMessageHelper helper = new MimeMessageHelper(message);
2956 
		helper.setSubject(subject);
2957 
		helper.setText(body, true);
2958 
		helper.setTo(email);
2959 
		if (cc != null) {
2960 
			helper.setCc(cc);
28218 tejbeer 2961 
		}
28222 tejbeer 2962 
		InternetAddress senderAddress = new InternetAddress("noreply@smartdukaan.com", "Smart Dukaan");
2963 
		helper.setFrom(senderAddress);
2964 
		mailSender.send(message);
28205 tejbeer 2965 
	}
2966 
 
28775 amit.gupta 2967 
	@Autowired
2968 
	WarehouseRepository warehouseRepository;
28790 amit.gupta 2969 
 
28775 amit.gupta 2970 
	public void getVendorWarehouses(int warehouseId) {
28778 amit.gupta 2971 
		LOGGER.info("Warehouses - {}", warehouseRepository.getVendorWarehouses().get(warehouseId));
28790 amit.gupta 2972 
 
28775 amit.gupta 2973 
	}
2974 
 
26418 tejbeer 2975 
}
27438 amit.gupta 2976 
//2284