Subversion Repositories SmartDukaan

package com.spice.profitmandi.web.controller;

import java.time.LocalDateTime;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.stream.Collectors;

import javax.servlet.http.HttpServletRequest;

import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
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.dao.entity.auth.AuthUser;
import com.spice.profitmandi.dao.entity.cs.Activity;
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.TicketAssigned;
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.enumuration.cs.TicketStatus;
import com.spice.profitmandi.dao.repository.auth.AuthRepository;
import com.spice.profitmandi.dao.repository.cs.ActivityRepository;
import com.spice.profitmandi.dao.repository.cs.CsService;
import com.spice.profitmandi.dao.repository.cs.PartnerRegionRepository;
import com.spice.profitmandi.dao.repository.cs.PositionRepository;
import com.spice.profitmandi.dao.repository.cs.RegionRepository;
import com.spice.profitmandi.dao.repository.cs.TicketAssignedRepository;
import com.spice.profitmandi.dao.repository.cs.TicketCategoryRepository;
import com.spice.profitmandi.dao.repository.cs.TicketRepository;
import com.spice.profitmandi.dao.repository.cs.TicketSubCategoryRepository;
import com.spice.profitmandi.service.authentication.RoleManager;
import com.spice.profitmandi.service.slab.TargetSlabService;
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;

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

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

        @Autowired
        private CsService csService;

        @Autowired
        private CookiesProcessor cookiesProcessor;

        @Autowired
        private TicketCategoryRepository ticketCategoryRepository;

        @Autowired
        private TicketSubCategoryRepository ticketSubCategoryRepository;

        @Autowired
        private RegionRepository regionRepository;

        @Autowired
        private TargetSlabService targetSlabService;

        @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 TicketAssignedRepository ticketAssignedRepository;
        
        @Autowired 
        private PartnerRegionRepository partnerRegionRepository;

        @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("response", 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 = targetSlabService.getfofoIdsFromfofoStore();
                List<Integer> addedfofoIds=partnerRegionRepository.selectByRegionId(regionId).stream().map(x->x.getFofoId()).collect(Collectors.toList());
                Map<Integer, CustomRetailer> fofoRetailers = retailerService.getFofoRetailers(fofoIds);
                model.addAttribute("fofoRetailers", fofoRetailers);
                model.addAttribute("addedfofoIds", addedfofoIds);
                return "added-region-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("response", mvcResponseSender.createResponseString(true));
                return "response";
        }

        @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.selectAll();
                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.selectAll(offset, limit);
                LOGGER.info(positions);
                Map<Integer, AuthUser> authUserIdAndAuthUserMap = csService
                                .getAuthUserIdAndAuthUserMapUsingPositions(positions);
                Map<Integer, TicketCategory> categoryIdAndCategoryMap = csService
                                .getCategoryIdAndCategoryUsingPositions(positions);
                Map<Integer, Region> regionIdAndRegionMap = csService.getRegionIdAndRegionMap(positions);
                long size = positionRepository.selectAllCount();

                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("positions", positions);
                model.addAttribute("authUserIdAndAuthUserMap", authUserIdAndAuthUserMap);
                model.addAttribute("categoryIdAndCategoryMap", categoryIdAndCategoryMap);
                model.addAttribute("regionIdAndRegionMap", regionIdAndRegionMap);
                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);
                model.addAttribute("positions", positions);
                model.addAttribute("authUserIdAndAuthUserMap", authUserIdAndAuthUserMap);
                model.addAttribute("categoryIdAndCategoryMap", categoryIdAndCategoryMap);
                model.addAttribute("regionIdAndRegionMap", regionIdAndRegionMap);
                return "position-paginated";
        }

        @PostMapping(value = "/cs/createPosition")
        public String createPosition(HttpServletRequest request, @RequestParam(name = "authUserId") int authUserId,
                        @RequestParam(name = "categoryId") int categoryId,
                        @RequestParam(name = "escalationType") EscalationType escalationType,
                        @RequestParam(name = "regionId") int regionId, Model model) throws Exception {

                Position position = positionRepository.selectPosition(authUserId, categoryId, regionId, escalationType);
                if (position == null) {
                        position = new Position();
                        position.setAuthUserId(authUserId);
                        position.setCategoryId(categoryId);
                        position.setEscalationType(escalationType);
                        position.setRegionId(regionId);
                        position.setCreateTimestamp(LocalDateTime.now());
                        positionRepository.persist(position);
                        model.addAttribute("response", mvcResponseSender.createResponseString(true));
                } else {
                        throw new ProfitMandiBusinessException("Position", authUserId, "already exists!");
                }
                return "response";
        }

        @GetMapping(value = "/cs/createTicket")
        public String createTicket(HttpServletRequest request, Model model) {
                List<TicketCategory> ticketCategories = csService.getAllTicketCategotyFromSubCategory();
                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);
                csService.createTicket(loginDetails.getFofoId(), categoryId, subCategoryId, message);
                model.addAttribute("response", mvcResponseSender.createResponseString(true));
                return "response";
        }

        @GetMapping(value = "/cs/myticket")
        public String getMyTicket(HttpServletRequest request, @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;
                List<Integer> ticketIds = null;
                long size = 0;
                Map<Integer, AuthUser> authUserIdAndAuthUserMap = null;
                // LOGGER.info(roleManager.isAdmin(new HashSet<>(loginDetails.getRoleIds()))));
                if (roleManager.isAdmin(new HashSet<>(loginDetails.getRoleIds()))) {
                        AuthUser authUser = authRepository.selectByEmailOrMobile(loginDetails.getEmailId());
                        ticketAssigneds = ticketAssignedRepository.selectByAssigneeId(authUser.getId(), offset, limit);
                        ticketIds = ticketAssigneds.stream().map(x -> x.getTicketId()).collect(Collectors.toList());
                        tickets = ticketRepository.selectAllByTicketIds(ticketIds);
                        size = ticketAssignedRepository.selectCountByAssigneeId(authUser.getId());
                        authUserIdAndAuthUserMap = csService.getAuthUserIdAndAuthUserMap(ticketAssigneds);
                        Map<Integer, CustomRetailer> fofoIdsAndCustomRetailer = csService.getPartnerByFofoIds(tickets);
                        model.addAttribute("fofoIdsAndCustomRetailer", fofoIdsAndCustomRetailer);
                } else {
                        tickets = ticketRepository.selectAllByCreator(loginDetails.getFofoId(), Optional.empty(), offset, limit);
                        authUserIdAndAuthUserMap = csService.getTicketIdAndAuthUserMapUsingTickets(tickets);
                        size = ticketRepository.selectAllCountByCreator(loginDetails.getFofoId(), Optional.empty());

                }
                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("authUserIdAndAuthUserMap", authUserIdAndAuthUserMap);
                model.addAttribute("subCategoryIdAndSubCategoryMap", subCategoryIdAndSubCategoryMap);
                return "ticket";
        }

        @GetMapping(value = "/cs/myticketPaginated")
        public String getMyTicketPaginated(HttpServletRequest request,
                        @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;
                List<Integer> ticketIds = null;
                Map<Integer, AuthUser> authUserIdAndAuthUserMap = null;
                // LOGGER.info(roleManager.isAdmin(new HashSet<>(loginDetails.getRoleIds()))));
                if (roleManager.isAdmin(new HashSet<>(loginDetails.getRoleIds()))) {
                        AuthUser authUser = authRepository.selectByEmailOrMobile(loginDetails.getEmailId());
                        ticketAssigneds = ticketAssignedRepository.selectByAssigneeId(authUser.getId(), offset, limit);
                        ticketIds = ticketAssigneds.stream().map(x -> x.getTicketId()).collect(Collectors.toList());
                        tickets = ticketRepository.selectAllByTicketIds(ticketIds);
                        authUserIdAndAuthUserMap = csService.getAuthUserIdAndAuthUserMap(ticketAssigneds);
                        Map<Integer, CustomRetailer> fofoIdsAndCustomRetailer = csService.getPartnerByFofoIds(tickets);
                        model.addAttribute("fofoIdsAndCustomRetailer", fofoIdsAndCustomRetailer);
                } else {
                        tickets = ticketRepository.selectAllByCreator(loginDetails.getFofoId(), Optional.empty(), 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);
                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> activities = activityRepository.selectAll(ticketId);
                if (activities == null) {
                        throw new ProfitMandiBusinessException("Activity", ticketId, "No Activity Found");
                }
                model.addAttribute("response", 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 = "message", defaultValue = "") String message, Model model) throws Exception {
                LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
                Ticket ticket = ticketRepository.selectById(ticketId);
                if (ticket.getCloseTimestamp() == null) {
                        if (!roleManager.isAdmin(new HashSet<>(loginDetails.getRoleIds()))) {
                                Activity activity = new Activity();
                                activity.setMessage(message);
                                activity.setCreatedBy(0);
                                activity.setCreateTimestamp(LocalDateTime.now());
                                activity.setType(ActivityType.COMMUNICATION_IN);
                                csService.addActivity(ticketId, activity);
                                AuthUser authUser = authRepository.selectById(assigneeId);
                                model.addAttribute("response", mvcResponseSender.createResponseString(authUser));
                        } else {
                                AuthUser authUser = authRepository.selectByEmailOrMobile(loginDetails.getEmailId());
                                Activity activity = new Activity();
                                activity.setMessage(message);
                                activity.setCreatedBy(authUser.getId());
                                activity.setCreateTimestamp(LocalDateTime.now());
                                activity.setType(ActivityType.COMMUNICATION_OUT);
                                csService.addActivity(ticketId, activity);
                                model.addAttribute("response", mvcResponseSender.createResponseString(authUser));
                        }
                } else {
                        throw new ProfitMandiBusinessException("Ticket", ticket.getId(), "Already closed ticket");
                }
                return "response";
        }

        @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("response", mvcResponseSender.createResponseString(true));
                } else {
                        throw new ProfitMandiBusinessException("Ticket", ticketId, "Happy Code can't match");
                }
                return "response";
        }

        @GetMapping(value = "/cs/managerTicket")
        public String getL2L3AndL4Tickets(HttpServletRequest request,
                        @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 (loginDetails.getEmailId().equals("amandeep.singh@smartdukaan.com")) {
                        tickets = ticketRepository.selectAll(offset, limit, Optional.empty());
                        authUserListMap=csService.getAuthUserList(tickets, EscalationType.L4);
                        size = ticketRepository.selectAllCount();
                } else {
                        tickets = ticketRepository.selectAllByEscalatedUserType(authUser.getId(), EscalationType.L2, offset, limit);
                        if (tickets.size() == 0) {
                                tickets = ticketRepository.selectAllByEscalatedUserType(authUser.getId(), EscalationType.L3, offset,
                                                limit);
                                size = ticketRepository.selectAllCountByEscalatedUserType(authUser.getId(), EscalationType.L3);
                                authUserListMap=csService.getAuthUserList(tickets, EscalationType.L3);
                                Map<Integer, CustomRetailer> fofoIdsAndCustomRetailer = csService.getPartnerByFofoIds(tickets);
                                model.addAttribute("fofoIdsAndCustomRetailer", fofoIdsAndCustomRetailer);
                        } else {
                                size = ticketRepository.selectAllCountByEscalatedUserType(authUser.getId(), EscalationType.L2);
                                authUserListMap=csService.getAuthUserList(tickets, EscalationType.L2);
                                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("tickets", tickets);
                model.addAttribute("authUserListMap", authUserListMap);
                model.addAttribute("subCategoryIdAndSubCategoryMap", subCategoryIdAndSubCategoryMap);
                return "managerTicket";
        }

        @GetMapping(value = "/cs/managerTicket-paginated")
        public String getL2L3AndL4TicketsPaginated(HttpServletRequest request,
                        @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 (loginDetails.getEmailId().equals("amandeep.singh@smartdukaan.com")) {
                        tickets = ticketRepository.selectAll(offset, limit, Optional.empty());
                        authUserListMap = csService.getAuthUserList(tickets, EscalationType.L4);
                } else {
                        tickets = ticketRepository.selectAllByEscalatedUserType(authUser.getId(), EscalationType.L2, offset, limit);
                        if (tickets.size() == 0) {
                                tickets = ticketRepository.selectAllByEscalatedUserType(authUser.getId(), EscalationType.L3, offset,
                                                limit);
                                authUserListMap = csService.getAuthUserList(tickets, EscalationType.L3);
                                Map<Integer, CustomRetailer> fofoIdsAndCustomRetailer = csService.getPartnerByFofoIds(tickets);
                                model.addAttribute("fofoIdsAndCustomRetailer", fofoIdsAndCustomRetailer);
                        } else {
                                Map<Integer, CustomRetailer> fofoIdsAndCustomRetailer = csService.getPartnerByFofoIds(tickets);
                                authUserListMap=csService.getAuthUserList(tickets, EscalationType.L2);
                                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=authRepository.selectAll();
                model.addAttribute("ticket", ticket);
                model.addAttribute("ticketCategories", ticketCategories);
                model.addAttribute("ticketSubCategories", ticketSubCategories);
                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(ticketId);
                Ticket ticket = ticketRepository.selectById(ticketId);
                
                if(ticket.getSubCategoryId()==subCategoryId)
                {
                LOGGER.info(ticket);
                
                TicketAssigned ticketAssigned=ticketAssignedRepository.selectByAssigneeIdAndTicketId(authUserId, ticket.getId());
                if(ticketAssigned==null)
                {
                        ticketAssignedRepository.deleteByTicketId(ticketId);
                        ticketAssigned=new TicketAssigned();
                        ticketAssigned.setTicketId(ticketId);
                        ticketAssigned.setAssineeId(authUserId);
                        ticketAssignedRepository.persist(ticketAssigned);
                }
                ticket.setL1AuthUser(authUserId);
                ticket.setSubCategoryId(subCategoryId);
                ticket.setUpdateTimestamp(LocalDateTime.now());
                ticket.setL2EscalationTimestamp(ticket.getUpdateTimestamp().plusDays(2));
                ticket.setL3EscalationTimestamp(ticket.getL2EscalationTimestamp().plusDays(2));
                ticket.setLastEscalationTimestamp(ticket.getL3EscalationTimestamp().plusDays(2));
                ticketRepository.persist(ticket);
                model.addAttribute("response", mvcResponseSender.createResponseString(true));
                }
                else
                {
                        ticketAssignedRepository.deleteByTicketId(ticketId);
                        csService.updateTicket(categoryId,subCategoryId,ticket);        
                        model.addAttribute("response", 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("response", mvcResponseSender.createResponseString(true));
                return "response";
        }
}