Subversion Repositories SmartDukaan

package com.spice.profitmandi.web.controller;

import com.spice.profitmandi.common.exception.ProfitMandiBusinessException;
import com.spice.profitmandi.common.model.CustomRetailer;
import com.spice.profitmandi.common.util.Utils;
import com.spice.profitmandi.dao.entity.auth.AuthUser;
import com.spice.profitmandi.dao.entity.cs.*;
import com.spice.profitmandi.dao.entity.dtr.Document;
import com.spice.profitmandi.dao.entity.fofo.ActivityType;
import com.spice.profitmandi.dao.enumuration.cs.EscalationType;
import com.spice.profitmandi.dao.enumuration.cs.TicketStatus;
import com.spice.profitmandi.dao.model.CreatePositionModel;
import com.spice.profitmandi.dao.repository.auth.AuthRepository;
import com.spice.profitmandi.dao.repository.cs.*;
import com.spice.profitmandi.dao.repository.dtr.DocumentRepository;
import com.spice.profitmandi.dao.repository.dtr.FofoStoreRepository;
import com.spice.profitmandi.service.authentication.RoleManager;
import com.spice.profitmandi.service.user.RetailerService;
import com.spice.profitmandi.web.model.LoginDetails;
import com.spice.profitmandi.web.util.CookiesProcessor;
import com.spice.profitmandi.web.util.MVCResponseSender;
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.Controller;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.*;

import javax.servlet.http.HttpServletRequest;
import javax.swing.*;
import java.time.LocalDateTime;
import java.util.*;
import java.util.stream.Collectors;

@Controller
@Transactional(rollbackFor = Throwable.class)
public class CsController {

        private static final Logger LOGGER = LogManager.getLogger(CsController.class);
        private static final String ACTIVITY_SUBJECT = "Message related ticketId#%s";
        private static final String PARTNER_RESOLVED_TICKET_MAIL = "Dear Partner , we have resolved your ticket # %s , request to kindly accept the same. In case you still have any concerns regarding the same pls click on %s so that we can help you.Regards\nSmartdukaan";
        private static final String PARTNER_REOPEN = "Dear Partner , Your ticket # %s has been re-opened as per your confirmation & we are committed to resolve it on priority.Regards\nSmartdukaan";
        private static final String INTERNAL_REOPEN_MAIL = "Team, Pls note that the Ticket Id %s has been re-opened by %s , pls respond on priority";
        private static final String INTERNAL_REOPEN_ACTIVITY_MESSAGE = "Hi,My ticket is not resolved yet,so I have reopened it";

        @Autowired
        JavaMailSender mailSender;

        @Autowired
        private CsService csService;

        @Autowired
        private CookiesProcessor cookiesProcessor;

        @Autowired
        private TicketCategoryRepository ticketCategoryRepository;

        @Autowired
        private TicketSubCategoryRepository ticketSubCategoryRepository;

        @Autowired
        private RegionRepository regionRepository;

        @Autowired
        private RetailerService retailerService;

        @Autowired
        private MVCResponseSender mvcResponseSender;

        @Autowired
        private AuthRepository authRepository;

        @Autowired
        private PositionRepository positionRepository;

        @Autowired
        private TicketRepository ticketRepository;

        @Autowired
        private RoleManager roleManager;

        @Autowired
        private ActivityRepository activityRepository;

        @Autowired
        private ActivityAttachmentRepository activityAttachmentRepository;

        @Autowired
        private TicketAssignedRepository ticketAssignedRepository;

        @Autowired
        private PartnerRegionRepository partnerRegionRepository;

        @Autowired
        PartnersPositionRepository partnersPositionRepository;

        @Autowired
        FofoStoreRepository fofoStoreRepository;

        @Autowired
        DocumentRepository documentRepository;

        @GetMapping(value = "/cs/createCategory")
        public String getCreateCategory(HttpServletRequest request, Model model) {
                List<TicketCategory> ticketCategories = ticketCategoryRepository.selectAll();
                model.addAttribute("ticketCategories", ticketCategories);
                return "create-ticket-category";
        }

        @PostMapping(value = "/cs/createCategory")
        public String createCategory(HttpServletRequest request, @RequestParam(name = "name") String name,
                        @RequestParam(name = "description") String description, Model model) throws ProfitMandiBusinessException {

                TicketCategory ticketCategory = ticketCategoryRepository.selectByName(name);
                if (ticketCategory != null) {
                        throw new ProfitMandiBusinessException("name", name, "already exists!");
                }
                ticketCategory = new TicketCategory();
                ticketCategory.setName(name);
                ticketCategory.setDescription(description);
                ticketCategoryRepository.persist(ticketCategory);
                return "create-ticket-category";
        }

        @GetMapping(value = "/cs/createSubCategory")
        public String getCreateSubCategory(HttpServletRequest request, Model model) {
                List<TicketCategory> ticketCategories = ticketCategoryRepository.selectAll();
                model.addAttribute("ticketCategories", ticketCategories);
                return "create-ticket-sub-category";
        }

        @GetMapping(value = "/cs/getSubCategoryByCategoryId")
        public String getSubCategoryByCategoryId(HttpServletRequest request,
                        @RequestParam(name = "ticketCategoryId", defaultValue = "") int ticketCategoryId, Model model) {
                List<TicketSubCategory> ticketSubCategories = ticketSubCategoryRepository.selectAll(ticketCategoryId);
                TicketCategory ticketCategory = ticketCategoryRepository.selectById(ticketCategoryId);
                model.addAttribute("ticketSubCategories", ticketSubCategories);
                model.addAttribute("ticketCategory", ticketCategory);
                return "ticket-sub-category";
        }

        @PostMapping(value = "/cs/createSubCategory")
        public String createSubCategory(HttpServletRequest request,
                        @RequestParam(name = "categoryId", defaultValue = "0") int categoryId,
                        @RequestParam(name = "name") String name, @RequestParam(name = "description") String description,
                        Model model) throws ProfitMandiBusinessException {

                TicketSubCategory ticketSubCategory = ticketSubCategoryRepository.selectTicketSubCategory(categoryId, name);
                if (ticketSubCategory != null) {
                        throw new ProfitMandiBusinessException("name & categoryId", name + "  " + categoryId, "already exists!");
                }

                ticketSubCategory = new TicketSubCategory();
                ticketSubCategory.setCategoryId(categoryId);
                ticketSubCategory.setName(name);
                ticketSubCategory.setDescription(description);
                ticketSubCategoryRepository.persist(ticketSubCategory);
                return "create-ticket-sub-category";
        }

        @GetMapping(value = "/cs/createRegion")
        public String createRegion(HttpServletRequest request, Model model) {
                List<Region> regions = regionRepository.selectAll();
                model.addAttribute("regions", regions);
                return "create-region";
        }

        @PostMapping(value = "/cs/createRegion")
        public String createRegion(HttpServletRequest request, @RequestParam(name = "name") String name,
                        @RequestParam(name = "description") String description, Model model) throws Exception {
                Region region = regionRepository.selectByName(name);
                if (region != null) {
                        throw new ProfitMandiBusinessException("name", name, "already exists!");
                }
                region = new Region();
                region.setName(name);
                region.setDescription(description);
                regionRepository.persist(region);
                model.addAttribute("response1", mvcResponseSender.createResponseString(true));
                return "response";
        }

        @GetMapping(value = "/cs/getPartners")
        public String getPartners(HttpServletRequest request,
                        @RequestParam(name = "regionId", defaultValue = "0") int regionId, Model model) {
                List<Integer> fofoIds = fofoStoreRepository.selectAll().stream().map(x -> x.getId())
                                .collect(Collectors.toList());
                List<Integer> addedfofoIds = partnerRegionRepository.selectByRegionId(regionId).stream().map(x -> x.getFofoId())
                                .collect(Collectors.toList());

                Map<Integer, CustomRetailer> customRetailerMap = retailerService.getAllFofoRetailers();
                Map<Integer, CustomRetailer> fofoRetailers = fofoIds.stream().map(x -> customRetailerMap.get(x))
                                .filter(x -> x != null).collect(Collectors.toList()).stream()
                                .collect(Collectors.toMap(x -> x.getPartnerId(), x -> x));
                model.addAttribute("fofoRetailers", fofoRetailers);
                model.addAttribute("addedfofoIds", addedfofoIds);
                return "added-region-partners";
        }

        @GetMapping(value = "/cs/getPartnersByRegion")
        public String getPartnersByRegion(HttpServletRequest request,
                        @RequestParam(name = "regionId", defaultValue = "0") int regionId, Model model) {
                List<Integer> fofoIds = null;
                fofoIds = partnerRegionRepository.selectByRegionId(regionId).stream().map(x -> x.getFofoId())
                                .collect(Collectors.toList());

                if (fofoIds.contains(0)) {
                        fofoIds = fofoStoreRepository.selectAll().stream().filter(x -> x.isActive()).collect(Collectors.toList())
                                        .stream().map(x -> x.getId()).collect(Collectors.toList());

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

                Map<Integer, CustomRetailer> fofoRetailers = fofoIds.stream().map(x -> customRetailerMap.get(x))
                                .filter(x -> x != null).collect(Collectors.toList()).stream()
                                .collect(Collectors.toMap(x -> x.getPartnerId(), x -> x));
                model.addAttribute("fofoRetailers", fofoRetailers);
                return "added-subregion-partners";
        }

        @GetMapping(value = "/cs/createPartnerRegion")
        public String createPartnerRegion(HttpServletRequest request, Model model) {
                List<Region> regions = regionRepository.selectAll();
                model.addAttribute("regions", regions);
                return "create-partner-region";
        }

        @PostMapping(value = "/cs/createPartnerRegion")
        public String createPartnerRegion(HttpServletRequest request, @RequestParam(name = "regionId") int regionId,
                        @RequestBody List<Integer> selectedFofoIds, Model model) throws Exception {
                partnerRegionRepository.delete(regionId);
                LOGGER.info("successfully removed");
                LOGGER.info(selectedFofoIds.size());
                csService.addPartnerToRegion(regionId, selectedFofoIds);
                model.addAttribute("response1", mvcResponseSender.createResponseString(true));
                return "response";
        }

        @GetMapping(value = "/cs/getPosition")
        public String getPosition(HttpServletRequest request, @RequestParam int positionId, Model model) {

                Position position = positionRepository.selectById(positionId);

                List<CustomRetailer> positionIdCustomRetailer = csService.getPositionCustomRetailerMap(Arrays.asList(position))
                                .get(position.getId());

                Map<Integer, CustomRetailer> regionRetailerMap = csService.getRegionPartners(Arrays.asList(position))
                                .get(position.getRegionId()).stream().collect(Collectors.toMap(x -> x.getPartnerId(), x -> x));

                model.addAttribute("position", position);
                model.addAttribute("regionRetailerMap", regionRetailerMap);
                model.addAttribute("positionIdCustomRetailer", positionIdCustomRetailer);

                return "position-partner";
        }

        @GetMapping(value = "/cs/createPosition")
        public String createPosition(HttpServletRequest request,
                        @RequestParam(name = "offset", defaultValue = "0") int offset,
                        @RequestParam(name = "limit", defaultValue = "10") int limit, Model model) {
                List<AuthUser> authUsers = authRepository.selectAllActiveUser();
                List<TicketCategory> ticketCategories = ticketCategoryRepository.selectAll();
                List<Region> regions = regionRepository.selectAll();
                model.addAttribute("escalationTypes", EscalationType.values());
                model.addAttribute("authUsers", authUsers);
                model.addAttribute("ticketCategories", ticketCategories);
                model.addAttribute("regions", regions);

                List<Position> positions = positionRepository.selectAllPosition();
                LOGGER.info("positions" + positions);

                Map<Integer, AuthUser> authUserIdAndAuthUserMap = csService
                                .getAuthUserIdAndAuthUserMapUsingPositions(positions);
                Map<Integer, TicketCategory> categoryIdAndCategoryMap = csService
                                .getCategoryIdAndCategoryUsingPositions(positions);
                Map<Integer, Region> regionIdAndRegionMap = csService.getRegionIdAndRegionMap(positions);

//          Map<Integer, List<CustomRetailer>> positionIdAndpartnerRegionMap = csService
//                      .getpositionIdAndpartnerRegionMap(positions);

//           Map<Integer, List<CustomRetailer>> addedpositionIdAndCustomRetailerMap = csService
//                              .getPositionCustomRetailerMap(positions);
//              LOGGER.info("fofoIdAndCustomRetailerMap" + addedpositionIdAndCustomRetailerMap);

                model.addAttribute("start", offset + 1);

                model.addAttribute("positions", positions);
                model.addAttribute("authUserIdAndAuthUserMap", authUserIdAndAuthUserMap);
                model.addAttribute("categoryIdAndCategoryMap", categoryIdAndCategoryMap);
                model.addAttribute("regionIdAndRegionMap", regionIdAndRegionMap);
                // model.addAttribute("positionIdAndCustomRetailerMap",
                // addedpositionIdAndCustomRetailerMap);
                // model.addAttribute("positionIdAndpartnerRegionMap",
// positionIdAndpartnerRegionMap);

                return "create-position";
        }

        @GetMapping(value = "/cs/position-paginated")
        public String positionPaginated(HttpServletRequest request,
                        @RequestParam(name = "offset", defaultValue = "0") int offset,
                        @RequestParam(name = "limit", defaultValue = "10") int limit, Model model) {

                List<Position> positions = positionRepository.selectAll(offset, limit);
                Map<Integer, AuthUser> authUserIdAndAuthUserMap = csService
                                .getAuthUserIdAndAuthUserMapUsingPositions(positions);
                Map<Integer, TicketCategory> categoryIdAndCategoryMap = csService
                                .getCategoryIdAndCategoryUsingPositions(positions);
                Map<Integer, Region> regionIdAndRegionMap = csService.getRegionIdAndRegionMap(positions);
                /*
                 * Map<Integer, List<CustomRetailer>> positionIdAndpartnerRegionMap = csService
                 * .getpositionIdAndpartnerRegionMap(positions);
                 * 
                 * Map<Integer, List<CustomRetailer>> addedpositionIdAndCustomRetailerMap =
                 * csService .getPositionCustomRetailerMap(positions);
                 */

                model.addAttribute("positions", positions);
                model.addAttribute("authUserIdAndAuthUserMap", authUserIdAndAuthUserMap);
                model.addAttribute("categoryIdAndCategoryMap", categoryIdAndCategoryMap);
                model.addAttribute("regionIdAndRegionMap", regionIdAndRegionMap);
                // model.addAttribute("positionIdAndCustomRetailerMap",
                // addedpositionIdAndCustomRetailerMap);
                // model.addAttribute("positionIdAndpartnerRegionMap",
                // positionIdAndpartnerRegionMap);

                return "position-paginated";
        }

        @PostMapping(value = "/cs/createPosition")
        public String createPosition(HttpServletRequest request, @RequestBody CreatePositionModel createPositionModel,
                        Model model) throws Exception {

                Position position = positionRepository.selectPosition(createPositionModel.getAuthUserId(),
                                createPositionModel.getCategoryId(), createPositionModel.getRegionId(),
                                createPositionModel.getEscalationType());
                if (position == null) {
                        position = new Position();
                        position.setAuthUserId(createPositionModel.getAuthUserId());
                        position.setCategoryId(createPositionModel.getCategoryId());
                        position.setEscalationType(createPositionModel.getEscalationType());
                        position.setRegionId(createPositionModel.getRegionId());
                        position.setCreateTimestamp(LocalDateTime.now());
                        positionRepository.persist(position);

                        for (int fofoId : createPositionModel.getFofoIds()) {

                                PartnerPosition partnerPosition = new PartnerPosition();
                                partnerPosition.setFofoId(fofoId);
                                partnerPosition.setRegionId(createPositionModel.getRegionId());
                                partnerPosition.setPositionId(position.getId());
                                partnersPositionRepository.persist(partnerPosition);
                                LOGGER.info("partnerPosition" + partnerPosition);
                        }

                        model.addAttribute("response1", mvcResponseSender.createResponseString(true));
                } else {
                        throw new ProfitMandiBusinessException("Position", createPositionModel.getAuthUserId(), "already exists!");
                }
                return "response";
        }

        @PostMapping(value = "/cs/updatePartnerPosition")
        public String updatePartnerPosition(HttpServletRequest request, @RequestParam(name = "regionId") int regionId,
                        @RequestBody List<Integer> selectedFofoIds, @RequestParam(name = "positionId") int positionId, Model model)
                        throws Exception {

                partnersPositionRepository.delete(positionId);
                for (int fofoId : selectedFofoIds) {
                        PartnerPosition partnerPosition = new PartnerPosition();
                        partnerPosition.setFofoId(fofoId);
                        partnerPosition.setRegionId(regionId);
                        partnerPosition.setPositionId(positionId);
                        partnersPositionRepository.persist(partnerPosition);
                }

                model.addAttribute("response1", mvcResponseSender.createResponseString(true));

                return "response";
        }

        @GetMapping(value = "/cs/createTicket")
        public String createTicket(HttpServletRequest request, Model model) throws ProfitMandiBusinessException {
                LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
                List<TicketCategory> ticketCategories = csService.getAllTicketCategotyFromSubCategory();
                model.addAttribute("roleType", roleManager.isAdmin(loginDetails.getRoleIds()));
                model.addAttribute("ticketCategories", ticketCategories);
                return "create-ticket";
        }

        @GetMapping(value = "/cs/getSubCategoriesByCategoryId")
        public String getSubCategoriesByCategoryId(HttpServletRequest request,
                        @RequestParam(name = "categoryId", defaultValue = "0") int categoryId, Model model) {
                List<TicketSubCategory> ticketSubCategories = ticketSubCategoryRepository.selectAll(categoryId);
                LOGGER.info(ticketSubCategories);
                model.addAttribute("ticketSubCategories", ticketSubCategories);
                return "ticket-sub-categories";
        }

        @PostMapping(value = "/cs/createTicket")
        public String createTicket(HttpServletRequest request, @RequestParam(name = "categoryId") int categoryId,
                        @RequestParam(name = "subCategoryId") int subCategoryId, @RequestParam(name = "message") String message,
                        Model model) throws Exception {
                LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
                List<Ticket> tickets = ticketRepository.selectAllResolvedMarkedTicketByCreator(loginDetails.getFofoId());
                if (tickets.size() > 3 || tickets.size() == 3) {
                        model.addAttribute("response1", mvcResponseSender.createResponseString(false));
                } else {
                        csService.createTicket(loginDetails.getFofoId(), categoryId, subCategoryId, message);
                        model.addAttribute("response1", mvcResponseSender.createResponseString(true));
                }
                return "response";
        }

        @GetMapping(value = "/cs/myticket")
        public String getTicket(HttpServletRequest request,
                        @RequestParam(name = "orderby", defaultValue = "DESCENDING") SortOrder sortOrder,
                        @RequestParam(name = "ticketStatus", defaultValue = "OPENED") TicketStatus ticketStatus,
                        @RequestParam(name = "ticketSearchType", defaultValue = "") TicketSearchType ticketSearchType,
                        @RequestParam(name = "searchTerm", defaultValue = "0") int searchTerm,
                        @RequestParam(name = "offset", defaultValue = "0") int offset,
                        @RequestParam(name = "limit", defaultValue = "10") int limit, Model model)
                        throws ProfitMandiBusinessException {
                LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
                List<Ticket> tickets = null;
                List<TicketAssigned> ticketAssigneds = null;
                long size = 0;
                Map<Integer, AuthUser> authUserIdAndAuthUserMap = null;
                if (roleManager.isAdmin(new HashSet<>(loginDetails.getRoleIds()))) {
                        AuthUser authUser = authRepository.selectByEmailOrMobile(loginDetails.getEmailId());
                        if (ticketSearchType == null) {
                                if (ticketStatus.equals(TicketStatus.RESOLVED)) {
                                        tickets = ticketRepository.selectAllByAssignee(authUser.getId(), Optional.empty(), sortOrder, null,
                                                        searchTerm, offset, limit);
                                        size = ticketRepository.selectAllCountByAssignee(authUser.getId(), Optional.empty(), null,
                                                        searchTerm);
                                } else {
                                        tickets = ticketRepository.selectAllByAssignee(authUser.getId(),
                                                        Optional.of(TicketStatus.CLOSED.equals(ticketStatus)), sortOrder, null, searchTerm, offset,
                                                        limit);
                                        size = ticketRepository.selectAllCountByAssignee(authUser.getId(),
                                                        Optional.of(TicketStatus.CLOSED.equals(ticketStatus)), null, searchTerm);
                                }

                        } else {

                                if (ticketStatus.equals(TicketStatus.RESOLVED)) {
                                        tickets = ticketRepository.selectAllByAssignee(authUser.getId(), Optional.empty(), sortOrder,
                                                        ticketSearchType, searchTerm, offset, limit);
                                        size = ticketRepository.selectAllCountByAssignee(authUser.getId(), Optional.empty(),
                                                        ticketSearchType, searchTerm);
                                } else {
                                        tickets = ticketRepository.selectAllByAssignee(authUser.getId(),
                                                        Optional.of(TicketStatus.CLOSED.equals(ticketStatus)), sortOrder, ticketSearchType,
                                                        searchTerm, offset, limit);
                                        size = ticketRepository.selectAllCountByAssignee(authUser.getId(),
                                                        Optional.of(TicketStatus.CLOSED.equals(ticketStatus)), ticketSearchType, searchTerm);
                                }
                        }
                        // LOGGER.info(size + "size");
                        if (tickets.size() > 0) {
                                ticketAssigneds = ticketAssignedRepository
                                                .selectByTicketIds(tickets.stream().map(x -> x.getId()).collect(Collectors.toList()));
                                authUserIdAndAuthUserMap = csService.getAuthUserIdAndAuthUserMap(ticketAssigneds);
                                Map<Integer, CustomRetailer> fofoIdsAndCustomRetailer = csService.getPartnerByFofoIds(tickets);
                                model.addAttribute("fofoIdsAndCustomRetailer", fofoIdsAndCustomRetailer);
                        }

                } else {
                        tickets = ticketRepository.selectAllByCreator(loginDetails.getFofoId(),
                                        Optional.of(TicketStatus.OPENED.equals(ticketStatus)), sortOrder, offset, limit);
                        size = ticketRepository.selectAllCountByCreator(loginDetails.getFofoId(),
                                        Optional.of(TicketStatus.OPENED.equals(ticketStatus)));
                }
                authUserIdAndAuthUserMap = csService.getTicketIdAndAuthUserMapUsingTickets(tickets);

                if (size < limit) {
                        model.addAttribute("end", offset + size);
                } else {
                        model.addAttribute("end", offset + limit);
                }
                model.addAttribute("start", offset + 1);
                model.addAttribute("size", size);
                model.addAttribute("roleType", roleManager.isAdmin(new HashSet<>(loginDetails.getRoleIds())));
                Map<Integer, TicketSubCategory> subCategoryIdAndSubCategoryMap = csService
                                .getSubCategoryIdAndSubCategoryMap(tickets);
                model.addAttribute("tickets", tickets);
                model.addAttribute("resolved", ActivityType.RESOLVED);
                model.addAttribute("resolved-accepted", ActivityType.RESOLVED_ACCEPTED);
                model.addAttribute("resolved-rejected", ActivityType.RESOLVED_REJECTED);
                model.addAttribute("authUserIdAndAuthUserMap", authUserIdAndAuthUserMap);
                model.addAttribute("subCategoryIdAndSubCategoryMap", subCategoryIdAndSubCategoryMap);
                model.addAttribute("ticketStatusValues", TicketStatus.values());
                model.addAttribute("orderByValues", SortOrder.values());
                model.addAttribute("selectedticketStatus", ticketStatus);
                model.addAttribute("selectedorderby", sortOrder);
                model.addAttribute("ticketSearchTypes", TicketSearchType.values());
                model.addAttribute("ticketSearchType", ticketSearchType);
                model.addAttribute("searchTerm", searchTerm);
                return "ticket";
        }

        @GetMapping(value = "/cs/myticketPaginated")
        public String getMyTicketPaginated(HttpServletRequest request,
                        @RequestParam(name = "orderby", defaultValue = "DESCENDING") SortOrder sortOrder,
                        @RequestParam(name = "ticketStatus", defaultValue = "OPENED") TicketStatus ticketStatus,
                        @RequestParam(name = "ticketSearchType", defaultValue = "") TicketSearchType ticketSearchType,
                        @RequestParam(name = "searchTerm", defaultValue = "0") int searchTerm,
                        @RequestParam(name = "offset", defaultValue = "0") int offset,
                        @RequestParam(name = "limit", defaultValue = "10") int limit, Model model)
                        throws ProfitMandiBusinessException {
                LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
                List<Ticket> tickets = null;
                List<TicketAssigned> ticketAssigneds = null;

                Map<Integer, AuthUser> authUserIdAndAuthUserMap = null;

                if (roleManager.isAdmin(new HashSet<>(loginDetails.getRoleIds()))) {
                        AuthUser authUser = authRepository.selectByEmailOrMobile(loginDetails.getEmailId());
                        if (ticketSearchType == null) {
                                if (ticketStatus.equals(TicketStatus.RESOLVED)) {
                                        tickets = ticketRepository.selectAllByAssignee(authUser.getId(), Optional.empty(), sortOrder, null,
                                                        searchTerm, offset, limit);
                                } else {
                                        tickets = ticketRepository.selectAllByAssignee(authUser.getId(),
                                                        Optional.of(TicketStatus.CLOSED.equals(ticketStatus)), sortOrder, null, searchTerm, offset,
                                                        limit);
                                }

                        } else {

                                if (ticketStatus.equals(TicketStatus.RESOLVED)) {
                                        tickets = ticketRepository.selectAllByAssignee(authUser.getId(), Optional.empty(), sortOrder,
                                                        ticketSearchType, searchTerm, offset, limit);
                                } else {
                                        tickets = ticketRepository.selectAllByAssignee(authUser.getId(),
                                                        Optional.of(TicketStatus.CLOSED.equals(ticketStatus)), sortOrder, ticketSearchType,
                                                        searchTerm, offset, limit);
                                }
                        }
                        ticketAssigneds = ticketAssignedRepository
                                        .selectByTicketIds(tickets.stream().map(x -> x.getId()).collect(Collectors.toList()));
                        authUserIdAndAuthUserMap = csService.getAuthUserIdAndAuthUserMap(ticketAssigneds);
                        Map<Integer, CustomRetailer> fofoIdsAndCustomRetailer = csService.getPartnerByFofoIds(tickets);
                        model.addAttribute("fofoIdsAndCustomRetailer", fofoIdsAndCustomRetailer);
                } else {
                        tickets = ticketRepository.selectAllByCreator(loginDetails.getFofoId(),
                                        Optional.of(TicketStatus.OPENED.equals(ticketStatus)), sortOrder, offset, limit);
                        authUserIdAndAuthUserMap = csService.getTicketIdAndAuthUserMapUsingTickets(tickets);
                }
                model.addAttribute("roleType", roleManager.isAdmin(new HashSet<>(loginDetails.getRoleIds())));
                Map<Integer, TicketSubCategory> subCategoryIdAndSubCategoryMap = csService
                                .getSubCategoryIdAndSubCategoryMap(tickets);
                model.addAttribute("tickets", tickets);
                model.addAttribute("authUserIdAndAuthUserMap", authUserIdAndAuthUserMap);
                model.addAttribute("subCategoryIdAndSubCategoryMap", subCategoryIdAndSubCategoryMap);
                model.addAttribute("resolved", ActivityType.RESOLVED);
                model.addAttribute("resolved-accepted", ActivityType.RESOLVED_ACCEPTED);
                model.addAttribute("resolved-rejected", ActivityType.RESOLVED_REJECTED);
                return "ticket-paginated";
        }

        @GetMapping(value = "/cs/getActivities")
        public String getActivity(HttpServletRequest request,
                        @RequestParam(name = "ticketId", defaultValue = "0") int ticketId, Model model) throws Exception {
                List<Activity> allactivities = activityRepository.selectAll(ticketId);
                List<List<ActivityAttachment>> activityAttachments = allactivities.stream().map(x -> x.getActivityAttachment())
                                .collect(Collectors.toList());
                for (List<ActivityAttachment> aA : activityAttachments) {
                        // List<ActivityAttachment> documentId = aA.stream().map(x ->
                        // x).collect(Collectors.toList());
                        for (ActivityAttachment attachment : aA) {
                                Document document = documentRepository.selectById(attachment.getDocumentId());
                                attachment.setDocumentName(document.getDisplayName());
                                activityAttachmentRepository.persist(attachment);
                        }
                }
                List<Activity> activities = null;
                LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
                if (roleManager.isAdmin(loginDetails.getRoleIds())) {
                        Set<Integer> authUserIds = allactivities.stream().map(x -> x.getCreatedBy()).collect(Collectors.toSet());
                        List<AuthUser> users = authRepository.selectAllAuthUserByIds(new ArrayList<>(authUserIds));
                        Map<Integer, String> authUserNameMap = users.stream()
                                        .collect(Collectors.toMap(AuthUser::getId, x -> x.getFirstName() + " " + x.getLastName()));
                        allactivities.stream().forEach(x -> x.setName(authUserNameMap.get(x.getCreatedBy())));
                        activities = allactivities;
                } else {
                        activities = allactivities.stream().filter(x -> ActivityType.PARTNER_ACTIVITIES.contains(x.getType()))
                                        .collect(Collectors.toList());
                }
                if (activities == null) {
                        throw new ProfitMandiBusinessException("Activity", ticketId, "No Activity Found");
                }
                model.addAttribute("response1", mvcResponseSender.createResponseString(activities));
                return "response";

        }

        @PostMapping(value = "/cs/createActivity")
        public String createActivity(HttpServletRequest request,
                        @RequestParam(name = "ticketId", defaultValue = "0") int ticketId,
                        @RequestParam(name = "assigneeId", defaultValue = "0") int assigneeId,
                        @RequestParam(name = "internal", defaultValue = "true") boolean internal,
                        @RequestParam(name = "message", defaultValue = "") String message, @RequestBody List<Integer> documentIds,

                        Model model) throws Exception {

                LOGGER.info("documentIds" + documentIds);
                LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
                Ticket ticket = ticketRepository.selectById(ticketId);
                List<TicketAssigned> ticketAssignedList = ticketAssignedRepository.selectByTicketIds(Arrays.asList(ticketId));
                List<Integer> authUserIds = ticketAssignedList.stream().map(x -> x.getAssineeId()).collect(Collectors.toList());
                authUserIds.add(ticketAssignedList.get(ticketAssignedList.size() - 1).getManagerId());
                Map<Integer, AuthUser> authUsersMap = authRepository.selectAllAuthUserByIds(authUserIds).stream()
                                .collect(Collectors.toMap(x -> x.getId(), x -> x));
                if (ticket.getCloseTimestamp() == null) {
                        Activity activity = new Activity();
                        activity.setCreatedBy(0);
                        activity.setCreateTimestamp(LocalDateTime.now());
                        String subject = null;
                        String mailMessage = null;
                        activity.setMessage(message);
                        if (!roleManager.isAdmin(new HashSet<>(loginDetails.getRoleIds()))) {
                                CustomRetailer customRetailer = retailerService.getFofoRetailers(true).get(loginDetails.getFofoId());
                                activity.setType(ActivityType.COMMUNICATION_IN);
                                subject = String.format("Ticket Update #%s by franchisee %s", ticket.getId(),
                                                customRetailer.getBusinessName() + "(" + customRetailer.getCode() + ")");
                                mailMessage = String.format("Franchisee message - %s", message);
                        } else {
                                AuthUser authUser = authRepository.selectByEmailOrMobile(loginDetails.getEmailId());
                                activity.setCreatedBy(authUser.getId());
                                authUsersMap.remove(authUser.getId());
                                subject = String.format("Ticket Update #%s by %s", ticket.getId(), authUser.getName());
                                mailMessage = String.format("%s's message - %s", authUser.getFirstName(), message);
                                if (internal) {
                                        activity.setType(ActivityType.COMMUNICATION_INTERNAL);
                                        // String subject = String.format(ACTIVITY_SUBJECT, ticket.getId());
                                } else {
                                        String updatedBy = "SD Team";
                                        CustomRetailer customRetailer = retailerService.getFofoRetailers(true).get(ticket.getFofoId());
                                        subject = String.format("Ticket Update #%s by %s", ticket.getId(), updatedBy);
                                        String partnerMessage = String.format("%s's message - %s", updatedBy, message);
                                        this.activityRelatedMail(customRetailer.getEmail(), null, "subject", partnerMessage);
                                        activity.setType(ActivityType.COMMUNICATION_OUT);
                                }
                        }
                        activityRepository.persist(activity);

                        for (Integer documentId : documentIds) {
                                ActivityAttachment activityAttachment = new ActivityAttachment();
                                activityAttachment.setActivityId(activity.getId());
                                activityAttachment.setDocumentId(documentId);
                                activityAttachmentRepository.persist(activityAttachment);
                        }

                        csService.addActivity(ticket, activity);
                        AuthUser authUser = authUsersMap.remove(authUserIds.get(0));
                        if (authUser == null) {
                                authUser = authUsersMap.remove(authUserIds.get(1));
                        }
                        model.addAttribute("response1", mvcResponseSender.createResponseString(authUser));
                        String[] cc = authUsersMap.entrySet().stream().map(x -> x.getValue().getEmailId()).toArray(String[]::new);
                        this.activityRelatedMail(authUser.getEmailId(), cc, subject, mailMessage);
                } else {
                        throw new ProfitMandiBusinessException("Ticket", ticket.getId(), "Already closed ticket");
                }
                return "response";
        }

        private void activityRelatedMail(String to, String[] cc, String subject, String message)
                        throws ProfitMandiBusinessException {
                try {
                        Utils.sendMailWithAttachments(mailSender, to, cc, subject, message, null);
                } catch (Exception e) {
                        throw new ProfitMandiBusinessException("Ticket Activity", to, "Could not send ticket activity mail");
                }
        }

        @PostMapping(value = "/cs/closeTicket")
        public String closeTicket(HttpServletRequest request,
                        @RequestParam(name = "ticketId", defaultValue = "0") int ticketId,
                        @RequestParam(name = "happyCode") String happyCode, Model model) throws Exception {
                Ticket ticket = ticketRepository.selectById(ticketId);
                if (ticket.getHappyCode().equals(happyCode)) {
                        ticket.setCloseTimestamp(LocalDateTime.now());
                        ticketRepository.persist(ticket);
                        model.addAttribute("response1", mvcResponseSender.createResponseString(true));
                } else {
                        throw new ProfitMandiBusinessException("Ticket", ticketId, "Happy Code can't match");
                }
                return "response";
        }

        @GetMapping(value = "/cs/managerTicket")
        public String getManagerTickets(HttpServletRequest request,
                        @RequestParam(name = "orderby", defaultValue = "DESCENDING") SortOrder sortOrder,
                        @RequestParam(name = "ticketStatus", defaultValue = "OPENED") TicketStatus ticketStatus,
                        @RequestParam(name = "ticketSearchType", defaultValue = "") TicketSearchType ticketSearchType,
                        @RequestParam(name = "searchTerm", defaultValue = "0") int searchTerm,
                        @RequestParam(name = "offset", defaultValue = "0") int offset,
                        @RequestParam(name = "limit", defaultValue = "10") int limit, Model model)
                        throws ProfitMandiBusinessException {
                LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
                long size = 0;
                AuthUser authUser = authRepository.selectByEmailOrMobile(loginDetails.getEmailId());
                List<Ticket> tickets = null;
                Map<Integer, List<AuthUser>> authUserListMap = null;
                if (ticketSearchType == null) {
                        if (ticketStatus.equals(TicketStatus.RESOLVED)) {
                                tickets = ticketRepository.selectAllManagerTicket(authUser.getId(), sortOrder, Optional.empty(), null,
                                                searchTerm, offset, limit);
                                size = ticketRepository.selectAllCountByManagerTicket(authUser.getId(), Optional.empty(), null, 0);
                        } else {
                                tickets = ticketRepository.selectAllManagerTicket(authUser.getId(), sortOrder,
                                                Optional.of(TicketStatus.CLOSED.equals(ticketStatus)), null, searchTerm, offset, limit);
                                size = ticketRepository.selectAllCountByManagerTicket(authUser.getId(),
                                                Optional.of(TicketStatus.CLOSED.equals(ticketStatus)), null, 0);
                        }
                } else {
                        if (ticketStatus.equals(TicketStatus.RESOLVED)) {
                                tickets = ticketRepository.selectAllManagerTicket(authUser.getId(), sortOrder, Optional.empty(),
                                                ticketSearchType, searchTerm, offset, limit);
                                size = ticketRepository.selectAllCountByManagerTicket(authUser.getId(), Optional.empty(),
                                                ticketSearchType, searchTerm);
                        } else {
                                tickets = ticketRepository.selectAllManagerTicket(authUser.getId(), sortOrder,
                                                Optional.of(TicketStatus.CLOSED.equals(ticketStatus)), ticketSearchType, searchTerm, offset,
                                                limit);
                                size = ticketRepository.selectAllCountByManagerTicket(authUser.getId(),
                                                Optional.of(TicketStatus.CLOSED.equals(ticketStatus)), ticketSearchType, searchTerm);
                        }

                }
                authUserListMap = csService.getAssignedAuthList(tickets);

                if (tickets.size() > 0) {
                        Map<Integer, CustomRetailer> fofoIdsAndCustomRetailer = csService.getPartnerByFofoIds(tickets);
                        model.addAttribute("fofoIdsAndCustomRetailer", fofoIdsAndCustomRetailer);
                }
                if (size < limit) {
                        model.addAttribute("end", offset + size);
                } else {
                        model.addAttribute("end", offset + limit);
                }
                model.addAttribute("start", offset + 1);
                model.addAttribute("size", size);
                model.addAttribute("tickets", tickets);

                Map<Integer, TicketSubCategory> subCategoryIdAndSubCategoryMap = csService
                                .getSubCategoryIdAndSubCategoryMap(tickets);
                model.addAttribute("ticketStatusValues", TicketStatus.values());
                model.addAttribute("orderByValues", SortOrder.values());
                model.addAttribute("selectedticketStatus", ticketStatus);
                model.addAttribute("selectedorderby", sortOrder);
                model.addAttribute("tickets", tickets);
                model.addAttribute("ticketSearchTypes", TicketSearchType.values());
                model.addAttribute("ticketSearchType", ticketSearchType);
                model.addAttribute("searchTerm", searchTerm);
                model.addAttribute("authUserListMap", authUserListMap);
                model.addAttribute("subCategoryIdAndSubCategoryMap", subCategoryIdAndSubCategoryMap);
                return "managerTicket";
        }

        @GetMapping(value = "/cs/managerTicket-paginated")
        public String getManagerTicketsPaginated(HttpServletRequest request,
                        @RequestParam(name = "orderby", defaultValue = "DESCENDING") SortOrder sortOrder,
                        @RequestParam(name = "ticketStatus", defaultValue = "OPENED") TicketStatus ticketStatus,
                        @RequestParam(name = "ticketSearchType", defaultValue = "") TicketSearchType ticketSearchType,
                        @RequestParam(name = "searchTerm", defaultValue = "0") int searchTerm,
                        @RequestParam(name = "offset", defaultValue = "0") int offset,
                        @RequestParam(name = "limit", defaultValue = "10") int limit, Model model)
                        throws ProfitMandiBusinessException {
                LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
                AuthUser authUser = authRepository.selectByEmailOrMobile(loginDetails.getEmailId());
                Map<Integer, List<AuthUser>> authUserListMap = null;
                List<Ticket> tickets = null;
                if (ticketSearchType == null) {
                        if (ticketStatus.equals(TicketStatus.RESOLVED)) {
                                tickets = ticketRepository.selectAllManagerTicket(authUser.getId(), sortOrder, Optional.empty(), null,
                                                searchTerm, offset, limit);

                        } else {
                                tickets = ticketRepository.selectAllManagerTicket(authUser.getId(), sortOrder,
                                                Optional.of(TicketStatus.CLOSED.equals(ticketStatus)), null, searchTerm, offset, limit);

                        }
                } else {
                        if (ticketStatus.equals(TicketStatus.RESOLVED)) {
                                tickets = ticketRepository.selectAllManagerTicket(authUser.getId(), sortOrder, Optional.empty(),
                                                ticketSearchType, searchTerm, offset, limit);

                        } else {
                                tickets = ticketRepository.selectAllManagerTicket(authUser.getId(), sortOrder,
                                                Optional.of(TicketStatus.CLOSED.equals(ticketStatus)), ticketSearchType, searchTerm, offset,
                                                limit);
                        }

                }
                authUserListMap = csService.getAssignedAuthList(tickets);
                if (tickets.size() > 0) {
                        Map<Integer, CustomRetailer> fofoIdsAndCustomRetailer = csService.getPartnerByFofoIds(tickets);
                        model.addAttribute("fofoIdsAndCustomRetailer", fofoIdsAndCustomRetailer);
                }
                model.addAttribute("tickets", tickets);
                Map<Integer, TicketSubCategory> subCategoryIdAndSubCategoryMap = csService
                                .getSubCategoryIdAndSubCategoryMap(tickets);
                model.addAttribute("tickets", tickets);
                model.addAttribute("authUserListMap", authUserListMap);
                model.addAttribute("subCategoryIdAndSubCategoryMap", subCategoryIdAndSubCategoryMap);
                return "managerTicket-paginated";
        }

        @GetMapping(value = "/cs/edit-ticket")
        public String getEditTicket(HttpServletRequest request,
                        @RequestParam(name = "ticketId", defaultValue = "0") int ticketId, Model model) {
                Ticket ticket = ticketRepository.selectById(ticketId);
                List<TicketCategory> ticketCategories = csService.getAllTicketCategotyFromSubCategory();
                TicketSubCategory ticketSubCategory = ticketSubCategoryRepository.selectById(ticket.getSubCategoryId());
                List<TicketSubCategory> ticketSubCategories = ticketSubCategoryRepository
                                .selectAll(ticketSubCategory.getCategoryId());
                List<AuthUser> authUsers = new ArrayList<>();
                model.addAttribute("ticket", ticket);
                model.addAttribute("ticketCategories", ticketCategories);
                model.addAttribute("ticketSubCategories", ticketSubCategories);
                model.addAttribute("ticketSubCategory", ticketSubCategory);
                model.addAttribute("authUsers", authUsers);
                return "edit-ticket-modal";
        }

        @PostMapping(value = "/cs/edit-ticket")
        public String editTicket(HttpServletRequest request,
                        @RequestParam(name = "ticketId", defaultValue = "0") int ticketId,
                        @RequestParam(name = "subCategoryId", defaultValue = "0") int subCategoryId,
                        @RequestParam(name = "categoryId", defaultValue = "0") int categoryId,
                        @RequestParam(name = "authUserId", defaultValue = "0") int authUserId, Model model) throws Exception {
                LOGGER.info("Ticket Id {}, CategoryId {}, SubCategory Id {}", ticketId, categoryId, subCategoryId);
                Ticket ticket = ticketRepository.selectById(ticketId);
                csService.updateTicket(categoryId, subCategoryId, ticket);
                model.addAttribute("response1", mvcResponseSender.createResponseString(true));
                return "response";

        }

        @DeleteMapping(value = "/cs/removePosition")
        public String removePosition(HttpServletRequest request,
                        @RequestParam(name = "positionId", defaultValue = "0") int positionId, Model model) throws Exception {
                positionRepository.delete(positionId);
                model.addAttribute("response1", mvcResponseSender.createResponseString(true));
                return "response";
        }

        @PostMapping(value = "/cs/create-last-activity")
        public String createlastActivity(HttpServletRequest request, @RequestParam(name = "ticketId") int ticketId,
                        @RequestParam(name = "lastactivity") ActivityType lastActivity, Model model) throws Exception {
                LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
                Ticket ticket = ticketRepository.selectById(ticketId);
                Activity activity = new Activity();
                String subject = String.format(ACTIVITY_SUBJECT, ticket.getId());
                if (roleManager.isAdmin(loginDetails.getRoleIds())) {
                        ticket.setLastActivity(lastActivity);
                        String to = retailerService.getFofoRetailer(ticket.getFofoId()).getEmail();
                        String message = String.format(PARTNER_RESOLVED_TICKET_MAIL, ticketId, "REOPEN");
                        activity.setMessage(message);
                        activity.setCreatedBy(authRepository.selectByEmailOrMobile(loginDetails.getEmailId()).getId());
                        activity.setTicketId(ticketId);
                        activity.setCreateTimestamp(LocalDateTime.now());
                        activity.setType(ActivityType.COMMUNICATION_OUT);
                        this.activityRelatedMail(to, null, subject, message);
                } else {
                        if (ActivityType.RESOLVED_ACCEPTED == lastActivity) {
                                ticket.setLastActivity(lastActivity);
                                ticket.setCloseTimestamp(LocalDateTime.now());
                                activity.setMessage(ActivityType.RESOLVED_ACCEPTED.toString());
                                activity.setCreatedBy(0);
                                activity.setTicketId(ticketId);
                                activity.setType(ActivityType.COMMUNICATION_IN);
                                activity.setCreateTimestamp(LocalDateTime.now());
                        } else {
                                String message = String.format(INTERNAL_REOPEN_MAIL, ticketId,
                                                retailerService.getFofoRetailer(loginDetails.getFofoId()).getBusinessName());
                                String to = authRepository.selectById(ticket.getL1AuthUser()).getEmailId();
                                String[] ccTo = authRepository
                                                .selectAllAuthUserByIds(Arrays.asList(ticket.getL2AuthUser(), ticket.getL3AuthUser(),
                                                                ticket.getL4AuthUser(), ticket.getL5AuthUser()))
                                                .stream().map(x -> x.getEmailId()).toArray(String[]::new);
                                ticket.setLastActivity(lastActivity);
                                ticket.setUpdateTimestamp(LocalDateTime.now());
                                ticketAssignedRepository.deleteByTicketId(ticketId);
                                TicketAssigned ticketAssigned = new TicketAssigned();
                                ticketAssigned.setAssineeId(ticket.getL1AuthUser());
                                ticketAssigned.setTicketId(ticketId);
                                ticketAssignedRepository.persist(ticketAssigned);
                                activity.setMessage(INTERNAL_REOPEN_ACTIVITY_MESSAGE);
                                activity.setCreatedBy(0);
                                activity.setTicketId(ticketId);
                                activity.setType(ActivityType.COMMUNICATION_IN);
                                activity.setCreateTimestamp(LocalDateTime.now());
                                this.activityRelatedMail(to, ccTo, subject, message);
                                this.activityRelatedMail(retailerService.getFofoRetailer(loginDetails.getFofoId()).getEmail(), null,
                                                subject, String.format(PARTNER_REOPEN, ticketId));
                        }

                }
                activityRepository.persist(activity);
                model.addAttribute("response1", mvcResponseSender.createResponseString(true));
                return "response";
        }

}