Esempio n. 1
0
        async Task LoadRequests()
        {
            var query = new BaseCarQuery();

            if (!string.IsNullOrEmpty(SearchValue))
            {
                query.Name = SearchValue;
            }

            requests = await _mediator.Send(new GenericQueryWithProjectCommand <Car, CarDatatableViewModel>(query));
        }
        public async Task CreationUnitOfWork_WorkingTest()
        {
            Brand brand = new Brand()
            {
                Name    = "Citroen",
                Country = new Country()
                {
                    Name        = "France",
                    CountryCode = "FR"
                }
            };

            IUnitOfWork uo = Resolve <IUnitOfWork>();

            var brandRepository = uo.GetRepository <Brand>();
            var carRepository   = uo.GetRepository <Car>();

            _ = await brandRepository.AddAsync(brand, false);

            Car car = new Car()
            {
                Name  = "C4",
                Brand = brand
            };

            _ = await carRepository.AddAsync(car, false);

            car.Id.Should().Be(0);
            brand.Id.Should().Be(0);

            int saveResult = await uo.CommitAsync();

            saveResult.Should().Be(3);

            car.Id.Should().BePositive();
            brand.Id.Should().BePositive();

            var brandSearch = await brandService.QueryAsync(new BaseBrandQuery());

            brandSearch.Results.Should().HaveCount(1);

            var query = new BaseCarQuery();

            query.AddInclude(x => x.Brand);

            var carSearch = await carService.QueryAsync(query);

            carSearch.Results.Should().HaveCount(1);
            carSearch.Results.First().Name.Should().Be("C4");
            carSearch.Results.First().Brand.Name.Should().Be("Citroen");
        }
        public async Task OrderFunction2Level_Tests()
        {
            Car newCar = new Car()
            {
                Name        = "C3",
                ReleaseYear = 2011,
                Brand       = new Brand()
                {
                    Name    = "Citroen",
                    Country = new Country()
                    {
                        Name        = "France",
                        CountryCode = "FR"
                    }
                }
            };

            _ = await carService.CreateAsync(newCar);

            Car newCar2 = new Car()
            {
                Name        = "B2",
                ReleaseYear = 2011,
                Brand       = new Brand()
                {
                    Name    = "Citroen",
                    Country = new Country()
                    {
                        Name        = "France",
                        CountryCode = "FR"
                    }
                }
            };

            _ = await carService.CreateAsync(newCar2);

            Car newCar3 = new Car()
            {
                Name        = "A2",
                ReleaseYear = 2011,
                Brand       = new Brand()
                {
                    Name    = "Citroen",
                    Country = new Country()
                    {
                        Name        = "France",
                        CountryCode = "FR"
                    }
                }
            };

            _ = await carService.CreateAsync(newCar3);

            var getResult = await carService.QueryAsync(new BaseCarQuery()
            {
                OrderBy = new List <OrderBySpecification <Expression <Func <Car, object> > > >()
                {
                    new OrderBySpecification <Expression <Func <Car, object> > >(x => x.ReleaseYear),
                    new OrderBySpecification <Expression <Func <Car, object> > >(x => x.Name)
                }
            });

            getResult.Results.Select(x => x.ReleaseYear).Should().BeInAscendingOrder();
            getResult.Results.Where(x => x.ReleaseYear == newCar.ReleaseYear).Select(x => x.Name).Should().BeInAscendingOrder();

            var getResultFluent = await carService.QueryAsync(QueryBuilder.Create <BaseCarQuery, Car>().OrderBy(x => x.ReleaseYear).ThenOrderBy(x => x.Name).Build());

            getResultFluent.Results.Select(x => x.ReleaseYear).Should().BeInAscendingOrder();
            getResultFluent.Results.Where(x => x.ReleaseYear == newCar.ReleaseYear).Select(x => x.Name).Should().BeInAscendingOrder();

            BaseCarQuery specification = new BaseCarQuery()
            {
            };

            specification.AddOrder(new OrderBySpecification <Expression <Func <Car, object> > >(x => x.ReleaseYear, false));
            specification.AddOrder(new OrderBySpecification <Expression <Func <Car, object> > >(x => x.Name, true));
            getResult = await carService.QueryAsync(specification);

            getResult.Results.Select(x => x.ReleaseYear).Should().BeInAscendingOrder();
            getResult.Results.Where(x => x.ReleaseYear == newCar.ReleaseYear).Select(x => x.Name).Should().BeInDescendingOrder();

            getResultFluent = await carService.QueryAsync(QueryBuilder.Create <BaseCarQuery, Car>().OrderBy(x => x.ReleaseYear).ThenOrderBy(x => x.Name, true).Build());

            getResultFluent.Results.Select(x => x.ReleaseYear).Should().BeInAscendingOrder();
            getResultFluent.Results.Where(x => x.ReleaseYear == newCar.ReleaseYear).Select(x => x.Name).Should().BeInDescendingOrder();

            getResult = await carService.QueryAsync(new BaseCarQuery()
            {
                OrderBy = new List <OrderBySpecification <Expression <Func <Car, object> > > >()
                {
                    new OrderBySpecification <Expression <Func <Car, object> > >(x => x.ReleaseYear),
                    new OrderBySpecification <Expression <Func <Car, object> > >(x => x.Name, true)
                }
            });

            getResult.Results.Select(x => x.ReleaseYear).Should().BeInAscendingOrder();
            getResult.Results.Where(x => x.ReleaseYear == newCar.ReleaseYear).Select(x => x.Name).Should().BeInDescendingOrder();
        }