Subversion Repositories SmartDukaan

Rev

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