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.model.ProfitMandiConstants;

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

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

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

import com.spice.profitmandi.dao.entity.cs.TicketReadStatus.UserType;

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.mail.MailOutboxService;

import com.spice.profitmandi.service.order.OrderService;

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.http.ResponseEntity;

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 gmailRelaySender;

    @Autowired

    MailOutboxService mailOutboxService;

    @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 OrderService orderService;

    @Autowired

    private ActivityAttachmentRepository activityAttachmentRepository;

    @Autowired

    private TicketAssignedRepository ticketAssignedRepository;

    @Autowired

    private PartnerRegionRepository partnerRegionRepository;

    @Autowired

    PartnerPositionRepository partnerPositionRepository;

    @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 = "categoryType") int categoryType,

                                 @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);

        ticketCategory.setCategoryType(categoryType == 1);

        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);

        LOGGER.info("ticketSubCategories {}", ticketSubCategories);

        LOGGER.info("ticketCategory {}", ticketCategory);

        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) throws ProfitMandiBusinessException {

        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) throws ProfitMandiBusinessException {

        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) throws ProfitMandiBusinessException {

        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 {

        LOGGER.info("partnerPosition" + createPositionModel.isTicketAssigned());

        // Validate authUserId exists

        int authUserId = createPositionModel.getAuthUserId();

        if (authUserId <= 0 || authRepository.selectById(authUserId) == null) {

            throw new ProfitMandiBusinessException("Position", authUserId, "Invalid authUserId");

        }

        // Validate categoryId exists (0 means "All Categories")

        int categoryId = createPositionModel.getCategoryId();

        if (categoryId > 0 && ticketCategoryRepository.selectById(categoryId) == null) {

            throw new ProfitMandiBusinessException("Position", categoryId, "Invalid categoryId");

        }

        // Validate regionId exists (0 or 5 typically means "All Partners/Regions")

        int regionId = createPositionModel.getRegionId();

        if (regionId > 0 && regionId != 5 && regionRepository.selectById(regionId) == null) {

            throw new ProfitMandiBusinessException("Position", regionId, "Invalid regionId");

        }

        // Partners are optional — a position can be created for a region that doesn't have

        // partners yet (e.g., a newly opened region). Partners can be added later via

        // /cs/updatePartnerPosition. When provided, validate the list; when empty, skip.

        List<Integer> fofoIds = createPositionModel.getFofoIds();

        boolean hasAllPartners = fofoIds != null && fofoIds.contains(0);

        if (hasAllPartners && fofoIds.size() > 1) {

            throw new ProfitMandiBusinessException("Position", 0, "Cannot mix 'All Partners' (0) with specific partner IDs");

        }

        if (fofoIds != null && !fofoIds.isEmpty() && !hasAllPartners) {

            Map<Integer, CustomRetailer> validRetailers = retailerService.getFofoRetailers(false);

            for (int fofoId : fofoIds) {

                if (!validRetailers.containsKey(fofoId)) {

                    throw new ProfitMandiBusinessException("Position", fofoId, "Invalid fofoId");

                }

            }

        }

        Position position = positionRepository.selectPosition(authUserId, categoryId, regionId, createPositionModel.getEscalationType());

        if (position == null) {

            position = new Position();

            position.setAuthUserId(authUserId);

            position.setCategoryId(categoryId);

            position.setEscalationType(createPositionModel.getEscalationType());

            position.setRegionId(regionId);

            position.setCreateTimestamp(LocalDateTime.now());

            position.setTicketAssignee(createPositionModel.isTicketAssigned());

            positionRepository.persist(position);

            if (fofoIds != null) {

                for (int fofoId : fofoIds) {

                    PartnerPosition partnerPosition = new PartnerPosition();

                    partnerPosition.setFofoId(fofoId);

                    partnerPosition.setRegionId(regionId);

                    partnerPosition.setPositionId(position.getId());

                    partnerPositionRepository.persist(partnerPosition);

                    LOGGER.info("partnerPosition" + partnerPosition);

                }

            }

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

        } else {

            throw new ProfitMandiBusinessException("Position", authUserId, "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 {

        // Validate positionId exists

        Position position = positionRepository.selectById(positionId);

        if (position == null) {

            throw new ProfitMandiBusinessException("Position", positionId, "Position not found");

        }

        // Validate regionId exists (0 or 5 typically means "All Partners/Regions")

        if (regionId > 0 && regionId != 5 && regionRepository.selectById(regionId) == null) {

            throw new ProfitMandiBusinessException("Position", regionId, "Invalid regionId");

        }

        // Validate fofoIds exist (0 means "All Partners")

        if (selectedFofoIds == null || selectedFofoIds.isEmpty()) {

            throw new ProfitMandiBusinessException("Position", 0, "At least one partner must be specified");

        }

        boolean hasAllPartners = selectedFofoIds.contains(0);

        if (hasAllPartners && selectedFofoIds.size() > 1) {

            throw new ProfitMandiBusinessException("Position", 0, "Cannot mix 'All Partners' (0) with specific partner IDs");

        }

        if (!hasAllPartners) {

            // Use direct database query instead of cached retailerService to include newly added partners

            Set<Integer> validFofoIds = fofoStoreRepository.selectAll().stream()

                    .map(fs -> fs.getId())

                    .collect(Collectors.toSet());

            for (int fofoId : selectedFofoIds) {

                if (!validFofoIds.contains(fofoId)) {

                    throw new ProfitMandiBusinessException("Position", fofoId, "Invalid fofoId");

                }

            }

        }

        partnerPositionRepository.delete(positionId);

        if (selectedFofoIds != null) {

            for (int fofoId : selectedFofoIds) {

                PartnerPosition partnerPosition = new PartnerPosition();

                partnerPosition.setFofoId(fofoId);

                partnerPosition.setRegionId(regionId);

                partnerPosition.setPositionId(positionId);

                partnerPositionRepository.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);

        boolean isAdmin = roleManager.isAdmin(loginDetails.getRoleIds());

        boolean isCrmUser = false;

        List<TicketCategory> ticketCategories = csService.getAllTicketCategotyFromSubCategory();

        if (isAdmin) {

            AuthUser currentAuthUser = authRepository.selectByEmailOrMobile(loginDetails.getEmailId());

            isCrmUser = positionRepository.hasCategory(currentAuthUser.getId(), ProfitMandiConstants.TICKET_CATEGORY_CRM);

            // CRM users should not see Sales and RBM categories

            if (isCrmUser) {

                ticketCategories = ticketCategories.stream()

                        .filter(tc -> tc.getId() != ProfitMandiConstants.TICKET_CATEGORY_SALES

                                && tc.getId() != ProfitMandiConstants.TICKET_CATEGORY_RBM)

                        .collect(Collectors.toList());

            }

        } else {

            // For partners/customers: hide categories where ALL subcategories are invisible

            ticketCategories = ticketCategories.stream()

                    .filter(category -> {

                        List<TicketSubCategory> subs = ticketSubCategoryRepository.selectAll(category.getId());

                        // Keep category if at least one subcategory is visible

                        return subs.stream().anyMatch(TicketSubCategory::isVisibility);

                    })

                    .collect(Collectors.toList());

        }

        model.addAttribute("roleType", isAdmin);

        model.addAttribute("ticketCategories", ticketCategories);

        model.addAttribute("isCrmUser", isCrmUser);

        return "create-ticket";

    }

    @GetMapping(value = "/cs/getSubCategoriesByCategoryId")

    public String getSubCategoriesByCategoryId(HttpServletRequest request, @RequestParam(name = "categoryId", defaultValue = "0") int categoryId, Model model) throws ProfitMandiBusinessException {

        LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

        boolean isAdmin = roleManager.isAdmin(loginDetails.getRoleIds());

        boolean isCrmUser = false;

        if (isAdmin) {

            AuthUser currentAuthUser = authRepository.selectByEmailOrMobile(loginDetails.getEmailId());

            isCrmUser = positionRepository.hasCategory(currentAuthUser.getId(), ProfitMandiConstants.TICKET_CATEGORY_CRM);

        }

        List<TicketSubCategory> ticketSubCategories = ticketSubCategoryRepository.selectAllVisible(categoryId);

        // CRM users should not see invisible subcategories

        if (isCrmUser) {

            ticketSubCategories = ticketSubCategories.stream()

                    .filter(TicketSubCategory::isVisibility)

                    .collect(Collectors.toList());

        }

        LOGGER.info(ticketSubCategories);

        model.addAttribute("ticketSubCategories", ticketSubCategories);

        return "ticket-sub-categories";

    }

    @GetMapping(value = "/cs/getEscalationTypeByCategoryId")

    public String getEscalationTypeByCategoryId(HttpServletRequest request, @RequestParam(name = "categoryId", defaultValue = "0") int categoryId, @RequestParam(name = "authId", defaultValue = "0") int authId, Model model) {

        List<Position> positions = positionRepository.selectPositionbyCategoryIdAndAuthId(categoryId, authId);

        List<EscalationType> escalationTypes = new ArrayList<>();

        if (!positions.isEmpty()) {

            escalationTypes = positions.stream().map(x -> x.getEscalationType()).distinct().collect(Collectors.toList());

        }

        LOGGER.info("escalationTypes {}", escalationTypes);

        model.addAttribute("escalationTypes", escalationTypes);

        return "ticket-escalationtype";

    }

    @GetMapping(value = "/cs/getCategoriesByAuthId")

    public String getCategoriesByAuthId(HttpServletRequest request, @RequestParam(name = "authId", defaultValue = "0") int authId, Model model) {

        List<Position> positions = positionRepository.selectPositionByAuthId(authId);

        LOGGER.info("positions {}", positions);

        List<TicketCategory> ticketCategories = new ArrayList<TicketCategory>();

        if (!positions.isEmpty()) {

            List<Integer> categoryIds = positions.stream().map(x -> x.getCategoryId()).collect(Collectors.toList());

            ticketCategories = ticketCategoryRepository.selectAll(categoryIds);

        }

        LOGGER.info("ticketCategories {}", ticketCategories);

        model.addAttribute("ticketCategories", ticketCategories);

        return "ticket-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 = "page", defaultValue = "0") int page,

                            @RequestParam(name = "pageSize", defaultValue = "25") int pageSize,

                            @RequestParam(name = "search", required = false) String searchText,

                            Model model) throws ProfitMandiBusinessException {

        populateMyTicketModel(request, sortOrder, ticketStatus, ticketSearchType, searchTerm, page, pageSize, searchText, model);

        return "ticket";

    }

    @GetMapping(value = "/cs/myticket-content")

    public String getTicketContent(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 = "page", defaultValue = "0") int page,

                                   @RequestParam(name = "pageSize", defaultValue = "25") int pageSize,

                                   @RequestParam(name = "search", required = false) String searchText,

                                   Model model) throws ProfitMandiBusinessException {

        populateMyTicketModel(request, sortOrder, ticketStatus, ticketSearchType, searchTerm, page, pageSize, searchText, model);

        return "ticket-content";

    }

    private static String nvl(String s) {

        return s == null ? "" : s;

    }

    // Download every ticket the user can see in the current filter (respects ticketStatus /

    // sortOrder / search — but ignores pagination) as CSV with the same 8 columns rendered

    // in ticket-content.vm: Ticket Id, Partner, Category, SubCategory, Message, Created By,

    // Assigned To, Created TimeStamp.

    @GetMapping(value = "/cs/downloadMyTickets")

    public ResponseEntity<?> downloadMyTickets(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 = "search", required = false) String searchText) throws Exception {

        LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

        boolean isAdmin = roleManager.isAdmin(new HashSet<>(loginDetails.getRoleIds()));

        AuthUser currentAuthUser = isAdmin ? authRepository.selectByEmailOrMobile(loginDetails.getEmailId()) : null;

        boolean isCrmUser = isAdmin && currentAuthUser != null

                && positionRepository.hasCategory(currentAuthUser.getId(), ProfitMandiConstants.TICKET_CATEGORY_CRM);

        List<Integer> userCategoryIds = isAdmin && currentAuthUser != null

                ? positionRepository.selectCategoryIdsByAuthUserId(currentAuthUser.getId())

                : Collections.emptyList();

        List<Ticket> tickets;

        if (isAdmin) {

            int authUserId = currentAuthUser.getId();

            Optional<Boolean> resolvedOpt = ticketStatus.equals(TicketStatus.RESOLVED)

                    ? Optional.empty()

                    : Optional.of(TicketStatus.CLOSED.equals(ticketStatus));

            long total;

            if (isCrmUser) {

                total = ticketRepository.selectAllTicketsPaginatedCount(

                        resolvedOpt, ticketSearchType, searchTerm, searchText, userCategoryIds);

                tickets = ticketRepository.selectAllTicketsPaginated(

                        resolvedOpt, sortOrder, ticketSearchType, searchTerm, searchText,

                        userCategoryIds, 0, (int) Math.max(1L, total));

            } else {

                total = ticketRepository.selectAllByAssigneePaginatedCount(

                        authUserId, resolvedOpt, ticketSearchType, searchTerm, searchText);

                tickets = ticketRepository.selectAllByAssigneePaginated(

                        authUserId, resolvedOpt, sortOrder, ticketSearchType, searchTerm, searchText,

                        0, (int) Math.max(1L, total));

            }

        } else {

            tickets = ticketRepository.selectAllByCreator(

                    loginDetails.getFofoId(),

                    Optional.of(TicketStatus.OPENED.equals(ticketStatus)),

                    sortOrder);

        }

        if (tickets == null) tickets = new ArrayList<>();

        List<Integer> subCategoryIds = tickets.stream().map(Ticket::getSubCategoryId).collect(Collectors.toList());

        Map<Integer, TicketSubCategory> subMap = csService.getSubCategoryIdAndSubCategoryMap(subCategoryIds);

        if (subMap == null) subMap = new HashMap<>();

        Map<Integer, TicketCategory> catMap = csService.getSubCategoryIdAndCategoryMap(subCategoryIds);

        if (catMap == null) catMap = new HashMap<>();

        Map<Integer, CustomRetailer> partnerMap = tickets.isEmpty()

                ? new HashMap<>()

                : csService.getPartnerByFofoIds(tickets);

        if (partnerMap == null) partnerMap = new HashMap<>();

        Map<Integer, List<AuthUser>> assigneeListMap = csService.getAssignedAuthList(tickets);

        if (assigneeListMap == null) assigneeListMap = new HashMap<>();

        Map<Integer, AuthUser> authUserIdMap = csService.getTicketIdAndAuthUserMapUsingTickets(tickets);

        if (authUserIdMap == null) authUserIdMap = new HashMap<>();

        List<Integer> ticketIds = tickets.stream().map(Ticket::getId).collect(Collectors.toList());

        Map<Integer, Activity> lastMessageMap = ticketIds.isEmpty()

                ? new HashMap<>()

                : csService.getLastMessageActivitiesForTickets(ticketIds);

        if (lastMessageMap == null) lastMessageMap = new HashMap<>();

        List<Activity> allActs = ticketIds.isEmpty()

                ? new ArrayList<>()

                : activityRepository.selectAll(ticketIds);

        Map<Integer, List<Activity>> activityByTicket = allActs.stream()

                .collect(Collectors.groupingBy(Activity::getTicketId));

        Map<Integer, Activity> activityById = allActs.stream()

                .collect(Collectors.toMap(Activity::getId, x -> x, (a, b) -> a));

        Set<Integer> creatorIds = new HashSet<>();

        for (Activity a : allActs) if (a.getCreatedBy() > 0) creatorIds.add(a.getCreatedBy());

        for (Activity a : lastMessageMap.values()) if (a.getCreatedBy() > 0) creatorIds.add(a.getCreatedBy());

        Map<Integer, AuthUser> authUserMap = creatorIds.isEmpty()

                ? new HashMap<>()

                : authRepository.selectByIds(new ArrayList<>(creatorIds)).stream()

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

        List<List<?>> rows = new ArrayList<>();

        for (Ticket t : tickets) {

            int id = t.getId();

            CustomRetailer cr = partnerMap.get(t.getFofoId());

            String partner = cr != null ? nvl(cr.getBusinessName()) : "";

            TicketCategory cat = catMap.get(t.getSubCategoryId());

            String category = cat != null ? nvl(cat.getName()) : "";

            TicketSubCategory sub = subMap.get(t.getSubCategoryId());

            String subCategory = sub != null ? nvl(sub.getName()) : "";

            String message = "-";

            Activity msgAct = lastMessageMap.get(id);

            if (msgAct == null) {

                List<Activity> list = activityByTicket.get(id);

                if (list != null && !list.isEmpty()) msgAct = list.get(0);

            }

            if (msgAct != null) {

                String prefix = "~Partner";

                if (msgAct.getCreatedBy() > 0 && authUserMap.get(msgAct.getCreatedBy()) != null) {

                    prefix = "~" + nvl(authUserMap.get(msgAct.getCreatedBy()).getFirstName());

                }

                message = prefix + " " + nvl(msgAct.getMessage());

            }

            String createdBy = "Partner";

            Activity firstAct = activityById.get(t.getFirstActivityId());

            if (firstAct != null && firstAct.getCreatedBy() > 0) {

                AuthUser u = authUserMap.get(firstAct.getCreatedBy());

                if (u != null) createdBy = (nvl(u.getFirstName()) + " " + nvl(u.getLastName())).trim();

            }

            String assignedTo = "";

            List<AuthUser> assignees = assigneeListMap.get(id);

            if (assignees != null && !assignees.isEmpty()) {

                assignedTo = assignees.stream()

                        .map(u -> (nvl(u.getFirstName()) + " " + nvl(u.getLastName())).trim())

                        .collect(Collectors.joining(", "));

            } else if (authUserIdMap.get(id) != null) {

                AuthUser a = authUserIdMap.get(id);

                assignedTo = (nvl(a.getFirstName()) + " " + nvl(a.getLastName())).trim();

            }

            String createdTs = t.getFormattedCreateTimestamp() != null ? t.getFormattedCreateTimestamp() : "";

            rows.add(Arrays.asList(id, partner, category, subCategory, message, createdBy, assignedTo, createdTs));

        }

        org.apache.commons.io.output.ByteArrayOutputStream baos = FileUtil.getCSVByteStream(

                Arrays.asList("Ticket Id", "Partner", "Category", "SubCategory", "Message",

                        "Created By", "Assigned To", "Created TimeStamp"),

                rows);

        return orderService.downloadReportInCsv(baos, rows, "Tickets_" + ticketStatus.name());

    }

    private void populateMyTicketModel(HttpServletRequest request, SortOrder sortOrder, TicketStatus ticketStatus,

                                       TicketSearchType ticketSearchType, int searchTerm, int page, int pageSize,

                                       String searchText, Model model) throws ProfitMandiBusinessException {

        LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

        List<Ticket> tickets = null;

        List<TicketAssigned> ticketAssigneds = null;

        long totalRecords = 0;

        Map<Integer, AuthUser> authUserIdAndAuthUserMap = null;

        boolean isAdmin = roleManager.isAdmin(new HashSet<>(loginDetails.getRoleIds()));

        AuthUser currentAuthUser = isAdmin ? authRepository.selectByEmailOrMobile(loginDetails.getEmailId()) : null;

        boolean isCrmUser = isAdmin && currentAuthUser != null && positionRepository.hasCategory(currentAuthUser.getId(), ProfitMandiConstants.TICKET_CATEGORY_CRM);

        boolean isSalesUser = isAdmin && currentAuthUser != null && positionRepository.hasCategory(currentAuthUser.getId(), ProfitMandiConstants.TICKET_CATEGORY_SALES);

        boolean isRbmUser = isAdmin && currentAuthUser != null && positionRepository.hasCategory(currentAuthUser.getId(), ProfitMandiConstants.TICKET_CATEGORY_RBM);

        List<Integer> userCategoryIds = isAdmin && currentAuthUser != null

                ? positionRepository.selectCategoryIdsByAuthUserId(currentAuthUser.getId())

                : Collections.emptyList();

        int offset = page * pageSize;

        if (isAdmin) {

            int authUserId = currentAuthUser.getId();

            if (isCrmUser) {

                Optional<Boolean> resolvedOpt = ticketStatus.equals(TicketStatus.RESOLVED) ? Optional.empty() : Optional.of(TicketStatus.CLOSED.equals(ticketStatus));

                tickets = ticketRepository.selectAllTicketsPaginated(

                        resolvedOpt, sortOrder, ticketSearchType, searchTerm, searchText,

                        userCategoryIds, offset, pageSize);

                totalRecords = ticketRepository.selectAllTicketsPaginatedCount(

                        resolvedOpt, ticketSearchType, searchTerm, searchText, userCategoryIds);

            } else {

                Optional<Boolean> resolvedOpt = ticketStatus.equals(TicketStatus.RESOLVED) ? Optional.empty() : Optional.of(TicketStatus.CLOSED.equals(ticketStatus));

                tickets = ticketRepository.selectAllByAssigneePaginated(

                        authUserId, resolvedOpt, sortOrder, ticketSearchType, searchTerm, searchText,

                        offset, pageSize);

                totalRecords = ticketRepository.selectAllByAssigneePaginatedCount(

                        authUserId, resolvedOpt, ticketSearchType, searchTerm, searchText);

            }

            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);

            totalRecords = ticketRepository.selectAllCountByCreator(loginDetails.getFofoId(), Optional.of(TicketStatus.OPENED.equals(ticketStatus)));

        }

        authUserIdAndAuthUserMap = csService.getTicketIdAndAuthUserMapUsingTickets(tickets);

        if (authUserIdAndAuthUserMap == null) {

            authUserIdAndAuthUserMap = new HashMap<>();

        }

        Map<Integer, List<AuthUser>> authUserListMap = csService.getAssignedAuthList(tickets);

        if (authUserListMap == null) {

            authUserListMap = new HashMap<>();

        }

        int totalPages = (int) Math.ceil((double) totalRecords / pageSize);

        if (totalPages == 0) totalPages = 1;

        int startRecord = totalRecords > 0 ? offset + 1 : 0;

        int endRecord = (int) Math.min(offset + pageSize, totalRecords);

        model.addAttribute("size", totalRecords);

        model.addAttribute("totalRecords", totalRecords);

        model.addAttribute("currentPage", page);

        model.addAttribute("pageSize", pageSize);

        model.addAttribute("totalPages", totalPages);

        model.addAttribute("startRecord", startRecord);

        model.addAttribute("endRecord", endRecord);

        model.addAttribute("searchText", searchText != null ? searchText : "");

        model.addAttribute("currentPageDisplay", page + 1);

        model.addAttribute("prevPage", page - 1);

        model.addAttribute("nextPage", page + 1);

        model.addAttribute("lastPage", totalPages - 1);

        model.addAttribute("roleType", isAdmin);

        model.addAttribute("isCrmUser", isCrmUser);

        model.addAttribute("isSalesUser", isSalesUser);

        model.addAttribute("salesCategoryId", ProfitMandiConstants.TICKET_CATEGORY_SALES);

        model.addAttribute("isRbmUser", isRbmUser);

        model.addAttribute("rbmCategoryId", ProfitMandiConstants.TICKET_CATEGORY_RBM);

        model.addAttribute("userCategoryIds", userCategoryIds);

        List<Integer> subCategoryIds = tickets.stream().map(x -> x.getSubCategoryId()).collect(Collectors.toList());

        Map<Integer, TicketSubCategory> subCategoryIdAndSubCategoryMap = csService.getSubCategoryIdAndSubCategoryMap(subCategoryIds);

        if (subCategoryIdAndSubCategoryMap == null) {

            subCategoryIdAndSubCategoryMap = new HashMap<>();

        }

        Map<Integer, TicketCategory> subCategoryIdAndCategoryMap = csService.getSubCategoryIdAndCategoryMap(subCategoryIds);

        if (subCategoryIdAndCategoryMap == null) {

            subCategoryIdAndCategoryMap = new HashMap<>();

        }

        List<Integer> ticketIds = tickets.stream().map(x -> x.getId()).collect(Collectors.toList());

        Map<Integer, List<Activity>> activityMap = new HashMap<>();

        Map<Integer, List<Activity>> activityMapWithActivityId = new HashMap<>();

        Map<Integer, AuthUser> authUserMap = new HashMap<>();

        if (!ticketIds.isEmpty()) {

            List<Activity> allActivities = activityRepository.selectAll(ticketIds);

            activityMap = allActivities.stream().collect(Collectors.groupingBy(Activity::getTicketId));

            activityMapWithActivityId = allActivities.stream().collect(Collectors.groupingBy(Activity::getId));

            Set<Integer> activityCreatorIds = allActivities.stream()

                    .map(Activity::getCreatedBy)

                    .filter(id -> id > 0)

                    .collect(Collectors.toSet());

            if (!activityCreatorIds.isEmpty()) {

                authUserMap = authRepository.selectByIds(new ArrayList<>(activityCreatorIds))

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

            }

        }

        int currentUserId;

        UserType currentUserType;

        if (isAdmin) {

            currentUserId = currentAuthUser.getId();

            currentUserType = UserType.AUTH_USER;

        } else {

            currentUserId = loginDetails.getFofoId();

            currentUserType = UserType.PARTNER;

        }

        Map<Integer, Boolean> unreadMap = csService.getUnreadStatusForTickets(tickets, currentUserId, currentUserType);

        Map<Integer, Activity> lastActivityMap = csService.getLastActivitiesForTickets(ticketIds);

        Map<Integer, Activity> lastMessageMap = csService.getLastMessageActivitiesForTickets(ticketIds);

        model.addAttribute("unreadMap", unreadMap);

        model.addAttribute("lastActivityMap", lastActivityMap);

        model.addAttribute("lastMessageMap", lastMessageMap);

        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("authUserListMap", authUserListMap);

        model.addAttribute("subCategoryIdAndSubCategoryMap", subCategoryIdAndSubCategoryMap);

        model.addAttribute("subCategoryIdAndCategoryMap", subCategoryIdAndCategoryMap);

        model.addAttribute("activityMap", activityMap);

        model.addAttribute("authUserMap", authUserMap);

        model.addAttribute("activityMapWithActivityId", activityMapWithActivityId);

        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);

    }

    @GetMapping(value = "/cs/getActivities")

    public String getActivity(HttpServletRequest request, @RequestParam(name = "ticketId", defaultValue = "0") int ticketId, Model model) throws Exception {

        LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

        Ticket ticket = ticketRepository.selectById(ticketId);

        if (ticket == null) {

            throw new ProfitMandiBusinessException("Ticket", ticketId, "Ticket not found");

        }

        // Authorization check: verify user has access to this ticket

        boolean isAdmin = roleManager.isAdmin(loginDetails.getRoleIds());

        if (!isAdmin) {

            // Partners can only view their own tickets

            if (ticket.getFofoId() != loginDetails.getFofoId()) {

                throw new ProfitMandiBusinessException("Ticket", ticketId, "You do not have permission to view this ticket");

            }

        } else {

            // Admins must be assigned to the ticket OR be CRM user OR be in the escalation chain

            AuthUser currentAuthUser = authRepository.selectByEmailOrMobile(loginDetails.getEmailId());

            boolean isCrmUser = positionRepository.hasCategory(currentAuthUser.getId(), ProfitMandiConstants.TICKET_CATEGORY_CRM);

            if (!isCrmUser) {

                // Assigned = user was ever the assignee or manager on this ticket (any level).

                // The old l1..l5AuthUser fallback check was fully subsumed by this since it

                // includes every past TicketAssigned row.

                List<TicketAssigned> assignments = ticketAssignedRepository.selectByTicketIds(Arrays.asList(ticketId));

                boolean isAssigned = assignments.stream().anyMatch(ta -> ta.getAssineeId() == currentAuthUser.getId() || ta.getManagerId() == currentAuthUser.getId());

                // Check if user is related to this partner (RBM, ASM, BM etc.)

                boolean isRelatedToPartner = false;

                if (!isAssigned) {

                    List<AuthUser> relatedUsers = csService.getAuthUserIdByPartnerId(ticket.getFofoId());

                    isRelatedToPartner = relatedUsers.stream()

                            .anyMatch(au -> au.getId() == currentAuthUser.getId());

                    if (!isRelatedToPartner) {

                        throw new ProfitMandiBusinessException("Ticket", ticketId, "You do not have permission to view this ticket");

                    }

                }

                // User can view but cannot take action if only related to partner (not assigned)

                model.addAttribute("canTakeAction", isAssigned);

            }

        }

        List<Activity> allactivities = activityRepository.selectAll(ticketId);

        // Batch fetch all documents for attachments (fix N+1 query)

        List<Integer> documentIds = allactivities.stream()

                .flatMap(a -> a.getActivityAttachment().stream())

                .map(ActivityAttachment::getDocumentId)

                .distinct()

                .collect(Collectors.toList());

        Map<Integer, Document> documentMap = Collections.emptyMap();

        if (!documentIds.isEmpty()) {

            documentMap = documentRepository.selectByIds(documentIds).stream()

                    .collect(Collectors.toMap(Document::getId, d -> d));

        }

        // Set document names transiently (do not persist during GET)

        for (Activity activity : allactivities) {

            for (ActivityAttachment attachment : activity.getActivityAttachment()) {

                Document document = documentMap.get(attachment.getDocumentId());

                if (document != null) {

                    attachment.setDocumentName(document.getDisplayName());

                }

            }

        }

        List<Activity> activities = null;

        if (isAdmin) {

            Set<Integer> authUserIds = allactivities.stream().map(x -> x.getCreatedBy()).collect(Collectors.toSet());

            // Fetch current assignees for this ticket to show in ASSIGNED/ESCALATED activities

            List<TicketAssigned> ticketAssignments = ticketAssignedRepository.selectByTicketIds(Arrays.asList(ticketId));

            Set<Integer> assigneeIds = ticketAssignments.stream()

                    .map(TicketAssigned::getAssineeId)

                    .collect(Collectors.toSet());

            authUserIds.addAll(assigneeIds);

            List<AuthUser> users = authRepository.selectByIds(new ArrayList<>(authUserIds));

            Map<Integer, String> authUserNameMap = users.stream().collect(Collectors.toMap(AuthUser::getId, x -> x.getFirstName() + " " + x.getLastName()));

            // Get current assignee name (most recent assignment)

            String currentAssigneeName = null;

            if (!ticketAssignments.isEmpty()) {