Subversion Repositories SmartDukaan

Rev

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