Subversion Repositories SmartDukaan

Rev

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