Exemplo n.º 1
0
        public async Task <IActionResult> GetTicketsList([FromQuery] Support_TicketsParameters support_TicketsParameters)
        {
            var tickets = await support_TicketsRepository.GetTickets(support_TicketsParameters);

            var metadata = new
            {
                totalCount  = tickets.TotalCount,
                pageSize    = tickets.PageSize,
                currentPage = tickets.CurrentPage,
                totalPages  = tickets.TotalPages,
                hasNext     = tickets.HasNext,
                hasPrevious = tickets.HasPrevious
            };

            Response.Headers.Add("X-Pagination", JsonConvert.SerializeObject(metadata));

            return(Ok(tickets));
        }
Exemplo n.º 2
0
        /* ------------------------------- Get Tickets ------------------------------ */
        public async Task <PagedList <Support_TicketsToList> > GetTickets(Support_TicketsParameters support_TicketsParameters)
        {
            var tickets = _unitOfWork.context.VWSupport_Tickets
                          .OrderBy(t => t.TicketNo)
                          .AsQueryable();

            /* -------------------------------- Filtering ------------------------------- */
            tickets = tickets.ApplyFiltering(support_TicketsParameters);

            /* --------------------------------- Sorting -------------------------------- */
            var columnsMap = new Dictionary <string, Expression <Func <Support_TicketsToList, object> > >()
            {
                ["sNo"]                = p => p.SNo,
                ["assignedTo"]         = p => p.AssignedTo,
                ["clientID"]           = p => p.ClientID,
                ["fullName"]           = p => p.FullName,
                ["accountManager"]     = p => p.AccountManager,
                ["ticketNo"]           = p => p.TicketNo,
                ["type"]               = p => p.Type,
                ["category"]           = p => p.Category,
                ["status"]             = p => p.Status,
                ["highPriority"]       = p => p.HighPriority,
                ["priority"]           = p => p.Priority,
                ["source"]             = p => p.Source,
                ["module"]             = p => p.Module,
                ["subject"]            = p => p.Subject,
                ["problemDescription"] = p => p.ProblemDescription,
                ["reminders"]          = p => p.Reminders,
                ["submittedBy"]        = p => p.SubmittedBy,
                ["submittedOn"]        = p => p.SubmittedOn,
                ["oasisComments"]      = p => p.OasisComments,
                ["closedBy"]           = p => p.ClosedBy,
                ["closedOn"]           = p => p.ClosedOn,
                ["approvedBy"]         = p => p.ApprovedBy,
                ["approvedOn"]         = p => p.ApprovedOn
            };

            tickets = tickets.ApplyOrdering(support_TicketsParameters, columnsMap);

            return(await PagedList <Support_TicketsToList> .ToPagedListAsync(tickets, support_TicketsParameters.PageNumber, support_TicketsParameters.PageSize));
        }
Exemplo n.º 3
0
        public static IQueryable <Support_TicketsToList> ApplyFiltering(this IQueryable <Support_TicketsToList> query, Support_TicketsParameters support_TicketsParameters)
        {
            // Client ID
            if (support_TicketsParameters.ClientId.HasValue)
            {
                if (support_TicketsParameters.ClientId != 0)
                {
                    query = query.Where(s => s.ClientID == support_TicketsParameters.ClientId);
                }
            }

            // Client Name
            if (support_TicketsParameters.FullName != null && support_TicketsParameters.FullName != "null")
            {
                query = query.Where(t => t.FullName.Contains(support_TicketsParameters.FullName));
            }

            // Module
            if (support_TicketsParameters.Module != null)
            {
                query = query.Where(t => support_TicketsParameters.Module.Contains(t.Module));
            }

            // Account Manager
            if (support_TicketsParameters.AccountManager != null)
            {
                query = query.Where(t => support_TicketsParameters.AccountManager.Contains(t.AccountManager));
            }

            // Assigned To
            if (support_TicketsParameters.AssignedTo != null)
            {
                query = query.Where(t => support_TicketsParameters.AssignedTo.Contains(t.AssignedTo));
            }

            // Not Approved
            if (support_TicketsParameters.NotApproved.HasValue)
            {
                if (support_TicketsParameters.NotApproved == true)
                {
                    query = query.Where(t => t.ApprovedBy != null);
                }
            }

            // High Priority
            if (support_TicketsParameters.HighPriority.HasValue)
            {
                if (support_TicketsParameters.HighPriority == true)
                {
                    query = query.Where(t => t.HighPriority == 1);
                }
            }
            // Status
            if (support_TicketsParameters.Status != null)
            {
                query = query.Where(t => support_TicketsParameters.Status.Contains(t.Status));
            }

            // Type
            if (support_TicketsParameters.Type != null)
            {
                query = query.Where(t => support_TicketsParameters.Type.Contains(t.Type));
            }

            return(query);
        }