Ejemplo n.º 1
0
        public async Task <List <UserManagementDTO> > GetUserList([FromQuery] UserFilterCriteria filter)
        {
            var message = new GetUserManagementProjectionQuery(filter);
            var result  = await _queryProcessor.Process(message);

            return(result);
        }
Ejemplo n.º 2
0
        public async Task <List <UserDetailProjectionDTO> > GetUserCollection([FromQuery] UserFilterCriteria filterCriteria)
        {
            var query = new GetUserCollectionQuery
            {
                FilterCriteria = filterCriteria,
            };

            var result = _queryProcessor.Process(query);

            return(await result);
        }
Ejemplo n.º 3
0
        public async void given_get_user_collection_query_queryprocessor_should_get_same_query_created_in_controller()
        {
            //Assemble
            var mockAgg = new UserControllerMockAggregate();

            mockAgg.setup_processor_to_verify_getUserCollectionQueries_are_the_same();

            var controller = mockAgg.CreateUserController();

            var filter = new UserFilterCriteria();

            //Apply
            var result = await controller.GetUserCollection(filter);

            //Assert
            Assert.IsType <List <UserDetailProjectionDTO> >(result);
        }
Ejemplo n.º 4
0
        public async void given_GetUserManagementProjectionQuery_queryprocessor_should_get_same_query_created_in_controller()
        {
            //Assemble
            var mockAgg = new UserControllerMockAggregate();

            var input = new UserFilterCriteria();

            mockAgg.setup_processor_to_verify_getUserListQueries_are_the_same();

            var controller = mockAgg.CreateUserController();

            //Apply
            var result = await controller.GetUserList(input);

            //Assert
            //Assert.Equal(query, mockAgg.PermissionQuery);
            Assert.IsType <List <UserManagementDTO> >(result);
        }
Ejemplo n.º 5
0
        public async Task <IEnumerable <ApplicationUser> > GetFilteredUsersAsync(UserFilterCriteria criteria)
        {
            if (criteria == null)
            {
                return(await Context.ApplicationUser.AsNoTracking().ToListAsync());
            }

            var users = Context.ApplicationUser.AsNoTracking();

            if (criteria.IsOnline.HasValue)
            {
                users = users.Where(usr => usr.SignedIn);
            }

            if (!String.IsNullOrEmpty(criteria.Name))
            {
                users = users.Where(usr => usr.Name.Contains(criteria.Name));
            }

            return(await users.ToListAsync());
        }
Ejemplo n.º 6
0
        private IQueryable <UserDetailProjection> Filter(UserFilterCriteria filter)
        {
            IQueryable <UserDetailProjection> queryable = _context.UserDetailProjection;

            if (!filter.IncludeInactive)
            {
                queryable = queryable.Where(a => a.IsActive);
            }

            if (!filter.IncludeIsAdmin)
            {
                queryable = queryable.Where(a => !a.IsAdmin);
            }

            if (!String.IsNullOrWhiteSpace(filter.SearchTerms))
            {
                _searchTerm = filter.SearchTerms.ToLower();
                queryable   = queryable.Where(
                    a => a.Department.ToLower().Contains(_searchTerm) ||
                    a.FirstName.ToLower().Contains(_searchTerm) ||
                    a.LastName.ToLower().Contains(_searchTerm) ||
                    a.Department.ToLower().Contains(_searchTerm) ||
                    a.Position.ToLower().Contains(_searchTerm) ||
                    a.Department.ToLower().Contains(_searchTerm)
                    );
            }

            if (filter.SortDirection.Equals("ASC"))
            {
                switch (filter.SortField)
                {
                case "Email":
                    queryable = queryable.OrderBy(a => a.Email);
                    //.ThenBy(a => a.LastName)
                    //.ThenBy(a => a.FirstName);
                    break;

                case "LastName":
                    queryable = queryable.OrderBy(a => a.LastName);
                    //.ThenBy(a => a.FirstName);
                    break;

                case "FirstName":
                    queryable = queryable.OrderBy(a => a.FirstName);
                    //.ThenBy(a => a.LastName);
                    break;

                case "IsAdmin":
                    queryable = queryable.OrderBy(a => a.IsAdmin);
                    //.ThenBy(a => a.LastName)
                    //.ThenBy(a => a.FirstName);
                    break;

                case "DateCreated":
                    queryable = queryable.OrderBy(a => a.DateCreated);
                    //.ThenBy(a => a.LastName)
                    //.ThenBy(a => a.FirstName);
                    break;

                case "Position":
                    queryable = queryable.OrderBy(a => a.Position);
                    //.ThenBy(a => a.LastName)
                    //.ThenBy(a => a.FirstName);
                    break;

                case "Department":
                    queryable = queryable.OrderBy(a => a.Department);
                    //.ThenBy(a => a.LastName)
                    //.ThenBy(a => a.FirstName);
                    break;

                case "Permission":
                    queryable = queryable.OrderBy(a => a.PermissionList);
                    break;

                default:
                    queryable = queryable.OrderBy(a => a.LastName);
                    //.ThenBy(a => a.FirstName);
                    break;
                }
            }
            else
            {
                switch (filter.SortField)
                {
                case "Email":
                    queryable = queryable.OrderByDescending(a => a.Email);
                    //.ThenByDescending(a => a.LastName)
                    //.ThenByDescending(a => a.FirstName);
                    break;

                case "LastName":
                    queryable = queryable.OrderByDescending(a => a.LastName);
                    //.ThenByDescending(a => a.FirstName);
                    break;

                case "FirstName":
                    queryable = queryable.OrderByDescending(a => a.FirstName);
                    //.ThenByDescending(a => a.LastName);
                    break;

                case "IsAdmin":
                    queryable = queryable.OrderByDescending(a => a.IsAdmin);
                    //.ThenByDescending(a => a.LastName)
                    //.ThenByDescending(a => a.FirstName);
                    break;

                case "DateCreated":
                    queryable = queryable.OrderByDescending(a => a.DateCreated);
                    //.ThenByDescending(a => a.LastName)
                    //.ThenByDescending(a => a.FirstName);
                    break;

                case "Position":
                    queryable = queryable.OrderByDescending(a => a.Position);
                    //.ThenByDescending(a => a.LastName)
                    //.ThenByDescending(a => a.FirstName);
                    break;

                case "Department":
                    queryable = queryable.OrderByDescending(a => a.Department);
                    //.ThenByDescending(a => a.LastName)
                    //.ThenByDescending(a => a.FirstName);
                    break;

                default:
                    queryable = queryable.OrderByDescending(a => a.LastName);
                    //.ThenByDescending(a => a.FirstName);
                    break;
                }
            }

            //Filter For Min/Max Date Range
            if (filter.MinDate != null && filter.MaxDate != null)
            {
                queryable = queryable.Where(a =>
                                            a.DateCreated >= filter.MinDate &&
                                            a.DateCreated <= filter.MaxDate);
            }

            //Filter For MinDate Only
            else if (filter.MinDate != null && filter.MaxDate == null)
            {
                queryable = queryable.Where(a => a.DateCreated >= filter.MinDate);
            }

            //Filter For MaxDate Only
            else if (filter.MinDate == null && filter.MaxDate != null)
            {
                queryable = queryable.Where(a => a.DateCreated <= filter.MaxDate);
            }

            return(queryable);
        }
Ejemplo n.º 7
0
        private IQueryable <UserManagementProjection> Filter(UserFilterCriteria filter)
        {
            IQueryable <UserManagementProjection> queryable = _context.UserManagementProjection;

            if (!filter.IncludeInactive)
            {
                queryable = queryable.Where(a => a.IsActive);
            }

            if (!filter.IncludeIsAdmin)
            {
                queryable = queryable.Where(a => !a.IsAdmin);
            }

            if (filter.SortDirection.Equals("ASC"))
            {
                switch (filter.SortField)
                {
                case "Email":
                    queryable = queryable.OrderBy(a => a.Email);
                    break;

                case "LastName":
                    queryable = queryable.OrderBy(a => a.LastName);
                    break;

                case "FirstName":
                    queryable = queryable.OrderBy(a => a.FirstName);
                    break;

                case "IsAdmin":
                    queryable = queryable.OrderBy(a => a.IsAdmin);
                    break;

                case "Position":
                    queryable = queryable.OrderBy(a => a.Position);
                    break;

                case "Department":
                    queryable = queryable.OrderBy(a => a.Department);
                    break;

                default:
                    queryable = queryable.OrderBy(a => a.LastName);
                    break;
                }
            }
            else
            {
                switch (filter.SortField)
                {
                case "Email":
                    queryable = queryable.OrderByDescending(a => a.Email);
                    break;

                case "LastName":
                    queryable = queryable.OrderByDescending(a => a.LastName);
                    break;

                case "FirstName":
                    queryable = queryable.OrderByDescending(a => a.FirstName);
                    break;

                case "IsAdmin":
                    queryable = queryable.OrderByDescending(a => a.IsAdmin);
                    break;

                case "Position":
                    queryable = queryable.OrderByDescending(a => a.Position);
                    break;

                case "Department":
                    queryable = queryable.OrderByDescending(a => a.Department);
                    break;

                default:
                    queryable = queryable.OrderByDescending(a => a.LastName);
                    break;
                }
            }


            switch (filter.FilterField)
            {
            case "Email":
                queryable = queryable.Where(a => a.Email.ToLower().Equals(filter.FilterFieldInput.ToLower()));
                break;

            case "LastName":
                queryable = queryable.Where(a => a.LastName.ToLower().Equals(filter.FilterFieldInput.ToLower()));
                break;

            case "FirstName":
                queryable = queryable.Where(a => a.FirstName.ToLower().Equals(filter.FilterFieldInput.ToLower()));
                break;

            case "Position":
                queryable = queryable.Where(a => a.Position.ToLower().Equals(filter.FilterFieldInput.ToLower()));
                break;

            case "Department":
                queryable = queryable.Where(a => a.Department.ToLower().Equals(filter.FilterFieldInput.ToLower()));
                break;

            default:
                break;
            }

            return(queryable);
        }
Ejemplo n.º 8
0
 public GetUserManagementProjectionQuery(UserFilterCriteria filterCriteria)
 {
     FilterCriteria = filterCriteria;
 }