Subversion Repositories SmartDukaan

package com.spice.profitmandi.web.controller;

import java.math.BigDecimal;

import java.time.LocalDate;

import java.time.LocalDateTime;

import java.util.ArrayList;

import java.util.List;

import java.util.Map;

import java.util.Map.Entry;

import java.util.Set;

import java.util.stream.Collectors;

import javax.servlet.http.HttpServletRequest;

import javax.transaction.Transactional;

import org.apache.logging.log4j.LogManager;

import org.apache.logging.log4j.Logger;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.http.MediaType;

import org.springframework.http.ResponseEntity;

import org.springframework.stereotype.Controller;

import org.springframework.web.bind.annotation.RequestMapping;

import org.springframework.web.bind.annotation.RequestMethod;

import org.springframework.web.bind.annotation.RequestParam;

import com.spice.profitmandi.common.exception.ProfitMandiBusinessException;

import com.spice.profitmandi.common.model.CustomRetailer;

import com.spice.profitmandi.common.web.util.ResponseSender;

import com.spice.profitmandi.dao.entity.auth.AuthUser;

import com.spice.profitmandi.dao.entity.dtr.CreditAccount;

import com.spice.profitmandi.dao.entity.transaction.Loan;

import com.spice.profitmandi.dao.entity.transaction.SDCreditRequirement;

import com.spice.profitmandi.dao.entity.transaction.SanctionRequest;

import com.spice.profitmandi.dao.enumuration.fofo.Gateway;

import com.spice.profitmandi.dao.enumuration.transaction.SanctionStatus;

import com.spice.profitmandi.dao.repository.auth.AuthRepository;

import com.spice.profitmandi.dao.repository.cs.CsService;

import com.spice.profitmandi.dao.repository.dtr.CreditAccountRepository;

import com.spice.profitmandi.dao.repository.dtr.FofoStoreRepository;

import com.spice.profitmandi.dao.repository.transaction.LoanRepository;

import com.spice.profitmandi.dao.repository.transaction.SDCreditRequirementRepository;

import com.spice.profitmandi.dao.repository.transaction.SanctionRequestRepository;

import com.spice.profitmandi.service.NotificationService;

import com.spice.profitmandi.service.transaction.SDCreditService;

import com.spice.profitmandi.service.user.RetailerService;

import com.spice.profitmandi.service.user.SDCreditModel;

import io.swagger.annotations.ApiImplicitParam;

import io.swagger.annotations.ApiImplicitParams;

@Controller

@Transactional(rollbackOn = Throwable.class)

public class SDCreditController {

	@Autowired

	private SDCreditRequirementRepository sdCreditRequirementRepository;

	@Autowired

	private RetailerService retailerService;

	@Autowired

	private AuthRepository authRepository;

	@Autowired

	private CsService csService;

	@Autowired

	private FofoStoreRepository fofoStoreRepository;

	@Autowired

	private SanctionRequestRepository sanctionRequestRepository;

	@Autowired

	private ResponseSender<?> responseSender;

	@Autowired

	private SDCreditService sdCreditService;

	@Autowired

	private CreditAccountRepository creditAccountRepository;

	@Autowired

	private LoanRepository loanRepository;

	@Autowired

	private NotificationService notificationService;

	private static final Logger LOGGER = LogManager.getLogger(SDCreditController.class);

	@RequestMapping(value = "/getSDCreditReq", method = RequestMethod.GET, produces = MediaType.APPLICATION_JSON_VALUE)

	@ApiImplicitParams({

			@ApiImplicitParam(name = "Auth-Token", value = "Auth-Token", required = true, dataType = "string", paramType = "header") })

	public ResponseEntity<?> getSDCreditReq(HttpServletRequest request, @RequestParam(name = "gmailId") String gmailId)

			throws ProfitMandiBusinessException {

		AuthUser authUser = authRepository.selectByGmailId(gmailId);

		Map<String, Set<Integer>> storeGuyMap = csService.getAuthUserPartnerIdMapping();

		List<Integer> fofoIds = new ArrayList<>(storeGuyMap.get(authUser.getEmailId()));

		List<SDCreditModel> partnersSDCredit = new ArrayList<>();

		if (fofoIds != null && fofoIds.size() > 0) {

			List<Integer> fofoIdList = fofoStoreRepository.selectByRetailerIds(fofoIds).stream()

					.filter(x -> !x.isInternal()).map(x -> x.getId()).collect(Collectors.toList());

			Map<Integer, CustomRetailer> customRetailerMap = retailerService.getAllFofoRetailers();

			Map<Integer, CustomRetailer> customRetailers = fofoIdList.stream().map(x -> customRetailerMap.get(x))

					.filter(x -> x != null).collect(Collectors.toList()).stream()

					.collect(Collectors.toMap(x -> x.getPartnerId(), x -> x));

			Map<Integer, SDCreditRequirement> sdCreditRequirementMap = sdCreditRequirementRepository.selectAll()

					.stream().collect(Collectors.toMap(x -> x.getFofoId(), x -> x));

			Map<Integer, SanctionRequest> sanctionRequestMap = sanctionRequestRepository.selectByDate(LocalDate.now())

					.stream().collect(Collectors.toMap(x -> x.getFofoId(), x -> x));

			for (Entry<Integer, CustomRetailer> customRetailerEntry : customRetailers.entrySet()) {

				int fofoId = customRetailerEntry.getKey();

				CustomRetailer customRetailer = customRetailerEntry.getValue();

				CreditAccount creditAccount = creditAccountRepository.selectByFofoIdAndGateway(fofoId,

						Gateway.SDDIRECT);

				SDCreditRequirement sdCreditRequirement = sdCreditRequirementMap.get(customRetailerEntry.getKey());

				SanctionRequest sanctionRequest = sanctionRequestMap.get(customRetailerEntry.getKey());

				SDCreditModel sdCreditModel = new SDCreditModel();

				sdCreditModel.setFofoId(fofoId);

				sdCreditModel.setBusinessName(customRetailer.getBusinessName());

				sdCreditModel.setMobile(customRetailer.getMobileNumber());

				if (sdCreditRequirement != null) {

					sdCreditModel.setLimit(sdCreditRequirement.getLimit());

					if (sdCreditRequirement.getSecurityCheck() > 0 && creditAccount.isActive()) {

						sdCreditModel.setEligibility("yes");

					} else {

						sdCreditModel.setEligibility("no");

					}

					sdCreditModel.setInterest(sdCreditRequirement.getInterestRate());

					long utilizationAmount = sdCreditService.getUtilizationAmount(fofoId);

					sdCreditModel.setAvailability(

							sdCreditRequirement.getLimit().subtract(new BigDecimal(utilizationAmount)));

					sdCreditModel.setRisk(sdCreditModel.getRisk());

					sdCreditModel.setCreditDuration(sdCreditRequirement.getCreditDays());

					List<Loan> loans = loanRepository.selectActiveLoan(fofoId);

					sdCreditModel.setTotalOpenLoan(loans.size());

				}

				if (sanctionRequest != null) {

					sdCreditModel.setStatus(sanctionRequest.getStatus());

				}

				partnersSDCredit.add(sdCreditModel);

			}

		}

		return responseSender.ok(partnersSDCredit);

	}

	@RequestMapping(value = "/createSanctionRequest", method = RequestMethod.POST, produces = MediaType.APPLICATION_JSON_VALUE)

	@ApiImplicitParams({

			@ApiImplicitParam(name = "Auth-Token", value = "Auth-Token", required = true, dataType = "string", paramType = "header") })

	public ResponseEntity<?> createSanctionRequest(HttpServletRequest request,

			@RequestParam(name = "gmailId") String gmailId, @RequestParam(name = "fofoId") int fofoId,

			@RequestParam(name = "requestedlimit") int requestedlimit) throws ProfitMandiBusinessException {

		SDCreditRequirement sdCreditReq = sdCreditRequirementRepository.selectByFofoId(fofoId);

		if (sdCreditReq != null) {

			AuthUser authUser = authRepository.selectByGmailId(gmailId);

			SanctionRequest sanctionRequest = new SanctionRequest();

			sanctionRequest.setAuthId(authUser.getId());

			sanctionRequest.setFofoId(fofoId);

			sanctionRequest.setRequestedAmount(BigDecimal.valueOf(requestedlimit));

			sanctionRequest.setApprovalAmount(BigDecimal.valueOf(requestedlimit));

			sanctionRequest.setCreatedTimestamp(LocalDateTime.now());

			sanctionRequest.setStatus(SanctionStatus.PENDING);

			sanctionRequest.setFreeDays(sdCreditReq.getFreeDays());

			sanctionRequestRepository.persist(sanctionRequest);

			return responseSender.ok(true);

		} else {

			return responseSender.ok(false);

		}

	}

}