Subversion Repositories SmartDukaan

package com.spice.profitmandi.web.controller;

import java.time.LocalDateTime;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.HashSet;

import java.util.List;

import java.util.Map;

import java.util.Optional;

import java.util.Set;

import java.util.stream.Collectors;

import javax.servlet.http.HttpServletRequest;

import javax.swing.SortOrder;

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.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.common.util.Utils;

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

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

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

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.TicketSearchType;

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

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.PartnersPositionRepository;

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.dao.repository.dtr.FofoStoreRepository;

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

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

	@Autowired

	PartnersPositionRepository partnersPositionRepository;

	@Autowired

	FofoStoreRepository fofoStoreRepository;

	@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/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> fofoRetailers = retailerService.getFofoRetailers(fofoIds);

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

		Map<Integer, List<CustomRetailer>> positionIdAndpartnerRegionMap = csService

				.getpositionIdAndpartnerRegionMap(positions);

		Map<Integer, List<CustomRetailer>> addedpositionIdAndCustomRetailerMap = csService

				.getPositionCustomRetailerMap(positions);

		LOGGER.info("fofoIdAndCustomRetailerMap" + addedpositionIdAndCustomRetailerMap);

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

		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("response", 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("response", 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("response", mvcResponseSender.createResponseString(false));

		} else {

			csService.createTicket(loginDetails.getFofoId(), categoryId, subCategoryId, message);

			model.addAttribute("response", 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<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("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 = "internal", defaultValue = "true") boolean internal,

			@RequestParam(name = "message", defaultValue = "") String message, Model model) throws Exception {

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

			csService.addActivity(ticket, activity);

			AuthUser authUser = authUsersMap.remove(authUserIds.get(0));

			if(authUser==null) {

				authUser = authUsersMap.remove(authUserIds.get(1));

			}

			model.addAttribute("response", 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("response", 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 (loginDetails.getEmailId().equals("amandeep.singh@smartdukaan.com")) {

			tickets = ticketRepository.selectAll(offset, limit, Optional.empty());

			authUserListMap = csService.getAssignedAuthList(tickets);

			size = ticketRepository.selectAllCount();

		} else {

			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 (loginDetails.getEmailId().equals("amandeep.singh@smartdukaan.com")) {

			tickets = ticketRepository.selectAll(offset, limit, Optional.empty());

			authUserListMap = csService.getAssignedAuthList(tickets);

		} else {

			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("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";

	}

	@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("response", mvcResponseSender.createResponseString(true));

		return "response";

	}

}