Subversion Repositories SmartDukaan

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

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

	private static final String ACTIVITY_SUBJECT = "Message related ticketId#%s";

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

    private static final String INTERNAL_REOPEN_ACTIVITY_MESSAGE = "Hi,My ticket is not resolved yet,so I have reopened it";

	@Autowired

    @Autowired

	JavaMailSender mailSender;

    JavaMailSender mailSender;

	@Autowired

    @Autowired

	private CsService csService;

    private CsService csService;

	@Autowired

    @Autowired

	private CookiesProcessor cookiesProcessor;

    private CookiesProcessor cookiesProcessor;

	@Autowired

    @Autowired

	private TicketCategoryRepository ticketCategoryRepository;

    private TicketCategoryRepository ticketCategoryRepository;

	@Autowired

    @Autowired

	private TicketSubCategoryRepository ticketSubCategoryRepository;

    private TicketSubCategoryRepository ticketSubCategoryRepository;

	@Autowired

    @Autowired

	private RegionRepository regionRepository;

    private RegionRepository regionRepository;

	@Autowired

    @Autowired

	private RetailerService retailerService;

    private RetailerService retailerService;

	@Autowired

    @Autowired

	private MVCResponseSender mvcResponseSender;

    private MVCResponseSender mvcResponseSender;

	@Autowired

    @Autowired

	private AuthRepository authRepository;

    private AuthRepository authRepository;

	@Autowired

    @Autowired

	private PositionRepository positionRepository;

    private PositionRepository positionRepository;

	@Autowired

    @Autowired

	private TicketRepository ticketRepository;

    private TicketRepository ticketRepository;

	@Autowired

    @Autowired

	private RoleManager roleManager;

    private RoleManager roleManager;

	@Autowired

    @Autowired

	private ActivityRepository activityRepository;

    private ActivityRepository activityRepository;

	@Autowired

    @Autowired

	private ActivityAttachmentRepository activityAttachmentRepository;

    private ActivityAttachmentRepository activityAttachmentRepository;

	@Autowired

    @Autowired

	private TicketAssignedRepository ticketAssignedRepository;

    private TicketAssignedRepository ticketAssignedRepository;

	@Autowired

    @Autowired

	private PartnerRegionRepository partnerRegionRepository;

    private PartnerRegionRepository partnerRegionRepository;

	@Autowired

    @Autowired

	PartnersPositionRepository partnersPositionRepository;

    PartnersPositionRepository partnersPositionRepository;

	@Autowired

    @Autowired

	FofoStoreRepository fofoStoreRepository;

    FofoStoreRepository fofoStoreRepository;

	@Autowired

    @Autowired

	DocumentRepository documentRepository;

    DocumentRepository documentRepository;

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

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

	public String getCreateCategory(HttpServletRequest request, Model model) {

    public String getCreateCategory(HttpServletRequest request, Model model) {

		List<TicketCategory> ticketCategories = ticketCategoryRepository.selectAll();

        List<TicketCategory> ticketCategories = ticketCategoryRepository.selectAll();

		model.addAttribute("ticketCategories", ticketCategories);

        model.addAttribute("ticketCategories", ticketCategories);

		return "create-ticket-category";

        return "create-ticket-category";

	}

    }

	@PostMapping(value = "/cs/createCategory")

    @PostMapping(value = "/cs/createCategory")

	public String createCategory(HttpServletRequest request, @RequestParam(name = "name") String name,

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

			@RequestParam(name = "description") String description, Model model) throws ProfitMandiBusinessException {

        TicketCategory ticketCategory = ticketCategoryRepository.selectByName(name);

		TicketCategory ticketCategory = ticketCategoryRepository.selectByName(name);

        if (ticketCategory != null) {

		if (ticketCategory != null) {

            throw new ProfitMandiBusinessException("name", name, "already exists!");

			throw new ProfitMandiBusinessException("name", name, "already exists!");

        }

		}

        ticketCategory = new TicketCategory();

		ticketCategory = new TicketCategory();

        ticketCategory.setName(name);

		ticketCategory.setName(name);

        ticketCategory.setDescription(description);

		ticketCategory.setDescription(description);

        ticketCategoryRepository.persist(ticketCategory);

		ticketCategoryRepository.persist(ticketCategory);

        return "create-ticket-category";

		return "create-ticket-category";

    }

	}

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

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

    public String getCreateSubCategory(HttpServletRequest request, Model model) {

	public String getCreateSubCategory(HttpServletRequest request, Model model) {

        List<TicketCategory> ticketCategories = ticketCategoryRepository.selectAll();

		List<TicketCategory> ticketCategories = ticketCategoryRepository.selectAll();

        model.addAttribute("ticketCategories", ticketCategories);

		model.addAttribute("ticketCategories", ticketCategories);

        return "create-ticket-sub-category";

		return "create-ticket-sub-category";

    }

	}

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

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

    public String getSubCategoryByCategoryId(HttpServletRequest request, @RequestParam(name = "ticketCategoryId", defaultValue = "") int ticketCategoryId, Model model) {

	public String getSubCategoryByCategoryId(HttpServletRequest request,

        List<TicketSubCategory> ticketSubCategories = ticketSubCategoryRepository.selectAll(ticketCategoryId);

			@RequestParam(name = "ticketCategoryId", defaultValue = "") int ticketCategoryId, Model model) {

        TicketCategory ticketCategory = ticketCategoryRepository.selectById(ticketCategoryId);

		List<TicketSubCategory> ticketSubCategories = ticketSubCategoryRepository.selectAll(ticketCategoryId);

        model.addAttribute("ticketSubCategories", ticketSubCategories);

		TicketCategory ticketCategory = ticketCategoryRepository.selectById(ticketCategoryId);

        model.addAttribute("ticketCategory", ticketCategory);

		model.addAttribute("ticketSubCategories", ticketSubCategories);

        return "ticket-sub-category";

		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 {

	@PostMapping(value = "/cs/createSubCategory")

	public String createSubCategory(HttpServletRequest request,

        TicketSubCategory ticketSubCategory = ticketSubCategoryRepository.selectTicketSubCategory(categoryId, name);

			@RequestParam(name = "categoryId", defaultValue = "0") int categoryId,

        if (ticketSubCategory != null) {

			@RequestParam(name = "name") String name, @RequestParam(name = "description") String description,

            throw new ProfitMandiBusinessException("name & categoryId", name + "  " + categoryId, "already exists!");

			Model model) throws ProfitMandiBusinessException {

        }

		TicketSubCategory ticketSubCategory = ticketSubCategoryRepository.selectTicketSubCategory(categoryId, name);

        ticketSubCategory = new TicketSubCategory();

		if (ticketSubCategory != null) {

        ticketSubCategory.setCategoryId(categoryId);

			throw new ProfitMandiBusinessException("name & categoryId", name + "  " + categoryId, "already exists!");

        ticketSubCategory.setName(name);

		}

        ticketSubCategory.setDescription(description);

        ticketSubCategoryRepository.persist(ticketSubCategory);

		ticketSubCategory = new TicketSubCategory();

        return "create-ticket-sub-category";

		ticketSubCategory.setCategoryId(categoryId);

    }

		ticketSubCategory.setName(name);

		ticketSubCategory.setDescription(description);

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

		ticketSubCategoryRepository.persist(ticketSubCategory);

    public String createRegion(HttpServletRequest request, Model model) {

		return "create-ticket-sub-category";

        List<Region> regions = regionRepository.selectAll();

	}

        model.addAttribute("regions", regions);

        return "create-region";

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

    }

	public String createRegion(HttpServletRequest request, Model model) {

		List<Region> regions = regionRepository.selectAll();

    @PostMapping(value = "/cs/createRegion")

		model.addAttribute("regions", regions);

    public String createRegion(HttpServletRequest request, @RequestParam(name = "name") String name, @RequestParam(name = "description") String description, Model model) throws Exception {

		return "create-region";

        Region region = regionRepository.selectByName(name);

	}

        if (region != null) {

            throw new ProfitMandiBusinessException("name", name, "already exists!");

	@PostMapping(value = "/cs/createRegion")

        }

	public String createRegion(HttpServletRequest request, @RequestParam(name = "name") String name,

        region = new Region();

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

        region.setName(name);

		Region region = regionRepository.selectByName(name);

        region.setDescription(description);

		if (region != null) {

        regionRepository.persist(region);

			throw new ProfitMandiBusinessException("name", name, "already exists!");

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

		}

        return "response";

		region = new Region();

    }

		region.setName(name);

		region.setDescription(description);

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

		regionRepository.persist(region);

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

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

        List<Integer> fofoIds = fofoStoreRepository.selectAll().stream().map(x -> x.getId()).collect(Collectors.toList());

		return "response";

        List<Integer> addedfofoIds = partnerRegionRepository.selectByRegionId(regionId).stream().map(x -> x.getFofoId()).collect(Collectors.toList());

	}

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

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

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

	public String getPartners(HttpServletRequest request,

        model.addAttribute("fofoRetailers", fofoRetailers);

			@RequestParam(name = "regionId", defaultValue = "0") int regionId, Model model) {

        model.addAttribute("addedfofoIds", addedfofoIds);

		List<Integer> fofoIds = fofoStoreRepository.selectAll().stream().map(x -> x.getId())

        return "added-region-partners";

				.collect(Collectors.toList());

    }

		List<Integer> addedfofoIds = partnerRegionRepository.selectByRegionId(regionId).stream().map(x -> x.getFofoId())

				.collect(Collectors.toList());

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

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

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

        List<Integer> fofoIds = null;

		Map<Integer, CustomRetailer> fofoRetailers = fofoIds.stream().map(x -> customRetailerMap.get(x))

        fofoIds = partnerRegionRepository.selectByRegionId(regionId).stream().map(x -> x.getFofoId()).collect(Collectors.toList());

				.filter(x -> x != null).collect(Collectors.toList()).stream()

				.collect(Collectors.toMap(x -> x.getPartnerId(), x -> x));

        if (fofoIds.contains(0)) {

		model.addAttribute("fofoRetailers", fofoRetailers);

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

		model.addAttribute("addedfofoIds", addedfofoIds);

		return "added-region-partners";

        }

	}

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

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

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

	public String getPartnersByRegion(HttpServletRequest request,

        model.addAttribute("fofoRetailers", fofoRetailers);

			@RequestParam(name = "regionId", defaultValue = "0") int regionId, Model model) {

        return "added-subregion-partners";

		List<Integer> fofoIds = null;

    }

		fofoIds = partnerRegionRepository.selectByRegionId(regionId).stream().map(x -> x.getFofoId())

				.collect(Collectors.toList());

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

    public String createPartnerRegion(HttpServletRequest request, Model model) {

		if (fofoIds.contains(0)) {

        List<Region> regions = regionRepository.selectAll();

			fofoIds = fofoStoreRepository.selectAll().stream().filter(x -> x.isActive()).collect(Collectors.toList())

        model.addAttribute("regions", regions);

					.stream().map(x -> x.getId()).collect(Collectors.toList());

        return "create-partner-region";

    }

		}

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

    @PostMapping(value = "/cs/createPartnerRegion")

    public String createPartnerRegion(HttpServletRequest request, @RequestParam(name = "regionId") int regionId, @RequestBody List<Integer> selectedFofoIds, Model model) throws Exception {

		Map<Integer, CustomRetailer> fofoRetailers = fofoIds.stream().map(x -> customRetailerMap.get(x))

        partnerRegionRepository.delete(regionId);

				.filter(x -> x != null).collect(Collectors.toList()).stream()

        LOGGER.info("successfully removed");

				.collect(Collectors.toMap(x -> x.getPartnerId(), x -> x));

        LOGGER.info(selectedFofoIds.size());

		model.addAttribute("fofoRetailers", fofoRetailers);

        csService.addPartnerToRegion(regionId, selectedFofoIds);

		return "added-subregion-partners";

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

	}

        return "response";

    }

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

	public String createPartnerRegion(HttpServletRequest request, Model model) {

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

		List<Region> regions = regionRepository.selectAll();

    public String getPosition(HttpServletRequest request, @RequestParam int positionId, Model model) {

		model.addAttribute("regions", regions);

		return "create-partner-region";

        Position position = positionRepository.selectById(positionId);

	}

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

	@PostMapping(value = "/cs/createPartnerRegion")

	public String createPartnerRegion(HttpServletRequest request, @RequestParam(name = "regionId") int regionId,

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

			@RequestBody List<Integer> selectedFofoIds, Model model) throws Exception {

		partnerRegionRepository.delete(regionId);

        model.addAttribute("position", position);

		LOGGER.info("successfully removed");

        model.addAttribute("regionRetailerMap", regionRetailerMap);

		LOGGER.info(selectedFofoIds.size());

        model.addAttribute("positionIdCustomRetailer", positionIdCustomRetailer);

		csService.addPartnerToRegion(regionId, selectedFofoIds);

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

        return "position-partner";

		return "response";

    }

	}

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

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

    public String createPosition(HttpServletRequest request, @RequestParam(name = "offset", defaultValue = "0") int offset, @RequestParam(name = "limit", defaultValue = "10") int limit, Model model) {

	public String getPosition(HttpServletRequest request, @RequestParam int positionId, Model model) {

        List<AuthUser> authUsers = authRepository.selectAllActiveUser();

        List<TicketCategory> ticketCategories = ticketCategoryRepository.selectAll();

		Position position = positionRepository.selectById(positionId);

        List<Region> regions = regionRepository.selectAll();

        model.addAttribute("escalationTypes", EscalationType.values());

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

        model.addAttribute("authUsers", authUsers);

				.get(position.getId());

        model.addAttribute("ticketCategories", ticketCategories);

        model.addAttribute("regions", regions);

		Map<Integer, CustomRetailer> regionRetailerMap = csService.getRegionPartners(Arrays.asList(position))

				.get(position.getRegionId()).stream().collect(Collectors.toMap(x -> x.getPartnerId(), x -> x));

        List<Position> positions = positionRepository.selectAllPosition();

        LOGGER.info("positions" + positions);

		model.addAttribute("position", position);

		model.addAttribute("regionRetailerMap", regionRetailerMap);

        Map<Integer, AuthUser> authUserIdAndAuthUserMap = csService.getAuthUserIdAndAuthUserMapUsingPositions(positions);

		model.addAttribute("positionIdCustomRetailer", positionIdCustomRetailer);

        Map<Integer, TicketCategory> categoryIdAndCategoryMap = csService.getCategoryIdAndCategoryUsingPositions(positions);

        Map<Integer, Region> regionIdAndRegionMap = csService.getRegionIdAndRegionMap(positions);

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

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

		model.addAttribute("positions", positions);

        model.addAttribute("positions", positions);

		model.addAttribute("authUserIdAndAuthUserMap", authUserIdAndAuthUserMap);

        model.addAttribute("authUserIdAndAuthUserMap", authUserIdAndAuthUserMap);

		model.addAttribute("categoryIdAndCategoryMap", categoryIdAndCategoryMap);

        model.addAttribute("categoryIdAndCategoryMap", categoryIdAndCategoryMap);

		model.addAttribute("regionIdAndRegionMap", regionIdAndRegionMap);

        model.addAttribute("regionIdAndRegionMap", regionIdAndRegionMap);

		// model.addAttribute("positionIdAndCustomRetailerMap",

        // model.addAttribute("positionIdAndCustomRetailerMap",

		// addedpositionIdAndCustomRetailerMap);

        // addedpositionIdAndCustomRetailerMap);

		// model.addAttribute("positionIdAndpartnerRegionMap",

        // model.addAttribute("positionIdAndpartnerRegionMap",

		return "create-position";

        return "create-position";

	}

	@GetMapping(value = "/cs/position-paginated")

        List<Position> positions = positionRepository.selectAll(offset, limit);

	public String positionPaginated(HttpServletRequest request,

        Map<Integer, AuthUser> authUserIdAndAuthUserMap = csService.getAuthUserIdAndAuthUserMapUsingPositions(positions);

			@RequestParam(name = "offset", defaultValue = "0") int offset,

        Map<Integer, TicketCategory> categoryIdAndCategoryMap = csService.getCategoryIdAndCategoryUsingPositions(positions);

			@RequestParam(name = "limit", defaultValue = "10") int limit, Model model) {

        Map<Integer, Region> regionIdAndRegionMap = csService.getRegionIdAndRegionMap(positions);

        /*

		List<Position> positions = positionRepository.selectAll(offset, limit);

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

		Map<Integer, AuthUser> authUserIdAndAuthUserMap = csService

         * .getpositionIdAndpartnerRegionMap(positions);

				.getAuthUserIdAndAuthUserMapUsingPositions(positions);

         * 

		Map<Integer, TicketCategory> categoryIdAndCategoryMap = csService

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

				.getCategoryIdAndCategoryUsingPositions(positions);

         * csService .getPositionCustomRetailerMap(positions);

		Map<Integer, Region> regionIdAndRegionMap = csService.getRegionIdAndRegionMap(positions);

         */

		/*

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

        model.addAttribute("positions", positions);

		 * .getpositionIdAndpartnerRegionMap(positions);

        model.addAttribute("authUserIdAndAuthUserMap", authUserIdAndAuthUserMap);

		 * 

        model.addAttribute("categoryIdAndCategoryMap", categoryIdAndCategoryMap);

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

        model.addAttribute("regionIdAndRegionMap", regionIdAndRegionMap);

		 * csService .getPositionCustomRetailerMap(positions);

        // model.addAttribute("positionIdAndCustomRetailerMap",

		 */

        // addedpositionIdAndCustomRetailerMap);

        // model.addAttribute("positionIdAndpartnerRegionMap",

		model.addAttribute("positions", positions);

        // positionIdAndpartnerRegionMap);

		model.addAttribute("authUserIdAndAuthUserMap", authUserIdAndAuthUserMap);

		model.addAttribute("categoryIdAndCategoryMap", categoryIdAndCategoryMap);

        return "position-paginated";

		model.addAttribute("regionIdAndRegionMap", regionIdAndRegionMap);

    }

		// model.addAttribute("positionIdAndCustomRetailerMap",

		// addedpositionIdAndCustomRetailerMap);

    @PostMapping(value = "/cs/createPosition")

		// model.addAttribute("positionIdAndpartnerRegionMap",

    public String createPosition(HttpServletRequest request, @RequestBody CreatePositionModel createPositionModel, Model model) throws Exception {

		// positionIdAndpartnerRegionMap);

		return "position-paginated";

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

	}

        Position position = positionRepository.selectPosition(createPositionModel.getAuthUserId(), createPositionModel.getCategoryId(), createPositionModel.getRegionId(), createPositionModel.getEscalationType());

        if (position == null) {

	@PostMapping(value = "/cs/createPosition")

            position = new Position();

	public String createPosition(HttpServletRequest request, @RequestBody CreatePositionModel createPositionModel,

            position.setAuthUserId(createPositionModel.getAuthUserId());

			Model model) throws Exception {

            position.setCategoryId(createPositionModel.getCategoryId());

            position.setEscalationType(createPositionModel.getEscalationType());

		Position position = positionRepository.selectPosition(createPositionModel.getAuthUserId(),

            position.setRegionId(createPositionModel.getRegionId());

				createPositionModel.getCategoryId(), createPositionModel.getRegionId(),

            position.setCreateTimestamp(LocalDateTime.now());

				createPositionModel.getEscalationType());

            position.setTicketAssignee(createPositionModel.isTicketAssigned());

		if (position == null) {

            positionRepository.persist(position);

			position = new Position();

			position.setAuthUserId(createPositionModel.getAuthUserId());

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

			position.setCategoryId(createPositionModel.getCategoryId());

			position.setEscalationType(createPositionModel.getEscalationType());

                PartnerPosition partnerPosition = new PartnerPosition();

			position.setRegionId(createPositionModel.getRegionId());

                partnerPosition.setFofoId(fofoId);

			position.setCreateTimestamp(LocalDateTime.now());

                partnerPosition.setRegionId(createPositionModel.getRegionId());

			positionRepository.persist(position);

                partnerPosition.setPositionId(position.getId());

                partnersPositionRepository.persist(partnerPosition);

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

                LOGGER.info("partnerPosition" + partnerPosition);

            }

				PartnerPosition partnerPosition = new PartnerPosition();

				partnerPosition.setFofoId(fofoId);

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

				partnerPosition.setRegionId(createPositionModel.getRegionId());

        } else {

				partnerPosition.setPositionId(position.getId());

            throw new ProfitMandiBusinessException("Position", createPositionModel.getAuthUserId(), "already exists!");

				partnersPositionRepository.persist(partnerPosition);

        }

				LOGGER.info("partnerPosition" + partnerPosition);

        return "response";

			}

    }

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

    @PostMapping(value = "/cs/updatePartnerPosition")

		} else {

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

			throw new ProfitMandiBusinessException("Position", createPositionModel.getAuthUserId(), "already exists!");

		}

        partnersPositionRepository.delete(positionId);

		return "response";

        for (int fofoId : selectedFofoIds) {

	}

            PartnerPosition partnerPosition = new PartnerPosition();

            partnerPosition.setFofoId(fofoId);

	@PostMapping(value = "/cs/updatePartnerPosition")

            partnerPosition.setRegionId(regionId);

	public String updatePartnerPosition(HttpServletRequest request, @RequestParam(name = "regionId") int regionId,

            partnerPosition.setPositionId(positionId);

			@RequestBody List<Integer> selectedFofoIds, @RequestParam(name = "positionId") int positionId, Model model)

            partnersPositionRepository.persist(partnerPosition);

			throws Exception {

        }

		partnersPositionRepository.delete(positionId);

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

		for (int fofoId : selectedFofoIds) {

			PartnerPosition partnerPosition = new PartnerPosition();

        return "response";

			partnerPosition.setFofoId(fofoId);

    }

			partnerPosition.setRegionId(regionId);

			partnerPosition.setPositionId(positionId);

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

			partnersPositionRepository.persist(partnerPosition);

    public String createTicket(HttpServletRequest request, Model model) throws ProfitMandiBusinessException {

		}

        LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

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

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

        model.addAttribute("roleType", roleManager.isAdmin(loginDetails.getRoleIds()));

        model.addAttribute("ticketCategories", ticketCategories);

		return "response";

        return "create-ticket";

	}

    }

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

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

	public String createTicket(HttpServletRequest request, Model model) throws ProfitMandiBusinessException {

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

		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

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

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

        LOGGER.info(ticketSubCategories);

		model.addAttribute("roleType", roleManager.isAdmin(loginDetails.getRoleIds()));

        model.addAttribute("ticketSubCategories", ticketSubCategories);

		model.addAttribute("ticketCategories", ticketCategories);

        return "ticket-sub-categories";

		return "create-ticket";

    }

	}

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

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

	public String getSubCategoriesByCategoryId(HttpServletRequest request,

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

			@RequestParam(name = "categoryId", defaultValue = "0") int categoryId, Model model) {

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

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

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

		LOGGER.info(ticketSubCategories);

		model.addAttribute("ticketSubCategories", ticketSubCategories);

        if (!positions.isEmpty()) {

		return "ticket-sub-categories";

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

	}

        }

	@PostMapping(value = "/cs/createTicket")

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

	public String createTicket(HttpServletRequest request, @RequestParam(name = "categoryId") int categoryId,

			@RequestParam(name = "subCategoryId") int subCategoryId, @RequestParam(name = "message") String message,

        model.addAttribute("escalationTypes", escalationTypes);

			Model model) throws Exception {

        return "ticket-escalationtype";

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

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

		} else {

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

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

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

		}

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

		return "response";

	}

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

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

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

	public String getTicket(HttpServletRequest request,

			@RequestParam(name = "orderby", defaultValue = "DESCENDING") SortOrder sortOrder,

        if (!positions.isEmpty()) {

			@RequestParam(name = "ticketStatus", defaultValue = "OPENED") TicketStatus ticketStatus,

			@RequestParam(name = "ticketSearchType", defaultValue = "") TicketSearchType ticketSearchType,

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

			@RequestParam(name = "searchTerm", defaultValue = "0") int searchTerm,

            ticketCategories = ticketCategoryRepository.selectAll(categoryIds);

			@RequestParam(name = "offset", defaultValue = "0") int offset,

        }

			@RequestParam(name = "limit", defaultValue = "10") int limit, Model model)

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

			throws ProfitMandiBusinessException {

        model.addAttribute("ticketCategories", ticketCategories);

		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

        return "ticket-categories";

		List<Ticket> tickets = null;

    }

		List<TicketAssigned> ticketAssigneds = null;

		long size = 0;

    @PostMapping(value = "/cs/createTicket")

		Map<Integer, AuthUser> authUserIdAndAuthUserMap = null;

    public String createTicket(HttpServletRequest request, @RequestParam(name = "categoryId") int categoryId, @RequestParam(name = "subCategoryId") int subCategoryId, @RequestParam(name = "message") String message, Model model) throws Exception {

		if (roleManager.isAdmin(new HashSet<>(loginDetails.getRoleIds()))) {

        LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

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

        List<Ticket> tickets = ticketRepository.selectAllResolvedMarkedTicketByCreator(loginDetails.getFofoId());

			if (ticketSearchType == null) {

        if (tickets.size() > 3 || tickets.size() == 3) {

				if (ticketStatus.equals(TicketStatus.RESOLVED)) {

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

					tickets = ticketRepository.selectAllByAssignee(authUser.getId(), Optional.empty(), sortOrder, null,

        } else {

							searchTerm, offset, limit);

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

					size = ticketRepository.selectAllCountByAssignee(authUser.getId(), Optional.empty(), null,

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

							searchTerm);

        }

				} else {

        return "response";

					tickets = ticketRepository.selectAllByAssignee(authUser.getId(),

    }

							Optional.of(TicketStatus.CLOSED.equals(ticketStatus)), sortOrder, null, searchTerm, offset,

							limit);

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

					size = ticketRepository.selectAllCountByAssignee(authUser.getId(),

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

							Optional.of(TicketStatus.CLOSED.equals(ticketStatus)), null, searchTerm);

        LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

				}

        List<Ticket> tickets = null;

        List<TicketAssigned> ticketAssigneds = null;

			} else {

        long size = 0;

        Map<Integer, AuthUser> authUserIdAndAuthUserMap = null;

				if (ticketStatus.equals(TicketStatus.RESOLVED)) {

        if (roleManager.isAdmin(new HashSet<>(loginDetails.getRoleIds()))) {

					tickets = ticketRepository.selectAllByAssignee(authUser.getId(), Optional.empty(), sortOrder,

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

							ticketSearchType, searchTerm, offset, limit);

            if (ticketSearchType == null) {

					size = ticketRepository.selectAllCountByAssignee(authUser.getId(), Optional.empty(),

                if (ticketStatus.equals(TicketStatus.RESOLVED)) {

							ticketSearchType, searchTerm);

                    tickets = ticketRepository.selectAllByAssignee(authUser.getId(), Optional.empty(), sortOrder, null, searchTerm);

				} else {

                    size = ticketRepository.selectAllCountByAssignee(authUser.getId(), Optional.empty(), null, searchTerm);

					tickets = ticketRepository.selectAllByAssignee(authUser.getId(),

                } else {

							Optional.of(TicketStatus.CLOSED.equals(ticketStatus)), sortOrder, ticketSearchType,

                    tickets = ticketRepository.selectAllByAssignee(authUser.getId(), Optional.of(TicketStatus.CLOSED.equals(ticketStatus)), sortOrder, null, searchTerm);

							searchTerm, offset, limit);

                    size = ticketRepository.selectAllCountByAssignee(authUser.getId(), Optional.of(TicketStatus.CLOSED.equals(ticketStatus)), null, searchTerm);

					size = ticketRepository.selectAllCountByAssignee(authUser.getId(),

                }

							Optional.of(TicketStatus.CLOSED.equals(ticketStatus)), ticketSearchType, searchTerm);

				}

            } else {

			}

			// LOGGER.info(size + "size");

                if (ticketStatus.equals(TicketStatus.RESOLVED)) {

			if (tickets.size() > 0) {

                    tickets = ticketRepository.selectAllByAssignee(authUser.getId(), Optional.empty(), sortOrder, ticketSearchType, searchTerm);

				ticketAssigneds = ticketAssignedRepository

                    size = ticketRepository.selectAllCountByAssignee(authUser.getId(), Optional.empty(), ticketSearchType, searchTerm);

						.selectByTicketIds(tickets.stream().map(x -> x.getId()).collect(Collectors.toList()));

                } else {

				authUserIdAndAuthUserMap = csService.getAuthUserIdAndAuthUserMap(ticketAssigneds);

                    tickets = ticketRepository.selectAllByAssignee(authUser.getId(), Optional.of(TicketStatus.CLOSED.equals(ticketStatus)), sortOrder, ticketSearchType, searchTerm);

				Map<Integer, CustomRetailer> fofoIdsAndCustomRetailer = csService.getPartnerByFofoIds(tickets);

                    size = ticketRepository.selectAllCountByAssignee(authUser.getId(), Optional.of(TicketStatus.CLOSED.equals(ticketStatus)), ticketSearchType, searchTerm);

				model.addAttribute("fofoIdsAndCustomRetailer", fofoIdsAndCustomRetailer);

                }

			}

            }

            // LOGGER.info(size + "size");

		} else {

            if (tickets.size() > 0) {

			tickets = ticketRepository.selectAllByCreator(loginDetails.getFofoId(),

                ticketAssigneds = ticketAssignedRepository.selectByTicketIds(tickets.stream().map(x -> x.getId()).collect(Collectors.toList()));

					Optional.of(TicketStatus.OPENED.equals(ticketStatus)), sortOrder, offset, limit);

                authUserIdAndAuthUserMap = csService.getAuthUserIdAndAuthUserMap(ticketAssigneds);

			size = ticketRepository.selectAllCountByCreator(loginDetails.getFofoId(),

                Map<Integer, CustomRetailer> fofoIdsAndCustomRetailer = csService.getPartnerByFofoIds(tickets);

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

                model.addAttribute("fofoIdsAndCustomRetailer", fofoIdsAndCustomRetailer);

		}

            }

		authUserIdAndAuthUserMap = csService.getTicketIdAndAuthUserMapUsingTickets(tickets);

        } else {

		if (size < limit) {

            tickets = ticketRepository.selectAllByCreator(loginDetails.getFofoId(), Optional.of(TicketStatus.OPENED.equals(ticketStatus)), sortOrder);

			model.addAttribute("end", offset + size);

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

		} else {

        }

			model.addAttribute("end", offset + limit);

        authUserIdAndAuthUserMap = csService.getTicketIdAndAuthUserMapUsingTickets(tickets);

		}

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

        model.addAttribute("size", size);

		model.addAttribute("size", size);

        model.addAttribute("roleType", roleManager.isAdmin(new HashSet<>(loginDetails.getRoleIds())));

		model.addAttribute("roleType", roleManager.isAdmin(new HashSet<>(loginDetails.getRoleIds())));

		Map<Integer, TicketSubCategory> subCategoryIdAndSubCategoryMap = csService

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

				.getSubCategoryIdAndSubCategoryMap(tickets);

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

		model.addAttribute("tickets", tickets);

		model.addAttribute("resolved", ActivityType.RESOLVED);

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

		model.addAttribute("resolved-accepted", ActivityType.RESOLVED_ACCEPTED);

		model.addAttribute("resolved-rejected", ActivityType.RESOLVED_REJECTED);

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

		model.addAttribute("authUserIdAndAuthUserMap", authUserIdAndAuthUserMap);

		model.addAttribute("subCategoryIdAndSubCategoryMap", subCategoryIdAndSubCategoryMap);

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

		model.addAttribute("ticketStatusValues", TicketStatus.values());

		model.addAttribute("orderByValues", SortOrder.values());

        if (!ticketIds.isEmpty()) {

		model.addAttribute("selectedticketStatus", ticketStatus);

            activityMap = activityRepository.selectAll(ticketIds).stream().collect(Collectors.groupingBy(x -> x.getTicketId()));

		model.addAttribute("selectedorderby", sortOrder);

		model.addAttribute("ticketSearchTypes", TicketSearchType.values());

        }

		model.addAttribute("ticketSearchType", ticketSearchType);

		model.addAttribute("searchTerm", searchTerm);

		return "ticket";

        model.addAttribute("tickets", tickets);

	}

        model.addAttribute("resolved", ActivityType.RESOLVED);

        model.addAttribute("resolved-accepted", ActivityType.RESOLVED_ACCEPTED);

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

        model.addAttribute("resolved-rejected", ActivityType.RESOLVED_REJECTED);

	public String getMyTicketPaginated(HttpServletRequest request,

        model.addAttribute("authUserIdAndAuthUserMap", authUserIdAndAuthUserMap);

			@RequestParam(name = "orderby", defaultValue = "DESCENDING") SortOrder sortOrder,

        model.addAttribute("subCategoryIdAndSubCategoryMap", subCategoryIdAndSubCategoryMap);

			@RequestParam(name = "ticketStatus", defaultValue = "OPENED") TicketStatus ticketStatus,

			@RequestParam(name = "ticketSearchType", defaultValue = "") TicketSearchType ticketSearchType,

        model.addAttribute("subCategoryIdAndCategoryMap", subCategoryIdAndCategoryMap);

			@RequestParam(name = "searchTerm", defaultValue = "0") int searchTerm,

        model.addAttribute("activityMap", activityMap);

			@RequestParam(name = "offset", defaultValue = "0") int offset,

			@RequestParam(name = "limit", defaultValue = "10") int limit, Model model)

        model.addAttribute("ticketStatusValues", TicketStatus.values());

			throws ProfitMandiBusinessException {

        model.addAttribute("orderByValues", SortOrder.values());

		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

        model.addAttribute("selectedticketStatus", ticketStatus);

		List<Ticket> tickets = null;

        model.addAttribute("selectedorderby", sortOrder);

		List<TicketAssigned> ticketAssigneds = null;

        model.addAttribute("ticketSearchTypes", TicketSearchType.values());

        model.addAttribute("ticketSearchType", ticketSearchType);

		Map<Integer, AuthUser> authUserIdAndAuthUserMap = null;

        model.addAttribute("searchTerm", searchTerm);

        return "ticket";

		if (roleManager.isAdmin(new HashSet<>(loginDetails.getRoleIds()))) {

    }

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

			if (ticketSearchType == null) {

				if (ticketStatus.equals(TicketStatus.RESOLVED)) {

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

					tickets = ticketRepository.selectAllByAssignee(authUser.getId(), Optional.empty(), sortOrder, null,

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

							searchTerm, offset, limit);

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

				} else {

        List<List<ActivityAttachment>> activityAttachments = allactivities.stream().map(x -> x.getActivityAttachment()).collect(Collectors.toList());

					tickets = ticketRepository.selectAllByAssignee(authUser.getId(),

        for (List<ActivityAttachment> aA : activityAttachments) {

							Optional.of(TicketStatus.CLOSED.equals(ticketStatus)), sortOrder, null, searchTerm, offset,

            // List<ActivityAttachment> documentId = aA.stream().map(x ->

							limit);

            // x).collect(Collectors.toList());

				}

            for (ActivityAttachment attachment : aA) {

                Document document = documentRepository.selectById(attachment.getDocumentId());

			} else {

                attachment.setDocumentName(document.getDisplayName());

                activityAttachmentRepository.persist(attachment);

				if (ticketStatus.equals(TicketStatus.RESOLVED)) {

            }

					tickets = ticketRepository.selectAllByAssignee(authUser.getId(), Optional.empty(), sortOrder,

        }

							ticketSearchType, searchTerm, offset, limit);

        List<Activity> activities = null;

				} else {

        LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

					tickets = ticketRepository.selectAllByAssignee(authUser.getId(),

        if (roleManager.isAdmin(loginDetails.getRoleIds())) {

							Optional.of(TicketStatus.CLOSED.equals(ticketStatus)), sortOrder, ticketSearchType,

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

							searchTerm, offset, limit);

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

			ticketAssigneds = ticketAssignedRepository

            activities = allactivities;

					.selectByTicketIds(tickets.stream().map(x -> x.getId()).collect(Collectors.toList()));

        } else {

			authUserIdAndAuthUserMap = csService.getAuthUserIdAndAuthUserMap(ticketAssigneds);

            activities = allactivities.stream().filter(x -> ActivityType.PARTNER_ACTIVITIES.contains(x.getType())).collect(Collectors.toList());

			Map<Integer, CustomRetailer> fofoIdsAndCustomRetailer = csService.getPartnerByFofoIds(tickets);

        }

			model.addAttribute("fofoIdsAndCustomRetailer", fofoIdsAndCustomRetailer);

        if (activities == null) {

		} else {

            throw new ProfitMandiBusinessException("Activity", ticketId, "No Activity Found");

			tickets = ticketRepository.selectAllByCreator(loginDetails.getFofoId(),

        }

					Optional.of(TicketStatus.OPENED.equals(ticketStatus)), sortOrder, offset, limit);

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

			authUserIdAndAuthUserMap = csService.getTicketIdAndAuthUserMapUsingTickets(tickets);

        return "response";

		}

		model.addAttribute("roleType", roleManager.isAdmin(new HashSet<>(loginDetails.getRoleIds())));

    }

		Map<Integer, TicketSubCategory> subCategoryIdAndSubCategoryMap = csService

				.getSubCategoryIdAndSubCategoryMap(tickets);

    @PostMapping(value = "/cs/createActivity")

		model.addAttribute("tickets", tickets);

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

		model.addAttribute("authUserIdAndAuthUserMap", authUserIdAndAuthUserMap);

		model.addAttribute("subCategoryIdAndSubCategoryMap", subCategoryIdAndSubCategoryMap);

                                 Model model) throws Exception {

		model.addAttribute("resolved", ActivityType.RESOLVED);

		model.addAttribute("resolved-accepted", ActivityType.RESOLVED_ACCEPTED);

        LOGGER.info("documentIds" + documentIds);

		model.addAttribute("resolved-rejected", ActivityType.RESOLVED_REJECTED);

        LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

		return "ticket-paginated";

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

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

        authUserIds.add(ticketAssignedList.get(ticketAssignedList.size() - 1).getManagerId());

	public String getActivity(HttpServletRequest request,

        Map<Integer, AuthUser> authUsersMap = authRepository.selectAllAuthUserByIds(authUserIds).stream().collect(Collectors.toMap(x -> x.getId(), x -> x));

			@RequestParam(name = "ticketId", defaultValue = "0") int ticketId, Model model) throws Exception {

        if (ticket.getCloseTimestamp() == null) {

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

            Activity activity = new Activity();

		List<List<ActivityAttachment>> activityAttachments = allactivities.stream().map(x -> x.getActivityAttachment())

            activity.setCreatedBy(0);

				.collect(Collectors.toList());

            activity.setCreateTimestamp(LocalDateTime.now());

		for (List<ActivityAttachment> aA : activityAttachments) {

            String subject = null;

			// List<ActivityAttachment> documentId = aA.stream().map(x ->

            String mailMessage = null;

			// x).collect(Collectors.toList());

            activity.setMessage(message);

			for (ActivityAttachment attachment : aA) {

            if (!roleManager.isAdmin(new HashSet<>(loginDetails.getRoleIds()))) {

				Document document = documentRepository.selectById(attachment.getDocumentId());

                CustomRetailer customRetailer = retailerService.getFofoRetailers(true).get(loginDetails.getFofoId());

				attachment.setDocumentName(document.getDisplayName());

                activity.setType(ActivityType.COMMUNICATION_IN);

				activityAttachmentRepository.persist(attachment);

                subject = String.format("Ticket Update #%s by franchisee %s", ticket.getId(), customRetailer.getBusinessName() + "(" + customRetailer.getCode() + ")");

			}

                mailMessage = String.format("Franchisee message - %s", message);

		}

            } else {

		List<Activity> activities = null;

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

		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

                activity.setCreatedBy(authUser.getId());

		if (roleManager.isAdmin(loginDetails.getRoleIds())) {

                authUsersMap.remove(authUser.getId());

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

                subject = String.format("Ticket Update #%s by %s", ticket.getId(), authUser.getName());

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

                mailMessage = String.format("%s's message - %s", authUser.getFirstName(), message);

			Map<Integer, String> authUserNameMap = users.stream()

                if (internal) {

					.collect(Collectors.toMap(AuthUser::getId, x -> x.getFirstName() + " " + x.getLastName()));

                    activity.setType(ActivityType.COMMUNICATION_INTERNAL);

			allactivities.stream().forEach(x -> x.setName(authUserNameMap.get(x.getCreatedBy())));

                    // String subject = String.format(ACTIVITY_SUBJECT, ticket.getId());

			activities = allactivities;

                } else {

		} else {

                    String updatedBy = "SD Team";

			activities = allactivities.stream().filter(x -> ActivityType.PARTNER_ACTIVITIES.contains(x.getType()))

                    CustomRetailer customRetailer = retailerService.getFofoRetailers(true).get(ticket.getFofoId());

					.collect(Collectors.toList());

                    subject = String.format("Ticket Update #%s by %s", ticket.getId(), updatedBy);

		}

                    String partnerMessage = String.format("%s's message - %s", updatedBy, message);

		if (activities == null) {

                    this.activityRelatedMail(customRetailer.getEmail(), null, "subject", partnerMessage);

			throw new ProfitMandiBusinessException("Activity", ticketId, "No Activity Found");

                    activity.setType(ActivityType.COMMUNICATION_OUT);

		}

                }

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

            }

		return "response";

            activityRepository.persist(activity);

	}

            for (Integer documentId : documentIds) {

                ActivityAttachment activityAttachment = new ActivityAttachment();

	@PostMapping(value = "/cs/createActivity")

                activityAttachment.setActivityId(activity.getId());

	public String createActivity(HttpServletRequest request,

                activityAttachment.setDocumentId(documentId);

			@RequestParam(name = "ticketId", defaultValue = "0") int ticketId,

                activityAttachmentRepository.persist(activityAttachment);

			@RequestParam(name = "assigneeId", defaultValue = "0") int assigneeId,

            }

			@RequestParam(name = "internal", defaultValue = "true") boolean internal,

			@RequestParam(name = "message", defaultValue = "") String message, @RequestBody List<Integer> documentIds,

            csService.addActivity(ticket, activity);

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

			Model model) throws Exception {

            if (authUser == null) {

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

		LOGGER.info("documentIds" + documentIds);

            }

		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

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

		Ticket ticket = ticketRepository.selectById(ticketId);

            String[] cc = authUsersMap.entrySet().stream().map(x -> x.getValue().getEmailId()).toArray(String[]::new);

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

            this.activityRelatedMail(authUser.getEmailId(), cc, subject, mailMessage);

		List<Integer> authUserIds = ticketAssignedList.stream().map(x -> x.getAssineeId()).collect(Collectors.toList());

        } else {

		authUserIds.add(ticketAssignedList.get(ticketAssignedList.size() - 1).getManagerId());

            throw new ProfitMandiBusinessException("Ticket", ticket.getId(), "Already closed ticket");

		Map<Integer, AuthUser> authUsersMap = authRepository.selectAllAuthUserByIds(authUserIds).stream()

        }

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

        return "response";

		if (ticket.getCloseTimestamp() == null) {

    }

			Activity activity = new Activity();

			activity.setCreatedBy(0);

    private void activityRelatedMail(String to, String[] cc, String subject, String message) throws ProfitMandiBusinessException {

			activity.setCreateTimestamp(LocalDateTime.now());

        try {

			String subject = null;

            Utils.sendMailWithAttachments(mailSender, to, cc, subject, message, null);

			String mailMessage = null;

        } catch (Exception e) {

			activity.setMessage(message);

            throw new ProfitMandiBusinessException("Ticket Activity", to, "Could not send ticket activity mail");

			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(),

    @PostMapping(value = "/cs/closeTicket")

						customRetailer.getBusinessName() + "(" + customRetailer.getCode() + ")");

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

				mailMessage = String.format("Franchisee message - %s", message);

        Ticket ticket = ticketRepository.selectById(ticketId);

			} else {

        if (ticket.getHappyCode().equals(happyCode)) {

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

            ticket.setCloseTimestamp(LocalDateTime.now());

				activity.setCreatedBy(authUser.getId());

            ticketRepository.persist(ticket);

				authUsersMap.remove(authUser.getId());

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

				subject = String.format("Ticket Update #%s by %s", ticket.getId(), authUser.getName());

        } else {

				mailMessage = String.format("%s's message - %s", authUser.getFirstName(), message);

            throw new ProfitMandiBusinessException("Ticket", ticketId, "Happy Code can't match");

				if (internal) {

        }

					activity.setType(ActivityType.COMMUNICATION_INTERNAL);

        return "response";

					// String subject = String.format(ACTIVITY_SUBJECT, ticket.getId());

    }

				} else {

					String updatedBy = "SD Team";

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

					CustomRetailer customRetailer = retailerService.getFofoRetailers(true).get(ticket.getFofoId());

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

					subject = String.format("Ticket Update #%s by %s", ticket.getId(), updatedBy);

        LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

					String partnerMessage = String.format("%s's message - %s", updatedBy, message);

        long size = 0;

					this.activityRelatedMail(customRetailer.getEmail(), null, "subject", partnerMessage);

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

					activity.setType(ActivityType.COMMUNICATION_OUT);

        List<Ticket> tickets = null;

				}

        Map<Integer, List<AuthUser>> authUserListMap = null;

			}

        if (ticketSearchType == null) {

			activityRepository.persist(activity);

            if (ticketStatus.equals(TicketStatus.RESOLVED)) {

                tickets = ticketRepository.selectAllManagerTicket(authUser.getId(), sortOrder, Optional.empty(), null, searchTerm);

			for (Integer documentId : documentIds) {

                size = ticketRepository.selectAllCountByManagerTicket(authUser.getId(), Optional.empty(), null, 0);

				ActivityAttachment activityAttachment = new ActivityAttachment();

            } else {

				activityAttachment.setActivityId(activity.getId());

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

				activityAttachment.setDocumentId(documentId);

                size = ticketRepository.selectAllCountByManagerTicket(authUser.getId(), Optional.of(TicketStatus.CLOSED.equals(ticketStatus)), null, 0);

				activityAttachmentRepository.persist(activityAttachment);

            }

			}

        } else {

            if (ticketStatus.equals(TicketStatus.RESOLVED)) {

			csService.addActivity(ticket, activity);

                tickets = ticketRepository.selectAllManagerTicket(authUser.getId(), sortOrder, Optional.empty(), ticketSearchType, searchTerm);

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

                size = ticketRepository.selectAllCountByManagerTicket(authUser.getId(), Optional.empty(), ticketSearchType, searchTerm);

			if (authUser == null) {

            } else {

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

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

			}

                size = ticketRepository.selectAllCountByManagerTicket(authUser.getId(), Optional.of(TicketStatus.CLOSED.equals(ticketStatus)), ticketSearchType, searchTerm);

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

            }

			String[] cc = authUsersMap.entrySet().stream().map(x -> x.getValue().getEmailId()).toArray(String[]::new);

			this.activityRelatedMail(authUser.getEmailId(), cc, subject, mailMessage);

        }

		} else {

        authUserListMap = csService.getAssignedAuthList(tickets);

			throw new ProfitMandiBusinessException("Ticket", ticket.getId(), "Already closed ticket");

		}

        if (tickets.size() > 0) {

		return "response";

            Map<Integer, CustomRetailer> fofoIdsAndCustomRetailer = csService.getPartnerByFofoIds(tickets);

	}

            model.addAttribute("fofoIdsAndCustomRetailer", fofoIdsAndCustomRetailer);

        }

	private void activityRelatedMail(String to, String[] cc, String subject, String message)

			throws ProfitMandiBusinessException {

        model.addAttribute("size", size);

		try {

        model.addAttribute("tickets", tickets);

			Utils.sendMailWithAttachments(mailSender, to, cc, subject, message, null);

		} catch (Exception e) {

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

			throw new ProfitMandiBusinessException("Ticket Activity", to, "Could not send ticket activity mail");

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

		}

	}

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

	@PostMapping(value = "/cs/closeTicket")

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

	public String closeTicket(HttpServletRequest request,

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

			@RequestParam(name = "ticketId", defaultValue = "0") int ticketId,

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

        if (!ticketIds.isEmpty()) {

		Ticket ticket = ticketRepository.selectById(ticketId);

            activityMap = activityRepository.selectAll(ticketIds).stream().collect(Collectors.groupingBy(x -> x.getTicketId()));

		if (ticket.getHappyCode().equals(happyCode)) {

			ticket.setCloseTimestamp(LocalDateTime.now());

        }

			ticketRepository.persist(ticket);

        model.addAttribute("ticketStatusValues", TicketStatus.values());

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

        model.addAttribute("orderByValues", SortOrder.values());

		} else {

        model.addAttribute("selectedticketStatus", ticketStatus);

			throw new ProfitMandiBusinessException("Ticket", ticketId, "Happy Code can't match");

        model.addAttribute("selectedorderby", sortOrder);

		}

        model.addAttribute("tickets", tickets);

		return "response";

        model.addAttribute("ticketSearchTypes", TicketSearchType.values());

	}

        model.addAttribute("ticketSearchType", ticketSearchType);

        model.addAttribute("searchTerm", searchTerm);

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

        model.addAttribute("authUserListMap", authUserListMap);

	public String getManagerTickets(HttpServletRequest request,

        model.addAttribute("subCategoryIdAndSubCategoryMap", subCategoryIdAndSubCategoryMap);

			@RequestParam(name = "orderby", defaultValue = "DESCENDING") SortOrder sortOrder,

			@RequestParam(name = "ticketStatus", defaultValue = "OPENED") TicketStatus ticketStatus,

        model.addAttribute("subCategoryIdAndCategoryMap", subCategoryIdAndCategoryMap);

			@RequestParam(name = "ticketSearchType", defaultValue = "") TicketSearchType ticketSearchType,

			@RequestParam(name = "searchTerm", defaultValue = "0") int searchTerm,

        model.addAttribute("activityMap", activityMap);

			@RequestParam(name = "offset", defaultValue = "0") int offset,

			@RequestParam(name = "limit", defaultValue = "10") int limit, Model model)

        return "managerTicket";

			throws ProfitMandiBusinessException {

    }

		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

		long size = 0;

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

    @GetMapping(value = "/cs/edit-ticket")

		List<Ticket> tickets = null;

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

		Map<Integer, List<AuthUser>> authUserListMap = null;

        Ticket ticket = ticketRepository.selectById(ticketId);

		if (ticketSearchType == null) {

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

			if (ticketStatus.equals(TicketStatus.RESOLVED)) {

        TicketSubCategory ticketSubCategory = ticketSubCategoryRepository.selectById(ticket.getSubCategoryId());

				tickets = ticketRepository.selectAllManagerTicket(authUser.getId(), sortOrder, Optional.empty(), null,

        List<TicketSubCategory> ticketSubCategories = ticketSubCategoryRepository.selectAll(ticketSubCategory.getCategoryId());

						searchTerm, offset, limit);

        List<AuthUser> authUsers = authRepository.selectAllActiveUser();

				size = ticketRepository.selectAllCountByManagerTicket(authUser.getId(), Optional.empty(), null, 0);

        model.addAttribute("ticket", ticket);

			} else {

        model.addAttribute("ticketCategories", ticketCategories);

				tickets = ticketRepository.selectAllManagerTicket(authUser.getId(), sortOrder,

        model.addAttribute("ticketSubCategories", ticketSubCategories);

						Optional.of(TicketStatus.CLOSED.equals(ticketStatus)), null, searchTerm, offset, limit);

        model.addAttribute("ticketSubCategory", ticketSubCategory);

				size = ticketRepository.selectAllCountByManagerTicket(authUser.getId(),

        model.addAttribute("authUsers", authUsers);

						Optional.of(TicketStatus.CLOSED.equals(ticketStatus)), null, 0);

        return "edit-ticket-modal";

			}

    }

		} else {

			if (ticketStatus.equals(TicketStatus.RESOLVED)) {

    @PostMapping(value = "/cs/edit-ticket")

				tickets = ticketRepository.selectAllManagerTicket(authUser.getId(), sortOrder, Optional.empty(),

    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, @RequestParam(name = "escalationType", defaultValue = "L1") EscalationType escalationType, Model model) throws Exception {

						ticketSearchType, searchTerm, offset, limit);

        LOGGER.info("Ticket Id {}, CategoryId {}, SubCategory Id {} authUserId {}", ticketId, categoryId, subCategoryId, authUserId);

				size = ticketRepository.selectAllCountByManagerTicket(authUser.getId(), Optional.empty(),

        Ticket ticket = ticketRepository.selectById(ticketId);

						ticketSearchType, searchTerm);

        csService.updateTicket(categoryId, subCategoryId, ticket, authUserId, escalationType);

			} else {

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

				tickets = ticketRepository.selectAllManagerTicket(authUser.getId(), sortOrder,

        return "response";

						Optional.of(TicketStatus.CLOSED.equals(ticketStatus)), ticketSearchType, searchTerm, offset,

						limit);

    }

				size = ticketRepository.selectAllCountByManagerTicket(authUser.getId(),

						Optional.of(TicketStatus.CLOSED.equals(ticketStatus)), ticketSearchType, searchTerm);

    @PostMapping(value = "/cs/changeTicketAssignee")

			}

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

        Position position = positionRepository.selectById(positionId);

		}

        if (position.isTicketAssignee()) {

		authUserListMap = csService.getAssignedAuthList(tickets);

            position.setTicketAssignee(false);

        } else {

		if (tickets.size() > 0) {

            position.setTicketAssignee(true);

			Map<Integer, CustomRetailer> fofoIdsAndCustomRetailer = csService.getPartnerByFofoIds(tickets);

        }

			model.addAttribute("fofoIdsAndCustomRetailer", fofoIdsAndCustomRetailer);

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

		}

        return "response";

		if (size < limit) {

    }

			model.addAttribute("end", offset + size);

		} else {

			model.addAttribute("end", offset + limit);

    @DeleteMapping(value = "/cs/removePosition")

		}

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

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

        positionRepository.delete(positionId);

		model.addAttribute("size", size);

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

		model.addAttribute("tickets", tickets);

        return "response";

    }

		Map<Integer, TicketSubCategory> subCategoryIdAndSubCategoryMap = csService

				.getSubCategoryIdAndSubCategoryMap(tickets);

    @PostMapping(value = "/cs/create-last-activity")

		model.addAttribute("ticketStatusValues", TicketStatus.values());

    public String createlastActivity(HttpServletRequest request, @RequestParam(name = "ticketId") int ticketId, @RequestParam(name = "lastactivity") ActivityType lastActivity, Model model) throws Exception {

		model.addAttribute("orderByValues", SortOrder.values());

        LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

		model.addAttribute("selectedticketStatus", ticketStatus);

        Ticket ticket = ticketRepository.selectById(ticketId);

		model.addAttribute("selectedorderby", sortOrder);

        Activity activity = new Activity();

		model.addAttribute("tickets", tickets);

        String subject = String.format(ACTIVITY_SUBJECT, ticket.getId());

		model.addAttribute("ticketSearchTypes", TicketSearchType.values());

        if (roleManager.isAdmin(loginDetails.getRoleIds())) {

		model.addAttribute("ticketSearchType", ticketSearchType);

            ticket.setLastActivity(lastActivity);

		model.addAttribute("searchTerm", searchTerm);

            String to = retailerService.getFofoRetailer(ticket.getFofoId()).getEmail();

		model.addAttribute("authUserListMap", authUserListMap);

            String message = String.format(PARTNER_RESOLVED_TICKET_MAIL, ticketId, "REOPEN");

		model.addAttribute("subCategoryIdAndSubCategoryMap", subCategoryIdAndSubCategoryMap);

            activity.setMessage(message);

		return "managerTicket";

            activity.setCreatedBy(authRepository.selectByEmailOrMobile(loginDetails.getEmailId()).getId());

	}

            activity.setTicketId(ticketId);

            activity.setCreateTimestamp(LocalDateTime.now());

	@GetMapping(value = "/cs/managerTicket-paginated")

            activity.setType(ActivityType.COMMUNICATION_OUT);

	public String getManagerTicketsPaginated(HttpServletRequest request,

            this.activityRelatedMail(to, null, subject, message);

			@RequestParam(name = "orderby", defaultValue = "DESCENDING") SortOrder sortOrder,

        } else {

			@RequestParam(name = "ticketStatus", defaultValue = "OPENED") TicketStatus ticketStatus,

            if (ActivityType.RESOLVED_ACCEPTED == lastActivity) {

			@RequestParam(name = "ticketSearchType", defaultValue = "") TicketSearchType ticketSearchType,

                ticket.setLastActivity(lastActivity);

			@RequestParam(name = "searchTerm", defaultValue = "0") int searchTerm,

                ticket.setCloseTimestamp(LocalDateTime.now());

			@RequestParam(name = "offset", defaultValue = "0") int offset,

                activity.setMessage(ActivityType.RESOLVED_ACCEPTED.toString());

			@RequestParam(name = "limit", defaultValue = "10") int limit, Model model)

                activity.setCreatedBy(0);

			throws ProfitMandiBusinessException {

                activity.setTicketId(ticketId);

		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

                activity.setType(ActivityType.COMMUNICATION_IN);

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

                activity.setCreateTimestamp(LocalDateTime.now());

		Map<Integer, List<AuthUser>> authUserListMap = null;

            } else {

		List<Ticket> tickets = null;

                String message = String.format(INTERNAL_REOPEN_MAIL, ticketId, retailerService.getFofoRetailer(loginDetails.getFofoId()).getBusinessName());

		if (ticketSearchType == null) {

                String to = authRepository.selectById(ticket.getL1AuthUser()).getEmailId();

			if (ticketStatus.equals(TicketStatus.RESOLVED)) {

                String[] ccTo = authRepository.selectAllAuthUserByIds(Arrays.asList(ticket.getL2AuthUser(), ticket.getL3AuthUser(), ticket.getL4AuthUser(), ticket.getL5AuthUser())).stream().map(x -> x.getEmailId()).toArray(String[]::new);

				tickets = ticketRepository.selectAllManagerTicket(authUser.getId(), sortOrder, Optional.empty(), null,

                ticket.setLastActivity(lastActivity);

						searchTerm, offset, limit);

                ticket.setUpdateTimestamp(LocalDateTime.now());

                ticketAssignedRepository.deleteByTicketId(ticketId);

			} else {

                TicketAssigned ticketAssigned = new TicketAssigned();

				tickets = ticketRepository.selectAllManagerTicket(authUser.getId(), sortOrder,

                ticketAssigned.setAssineeId(ticket.getL1AuthUser());

						Optional.of(TicketStatus.CLOSED.equals(ticketStatus)), null, searchTerm, offset, limit);

                ticketAssigned.setTicketId(ticketId);

                ticketAssignedRepository.persist(ticketAssigned);

			}

                activity.setMessage(INTERNAL_REOPEN_ACTIVITY_MESSAGE);

		} else {

                activity.setCreatedBy(0);

			if (ticketStatus.equals(TicketStatus.RESOLVED)) {

                activity.setTicketId(ticketId);

				tickets = ticketRepository.selectAllManagerTicket(authUser.getId(), sortOrder, Optional.empty(),

                activity.setType(ActivityType.COMMUNICATION_IN);

						ticketSearchType, searchTerm, offset, limit);

                activity.setCreateTimestamp(LocalDateTime.now());

                this.activityRelatedMail(to, ccTo, subject, message);

			} else {

                this.activityRelatedMail(retailerService.getFofoRetailer(loginDetails.getFofoId()).getEmail(), null, subject, String.format(PARTNER_REOPEN, ticketId));

				tickets = ticketRepository.selectAllManagerTicket(authUser.getId(), sortOrder,

            }

						Optional.of(TicketStatus.CLOSED.equals(ticketStatus)), ticketSearchType, searchTerm, offset,

						limit);

        }

			}

        activityRepository.persist(activity);

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

		}

        return "response";

		authUserListMap = csService.getAssignedAuthList(tickets);

    }