Subversion Repositories SmartDukaan

Rev

Rev 24791 | Rev 24836 | 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);
24747 govind 328 
		List<Ticket> tickets = ticketRepository.selectAllByCreator(loginDetails.getFofoId(), Optional.of(true),
329 
				SortOrder.DESCENDING, 0, 10);
24620 govind 330 
		if (tickets.size() > 3 || tickets.size() == 3) {
331 
			model.addAttribute("response", mvcResponseSender.createResponseString(false));
332 
		} else {
333 
			csService.createTicket(loginDetails.getFofoId(), categoryId, subCategoryId, message);
334 
			model.addAttribute("response", mvcResponseSender.createResponseString(true));
335 
		}
24417 govind 336 
		return "response";
337 
	}
338 
 
339 
	@GetMapping(value = "/cs/myticket")
24699 govind 340 
	public String getTicket(HttpServletRequest request,
341 
			@RequestParam(name = "orderby", defaultValue = "DESCENDING") SortOrder sortOrder,
342 
			@RequestParam(name = "ticketStatus", defaultValue = "OPENED") TicketStatus ticketStatus,
24787 govind 343 
			@RequestParam(name = "ticketSearchType", defaultValue = "") TicketSearchType ticketSearchType,
344 
			@RequestParam(name = "searchTerm", defaultValue = "0") int searchTerm,
24699 govind 345 
			@RequestParam(name = "offset", defaultValue = "0") int offset,
24417 govind 346 
			@RequestParam(name = "limit", defaultValue = "10") int limit, Model model)
347 
			throws ProfitMandiBusinessException {
348 
		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
349 
		List<Ticket> tickets = null;
24500 govind 350 
		List<TicketAssigned> ticketAssigneds = null;
24417 govind 351 
		long size = 0;
24500 govind 352 
		Map<Integer, AuthUser> authUserIdAndAuthUserMap = null;
24417 govind 353 
		if (roleManager.isAdmin(new HashSet<>(loginDetails.getRoleIds()))) {
354 
			AuthUser authUser = authRepository.selectByEmailOrMobile(loginDetails.getEmailId());
24787 govind 355 
			if (ticketSearchType == null) {
24791 govind 356 
				if (ticketStatus.equals(TicketStatus.RESOLVED)) {
357 
					tickets = ticketRepository.selectAllByAssignee(authUser.getId(), Optional.empty(), sortOrder, null,
358 
							searchTerm, offset, limit);
359 
					size = ticketRepository.selectAllCountByAssignee(authUser.getId(), Optional.empty(), null,
360 
							searchTerm);
361 
				} else {
24787 govind 362 
					tickets = ticketRepository.selectAllByAssignee(authUser.getId(),
363 
							Optional.of(TicketStatus.OPENED.equals(ticketStatus)), sortOrder, null, searchTerm, offset,
364 
							limit);
365 
					size = ticketRepository.selectAllCountByAssignee(authUser.getId(),
366 
							Optional.of(TicketStatus.OPENED.equals(ticketStatus)), null, searchTerm);
24791 govind 367 
				}
368 
 
24787 govind 369 
			} else {
24791 govind 370 
 
371 
				if (ticketStatus.equals(TicketStatus.RESOLVED)) {
372 
					tickets = ticketRepository.selectAllByAssignee(authUser.getId(), Optional.empty(), sortOrder,
373 
							ticketSearchType, searchTerm, offset, limit);
374 
					size = ticketRepository.selectAllCountByAssignee(authUser.getId(), Optional.empty(),
375 
							ticketSearchType, searchTerm);
376 
				} else {
24787 govind 377 
					tickets = ticketRepository.selectAllByAssignee(authUser.getId(),
378 
							Optional.of(TicketStatus.OPENED.equals(ticketStatus)), sortOrder, ticketSearchType,
379 
							searchTerm, offset, limit);
380 
					size = ticketRepository.selectAllCountByAssignee(authUser.getId(),
381 
							Optional.of(TicketStatus.OPENED.equals(ticketStatus)), ticketSearchType, searchTerm);
24791 govind 382 
				}
24787 govind 383 
			}
24824 govind 384 
			// LOGGER.info(size + "size");
24791 govind 385 
			if (tickets.size() > 0) {
386 
				ticketAssigneds = ticketAssignedRepository
387 
						.selectByTicketIds(tickets.stream().map(x -> x.getId()).collect(Collectors.toList()));
388 
				authUserIdAndAuthUserMap = csService.getAuthUserIdAndAuthUserMap(ticketAssigneds);
389 
				Map<Integer, CustomRetailer> fofoIdsAndCustomRetailer = csService.getPartnerByFofoIds(tickets);
390 
				model.addAttribute("fofoIdsAndCustomRetailer", fofoIdsAndCustomRetailer);
24787 govind 391 
			}
24620 govind 392 
 
24417 govind 393 
		} else {
24699 govind 394 
			tickets = ticketRepository.selectAllByCreator(loginDetails.getFofoId(),
24751 govind 395 
					Optional.of(TicketStatus.OPENED.equals(ticketStatus)), sortOrder, offset, limit);
24699 govind 396 
			size = ticketRepository.selectAllCountByCreator(loginDetails.getFofoId(),
24751 govind 397 
					Optional.of(TicketStatus.OPENED.equals(ticketStatus)));
24699 govind 398 
		}
399 
		authUserIdAndAuthUserMap = csService.getTicketIdAndAuthUserMapUsingTickets(tickets);
24500 govind 400 
 
24417 govind 401 
		if (size < limit) {
402 
			model.addAttribute("end", offset + size);
403 
		} else {
404 
			model.addAttribute("end", offset + limit);
405 
		}
406 
		model.addAttribute("start", offset + 1);
407 
		model.addAttribute("size", size);
24500 govind 408 
		model.addAttribute("roleType", roleManager.isAdmin(new HashSet<>(loginDetails.getRoleIds())));
24417 govind 409 
		Map<Integer, TicketSubCategory> subCategoryIdAndSubCategoryMap = csService
410 
				.getSubCategoryIdAndSubCategoryMap(tickets);
411 
		model.addAttribute("tickets", tickets);
24620 govind 412 
		model.addAttribute("resolved", ActivityType.RESOLVED);
413 
		model.addAttribute("resolved-accepted", ActivityType.RESOLVED_ACCEPTED);
414 
		model.addAttribute("resolved-rejected", ActivityType.RESOLVED_REJECTED);
24417 govind 415 
		model.addAttribute("authUserIdAndAuthUserMap", authUserIdAndAuthUserMap);
416 
		model.addAttribute("subCategoryIdAndSubCategoryMap", subCategoryIdAndSubCategoryMap);
24699 govind 417 
		model.addAttribute("ticketStatusValues", TicketStatus.values());
418 
		model.addAttribute("orderByValues", SortOrder.values());
419 
		model.addAttribute("selectedticketStatus", ticketStatus);
420 
		model.addAttribute("selectedorderby", sortOrder);
24787 govind 421 
		model.addAttribute("ticketSearchTypes", TicketSearchType.values());
422 
		model.addAttribute("ticketSearchType", ticketSearchType);
423 
		model.addAttribute("searchTerm", searchTerm);
24417 govind 424 
		return "ticket";
425 
	}
24500 govind 426 
 
24417 govind 427 
	@GetMapping(value = "/cs/myticketPaginated")
24500 govind 428 
	public String getMyTicketPaginated(HttpServletRequest request,
24699 govind 429 
			@RequestParam(name = "orderby", defaultValue = "DESCENDING") SortOrder sortOrder,
430 
			@RequestParam(name = "ticketStatus", defaultValue = "OPENED") TicketStatus ticketStatus,
24787 govind 431 
			@RequestParam(name = "ticketSearchType", defaultValue = "") TicketSearchType ticketSearchType,
432 
			@RequestParam(name = "searchTerm", defaultValue = "0") int searchTerm,
24500 govind 433 
			@RequestParam(name = "offset", defaultValue = "0") int offset,
24417 govind 434 
			@RequestParam(name = "limit", defaultValue = "10") int limit, Model model)
435 
			throws ProfitMandiBusinessException {
436 
		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
437 
		List<Ticket> tickets = null;
24500 govind 438 
		List<TicketAssigned> ticketAssigneds = null;
24824 govind 439 
 
24500 govind 440 
		Map<Integer, AuthUser> authUserIdAndAuthUserMap = null;
24824 govind 441 
 
24417 govind 442 
		if (roleManager.isAdmin(new HashSet<>(loginDetails.getRoleIds()))) {
443 
			AuthUser authUser = authRepository.selectByEmailOrMobile(loginDetails.getEmailId());
24791 govind 444 
			if (ticketSearchType == null) {
445 
				if (ticketStatus.equals(TicketStatus.RESOLVED)) {
446 
					tickets = ticketRepository.selectAllByAssignee(authUser.getId(), Optional.empty(), sortOrder, null,
447 
							searchTerm, offset, limit);
448 
				} else {
449 
					tickets = ticketRepository.selectAllByAssignee(authUser.getId(),
450 
							Optional.of(TicketStatus.OPENED.equals(ticketStatus)), sortOrder, null, searchTerm, offset,
451 
							limit);
452 
				}
24787 govind 453 
 
454 
			} else {
24791 govind 455 
 
456 
				if (ticketStatus.equals(TicketStatus.RESOLVED)) {
457 
					tickets = ticketRepository.selectAllByAssignee(authUser.getId(), Optional.empty(), sortOrder,
458 
							ticketSearchType, searchTerm, offset, limit);
459 
				} else {
460 
					tickets = ticketRepository.selectAllByAssignee(authUser.getId(),
461 
							Optional.of(TicketStatus.OPENED.equals(ticketStatus)), sortOrder, ticketSearchType,
462 
							searchTerm, offset, limit);
463 
				}
24787 govind 464 
			}
24747 govind 465 
			ticketAssigneds = ticketAssignedRepository
466 
					.selectByTicketIds(tickets.stream().map(x -> x.getId()).collect(Collectors.toList()));
24620 govind 467 
			authUserIdAndAuthUserMap = csService.getAuthUserIdAndAuthUserMap(ticketAssigneds);
468 
			Map<Integer, CustomRetailer> fofoIdsAndCustomRetailer = csService.getPartnerByFofoIds(tickets);
469 
			model.addAttribute("fofoIdsAndCustomRetailer", fofoIdsAndCustomRetailer);
24417 govind 470 
		} else {
24747 govind 471 
			tickets = ticketRepository.selectAllByCreator(loginDetails.getFofoId(),
24751 govind 472 
					Optional.of(TicketStatus.OPENED.equals(ticketStatus)), sortOrder, offset, limit);
24500 govind 473 
			authUserIdAndAuthUserMap = csService.getTicketIdAndAuthUserMapUsingTickets(tickets);
24417 govind 474 
		}
24500 govind 475 
		model.addAttribute("roleType", roleManager.isAdmin(new HashSet<>(loginDetails.getRoleIds())));
24417 govind 476 
		Map<Integer, TicketSubCategory> subCategoryIdAndSubCategoryMap = csService
477 
				.getSubCategoryIdAndSubCategoryMap(tickets);
478 
		model.addAttribute("tickets", tickets);
479 
		model.addAttribute("authUserIdAndAuthUserMap", authUserIdAndAuthUserMap);
480 
		model.addAttribute("subCategoryIdAndSubCategoryMap", subCategoryIdAndSubCategoryMap);
24699 govind 481 
		model.addAttribute("resolved", ActivityType.RESOLVED);
482 
		model.addAttribute("resolved-accepted", ActivityType.RESOLVED_ACCEPTED);
483 
		model.addAttribute("resolved-rejected", ActivityType.RESOLVED_REJECTED);
24417 govind 484 
		return "ticket-paginated";
485 
	}
486 
 
487 
	@GetMapping(value = "/cs/getActivities")
488 
	public String getActivity(HttpServletRequest request,
489 
			@RequestParam(name = "ticketId", defaultValue = "0") int ticketId, Model model) throws Exception {
24824 govind 490 
		List<Activity> allactivities = activityRepository.selectAll(ticketId);
491 
		List<Activity> activities = null;
24572 amit.gupta 492 
		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
24620 govind 493 
		if (roleManager.isAdmin(loginDetails.getRoleIds())) {
24824 govind 494 
			Set<Integer> authUserIds = allactivities.stream().map(x -> x.getCreatedBy()).collect(Collectors.toSet());
24572 amit.gupta 495 
			List<AuthUser> users = authRepository.selectAllAuthUserByIds(new ArrayList<>(authUserIds));
24620 govind 496 
			Map<Integer, String> authUserNameMap = users.stream()
497 
					.collect(Collectors.toMap(AuthUser::getId, x -> x.getFirstName() + " " + x.getLastName()));
24824 govind 498 
			allactivities.stream().forEach(x -> x.setName(authUserNameMap.get(x.getCreatedBy())));
499 
			activities = allactivities;
500 
		} else {
501 
			activities = allactivities.stream().filter(x -> !x.getType().equals(ActivityType.COMMUNICATION_INTERNAL))
502 
					.collect(Collectors.toList());
24572 amit.gupta 503 
		}
24417 govind 504 
		if (activities == null) {
505 
			throw new ProfitMandiBusinessException("Activity", ticketId, "No Activity Found");
506 
		}
507 
		model.addAttribute("response", mvcResponseSender.createResponseString(activities));
508 
		return "response";
509 
 
510 
	}
511 
 
512 
	@PostMapping(value = "/cs/createActivity")
513 
	public String createActivity(HttpServletRequest request,
514 
			@RequestParam(name = "ticketId", defaultValue = "0") int ticketId,
24500 govind 515 
			@RequestParam(name = "assigneeId", defaultValue = "0") int assigneeId,
24824 govind 516 
			@RequestParam(name = "internal", defaultValue = "true") boolean internal,
24417 govind 517 
			@RequestParam(name = "message", defaultValue = "") String message, Model model) throws Exception {
518 
		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
24500 govind 519 
		Ticket ticket = ticketRepository.selectById(ticketId);
520 
		if (ticket.getCloseTimestamp() == null) {
521 
			if (!roleManager.isAdmin(new HashSet<>(loginDetails.getRoleIds()))) {
522 
				Activity activity = new Activity();
523 
				activity.setMessage(message);
524 
				activity.setCreatedBy(0);
525 
				activity.setCreateTimestamp(LocalDateTime.now());
526 
				activity.setType(ActivityType.COMMUNICATION_IN);
527 
				csService.addActivity(ticketId, activity);
24620 govind 528 
				AuthUser authUser = authRepository.selectById(ticket.getL1AuthUser());
529 
				String subject = String.format(ACTIVITY_SUBJECT, ticket.getId());
530 
				String[] cc = { authRepository.selectById(ticket.getL2AuthUser()).getEmailId(),
531 
						authRepository.selectById(ticket.getL3AuthUser()).getEmailId() };
532 
				// LOGGER.info(authUser.getEmailId()+" "+cc+" "+subject+" "+message);
24824 govind 533 
				// this.activityRelatedMail(authUser.getEmailId(), cc, subject, message);
24500 govind 534 
				model.addAttribute("response", mvcResponseSender.createResponseString(authUser));
535 
			} else {
536 
				AuthUser authUser = authRepository.selectByEmailOrMobile(loginDetails.getEmailId());
537 
				Activity activity = new Activity();
538 
				activity.setMessage(message);
539 
				activity.setCreatedBy(authUser.getId());
540 
				activity.setCreateTimestamp(LocalDateTime.now());
24824 govind 541 
				if (internal) {
542 
					activity.setType(ActivityType.COMMUNICATION_INTERNAL);
543 
 
544 
				} else {
545 
 
546 
					activity.setType(ActivityType.COMMUNICATION_OUT);
547 
					String subject = String.format(ACTIVITY_SUBJECT, ticket.getId());
548 
					this.activityRelatedMail(retailerService.getFofoRetailer(ticket.getFofoId()).getEmail(), null,
549 
							subject, message);
550 
				}
24500 govind 551 
				csService.addActivity(ticketId, activity);
24824 govind 552 
 
553 
				// LOGGER.info(authUser.getEmailId() + " " + subject + " " + message);
554 
 
24500 govind 555 
				model.addAttribute("response", mvcResponseSender.createResponseString(authUser));
556 
			}
24417 govind 557 
		} else {
558 
			throw new ProfitMandiBusinessException("Ticket", ticket.getId(), "Already closed ticket");
559 
		}
560 
		return "response";
561 
	}
24500 govind 562 
 
24620 govind 563 
	private void activityRelatedMail(String to, String[] cc, String subject, String message)
564 
			throws ProfitMandiBusinessException {
565 
		try {
566 
			Utils.sendMailWithAttachments(mailSender, to, cc, subject, message, null);
567 
		} catch (Exception e) {
568 
			throw new ProfitMandiBusinessException("Ticket Activity", to, "Could not send ticket activity mail");
569 
		}
570 
	}
571 
 
24500 govind 572 
	@PostMapping(value = "/cs/closeTicket")
24417 govind 573 
	public String closeTicket(HttpServletRequest request,
24439 govind 574 
			@RequestParam(name = "ticketId", defaultValue = "0") int ticketId,
24500 govind 575 
			@RequestParam(name = "happyCode") String happyCode, Model model) throws Exception {
576 
		Ticket ticket = ticketRepository.selectById(ticketId);
577 
		if (ticket.getHappyCode().equals(happyCode)) {
578 
			ticket.setCloseTimestamp(LocalDateTime.now());
579 
			ticketRepository.persist(ticket);
580 
			model.addAttribute("response", mvcResponseSender.createResponseString(true));
581 
		} else {
582 
			throw new ProfitMandiBusinessException("Ticket", ticketId, "Happy Code can't match");
24439 govind 583 
		}
24417 govind 584 
		return "response";
585 
	}
24500 govind 586 
 
587 
	@GetMapping(value = "/cs/managerTicket")
588 
	public String getL2L3AndL4Tickets(HttpServletRequest request,
24699 govind 589 
			@RequestParam(name = "orderby", defaultValue = "DESCENDING") SortOrder sortOrder,
590 
			@RequestParam(name = "ticketStatus", defaultValue = "OPENED") TicketStatus ticketStatus,
24747 govind 591 
			@RequestParam(name = "ticketSearchType", defaultValue = "") TicketSearchType ticketSearchType,
592 
			@RequestParam(name = "searchTerm", defaultValue = "0") int searchTerm,
24500 govind 593 
			@RequestParam(name = "offset", defaultValue = "0") int offset,
594 
			@RequestParam(name = "limit", defaultValue = "10") int limit, Model model)
595 
			throws ProfitMandiBusinessException {
24439 govind 596 
		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
597 
		long size = 0;
24500 govind 598 
		AuthUser authUser = authRepository.selectByEmailOrMobile(loginDetails.getEmailId());
599 
		List<Ticket> tickets = null;
24569 govind 600 
		Map<Integer, List<AuthUser>> authUserListMap = null;
24500 govind 601 
		if (loginDetails.getEmailId().equals("amandeep.singh@smartdukaan.com")) {
602 
			tickets = ticketRepository.selectAll(offset, limit, Optional.empty());
24620 govind 603 
			authUserListMap = csService.getAuthUserList(tickets, authUser);
24500 govind 604 
			size = ticketRepository.selectAllCount();
605 
		} else {
24747 govind 606 
			if (ticketSearchType == null) {
24787 govind 607 
				if (ticketStatus.equals(TicketStatus.RESOLVED)) {
608 
					tickets = ticketRepository.selectAllManagerTicket(authUser.getId(), sortOrder, Optional.empty(),
609 
							null, searchTerm, offset, limit);
610 
					size = ticketRepository.selectAllCountByManagerTicket(authUser.getId(), Optional.empty(), null, 0);
611 
				} else {
612 
					tickets = ticketRepository.selectAllManagerTicket(authUser.getId(), sortOrder,
613 
							Optional.of(TicketStatus.CLOSED.equals(ticketStatus)), null, searchTerm, offset, limit);
614 
					size = ticketRepository.selectAllCountByManagerTicket(authUser.getId(),
615 
							Optional.of(TicketStatus.CLOSED.equals(ticketStatus)), null, 0);
616 
				}
24747 govind 617 
			} else {
24787 govind 618 
				if (ticketStatus.equals(TicketStatus.RESOLVED)) {
619 
					tickets = ticketRepository.selectAllManagerTicket(authUser.getId(), sortOrder, Optional.empty(),
620 
							ticketSearchType, searchTerm, offset, limit);
621 
					size = ticketRepository.selectAllCountByManagerTicket(authUser.getId(), Optional.empty(),
622 
							ticketSearchType, searchTerm);
623 
				} else {
624 
					tickets = ticketRepository.selectAllManagerTicket(authUser.getId(), sortOrder,
625 
							Optional.of(TicketStatus.CLOSED.equals(ticketStatus)), ticketSearchType, searchTerm, offset,
626 
							limit);
627 
					size = ticketRepository.selectAllCountByManagerTicket(authUser.getId(),
628 
							Optional.of(TicketStatus.CLOSED.equals(ticketStatus)), ticketSearchType, searchTerm);
629 
				}
630 
 
24747 govind 631 
			}
24620 govind 632 
			authUserListMap = csService.getAuthUserList(tickets, authUser);
24747 govind 633 
 
24620 govind 634 
			if (tickets.size() > 0) {
635 
				Map<Integer, CustomRetailer> fofoIdsAndCustomRetailer = csService.getPartnerByFofoIds(tickets);
636 
				model.addAttribute("fofoIdsAndCustomRetailer", fofoIdsAndCustomRetailer);
24439 govind 637 
			}
638 
		}
639 
		if (size < limit) {
640 
			model.addAttribute("end", offset + size);
641 
		} else {
642 
			model.addAttribute("end", offset + limit);
643 
		}
644 
		model.addAttribute("start", offset + 1);
645 
		model.addAttribute("size", size);
646 
		model.addAttribute("tickets", tickets);
24500 govind 647 
 
24439 govind 648 
		Map<Integer, TicketSubCategory> subCategoryIdAndSubCategoryMap = csService
649 
				.getSubCategoryIdAndSubCategoryMap(tickets);
24699 govind 650 
		model.addAttribute("ticketStatusValues", TicketStatus.values());
651 
		model.addAttribute("orderByValues", SortOrder.values());
652 
		model.addAttribute("selectedticketStatus", ticketStatus);
653 
		model.addAttribute("selectedorderby", sortOrder);
24439 govind 654 
		model.addAttribute("tickets", tickets);
24747 govind 655 
		model.addAttribute("ticketSearchTypes", TicketSearchType.values());
24750 govind 656 
		model.addAttribute("ticketSearchType", ticketSearchType);
24747 govind 657 
		model.addAttribute("searchTerm", searchTerm);
24500 govind 658 
		model.addAttribute("authUserListMap", authUserListMap);
24439 govind 659 
		model.addAttribute("subCategoryIdAndSubCategoryMap", subCategoryIdAndSubCategoryMap);
660 
		return "managerTicket";
661 
	}
24500 govind 662 
 
663 
	@GetMapping(value = "/cs/managerTicket-paginated")
664 
	public String getL2L3AndL4TicketsPaginated(HttpServletRequest request,
24699 govind 665 
			@RequestParam(name = "orderby", defaultValue = "DESCENDING") SortOrder sortOrder,
666 
			@RequestParam(name = "ticketStatus", defaultValue = "OPENED") TicketStatus ticketStatus,
24747 govind 667 
			@RequestParam(name = "ticketSearchType", defaultValue = "") TicketSearchType ticketSearchType,
668 
			@RequestParam(name = "searchTerm", defaultValue = "0") int searchTerm,
24500 govind 669 
			@RequestParam(name = "offset", defaultValue = "0") int offset,
670 
			@RequestParam(name = "limit", defaultValue = "10") int limit, Model model)
671 
			throws ProfitMandiBusinessException {
24467 govind 672 
		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
24500 govind 673 
		AuthUser authUser = authRepository.selectByEmailOrMobile(loginDetails.getEmailId());
24557 govind 674 
		Map<Integer, List<AuthUser>> authUserListMap = null;
24500 govind 675 
		List<Ticket> tickets = null;
676 
		if (loginDetails.getEmailId().equals("amandeep.singh@smartdukaan.com")) {
677 
			tickets = ticketRepository.selectAll(offset, limit, Optional.empty());
24620 govind 678 
			authUserListMap = csService.getAuthUserList(tickets, authUser);
24500 govind 679 
		} else {
24747 govind 680 
			if (ticketSearchType == null) {
24787 govind 681 
				if (ticketStatus.equals(TicketStatus.RESOLVED)) {
682 
					tickets = ticketRepository.selectAllManagerTicket(authUser.getId(), sortOrder, Optional.empty(),
683 
							null, searchTerm, offset, limit);
684 
 
685 
				} else {
686 
					tickets = ticketRepository.selectAllManagerTicket(authUser.getId(), sortOrder,
687 
							Optional.of(TicketStatus.CLOSED.equals(ticketStatus)), null, searchTerm, offset, limit);
688 
 
689 
				}
24747 govind 690 
			} else {
24787 govind 691 
				if (ticketStatus.equals(TicketStatus.RESOLVED)) {
692 
					tickets = ticketRepository.selectAllManagerTicket(authUser.getId(), sortOrder, Optional.empty(),
693 
							ticketSearchType, searchTerm, offset, limit);
694 
 
695 
				} else {
696 
					tickets = ticketRepository.selectAllManagerTicket(authUser.getId(), sortOrder,
697 
							Optional.of(TicketStatus.CLOSED.equals(ticketStatus)), ticketSearchType, searchTerm, offset,
698 
							limit);
699 
				}
700 
 
24747 govind 701 
			}
24620 govind 702 
			authUserListMap = csService.getAuthUserList(tickets, authUser);
703 
			if (tickets.size() > 0) {
24500 govind 704 
				Map<Integer, CustomRetailer> fofoIdsAndCustomRetailer = csService.getPartnerByFofoIds(tickets);
24467 govind 705 
				model.addAttribute("fofoIdsAndCustomRetailer", fofoIdsAndCustomRetailer);
24620 govind 706 
			}
24467 govind 707 
		}
708 
		model.addAttribute("tickets", tickets);
709 
		Map<Integer, TicketSubCategory> subCategoryIdAndSubCategoryMap = csService
710 
				.getSubCategoryIdAndSubCategoryMap(tickets);
711 
		model.addAttribute("tickets", tickets);
24500 govind 712 
		model.addAttribute("authUserListMap", authUserListMap);
24467 govind 713 
		model.addAttribute("subCategoryIdAndSubCategoryMap", subCategoryIdAndSubCategoryMap);
714 
		return "managerTicket-paginated";
715 
	}
24500 govind 716 
 
717 
	@GetMapping(value = "/cs/edit-ticket")
718 
	public String getEditTicket(HttpServletRequest request,
719 
			@RequestParam(name = "ticketId", defaultValue = "0") int ticketId, Model model) {
720 
		Ticket ticket = ticketRepository.selectById(ticketId);
721 
		List<TicketCategory> ticketCategories = csService.getAllTicketCategotyFromSubCategory();
722 
		TicketSubCategory ticketSubCategory = ticketSubCategoryRepository.selectById(ticket.getSubCategoryId());
723 
		List<TicketSubCategory> ticketSubCategories = ticketSubCategoryRepository
724 
				.selectAll(ticketSubCategory.getcategoryId());
24569 govind 725 
		List<AuthUser> authUsers = authRepository.selectAll();
24467 govind 726 
		model.addAttribute("ticket", ticket);
727 
		model.addAttribute("ticketCategories", ticketCategories);
728 
		model.addAttribute("ticketSubCategories", ticketSubCategories);
24575 govind 729 
		model.addAttribute("ticketSubCategory", ticketSubCategory);
24500 govind 730 
		model.addAttribute("authUsers", authUsers);
24467 govind 731 
		return "edit-ticket-modal";
732 
	}
24500 govind 733 
 
734 
	@PostMapping(value = "/cs/edit-ticket")
735 
	public String editTicket(HttpServletRequest request,
736 
			@RequestParam(name = "ticketId", defaultValue = "0") int ticketId,
737 
			@RequestParam(name = "subCategoryId", defaultValue = "0") int subCategoryId,
738 
			@RequestParam(name = "categoryId", defaultValue = "0") int categoryId,
739 
			@RequestParam(name = "authUserId", defaultValue = "0") int authUserId, Model model) throws Exception {
24467 govind 740 
		LOGGER.info(ticketId);
24500 govind 741 
		Ticket ticket = ticketRepository.selectById(ticketId);
24569 govind 742 
		ticketAssignedRepository.deleteByTicketId(ticketId);
743 
		if (ticket.getSubCategoryId() == subCategoryId) {
744 
			LOGGER.info(ticket);
745 
			TicketAssigned ticketAssigned = new TicketAssigned();
24500 govind 746 
			ticketAssigned.setTicketId(ticketId);
747 
			ticketAssigned.setAssineeId(authUserId);
748 
			ticketAssignedRepository.persist(ticketAssigned);
24569 govind 749 
			ticket.setL1AuthUser(authUserId);
750 
			ticket.setSubCategoryId(subCategoryId);
751 
			ticket.setUpdateTimestamp(LocalDateTime.now());
752 
			ticket.setL2EscalationTimestamp(ticket.getUpdateTimestamp().plusDays(2));
753 
			ticket.setL3EscalationTimestamp(ticket.getL2EscalationTimestamp().plusDays(2));
754 
			ticket.setLastEscalationTimestamp(ticket.getL3EscalationTimestamp().plusDays(2));
755 
			ticketRepository.persist(ticket);
756 
			csService.sendAssignedTicketMail(authRepository.selectById(authUserId), ticket);
24500 govind 757 
			model.addAttribute("response", mvcResponseSender.createResponseString(true));
24569 govind 758 
		} else {
759 
			csService.updateTicket(categoryId, subCategoryId, ticket);
760 
			model.addAttribute("response", mvcResponseSender.createResponseString(true));
24500 govind 761 
		}
24467 govind 762 
		return "response";
763 
	}
24500 govind 764 
 
765 
	@DeleteMapping(value = "/cs/removePosition")
766 
	public String removePosition(HttpServletRequest request,
767 
			@RequestParam(name = "positionId", defaultValue = "0") int positionId, Model model) throws Exception {
24471 govind 768 
		positionRepository.delete(positionId);
769 
		model.addAttribute("response", mvcResponseSender.createResponseString(true));
770 
		return "response";
771 
	}
24620 govind 772 
 
773 
	@PostMapping(value = "/cs/create-last-activity")
774 
	public String createlastActivity(HttpServletRequest request, @RequestParam(name = "ticketId") int ticketId,
775 
			@RequestParam(name = "lastactivity") ActivityType lastActivity, Model model) throws Exception {
776 
		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
777 
		Ticket ticket = ticketRepository.selectById(ticketId);
778 
		Activity activity = new Activity();
779 
		String subject = String.format(ACTIVITY_SUBJECT, ticket.getId());
780 
		if (roleManager.isAdmin(loginDetails.getRoleIds())) {
781 
			ticket.setLastActivity(lastActivity);
782 
			String to = retailerService.getFofoRetailer(ticket.getFofoId()).getEmail();
24699 govind 783 
			String message = String.format(PARTNER_RESOLVED_TICKET_MAIL, ticketId, "REOPEN");
24620 govind 784 
			activity.setMessage(message);
785 
			activity.setCreatedBy(authRepository.selectByEmailOrMobile(loginDetails.getEmailId()).getId());
786 
			activity.setTicketId(ticketId);
787 
			activity.setCreateTimestamp(LocalDateTime.now());
788 
			activity.setType(ActivityType.COMMUNICATION_OUT);
24621 govind 789 
			this.activityRelatedMail(to, null, subject, message);
24620 govind 790 
		} else {
791 
			if (ActivityType.RESOLVED_ACCEPTED == lastActivity) {
792 
				ticket.setLastActivity(lastActivity);
793 
				ticket.setCloseTimestamp(LocalDateTime.now());
794 
				activity.setMessage(ActivityType.RESOLVED.toString());
795 
				activity.setCreatedBy(0);
796 
				activity.setTicketId(ticketId);
797 
				activity.setType(ActivityType.COMMUNICATION_IN);
798 
				activity.setCreateTimestamp(LocalDateTime.now());
799 
			} else {
24699 govind 800 
				String message = String.format(INTERNAL_REOPEN_MAIL, ticketId,
801 
						retailerService.getFofoRetailer(loginDetails.getFofoId()).getBusinessName());
24620 govind 802 
				String to = authRepository.selectById(ticket.getL1AuthUser()).getEmailId();
803 
				String cc[] = { authRepository.selectById(ticket.getL2AuthUser()).getEmailId(),
804 
						authRepository.selectById(ticket.getL3AuthUser()).getEmailId() };
805 
				ticket.setLastActivity(lastActivity);
24638 govind 806 
				ticket.setUpdateTimestamp(LocalDateTime.now());
807 
				ticket.setL2EscalationTimestamp(ticket.getUpdateTimestamp().plusDays(2));
808 
				ticket.setL3EscalationTimestamp(ticket.getL2EscalationTimestamp().plusDays(2));
809 
				ticket.setLastEscalationTimestamp(ticket.getL3EscalationTimestamp().plusDays(2));
810 
				ticketAssignedRepository.deleteByTicketId(ticketId);
24699 govind 811 
				TicketAssigned ticketAssigned = new TicketAssigned();
24638 govind 812 
				ticketAssigned.setAssineeId(ticket.getL1AuthUser());
813 
				ticketAssigned.setTicketId(ticketId);
814 
				ticketAssignedRepository.persist(ticketAssigned);
24620 govind 815 
				activity.setMessage(INTERNAL_REOPEN_ACTIVITY_MESSAGE);
816 
				activity.setCreatedBy(0);
817 
				activity.setTicketId(ticketId);
818 
				activity.setType(ActivityType.COMMUNICATION_IN);
819 
				activity.setCreateTimestamp(LocalDateTime.now());
24621 govind 820 
				this.activityRelatedMail(to, cc, subject, message);
24699 govind 821 
				this.activityRelatedMail(retailerService.getFofoRetailer(loginDetails.getFofoId()).getEmail(), null,
822 
						subject, String.format(PARTNER_REOPEN, ticketId));
24620 govind 823 
			}
824 
 
825 
		}
826 
		ticketRepository.persist(ticket);
827 
		activityRepository.persist(activity);
828 
		model.addAttribute("response", mvcResponseSender.createResponseString(true));
829 
		return "response";
830 
	}
831 
 
24417 govind 832 
}