Subversion Repositories SmartDukaan

Rev

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