Subversion Repositories SmartDukaan

Rev

Rev 24471 | Rev 24543 | 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;
4 
import java.util.HashSet;
5 
import java.util.List;
6 
import java.util.Map;
7 
import java.util.Optional;
24500 govind 8 
import java.util.stream.Collectors;
24417 govind 9 
 
10 
import javax.servlet.http.HttpServletRequest;
11 
 
12 
import org.apache.logging.log4j.LogManager;
13 
import org.apache.logging.log4j.Logger;
14 
import org.springframework.beans.factory.annotation.Autowired;
15 
import org.springframework.stereotype.Controller;
16 
import org.springframework.transaction.annotation.Transactional;
17 
import org.springframework.ui.Model;
24471 govind 18 
import org.springframework.web.bind.annotation.DeleteMapping;
24417 govind 19 
import org.springframework.web.bind.annotation.GetMapping;
20 
import org.springframework.web.bind.annotation.PostMapping;
21 
import org.springframework.web.bind.annotation.RequestBody;
22 
import org.springframework.web.bind.annotation.RequestParam;
23 
 
24 
import com.spice.profitmandi.common.exception.ProfitMandiBusinessException;
25 
import com.spice.profitmandi.common.model.CustomRetailer;
26 
import com.spice.profitmandi.dao.entity.auth.AuthUser;
27 
import com.spice.profitmandi.dao.entity.cs.Activity;
28 
import com.spice.profitmandi.dao.entity.cs.Position;
29 
import com.spice.profitmandi.dao.entity.cs.Region;
30 
import com.spice.profitmandi.dao.entity.cs.Ticket;
24500 govind 31 
import com.spice.profitmandi.dao.entity.cs.TicketAssigned;
24417 govind 32 
import com.spice.profitmandi.dao.entity.cs.TicketCategory;
33 
import com.spice.profitmandi.dao.entity.cs.TicketSubCategory;
34 
import com.spice.profitmandi.dao.entity.fofo.ActivityType;
35 
import com.spice.profitmandi.dao.enumuration.cs.EscalationType;
36 
import com.spice.profitmandi.dao.repository.auth.AuthRepository;
37 
import com.spice.profitmandi.dao.repository.cs.ActivityRepository;
38 
import com.spice.profitmandi.dao.repository.cs.CsService;
39 
import com.spice.profitmandi.dao.repository.cs.PositionRepository;
40 
import com.spice.profitmandi.dao.repository.cs.RegionRepository;
24500 govind 41 
import com.spice.profitmandi.dao.repository.cs.TicketAssignedRepository;
24417 govind 42 
import com.spice.profitmandi.dao.repository.cs.TicketCategoryRepository;
43 
import com.spice.profitmandi.dao.repository.cs.TicketRepository;
44 
import com.spice.profitmandi.dao.repository.cs.TicketSubCategoryRepository;
45 
import com.spice.profitmandi.service.authentication.RoleManager;
46 
import com.spice.profitmandi.service.slab.TargetSlabService;
47 
import com.spice.profitmandi.service.user.RetailerService;
48 
import com.spice.profitmandi.web.model.LoginDetails;
49 
import com.spice.profitmandi.web.util.CookiesProcessor;
50 
import com.spice.profitmandi.web.util.MVCResponseSender;
51 
 
52 
@Controller
53 
@Transactional(rollbackFor = Throwable.class)
54 
public class CsController {
55 
 
56 
	private static final Logger LOGGER = LogManager.getLogger(CsController.class);
57 
 
58 
	@Autowired
59 
	private CsService csService;
60 
 
61 
	@Autowired
62 
	private CookiesProcessor cookiesProcessor;
63 
 
64 
	@Autowired
65 
	private TicketCategoryRepository ticketCategoryRepository;
66 
 
67 
	@Autowired
68 
	private TicketSubCategoryRepository ticketSubCategoryRepository;
69 
 
70 
	@Autowired
71 
	private RegionRepository regionRepository;
72 
 
73 
	@Autowired
74 
	private TargetSlabService targetSlabService;
75 
 
76 
	@Autowired
77 
	private RetailerService retailerService;
78 
 
79 
	@Autowired
80 
	private MVCResponseSender mvcResponseSender;
81 
 
82 
	@Autowired
83 
	private AuthRepository authRepository;
84 
 
85 
	@Autowired
86 
	private PositionRepository positionRepository;
87 
 
88 
	@Autowired
89 
	private TicketRepository ticketRepository;
90 
 
91 
	@Autowired
92 
	private RoleManager roleManager;
93 
 
94 
	@Autowired
95 
	private ActivityRepository activityRepository;
96 
 
24500 govind 97 
	@Autowired
98 
	private TicketAssignedRepository ticketAssignedRepository;
99 
 
24417 govind 100 
	@GetMapping(value = "/cs/createCategory")
101 
	public String getCreateCategory(HttpServletRequest request, Model model) {
102 
		List<TicketCategory> ticketCategories = ticketCategoryRepository.selectAll();
103 
		model.addAttribute("ticketCategories", ticketCategories);
104 
		return "create-ticket-category";
105 
	}
106 
 
107 
	@PostMapping(value = "/cs/createCategory")
108 
	public String createCategory(HttpServletRequest request, @RequestParam(name = "name") String name,
109 
			@RequestParam(name = "description") String description, Model model) throws ProfitMandiBusinessException {
110 
 
111 
		TicketCategory ticketCategory = ticketCategoryRepository.selectByName(name);
112 
		if (ticketCategory != null) {
113 
			throw new ProfitMandiBusinessException("name", name, "already exists!");
114 
		}
115 
		ticketCategory = new TicketCategory();
116 
		ticketCategory.setName(name);
117 
		ticketCategory.setDescription(description);
118 
		ticketCategoryRepository.persist(ticketCategory);
119 
		return "create-ticket-category";
120 
	}
121 
 
122 
	@GetMapping(value = "/cs/createSubCategory")
123 
	public String getCreateSubCategory(HttpServletRequest request, Model model) {
124 
		List<TicketCategory> ticketCategories = ticketCategoryRepository.selectAll();
125 
		model.addAttribute("ticketCategories", ticketCategories);
126 
		return "create-ticket-sub-category";
127 
	}
128 
 
129 
	@GetMapping(value = "/cs/getSubCategoryByCategoryId")
130 
	public String getSubCategoryByCategoryId(HttpServletRequest request,
131 
			@RequestParam(name = "ticketCategoryId", defaultValue = "") int ticketCategoryId, Model model) {
132 
		List<TicketSubCategory> ticketSubCategories = ticketSubCategoryRepository.selectAll(ticketCategoryId);
133 
		TicketCategory ticketCategory = ticketCategoryRepository.selectById(ticketCategoryId);
134 
		model.addAttribute("ticketSubCategories", ticketSubCategories);
135 
		model.addAttribute("ticketCategory", ticketCategory);
136 
		return "ticket-sub-category";
137 
	}
138 
 
139 
	@PostMapping(value = "/cs/createSubCategory")
140 
	public String createSubCategory(HttpServletRequest request,
141 
			@RequestParam(name = "categoryId", defaultValue = "0") int categoryId,
142 
			@RequestParam(name = "name") String name, @RequestParam(name = "description") String description,
143 
			Model model) throws ProfitMandiBusinessException {
144 
 
145 
		TicketSubCategory ticketSubCategory = ticketSubCategoryRepository.selectTicketSubCategory(categoryId, name);
146 
		if (ticketSubCategory != null) {
147 
			throw new ProfitMandiBusinessException("name & categoryId", name + "  " + categoryId, "already exists!");
148 
		}
149 
 
150 
		ticketSubCategory = new TicketSubCategory();
151 
		ticketSubCategory.setcategoryId(categoryId);
152 
		ticketSubCategory.setName(name);
153 
		ticketSubCategory.setDescription(description);
154 
		ticketSubCategoryRepository.persist(ticketSubCategory);
155 
		return "create-ticket-sub-category";
156 
	}
157 
 
158 
	@GetMapping(value = "/cs/createRegion")
159 
	public String createRegion(HttpServletRequest request, Model model) {
160 
		List<Region> regions = regionRepository.selectAll();
161 
		model.addAttribute("regions", regions);
162 
		return "create-region";
163 
	}
164 
 
165 
	@PostMapping(value = "/cs/createRegion")
166 
	public String createRegion(HttpServletRequest request, @RequestParam(name = "name") String name,
167 
			@RequestParam(name = "description") String description, Model model) throws Exception {
168 
		Region region = regionRepository.selectByName(name);
169 
		if (region != null) {
170 
			throw new ProfitMandiBusinessException("name", name, "already exists!");
171 
		}
172 
		region = new Region();
173 
		region.setName(name);
174 
		region.setDescription(description);
175 
		regionRepository.persist(region);
176 
		model.addAttribute("response", mvcResponseSender.createResponseString(true));
177 
		return "response";
178 
	}
179 
 
180 
	@GetMapping(value = "/cs/createPartnerRegion")
181 
	public String createPartnerRegion(HttpServletRequest request, Model model) {
182 
		List<Region> regions = regionRepository.selectAll();
183 
		List<Integer> fofoIds = targetSlabService.getfofoIdsFromfofoStore();
184 
		Map<Integer, CustomRetailer> fofoRetailers = retailerService.getFofoRetailers(fofoIds);
185 
		model.addAttribute("regions", regions);
186 
		model.addAttribute("fofoRetailers", fofoRetailers);
187 
		return "create-partner-region";
188 
	}
189 
 
190 
	@PostMapping(value = "/cs/createPartnerRegion")
191 
	public String createPartnerRegion(HttpServletRequest request, @RequestParam(name = "regionId") int regionId,
192 
			@RequestBody List<Integer> selectedFofoIds, Model model) throws Exception {
193 
 
194 
		csService.addPartnerToRegion(regionId, selectedFofoIds);
195 
		model.addAttribute("response", mvcResponseSender.createResponseString(true));
196 
		return "response";
197 
	}
198 
 
199 
	@GetMapping(value = "/cs/createPosition")
24500 govind 200 
	public String createPosition(HttpServletRequest request,
201 
			@RequestParam(name = "offset", defaultValue = "0") int offset,
24471 govind 202 
			@RequestParam(name = "limit", defaultValue = "10") int limit, Model model) {
24417 govind 203 
		List<AuthUser> authUsers = authRepository.selectAll();
204 
		List<TicketCategory> ticketCategories = ticketCategoryRepository.selectAll();
205 
		List<Region> regions = regionRepository.selectAll();
206 
		model.addAttribute("escalationTypes", EscalationType.values());
207 
		model.addAttribute("authUsers", authUsers);
208 
		model.addAttribute("ticketCategories", ticketCategories);
209 
		model.addAttribute("regions", regions);
24500 govind 210 
 
211 
		List<Position> positions = positionRepository.selectAll(offset, limit);
212 
		LOGGER.info(positions);
213 
		Map<Integer, AuthUser> authUserIdAndAuthUserMap = csService
214 
				.getAuthUserIdAndAuthUserMapUsingPositions(positions);
215 
		Map<Integer, TicketCategory> categoryIdAndCategoryMap = csService
216 
				.getCategoryIdAndCategoryUsingPositions(positions);
217 
		Map<Integer, Region> regionIdAndRegionMap = csService.getRegionIdAndRegionMap(positions);
218 
		long size = positionRepository.selectAllCount();
219 
 
24471 govind 220 
		if (size < limit) {
221 
			model.addAttribute("end", offset + size);
222 
		} else {
223 
			model.addAttribute("end", offset + limit);
224 
		}
225 
		model.addAttribute("start", offset + 1);
226 
		model.addAttribute("size", size);
227 
		model.addAttribute("positions", positions);
228 
		model.addAttribute("authUserIdAndAuthUserMap", authUserIdAndAuthUserMap);
229 
		model.addAttribute("categoryIdAndCategoryMap", categoryIdAndCategoryMap);
230 
		model.addAttribute("regionIdAndRegionMap", regionIdAndRegionMap);
24417 govind 231 
		return "create-position";
232 
	}
24500 govind 233 
 
24471 govind 234 
	@GetMapping(value = "/cs/position-paginated")
24500 govind 235 
	public String positionPaginated(HttpServletRequest request,
236 
			@RequestParam(name = "offset", defaultValue = "0") int offset,
24471 govind 237 
			@RequestParam(name = "limit", defaultValue = "10") int limit, Model model) {
24500 govind 238 
 
239 
		List<Position> positions = positionRepository.selectAll(offset, limit);
240 
		Map<Integer, AuthUser> authUserIdAndAuthUserMap = csService
241 
				.getAuthUserIdAndAuthUserMapUsingPositions(positions);
242 
		Map<Integer, TicketCategory> categoryIdAndCategoryMap = csService
243 
				.getCategoryIdAndCategoryUsingPositions(positions);
244 
		Map<Integer, Region> regionIdAndRegionMap = csService.getRegionIdAndRegionMap(positions);
24471 govind 245 
		model.addAttribute("positions", positions);
246 
		model.addAttribute("authUserIdAndAuthUserMap", authUserIdAndAuthUserMap);
247 
		model.addAttribute("categoryIdAndCategoryMap", categoryIdAndCategoryMap);
248 
		model.addAttribute("regionIdAndRegionMap", regionIdAndRegionMap);
249 
		return "position-paginated";
250 
	}
24417 govind 251 
 
252 
	@PostMapping(value = "/cs/createPosition")
253 
	public String createPosition(HttpServletRequest request, @RequestParam(name = "authUserId") int authUserId,
254 
			@RequestParam(name = "categoryId") int categoryId,
255 
			@RequestParam(name = "escalationType") EscalationType escalationType,
256 
			@RequestParam(name = "regionId") int regionId, Model model) throws Exception {
257 
 
258 
		Position position = positionRepository.selectPosition(authUserId, categoryId, regionId, escalationType);
259 
		if (position == null) {
260 
			position = new Position();
261 
			position.setAuthUserId(authUserId);
262 
			position.setCategoryId(categoryId);
263 
			position.setEscalationType(escalationType);
264 
			position.setRegionId(regionId);
265 
			position.setCreateTimestamp(LocalDateTime.now());
266 
			positionRepository.persist(position);
267 
			model.addAttribute("response", mvcResponseSender.createResponseString(true));
268 
		} else {
269 
			throw new ProfitMandiBusinessException("Position", authUserId, "already exists!");
270 
		}
271 
		return "response";
272 
	}
273 
 
274 
	@GetMapping(value = "/cs/createTicket")
275 
	public String createTicket(HttpServletRequest request, Model model) {
24500 govind 276 
		List<TicketCategory> ticketCategories = csService.getAllTicketCategotyFromSubCategory();
24417 govind 277 
		model.addAttribute("ticketCategories", ticketCategories);
278 
		return "create-ticket";
279 
	}
280 
 
281 
	@GetMapping(value = "/cs/getSubCategoriesByCategoryId")
282 
	public String getSubCategoriesByCategoryId(HttpServletRequest request,
283 
			@RequestParam(name = "categoryId", defaultValue = "0") int categoryId, Model model) {
284 
		List<TicketSubCategory> ticketSubCategories = ticketSubCategoryRepository.selectAll(categoryId);
285 
		LOGGER.info(ticketSubCategories);
286 
		model.addAttribute("ticketSubCategories", ticketSubCategories);
287 
		return "ticket-sub-categories";
288 
	}
289 
 
290 
	@PostMapping(value = "/cs/createTicket")
291 
	public String createTicket(HttpServletRequest request, @RequestParam(name = "categoryId") int categoryId,
292 
			@RequestParam(name = "subCategoryId") int subCategoryId, @RequestParam(name = "message") String message,
293 
			Model model) throws Exception {
294 
		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
295 
		csService.createTicket(loginDetails.getFofoId(), categoryId, subCategoryId, message);
296 
		model.addAttribute("response", mvcResponseSender.createResponseString(true));
297 
		return "response";
298 
	}
299 
 
300 
	@GetMapping(value = "/cs/myticket")
301 
	public String getMyTicket(HttpServletRequest request, @RequestParam(name = "offset", defaultValue = "0") int offset,
302 
			@RequestParam(name = "limit", defaultValue = "10") int limit, Model model)
303 
			throws ProfitMandiBusinessException {
304 
		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
305 
		List<Ticket> tickets = null;
24500 govind 306 
		List<TicketAssigned> ticketAssigneds = null;
307 
		List<Integer> ticketIds = null;
24417 govind 308 
		long size = 0;
24500 govind 309 
		Map<Integer, AuthUser> authUserIdAndAuthUserMap = null;
310 
		// LOGGER.info(roleManager.isAdmin(new HashSet<>(loginDetails.getRoleIds()))));
24417 govind 311 
		if (roleManager.isAdmin(new HashSet<>(loginDetails.getRoleIds()))) {
312 
			AuthUser authUser = authRepository.selectByEmailOrMobile(loginDetails.getEmailId());
24500 govind 313 
			ticketAssigneds = ticketAssignedRepository.selectByAssigneeId(authUser.getId(), offset, limit);
314 
			ticketIds = ticketAssigneds.stream().map(x -> x.getTicketId()).collect(Collectors.toList());
315 
			tickets = ticketRepository.SelectAllByTicketIds(ticketIds);
316 
			size = ticketAssignedRepository.selectCountByAssigneeId(authUser.getId());
317 
			authUserIdAndAuthUserMap = csService.getAuthUserIdAndAuthUserMap(ticketAssigneds);
318 
			Map<Integer, CustomRetailer> fofoIdsAndCustomRetailer = csService.getPartnerByFofoIds(tickets);
24417 govind 319 
			model.addAttribute("fofoIdsAndCustomRetailer", fofoIdsAndCustomRetailer);
320 
		} else {
321 
			tickets = ticketRepository.selectAllByCreator(loginDetails.getFofoId(), Optional.empty(), offset, limit);
24500 govind 322 
			authUserIdAndAuthUserMap = csService.getTicketIdAndAuthUserMapUsingTickets(tickets);
323 
			size = ticketRepository.selectAllCountByCreator(loginDetails.getFofoId(), Optional.empty());
324 
 
24417 govind 325 
		}
326 
		if (size < limit) {
327 
			model.addAttribute("end", offset + size);
328 
		} else {
329 
			model.addAttribute("end", offset + limit);
330 
		}
331 
		model.addAttribute("start", offset + 1);
332 
		model.addAttribute("size", size);
24500 govind 333 
		model.addAttribute("roleType", roleManager.isAdmin(new HashSet<>(loginDetails.getRoleIds())));
24417 govind 334 
		Map<Integer, TicketSubCategory> subCategoryIdAndSubCategoryMap = csService
335 
				.getSubCategoryIdAndSubCategoryMap(tickets);
336 
		model.addAttribute("tickets", tickets);
337 
		model.addAttribute("authUserIdAndAuthUserMap", authUserIdAndAuthUserMap);
338 
		model.addAttribute("subCategoryIdAndSubCategoryMap", subCategoryIdAndSubCategoryMap);
339 
		return "ticket";
340 
	}
24500 govind 341 
 
24417 govind 342 
	@GetMapping(value = "/cs/myticketPaginated")
24500 govind 343 
	public String getMyTicketPaginated(HttpServletRequest request,
344 
			@RequestParam(name = "offset", defaultValue = "0") int offset,
24417 govind 345 
			@RequestParam(name = "limit", defaultValue = "10") int limit, Model model)
346 
			throws ProfitMandiBusinessException {
347 
		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
348 
		List<Ticket> tickets = null;
24500 govind 349 
		List<TicketAssigned> ticketAssigneds = null;
350 
		List<Integer> ticketIds = null;
351 
		Map<Integer, AuthUser> authUserIdAndAuthUserMap = null;
352 
		// LOGGER.info(roleManager.isAdmin(new HashSet<>(loginDetails.getRoleIds()))));
24417 govind 353 
		if (roleManager.isAdmin(new HashSet<>(loginDetails.getRoleIds()))) {
354 
			AuthUser authUser = authRepository.selectByEmailOrMobile(loginDetails.getEmailId());
24500 govind 355 
			ticketAssigneds = ticketAssignedRepository.selectByAssigneeId(authUser.getId(), offset, limit);
356 
			ticketIds = ticketAssigneds.stream().map(x -> x.getTicketId()).collect(Collectors.toList());
357 
			tickets = ticketRepository.SelectAllByTicketIds(ticketIds);
358 
			authUserIdAndAuthUserMap = csService.getAuthUserIdAndAuthUserMap(ticketAssigneds);
359 
			Map<Integer, CustomRetailer> fofoIdsAndCustomRetailer = csService.getPartnerByFofoIds(tickets);
24417 govind 360 
			model.addAttribute("fofoIdsAndCustomRetailer", fofoIdsAndCustomRetailer);
361 
		} else {
362 
			tickets = ticketRepository.selectAllByCreator(loginDetails.getFofoId(), Optional.empty(), offset, limit);
24500 govind 363 
			authUserIdAndAuthUserMap = csService.getTicketIdAndAuthUserMapUsingTickets(tickets);
24417 govind 364 
		}
24500 govind 365 
		model.addAttribute("roleType", roleManager.isAdmin(new HashSet<>(loginDetails.getRoleIds())));
24417 govind 366 
		Map<Integer, TicketSubCategory> subCategoryIdAndSubCategoryMap = csService
367 
				.getSubCategoryIdAndSubCategoryMap(tickets);
368 
		model.addAttribute("tickets", tickets);
369 
		model.addAttribute("authUserIdAndAuthUserMap", authUserIdAndAuthUserMap);
370 
		model.addAttribute("subCategoryIdAndSubCategoryMap", subCategoryIdAndSubCategoryMap);
371 
		return "ticket-paginated";
372 
	}
373 
 
374 
	@GetMapping(value = "/cs/getActivities")
375 
	public String getActivity(HttpServletRequest request,
376 
			@RequestParam(name = "ticketId", defaultValue = "0") int ticketId, Model model) throws Exception {
377 
		List<Activity> activities = activityRepository.selectAll(ticketId);
378 
		if (activities == null) {
379 
			throw new ProfitMandiBusinessException("Activity", ticketId, "No Activity Found");
380 
		}
381 
		model.addAttribute("response", mvcResponseSender.createResponseString(activities));
382 
		return "response";
383 
 
384 
	}
385 
 
386 
	@PostMapping(value = "/cs/createActivity")
387 
	public String createActivity(HttpServletRequest request,
388 
			@RequestParam(name = "ticketId", defaultValue = "0") int ticketId,
24500 govind 389 
			@RequestParam(name = "assigneeId", defaultValue = "0") int assigneeId,
24417 govind 390 
			@RequestParam(name = "message", defaultValue = "") String message, Model model) throws Exception {
391 
		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
24500 govind 392 
		Ticket ticket = ticketRepository.selectById(ticketId);
393 
		if (ticket.getCloseTimestamp() == null) {
394 
			if (!roleManager.isAdmin(new HashSet<>(loginDetails.getRoleIds()))) {
395 
				Activity activity = new Activity();
396 
				activity.setMessage(message);
397 
				activity.setCreatedBy(0);
398 
				activity.setCreateTimestamp(LocalDateTime.now());
399 
				activity.setType(ActivityType.COMMUNICATION_IN);
400 
				csService.addActivity(ticketId, activity);
401 
				AuthUser authUser = authRepository.selectById(assigneeId);
402 
				model.addAttribute("response", mvcResponseSender.createResponseString(authUser));
403 
			} else {
404 
				AuthUser authUser = authRepository.selectByEmailOrMobile(loginDetails.getEmailId());
405 
				Activity activity = new Activity();
406 
				activity.setMessage(message);
407 
				activity.setCreatedBy(authUser.getId());
408 
				activity.setCreateTimestamp(LocalDateTime.now());
409 
				activity.setType(ActivityType.COMMUNICATION_OUT);
410 
				csService.addActivity(ticketId, activity);
411 
				model.addAttribute("response", mvcResponseSender.createResponseString(authUser));
412 
			}
24417 govind 413 
		} else {
414 
			throw new ProfitMandiBusinessException("Ticket", ticket.getId(), "Already closed ticket");
415 
		}
416 
		return "response";
417 
	}
24500 govind 418 
 
419 
	@PostMapping(value = "/cs/closeTicket")
24417 govind 420 
	public String closeTicket(HttpServletRequest request,
24439 govind 421 
			@RequestParam(name = "ticketId", defaultValue = "0") int ticketId,
24500 govind 422 
			@RequestParam(name = "happyCode") String happyCode, Model model) throws Exception {
423 
		Ticket ticket = ticketRepository.selectById(ticketId);
424 
		if (ticket.getHappyCode().equals(happyCode)) {
425 
			ticket.setCloseTimestamp(LocalDateTime.now());
426 
			ticketRepository.persist(ticket);
427 
			model.addAttribute("response", mvcResponseSender.createResponseString(true));
428 
		} else {
429 
			throw new ProfitMandiBusinessException("Ticket", ticketId, "Happy Code can't match");
24439 govind 430 
		}
24417 govind 431 
		return "response";
432 
	}
24500 govind 433 
 
434 
	@GetMapping(value = "/cs/managerTicket")
435 
	public String getL2L3AndL4Tickets(HttpServletRequest request,
436 
			@RequestParam(name = "offset", defaultValue = "0") int offset,
437 
			@RequestParam(name = "limit", defaultValue = "10") int limit, Model model)
438 
			throws ProfitMandiBusinessException {
24439 govind 439 
		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
440 
		long size = 0;
24500 govind 441 
		AuthUser authUser = authRepository.selectByEmailOrMobile(loginDetails.getEmailId());
442 
		List<Ticket> tickets = null;
443 
		Map<Integer, List<AuthUser>> authUserListMap=null;
444 
		if (loginDetails.getEmailId().equals("amandeep.singh@smartdukaan.com")) {
445 
			tickets = ticketRepository.selectAll(offset, limit, Optional.empty());
446 
			authUserListMap=csService.getAuthUserList(tickets, EscalationType.L4);
447 
			size = ticketRepository.selectAllCount();
448 
		} else {
449 
			tickets = ticketRepository.selectAllByEscalatedUserType(authUser.getId(), EscalationType.L2, offset, limit);
450 
			if (tickets.size() == 0) {
451 
				tickets = ticketRepository.selectAllByEscalatedUserType(authUser.getId(), EscalationType.L3, offset,
452 
						limit);
453 
				size = ticketRepository.selectAllCountByEscalatedUserType(authUser.getId(), EscalationType.L3);
454 
				authUserListMap=csService.getAuthUserList(tickets, EscalationType.L3);
455 
				Map<Integer, CustomRetailer> fofoIdsAndCustomRetailer = csService.getPartnerByFofoIds(tickets);
24439 govind 456 
				model.addAttribute("fofoIdsAndCustomRetailer", fofoIdsAndCustomRetailer);
24500 govind 457 
			} else {
458 
				size = ticketRepository.selectAllCountByEscalatedUserType(authUser.getId(), EscalationType.L2);
459 
				authUserListMap=csService.getAuthUserList(tickets, EscalationType.L2);
460 
				Map<Integer, CustomRetailer> fofoIdsAndCustomRetailer = csService.getPartnerByFofoIds(tickets);
24439 govind 461 
				model.addAttribute("fofoIdsAndCustomRetailer", fofoIdsAndCustomRetailer);
462 
			}
463 
		}
464 
		if (size < limit) {
465 
			model.addAttribute("end", offset + size);
466 
		} else {
467 
			model.addAttribute("end", offset + limit);
468 
		}
469 
		model.addAttribute("start", offset + 1);
470 
		model.addAttribute("size", size);
471 
		model.addAttribute("tickets", tickets);
24500 govind 472 
 
24439 govind 473 
		Map<Integer, TicketSubCategory> subCategoryIdAndSubCategoryMap = csService
474 
				.getSubCategoryIdAndSubCategoryMap(tickets);
475 
		model.addAttribute("tickets", tickets);
24500 govind 476 
		model.addAttribute("authUserListMap", authUserListMap);
24439 govind 477 
		model.addAttribute("subCategoryIdAndSubCategoryMap", subCategoryIdAndSubCategoryMap);
478 
		return "managerTicket";
479 
	}
24500 govind 480 
 
481 
	@GetMapping(value = "/cs/managerTicket-paginated")
482 
	public String getL2L3AndL4TicketsPaginated(HttpServletRequest request,
483 
			@RequestParam(name = "offset", defaultValue = "0") int offset,
484 
			@RequestParam(name = "limit", defaultValue = "10") int limit, Model model)
485 
			throws ProfitMandiBusinessException {
24467 govind 486 
		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
24500 govind 487 
		AuthUser authUser = authRepository.selectByEmailOrMobile(loginDetails.getEmailId());
488 
		Map<Integer, List<AuthUser>> authUserListMap=null;
489 
		List<Ticket> tickets = null;
490 
		if (loginDetails.getEmailId().equals("amandeep.singh@smartdukaan.com")) {
491 
			tickets = ticketRepository.selectAll(offset, limit, Optional.empty());
492 
			authUserListMap=csService.getAuthUserList(tickets, EscalationType.L4);
493 
		} else {
494 
			tickets = ticketRepository.selectAllByEscalatedUserType(authUser.getId(), EscalationType.L2, offset, limit);
495 
			if (tickets.size() == 0) {
496 
				tickets = ticketRepository.selectAllByEscalatedUserType(authUser.getId(), EscalationType.L3, offset,
497 
						limit);
498 
				authUserListMap=csService.getAuthUserList(tickets, EscalationType.L3);
499 
				Map<Integer, CustomRetailer> fofoIdsAndCustomRetailer = csService.getPartnerByFofoIds(tickets);
24467 govind 500 
				model.addAttribute("fofoIdsAndCustomRetailer", fofoIdsAndCustomRetailer);
24500 govind 501 
			} else {
502 
				Map<Integer, CustomRetailer> fofoIdsAndCustomRetailer = csService.getPartnerByFofoIds(tickets);
503 
				authUserListMap=csService.getAuthUserList(tickets, EscalationType.L2);
24467 govind 504 
				model.addAttribute("fofoIdsAndCustomRetailer", fofoIdsAndCustomRetailer);
505 
			}
506 
		}
507 
		model.addAttribute("tickets", tickets);
508 
		Map<Integer, TicketSubCategory> subCategoryIdAndSubCategoryMap = csService
509 
				.getSubCategoryIdAndSubCategoryMap(tickets);
510 
		model.addAttribute("tickets", tickets);
24500 govind 511 
		model.addAttribute("authUserListMap", authUserListMap);
24467 govind 512 
		model.addAttribute("subCategoryIdAndSubCategoryMap", subCategoryIdAndSubCategoryMap);
513 
		return "managerTicket-paginated";
514 
	}
24500 govind 515 
 
516 
	@GetMapping(value = "/cs/edit-ticket")
517 
	public String getEditTicket(HttpServletRequest request,
518 
			@RequestParam(name = "ticketId", defaultValue = "0") int ticketId, Model model) {
519 
		Ticket ticket = ticketRepository.selectById(ticketId);
520 
		List<TicketCategory> ticketCategories = csService.getAllTicketCategotyFromSubCategory();
521 
		TicketSubCategory ticketSubCategory = ticketSubCategoryRepository.selectById(ticket.getSubCategoryId());
522 
		List<TicketSubCategory> ticketSubCategories = ticketSubCategoryRepository
523 
				.selectAll(ticketSubCategory.getcategoryId());
524 
		List<Position> positions=positionRepository.selectPositionByCategoryId(ticketSubCategoryRepository.selectById(ticket.getSubCategoryId()).getcategoryId());
525 
		List<Integer> authUserids=positions.stream().map(x->x.getAuthUserId()).collect(Collectors.toList());
526 
		List<AuthUser> authUsers=authRepository.selectAllAuthUserByIds(authUserids);
24467 govind 527 
		model.addAttribute("ticket", ticket);
528 
		model.addAttribute("ticketCategories", ticketCategories);
529 
		model.addAttribute("ticketSubCategories", ticketSubCategories);
24500 govind 530 
		model.addAttribute("authUsers", authUsers);
24467 govind 531 
		return "edit-ticket-modal";
532 
	}
24500 govind 533 
 
534 
	@PostMapping(value = "/cs/edit-ticket")
535 
	public String editTicket(HttpServletRequest request,
536 
			@RequestParam(name = "ticketId", defaultValue = "0") int ticketId,
537 
			@RequestParam(name = "subCategoryId", defaultValue = "0") int subCategoryId,
538 
			@RequestParam(name = "categoryId", defaultValue = "0") int categoryId,
539 
			@RequestParam(name = "authUserId", defaultValue = "0") int authUserId, Model model) throws Exception {
24467 govind 540 
		LOGGER.info(ticketId);
24500 govind 541 
		Ticket ticket = ticketRepository.selectById(ticketId);
542 
 
543 
		if(ticket.getSubCategoryId()==subCategoryId)
544 
		{
24467 govind 545 
		LOGGER.info(ticket);
24500 govind 546 
 
547 
		TicketAssigned ticketAssigned=ticketAssignedRepository.selectByAssigneeIdAndTicketId(authUserId, ticket.getId());
548 
		if(ticketAssigned==null)
549 
		{
550 
			ticketAssignedRepository.deleteByTicketId(ticketId);
551 
			ticketAssigned=new TicketAssigned();
552 
			ticketAssigned.setTicketId(ticketId);
553 
			ticketAssigned.setAssineeId(authUserId);
554 
			ticketAssignedRepository.persist(ticketAssigned);
555 
		}
24467 govind 556 
		ticket.setL1AuthUser(authUserId);
557 
		ticket.setSubCategoryId(subCategoryId);
558 
		ticket.setUpdateTimestamp(LocalDateTime.now());
559 
		ticket.setL2EscalationTimestamp(ticket.getUpdateTimestamp().plusDays(2));
560 
		ticket.setL3EscalationTimestamp(ticket.getL2EscalationTimestamp().plusDays(2));
561 
		ticket.setLastEscalationTimestamp(ticket.getL3EscalationTimestamp().plusDays(2));
562 
		ticketRepository.persist(ticket);
563 
		model.addAttribute("response", mvcResponseSender.createResponseString(true));
24500 govind 564 
		}
565 
		else
566 
		{
567 
			ticketAssignedRepository.deleteByTicketId(ticketId);
568 
			csService.updateTicket(categoryId,subCategoryId,ticket);
569 
			model.addAttribute("response", mvcResponseSender.createResponseString(true));
570 
		}
24467 govind 571 
		return "response";
572 
	}
24500 govind 573 
 
574 
	@DeleteMapping(value = "/cs/removePosition")
575 
	public String removePosition(HttpServletRequest request,
576 
			@RequestParam(name = "positionId", defaultValue = "0") int positionId, Model model) throws Exception {
24471 govind 577 
		positionRepository.delete(positionId);
578 
		model.addAttribute("response", mvcResponseSender.createResponseString(true));
579 
		return "response";
580 
	}
24417 govind 581 
}