Subversion Repositories SmartDukaan

Rev

Rev 31161 | Rev 31465 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
24383 amit.gupta 1 
package com.spice.profitmandi.dao.repository.cs;
24500 govind 2 
 
24383 amit.gupta 3 
import com.spice.profitmandi.common.exception.ProfitMandiBusinessException;
24417 govind 4 
import com.spice.profitmandi.common.model.CustomRetailer;
24439 govind 5 
import com.spice.profitmandi.common.model.ProfitMandiConstants;
6 
import com.spice.profitmandi.common.util.Utils;
24417 govind 7 
import com.spice.profitmandi.dao.entity.auth.AuthUser;
30423 amit.gupta 8 
import com.spice.profitmandi.dao.entity.cs.*;
24383 amit.gupta 9 
import com.spice.profitmandi.dao.entity.fofo.ActivityType;
30003 tejbeer 10 
import com.spice.profitmandi.dao.entity.fofo.FofoStore;
24417 govind 11 
import com.spice.profitmandi.dao.enumuration.cs.EscalationType;
30003 tejbeer 12 
import com.spice.profitmandi.dao.model.FofoReportingModel;
24417 govind 13 
import com.spice.profitmandi.dao.repository.auth.AuthRepository;
25570 tejbeer 14 
import com.spice.profitmandi.dao.repository.dtr.FofoStoreRepository;
24417 govind 15 
import com.spice.profitmandi.service.user.RetailerService;
30423 amit.gupta 16 
import org.apache.commons.collections4.map.HashedMap;
17 
import org.apache.commons.lang.RandomStringUtils;
18 
import org.apache.commons.lang.StringUtils;
19 
import org.apache.logging.log4j.LogManager;
20 
import org.apache.logging.log4j.Logger;
21 
import org.springframework.beans.factory.annotation.Autowired;
22 
import org.springframework.cache.annotation.Cacheable;
23 
import org.springframework.mail.javamail.JavaMailSender;
24 
import org.springframework.stereotype.Component;
24383 amit.gupta 25 
 
30423 amit.gupta 26 
import java.time.LocalDateTime;
27 
import java.util.*;
28 
import java.util.stream.Collectors;
29 
 
24383 amit.gupta 30 
@Component
31 
public class CsServiceImpl implements CsService {
24417 govind 32 
 
27124 amit.gupta 33 
	private static final int ALL_PARTNERS_REGION = 5;
34 
 
24439 govind 35 
	private static final Logger LOGGER = LogManager.getLogger(CsServiceImpl.class);
36 
 
27124 amit.gupta 37 
	private static final String ASSIGNED_TICKET = "Dear %s, New ticket #%s created by %s has been assigned to you. Regards\nSmartdukaan";
38 
	private static final String ESCALATED_TICKET = "Dear %s, Ticket #%s created by %s has been escalated to you. Regards\nSmartdukaan";
39 
	private static final String CATEGORY_CHANGED_TICKET = "Dear team, Category of Ticket #%s created by %s has been changed to %s. Regards\nSmartdukaan";
24439 govind 40 
	private static final String ASSINMENT_SUBJECT = "Assignment Ticket";
41 
 
24383 amit.gupta 42 
	@Autowired
43 
	TicketRepository ticketRepository;
24417 govind 44 
 
24383 amit.gupta 45 
	@Autowired
24439 govind 46 
	JavaMailSender mailSender;
47 
 
48 
	@Autowired
24383 amit.gupta 49 
	TicketCategoryRepository ticketCategoryRepository;
24417 govind 50 
 
24383 amit.gupta 51 
	@Autowired
52 
	TicketSubCategoryRepository ticketSubCategoryRepository;
24417 govind 53 
 
54 
	@Autowired
24388 amit.gupta 55 
	ActivityRepository activityRepository;
24417 govind 56 
 
57 
	@Autowired
24439 govind 58 
	PartnerRegionRepository partnerRegionRepository;
24417 govind 59 
 
60 
	@Autowired
61 
	private PositionRepository positionRepository;
62 
 
63 
	@Autowired
64 
	private AuthRepository authRepository;
65 
 
66 
	@Autowired
67 
	private RetailerService retailerService;
24500 govind 68 
 
24471 govind 69 
	@Autowired
70 
	private RegionRepository regionRepository;
24417 govind 71 
 
24500 govind 72 
	@Autowired
73 
	private TicketAssignedRepository ticketAssignedRepository;
74 
 
25570 tejbeer 75 
	@Autowired
76 
	private PartnersPositionRepository partnersPositionRepository;
77 
 
78 
	@Autowired
79 
	private FofoStoreRepository fofoStoreRepository;
80 
 
24383 amit.gupta 81 
	@Override
24439 govind 82 
	public void createTicket(int fofoId, int categoryId, int subcategoryId, String message)
83 
			throws ProfitMandiBusinessException {
24417 govind 84 
 
24383 amit.gupta 85 
		ActivityType type = ActivityType.OPENED;
86 
		Ticket ticket = new Ticket();
87 
		ticket.setSubCategoryId(subcategoryId);
24417 govind 88 
		ticket.setFofoId(fofoId);
24383 amit.gupta 89 
		ticket.setCreateTimestamp(LocalDateTime.now());
24417 govind 90 
		ticket.setUpdateTimestamp(LocalDateTime.now());
24439 govind 91 
		ticket.setHappyCode(getRandomString());
27124 amit.gupta 92 
		ticketRepository.persist(ticket);
93 
		this.addActivity(ticket, this.createActivity(type, message, 0));
94 
		this.assignTicket(ticket);
95 
 
96 
	}
97 
 
98 
	@Override
99 
	public void assignTicket(Ticket ticket) throws ProfitMandiBusinessException {
100 
		TicketAssigned ticketAssigned = null;
101 
		EscalationType newEscalationType = EscalationType.L1;
27545 tejbeer 102 
		if (ticket.getAssignmentId() > 0) {
27124 amit.gupta 103 
			ticketAssigned = ticketAssignedRepository.selectById(ticket.getAssignmentId());
104 
			newEscalationType = ticketAssigned.getEscalationType().next();
27393 amit.gupta 105 
			if (newEscalationType == null || newEscalationType.equals(EscalationType.Final)) {
27124 amit.gupta 106 
				LOGGER.info("Cant escalate further");
107 
				return;
24439 govind 108 
			}
27393 amit.gupta 109 
		} else {
110 
			ticket.setL1AuthUser(0);
111 
			ticket.setL2AuthUser(0);
112 
			ticket.setL3AuthUser(0);
113 
			ticket.setL4AuthUser(0);
114 
			ticket.setL5AuthUser(0);
27124 amit.gupta 115 
		}
116 
		ticket.setUpdateTimestamp(LocalDateTime.now());
117 
		TicketSubCategory ticketSubCategory = ticketSubCategoryRepository.selectById(ticket.getSubCategoryId());
118 
		TicketCategory ticketCategory = ticketCategoryRepository.selectById(ticketSubCategory.getCategoryId());
119 
		Map<Integer, EscalationType> escalationUserMap = new HashedMap<>();
120 
		Set<Integer> assigneeUserIds = new LinkedHashSet<>();
121 
		EscalationType escalationTypeNext = newEscalationType;
122 
		do {
123 
			int assigneeUserId = this.getAuthUserId(ticketCategory.getId(), escalationTypeNext, ticket.getFofoId());
124 
			if (assigneeUserId == 0) {
125 
				escalationTypeNext = escalationTypeNext.next();
126 
				LOGGER.info("Escalation type next {}", escalationTypeNext);
127 
				continue;
128 
			}
129 
			assigneeUserIds.add(assigneeUserId);
130 
			escalationUserMap.put(assigneeUserId, escalationTypeNext);
131 
			switch (escalationTypeNext) {
132 
			case L1:
133 
				ticket.setL1AuthUser(assigneeUserId);
134 
				break;
135 
			case L2:
136 
				ticket.setL2AuthUser(assigneeUserId);
137 
				break;
138 
			case L3:
139 
				ticket.setL3AuthUser(assigneeUserId);
140 
				break;
141 
			case L4:
142 
				ticket.setL4AuthUser(assigneeUserId);
143 
				break;
144 
			case L5:
145 
				ticket.setL5AuthUser(assigneeUserId);
146 
				break;
147 
 
148 
			default:
149 
				break;
150 
			}
151 
			escalationTypeNext = escalationTypeNext.next();
152 
			// LOGGER.info("Escalation type next {}", escalationTypeNext);
153 
		} while (!escalationTypeNext.equals(EscalationType.Final));
154 
 
155 
		int assigneeAuthId = assigneeUserIds.stream().findFirst().orElse(0);
27545 tejbeer 156 
 
27124 amit.gupta 157 
		int managerAuthId = 0;
158 
		EscalationType assigneeEscalationType = null;
159 
		if (assigneeAuthId == 0) {
160 
			assigneeAuthId = ProfitMandiConstants.FINAL_AUTH_ID;
161 
			assigneeEscalationType = EscalationType.Final;
27393 amit.gupta 162 
			managerAuthId = ProfitMandiConstants.FINAL_AUTH_ID;
24439 govind 163 
		} else {
27124 amit.gupta 164 
			assigneeEscalationType = escalationUserMap.get(assigneeAuthId);
165 
			managerAuthId = assigneeUserIds.stream().skip(1).findFirst().orElse(0);
166 
			if (managerAuthId == 0) {
167 
				managerAuthId = ProfitMandiConstants.FINAL_AUTH_ID;
168 
			}
24439 govind 169 
		}
27124 amit.gupta 170 
 
171 
		TicketAssigned ticketAssignedNew = new TicketAssigned();
172 
		ticketAssignedNew.setTicketId(ticket.getId());
173 
		ticketAssignedNew.setAssineeId(assigneeAuthId);
174 
		ticketAssignedNew.setEscalationType(assigneeEscalationType);
27393 amit.gupta 175 
		ticketAssignedNew.setManagerId(managerAuthId);
27124 amit.gupta 176 
		ticketAssignedNew.setCreateTimestamp(LocalDateTime.now());
177 
		ticketAssignedRepository.persist(ticketAssignedNew);
178 
		LOGGER.info(ticketAssigned);
27545 tejbeer 179 
 
27124 amit.gupta 180 
		AuthUser authUser = authRepository.selectById(ticketAssignedNew.getAssineeId());
181 
		AuthUser authUserManager = null;
27545 tejbeer 182 
 
183 
		// Dont send cc mail if both are same
184 
		if (managerAuthId != assigneeAuthId) {
27124 amit.gupta 185 
			authUserManager = authRepository.selectById(managerAuthId);
186 
		}
187 
		ticket.setAssignmentId(ticketAssignedNew.getId());
27545 tejbeer 188 
		this.sendAssignedTicketMail(authUser, Arrays.asList(authUserManager), ticket, ticketAssigned != null);
27124 amit.gupta 189 
		if (!ticketAssignedNew.getEscalationType().equals(EscalationType.L1)) {
190 
			this.addActivity(ticket, this.createActivity(ActivityType.ESCALATED,
191 
					"Ticket ecalated and assigned to " + authUser.getName(), 0));
192 
		} else {
193 
			this.addActivity(ticket,
194 
					this.createActivity(ActivityType.ASSIGNED, "Ticket assigned to " + authUser.getName(), 0));
195 
		}
24383 amit.gupta 196 
	}
197 
 
27124 amit.gupta 198 
	@Override
199 
	public void updateTicket(int categoryId, int subCategoryId, Ticket ticket) throws ProfitMandiBusinessException {
200 
 
201 
		TicketSubCategory ticketSubCategory = ticketSubCategoryRepository.getTicketSubCategoryMap().get(subCategoryId);
27545 tejbeer 202 
		if (ticketSubCategory == null) {
203 
			throw new ProfitMandiBusinessException("Could not find subCategoryId " + subCategoryId + "- " + categoryId,
204 
					"Problem", "Problem");
27126 amit.gupta 205 
		}
27861 tejbeer 206 
		String storeName = retailerService.getAllFofoRetailers().get(ticket.getFofoId()).getBusinessName();
27545 tejbeer 207 
		List<TicketAssigned> oldTicketAssignedList = ticketAssignedRepository
208 
				.selectByTicketIds(Arrays.asList(ticket.getId()));
209 
		for (TicketAssigned oldTicketAssigned : oldTicketAssignedList) {
27124 amit.gupta 210 
			ticketAssignedRepository.delete(oldTicketAssigned);
211 
		}
212 
 
27153 amit.gupta 213 
		if (ticket.getSubCategoryId() != ticketSubCategory.getId()) {
214 
			ticket.setSubCategoryId(ticketSubCategory.getId());
27545 tejbeer 215 
			List<Integer> oldAssignedAuthUserIds = oldTicketAssignedList.stream().map(x -> x.getAssineeId())
216 
					.collect(Collectors.toList());
217 
			List<String> oldAssignedEmailIds = authRepository.selectAllAuthUserByIds(oldAssignedAuthUserIds).stream()
218 
					.map(x -> x.getEmailId()).collect(Collectors.toList());
27124 amit.gupta 219 
			String mailTo = oldAssignedEmailIds.remove(0);
27545 tejbeer 220 
			String message = String.format(CATEGORY_CHANGED_TICKET, ticket.getId(), storeName,
221 
					ticketSubCategory.getTicketCategory().getName() + " - " + ticketSubCategory.getName());
27124 amit.gupta 222 
			try {
27545 tejbeer 223 
				Utils.sendMailWithAttachments(mailSender, mailTo, oldAssignedEmailIds.toArray(new String[0]),
224 
						"Ticket Category/Subcategory Changed", message, null);
27124 amit.gupta 225 
			} catch (Exception e) {
226 
				LOGGER.info("Could not send mail for ticket {}", ticket.toString());
227 
			}
228 
		}
229 
 
230 
		Activity categoryChangedActivity = this.createActivity(ActivityType.CATEGORY_CHANGED, "Category changed to "
231 
				+ ticketSubCategory.getTicketCategory().getName() + " - " + ticketSubCategory.getName(), 0);
232 
		this.addActivity(ticket, categoryChangedActivity);
27393 amit.gupta 233 
		ticket.setAssignmentId(0);
27124 amit.gupta 234 
		this.assignTicket(ticket);
27545 tejbeer 235 
 
27124 amit.gupta 236 
	}
237 
 
27393 amit.gupta 238 
	@Override
239 
	public Activity createActivity(ActivityType activityType, String message, int createdBy) {
24383 amit.gupta 240 
		Activity activity = new Activity();
241 
		activity.setMessage(message);
242 
		activity.setCreatedBy(createdBy);
243 
		activity.setType(activityType);
24417 govind 244 
		activity.setCreateTimestamp(LocalDateTime.now());
27124 amit.gupta 245 
		activityRepository.persist(activity);
24383 amit.gupta 246 
		return activity;
247 
	}
24417 govind 248 
 
27078 amit.gupta 249 
	@Override
250 
	public int getAuthUserId(int categoryId, EscalationType escalationType, int fofoId) {
27124 amit.gupta 251 
		int authUserId = 0;
252 
		List<Position> positions = positionRepository.selectPositionbyCategoryIdAndEscalationType(categoryId,
253 
				escalationType);
254 
		List<Integer> regionIds = partnerRegionRepository.selectByfofoId(fofoId).stream().map(x -> x.getRegionId())
255 
				.collect(Collectors.toList());
256 
		// Add all Partner regions id
257 
		regionIds.add(ALL_PARTNERS_REGION);
258 
		LOGGER.info("Escalation Type {}, Region Ids {}", escalationType, regionIds);
259 
		List<Integer> partnerPositionsIds = partnersPositionRepository
260 
				.selectByRegionIdAndPartnerId(regionIds, Arrays.asList(0, fofoId)).stream().map(x -> x.getPositionId())
261 
				.collect(Collectors.toList());
262 
		positions = positions.stream().filter(x -> partnerPositionsIds.contains(x.getId()))
263 
				.collect(Collectors.toList());
264 
		LOGGER.info("User List List {}", positions.stream().map(x -> x.getAuthUserId()).collect(Collectors.toList()));
265 
		if (positions.size() > 0) {
266 
			List<AuthUser> authUsers = authRepository.selectAllAuthUserByIds(
267 
					positions.stream().map(x -> x.getAuthUserId()).collect(Collectors.toList()));
268 
			authUsers = authUsers.stream().filter(x -> x.isActive()).collect(Collectors.toList());
269 
			if (authUsers.size() > 0) {
27260 amit.gupta 270 
				authUserId = authUsers.get(0).getId();
27545 tejbeer 271 
				/*
272 
				 * Random rand = new Random(); authUserId =
273 
				 * authUsers.get(rand.nextInt(authUsers.size())).getId();
274 
				 */
24452 govind 275 
			}
24439 govind 276 
		}
27124 amit.gupta 277 
		return authUserId;
24439 govind 278 
 
24383 amit.gupta 279 
	}
280 
 
281 
	@Override
27124 amit.gupta 282 
	public void addActivity(Ticket ticket, Activity activity) {
283 
		activity.setTicketId(ticket.getId());
284 
		ticket.setLastActivity(activity.getType());
285 
		ticket.setLastActivityId(activity.getId());
24383 amit.gupta 286 
	}
287 
 
24439 govind 288 
	private String getRandomString() {
289 
		int length = 4;
290 
		boolean useLetters = false;
291 
		boolean useNumbers = true;
292 
		String generatedString = RandomStringUtils.random(length, useLetters, useNumbers);
293 
		return generatedString;
294 
	}
295 
 
24417 govind 296 
	@Override
297 
	public void addPartnerToRegion(int regionId, List<Integer> fofoIds) {
298 
 
24557 govind 299 
		for (int fofoId : fofoIds) {
300 
			PartnerRegion partnerRegion = new PartnerRegion();
301 
			partnerRegion.setFofoId(fofoId);
302 
			partnerRegion.setRegionId(regionId);
303 
			partnerRegionRepository.persist(partnerRegion);
24417 govind 304 
		}
305 
	}
306 
 
307 
	@Override
24500 govind 308 
	public Map<Integer, AuthUser> getAuthUserIdAndAuthUserMap(List<TicketAssigned> ticketAssigneds) {
24417 govind 309 
		Map<Integer, AuthUser> authUserIdAndAuthUserMap = new HashMap<>();
24500 govind 310 
 
311 
		for (TicketAssigned ticketAssigned : ticketAssigneds) {
312 
			AuthUser authUser = authRepository.selectById(ticketAssigned.getAssineeId());
313 
			authUserIdAndAuthUserMap.put(ticketAssigned.getTicketId(), authUser);
314 
		}
315 
		return authUserIdAndAuthUserMap;
316 
	}
317 
 
318 
	@Override
319 
	public Map<Integer, AuthUser> getTicketIdAndAuthUserMapUsingTickets(List<Ticket> tickets) {
320 
		Map<Integer, AuthUser> authUserIdAndAuthUserMap = new HashMap<>();
321 
 
24417 govind 322 
		for (Ticket ticket : tickets) {
24500 govind 323 
			AuthUser authUser = authRepository.selectById(ticket.getL1AuthUser());
324 
			authUserIdAndAuthUserMap.put(ticket.getId(), authUser);
24417 govind 325 
		}
326 
		return authUserIdAndAuthUserMap;
327 
	}
328 
 
329 
	@Override
330 
	public Map<Integer, TicketSubCategory> getSubCategoryIdAndSubCategoryMap(List<Ticket> tickets) {
331 
		Map<Integer, TicketSubCategory> subCategoryIdAndSubCategoryMap = new HashMap<>();
24699 govind 332 
		if (tickets != null) {
333 
			for (Ticket ticket : tickets) {
334 
				TicketSubCategory ticketSubCategory = ticketSubCategoryRepository.selectById(ticket.getSubCategoryId());
335 
				subCategoryIdAndSubCategoryMap.put(ticket.getSubCategoryId(), ticketSubCategory);
336 
			}
24417 govind 337 
		}
338 
		return subCategoryIdAndSubCategoryMap;
339 
	}
340 
 
341 
	@Override
342 
	public Map<Integer, CustomRetailer> getPartnerByFofoIds(List<Ticket> tickets) {
343 
		List<Integer> fofoIds = new ArrayList<>();
24569 govind 344 
		LOGGER.info(tickets);
24699 govind 345 
		if (tickets == null) {
24569 govind 346 
			return null;
347 
		}
24417 govind 348 
		for (Ticket ticket : tickets) {
349 
			fofoIds.add(ticket.getFofoId());
350 
		}
30426 tejbeer 351 
 
352 
		Map<Integer, CustomRetailer> customRetailerMap = retailerService.getAllFofoRetailers();
353 
 
30764 tejbeer 354 
		Map<Integer, CustomRetailer> fofoIdsAndCustomRetailer = fofoIds.stream().distinct()
355 
				.map(x -> customRetailerMap.get(x)).filter(x -> x != null).collect(Collectors.toList()).stream()
30426 tejbeer 356 
				.collect(Collectors.toMap(x -> x.getPartnerId(), x -> x));
24417 govind 357 
		return fofoIdsAndCustomRetailer;
358 
	}
359 
 
24439 govind 360 
	@Override
361 
	public List<TicketCategory> getAllTicketCategotyFromSubCategory() {
362 
 
363 
		List<TicketSubCategory> ticketSubCategories = ticketSubCategoryRepository.selectAll();
364 
		HashSet<Integer> categoryIds = new HashSet<>();
365 
		for (TicketSubCategory ticketSubcategory : ticketSubCategories) {
27124 amit.gupta 366 
			categoryIds.add(ticketSubcategory.getCategoryId());
24439 govind 367 
		}
368 
		List<TicketCategory> ticketcategories = ticketCategoryRepository.selectAll(new ArrayList<>(categoryIds));
369 
		return ticketcategories;
370 
	}
371 
 
24471 govind 372 
	@Override
373 
	public Map<Integer, AuthUser> getAuthUserIdAndAuthUserMapUsingPositions(List<Position> positions) {
374 
		Map<Integer, AuthUser> authUserIdAndAuthUserMap = new HashMap<>();
375 
		for (Position position : positions) {
376 
			AuthUser authUser = authRepository.selectById(position.getAuthUserId());
377 
			authUserIdAndAuthUserMap.put(position.getAuthUserId(), authUser);
378 
		}
379 
		return authUserIdAndAuthUserMap;
380 
	}
24500 govind 381 
 
24471 govind 382 
	@Override
383 
	public Map<Integer, TicketCategory> getCategoryIdAndCategoryUsingPositions(List<Position> positions) {
384 
		Map<Integer, TicketCategory> categoryIdAndCategoryMap = new HashMap<>();
385 
		for (Position position : positions) {
24500 govind 386 
			TicketCategory ticketCategory = ticketCategoryRepository.selectById(position.getCategoryId());
24471 govind 387 
			categoryIdAndCategoryMap.put(position.getCategoryId(), ticketCategory);
388 
		}
389 
		return categoryIdAndCategoryMap;
390 
	}
24439 govind 391 
 
24471 govind 392 
	@Override
393 
	public Map<Integer, Region> getRegionIdAndRegionMap(List<Position> positions) {
394 
		Map<Integer, Region> regionIdAndRegionMap = new HashMap<>();
395 
		for (Position position : positions) {
24500 govind 396 
			Region region = regionRepository.selectById(position.getRegionId());
24471 govind 397 
			regionIdAndRegionMap.put(position.getRegionId(), region);
398 
		}
399 
		return regionIdAndRegionMap;
400 
	}
24500 govind 401 
 
27545 tejbeer 402 
	private void sendAssignedTicketMail(AuthUser authUserTo, List<AuthUser> authUsersCc, Ticket ticket,
403 
			boolean isEscalated) throws ProfitMandiBusinessException {
27124 amit.gupta 404 
		try {
405 
			String[] ccTo = authUsersCc.stream().filter(x -> x != null).map(x -> x.getEmailId()).toArray(String[]::new);
406 
 
407 
			String messageFormat = null;
27545 tejbeer 408 
			if (isEscalated) {
27124 amit.gupta 409 
				messageFormat = ESCALATED_TICKET;
24500 govind 410 
			} else {
27124 amit.gupta 411 
				messageFormat = ASSIGNED_TICKET;
24500 govind 412 
			}
27124 amit.gupta 413 
			String message = String.format(messageFormat, authUserTo.getName(), ticket.getId(),
414 
					retailerService.getFofoRetailer(ticket.getFofoId()).getBusinessName());
27545 tejbeer 415 
			Utils.sendMailWithAttachments(mailSender, authUserTo.getEmailId(), ccTo, ASSINMENT_SUBJECT, message, null);
24500 govind 416 
		} catch (Exception e) {
27124 amit.gupta 417 
			e.printStackTrace();
418 
			throw new ProfitMandiBusinessException("Ticket Assingment", authUserTo.getEmailId(),
24500 govind 419 
					"Could not send ticket assignment mail");
420 
		}
421 
	}
25570 tejbeer 422 
 
423 
	@Override
424 
	public Map<Integer, List<CustomRetailer>> getPositionCustomRetailerMap(List<Position> positions) {
30423 amit.gupta 425 
		Map<Integer, CustomRetailer> customRetailerMap = retailerService.getAllFofoRetailers();
25570 tejbeer 426 
		Map<Integer, List<CustomRetailer>> positionRetailerMap = new HashMap<>();
427 
		for (Position position : positions) {
428 
			List<Integer> fofoIds = partnersPositionRepository.selectByPositionId(position.getId()).stream()
429 
					.map(x -> x.getFofoId()).collect(Collectors.toList());
430 
 
26992 amit.gupta 431 
			LOGGER.info("fofoIds - {}", fofoIds);
25570 tejbeer 432 
			if (!fofoIds.isEmpty()) {
433 
				if (fofoIds.contains(0)) {
434 
					fofoIds = partnerRegionRepository.selectByRegionId(position.getRegionId()).stream()
435 
							.map(x -> x.getFofoId()).collect(Collectors.toList());
436 
					if (fofoIds.contains(0)) {
30424 amit.gupta 437 
						fofoIds = new ArrayList<>(customRetailerMap.keySet());
25570 tejbeer 438 
					}
439 
 
440 
				}
26991 amit.gupta 441 
				LOGGER.info("fofoIds - {}", fofoIds);
30426 tejbeer 442 
				positionRetailerMap.put(position.getId(), fofoIds.stream().map(x -> customRetailerMap.get(x))
443 
						.filter(x -> x != null).collect(Collectors.toList()));
25570 tejbeer 444 
 
445 
			}
446 
		}
447 
		return positionRetailerMap;
448 
	}
449 
 
450 
	@Override
27410 tejbeer 451 
	public Map<Integer, List<CustomRetailer>> getRegionPartners(List<Position> positions) {
30426 tejbeer 452 
		Map<Integer, CustomRetailer> customRetailerMap = retailerService.getAllFofoRetailers();
25570 tejbeer 453 
		Map<Integer, List<CustomRetailer>> positionIdAndpartnerRegionMap = new HashedMap<>();
454 
		for (Position position : positions) {
455 
			List<Integer> fofoIds = partnerRegionRepository.selectByRegionId(position.getRegionId()).stream()
456 
					.map(x -> x.getFofoId()).collect(Collectors.toList());
457 
 
458 
			if (!fofoIds.isEmpty()) {
459 
				if (fofoIds.contains(0)) {
460 
					fofoIds = fofoStoreRepository.selectAll().stream().map(x -> x.getId()).collect(Collectors.toList());
461 
 
462 
				}
463 
 
30426 tejbeer 464 
				Map<Integer, CustomRetailer> fofoRetailers = fofoIds.stream().map(x -> customRetailerMap.get(x))
465 
						.filter(x -> x != null).collect(Collectors.toList()).stream()
466 
						.collect(Collectors.toMap(x -> x.getPartnerId(), x -> x));
25570 tejbeer 467 
				positionIdAndpartnerRegionMap.put(position.getRegionId(),
468 
						new ArrayList<CustomRetailer>(fofoRetailers.values()));
469 
			}
470 
 
471 
		}
472 
 
473 
		return positionIdAndpartnerRegionMap;
474 
	}
25597 amit.gupta 475 
 
476 
	@Override
25726 amit.gupta 477 
	@Cacheable(value = "authUserEmailMapping", cacheManager = "thirtyMinsTimeOutCacheManager")
25597 amit.gupta 478 
	public Map<String, Set<String>> getAuthUserPartnerEmailMapping() {
479 
		Map<String, Set<String>> storeGuyMap = new HashMap<>();
480 
		Set<Integer> activeFofoIds = fofoStoreRepository.selectActiveStores().stream().map(x -> x.getId())
481 
				.collect(Collectors.toSet());
482 
		List<Position> categoryPositions = positionRepository
483 
				.selectPositionByCategoryId(ProfitMandiConstants.TICKET_CATEGORY_SALES);
28908 tejbeer 484 
		categoryPositions
485 
				.addAll(positionRepository.selectPositionByCategoryId(ProfitMandiConstants.TICKET_CATEGORY_RBM));
25597 amit.gupta 486 
		Map<Integer, Position> positionsMap = categoryPositions.stream()
487 
				.collect(Collectors.toMap(x -> x.getId(), x -> x));
488 
 
25721 tejbeer 489 
		Map<Integer, List<CustomRetailer>> positonPartnerMap = this.getPositionCustomRetailerMap(categoryPositions);
25597 amit.gupta 490 
		for (Map.Entry<Integer, List<CustomRetailer>> positionPartnerEntry : positonPartnerMap.entrySet()) {
491 
			int authUserId = positionsMap.get(positionPartnerEntry.getKey()).getAuthUserId();
492 
			Set<String> partnerEmails = positionPartnerEntry.getValue().stream()
493 
					.filter(x -> activeFofoIds.contains(x.getPartnerId())).map(x -> x.getEmail())
494 
					.collect(Collectors.toSet());
495 
			AuthUser authUser = authRepository.selectById(authUserId);
496 
			if (authUser.isActive()) {
26298 tejbeer 497 
				if (!storeGuyMap.containsKey(authUser.getEmailId())) {
26111 amit.gupta 498 
					storeGuyMap.put(authUser.getEmailId(), partnerEmails);
499 
				} else {
500 
					storeGuyMap.get(authUser.getEmailId()).addAll(partnerEmails);
501 
				}
25597 amit.gupta 502 
			}
503 
		}
504 
		return storeGuyMap;
505 
	}
25721 tejbeer 506 
 
507 
	@Override
25777 amit.gupta 508 
	@Cacheable(value = "authUserEmailPartnerIdMapping", cacheManager = "thirtyMinsTimeOutCacheManager")
25721 tejbeer 509 
	public Map<String, Set<Integer>> getAuthUserPartnerIdMapping() {
510 
		Map<String, Set<Integer>> storeGuyMap = new HashMap<>();
25777 amit.gupta 511 
		Set<Integer> activeFofoIds = fofoStoreRepository.selectActiveStores().stream().map(x -> x.getId())
512 
				.collect(Collectors.toSet());
25721 tejbeer 513 
		List<Position> categoryPositions = positionRepository
514 
				.selectPositionByCategoryId(ProfitMandiConstants.TICKET_CATEGORY_SALES);
28908 tejbeer 515 
		categoryPositions
516 
				.addAll(positionRepository.selectPositionByCategoryId(ProfitMandiConstants.TICKET_CATEGORY_RBM));
31235 amit.gupta 517 
		categoryPositions.addAll(positionRepository.selectPositionByCategoryId(ProfitMandiConstants.TICKET_CATEGORY_BUSINESSINTELLIGENT));
25721 tejbeer 518 
		Map<Integer, Position> positionsMap = categoryPositions.stream()
519 
				.collect(Collectors.toMap(x -> x.getId(), x -> x));
520 
 
521 
		Map<Integer, List<CustomRetailer>> positonPartnerMap = this.getPositionCustomRetailerMap(categoryPositions);
522 
		for (Map.Entry<Integer, List<CustomRetailer>> positionPartnerEntry : positonPartnerMap.entrySet()) {
523 
			int authUserId = positionsMap.get(positionPartnerEntry.getKey()).getAuthUserId();
27044 amit.gupta 524 
			Set<Integer> partnerIds = positionPartnerEntry.getValue().stream()
25777 amit.gupta 525 
					.filter(x -> activeFofoIds.contains(x.getPartnerId())).map(x -> x.getPartnerId())
25721 tejbeer 526 
					.collect(Collectors.toSet());
527 
			AuthUser authUser = authRepository.selectById(authUserId);
528 
			if (authUser.isActive()) {
26298 tejbeer 529 
				if (!storeGuyMap.containsKey(authUser.getEmailId())) {
27044 amit.gupta 530 
					storeGuyMap.put(authUser.getEmailId(), partnerIds);
26111 amit.gupta 531 
				} else {
27044 amit.gupta 532 
					storeGuyMap.get(authUser.getEmailId()).addAll(partnerIds);
26111 amit.gupta 533 
				}
25721 tejbeer 534 
			}
535 
		}
536 
		return storeGuyMap;
537 
	}
538 
 
539 
	@Override
31152 tejbeer 540 
	@Cacheable(value = "authUserPartnerEmailPartnerIdMapping", cacheManager = "thirtyMinsTimeOutCacheManager")
541 
	public Map<String, Set<Integer>> getAuthUserPartnerIdMappingByCategoryIds(List<Integer> categoryIds) {
542 
		Map<String, Set<Integer>> authUserPartnerMap = new HashMap<>();
543 
		Set<Integer> activeFofoIds = fofoStoreRepository.selectActiveStores().stream().map(x -> x.getId())
544 
				.collect(Collectors.toSet());
545 
 
546 
		List<Position> categoryPositions = positionRepository.selectPositionByCategoryIds(categoryIds);
547 
		Map<Integer, Position> positionsMap = categoryPositions.stream()
548 
				.collect(Collectors.toMap(x -> x.getId(), x -> x));
549 
 
550 
		Map<Integer, List<CustomRetailer>> positonPartnerMap = this.getPositionCustomRetailerMap(categoryPositions);
551 
		for (Map.Entry<Integer, List<CustomRetailer>> positionPartnerEntry : positonPartnerMap.entrySet()) {
552 
			int authUserId = positionsMap.get(positionPartnerEntry.getKey()).getAuthUserId();
553 
			Set<Integer> partnerIds = positionPartnerEntry.getValue().stream()
554 
					.filter(x -> activeFofoIds.contains(x.getPartnerId())).map(x -> x.getPartnerId())
555 
					.collect(Collectors.toSet());
556 
			AuthUser authUser = authRepository.selectById(authUserId);
557 
			if (authUser.isActive()) {
558 
				if (!authUserPartnerMap.containsKey(authUser.getEmailId())) {
559 
					authUserPartnerMap.put(authUser.getEmailId(), partnerIds);
560 
				} else {
561 
					authUserPartnerMap.get(authUser.getEmailId()).addAll(partnerIds);
562 
				}
563 
			}
564 
		}
565 
		return authUserPartnerMap;
566 
	}
567 
 
568 
	@Override
25721 tejbeer 569 
	public List<String> getAuthUserByPartnerId(int fofoId) {
570 
 
571 
		List<String> emails = new ArrayList<>();
572 
		List<Integer> regionIds = partnerRegionRepository.selectByfofoId(fofoId).stream().map(x -> x.getRegionId())
573 
				.collect(Collectors.toList());
574 
 
575 
		regionIds.add(5);// All partners Id;
25799 tejbeer 576 
 
29318 tejbeer 577 
		List<Integer> partnerPositionIds = partnersPositionRepository
578 
				.selectByRegionIdAndPartnerId(regionIds, Arrays.asList(fofoId, 0)).stream().map(x -> x.getPositionId())
579 
				.collect(Collectors.toList());
25721 tejbeer 580 
 
25799 tejbeer 581 
		LOGGER.info("partnerPositionIds" + partnerPositionIds);
582 
 
29318 tejbeer 583 
		List<Position> positions = positionRepository.selectAll(partnerPositionIds);
25721 tejbeer 584 
 
29318 tejbeer 585 
		positions = positions.stream().filter(x -> (x.getCategoryId() == ProfitMandiConstants.TICKET_CATEGORY_SALES
586 
				|| x.getCategoryId() == ProfitMandiConstants.TICKET_CATEGORY_RBM)).collect(Collectors.toList());
587 
 
588 
		if (!positions.isEmpty()) {
589 
			for (Position partnerPostionId : positions) {
590 
 
591 
				AuthUser authUser = authRepository.selectById(partnerPostionId.getAuthUserId());
25799 tejbeer 592 
				LOGGER.info("authUser" + authUser);
593 
				emails.add(authUser.getEmailId());
594 
			}
25721 tejbeer 595 
		}
596 
 
597 
		return emails;
598 
	}
26298 tejbeer 599 
 
600 
	@Override
26978 tejbeer 601 
	public Map<EscalationType, String> getAuthUserAndEsclationTypeByPartnerId(int fofoId) {
602 
 
603 
		List<String> emails = new ArrayList<>();
604 
		Map<EscalationType, String> emailEsclationTypeMap = new HashMap<>();
605 
		List<Integer> regionIds = partnerRegionRepository.selectByfofoId(fofoId).stream().map(x -> x.getRegionId())
606 
				.collect(Collectors.toList());
607 
 
608 
		regionIds.add(5);// All partners Id;
609 
		List<Integer> fofoIds = new ArrayList<>();
610 
		fofoIds.add(fofoId);
611 
		fofoIds.add(0);
612 
 
613 
		LOGGER.info("fofoIds" + fofoIds);
614 
		List<Integer> partnerPositionIds = partnersPositionRepository.selectByRegionIdAndPartnerId(regionIds, fofoIds)
615 
				.stream().map(x -> x.getPositionId()).collect(Collectors.toList());
616 
 
617 
		LOGGER.info("partnerPositionIds" + partnerPositionIds);
618 
 
619 
		for (Integer partnerPostionId : partnerPositionIds) {
620 
			Position position = positionRepository.selectByIdAndCategoryId(partnerPostionId,
621 
					ProfitMandiConstants.TICKET_CATEGORY_SALES);
622 
			LOGGER.info("position" + position);
623 
			if (position != null) {
624 
 
625 
				AuthUser authUser = authRepository.selectById(position.getAuthUserId());
626 
				LOGGER.info("authUser" + authUser);
627 
 
628 
				emailEsclationTypeMap.put(position.getEscalationType(), authUser.getEmailId());
629 
			}
630 
		}
631 
 
632 
		LOGGER.info("emailEsclationTypeMap" + emailEsclationTypeMap);
633 
 
634 
		return emailEsclationTypeMap;
635 
	}
636 
 
637 
	@Override
26298 tejbeer 638 
	@Cacheable(value = "authUserIdPartnerIdMapping", cacheManager = "thirtyMinsTimeOutCacheManager")
639 
	public Map<Integer, List<Integer>> getAuthUserIdPartnerIdMapping() {
640 
		Map<Integer, List<Integer>> storeGuyMap = new HashMap<>();
641 
		Set<Integer> activeFofoIds = fofoStoreRepository.selectActiveStores().stream().map(x -> x.getId())
642 
				.collect(Collectors.toSet());
643 
		List<Position> categoryPositions = positionRepository
644 
				.selectPositionByCategoryId(ProfitMandiConstants.TICKET_CATEGORY_SALES);
28908 tejbeer 645 
		categoryPositions
646 
				.addAll(positionRepository.selectPositionByCategoryId(ProfitMandiConstants.TICKET_CATEGORY_RBM));
29229 tejbeer 647 
 
648 
		categoryPositions
649 
				.addAll(positionRepository.selectPositionByCategoryId(ProfitMandiConstants.TICKET_CATEGORY_CRM));
650 
 
31161 tejbeer 651 
		categoryPositions
652 
				.addAll(positionRepository.selectPositionByCategoryId(ProfitMandiConstants.TICKET_CATEGORY_MARKETING));
653 
 
26298 tejbeer 654 
		Map<Integer, Position> positionsMap = categoryPositions.stream()
655 
				.collect(Collectors.toMap(x -> x.getId(), x -> x));
656 
 
657 
		Map<Integer, List<CustomRetailer>> positonPartnerMap = this.getPositionCustomRetailerMap(categoryPositions);
658 
		for (Map.Entry<Integer, List<CustomRetailer>> positionPartnerEntry : positonPartnerMap.entrySet()) {
659 
			int authUserId = positionsMap.get(positionPartnerEntry.getKey()).getAuthUserId();
26991 amit.gupta 660 
			List<Integer> partnerIds = positionPartnerEntry.getValue().stream()
26298 tejbeer 661 
					.filter(x -> activeFofoIds.contains(x.getPartnerId())).map(x -> x.getPartnerId())
662 
					.collect(Collectors.toList());
663 
			AuthUser authUser = authRepository.selectById(authUserId);
27044 amit.gupta 664 
			if (authUser != null && authUser.isActive()) {
26960 amit.gupta 665 
				if (!storeGuyMap.containsKey(authUserId)) {
26991 amit.gupta 666 
					storeGuyMap.put(authUserId, partnerIds);
26298 tejbeer 667 
				} else {
26991 amit.gupta 668 
					storeGuyMap.get(authUserId).addAll(partnerIds);
26298 tejbeer 669 
				}
670 
			}
671 
		}
30985 amit.gupta 672 
		storeGuyMap.keySet().stream().forEach(x -> {
673 
			List<Integer> fofoIds = storeGuyMap.get(x);
674 
			storeGuyMap.put(x, fofoIds.stream().distinct().collect(Collectors.toList()));
675 
		});
26298 tejbeer 676 
		return storeGuyMap;
677 
	}
678 
 
679 
	@Override
680 
	@Cacheable(value = "L1L2Mapping", cacheManager = "thirtyMinsTimeOutCacheManager")
26460 amit.gupta 681 
	public Map<Integer, List<Integer>> getL2L1Mapping() {
26448 amit.gupta 682 
		List<Position> l1SalesPositions = positionRepository.selectPositionbyCategoryIdAndEscalationType(
683 
				ProfitMandiConstants.TICKET_CATEGORY_SALES, EscalationType.L1);
684 
		List<Position> l2SalesPositions = positionRepository.selectPositionbyCategoryIdAndEscalationType(
685 
				ProfitMandiConstants.TICKET_CATEGORY_SALES, EscalationType.L2);
26298 tejbeer 686 
 
26448 amit.gupta 687 
		LOGGER.info("position" + l1SalesPositions);
688 
		Map<Integer, List<Integer>> authUserPartnerListMap = this.getAuthUserIdPartnerIdMapping();
689 
		LOGGER.info("map" + authUserPartnerListMap);
26298 tejbeer 690 
 
26448 amit.gupta 691 
		Map<Integer, List<Integer>> l2l1ListMap = new HashMap<>();
26298 tejbeer 692 
 
26448 amit.gupta 693 
		for (Position l2SalePosition : l2SalesPositions) {
694 
			int l2AuthUserId = l2SalePosition.getAuthUserId();
695 
			if (authUserPartnerListMap.containsKey(l2SalePosition.getAuthUserId())) {
696 
				List<Integer> mappedL1AuthUsers = new ArrayList<>();
697 
				l2l1ListMap.put(l2AuthUserId, mappedL1AuthUsers);
698 
				List<Integer> l2FofoIds = authUserPartnerListMap.get(l2AuthUserId);
699 
				for (Position l1SalePosition : l1SalesPositions) {
700 
					int l1AuthUserId = l1SalePosition.getAuthUserId();
701 
					if (authUserPartnerListMap.containsKey(l1AuthUserId)) {
702 
						List<Integer> l1FofoIds = authUserPartnerListMap.get(l1SalePosition.getAuthUserId());
703 
						if (l2FofoIds.containsAll(l1FofoIds)) {
704 
							mappedL1AuthUsers.add(l1AuthUserId);
705 
						}
706 
					}
26298 tejbeer 707 
 
708 
				}
709 
			}
710 
 
711 
		}
712 
 
26448 amit.gupta 713 
		return l2l1ListMap;
26298 tejbeer 714 
	}
26448 amit.gupta 715 
 
27205 amit.gupta 716 
	@Override
717 
	public Map<Integer, List<AuthUser>> getAssignedAuthList(List<Ticket> tickets) {
27545 tejbeer 718 
		if (tickets.size() == 0) {
27259 amit.gupta 719 
			return new HashMap<>();
720 
		}
27545 tejbeer 721 
		List<TicketAssigned> ticketAssignedList = ticketAssignedRepository
722 
				.selectByTicketIds(tickets.stream().map(x -> x.getId()).collect(Collectors.toList()));
723 
		List<Integer> authUserIds = ticketAssignedList.stream().map(x -> x.getAssineeId()).distinct()
724 
				.collect(Collectors.toList());
725 
		Map<Integer, AuthUser> authUserMap = authRepository.selectAllAuthUserByIds(authUserIds).stream()
726 
				.collect(Collectors.toMap(x -> x.getId(), x -> x));
727 
		return ticketAssignedList.stream().collect(Collectors.groupingBy(x -> x.getTicketId(),
728 
				Collectors.mapping(x -> authUserMap.get(x.getAssineeId()), Collectors.toList())));
27205 amit.gupta 729 
	}
730 
 
27548 tejbeer 731 
	@Override
732 
	public Map<EscalationType, AuthUser> getAuthUserAndEsclationByPartnerId(int fofoId) {
733 
		Map<EscalationType, AuthUser> authuserEsclationTypeMap = new HashMap<>();
734 
		List<Integer> regionIds = partnerRegionRepository.selectByfofoId(fofoId).stream().map(x -> x.getRegionId())
735 
				.collect(Collectors.toList());
736 
 
737 
		regionIds.add(5);// All partners Id;
738 
		List<Integer> fofoIds = new ArrayList<>();
739 
		fofoIds.add(fofoId);
740 
		fofoIds.add(0);
741 
 
742 
		LOGGER.info("fofoIds" + fofoIds);
743 
		List<Integer> partnerPositionIds = partnersPositionRepository.selectByRegionIdAndPartnerId(regionIds, fofoIds)
744 
				.stream().map(x -> x.getPositionId()).collect(Collectors.toList());
745 
 
746 
		LOGGER.info("partnerPositionIds" + partnerPositionIds);
747 
 
748 
		for (Integer partnerPostionId : partnerPositionIds) {
749 
			Position position = positionRepository.selectByIdAndCategoryId(partnerPostionId,
750 
					ProfitMandiConstants.TICKET_CATEGORY_SALES);
751 
			LOGGER.info("position" + position);
752 
			if (position != null) {
753 
 
754 
				AuthUser authUser = authRepository.selectById(position.getAuthUserId());
755 
				LOGGER.info("authUser" + authUser);
756 
 
757 
				authuserEsclationTypeMap.put(position.getEscalationType(), authUser);
758 
			}
759 
		}
760 
 
761 
		LOGGER.info("emailEsclationTypeMap" + authuserEsclationTypeMap);
762 
 
763 
		return authuserEsclationTypeMap;
764 
	}
765 
 
28377 tejbeer 766 
	@Override
767 
	public List<AuthUser> getAuthUserIdByPartnerId(int fofoId) {
768 
		List<AuthUser> authUsers = new ArrayList<>();
769 
		List<Integer> regionIds = partnerRegionRepository.selectByfofoId(fofoId).stream().map(x -> x.getRegionId())
770 
				.collect(Collectors.toList());
771 
 
772 
		regionIds.add(5);// All partners Id;
773 
		List<Integer> fofoIds = new ArrayList<>();
774 
		fofoIds.add(fofoId);
775 
		fofoIds.add(0);
776 
 
777 
		LOGGER.info("fofoIds" + fofoIds);
778 
		List<Integer> partnerPositionIds = partnersPositionRepository.selectByRegionIdAndPartnerId(regionIds, fofoIds)
779 
				.stream().map(x -> x.getPositionId()).collect(Collectors.toList());
780 
 
781 
		LOGGER.info("partnerPositionIds" + partnerPositionIds);
782 
 
783 
		for (Integer partnerPostionId : partnerPositionIds) {
784 
			Position position = positionRepository.selectByIdAndCategoryId(partnerPostionId,
785 
					ProfitMandiConstants.TICKET_CATEGORY_SALES);
786 
			LOGGER.info("position" + position);
787 
			if (position != null) {
788 
 
789 
				AuthUser authUser = authRepository.selectById(position.getAuthUserId());
790 
				LOGGER.info("authUser" + authUser);
791 
				authUsers.add(authUser);
792 
			}
31020 tejbeer 793 
 
794 
			Position rbmPosition = positionRepository.selectByIdAndCategoryId(partnerPostionId,
795 
					ProfitMandiConstants.TICKET_CATEGORY_RBM);
796 
			if (rbmPosition != null) {
797 
 
798 
				AuthUser authUser = authRepository.selectById(rbmPosition.getAuthUserId());
799 
				LOGGER.info("authUser" + authUser);
800 
				authUsers.add(authUser);
801 
			}
802 
 
28377 tejbeer 803 
		}
804 
 
805 
		return authUsers;
806 
	}
807 
 
28856 manish 808 
	@Override
28977 manish 809 
	public List<AuthUser> getAuthUserIds(int categoryId, List<EscalationType> escalationType) {
29229 tejbeer 810 
 
28977 manish 811 
		List<Position> positions = positionRepository.selectPositionbyCategoryIdAndEscalationTypes(categoryId,
28856 manish 812 
				escalationType);
28908 tejbeer 813 
		List<Integer> authIds = positions.stream().map(x -> x.getAuthUserId()).distinct().collect(Collectors.toList());
814 
 
815 
		LOGGER.info("authIds" + authIds);
816 
 
817 
		List<AuthUser> authUsers = authRepository.selectAllAuthUserByIds(authIds);
818 
 
819 
		LOGGER.info("authUsers" + authUsers);
28856 manish 820 
		return authUsers;
821 
	}
29318 tejbeer 822 
 
29296 manish 823 
	@Override
29927 amit.gupta 824 
	public List<AuthUser> getAuthUserByCategoryId(int categoryId, EscalationType escalationType) {
28856 manish 825 
 
29296 manish 826 
		List<Position> positions = positionRepository.selectPositionbyCategoryIdAndEscalationType(categoryId,
827 
				escalationType);
828 
		List<Integer> authIds = positions.stream().map(x -> x.getAuthUserId()).distinct().collect(Collectors.toList());
829 
 
830 
		LOGGER.info("authIds" + authIds);
30764 tejbeer 831 
		List<AuthUser> authUsers = new ArrayList<>();
832 
		if (!authIds.isEmpty()) {
833 
			authUsers = authRepository.selectAllAuthUserByIds(authIds);
834 
		}
29296 manish 835 
 
836 
		LOGGER.info("authUsers" + authUsers);
837 
		return authUsers;
838 
	}
839 
 
28908 tejbeer 840 
	@Override
29927 amit.gupta 841 
	@Cacheable(value = "authUserByCategoryId", cacheManager = "thirtyMinsTimeOutCacheManager")
28908 tejbeer 842 
	public List<AuthUser> getAuthUserByCategoryId(int categoryId) {
843 
		List<Position> positions = positionRepository.selectPositionByCategoryId(categoryId);
844 
		List<Integer> authIds = positions.stream().map(x -> x.getAuthUserId()).distinct().collect(Collectors.toList());
845 
 
846 
		LOGGER.info("authIds" + authIds);
847 
 
30003 tejbeer 848 
		List<AuthUser> authUsers = authRepository.selectAllAuthUserByIds(authIds).stream().filter(x -> x.getActive())
849 
				.collect(Collectors.toList());
28908 tejbeer 850 
 
851 
		LOGGER.info("authUsers" + authUsers);
852 
		return authUsers;
853 
	}
854 
 
30003 tejbeer 855 
	private class SaleRoles {
856 
 
857 
		private List<String> l1;
858 
		private List<String> l2;
30044 tejbeer 859 
		private List<String> l3;
860 
		private List<String> l4;
30003 tejbeer 861 
 
862 
		public SaleRoles() {
863 
			l1 = new ArrayList<>();
864 
			l2 = new ArrayList<>();
30044 tejbeer 865 
			l3 = new ArrayList<>();
866 
			l4 = new ArrayList<>();
30003 tejbeer 867 
		}
868 
 
869 
		public List<String> getL1() {
870 
			return l1;
871 
		}
872 
 
873 
		public List<String> getL2() {
874 
			return l2;
875 
		}
876 
 
30044 tejbeer 877 
		public List<String> getL3() {
878 
			return l3;
879 
		}
880 
 
881 
		public List<String> getL4() {
882 
			return l4;
883 
		}
884 
 
885 
		@Override
886 
		public String toString() {
887 
			return "SaleRoles [l1=" + l1 + ", l2=" + l2 + ", l3=" + l3 + ", l4=" + l4 + "]";
888 
		}
889 
 
30003 tejbeer 890 
	}
891 
 
892 
	@Override
893 
	@Cacheable(value = "partnerSaleHeader", cacheManager = "oneDayCacheManager")
894 
	public Map<Integer, FofoReportingModel> getPartnerIdSalesHeaders() {
895 
		Map<String, SaleRoles> partnerEmailSalesMap = new HashMap<>();
896 
 
897 
		List<Position> positions = positionRepository
898 
				.selectPositionByCategoryId(ProfitMandiConstants.TICKET_CATEGORY_SALES);
899 
		Map<Integer, AuthUser> authUsersMap = authRepository.selectAllActiveUser().stream()
900 
				.collect(Collectors.toMap(x -> x.getId(), x -> x));
901 
		Map<Integer, List<CustomRetailer>> positionIdRetailerMap = this.getPositionCustomRetailerMap(positions);
902 
		for (Position position : positions) {
903 
			List<CustomRetailer> crList = positionIdRetailerMap.get(position.getId());
904 
			if (crList == null)
905 
				continue;
906 
			for (CustomRetailer cr : crList) {
907 
				if (!partnerEmailSalesMap.containsKey(cr.getEmail())) {
908 
					partnerEmailSalesMap.put(cr.getEmail(), new SaleRoles());
909 
				}
910 
				SaleRoles saleRoles = partnerEmailSalesMap.get(cr.getEmail());
911 
				AuthUser authUser = authUsersMap.get(position.getAuthUserId());
912 
				if (authUser == null) {
913 
					continue;
914 
				}
915 
				String name = authUser.getFirstName() + " " + authUser.getLastName();
916 
				if (position.getEscalationType().equals(EscalationType.L1)) {
917 
					saleRoles.getL1().add(name);
918 
				} else if (position.getEscalationType().equals(EscalationType.L2)) {
919 
					saleRoles.getL2().add(name);
920 
				}
30044 tejbeer 921 
 
30003 tejbeer 922 
			}
923 
		}
924 
 
925 
		Set<CustomRetailer> allCrList = new HashSet<>();
926 
		for (List<CustomRetailer> cr : positionIdRetailerMap.values()) {
927 
			allCrList.addAll(cr);
928 
		}
929 
 
930 
		Map<Integer, FofoStore> fofoStoresMap = fofoStoreRepository.selectActiveStores().stream()
931 
				.collect(Collectors.toMap(x -> x.getId(), x -> x));
932 
 
933 
		Map<Integer, FofoReportingModel> partnerIdSalesHeadersMap = new HashMap<>();
934 
 
935 
		for (CustomRetailer cr : allCrList) {
936 
			FofoStore fofoStore = fofoStoresMap.get(cr.getPartnerId());
937 
			if (fofoStore == null) {
938 
				LOGGER.info("Could not find Store {} in active Store", cr.getBusinessName());
939 
				continue;
940 
			}
941 
			String code = fofoStore.getCode();
942 
			// String storeName = "SmartDukaan-" +
943 
			// fofoStore.getCode().replaceAll("[a-zA-Z]", "");
944 
			String businessName = cr.getBusinessName();
945 
			try {
946 
				String stateManager = StringUtils.join(partnerEmailSalesMap.get(cr.getEmail()).getL2(), ", ");
947 
				String territoryManager = StringUtils.join(partnerEmailSalesMap.get(cr.getEmail()).getL1(), ", ");
30044 tejbeer 948 
 
949 
				if (StringUtils.isEmpty(territoryManager)) {
950 
					territoryManager = StringUtils.join(partnerEmailSalesMap.get(cr.getEmail()).getL2(), ", ");
951 
				}
952 
 
30003 tejbeer 953 
				FofoReportingModel reportingModel = new FofoReportingModel();
954 
				reportingModel.setBusinessName(businessName);
955 
				reportingModel.setCode(code);
956 
				reportingModel.setFofoId(fofoStore.getId());
957 
				reportingModel.setRegionalManager(stateManager);
958 
				reportingModel.setTerritoryManager(territoryManager);
959 
				partnerIdSalesHeadersMap.put(fofoStore.getId(), reportingModel);
960 
			} catch (Exception e) {
961 
				LOGGER.warn("Could not find partner with email - {}", cr.getEmail());
962 
			}
963 
		}
964 
		return partnerIdSalesHeadersMap;
965 
 
966 
	}
967 
 
31152 tejbeer 968 
	@Override
969 
	public Set<Integer> getAuthFofoIds(String email) throws ProfitMandiBusinessException {
970 
 
31153 tejbeer 971 
		List<Integer> categoryIds = Arrays.asList(ProfitMandiConstants.TICKET_CATEGORY_LOGISTICS,
972 
				ProfitMandiConstants.TICKET_CATEGORY_FINANCIAL_SERVICES, ProfitMandiConstants.TICKET_CATEGORY_CATEGORY,
973 
				ProfitMandiConstants.TICKET_CATEGORY_RBM, ProfitMandiConstants.TICKET_CATEGORY_SALES,
974 
				ProfitMandiConstants.TICKET_CATEGORY_MARKETING, ProfitMandiConstants.TICKET_CATEGORY_ACCOUNTS,
975 
				ProfitMandiConstants.TICKET_CATEGORY_BUSINESSINTELLIGENT,
976 
				ProfitMandiConstants.TICKET_CATEGORY_TECHNOLOGY);
977 
 
31152 tejbeer 978 
		Map<String, Set<Integer>> storeGuyMap = this.getAuthUserPartnerIdMappingByCategoryIds(categoryIds);
979 
		Set<Integer> authfofoIds = storeGuyMap.get(email);
980 
 
981 
		AuthUser authUser = authRepository.selectByEmailOrMobile(email);
982 
		if (authfofoIds == null) {
983 
			List<Position> positions1 = positionRepository.selectAll(authUser.getId());
984 
			if (positions1.stream().filter(x -> x.getCategoryId() == ProfitMandiConstants.TICKET_CATEGORY_MASTER)
985 
					.count() > 0) {
986 
				authfofoIds = this.getPositionCustomRetailerMap(positions1).values().stream().flatMap(x -> x.stream())
987 
						.map(x -> x.getPartnerId()).collect(Collectors.toSet());
988 
			}
989 
		}
990 
 
991 
		return authfofoIds;
992 
	}
993 
 
24383 amit.gupta 994 
}