Subversion Repositories SmartDukaan

package com.spice.profitmandi.service.user;

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

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

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

import com.spice.profitmandi.common.util.Utils;

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

import com.spice.profitmandi.dao.entity.cs.Position;

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

import com.spice.profitmandi.dao.entity.fofo.FofoStore;

import com.spice.profitmandi.dao.entity.fofo.StoreClosure;

import com.spice.profitmandi.dao.enumuration.cs.EscalationType;

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

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

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

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

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

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

import com.spice.profitmandi.dao.repository.fofo.StoreClosureRepository;

import com.spice.profitmandi.service.mail.MailOutboxService;

import org.apache.logging.log4j.LogManager;

import org.apache.logging.log4j.Logger;

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

import org.springframework.core.io.FileSystemResource;

import org.springframework.stereotype.Service;

import java.io.File;

import java.time.LocalDateTime;

import java.time.format.DateTimeFormatter;

import java.util.*;

import java.util.stream.Collectors;

/**

 * Permanent partner store closure. A closure needs a reason, a remark and the approval mail

 * (uploaded via /document-upload), and queues a closure report with the approval attached to the partner's

 * Sales L2, the top three Sales levels, the top Accounts level and the closer.

 */

@Service

public class StoreClosureService {

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

	private static final DateTimeFormatter REPORT_TIME_FORMAT = DateTimeFormatter.ofPattern("dd-MMM-yyyy hh:mm a");

	@Autowired

	private FofoStoreRepository fofoStoreRepository;

	@Autowired

	private StoreClosureRepository storeClosureRepository;

	@Autowired

	private DocumentRepository documentRepository;

	@Autowired

	private PositionRepository positionRepository;

	@Autowired

	private AuthRepository authRepository;

	@Autowired

	private CsService csService;

	@Autowired

	private RetailerService retailerService;

	@Autowired

	private MailOutboxService mailOutboxService;

	public void closeStore(int fofoId, String storeCode, StoreClosureReason reason, String remark,

						   int approvalDocumentId, String closedBy) throws ProfitMandiBusinessException {

		StoreAccess.check(StoreAccess.CLOSE, closedBy, "close store");

		FofoStore fofoStore = fofoStoreRepository.selectByRetailerId(fofoId);

		if (fofoStore.isClosed()) {

			throw new ProfitMandiBusinessException("Store Closed", "Store Already Closed",

					"This store is already permanently closed");

		}

		if (storeCode == null || !storeCode.equals(fofoStore.getCode())) {

			throw new ProfitMandiBusinessException("Invalid Store Code", "Store Code Mismatch",

					"Please type the correct store code to confirm closure");

		}

		if (reason == null) {

			throw new ProfitMandiBusinessException("Closure Reason", "Reason Missing",

					"Please select the reason for closing the store");

		}

		if (remark == null || remark.trim().isEmpty()) {

			throw new ProfitMandiBusinessException("Closure Remark", "Remark Missing",

					"Please describe why the store is being closed");

		}

		if (remark.trim().length() > 1000) {

			throw new ProfitMandiBusinessException("Closure Remark", "Remark Too Long",

					"Please keep the remark within 1000 characters");

		}

		Document approvalDocument = approvalDocumentId > 0 ? documentRepository.selectById(approvalDocumentId) : null;

		if (approvalDocument == null) {

			throw new ProfitMandiBusinessException("Approval Mail", "Approval Missing",

					"Please attach the approval mail for this closure");

		}

		File approvalFile = new File(approvalDocument.getPath(), approvalDocument.getName());

		if (!approvalFile.isFile()) {

			throw new ProfitMandiBusinessException("Approval Mail", "Approval File Missing",

					"The uploaded approval mail could not be found, please upload it again");

		}

		LocalDateTime now = LocalDateTime.now();

		fofoStore.setActive(false);

		fofoStore.setClosed(true);

		fofoStore.setClosedTimestamp(now);

		StoreClosure storeClosure = new StoreClosure();

		storeClosure.setFofoId(fofoId);

		storeClosure.setReason(reason);

		storeClosure.setRemark(remark.trim());

		storeClosure.setApprovalDocumentId(approvalDocumentId);

		storeClosure.setClosedBy(closedBy);

		storeClosure.setCreateTimestamp(now);

		storeClosureRepository.persist(storeClosure);

		LOGGER.info("Store {} closed permanently by {} - {}", fofoStore.getCode(), closedBy, storeClosure);

		sendClosureReport(fofoStore, storeClosure, approvalDocument, approvalFile);

	}

	private void sendClosureReport(FofoStore fofoStore, StoreClosure storeClosure, Document approvalDocument,

								   File approvalFile) throws ProfitMandiBusinessException {

		CustomRetailer retailer = retailerService.getFofoRetailer(fofoStore.getId());

		List<AuthUser> salesL2 = csService.getAuthUsersByPartnerIdAndCategory(fofoStore.getId(),

				ProfitMandiConstants.TICKET_CATEGORY_SALES, EscalationType.L2);

		Set<String> recipients = new LinkedHashSet<>();

		salesL2.stream().map(AuthUser::getEmailId).filter(Objects::nonNull).forEach(recipients::add);

		recipients.addAll(topLevelEmails(ProfitMandiConstants.TICKET_CATEGORY_SALES, 3));

		recipients.addAll(topLevelEmails(ProfitMandiConstants.TICKET_CATEGORY_ACCOUNTS, 1));

		recipients.add(storeClosure.getClosedBy());

		String businessName = retailer.getBusinessName();

		String city = retailer.getAddress() == null ? "-" : retailer.getAddress().getCity() + ", " + retailer.getAddress().getState();

		String subject = "Store Closure Report - " + fofoStore.getCode() + " - " + businessName;

		StringBuilder body = new StringBuilder();

		body.append("Dear Team,\n\nThe following partner store has been permanently closed.\n\n");

		body.append("Partner       : ").append(businessName).append(" (Partner Id ").append(fofoStore.getId()).append(")\n");

		body.append("Store Code    : ").append(fofoStore.getCode()).append("\n");

		body.append("GSTIN         : ").append(Optional.ofNullable(retailer.getGstNumber()).orElse("-")).append("\n");

		body.append("Location      : ").append(city).append("\n");

		body.append("Sales L2      : ").append(salesL2.isEmpty() ? "-" :

				salesL2.stream().map(AuthUser::getFullName).collect(Collectors.joining(", "))).append("\n");

		body.append("Closed By     : ").append(storeClosure.getClosedBy()).append("\n");

		body.append("Closed On     : ").append(storeClosure.getCreateTimestamp().format(REPORT_TIME_FORMAT)).append("\n");

		body.append("Reason        : ").append(storeClosure.getReason().getLabel()).append("\n");

		body.append("Remark        : ").append(storeClosure.getRemark()).append("\n\n");

		body.append("The approval mail for this closure is attached.\n\nRegards,\nSmartDukaan");

		String attachmentName = approvalDocument.getDisplayName() != null ? approvalDocument.getDisplayName() : approvalDocument.getName();

		mailOutboxService.queueMailWithAttachments(recipients.toArray(new String[0]), null, subject, body.toString(),

				"StoreClosureService.sendClosureReport", new Utils.Attachment(attachmentName, new FileSystemResource(approvalFile)));

	}

	/**

	 * Emails of active auth users holding the highest {@code levels} distinct escalation levels held by active users

	 * in a position category, resolved live so role changes in cs.position flow through without a code change.

	 */

	private Set<String> topLevelEmails(int categoryId, int levels) {

		List<Position> positions = positionRepository.selectPositionByCategoryId(categoryId).stream()

				.filter(x -> x.getAuthUserId() > 0 && x.getEscalationType() != null).collect(Collectors.toList());

		if (positions.isEmpty()) {

			return new HashSet<>();

		}

		Map<Integer, AuthUser> activeUsers = authRepository.selectByIds(positions.stream().map(Position::getAuthUserId)

						.distinct().collect(Collectors.toList())).stream().filter(x -> Boolean.TRUE.equals(x.getActive()))

				.collect(Collectors.toMap(AuthUser::getId, x -> x));

		List<Position> activePositions = positions.stream().filter(x -> activeUsers.containsKey(x.getAuthUserId()))

				.collect(Collectors.toList());

		List<EscalationType> topLevels = activePositions.stream().map(Position::getEscalationType).distinct()

				.sorted(Comparator.reverseOrder()).limit(levels).collect(Collectors.toList());

		return activePositions.stream().filter(x -> topLevels.contains(x.getEscalationType()))

				.map(x -> activeUsers.get(x.getAuthUserId()).getEmailId()).filter(Objects::nonNull)

				.map(String::toLowerCase).collect(Collectors.toSet());

	}

}