Subversion Repositories SmartDukaan

Rev

Rev 24836 | Rev 24840 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
24417 govind 1 
package com.spice.profitmandi.web.controller;
2 
 
3 
import java.time.LocalDateTime;
24572 amit.gupta 4 
import java.util.ArrayList;
24417 govind 5 
import java.util.HashSet;
6 
import java.util.List;
7 
import java.util.Map;
8 
import java.util.Optional;
24572 amit.gupta 9 
import java.util.Set;
24500 govind 10 
import java.util.stream.Collectors;
24417 govind 11 
 
12 
import javax.servlet.http.HttpServletRequest;
24699 govind 13 
import javax.swing.SortOrder;
24417 govind 14 
 
15 
import org.apache.logging.log4j.LogManager;
16 
import org.apache.logging.log4j.Logger;
17 
import org.springframework.beans.factory.annotation.Autowired;
24620 govind 18 
import org.springframework.mail.javamail.JavaMailSender;
24417 govind 19 
import org.springframework.stereotype.Controller;
20 
import org.springframework.transaction.annotation.Transactional;
21 
import org.springframework.ui.Model;
24471 govind 22 
import org.springframework.web.bind.annotation.DeleteMapping;
24417 govind 23 
import org.springframework.web.bind.annotation.GetMapping;
24 
import org.springframework.web.bind.annotation.PostMapping;
25 
import org.springframework.web.bind.annotation.RequestBody;
26 
import org.springframework.web.bind.annotation.RequestParam;
27 
 
28 
import com.spice.profitmandi.common.exception.ProfitMandiBusinessException;
29 
import com.spice.profitmandi.common.model.CustomRetailer;
24620 govind 30 
import com.spice.profitmandi.common.util.Utils;
24417 govind 31 
import com.spice.profitmandi.dao.entity.auth.AuthUser;
32 
import com.spice.profitmandi.dao.entity.cs.Activity;
33 
import com.spice.profitmandi.dao.entity.cs.Position;
34 
import com.spice.profitmandi.dao.entity.cs.Region;
35 
import com.spice.profitmandi.dao.entity.cs.Ticket;
24500 govind 36 
import com.spice.profitmandi.dao.entity.cs.TicketAssigned;
24417 govind 37 
import com.spice.profitmandi.dao.entity.cs.TicketCategory;
24747 govind 38 
import com.spice.profitmandi.dao.entity.cs.TicketSearchType;
24417 govind 39 
import com.spice.profitmandi.dao.entity.cs.TicketSubCategory;
40 
import com.spice.profitmandi.dao.entity.fofo.ActivityType;
41 
import com.spice.profitmandi.dao.enumuration.cs.EscalationType;
24699 govind 42 
import com.spice.profitmandi.dao.enumuration.cs.TicketStatus;
24417 govind 43 
import com.spice.profitmandi.dao.repository.auth.AuthRepository;
44 
import com.spice.profitmandi.dao.repository.cs.ActivityRepository;
45 
import com.spice.profitmandi.dao.repository.cs.CsService;
24557 govind 46 
import com.spice.profitmandi.dao.repository.cs.PartnerRegionRepository;
24417 govind 47 
import com.spice.profitmandi.dao.repository.cs.PositionRepository;
48 
import com.spice.profitmandi.dao.repository.cs.RegionRepository;
24500 govind 49 
import com.spice.profitmandi.dao.repository.cs.TicketAssignedRepository;
24417 govind 50 
import com.spice.profitmandi.dao.repository.cs.TicketCategoryRepository;
51 
import com.spice.profitmandi.dao.repository.cs.TicketRepository;
52 
import com.spice.profitmandi.dao.repository.cs.TicketSubCategoryRepository;
53 
import com.spice.profitmandi.service.authentication.RoleManager;
54 
import com.spice.profitmandi.service.slab.TargetSlabService;
55 
import com.spice.profitmandi.service.user.RetailerService;
56 
import com.spice.profitmandi.web.model.LoginDetails;
57 
import com.spice.profitmandi.web.util.CookiesProcessor;
58 
import com.spice.profitmandi.web.util.MVCResponseSender;
59 
 
60 
@Controller
61 
@Transactional(rollbackFor = Throwable.class)
62 
public class CsController {
63 
 
64 
	private static final Logger LOGGER = LogManager.getLogger(CsController.class);
65 
 
24620 govind 66 
	private static final String ACTIVITY_SUBJECT = "Message related ticketId#%s";
24699 govind 67 
	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";
68 
	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";
69 
	private static final String INTERNAL_REOPEN_MAIL = "Hi, Pls note that the ticket # %s has been re-opened by %s , pls respond on priority.";
70 
	private static final String INTERNAL_REOPEN_ACTIVITY_MESSAGE = "Hi,My ticket is not resolved yet,so I am reopenning ticket";
71 
 
24417 govind 72 
	@Autowired
24620 govind 73 
	JavaMailSender mailSender;
74 
 
75 
	@Autowired
24417 govind 76 
	private CsService csService;
77 
 
78 
	@Autowired
79 
	private CookiesProcessor cookiesProcessor;
80 
 
81 
	@Autowired
82 
	private TicketCategoryRepository ticketCategoryRepository;
83 
 
84 
	@Autowired
85 
	private TicketSubCategoryRepository ticketSubCategoryRepository;
86 
 
87 
	@Autowired
88 
	private RegionRepository regionRepository;
89 
 
90 
	@Autowired
91 
	private TargetSlabService targetSlabService;
92 
 
93 
	@Autowired
94 
	private RetailerService retailerService;
95 
 
96 
	@Autowired
97 
	private MVCResponseSender mvcResponseSender;
98 
 
99 
	@Autowired
100 
	private AuthRepository authRepository;
101 
 
102 
	@Autowired
103 
	private PositionRepository positionRepository;
104 
 
105 
	@Autowired
106 
	private TicketRepository ticketRepository;
107 
 
108 
	@Autowired
109 
	private RoleManager roleManager;
110 
 
111 
	@Autowired
112 
	private ActivityRepository activityRepository;
113 
 
24500 govind 114 
	@Autowired
115 
	private TicketAssignedRepository ticketAssignedRepository;
24569 govind 116 
 
117 
	@Autowired
24557 govind 118 
	private PartnerRegionRepository partnerRegionRepository;
24500 govind 119 
 
24417 govind 120 
	@GetMapping(value = "/cs/createCategory")
121 
	public String getCreateCategory(HttpServletRequest request, Model model) {
122 
		List<TicketCategory> ticketCategories = ticketCategoryRepository.selectAll();
123 
		model.addAttribute("ticketCategories", ticketCategories);
124 
		return "create-ticket-category";
125 
	}
126 
 
127 
	@PostMapping(value = "/cs/createCategory")
128 
	public String createCategory(HttpServletRequest request, @RequestParam(name = "name") String name,
129 
			@RequestParam(name = "description") String description, Model model) throws ProfitMandiBusinessException {
130 
 
131 
		TicketCategory ticketCategory = ticketCategoryRepository.selectByName(name);
132 
		if (ticketCategory != null) {
133 
			throw new ProfitMandiBusinessException("name", name, "already exists!");
134 
		}
135 
		ticketCategory = new TicketCategory();
136 
		ticketCategory.setName(name);
137 
		ticketCategory.setDescription(description);
138 
		ticketCategoryRepository.persist(ticketCategory);
139 
		return "create-ticket-category";
140 
	}
141 
 
142 
	@GetMapping(value = "/cs/createSubCategory")
143 
	public String getCreateSubCategory(HttpServletRequest request, Model model) {
144 
		List<TicketCategory> ticketCategories = ticketCategoryRepository.selectAll();
145 
		model.addAttribute("ticketCategories", ticketCategories);
146 
		return "create-ticket-sub-category";
147 
	}
148 
 
149 
	@GetMapping(value = "/cs/getSubCategoryByCategoryId")
150 
	public String getSubCategoryByCategoryId(HttpServletRequest request,
151 
			@RequestParam(name = "ticketCategoryId", defaultValue = "") int ticketCategoryId, Model model) {
152 
		List<TicketSubCategory> ticketSubCategories = ticketSubCategoryRepository.selectAll(ticketCategoryId);
153 
		TicketCategory ticketCategory = ticketCategoryRepository.selectById(ticketCategoryId);
154 
		model.addAttribute("ticketSubCategories", ticketSubCategories);
155 
		model.addAttribute("ticketCategory", ticketCategory);
156 
		return "ticket-sub-category";
157 
	}
158 
 
159 
	@PostMapping(value = "/cs/createSubCategory")
160 
	public String createSubCategory(HttpServletRequest request,
161 
			@RequestParam(name = "categoryId", defaultValue = "0") int categoryId,
162 
			@RequestParam(name = "name") String name, @RequestParam(name = "description") String description,
163 
			Model model) throws ProfitMandiBusinessException {
164 
 
165 
		TicketSubCategory ticketSubCategory = ticketSubCategoryRepository.selectTicketSubCategory(categoryId, name);
166 
		if (ticketSubCategory != null) {
167 
			throw new ProfitMandiBusinessException("name & categoryId", name + "  " + categoryId, "already exists!");
168 
		}
169 
 
170 
		ticketSubCategory = new TicketSubCategory();
171 
		ticketSubCategory.setcategoryId(categoryId);
172 
		ticketSubCategory.setName(name);
173 
		ticketSubCategory.setDescription(description);
174 
		ticketSubCategoryRepository.persist(ticketSubCategory);
175 
		return "create-ticket-sub-category";
176 
	}
177 
 
178 
	@GetMapping(value = "/cs/createRegion")
179 
	public String createRegion(HttpServletRequest request, Model model) {
180 
		List<Region> regions = regionRepository.selectAll();
181 
		model.addAttribute("regions", regions);
182 
		return "create-region";
183 
	}
184 
 
185 
	@PostMapping(value = "/cs/createRegion")
186 
	public String createRegion(HttpServletRequest request, @RequestParam(name = "name") String name,
187 
			@RequestParam(name = "description") String description, Model model) throws Exception {
188 
		Region region = regionRepository.selectByName(name);
189 
		if (region != null) {
190 
			throw new ProfitMandiBusinessException("name", name, "already exists!");
191 
		}
192 
		region = new Region();
193 
		region.setName(name);
194 
		region.setDescription(description);
195 
		regionRepository.persist(region);
196 
		model.addAttribute("response", mvcResponseSender.createResponseString(true));
197 
		return "response";
198 
	}
199 
 
24557 govind 200 
	@GetMapping(value = "/cs/getPartners")
24569 govind 201 
	public String getPartners(HttpServletRequest request,
202 
			@RequestParam(name = "regionId", defaultValue = "0") int regionId, Model model) {
24557 govind 203 
		List<Integer> fofoIds = targetSlabService.getfofoIdsFromfofoStore();
24569 govind 204 
		List<Integer> addedfofoIds = partnerRegionRepository.selectByRegionId(regionId).stream().map(x -> x.getFofoId())
205 
				.collect(Collectors.toList());
24557 govind 206 
		Map<Integer, CustomRetailer> fofoRetailers = retailerService.getFofoRetailers(fofoIds);
207 
		model.addAttribute("fofoRetailers", fofoRetailers);
208 
		model.addAttribute("addedfofoIds", addedfofoIds);
209 
		return "added-region-partners";
210 
	}
24569 govind 211 
 
24417 govind 212 
	@GetMapping(value = "/cs/createPartnerRegion")
213 
	public String createPartnerRegion(HttpServletRequest request, Model model) {
214 
		List<Region> regions = regionRepository.selectAll();
215 
		model.addAttribute("regions", regions);
216 
		return "create-partner-region";
217 
	}
218 
 
219 
	@PostMapping(value = "/cs/createPartnerRegion")
220 
	public String createPartnerRegion(HttpServletRequest request, @RequestParam(name = "regionId") int regionId,
221 
			@RequestBody List<Integer> selectedFofoIds, Model model) throws Exception {
24557 govind 222 
		partnerRegionRepository.delete(regionId);
223 
		LOGGER.info("successfully removed");
224 
		LOGGER.info(selectedFofoIds.size());
24417 govind 225 
		csService.addPartnerToRegion(regionId, selectedFofoIds);
226 
		model.addAttribute("response", mvcResponseSender.createResponseString(true));
227 
		return "response";
228 
	}
229 
 
230 
	@GetMapping(value = "/cs/createPosition")
24500 govind 231 
	public String createPosition(HttpServletRequest request,
232 
			@RequestParam(name = "offset", defaultValue = "0") int offset,
24471 govind 233 
			@RequestParam(name = "limit", defaultValue = "10") int limit, Model model) {
24417 govind 234 
		List<AuthUser> authUsers = authRepository.selectAll();
235 
		List<TicketCategory> ticketCategories = ticketCategoryRepository.selectAll();
236 
		List<Region> regions = regionRepository.selectAll();
237 
		model.addAttribute("escalationTypes", EscalationType.values());
238 
		model.addAttribute("authUsers", authUsers);
239 
		model.addAttribute("ticketCategories", ticketCategories);
240 
		model.addAttribute("regions", regions);
24500 govind 241 
 
242 
		List<Position> positions = positionRepository.selectAll(offset, limit);
243 
		LOGGER.info(positions);
244 
		Map<Integer, AuthUser> authUserIdAndAuthUserMap = csService
245 
				.getAuthUserIdAndAuthUserMapUsingPositions(positions);
246 
		Map<Integer, TicketCategory> categoryIdAndCategoryMap = csService
247 
				.getCategoryIdAndCategoryUsingPositions(positions);
248 
		Map<Integer, Region> regionIdAndRegionMap = csService.getRegionIdAndRegionMap(positions);
249 
		long size = positionRepository.selectAllCount();
250 
 
24471 govind 251 
		if (size < limit) {
252 
			model.addAttribute("end", offset + size);
253 
		} else {
254 
			model.addAttribute("end", offset + limit);
255 
		}
256 
		model.addAttribute("start", offset + 1);
257 
		model.addAttribute("size", size);
258 
		model.addAttribute("positions", positions);
259 
		model.addAttribute("authUserIdAndAuthUserMap", authUserIdAndAuthUserMap);
260 
		model.addAttribute("categoryIdAndCategoryMap", categoryIdAndCategoryMap);
261 
		model.addAttribute("regionIdAndRegionMap", regionIdAndRegionMap);
24417 govind 262 
		return "create-position";
263 
	}
24500 govind 264 
 
24471 govind 265 
	@GetMapping(value = "/cs/position-paginated")
24500 govind 266 
	public String positionPaginated(HttpServletRequest request,
267 
			@RequestParam(name = "offset", defaultValue = "0") int offset,
24471 govind 268 
			@RequestParam(name = "limit", defaultValue = "10") int limit, Model model) {
24500 govind 269 
 
270 
		List<Position> positions = positionRepository.selectAll(offset, limit);
271 
		Map<Integer, AuthUser> authUserIdAndAuthUserMap = csService
272 
				.getAuthUserIdAndAuthUserMapUsingPositions(positions);
273 
		Map<Integer, TicketCategory> categoryIdAndCategoryMap = csService
274 
				.getCategoryIdAndCategoryUsingPositions(positions);
275 
		Map<Integer, Region> regionIdAndRegionMap = csService.getRegionIdAndRegionMap(positions);
24471 govind 276 
		model.addAttribute("positions", positions);
277 
		model.addAttribute("authUserIdAndAuthUserMap", authUserIdAndAuthUserMap);
278 
		model.addAttribute("categoryIdAndCategoryMap", categoryIdAndCategoryMap);
279 
		model.addAttribute("regionIdAndRegionMap", regionIdAndRegionMap);
280 
		return "position-paginated";
281 
	}
24417 govind 282 
 
283 
	@PostMapping(value = "/cs/createPosition")
284 
	public String createPosition(HttpServletRequest request, @RequestParam(name = "authUserId") int authUserId,
285 
			@RequestParam(name = "categoryId") int categoryId,
286 
			@RequestParam(name = "escalationType") EscalationType escalationType,
287 
			@RequestParam(name = "regionId") int regionId, Model model) throws Exception {
288 
 
289 
		Position position = positionRepository.selectPosition(authUserId, categoryId, regionId, escalationType);
290 
		if (position == null) {
291 
			position = new Position();
292 
			position.setAuthUserId(authUserId);
293 
			position.setCategoryId(categoryId);
294 
			position.setEscalationType(escalationType);
295 
			position.setRegionId(regionId);
296 
			position.setCreateTimestamp(LocalDateTime.now());
297 
			positionRepository.persist(position);
298 
			model.addAttribute("response", mvcResponseSender.createResponseString(true));
299 
		} else {
300 
			throw new ProfitMandiBusinessException("Position", authUserId, "already exists!");
301 
		}
302 
		return "response";
303 
	}
304 
 
305 
	@GetMapping(value = "/cs/createTicket")
24824 govind 306 
	public String createTicket(HttpServletRequest request, Model model) throws ProfitMandiBusinessException {
307 
		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
24500 govind 308 
		List<TicketCategory> ticketCategories = csService.getAllTicketCategotyFromSubCategory();
24824 govind 309 
		model.addAttribute("roleType", roleManager.isAdmin(loginDetails.getRoleIds()));
24417 govind 310 
		model.addAttribute("ticketCategories", ticketCategories);
311 
		return "create-ticket";
312 
	}
313 
 
314 
	@GetMapping(value = "/cs/getSubCategoriesByCategoryId")
315 
	public String getSubCategoriesByCategoryId(HttpServletRequest request,
316 
			@RequestParam(name = "categoryId", defaultValue = "0") int categoryId, Model model) {
317 
		List<TicketSubCategory> ticketSubCategories = ticketSubCategoryRepository.selectAll(categoryId);
318 
		LOGGER.info(ticketSubCategories);
319 
		model.addAttribute("ticketSubCategories", ticketSubCategories);
320 
		return "ticket-sub-categories";
321 
	}
322 
 
323 
	@PostMapping(value = "/cs/createTicket")
324 
	public String createTicket(HttpServletRequest request, @RequestParam(name = "categoryId") int categoryId,
325 
			@RequestParam(name = "subCategoryId") int subCategoryId, @RequestParam(name = "message") String message,
326 
			Model model) throws Exception {
327 
		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
24837 govind 328 
		List<Ticket> tickets = ticketRepository.selectAllResolvedMarkedTicketByCreator(loginDetails.getFofoId());
24620 govind 329 
		if (tickets.size() > 3 || tickets.size() == 3) {
330 
			model.addAttribute("response", mvcResponseSender.createResponseString(false));
331 
		} else {
332 
			csService.createTicket(loginDetails.getFofoId(), categoryId, subCategoryId, message);
333 
			model.addAttribute("response", mvcResponseSender.createResponseString(true));
334 
		}
24417 govind 335 
		return "response";
336 
	}
337 
 
338 
	@GetMapping(value = "/cs/myticket")
24699 govind 339 
	public String getTicket(HttpServletRequest request,
340 
			@RequestParam(name = "orderby", defaultValue = "DESCENDING") SortOrder sortOrder,
341 
			@RequestParam(name = "ticketStatus", defaultValue = "OPENED") TicketStatus ticketStatus,
24787 govind 342 
			@RequestParam(name = "ticketSearchType", defaultValue = "") TicketSearchType ticketSearchType,
343 
			@RequestParam(name = "searchTerm", defaultValue = "0") int searchTerm,
24699 govind 344 
			@RequestParam(name = "offset", defaultValue = "0") int offset,
24417 govind 345 
			@RequestParam(name = "limit", defaultValue = "10") int limit, Model model)
346 
			throws ProfitMandiBusinessException {
347 
		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
348 
		List<Ticket> tickets = null;
24500 govind 349 
		List<TicketAssigned> ticketAssigneds = null;
24417 govind 350 
		long size = 0;
24500 govind 351 
		Map<Integer, AuthUser> authUserIdAndAuthUserMap = null;
24417 govind 352 
		if (roleManager.isAdmin(new HashSet<>(loginDetails.getRoleIds()))) {
353 
			AuthUser authUser = authRepository.selectByEmailOrMobile(loginDetails.getEmailId());
24787 govind 354 
			if (ticketSearchType == null) {
24791 govind 355 
				if (ticketStatus.equals(TicketStatus.RESOLVED)) {
356 
					tickets = ticketRepository.selectAllByAssignee(authUser.getId(), Optional.empty(), sortOrder, null,
357 
							searchTerm, offset, limit);
358 
					size = ticketRepository.selectAllCountByAssignee(authUser.getId(), Optional.empty(), null,
359 
							searchTerm);
360 
				} else {
24787 govind 361 
					tickets = ticketRepository.selectAllByAssignee(authUser.getId(),
362 
							Optional.of(TicketStatus.OPENED.equals(ticketStatus)), sortOrder, null, searchTerm, offset,
363 
							limit);
364 
					size = ticketRepository.selectAllCountByAssignee(authUser.getId(),
365 
							Optional.of(TicketStatus.OPENED.equals(ticketStatus)), null, searchTerm);
24791 govind 366 
				}
367 
 
24787 govind 368 
			} else {
24791 govind 369 
 
370 
				if (ticketStatus.equals(TicketStatus.RESOLVED)) {
371 
					tickets = ticketRepository.selectAllByAssignee(authUser.getId(), Optional.empty(), sortOrder,
372 
							ticketSearchType, searchTerm, offset, limit);
373 
					size = ticketRepository.selectAllCountByAssignee(authUser.getId(), Optional.empty(),
374 
							ticketSearchType, searchTerm);
375 
				} else {
24787 govind 376 
					tickets = ticketRepository.selectAllByAssignee(authUser.getId(),
377 
							Optional.of(TicketStatus.OPENED.equals(ticketStatus)), sortOrder, ticketSearchType,
378 
							searchTerm, offset, limit);
379 
					size = ticketRepository.selectAllCountByAssignee(authUser.getId(),
380 
							Optional.of(TicketStatus.OPENED.equals(ticketStatus)), ticketSearchType, searchTerm);
24791 govind 381 
				}
24787 govind 382 
			}
24824 govind 383 
			// LOGGER.info(size + "size");
24791 govind 384 
			if (tickets.size() > 0) {
385 
				ticketAssigneds = ticketAssignedRepository
386 
						.selectByTicketIds(tickets.stream().map(x -> x.getId()).collect(Collectors.toList()));
387 
				authUserIdAndAuthUserMap = csService.getAuthUserIdAndAuthUserMap(ticketAssigneds);
388 
				Map<Integer, CustomRetailer> fofoIdsAndCustomRetailer = csService.getPartnerByFofoIds(tickets);
389 
				model.addAttribute("fofoIdsAndCustomRetailer", fofoIdsAndCustomRetailer);
24787 govind 390 
			}
24620 govind 391 
 
24417 govind 392 
		} else {
24699 govind 393 
			tickets = ticketRepository.selectAllByCreator(loginDetails.getFofoId(),
24751 govind 394 
					Optional.of(TicketStatus.OPENED.equals(ticketStatus)), sortOrder, offset, limit);
24699 govind 395 
			size = ticketRepository.selectAllCountByCreator(loginDetails.getFofoId(),
24751 govind 396 
					Optional.of(TicketStatus.OPENED.equals(ticketStatus)));
24699 govind 397 
		}
398 
		authUserIdAndAuthUserMap = csService.getTicketIdAndAuthUserMapUsingTickets(tickets);
24500 govind 399 
 
24417 govind 400 
		if (size < limit) {
401 
			model.addAttribute("end", offset + size);
402 
		} else {
403 
			model.addAttribute("end", offset + limit);
404 
		}
405 
		model.addAttribute("start", offset + 1);
406 
		model.addAttribute("size", size);
24500 govind 407 
		model.addAttribute("roleType", roleManager.isAdmin(new HashSet<>(loginDetails.getRoleIds())));
24417 govind 408 
		Map<Integer, TicketSubCategory> subCategoryIdAndSubCategoryMap = csService
409 
				.getSubCategoryIdAndSubCategoryMap(tickets);
410 
		model.addAttribute("tickets", tickets);
24620 govind 411 
		model.addAttribute("resolved", ActivityType.RESOLVED);
412 
		model.addAttribute("resolved-accepted", ActivityType.RESOLVED_ACCEPTED);
413 
		model.addAttribute("resolved-rejected", ActivityType.RESOLVED_REJECTED);
24417 govind 414 
		model.addAttribute("authUserIdAndAuthUserMap", authUserIdAndAuthUserMap);
415 
		model.addAttribute("subCategoryIdAndSubCategoryMap", subCategoryIdAndSubCategoryMap);
24699 govind 416 
		model.addAttribute("ticketStatusValues", TicketStatus.values());
417 
		model.addAttribute("orderByValues", SortOrder.values());
418 
		model.addAttribute("selectedticketStatus", ticketStatus);
419 
		model.addAttribute("selectedorderby", sortOrder);
24787 govind 420 
		model.addAttribute("ticketSearchTypes", TicketSearchType.values());
421 
		model.addAttribute("ticketSearchType", ticketSearchType);
422 
		model.addAttribute("searchTerm", searchTerm);
24417 govind 423 
		return "ticket";
424 
	}
24500 govind 425 
 
24417 govind 426 
	@GetMapping(value = "/cs/myticketPaginated")
24500 govind 427 
	public String getMyTicketPaginated(HttpServletRequest request,
24699 govind 428 
			@RequestParam(name = "orderby", defaultValue = "DESCENDING") SortOrder sortOrder,
429 
			@RequestParam(name = "ticketStatus", defaultValue = "OPENED") TicketStatus ticketStatus,
24787 govind 430 
			@RequestParam(name = "ticketSearchType", defaultValue = "") TicketSearchType ticketSearchType,
431 
			@RequestParam(name = "searchTerm", defaultValue = "0") int searchTerm,
24500 govind 432 
			@RequestParam(name = "offset", defaultValue = "0") int offset,
24417 govind 433 
			@RequestParam(name = "limit", defaultValue = "10") int limit, Model model)
434 
			throws ProfitMandiBusinessException {
435 
		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
436 
		List<Ticket> tickets = null;
24500 govind 437 
		List<TicketAssigned> ticketAssigneds = null;
24824 govind 438 
 
24500 govind 439 
		Map<Integer, AuthUser> authUserIdAndAuthUserMap = null;
24824 govind 440 
 
24417 govind 441 
		if (roleManager.isAdmin(new HashSet<>(loginDetails.getRoleIds()))) {
442 
			AuthUser authUser = authRepository.selectByEmailOrMobile(loginDetails.getEmailId());
24791 govind 443 
			if (ticketSearchType == null) {
444 
				if (ticketStatus.equals(TicketStatus.RESOLVED)) {
445 
					tickets = ticketRepository.selectAllByAssignee(authUser.getId(), Optional.empty(), sortOrder, null,
446 
							searchTerm, offset, limit);
447 
				} else {
448 
					tickets = ticketRepository.selectAllByAssignee(authUser.getId(),
449 
							Optional.of(TicketStatus.OPENED.equals(ticketStatus)), sortOrder, null, searchTerm, offset,
450 
							limit);
451 
				}
24787 govind 452 
 
453 
			} else {
24791 govind 454 
 
455 
				if (ticketStatus.equals(TicketStatus.RESOLVED)) {
456 
					tickets = ticketRepository.selectAllByAssignee(authUser.getId(), Optional.empty(), sortOrder,
457 
							ticketSearchType, searchTerm, offset, limit);
458 
				} else {
459 
					tickets = ticketRepository.selectAllByAssignee(authUser.getId(),
460 
							Optional.of(TicketStatus.OPENED.equals(ticketStatus)), sortOrder, ticketSearchType,
461 
							searchTerm, offset, limit);
462 
				}
24787 govind 463 
			}
24747 govind 464 
			ticketAssigneds = ticketAssignedRepository
465 
					.selectByTicketIds(tickets.stream().map(x -> x.getId()).collect(Collectors.toList()));
24620 govind 466 
			authUserIdAndAuthUserMap = csService.getAuthUserIdAndAuthUserMap(ticketAssigneds);
467 
			Map<Integer, CustomRetailer> fofoIdsAndCustomRetailer = csService.getPartnerByFofoIds(tickets);
468 
			model.addAttribute("fofoIdsAndCustomRetailer", fofoIdsAndCustomRetailer);
24417 govind 469 
		} else {
24747 govind 470 
			tickets = ticketRepository.selectAllByCreator(loginDetails.getFofoId(),
24751 govind 471 
					Optional.of(TicketStatus.OPENED.equals(ticketStatus)), sortOrder, offset, limit);
24500 govind 472 
			authUserIdAndAuthUserMap = csService.getTicketIdAndAuthUserMapUsingTickets(tickets);
24417 govind 473 
		}
24500 govind 474 
		model.addAttribute("roleType", roleManager.isAdmin(new HashSet<>(loginDetails.getRoleIds())));
24417 govind 475 
		Map<Integer, TicketSubCategory> subCategoryIdAndSubCategoryMap = csService
476 
				.getSubCategoryIdAndSubCategoryMap(tickets);
477 
		model.addAttribute("tickets", tickets);
478 
		model.addAttribute("authUserIdAndAuthUserMap", authUserIdAndAuthUserMap);
479 
		model.addAttribute("subCategoryIdAndSubCategoryMap", subCategoryIdAndSubCategoryMap);
24699 govind 480 
		model.addAttribute("resolved", ActivityType.RESOLVED);
481 
		model.addAttribute("resolved-accepted", ActivityType.RESOLVED_ACCEPTED);
482 
		model.addAttribute("resolved-rejected", ActivityType.RESOLVED_REJECTED);
24417 govind 483 
		return "ticket-paginated";
484 
	}
485 
 
486 
	@GetMapping(value = "/cs/getActivities")
487 
	public String getActivity(HttpServletRequest request,
488 
			@RequestParam(name = "ticketId", defaultValue = "0") int ticketId, Model model) throws Exception {
24824 govind 489 
		List<Activity> allactivities = activityRepository.selectAll(ticketId);
490 
		List<Activity> activities = null;
24572 amit.gupta 491 
		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
24620 govind 492 
		if (roleManager.isAdmin(loginDetails.getRoleIds())) {
24824 govind 493 
			Set<Integer> authUserIds = allactivities.stream().map(x -> x.getCreatedBy()).collect(Collectors.toSet());
24572 amit.gupta 494 
			List<AuthUser> users = authRepository.selectAllAuthUserByIds(new ArrayList<>(authUserIds));
24620 govind 495 
			Map<Integer, String> authUserNameMap = users.stream()
496 
					.collect(Collectors.toMap(AuthUser::getId, x -> x.getFirstName() + " " + x.getLastName()));
24824 govind 497 
			allactivities.stream().forEach(x -> x.setName(authUserNameMap.get(x.getCreatedBy())));
498 
			activities = allactivities;
499 
		} else {
500 
			activities = allactivities.stream().filter(x -> !x.getType().equals(ActivityType.COMMUNICATION_INTERNAL))
501 
					.collect(Collectors.toList());
24572 amit.gupta 502 
		}
24417 govind 503 
		if (activities == null) {
504 
			throw new ProfitMandiBusinessException("Activity", ticketId, "No Activity Found");
505 
		}
506 
		model.addAttribute("response", mvcResponseSender.createResponseString(activities));
507 
		return "response";
508 
 
509 
	}
510 
 
511 
	@PostMapping(value = "/cs/createActivity")
512 
	public String createActivity(HttpServletRequest request,
513 
			@RequestParam(name = "ticketId", defaultValue = "0") int ticketId,
24500 govind 514 
			@RequestParam(name = "assigneeId", defaultValue = "0") int assigneeId,
24824 govind 515 
			@RequestParam(name = "internal", defaultValue = "true") boolean internal,
24417 govind 516 
			@RequestParam(name = "message", defaultValue = "") String message, Model model) throws Exception {
517 
		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
24500 govind 518 
		Ticket ticket = ticketRepository.selectById(ticketId);
519 
		if (ticket.getCloseTimestamp() == null) {
520 
			if (!roleManager.isAdmin(new HashSet<>(loginDetails.getRoleIds()))) {
521 
				Activity activity = new Activity();
522 
				activity.setMessage(message);
523 
				activity.setCreatedBy(0);
524 
				activity.setCreateTimestamp(LocalDateTime.now());
525 
				activity.setType(ActivityType.COMMUNICATION_IN);
526 
				csService.addActivity(ticketId, activity);
24620 govind 527 
				AuthUser authUser = authRepository.selectById(ticket.getL1AuthUser());
528 
				String subject = String.format(ACTIVITY_SUBJECT, ticket.getId());
529 
				String[] cc = { authRepository.selectById(ticket.getL2AuthUser()).getEmailId(),
530 
						authRepository.selectById(ticket.getL3AuthUser()).getEmailId() };
531 
				// LOGGER.info(authUser.getEmailId()+" "+cc+" "+subject+" "+message);
24824 govind 532 
				// this.activityRelatedMail(authUser.getEmailId(), cc, subject, message);
24500 govind 533 
				model.addAttribute("response", mvcResponseSender.createResponseString(authUser));
534 
			} else {
535 
				AuthUser authUser = authRepository.selectByEmailOrMobile(loginDetails.getEmailId());
536 
				Activity activity = new Activity();
537 
				activity.setMessage(message);
538 
				activity.setCreatedBy(authUser.getId());
539 
				activity.setCreateTimestamp(LocalDateTime.now());
24824 govind 540 
				if (internal) {
541 
					activity.setType(ActivityType.COMMUNICATION_INTERNAL);
542 
 
543 
				} else {
544 
 
545 
					activity.setType(ActivityType.COMMUNICATION_OUT);
546 
					String subject = String.format(ACTIVITY_SUBJECT, ticket.getId());
547 
					this.activityRelatedMail(retailerService.getFofoRetailer(ticket.getFofoId()).getEmail(), null,
548 
							subject, message);
549 
				}
24500 govind 550 
				csService.addActivity(ticketId, activity);
24824 govind 551 
 
552 
				// LOGGER.info(authUser.getEmailId() + " " + subject + " " + message);
553 
 
24500 govind 554 
				model.addAttribute("response", mvcResponseSender.createResponseString(authUser));
555 
			}
24417 govind 556 
		} else {
557 
			throw new ProfitMandiBusinessException("Ticket", ticket.getId(), "Already closed ticket");
558 
		}
559 
		return "response";
560 
	}
24500 govind 561 
 
24620 govind 562 
	private void activityRelatedMail(String to, String[] cc, String subject, String message)
563 
			throws ProfitMandiBusinessException {
564 
		try {
565 
			Utils.sendMailWithAttachments(mailSender, to, cc, subject, message, null);
566 
		} catch (Exception e) {
567 
			throw new ProfitMandiBusinessException("Ticket Activity", to, "Could not send ticket activity mail");
568 
		}
569 
	}
570 
 
24500 govind 571 
	@PostMapping(value = "/cs/closeTicket")
24417 govind 572 
	public String closeTicket(HttpServletRequest request,
24439 govind 573 
			@RequestParam(name = "ticketId", defaultValue = "0") int ticketId,
24500 govind 574 
			@RequestParam(name = "happyCode") String happyCode, Model model) throws Exception {
575 
		Ticket ticket = ticketRepository.selectById(ticketId);
576 
		if (ticket.getHappyCode().equals(happyCode)) {
577 
			ticket.setCloseTimestamp(LocalDateTime.now());
578 
			ticketRepository.persist(ticket);
579 
			model.addAttribute("response", mvcResponseSender.createResponseString(true));
580 
		} else {
581 
			throw new ProfitMandiBusinessException("Ticket", ticketId, "Happy Code can't match");
24439 govind 582 
		}
24417 govind 583 
		return "response";
584 
	}
24500 govind 585 
 
586 
	@GetMapping(value = "/cs/managerTicket")
587 
	public String getL2L3AndL4Tickets(HttpServletRequest request,
24699 govind 588 
			@RequestParam(name = "orderby", defaultValue = "DESCENDING") SortOrder sortOrder,
589 
			@RequestParam(name = "ticketStatus", defaultValue = "OPENED") TicketStatus ticketStatus,
24747 govind 590 
			@RequestParam(name = "ticketSearchType", defaultValue = "") TicketSearchType ticketSearchType,
591 
			@RequestParam(name = "searchTerm", defaultValue = "0") int searchTerm,
24500 govind 592 
			@RequestParam(name = "offset", defaultValue = "0") int offset,
593 
			@RequestParam(name = "limit", defaultValue = "10") int limit, Model model)
594 
			throws ProfitMandiBusinessException {
24439 govind 595 
		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
596 
		long size = 0;
24500 govind 597 
		AuthUser authUser = authRepository.selectByEmailOrMobile(loginDetails.getEmailId());
598 
		List<Ticket> tickets = null;
24569 govind 599 
		Map<Integer, List<AuthUser>> authUserListMap = null;
24500 govind 600 
		if (loginDetails.getEmailId().equals("amandeep.singh@smartdukaan.com")) {
601 
			tickets = ticketRepository.selectAll(offset, limit, Optional.empty());
24620 govind 602 
			authUserListMap = csService.getAuthUserList(tickets, authUser);
24500 govind 603 
			size = ticketRepository.selectAllCount();
604 
		} else {
24747 govind 605 
			if (ticketSearchType == null) {
24787 govind 606 
				if (ticketStatus.equals(TicketStatus.RESOLVED)) {
607 
					tickets = ticketRepository.selectAllManagerTicket(authUser.getId(), sortOrder, Optional.empty(),
608 
							null, searchTerm, offset, limit);
609 
					size = ticketRepository.selectAllCountByManagerTicket(authUser.getId(), Optional.empty(), null, 0);
610 
				} else {
611 
					tickets = ticketRepository.selectAllManagerTicket(authUser.getId(), sortOrder,
612 
							Optional.of(TicketStatus.CLOSED.equals(ticketStatus)), null, searchTerm, offset, limit);
613 
					size = ticketRepository.selectAllCountByManagerTicket(authUser.getId(),
614 
							Optional.of(TicketStatus.CLOSED.equals(ticketStatus)), null, 0);
615 
				}
24747 govind 616 
			} else {
24787 govind 617 
				if (ticketStatus.equals(TicketStatus.RESOLVED)) {
618 
					tickets = ticketRepository.selectAllManagerTicket(authUser.getId(), sortOrder, Optional.empty(),
619 
							ticketSearchType, searchTerm, offset, limit);
620 
					size = ticketRepository.selectAllCountByManagerTicket(authUser.getId(), Optional.empty(),
621 
							ticketSearchType, searchTerm);
622 
				} else {
623 
					tickets = ticketRepository.selectAllManagerTicket(authUser.getId(), sortOrder,
624 
							Optional.of(TicketStatus.CLOSED.equals(ticketStatus)), ticketSearchType, searchTerm, offset,
625 
							limit);
626 
					size = ticketRepository.selectAllCountByManagerTicket(authUser.getId(),
627 
							Optional.of(TicketStatus.CLOSED.equals(ticketStatus)), ticketSearchType, searchTerm);
628 
				}
629 
 
24747 govind 630 
			}
24620 govind 631 
			authUserListMap = csService.getAuthUserList(tickets, authUser);
24747 govind 632 
 
24620 govind 633 
			if (tickets.size() > 0) {
634 
				Map<Integer, CustomRetailer> fofoIdsAndCustomRetailer = csService.getPartnerByFofoIds(tickets);
635 
				model.addAttribute("fofoIdsAndCustomRetailer", fofoIdsAndCustomRetailer);
24439 govind 636 
			}
637 
		}
638 
		if (size < limit) {
639 
			model.addAttribute("end", offset + size);
640 
		} else {
641 
			model.addAttribute("end", offset + limit);
642 
		}
643 
		model.addAttribute("start", offset + 1);
644 
		model.addAttribute("size", size);
645 
		model.addAttribute("tickets", tickets);
24500 govind 646 
 
24439 govind 647 
		Map<Integer, TicketSubCategory> subCategoryIdAndSubCategoryMap = csService
648 
				.getSubCategoryIdAndSubCategoryMap(tickets);
24699 govind 649 
		model.addAttribute("ticketStatusValues", TicketStatus.values());
650 
		model.addAttribute("orderByValues", SortOrder.values());
651 
		model.addAttribute("selectedticketStatus", ticketStatus);
652 
		model.addAttribute("selectedorderby", sortOrder);
24439 govind 653 
		model.addAttribute("tickets", tickets);
24747 govind 654 
		model.addAttribute("ticketSearchTypes", TicketSearchType.values());
24750 govind 655 
		model.addAttribute("ticketSearchType", ticketSearchType);
24747 govind 656 
		model.addAttribute("searchTerm", searchTerm);
24500 govind 657 
		model.addAttribute("authUserListMap", authUserListMap);
24439 govind 658 
		model.addAttribute("subCategoryIdAndSubCategoryMap", subCategoryIdAndSubCategoryMap);
659 
		return "managerTicket";
660 
	}
24500 govind 661 
 
662 
	@GetMapping(value = "/cs/managerTicket-paginated")
663 
	public String getL2L3AndL4TicketsPaginated(HttpServletRequest request,
24699 govind 664 
			@RequestParam(name = "orderby", defaultValue = "DESCENDING") SortOrder sortOrder,
665 
			@RequestParam(name = "ticketStatus", defaultValue = "OPENED") TicketStatus ticketStatus,
24747 govind 666 
			@RequestParam(name = "ticketSearchType", defaultValue = "") TicketSearchType ticketSearchType,
667 
			@RequestParam(name = "searchTerm", defaultValue = "0") int searchTerm,
24500 govind 668 
			@RequestParam(name = "offset", defaultValue = "0") int offset,
669 
			@RequestParam(name = "limit", defaultValue = "10") int limit, Model model)
670 
			throws ProfitMandiBusinessException {
24467 govind 671 
		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
24500 govind 672 
		AuthUser authUser = authRepository.selectByEmailOrMobile(loginDetails.getEmailId());
24557 govind 673 
		Map<Integer, List<AuthUser>> authUserListMap = null;
24500 govind 674 
		List<Ticket> tickets = null;
675 
		if (loginDetails.getEmailId().equals("amandeep.singh@smartdukaan.com")) {
676 
			tickets = ticketRepository.selectAll(offset, limit, Optional.empty());
24620 govind 677 
			authUserListMap = csService.getAuthUserList(tickets, authUser);
24500 govind 678 
		} else {
24747 govind 679 
			if (ticketSearchType == null) {
24787 govind 680 
				if (ticketStatus.equals(TicketStatus.RESOLVED)) {
681 
					tickets = ticketRepository.selectAllManagerTicket(authUser.getId(), sortOrder, Optional.empty(),
682 
							null, searchTerm, offset, limit);
683 
 
684 
				} else {
685 
					tickets = ticketRepository.selectAllManagerTicket(authUser.getId(), sortOrder,
686 
							Optional.of(TicketStatus.CLOSED.equals(ticketStatus)), null, searchTerm, offset, limit);
687 
 
688 
				}
24747 govind 689 
			} else {
24787 govind 690 
				if (ticketStatus.equals(TicketStatus.RESOLVED)) {
691 
					tickets = ticketRepository.selectAllManagerTicket(authUser.getId(), sortOrder, Optional.empty(),
692 
							ticketSearchType, searchTerm, offset, limit);
693 
 
694 
				} else {
695 
					tickets = ticketRepository.selectAllManagerTicket(authUser.getId(), sortOrder,
696 
							Optional.of(TicketStatus.CLOSED.equals(ticketStatus)), ticketSearchType, searchTerm, offset,
697 
							limit);
698 
				}
699 
 
24747 govind 700 
			}
24620 govind 701 
			authUserListMap = csService.getAuthUserList(tickets, authUser);
702 
			if (tickets.size() > 0) {
24500 govind 703 
				Map<Integer, CustomRetailer> fofoIdsAndCustomRetailer = csService.getPartnerByFofoIds(tickets);
24467 govind 704 
				model.addAttribute("fofoIdsAndCustomRetailer", fofoIdsAndCustomRetailer);
24620 govind 705 
			}
24467 govind 706 
		}
707 
		model.addAttribute("tickets", tickets);
708 
		Map<Integer, TicketSubCategory> subCategoryIdAndSubCategoryMap = csService
709 
				.getSubCategoryIdAndSubCategoryMap(tickets);
710 
		model.addAttribute("tickets", tickets);
24500 govind 711 
		model.addAttribute("authUserListMap", authUserListMap);
24467 govind 712 
		model.addAttribute("subCategoryIdAndSubCategoryMap", subCategoryIdAndSubCategoryMap);
713 
		return "managerTicket-paginated";
714 
	}
24500 govind 715 
 
716 
	@GetMapping(value = "/cs/edit-ticket")
717 
	public String getEditTicket(HttpServletRequest request,
718 
			@RequestParam(name = "ticketId", defaultValue = "0") int ticketId, Model model) {
719 
		Ticket ticket = ticketRepository.selectById(ticketId);
720 
		List<TicketCategory> ticketCategories = csService.getAllTicketCategotyFromSubCategory();
721 
		TicketSubCategory ticketSubCategory = ticketSubCategoryRepository.selectById(ticket.getSubCategoryId());
722 
		List<TicketSubCategory> ticketSubCategories = ticketSubCategoryRepository
723 
				.selectAll(ticketSubCategory.getcategoryId());
24569 govind 724 
		List<AuthUser> authUsers = authRepository.selectAll();
24467 govind 725 
		model.addAttribute("ticket", ticket);
726 
		model.addAttribute("ticketCategories", ticketCategories);
727 
		model.addAttribute("ticketSubCategories", ticketSubCategories);
24575 govind 728 
		model.addAttribute("ticketSubCategory", ticketSubCategory);
24500 govind 729 
		model.addAttribute("authUsers", authUsers);
24467 govind 730 
		return "edit-ticket-modal";
731 
	}
24500 govind 732 
 
733 
	@PostMapping(value = "/cs/edit-ticket")
734 
	public String editTicket(HttpServletRequest request,
735 
			@RequestParam(name = "ticketId", defaultValue = "0") int ticketId,
736 
			@RequestParam(name = "subCategoryId", defaultValue = "0") int subCategoryId,
737 
			@RequestParam(name = "categoryId", defaultValue = "0") int categoryId,
738 
			@RequestParam(name = "authUserId", defaultValue = "0") int authUserId, Model model) throws Exception {
24467 govind 739 
		LOGGER.info(ticketId);
24500 govind 740 
		Ticket ticket = ticketRepository.selectById(ticketId);
24569 govind 741 
		ticketAssignedRepository.deleteByTicketId(ticketId);
742 
		if (ticket.getSubCategoryId() == subCategoryId) {
743 
			LOGGER.info(ticket);
744 
			TicketAssigned ticketAssigned = new TicketAssigned();
24500 govind 745 
			ticketAssigned.setTicketId(ticketId);
746 
			ticketAssigned.setAssineeId(authUserId);
747 
			ticketAssignedRepository.persist(ticketAssigned);
24569 govind 748 
			ticket.setL1AuthUser(authUserId);
749 
			ticket.setSubCategoryId(subCategoryId);
750 
			ticket.setUpdateTimestamp(LocalDateTime.now());
751 
			ticket.setL2EscalationTimestamp(ticket.getUpdateTimestamp().plusDays(2));
752 
			ticket.setL3EscalationTimestamp(ticket.getL2EscalationTimestamp().plusDays(2));
753 
			ticket.setLastEscalationTimestamp(ticket.getL3EscalationTimestamp().plusDays(2));
754 
			ticketRepository.persist(ticket);
755 
			csService.sendAssignedTicketMail(authRepository.selectById(authUserId), ticket);
24500 govind 756 
			model.addAttribute("response", mvcResponseSender.createResponseString(true));
24569 govind 757 
		} else {
758 
			csService.updateTicket(categoryId, subCategoryId, ticket);
759 
			model.addAttribute("response", mvcResponseSender.createResponseString(true));
24500 govind 760 
		}
24467 govind 761 
		return "response";
762 
	}
24500 govind 763 
 
764 
	@DeleteMapping(value = "/cs/removePosition")
765 
	public String removePosition(HttpServletRequest request,
766 
			@RequestParam(name = "positionId", defaultValue = "0") int positionId, Model model) throws Exception {
24471 govind 767 
		positionRepository.delete(positionId);
768 
		model.addAttribute("response", mvcResponseSender.createResponseString(true));
769 
		return "response";
770 
	}
24620 govind 771 
 
772 
	@PostMapping(value = "/cs/create-last-activity")
773 
	public String createlastActivity(HttpServletRequest request, @RequestParam(name = "ticketId") int ticketId,
774 
			@RequestParam(name = "lastactivity") ActivityType lastActivity, Model model) throws Exception {
775 
		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
776 
		Ticket ticket = ticketRepository.selectById(ticketId);
777 
		Activity activity = new Activity();
778 
		String subject = String.format(ACTIVITY_SUBJECT, ticket.getId());
779 
		if (roleManager.isAdmin(loginDetails.getRoleIds())) {
780 
			ticket.setLastActivity(lastActivity);
781 
			String to = retailerService.getFofoRetailer(ticket.getFofoId()).getEmail();
24699 govind 782 
			String message = String.format(PARTNER_RESOLVED_TICKET_MAIL, ticketId, "REOPEN");
24620 govind 783 
			activity.setMessage(message);
784 
			activity.setCreatedBy(authRepository.selectByEmailOrMobile(loginDetails.getEmailId()).getId());
785 
			activity.setTicketId(ticketId);
786 
			activity.setCreateTimestamp(LocalDateTime.now());
787 
			activity.setType(ActivityType.COMMUNICATION_OUT);
24621 govind 788 
			this.activityRelatedMail(to, null, subject, message);
24620 govind 789 
		} else {
790 
			if (ActivityType.RESOLVED_ACCEPTED == lastActivity) {
791 
				ticket.setLastActivity(lastActivity);
792 
				ticket.setCloseTimestamp(LocalDateTime.now());
793 
				activity.setMessage(ActivityType.RESOLVED.toString());
794 
				activity.setCreatedBy(0);
795 
				activity.setTicketId(ticketId);
796 
				activity.setType(ActivityType.COMMUNICATION_IN);
797 
				activity.setCreateTimestamp(LocalDateTime.now());
798 
			} else {
24699 govind 799 
				String message = String.format(INTERNAL_REOPEN_MAIL, ticketId,
800 
						retailerService.getFofoRetailer(loginDetails.getFofoId()).getBusinessName());
24620 govind 801 
				String to = authRepository.selectById(ticket.getL1AuthUser()).getEmailId();
802 
				String cc[] = { authRepository.selectById(ticket.getL2AuthUser()).getEmailId(),
803 
						authRepository.selectById(ticket.getL3AuthUser()).getEmailId() };
804 
				ticket.setLastActivity(lastActivity);
24638 govind 805 
				ticket.setUpdateTimestamp(LocalDateTime.now());
806 
				ticket.setL2EscalationTimestamp(ticket.getUpdateTimestamp().plusDays(2));
807 
				ticket.setL3EscalationTimestamp(ticket.getL2EscalationTimestamp().plusDays(2));
808 
				ticket.setLastEscalationTimestamp(ticket.getL3EscalationTimestamp().plusDays(2));
809 
				ticketAssignedRepository.deleteByTicketId(ticketId);
24699 govind 810 
				TicketAssigned ticketAssigned = new TicketAssigned();
24638 govind 811 
				ticketAssigned.setAssineeId(ticket.getL1AuthUser());
812 
				ticketAssigned.setTicketId(ticketId);
813 
				ticketAssignedRepository.persist(ticketAssigned);
24620 govind 814 
				activity.setMessage(INTERNAL_REOPEN_ACTIVITY_MESSAGE);
815 
				activity.setCreatedBy(0);
816 
				activity.setTicketId(ticketId);
817 
				activity.setType(ActivityType.COMMUNICATION_IN);
818 
				activity.setCreateTimestamp(LocalDateTime.now());
24621 govind 819 
				this.activityRelatedMail(to, cc, subject, message);
24699 govind 820 
				this.activityRelatedMail(retailerService.getFofoRetailer(loginDetails.getFofoId()).getEmail(), null,
821 
						subject, String.format(PARTNER_REOPEN, ticketId));
24620 govind 822 
			}
823 
 
824 
		}
825 
		ticketRepository.persist(ticket);
826 
		activityRepository.persist(activity);
827 
		model.addAttribute("response", mvcResponseSender.createResponseString(true));
828 
		return "response";
829 
	}
830 
 
24417 govind 831 
}