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());
                                        
                                        sdCreditModel.setLoan(loans);
                                }
                                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);
                }

        }
}