WebSVN – SmartDukaan – Diff – /trunk/profitmandi-fofo/src/main/java/com/spice/profitmandi/web/controller/WalletController.java

 package com.spice.profitmandi.web.controller;
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.InputStream;
 import java.text.MessageFormat;
 import java.time.LocalDateTime;
+import java.time.ZoneId;
 import java.util.ArrayList;
 import java.util.Collections;
+import java.util.Date;
+import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.stream.Collectors;
 import javax.mail.internet.InternetAddress;
 import javax.swing.SortOrder;
 import javax.transaction.Transactional;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
+import org.apache.poi.ss.usermodel.Cell;
+import org.apache.poi.ss.usermodel.CellStyle;
+import org.apache.poi.ss.usermodel.CreationHelper;
+import org.apache.poi.ss.usermodel.Sheet;
+import org.apache.poi.xssf.usermodel.XSSFWorkbook;
 import org.json.JSONObject;
 import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.core.io.InputStreamResource;
+import org.springframework.http.HttpHeaders;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
 import org.springframework.mail.javamail.JavaMailSender;
 import org.springframework.mail.javamail.MimeMessageHelper;
 import org.springframework.stereotype.Controller;
 import org.springframework.ui.Model;
 import org.springframework.web.bind.annotation.PostMapping;
 import com.spice.profitmandi.dao.entity.transaction.UnsettledPayment;
 import com.spice.profitmandi.dao.entity.transaction.UserWallet;
 import com.spice.profitmandi.dao.entity.transaction.UserWalletHistory;
 import com.spice.profitmandi.dao.enumuration.transaction.AddWalletRequestStatus;
 import com.spice.profitmandi.dao.enumuration.transaction.TransactionType;
-import com.spice.profitmandi.dao.model.ContentPojo;
+import com.spice.profitmandi.dao.model.AccountStatementModel;
 import com.spice.profitmandi.dao.repository.catalog.AddWalletRequestRepository;
 import com.spice.profitmandi.dao.repository.catalog.ManualPaymentRequestRepository;
 import com.spice.profitmandi.dao.repository.catalog.UnsettledPaymentsRepository;
 import com.spice.profitmandi.dao.repository.dtr.FofoStoreRepository;
 import com.spice.profitmandi.dao.repository.dtr.RetailerRepository;
 import com.spice.profitmandi.dao.repository.dtr.UserAccountRepository;
 import com.spice.profitmandi.dao.repository.dtr.UserRepository;
+import com.spice.profitmandi.dao.repository.transaction.OrderRepository;
+import com.spice.profitmandi.dao.repository.transaction.StatementDetailModel;
 import com.spice.profitmandi.dao.repository.transaction.UserWalletHistoryRepository;
 import com.spice.profitmandi.dao.repository.transaction.UserWalletRepository;
 import com.spice.profitmandi.service.authentication.RoleManager;
 import com.spice.profitmandi.service.user.RetailerService;
 import com.spice.profitmandi.service.wallet.WalletService;
 @Controller
 @Transactional(rollbackOn = Throwable.class)
 public class WalletController {
+	private static final int IDX_PERIOD = 1;
+	private static final int OPENING_BALANCE = 2;
+	private static final int ACTIVATION_SCHEME = 4;
+	private static final int ADVANCE_AMOUNT = 5;
+	private static final int AUTOMATED_ADVANCE = 6;
+	private static final int BRAND_PAYOUT = 7;
+	private static final int INVESTMENT_PAYOUT = 8;
+	private static final int OTHERS = 9;
+	private static final int PREBOOKING_ORDER = 10;
+	private static final int PRICE_DROP = 11;
+	private static final int PURCHASE = 12;
+	private static final int PURCHASE_BILLED = 13;
+	private static final int PURCHASE_PENDING_BILLING = 14;
+	private static final int PURCHASE_CANCELLED = 15;
+	private static final int RECHARGE = 16;
+	private static final int REFUND = 17;
+	private static final int SCHEME_IN = 18;
+	private static final int SCHEME_OUT = 19;
+	private static final Map<WalletReferenceType, Integer> walletReferenceMap = new HashMap<>();
+	static {
+		walletReferenceMap.put(WalletReferenceType.ACTIVATION_SCHEME, ACTIVATION_SCHEME);
+		walletReferenceMap.put(WalletReferenceType.ADVANCE_AMOUNT, ADVANCE_AMOUNT);
+		walletReferenceMap.put(WalletReferenceType.AUTOMATED_ADVANCE, AUTOMATED_ADVANCE);
+		walletReferenceMap.put(WalletReferenceType.BRAND_PAYOUT, BRAND_PAYOUT);
+		walletReferenceMap.put(WalletReferenceType.INVESTMENT_PAYOUT, INVESTMENT_PAYOUT);
+		walletReferenceMap.put(WalletReferenceType.OTHERS, OTHERS);
+		walletReferenceMap.put(WalletReferenceType.PREBOOKING_ORDER, PREBOOKING_ORDER);
+		walletReferenceMap.put(WalletReferenceType.PRICE_DROP, PRICE_DROP);
+		walletReferenceMap.put(WalletReferenceType.PURCHASE, PURCHASE);
+		walletReferenceMap.put(WalletReferenceType.RECHARGE, RECHARGE);
+		walletReferenceMap.put(WalletReferenceType.REFUND, REFUND);
+		walletReferenceMap.put(WalletReferenceType.SCHEME_IN, SCHEME_IN);
+		walletReferenceMap.put(WalletReferenceType.SCHEME_OUT, SCHEME_OUT);
+	}
+	private static final int GRAND_TOTAL = 20;
+	private static final int CLOSING_BALANCE = 22;
+	private static final int PENDING_GRN = 23;
+	private static final int ACTIVATED_IMEIS = 24;
 	@Autowired
 	private CookiesProcessor cookiesProcessor;
 	@Autowired
 	private WalletService walletService;
 	@Autowired
 	private UserAccountRepository userAccountRepository;
 	@Autowired
+	private OrderRepository orderRepository;
+	@Autowired
 	JavaMailSender mailSender;
 	@Autowired
 	private UnsettledPaymentsRepository unsettledPaymentsRepository;
 	private RetailerRepository retailerRepository;
 	@Autowired
 	private UserRepository userRepository;
 	private static final Logger LOGGER = LogManager.getLogger(WalletController.class);
 	@PostMapping(value = "/wallet/upload")
 	public String uploadWalletBulk(HttpServletRequest request, @RequestPart("file") MultipartFile file, Model model)
 			throws Exception {
 		List<WalletHistoryModel> walletHistoryModelList = ExcelUtils.parseWalletBulkCredit(file.getInputStream());
-		for(WalletHistoryModel walletHistoryModel : walletHistoryModelList) {
+		for (WalletHistoryModel walletHistoryModel : walletHistoryModelList) {
-			if(walletHistoryModel.getReference()==0) {
+			if (walletHistoryModel.getReference() == 0) {
-				ManualPaymentType paymentType =
+				ManualPaymentType paymentType = manualPaymentRequestRepository
-						manualPaymentRequestRepository.selectByReferenceType(walletHistoryModel.getWalletReferenceType());
+						.selectByReferenceType(walletHistoryModel.getWalletReferenceType());
 				if (paymentType == null) {
 					paymentType = new ManualPaymentType();
 					paymentType.setReferenceType(walletHistoryModel.getWalletReferenceType());
+				}
 				paymentType.setCounter(paymentType.getCounter() + 1);
 				manualPaymentRequestRepository.persist(paymentType);
 				int reference = paymentType.getCounter();
-				walletService.addAmountToWallet(walletHistoryModel.getFofoId(), reference, walletHistoryModel.getWalletReferenceType(),
+				walletService.addAmountToWallet(walletHistoryModel.getFofoId(), reference,
+						walletHistoryModel.getWalletReferenceType(), walletHistoryModel.getDescription(),
-						walletHistoryModel.getDescription(), (float)walletHistoryModel.getAmount(), walletHistoryModel.getBusinessDate());
+						(float) walletHistoryModel.getAmount(), walletHistoryModel.getBusinessDate());
-			}  else {
+			} else {
-				walletService.addAmountToWallet(walletHistoryModel.getFofoId(), walletHistoryModel.getReference(), walletHistoryModel.getWalletReferenceType(),
+				walletService.addAmountToWallet(walletHistoryModel.getFofoId(), walletHistoryModel.getReference(),
+						walletHistoryModel.getWalletReferenceType(), walletHistoryModel.getDescription(),
-						walletHistoryModel.getDescription(), (float)walletHistoryModel.getAmount(), walletHistoryModel.getBusinessDate());
+						(float) walletHistoryModel.getAmount(), walletHistoryModel.getBusinessDate());
+			}
+		}
 		model.addAttribute("response", mvcResponseSender.createResponseString(true));
 		return "response";
 			throws Exception {
 		AddWalletRequest addWalletRequest = addWalletRequestRepository.selectById(walletRequestid);
 		if (addWalletRequest.getStatus().equals(AddWalletRequestStatus.pending)) {
 			walletService.addAmountToWallet(addWalletRequest.getRetailerId(), walletRequestid,
-					WalletReferenceType.ADVANCE_AMOUNT, "ntfs/rgfs", addWalletRequest.getAmount(), addWalletRequest.getCreateTimestamp());
+					WalletReferenceType.ADVANCE_AMOUNT, "ntfs/rgfs", addWalletRequest.getAmount(),
+					addWalletRequest.getCreateTimestamp());
 			addWalletRequest.setStatus(AddWalletRequestStatus.approved);
 			addWalletRequest.setUpdateTimestamp(LocalDateTime.now());
 			addWalletRequestRepository.persist(addWalletRequest);
 			unsettledPaymentsRepository.deleteById(id);
 			model.addAttribute("response", mvcResponseSender.createResponseString(true));
 		model.addAttribute("startDate", startDate);
 		model.addAttribute("endDate", endDate);
 		return "walletStatement";
+	}
+	@RequestMapping(value = "/account/statement", method = RequestMethod.GET)
+	public ResponseEntity<?> getAccountStatement(HttpServletRequest request, @RequestParam LocalDateTime startDate,
+			@RequestParam LocalDateTime endDate, Model model, @RequestParam(defaultValue = "0") int fofoId)
+			throws Exception {
+		boolean isAdmin = roleManager.isAdmin(cookiesProcessor.getCookiesObject(request).getRoleIds());
+		if (fofoId > 0) {
+			if (!isAdmin) {
+				throw new ProfitMandiBusinessException("Unauthorised access", "PartnerId", "Permission Denied");
+			}
+		} else {
+			fofoId = cookiesProcessor.getCookiesObject(request).getFofoId();
+		}
+		float openingBalance = walletService.getOpeningTillExcludingPurchase(fofoId, startDate);
+		float closingBalance = walletService.getOpeningTillExcludingPurchase(fofoId, endDate);
+		List<AccountStatementModel> accountModels = userWalletRepository.getStatement(fofoId, startDate, endDate)
+				.stream().filter(x -> !x.getWalletReferenceType().equals(WalletReferenceType.PURCHASE))
+				.collect(Collectors.toList());
+		Map<WalletReferenceType, AccountStatementModel> accountModelsMap = accountModels.stream()
+				.collect(Collectors.toMap(AccountStatementModel::getWalletReferenceType, x -> x));
+		InputStream is = getClass().getClassLoader().getResourceAsStream("account-statement.xlsx");
+		String partnerName = retailerService.getAllFofoRetailerIdNameMap().get(fofoId);
+		List<StatementDetailModel> details = orderRepository.selectDetailsBetween(fofoId, startDate, endDate);
+		float openingAmount = orderRepository.selectOpeningAmount(fofoId, startDate);
+		float closingAmount = orderRepository.selectOpeningAmount(fofoId, endDate);
+		LOGGER.info("Opening - {}, Closing - {}", openingAmount, closingAmount);
+		ByteArrayOutputStream byteArrayOutputStream = this.populateData(is, openingBalance - openingAmount,
+				closingBalance - closingAmount, partnerName, accountModelsMap, startDate, endDate, details);
+		final HttpHeaders headers = new HttpHeaders();
+		headers.set("Content-Type", "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet");
+		headers.set("Content-disposition",
+				"inline; filename=account-statement." + StringUtils.toHyphenatedString(startDate.toLocalDate()) + "-"
+						+ StringUtils.toHyphenatedString(endDate.toLocalDate()) + ".xlsx");
+		headers.setContentLength(byteArrayOutputStream.toByteArray().length);
+		final InputStream inputStream = new ByteArrayInputStream(byteArrayOutputStream.toByteArray());
+		final InputStreamResource inputStreamResource = new InputStreamResource(inputStream);
+		return new ResponseEntity<InputStreamResource>(inputStreamResource, headers, HttpStatus.OK);
+	}
+	private ByteArrayOutputStream populateData(InputStream is, float openingBalance, float closingBalance,
+			String partnerName, Map<WalletReferenceType, AccountStatementModel> accountModels, LocalDateTime startDate,
+			LocalDateTime endDate, List<StatementDetailModel> invoiceDetails) throws Exception {
+		XSSFWorkbook workbook = new XSSFWorkbook(is);
+		CreationHelper creationHelper = workbook.getCreationHelper();
+		CellStyle style2 = workbook.createCellStyle();
+		style2.setDataFormat(creationHelper.createDataFormat().getFormat(
+				"mm/dd/yyyy hh:mm:ss"));
+		ByteArrayOutputStream bos = new ByteArrayOutputStream();
+		Sheet sheet = workbook.getSheetAt(0);
+		sheet.getRow(0).getCell(0).setCellValue(partnerName);
+		sheet.getRow(1).getCell(1)
+				.setCellValue(new Date(startDate.atZone(ZoneId.systemDefault()).toInstant().toEpochMilli()));
+		sheet.getRow(1).getCell(2)
+				.setCellValue(new Date(endDate.atZone(ZoneId.systemDefault()).toInstant().toEpochMilli()));
+		sheet.getRow(2).getCell(2).setCellValue(openingBalance);
+		long grandTotalDebit = 0l;
+		long grandTotalCredit = 0l;
+		int row = 4;
+		for (Map.Entry<WalletReferenceType, AccountStatementModel> walletRow : accountModels.entrySet()) {
+			sheet.createRow(row).createCell(0).setCellValue(walletRow.getKey().toString());
+			sheet.getRow(row).createCell(1).setCellValue(walletRow.getValue().getDebit());
+			sheet.getRow(row).createCell(2).setCellValue(walletRow.getValue().getCredit());
+			grandTotalDebit += walletRow.getValue().getDebit();
+			grandTotalCredit += walletRow.getValue().getCredit();
+			row++;
+		}
+		for (StatementDetailModel statementDetailModel : invoiceDetails) {
+			sheet.createRow(row).createCell(0).setCellValue(statementDetailModel.getInvoiceNumber());
+			if (statementDetailModel.getAmount() > 0) {
+				sheet.getRow(row).createCell(1).setCellValue(statementDetailModel.getAmount());
+				sheet.getRow(row).createCell(2).setCellValue(0);
+				grandTotalDebit += statementDetailModel.getAmount();
+			} else {
+				sheet.getRow(row).createCell(1).setCellValue(0);
+				sheet.getRow(row).createCell(2).setCellValue(-statementDetailModel.getAmount());
+				grandTotalCredit += -statementDetailModel.getAmount();
+			}
+			Cell dateCell = sheet.getRow(row).createCell(3);
+			dateCell.setCellValue(statementDetailModel.getOnDate());
+			dateCell.setCellStyle(style2);
+			row += 1;
+		}
+		sheet.createRow(row).createCell(0).setCellValue("Grand Total");
+		sheet.getRow(row).createCell(1).setCellValue(grandTotalDebit);
+		sheet.getRow(row).createCell(2).setCellValue(grandTotalCredit);
+		row += 2;
+		sheet.createRow(row).createCell(0).setCellValue("Closing Balance");
+		sheet.getRow(row).createCell(2).setCellValue(closingBalance);
+		row++;
+		/*
+		 * sheet.createRow(row).createCell(0).setCellValue("Pending Grns");
+		 * sheet.getRow(row).createCell(2).setCellValue(closingBalance); row++;
+		 */
+		try {
+			workbook.write(bos);
+		} finally {
+			workbook.close();
+			bos.close();
+		}
+		return bos;
+	}
 	@RequestMapping(value = "/manualPayment", method = RequestMethod.GET)
 	public String ManualPayment(HttpServletRequest request, Model model) throws Exception {
 		List<Integer> fofoIds = fofoStoreRepository.selectAll().stream().map(x -> x.getId())
 				.collect(Collectors.toList());
+	}
 	@RequestMapping(value = "/walletUpdate", method = RequestMethod.POST)
 	public String walletUpdate(HttpServletRequest request,
-			@RequestParam(name = "reference", defaultValue = "0") int reference,
+			@RequestParam(name = "reference", defaultValue = "0") int reference, @RequestParam int referenceTypeValue,
-			@RequestParam int referenceTypeValue, @RequestParam TransactionType transactiontype,
+			@RequestParam TransactionType transactiontype, @RequestParam int amount, @RequestParam String description,
-			@RequestParam int amount, @RequestParam String description, @RequestParam int retailerId, Model model,
+			@RequestParam int retailerId, Model model, @RequestParam LocalDateTime businessTimestamp) throws Exception {
-			@RequestParam LocalDateTime businessTimestamp)
-			throws Exception {
 		WalletReferenceType referenceType = WalletReferenceType.findByValue(referenceTypeValue);
-		if (reference==0 && referenceType.getValue()>= WalletReferenceType.INCENTIVES.getValue()) {
+		if (reference == 0 && referenceType.getValue() >= WalletReferenceType.INCENTIVES.getValue()) {
 			LOGGER.error("referenceType: " + referenceType);
 			ManualPaymentType paymentType = manualPaymentRequestRepository.selectByReferenceType(referenceType);
 			if (paymentType == null) {
 				paymentType = new ManualPaymentType();
 				paymentType.setReferenceType(referenceType);
+			}
 			paymentType.setCounter(paymentType.getCounter() + 1);
 			manualPaymentRequestRepository.persist(paymentType);
 			reference = paymentType.getCounter();
-		} else if(reference==0){
+		} else if (reference == 0) {
 			throw new ProfitMandiBusinessException("RefrenceId", reference,
 					"System specific reference type cant be used manually");
+		}
 		List<UserWalletHistory> userWalletHistoryList = userWalletHistoryRepository
 				.selectAllByreferenceIdandreferenceType(reference, referenceType);
 		UserWallet userWallet = userWalletRepository.selectByRetailerId(retailerId);
 		int walletId = userWallet.getId();
 		int walletAmount = walletService.getWalletAmount(retailerId);
 		int returnReference = 0;
 		UserWalletHistory newUserWalletHistory = new UserWalletHistory();
 		if (!userWalletHistoryList.isEmpty()) {
-			long validRetailerEntries = userWalletHistoryList.stream()
+			long validRetailerEntries = userWalletHistoryList.stream().filter(x -> x.getWalletId() == walletId).count();
-					.filter(x-> x.getWalletId() == walletId)
-					.count();
-			if(validRetailerEntries == 0) {
+			if (validRetailerEntries == 0) {
 				throw new ProfitMandiBusinessException("RefrenceId", reference,
 						"Reference Id assign to Other  partner");
+			}
+		}
 		if (TransactionType.DEBIT.equals(transactiontype)) {
 			amount = -amount;
+		}
 		userWallet.setAmount(walletAmount + amount);
 		newUserWalletHistory.setAmount(amount);
 		newUserWalletHistory.setBusinessTimestamp(businessTimestamp);
 		newUserWalletHistory.setDescription(description);
 		newUserWalletHistory.setReference(reference);

Subversion Repositories SmartDukaan

(root)/trunk/profitmandi-fofo/src/main/java/com/spice/profitmandi/web/controller/WalletController.java – Rev 27345 → 28515