Subversion Repositories SmartDukaan

Rev

Rev 24467 | Rev 24471 | Go to most recent revision | Blame | Compare with Previous | Last modification | View Log | RSS feed 

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.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.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.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 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=csService.getAllTicketCategotyFromSubCategory();
                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,
                        @RequestParam (name="happyCode")String happyCode,Model model) throws Exception
        {
                Ticket ticket=ticketRepository.selectById(ticketId);
                if(ticket.getHappyCode().equals(happyCode))
                {
                ticket.setCloseTimestamp(LocalDateTime.now());
                ticketRepository.persist(ticket);
                model.addAttribute("response", mvcResponseSender.createResponseString(true));
                }
                else
                {
                        throw new ProfitMandiBusinessException("Ticket",ticketId, "Happy Code can't match");
                }
                return "response";
        }
        @GetMapping(value="/cs/managerTicket")
        public String getL2L3AndL4Tickets(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);
                long size = 0;
                AuthUser authUser=authRepository.selectByEmailOrMobile(loginDetails.getEmailId());
                List<Ticket> tickets=null;
                if(loginDetails.getEmailId().equals("amandeep.singh@smartdukaan.com"))
                {
                 tickets=ticketRepository.selectAll(offset, limit,Optional.empty());
                 size=ticketRepository.selectAllCount();
                }
                else
                {
                        tickets=ticketRepository.selectAllByEscalatedUserType(authUser.getId(),EscalationType.L2, offset, limit);
                        if(tickets.size()==0)
                        {
                                tickets=ticketRepository.selectAllByEscalatedUserType(authUser.getId(),EscalationType.L3, offset, limit);
                                size=ticketRepository.selectAllCountByEscalatedUserType(authUser.getId(),EscalationType.L3);
                                Map<Integer, CustomRetailer> fofoIdsAndCustomRetailer=csService.getPartnerByFofoIds(tickets);
                                model.addAttribute("fofoIdsAndCustomRetailer", fofoIdsAndCustomRetailer);
                        }
                        else
                        {
                                size=ticketRepository.selectAllCountByEscalatedUserType(authUser.getId(),EscalationType.L2);
                                Map<Integer, CustomRetailer> fofoIdsAndCustomRetailer=csService.getPartnerByFofoIds(tickets);
                                model.addAttribute("fofoIdsAndCustomRetailer", fofoIdsAndCustomRetailer);
                        }
                }
                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("tickets", tickets);
                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 "managerTicket";
        }
        @GetMapping(value="/cs/managerTicket-paginated")
        public String getL2L3AndL4TicketsPaginated(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);
                AuthUser authUser=authRepository.selectByEmailOrMobile(loginDetails.getEmailId());
                List<Ticket> tickets=null;
                if(loginDetails.getEmailId().equals("amandeep.singh@smartdukaan.com"))
                {
                 tickets=ticketRepository.selectAll(offset, limit,Optional.empty());
                }
                else
                {
                        tickets=ticketRepository.selectAllByEscalatedUserType(authUser.getId(),EscalationType.L2, offset, limit);
                        if(tickets.size()==0)
                        {
                                tickets=ticketRepository.selectAllByEscalatedUserType(authUser.getId(),EscalationType.L3, offset, limit);
                                Map<Integer, CustomRetailer> fofoIdsAndCustomRetailer=csService.getPartnerByFofoIds(tickets);
                                model.addAttribute("fofoIdsAndCustomRetailer", fofoIdsAndCustomRetailer);
                        }
                        else
                        {
                                Map<Integer, CustomRetailer> fofoIdsAndCustomRetailer=csService.getPartnerByFofoIds(tickets);
                                model.addAttribute("fofoIdsAndCustomRetailer", fofoIdsAndCustomRetailer);
                        }
                }
                model.addAttribute("tickets", tickets);
                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 "managerTicket-paginated";
        }
        @GetMapping(value="/cs/edit-ticket")
        public String getEditTicket(HttpServletRequest request,@RequestParam(name="ticketId",defaultValue="0")int ticketId,Model model)
        {
                Ticket ticket=ticketRepository.selectById(ticketId);
                List<TicketCategory> ticketCategories=csService.getAllTicketCategotyFromSubCategory();
                TicketSubCategory ticketSubCategory=ticketSubCategoryRepository.selectById(ticket.getSubCategoryId());
                List<TicketSubCategory> ticketSubCategories=ticketSubCategoryRepository.selectAll(ticketSubCategory.getcategoryId());
                List<AuthUser> authUsers=authRepository.selectAll();
                model.addAttribute("ticket", ticket);
                model.addAttribute("ticketCategories", ticketCategories);
                model.addAttribute("ticketSubCategories", ticketSubCategories);
                model.addAttribute("authUsers",authUsers);
                return "edit-ticket-modal";
        }
        @PostMapping(value="/cs/edit-ticket")
        public String editTicket(HttpServletRequest request,@RequestParam(name="ticketId",defaultValue="0")int ticketId,@RequestParam(name="subCategoryId",defaultValue="0")int subCategoryId,@RequestParam(name="authUserId",defaultValue="0")int authUserId,Model model) throws Exception
        {
                LOGGER.info(ticketId);
                Ticket ticket=ticketRepository.selectById(ticketId);
                LOGGER.info(ticket);
                ticket.setAssigneeId(authUserId);
                ticket.setL1AuthUser(authUserId);
                ticket.setSubCategoryId(subCategoryId);
                ticket.setUpdateTimestamp(LocalDateTime.now());
                ticket.setL2EscalationTimestamp(ticket.getUpdateTimestamp().plusDays(2));
                ticket.setL3EscalationTimestamp(ticket.getL2EscalationTimestamp().plusDays(2));
                ticket.setLastEscalationTimestamp(ticket.getL3EscalationTimestamp().plusDays(2));
                ticketRepository.persist(ticket);
                model.addAttribute("response", mvcResponseSender.createResponseString(true));
                return "response";
        }
}