Subversion Repositories SmartDukaan

package com.spice.profitmandi.dao.repository.cs;
import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import org.apache.commons.lang.RandomStringUtils;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.mail.javamail.JavaMailSender;
import org.springframework.stereotype.Component;
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.Activity;
import com.spice.profitmandi.dao.entity.cs.PartnerRegion;
import com.spice.profitmandi.dao.entity.cs.Position;
import com.spice.profitmandi.dao.entity.cs.Region;
import com.spice.profitmandi.dao.entity.cs.Ticket;
import com.spice.profitmandi.dao.entity.cs.TicketCategory;
import com.spice.profitmandi.dao.entity.cs.TicketSubCategory;
import com.spice.profitmandi.dao.entity.fofo.ActivityType;
import com.spice.profitmandi.dao.enumuration.cs.EscalationType;
import com.spice.profitmandi.dao.repository.auth.AuthRepository;
import com.spice.profitmandi.service.user.RetailerService;

@Component
public class CsServiceImpl implements CsService {

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

        private static final String ASSIGNED_TICKET = "Dear %s,You have assigned a ticket by %s. Regards\nSmartdukaan";
        private static final String ASSINMENT_SUBJECT = "Assignment Ticket";

        @Autowired
        TicketRepository ticketRepository;

        @Autowired
        JavaMailSender mailSender;

        @Autowired
        TicketCategoryRepository ticketCategoryRepository;

        @Autowired
        TicketSubCategoryRepository ticketSubCategoryRepository;

        @Autowired
        ActivityRepository activityRepository;

        @Autowired
        PartnerRegionRepository partnerRegionRepository;

        @Autowired
        private PositionRepository positionRepository;

        @Autowired
        private AuthRepository authRepository;

        @Autowired
        private RetailerService retailerService;
        
        @Autowired
        private RegionRepository regionRepository;

        @Override
        public void createTicket(int fofoId, int categoryId, int subcategoryId, String message)
                        throws ProfitMandiBusinessException {

                ActivityType type = ActivityType.OPENED;
                EscalationType escalationTypeL1 = EscalationType.L1;
                EscalationType escalationTypeL2 = EscalationType.L2;
                EscalationType escalationTypeL3 = EscalationType.L3;
                Ticket ticket = new Ticket();
                ticket.setSubCategoryId(subcategoryId);
                ticket.setFofoId(fofoId);
                ticket.setCreateTimestamp(LocalDateTime.now());
                ticket.setUpdateTimestamp(LocalDateTime.now());
                ticket.setL2EscalationTimestamp(ticket.getUpdateTimestamp().plusDays(2));
                ticket.setL3EscalationTimestamp(ticket.getL2EscalationTimestamp().plusDays(2));
                ticket.setLastEscalationTimestamp(ticket.getL3EscalationTimestamp().plusDays(2));
                ticket.setHappyCode(getRandomString());
                int l3Auth = this.getAuthUserId(categoryId, escalationTypeL3, fofoId);
                int l1Auth = this.getAuthUserId(categoryId, escalationTypeL1, fofoId);
                int l2Auth = this.getAuthUserId(categoryId, escalationTypeL2, fofoId);
                LOGGER.info(l1Auth + "-" + l2Auth + "-" + l3Auth);
                if (l1Auth == 0) {
                        if (l2Auth == 0) {
                                this.setAssignment(ticket);
                        } else {
                                ticket.setAssigneeId(l2Auth);
                        }
                } else {
                        ticket.setAssigneeId(l1Auth);
                        ticket.setL1AuthUser(l1Auth);
                        ticket.setL2AuthUser(l2Auth);
                }
                ticket.setL3AuthUser(l3Auth);
                ticketRepository.persist(ticket);
                AuthUser authUser = authRepository.selectById(ticket.getAssigneeId());
                try {
                        Utils.sendMailWithAttachments(mailSender, authUser.getEmailId(), null, ASSINMENT_SUBJECT,
                                        String.format(ASSIGNED_TICKET, authUser.getFirstName(),
                                                        retailerService.getFofoRetailer(fofoId).getBusinessName()),
                                        null);
                } catch (Exception e) {
                        throw new ProfitMandiBusinessException("Ticket Assingment", authUser.getEmailId(),
                                        "Could not send ticket assignment mail");
                }
                Activity activity = this.createActivity(type, message, 0);
                this.addActivity(ticket.getId(), activity);
        }

        private Activity createActivity(ActivityType activityType, String message, int createdBy) {
                Activity activity = new Activity();
                activity.setMessage(message);
                activity.setCreatedBy(createdBy);
                activity.setType(activityType);
                activity.setCreateTimestamp(LocalDateTime.now());
                return activity;
        }

        private int getAuthUserId(int categoryId, EscalationType escalationType, int fofoId) {

                List<Position> positions = null;
                if (escalationType == EscalationType.L3) {
                        positions = positionRepository.selectPositionbyCategoryIdAndEscalationType(0, escalationType, 0);
                } else {
                        List<PartnerRegion> regions = partnerRegionRepository.selectByfofoId(fofoId);
                        LOGGER.info("regions=" + regions);
                        if(regions.size()==0)
                        {
                                regions=partnerRegionRepository.selectByfofoId(0);
                                LOGGER.info("regions=" + regions);
                        }
                        for (PartnerRegion region : regions) {
                                positions = positionRepository.selectPositionbyCategoryIdAndEscalationType(categoryId, escalationType,
                                                region.getRegionId());
                                LOGGER.info("positions:-" + positions);
                                if (positions != null) {
                                        break;
                                }

                        }
                        if (positions.size() == 0) {
                                return 0;
                        }
                }
                return positions.get(0).getAuthUserId();
                /*
                 * if(ActivityType.escalationTypes.contains(escalationType)) {
                 * //escalationMatrix } else { throw new
                 * ProfitMandiBusinessException("SubCategory", subcategoryId,
                 * "Could not find Assignee for "); }
                 */

        }

        @Override
        public void addActivity(int ticketId, Activity activity) {
                activity.setTicketId(ticketId);
                activityRepository.persist(activity);
        }

        private String getRandomString() {
                int length = 4;
                boolean useLetters = false;
                boolean useNumbers = true;
                String generatedString = RandomStringUtils.random(length, useLetters, useNumbers);
                return generatedString;
        }

        @Override
        public void addPartnerToRegion(int regionId, List<Integer> fofoIds) {

                for (Integer fofoId : fofoIds) {
                        PartnerRegion partnerRegion = partnerRegionRepository.selectByRegionIdAndFofoId(regionId, fofoId);
                        if (partnerRegion == null) {
                                partnerRegion = new PartnerRegion();
                                partnerRegion.setFofoId(fofoId);
                                partnerRegion.setRegionId(regionId);
                                partnerRegionRepository.persist(partnerRegion);
                        } else {
                                continue;
                        }
                }
        }

        @Override
        public Map<Integer, AuthUser> getAuthUserIdAndAuthUserMap(List<Ticket> tickets) {
                Map<Integer, AuthUser> authUserIdAndAuthUserMap = new HashMap<>();
                for (Ticket ticket : tickets) {
                        AuthUser authUser = authRepository.selectById(ticket.getAssigneeId());
                        authUserIdAndAuthUserMap.put(ticket.getAssigneeId(), authUser);
                }
                return authUserIdAndAuthUserMap;
        }

        @Override
        public Map<Integer, TicketSubCategory> getSubCategoryIdAndSubCategoryMap(List<Ticket> tickets) {
                Map<Integer, TicketSubCategory> subCategoryIdAndSubCategoryMap = new HashMap<>();
                for (Ticket ticket : tickets) {
                        TicketSubCategory ticketSubCategory = ticketSubCategoryRepository.selectById(ticket.getSubCategoryId());
                        subCategoryIdAndSubCategoryMap.put(ticket.getSubCategoryId(), ticketSubCategory);
                }
                return subCategoryIdAndSubCategoryMap;
        }

        @Override
        public Map<Integer, CustomRetailer> getPartnerByFofoIds(List<Ticket> tickets) {
                List<Integer> fofoIds = new ArrayList<>();
                for (Ticket ticket : tickets) {
                        fofoIds.add(ticket.getFofoId());
                }
                Map<Integer, CustomRetailer> fofoIdsAndCustomRetailer = retailerService.getFofoRetailers(fofoIds);
                return fofoIdsAndCustomRetailer;
        }

        @Override
        public List<TicketCategory> getAllTicketCategotyFromSubCategory() {

                List<TicketSubCategory> ticketSubCategories = ticketSubCategoryRepository.selectAll();
                HashSet<Integer> categoryIds = new HashSet<>();
                for (TicketSubCategory ticketSubcategory : ticketSubCategories) {
                        categoryIds.add(ticketSubcategory.getcategoryId());
                }
                List<TicketCategory> ticketcategories = ticketCategoryRepository.selectAll(new ArrayList<>(categoryIds));
                return ticketcategories;
        }

        private Ticket setAssignment(Ticket ticket) {
                TicketCategory ticketCategory = ticketCategoryRepository.selectByName(ProfitMandiConstants.CRM);
                List<Position> positions = positionRepository.selectPositionByCategoryId(ticketCategory.getId());
                for (Position position : positions) {
                        if (position.getEscalationType().equals(EscalationType.L1)) {
                                ticket.setAssigneeId(position.getAuthUserId());
                                ticket.setL1AuthUser(position.getAuthUserId());
                        } else {
                                ticket.setL2AuthUser(position.getAuthUserId());
                        }
                }
                return ticket;
        }
        
        @Override
        public Map<Integer, AuthUser> getAuthUserIdAndAuthUserMapUsingPositions(List<Position> positions) {
                Map<Integer, AuthUser> authUserIdAndAuthUserMap = new HashMap<>();
                for (Position position : positions) {
                        AuthUser authUser = authRepository.selectById(position.getAuthUserId());
                        authUserIdAndAuthUserMap.put(position.getAuthUserId(), authUser);
                }
                return authUserIdAndAuthUserMap;
        }
        
        @Override
        public Map<Integer, TicketCategory> getCategoryIdAndCategoryUsingPositions(List<Position> positions) {
                Map<Integer, TicketCategory> categoryIdAndCategoryMap = new HashMap<>();
                for (Position position : positions) {
                        TicketCategory ticketCategory=ticketCategoryRepository.selectById(position.getCategoryId());
                        categoryIdAndCategoryMap.put(position.getCategoryId(), ticketCategory);
                }
                return categoryIdAndCategoryMap;
        }

        @Override
        public Map<Integer, Region> getRegionIdAndRegionMap(List<Position> positions) {
                Map<Integer, Region> regionIdAndRegionMap = new HashMap<>();
                for (Position position : positions) {
                        Region region=regionRepository.selectById(position.getRegionId());
                        regionIdAndRegionMap.put(position.getRegionId(), region);
                }
                return regionIdAndRegionMap;
        }
        
}