Subversion Repositories SmartDukaan

package com.spice.profitmandi.web.controller;

import java.time.LocalDateTime;

import java.util.HashSet;

import java.util.List;

import java.util.Map;

import java.util.Optional;

import javax.servlet.http.HttpServletRequest;

import org.apache.logging.log4j.LogManager;

import org.apache.logging.log4j.Logger;

import org.apache.logging.log4j.message.Message;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.stereotype.Controller;

import org.springframework.transaction.annotation.Transactional;

import org.springframework.ui.Model;

import org.springframework.web.bind.annotation.GetMapping;

import org.springframework.web.bind.annotation.PostMapping;

import org.springframework.web.bind.annotation.RequestBody;

import org.springframework.web.bind.annotation.RequestParam;

import com.spice.profitmandi.common.exception.ProfitMandiBusinessException;

import com.spice.profitmandi.common.model.CustomRetailer;

import com.spice.profitmandi.dao.entity.auth.AuthUser;

import com.spice.profitmandi.dao.entity.cs.Activity;

import com.spice.profitmandi.dao.entity.cs.Position;

import com.spice.profitmandi.dao.entity.cs.Region;

import com.spice.profitmandi.dao.entity.cs.Ticket;

import com.spice.profitmandi.dao.entity.cs.TicketCategory;

import com.spice.profitmandi.dao.entity.cs.TicketSubCategory;

import com.spice.profitmandi.dao.entity.fofo.ActivityType;

import com.spice.profitmandi.dao.enumuration.cs.EscalationType;

import com.spice.profitmandi.dao.repository.auth.AuthRepository;

import com.spice.profitmandi.dao.repository.cs.ActivityRepository;

import com.spice.profitmandi.dao.repository.cs.CsService;

import com.spice.profitmandi.dao.repository.cs.PartnerRegionRepository;

import com.spice.profitmandi.dao.repository.cs.PositionRepository;

import com.spice.profitmandi.dao.repository.cs.RegionRepository;

import com.spice.profitmandi.dao.repository.cs.TicketCategoryRepository;

import com.spice.profitmandi.dao.repository.cs.TicketRepository;

import com.spice.profitmandi.dao.repository.cs.TicketSubCategoryRepository;

import com.spice.profitmandi.dao.repository.dtr.UserRepository;

import com.spice.profitmandi.service.authentication.RoleManager;

import com.spice.profitmandi.service.slab.TargetSlabService;

import com.spice.profitmandi.service.user.RetailerService;

import com.spice.profitmandi.web.model.LoginDetails;

import com.spice.profitmandi.web.util.CookiesProcessor;

import com.spice.profitmandi.web.util.MVCResponseSender;

@Controller

@Transactional(rollbackFor = Throwable.class)

public class CsController {

	private static final Logger LOGGER = LogManager.getLogger(CsController.class);

	@Autowired

	private CsService csService;

	@Autowired

	private CookiesProcessor cookiesProcessor;

	@Autowired

	private TicketCategoryRepository ticketCategoryRepository;

	@Autowired

	private TicketSubCategoryRepository ticketSubCategoryRepository;

	@Autowired

	private RegionRepository regionRepository;

	@Autowired

	private PartnerRegionRepository partnerRegionRepository;

	@Autowired

	private TargetSlabService targetSlabService;

	@Autowired

	private RetailerService retailerService;

	@Autowired

	private MVCResponseSender mvcResponseSender;

	@Autowired

	private AuthRepository authRepository;

	@Autowired

	private PositionRepository positionRepository;

	@Autowired

	private TicketRepository ticketRepository;

	@Autowired

	private RoleManager roleManager;

	@Autowired

	private ActivityRepository activityRepository;

	@GetMapping(value = "/cs/createCategory")

	public String getCreateCategory(HttpServletRequest request, Model model) {

		List<TicketCategory> ticketCategories = ticketCategoryRepository.selectAll();

		model.addAttribute("ticketCategories", ticketCategories);

		return "create-ticket-category";

	}

	@PostMapping(value = "/cs/createCategory")

	public String createCategory(HttpServletRequest request, @RequestParam(name = "name") String name,

			@RequestParam(name = "description") String description, Model model) throws ProfitMandiBusinessException {

		TicketCategory ticketCategory = ticketCategoryRepository.selectByName(name);

		if (ticketCategory != null) {

			throw new ProfitMandiBusinessException("name", name, "already exists!");

		}

		ticketCategory = new TicketCategory();

		ticketCategory.setName(name);

		ticketCategory.setDescription(description);

		ticketCategoryRepository.persist(ticketCategory);

		return "create-ticket-category";

	}

	@GetMapping(value = "/cs/createSubCategory")

	public String getCreateSubCategory(HttpServletRequest request, Model model) {

		List<TicketCategory> ticketCategories = ticketCategoryRepository.selectAll();

		model.addAttribute("ticketCategories", ticketCategories);

		return "create-ticket-sub-category";

	}

	@GetMapping(value = "/cs/getSubCategoryByCategoryId")

	public String getSubCategoryByCategoryId(HttpServletRequest request,

			@RequestParam(name = "ticketCategoryId", defaultValue = "") int ticketCategoryId, Model model) {

		List<TicketSubCategory> ticketSubCategories = ticketSubCategoryRepository.selectAll(ticketCategoryId);

		TicketCategory ticketCategory = ticketCategoryRepository.selectById(ticketCategoryId);

		model.addAttribute("ticketSubCategories", ticketSubCategories);

		model.addAttribute("ticketCategory", ticketCategory);

		return "ticket-sub-category";

	}

	@PostMapping(value = "/cs/createSubCategory")

	public String createSubCategory(HttpServletRequest request,

			@RequestParam(name = "categoryId", defaultValue = "0") int categoryId,

			@RequestParam(name = "name") String name, @RequestParam(name = "description") String description,

			Model model) throws ProfitMandiBusinessException {

		TicketSubCategory ticketSubCategory = ticketSubCategoryRepository.selectTicketSubCategory(categoryId, name);

		if (ticketSubCategory != null) {

			throw new ProfitMandiBusinessException("name & categoryId", name + "  " + categoryId, "already exists!");

		}

		ticketSubCategory = new TicketSubCategory();

		ticketSubCategory.setcategoryId(categoryId);

		ticketSubCategory.setName(name);

		ticketSubCategory.setDescription(description);

		ticketSubCategoryRepository.persist(ticketSubCategory);

		return "create-ticket-sub-category";

	}

	@GetMapping(value = "/cs/createRegion")

	public String createRegion(HttpServletRequest request, Model model) {

		List<Region> regions = regionRepository.selectAll();

		model.addAttribute("regions", regions);

		return "create-region";

	}

	@PostMapping(value = "/cs/createRegion")

	public String createRegion(HttpServletRequest request, @RequestParam(name = "name") String name,

			@RequestParam(name = "description") String description, Model model) throws Exception {

		Region region = regionRepository.selectByName(name);

		if (region != null) {

			throw new ProfitMandiBusinessException("name", name, "already exists!");

		}

		region = new Region();

		region.setName(name);

		region.setDescription(description);

		regionRepository.persist(region);

		model.addAttribute("response", mvcResponseSender.createResponseString(true));

		return "response";

	}

	@GetMapping(value = "/cs/createPartnerRegion")

	public String createPartnerRegion(HttpServletRequest request, Model model) {

		List<Region> regions = regionRepository.selectAll();

		List<Integer> fofoIds = targetSlabService.getfofoIdsFromfofoStore();

		Map<Integer, CustomRetailer> fofoRetailers = retailerService.getFofoRetailers(fofoIds);

		model.addAttribute("regions", regions);

		model.addAttribute("fofoRetailers", fofoRetailers);

		return "create-partner-region";

	}

	@PostMapping(value = "/cs/createPartnerRegion")

	public String createPartnerRegion(HttpServletRequest request, @RequestParam(name = "regionId") int regionId,

			@RequestBody List<Integer> selectedFofoIds, Model model) throws Exception {

		csService.addPartnerToRegion(regionId, selectedFofoIds);

		model.addAttribute("response", mvcResponseSender.createResponseString(true));

		return "response";

	}

	@GetMapping(value = "/cs/createPosition")

	public String createPosition(HttpServletRequest request, Model model) {

		List<AuthUser> authUsers = authRepository.selectAll();

		List<TicketCategory> ticketCategories = ticketCategoryRepository.selectAll();

		List<Region> regions = regionRepository.selectAll();

		model.addAttribute("escalationTypes", EscalationType.values());

		model.addAttribute("authUsers", authUsers);

		model.addAttribute("ticketCategories", ticketCategories);

		model.addAttribute("regions", regions);

		return "create-position";

	}

	@PostMapping(value = "/cs/createPosition")

	public String createPosition(HttpServletRequest request, @RequestParam(name = "authUserId") int authUserId,

			@RequestParam(name = "categoryId") int categoryId,

			@RequestParam(name = "escalationType") EscalationType escalationType,

			@RequestParam(name = "regionId") int regionId, Model model) throws Exception {

		Position position = positionRepository.selectPosition(authUserId, categoryId, regionId, escalationType);

		if (position == null) {

			position = new Position();

			position.setAuthUserId(authUserId);

			position.setCategoryId(categoryId);

			position.setEscalationType(escalationType);

			position.setRegionId(regionId);

			position.setCreateTimestamp(LocalDateTime.now());

			positionRepository.persist(position);

			model.addAttribute("response", mvcResponseSender.createResponseString(true));

		} else {

			throw new ProfitMandiBusinessException("Position", authUserId, "already exists!");

		}

		return "response";

	}

	@GetMapping(value = "/cs/createTicket")

	public String createTicket(HttpServletRequest request, Model model) {

		List<TicketCategory> ticketCategories = ticketCategoryRepository.selectAll();

		model.addAttribute("ticketCategories", ticketCategories);

		return "create-ticket";

	}

	@GetMapping(value = "/cs/getSubCategoriesByCategoryId")

	public String getSubCategoriesByCategoryId(HttpServletRequest request,

			@RequestParam(name = "categoryId", defaultValue = "0") int categoryId, Model model) {

		List<TicketSubCategory> ticketSubCategories = ticketSubCategoryRepository.selectAll(categoryId);

		LOGGER.info(ticketSubCategories);

		model.addAttribute("ticketSubCategories", ticketSubCategories);

		return "ticket-sub-categories";

	}

	@PostMapping(value = "/cs/createTicket")

	public String createTicket(HttpServletRequest request, @RequestParam(name = "categoryId") int categoryId,

			@RequestParam(name = "subCategoryId") int subCategoryId, @RequestParam(name = "message") String message,

			Model model) throws Exception {

		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

		csService.createTicket(loginDetails.getFofoId(), categoryId, subCategoryId, message);

		model.addAttribute("response", mvcResponseSender.createResponseString(true));

		return "response";

	}

	@GetMapping(value = "/cs/myticket")

	public String getMyTicket(HttpServletRequest request, @RequestParam(name = "offset", defaultValue = "0") int offset,

			@RequestParam(name = "limit", defaultValue = "10") int limit, Model model)

			throws ProfitMandiBusinessException {

		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

		List<Ticket> tickets = null;

		long size = 0;

		//LOGGER.info(roleManager.isAdmin(new HashSet<>(loginDetails.getRoleIds()))));

		if (roleManager.isAdmin(new HashSet<>(loginDetails.getRoleIds()))) {

			AuthUser authUser = authRepository.selectByEmailOrMobile(loginDetails.getEmailId());

			tickets = ticketRepository.selectAllByAssignee(authUser.getId(), Optional.empty(), offset, limit);

			size=ticketRepository.selectAllCountByAssignee(authUser.getId(),Optional.empty());

			Map<Integer, CustomRetailer> fofoIdsAndCustomRetailer=csService.getPartnerByFofoIds(tickets);

			model.addAttribute("fofoIdsAndCustomRetailer", fofoIdsAndCustomRetailer);

		} else {

			tickets = ticketRepository.selectAllByCreator(loginDetails.getFofoId(), Optional.empty(), offset, limit);

			size=ticketRepository.selectAllCountByCreator(loginDetails.getFofoId(), Optional.empty());

		}

		if (size < limit) {

			model.addAttribute("end", offset + size);

		} else {

			model.addAttribute("end", offset + limit);

		}

		model.addAttribute("start", offset + 1);

		model.addAttribute("size", size);

		model.addAttribute("roleType",roleManager.isAdmin(new HashSet<>(loginDetails.getRoleIds())));

		Map<Integer, AuthUser> authUserIdAndAuthUserMap = csService.getAuthUserIdAndAuthUserMap(tickets);

		Map<Integer, TicketSubCategory> subCategoryIdAndSubCategoryMap = csService

				.getSubCategoryIdAndSubCategoryMap(tickets);

		model.addAttribute("tickets", tickets);

		model.addAttribute("authUserIdAndAuthUserMap", authUserIdAndAuthUserMap);

		model.addAttribute("subCategoryIdAndSubCategoryMap", subCategoryIdAndSubCategoryMap);

		return "ticket";

	}

	@GetMapping(value = "/cs/myticketPaginated")

	public String getMyTicketPaginated(HttpServletRequest request, @RequestParam(name = "offset", defaultValue = "0") int offset,

			@RequestParam(name = "limit", defaultValue = "10") int limit, Model model)

			throws ProfitMandiBusinessException {

		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

		List<Ticket> tickets = null;

		//LOGGER.info(roleManager.isAdmin(new HashSet<>(loginDetails.getRoleIds()))));

		if (roleManager.isAdmin(new HashSet<>(loginDetails.getRoleIds()))) {

			AuthUser authUser = authRepository.selectByEmailOrMobile(loginDetails.getEmailId());

			tickets = ticketRepository.selectAllByAssignee(authUser.getId(), Optional.empty(), offset, limit);

			Map<Integer, CustomRetailer> fofoIdsAndCustomRetailer=csService.getPartnerByFofoIds(tickets);

			model.addAttribute("fofoIdsAndCustomRetailer", fofoIdsAndCustomRetailer);

		} else {

			tickets = ticketRepository.selectAllByCreator(loginDetails.getFofoId(), Optional.empty(), offset, limit);

		}

		model.addAttribute("roleType",roleManager.isAdmin(new HashSet<>(loginDetails.getRoleIds())));

		Map<Integer, AuthUser> authUserIdAndAuthUserMap = csService.getAuthUserIdAndAuthUserMap(tickets);

		Map<Integer, TicketSubCategory> subCategoryIdAndSubCategoryMap = csService

				.getSubCategoryIdAndSubCategoryMap(tickets);

		model.addAttribute("tickets", tickets);

		model.addAttribute("authUserIdAndAuthUserMap", authUserIdAndAuthUserMap);

		model.addAttribute("subCategoryIdAndSubCategoryMap", subCategoryIdAndSubCategoryMap);

		return "ticket-paginated";

	}

	@GetMapping(value = "/cs/getActivities")

	public String getActivity(HttpServletRequest request,

			@RequestParam(name = "ticketId", defaultValue = "0") int ticketId, Model model) throws Exception {

		List<Activity> activities = activityRepository.selectAll(ticketId);

		if (activities == null) {

			throw new ProfitMandiBusinessException("Activity", ticketId, "No Activity Found");

		}

		model.addAttribute("response", mvcResponseSender.createResponseString(activities));

		return "response";

	}

	@PostMapping(value = "/cs/createActivity")

	public String createActivity(HttpServletRequest request,

			@RequestParam(name = "ticketId", defaultValue = "0") int ticketId,

			@RequestParam(name = "message", defaultValue = "") String message, Model model) throws Exception {

		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

		Ticket ticket=ticketRepository.selectById(ticketId);

		if(ticket.getCloseTimestamp()==null) {

		if (!roleManager.isAdmin(new HashSet<>(loginDetails.getRoleIds()))) {

			Activity activity = new Activity();

			activity.setMessage(message);

			activity.setCreatedBy(0);

			activity.setCreateTimestamp(LocalDateTime.now());

			activity.setType(ActivityType.COMMUNICATION_IN);

			csService.addActivity(ticketId, activity);

			AuthUser authUser=authRepository.selectById(ticket.getAssigneeId());

			model.addAttribute("response", mvcResponseSender.createResponseString(authUser));

		} else {

			AuthUser authUser=authRepository.selectByEmailOrMobile(loginDetails.getEmailId());

			Activity activity = new Activity();

			activity.setMessage(message);

			activity.setCreatedBy(authUser.getId());

			activity.setCreateTimestamp(LocalDateTime.now());

			activity.setType(ActivityType.COMMUNICATION_OUT);

			csService.addActivity(ticketId, activity);

			model.addAttribute("response", mvcResponseSender.createResponseString(authUser));

		}

	}

		else

		{

			throw new ProfitMandiBusinessException("Ticket", ticket.getId(), "Already closed ticket");

		}

		return "response";

	}

	@PostMapping(value="/cs/closeTicket")

	public String closeTicket(HttpServletRequest request,

			@RequestParam(name = "ticketId", defaultValue = "0") int ticketId,Model model) throws Exception

	{

		Ticket ticket=ticketRepository.selectById(ticketId);

		ticket.setCloseTimestamp(LocalDateTime.now());

		ticketRepository.persist(ticket);

		model.addAttribute("response", mvcResponseSender.createResponseString(true));

		return "response";

	}

}