PruebaP

.travis.yml

@@ -1,6 +1,14 @@
+dist: xenial
+addons:
+  snaps:
+  - name: dotnet-sdk
+    classic: true
+    channel: latest/beta
+sudo: required
 language: csharp
 mono: none
-dotnet: 2.1.300
 script:
+  - sudo snap alias dotnet-sdk.dotnet dotnet
+  - dotnet --version
   - dotnet build
   - dotnet test URF.Core.EF.Tests --no-build --no-restore

URF.Core.Abstractions.Services/URF.Core.Abstractions.Services.csproj

@@ -1,19 +1,24 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFramework>netstandard2.0</TargetFramework>
+    <TargetFramework>net8.0</TargetFramework>
     <LangVersion>latest</LangVersion>
-    <Version>1.1.0</Version>
+    <Version>8.0.0</Version>
     <Authors>Long Le, Tony Sneed</Authors>
-    <PackageLicenseUrl>https://github.com/urfnet/URF.Core/blob/master/LICENSE</PackageLicenseUrl>
+    <PackageLicenseExpression>MIT</PackageLicenseExpression>
     <PackageProjectUrl>https://github.com/urfnet/URF.Core</PackageProjectUrl>
-    <PackageIconUrl>https://user-images.githubusercontent.com/2836367/36162252-7ec8dd8a-10ab-11e8-936c-11bbb77ef574.png</PackageIconUrl>
+    <PackageIcon>icon.png</PackageIcon>
     <Title>URF - Unit of Work and Repositories Framework for .NET Standard and .NET Core (Official): Abstractions.Services</Title>
     <Description>This official URF framework minimizes the surface area of your ORM technlogy from disseminating in your application. Framework provides an elegant way to implement a reusable and extensible Unit of Work and Repository pattern.</Description>
     <PackageTags>repository unitofwork patterns</PackageTags>
+	<PackageReleaseNotes>https://github.com/urfnet/URF.Core/releases/tag/v8.0.0</PackageReleaseNotes>
     <GeneratePackageOnBuild>true</GeneratePackageOnBuild>
   </PropertyGroup>
 
+  <ItemGroup>
+    <None Include="icon.png" Pack="true" Visible="false" PackagePath="" />
+  </ItemGroup>
+
   <ItemGroup>
     <ProjectReference Include="..\URF.Core.Abstractions.Trackable\URF.Core.Abstractions.Trackable.csproj" />
     <ProjectReference Include="..\URF.Core.Abstractions\URF.Core.Abstractions.csproj" />

URF.Core.Abstractions.Trackable/URF.Core.Abstractions.Trackable.csproj

@@ -1,21 +1,26 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFramework>netstandard2.0</TargetFramework>
+    <TargetFramework>net8.0</TargetFramework>
     <LangVersion>latest</LangVersion>
-    <Version>1.1.0</Version>
+    <Version>8.0.0</Version>
     <Authors>Long Le, Tony Sneed</Authors>
-    <PackageLicenseUrl>https://github.com/urfnet/URF.Core/blob/master/LICENSE</PackageLicenseUrl>
+    <PackageLicenseExpression>MIT</PackageLicenseExpression>
     <PackageProjectUrl>https://github.com/urfnet/URF.Core</PackageProjectUrl>
-    <PackageIconUrl>https://user-images.githubusercontent.com/2836367/36162252-7ec8dd8a-10ab-11e8-936c-11bbb77ef574.png</PackageIconUrl>
+    <PackageIcon>icon.png</PackageIcon>
     <Title>URF - Unit of Work and Repositories Framework for .NET Standard and .NET Core (Official): Abstractions.Trackable</Title>
     <Description>This official URF framework minimizes the surface area of your ORM technlogy from disseminating in your application. Framework provides an elegant way to implement a reusable and extensible Unit of Work and Repository pattern.</Description>
     <PackageTags>repository unitofwork patterns</PackageTags>
+	<PackageReleaseNotes>https://github.com/urfnet/URF.Core/releases/tag/v8.0.0</PackageReleaseNotes>
     <GeneratePackageOnBuild>true</GeneratePackageOnBuild>
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="TrackableEntities.Common.Core" Version="1.1.0" />
+    <None Include="icon.png" Pack="true" Visible="false" PackagePath="" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <PackageReference Include="TrackableEntities.Common.Core" Version="8.0.0" />
   </ItemGroup>
 
   <ItemGroup>

URF.Core.Abstractions/IDocumentRepository.cs

@@ -0,0 +1,30 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Linq.Expressions;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace URF.Core.Abstractions
+{
+    public interface IDocumentRepository<TEntity> where TEntity : class
+    {
+        Task<List<TEntity>> FindManyAsync(CancellationToken cancellationToken = default);
+
+        Task<List<TEntity>> FindManyAsync(Expression<Func<TEntity, bool>> filter, CancellationToken cancellationToken = default);
+
+        Task<TEntity> FindOneAsync(Expression<Func<TEntity, bool>> filter, CancellationToken cancellationToken = default);
+
+        Task<TEntity> FindOneAndReplaceAsync(Expression<Func<TEntity, bool>> filter, TEntity item, CancellationToken cancellationToken = default);
+
+        Task<TEntity> InsertOneAsync(TEntity item, CancellationToken cancellationToken = default);
+
+        Task<List<TEntity>> InsertManyAsync(IEnumerable<TEntity> items, CancellationToken cancellationToken = default);
+
+        Task<int> DeleteOneAsync(Expression<Func<TEntity, bool>> filter, CancellationToken cancellationToken = default);
+
+        Task<int> DeleteManyAsync(Expression<Func<TEntity, bool>> filter, CancellationToken cancellationToken = default);
+
+        IQueryable<TEntity> Queryable();
+    }
+}

URF.Core.Abstractions/IDocumentUnitOfWork.cs

@@ -0,0 +1,10 @@
+using System.Threading.Tasks;
+
+namespace URF.Core.Abstractions;
+
+public interface IDocumentUnitOfWork
+{
+    Task StartTransactionAsync();
+    Task CommitAsync();
+    Task AbortAsync();
+}

URF.Core.Abstractions/IQuery.cs

@@ -19,10 +19,14 @@ public interface IQuery<TEntity> where TEntity : class
         IQuery<TEntity> ThenBy(Expression<Func<TEntity, object>> thenBy);
         IQuery<TEntity> ThenByDescending(Expression<Func<TEntity, object>> thenByDescending);
         Task<int> CountAsync(CancellationToken cancellationToken = default);
-        Task<TEntity> FirstOrDefaultAsync(Expression<Func<TEntity, bool>> predicate, CancellationToken cancellationToken);
-        Task<TEntity> SingleOrDefaultAsync(Expression<Func<TEntity, bool>> predicate, CancellationToken cancellationToken);
+        Task<TEntity> FirstOrDefaultAsync(CancellationToken cancellationToken = default);
+        Task<TEntity> FirstOrDefaultAsync(Expression<Func<TEntity, bool>> predicate, CancellationToken cancellationToken = default);
+        Task<TEntity> SingleOrDefaultAsync(CancellationToken cancellationToken = default);
+        Task<TEntity> SingleOrDefaultAsync(Expression<Func<TEntity, bool>> predicate, CancellationToken cancellationToken = default);
         Task<IEnumerable<TEntity>> SelectSqlAsync(string sql, object[] parameters, CancellationToken cancellationToken = default);
-        Task<bool> AnyAsync(Expression<Func<TEntity, bool>> predicate, CancellationToken cancellationToken);
-        Task<bool> AnyAsync(CancellationToken cancellationToken);
+        Task<bool> AnyAsync(Expression<Func<TEntity, bool>> predicate, CancellationToken cancellationToken = default);
+        Task<bool> AnyAsync(CancellationToken cancellationToken = default);
+        Task<bool> AllAsync(Expression<Func<TEntity, bool>> predicate, CancellationToken cancellationToken = default);
+
     }
 }

URF.Core.Abstractions/URF.Core.Abstractions.csproj

@@ -1,18 +1,23 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFramework>netstandard2.0</TargetFramework>
+    <TargetFramework>net8.0</TargetFramework>
     <LangVersion>latest</LangVersion>
-    <Version>1.1.0</Version>
+    <Version>8.0.0</Version>
     <Authors>Long Le, Tony Sneed</Authors>
-    <PackageLicenseUrl>https://github.com/urfnet/URF.Core/blob/master/LICENSE</PackageLicenseUrl>
+    <PackageLicenseExpression>MIT</PackageLicenseExpression>
     <PackageProjectUrl>https://github.com/urfnet/URF.Core</PackageProjectUrl>
-    <PackageIconUrl>https://user-images.githubusercontent.com/2836367/36162252-7ec8dd8a-10ab-11e8-936c-11bbb77ef574.png</PackageIconUrl>
+    <PackageIcon>icon.png</PackageIcon>
     <Title>URF - Unit of Work and Repositories Framework for .NET Standard and .NET Core (Official): Abstractions</Title>
     <Description>This official URF framework minimizes the surface area of your ORM technlogy from disseminating in your application. Framework provides an elegant way to implement a reusable and extensible Unit of Work and Repository pattern.</Description>
     <PackageTags>repository unitofwork service patterns</PackageTags>
+	<PackageReleaseNotes>https://github.com/urfnet/URF.Core/releases/tag/v8.0.0</PackageReleaseNotes>
     <GeneratePackageOnBuild>true</GeneratePackageOnBuild>
     <RepositoryUrl>https://github.com/urfnet/URF.Core</RepositoryUrl>
   </PropertyGroup>
 
+  <ItemGroup>
+    <None Include="icon.png" Pack="true" Visible="false" PackagePath="" />
+  </ItemGroup>
+
 </Project>

URF.Core.EF.Tests/Contexts/NorthwindDbContextSeed.cs

@@ -13,16 +13,16 @@ public static void SeedDataSql(this NorthwindDbContext context,
             {
                 context.Database.OpenConnection();
                 context.Categories.AddRange(categories);
-                context.Database.ExecuteSqlCommand("DELETE Categories");
-                context.Database.ExecuteSqlCommand("SET IDENTITY_INSERT Categories ON");
+                context.Database.ExecuteSqlRaw("DELETE Categories");
+                context.Database.ExecuteSqlRaw("SET IDENTITY_INSERT Categories ON");
                 context.SaveChanges();
-                context.Database.ExecuteSqlCommand("SET IDENTITY_INSERT Categories OFF");
+                context.Database.ExecuteSqlRaw("SET IDENTITY_INSERT Categories OFF");
 
                 context.Products.AddRange(products);
-                context.Database.ExecuteSqlCommand("DELETE Products");
-                context.Database.ExecuteSqlCommand("SET IDENTITY_INSERT Products ON");
+                context.Database.ExecuteSqlRaw("DELETE Products");
+                context.Database.ExecuteSqlRaw("SET IDENTITY_INSERT Products ON");
                 context.SaveChanges();
-                context.Database.ExecuteSqlCommand("SET IDENTITY_INSERT Products OFF");
+                context.Database.ExecuteSqlRaw("SET IDENTITY_INSERT Products OFF");
             }
             finally
             {

URF.Core.EF.Tests/Models/MyProductComparer.cs

@@ -6,7 +6,7 @@ namespace URF.Core.EF.Tests.Models
     internal class MyProductComparer : IEqualityComparer<MyProduct>
     {
         public bool Equals(MyProduct x, MyProduct y)
-            => x.Id == y.Id && (string.Compare(x.Name, y.Name, StringComparison.InvariantCulture) == 0) && x.Price == y.Price && x.Category == y.Category;
+            => x!.Id == y!.Id && (string.Compare(x.Name, y.Name, StringComparison.InvariantCulture) == 0) && x.Price == y.Price && x.Category == y.Category;
 
         public int GetHashCode(MyProduct x)
             => x.Id.GetHashCode()

URF.Core.EF.Tests/QueryIncludeTest.cs

@@ -77,10 +77,10 @@ private void EnsureEntities<TEntity>(NorthwindDbContext context, IEnumerable<TEn
                 var insertOn = $"SET IDENTITY_INSERT dbo.{tableName} ON";
                 var insertOff = $"SET IDENTITY_INSERT dbo.{tableName} OFF";
                 if (typeof(TEntity) != typeof(Customer) && typeof(TEntity) != typeof(OrderDetail))
-                    context.Database.ExecuteSqlCommand(insertOn);
+                    context.Database.ExecuteSqlRaw(insertOn);
                 context.SaveChanges();
                 if (typeof(TEntity) != typeof(Customer) && typeof(TEntity) != typeof(OrderDetail))
-                    context.Database.ExecuteSqlCommand(insertOff);
+                    context.Database.ExecuteSqlRaw(insertOff);
             }
             finally
             {

URF.Core.EF.Tests/RepositorySqlTest.cs

@@ -51,14 +51,14 @@ public async Task QueryableSql_Should_Allow_Composition()
             var comparer = new MyProductComparer();
             var expected1 = new MyProduct { Id = 1, Name = "Chai", Price = 18m, Category = "Beverages" };
             var expected2 = new MyProduct { Id = 2, Name = "Chang", Price = 19m, Category = "Beverages" };
-            var expected3 = new MyProduct { Id = 24, Name = "Guarana Fantastica", Price = 4.5m, Category = "Beverages" };
+            var expected3 = new MyProduct { Id = 35, Name = "Steeleye Stout", Price = 18m, Category = "Beverages" };
             var repository = new Repository<Product>(_fixture.Context);
 
             // Act
             var query = repository.QueryableSql("SELECT * FROM Products");
             var products = await query
                 .Include(p => p.Category)
-                .Where(p => p.UnitPrice > 15)
+                .Where(p => (new[] { 1, 2, 35 }).Contains(p.ProductId))
                 .Select(p => new MyProduct
                 {
                     Id = p.ProductId,

URF.Core.EF.Tests/RepositoryTest.cs

@@ -285,7 +285,7 @@ public async Task Queryable_Should_Allow_Composition()
             var products = await query
                 .Take(2)
                 .Include(p => p.Category)
-                .Where(p => p.UnitPrice > 15)
+                .Where(p => p.UnitPrice.CompareTo(15.00m) > 0 )
                 .Select(p => new MyProduct
                 {
                     Id = p.ProductId,
@@ -315,6 +315,64 @@ public async Task SelectAsync_Should_Return_Entities()
             Assert.Equal(77, enumerable.Length);
         }
 
+        [Fact]
+        public async Task Queries_should_be_fired_and_forgotten()
+        {
+            // Arrange
+            var repository = new Repository<Product>(_fixture.Context);
+
+            // Act
+            var products = await repository.Query().Where(p => p.ProductId == 1).SelectAsync();
+
+            // Assert
+            Assert.NotNull(products);
+
+            // Act
+            var product = await repository.Query().SingleOrDefaultAsync(s => s.ProductId == 2);
+
+            // Assert
+            Assert.NotNull(product);
+        }
+
+        [Fact]
+        public async Task FirstOrDefaultAsync_Should_Return_Entity()
+        {
+            // Arrange
+            var repository = new Repository<Product>(_fixture.Context);
+
+            // Act
+            var product = await repository.Query().Where(p => p.CategoryId == 1).FirstOrDefaultAsync();
+
+            // Assert
+            Assert.NotNull(product);
+        }
+
+        [Fact]
+        public async Task FirstOrDefaultAsync_Should_Return_Null()
+        {
+            // Arrange
+            var repository = new Repository<Product>(_fixture.Context);
+
+            // Act
+            var product = await repository.Query().Where(p => p.CategoryId == -1).FirstOrDefaultAsync();
+
+            // Assert
+            Assert.Null(product);
+        }
+
+        [Fact]
+        public async Task FirstOrDefaultAsync_With_Predicate_Should_Return_Entity()
+        {
+            // Arrange
+            var repository = new Repository<Product>(_fixture.Context);
+
+            // Act
+            var product = await repository.Query().FirstOrDefaultAsync(s => s.ProductId == 1);
+
+            // Assert
+            Assert.NotNull(product);
+        }
+
         [Fact]
         public void Update_Should_Set_Entity_State_Modified()
         {

URF.Core.EF.Tests/ServiceTest.cs

@@ -1,4 +1,3 @@
-using System.Collections.Generic;
 using System.Threading.Tasks;
 using URF.Core.Abstractions;
 using URF.Core.Abstractions.Trackable;
@@ -13,30 +12,24 @@ namespace URF.Core.EF.Tests
     [Collection(nameof(NorthwindDbContext))]
     public class ServiceTest
     {
-        private readonly List<Order> _orders;
-        private readonly List<Product> _products;
-        private readonly List<Category> _categories;
-        private readonly List<Customer> _customers;
-        private readonly List<OrderDetail> _ordersDetails;
-
         private readonly NorthwindDbContextFixture _fixture;
 
         public ServiceTest(NorthwindDbContextFixture fixture)
         {
-            _orders = Factory.Orders();
-            _products = Factory.Products();
-            _categories = Factory.Categories();
-            _customers = Factory.Customers();
-            _ordersDetails = Factory.OrderDetails();
+            var orders = Factory.Orders();
+            var products = Factory.Products();
+            var categories = Factory.Categories();
+            var customers = Factory.Customers();
+            var ordersDetails = Factory.OrderDetails();
 
             _fixture = fixture;
             _fixture.Initialize(true, () =>
             {
-                _fixture.Context.Categories.AddRange(_categories);
-                _fixture.Context.Products.AddRange(_products);
-                _fixture.Context.Customers.AddRange(_customers);
-                _fixture.Context.Orders.AddRange(_orders);
-                _fixture.Context.OrderDetails.AddRange(_ordersDetails);
+                _fixture.Context.Categories.AddRange(categories);
+                _fixture.Context.Products.AddRange(products);
+                _fixture.Context.Customers.AddRange(customers);
+                _fixture.Context.Orders.AddRange(orders);
+                _fixture.Context.OrderDetails.AddRange(ordersDetails);
                 _fixture.Context.SaveChanges();
             });
         }
@@ -107,8 +100,8 @@ public async Task Service_Insert_Should_Insert_Into_Database()
             var newCustomer = await customerRepository.FindAsync(customerId);
 
             // Assert
-            Assert.Equal(newCustomer.CustomerId, customerId);
-            Assert.Equal(newCustomer.CompanyName, companyName);
+            Assert.Equal(customerId, newCustomer.CustomerId);
+            Assert.Equal(companyName, newCustomer.CompanyName);
         }
     }
 }

URF.Core.EF.Tests/Services/CustomerService.cs

@@ -29,13 +29,15 @@ public async Task<IEnumerable<Customer>> CustomersByCompany(string companyName)
 
         public async Task<decimal> CustomerOrderTotalByYear(string customerId, int year)
         {
-            return await Repository
+            var customers = await Repository
                 .Queryable()
                 .Where(c => c.CustomerId == customerId)
+                .ToListAsync();
+            return customers
                 .SelectMany(c => c.Orders.Where(o => o.OrderDate != null && o.OrderDate.Value.Year == year))
                 .SelectMany(c => c.OrderDetails)
                 .Select(c => c.Quantity * c.UnitPrice)
-                .SumAsync();
+                .Sum();
         }
 
         public async Task<IEnumerable<CustomerOrder>> GetCustomerOrder(string country)