(GH-659) Allow azure storage blob context to respect DatabaseGeneratedOption for primary keys

johelvisguzman · johelvisguzman · commit e777b52a197b · 2021-10-13T11:18:24.000-04:00
diff --git a/src/DotNetToolkit.Repository.AzureStorageBlob/Internal/AzureStorageBlobRepositoryContext.cs b/src/DotNetToolkit.Repository.AzureStorageBlob/Internal/AzureStorageBlobRepositoryContext.cs
@@ -10,10 +10,13 @@
     using Query.Strategies;
     using System;
     using System.Collections.Generic;
+    using System.ComponentModel.DataAnnotations.Schema;
     using System.Data;
+    using System.Globalization;
     using System.IO;
     using System.Linq;
     using System.Linq.Expressions;
+    using System.Reflection;
     using System.Text;
     using System.Threading;
     using System.Threading.Tasks;
@@ -86,6 +89,62 @@ private TEntity Deserialize<TEntity>(Stream stream)
             }
         }
 
+        protected async Task<Tuple<bool, object>> TryGeneratePrimaryKeyAsync<TEntity>(TEntity entity) where TEntity : class
+        {
+            Guard.NotNull(entity, nameof(entity));
+
+            var primaryKeyPropertyInfos = Conventions.GetPrimaryKeyPropertyInfos<TEntity>();
+
+            if (primaryKeyPropertyInfos.Length > 1)
+                return Tuple.Create<bool, object>(false, null);
+
+            var primaryKeyPropertyInfo = primaryKeyPropertyInfos.First();
+            var attribute = primaryKeyPropertyInfo.GetCustomAttribute<DatabaseGeneratedAttribute>();
+            if (attribute?.DatabaseGeneratedOption == DatabaseGeneratedOption.None ||
+                attribute?.DatabaseGeneratedOption == DatabaseGeneratedOption.Computed)
+            {
+                return Tuple.Create<bool, object>(false, null);
+            }
+
+            var propertyType = primaryKeyPropertyInfo.PropertyType;
+            object newKey = null;
+
+            if (propertyType == typeof(Guid))
+            {
+                newKey = Guid.NewGuid();
+            }
+            else if (propertyType == typeof(string))
+            {
+                newKey = Guid.NewGuid().ToString("N");
+            }
+            else if (propertyType == typeof(int))
+            {
+                var lambda = ExpressionHelper.GetExpression<TEntity>(primaryKeyPropertyInfo.Name);
+                var func = (Func<TEntity, int>)lambda.Compile();
+
+                var key = await AsAsyncEnumerable<TEntity>()
+                    .Select(func)
+                    .OrderByDescending(x => x)
+                    .FirstOrDefaultAsync();
+
+                newKey = Convert.ToInt32(key) + 1;
+            }
+
+            if (newKey != null)
+            {
+                primaryKeyPropertyInfo.SetValue(entity, newKey);
+
+                return Tuple.Create<bool, object>(true, newKey);
+            }
+
+            throw new InvalidOperationException(
+                string.Format(
+                    CultureInfo.CurrentCulture,
+                    Resources.EntityKeyValueTypeInvalid,
+                    typeof(TEntity).FullName,
+                    propertyType));
+        }
+
         private BlobContainerClient GetBlobContainer<TEntity>()
         {
             var container = _containerNameBuilder.Build<TEntity>();
@@ -186,6 +245,9 @@ private async IAsyncEnumerable<TEntity> DownloadEntitiesAsync<TEntity>() where T
         private void UploadEntity<TEntity>(TEntity entity) where TEntity : class
         {
             var blob = GetBlobClient(entity);
+
+            TryGeneratePrimaryKey(entity, out var _);
+
             using (var stream = Serialize<TEntity>(entity))
             {
                 var binaryData = BinaryData.FromStream(stream);
@@ -197,6 +259,9 @@ private void UploadEntity<TEntity>(TEntity entity) where TEntity : class
         private async Task UploadEntityAsync<TEntity>(TEntity entity, CancellationToken cancellationToken = new CancellationToken()) where TEntity : class
         {
             var blob = await GetBlobClientAsync(entity);
+
+            await TryGeneratePrimaryKeyAsync(entity);
+
             using (var stream = Serialize<TEntity>(entity))
             {
                 var binaryData = await BinaryData.FromStreamAsync(stream, cancellationToken);
diff --git a/src/DotNetToolkit.Repository/Configuration/LinqEnumerableRepositoryContextBase.cs b/src/DotNetToolkit.Repository/Configuration/LinqEnumerableRepositoryContextBase.cs
@@ -10,9 +10,12 @@
     using System;
     using System.Collections;
     using System.Collections.Generic;
+    using System.ComponentModel.DataAnnotations.Schema;
     using System.Data;
+    using System.Globalization;
     using System.Linq;
     using System.Linq.Expressions;
+    using System.Reflection;
     using Transactions;
     using Utility;
 
@@ -87,6 +90,66 @@ protected LinqEnumerableRepositoryContextBase()
         /// <returns>The entity's query.</returns>
         protected abstract IEnumerable<TEntity> AsEnumerable<TEntity>([CanBeNull] IFetchQueryStrategy<TEntity> fetchStrategy) where TEntity : class;
 
+        /// <summary>
+        /// Returns <c>true</c> if able to generate a primary key for the specified entity; otherwise, <c>false</c>.
+        /// </summary>
+        protected bool TryGeneratePrimaryKey<TEntity>(TEntity entity, out object newKey) where TEntity : class
+        {
+            Guard.NotNull(entity, nameof(entity));
+
+            var primaryKeyPropertyInfos = Conventions.GetPrimaryKeyPropertyInfos<TEntity>();
+
+            newKey = null;
+
+            if (primaryKeyPropertyInfos.Length > 1)
+                return false;
+
+            var primaryKeyPropertyInfo = primaryKeyPropertyInfos.First();
+            var attribute = primaryKeyPropertyInfo.GetCustomAttribute<DatabaseGeneratedAttribute>();
+            if (attribute?.DatabaseGeneratedOption == DatabaseGeneratedOption.None ||
+                attribute?.DatabaseGeneratedOption == DatabaseGeneratedOption.Computed)
+            {
+                return false;
+            }
+
+            var propertyType = primaryKeyPropertyInfo.PropertyType;
+
+            if (propertyType == typeof(Guid))
+            {
+                newKey = Guid.NewGuid();
+            }
+            else if (propertyType == typeof(string))
+            {
+                newKey = Guid.NewGuid().ToString("N");
+            }
+            else if (propertyType == typeof(int))
+            {
+                var lambda = ExpressionHelper.GetExpression<TEntity>(primaryKeyPropertyInfo.Name);
+                var func = (Func<TEntity, int>)lambda.Compile();
+
+                var key = AsEnumerable<TEntity>(fetchStrategy: null)
+                    .Select(func)
+                    .OrderByDescending(x => x)
+                    .FirstOrDefault();
+
+                newKey = Convert.ToInt32(key) + 1;
+            }
+
+            if (newKey != null)
+            {
+                primaryKeyPropertyInfo.SetValue(entity, newKey);
+
+                return true;
+            }
+
+            throw new InvalidOperationException(
+                string.Format(
+                    CultureInfo.CurrentCulture,
+                    Resources.EntityKeyValueTypeInvalid,
+                    typeof(TEntity).FullName,
+                    propertyType));
+        }
+
         #endregion
 
         #region Implementation of IRepositoryContext
diff --git a/test/DotNetToolkit.Repository.Integration.Test/Tests/Repository/RepositoryTests.Add.cs b/test/DotNetToolkit.Repository.Integration.Test/Tests/Repository/RepositoryTests.Add.cs
@@ -16,9 +16,7 @@ public void Add()
         [Fact]
         public void AddWithSeededIdForIdentity()
         {
-            ForAllRepositoryFactories(TestAddWithSeededIdForIdentity, 
-                ContextProviderType.EntityFrameworkCore, 
-                ContextProviderType.AzureStorageBlob);
+            ForAllRepositoryFactories(TestAddWithSeededIdForIdentity, ContextProviderType.EntityFrameworkCore);
         }
 
         [Fact]
@@ -27,6 +25,12 @@ public void AddWithSeededIdForNoneIdentity()
             ForAllRepositoryFactories(TestAddWithSeededIdForNoneIdentity);
         }
 
+        [Fact]
+        public void AddWithNotSeededIdForIdentity()
+        {
+            ForAllRepositoryFactories(TestAddWithNotSeededIdForIdentity, ContextProviderType.EntityFrameworkCore);
+        }
+
         [Fact]
         public void AddRange()
         {
@@ -42,9 +46,7 @@ public void AddAsync()
         [Fact]
         public void AddWithSeededIdForIdentityAsync()
         {
-            ForAllRepositoryFactoriesAsync(TestAddWithSeededIdForIdentityAsync, 
-                ContextProviderType.EntityFrameworkCore, 
-                ContextProviderType.AzureStorageBlob);
+            ForAllRepositoryFactoriesAsync(TestAddWithSeededIdForIdentityAsync, ContextProviderType.EntityFrameworkCore);
         }
 
         [Fact]
@@ -53,6 +55,12 @@ public void AddWithSeededIdForNoneIdentityAsync()
             ForAllRepositoryFactoriesAsync(TestAddWithSeededIdForNoneIdentityAsync);
         }
 
+        [Fact]
+        public void AddWithNotSeededIdForIdentityAsync()
+        {
+            ForAllRepositoryFactoriesAsync(TestAddWithNotSeededIdForIdentityAsync, ContextProviderType.EntityFrameworkCore);
+        }
+
         [Fact]
         public void AddRangeAsync()
         {
@@ -106,6 +114,24 @@ private static void TestAddWithSeededIdForNoneIdentity(IRepositoryFactory repoFa
             Assert.True(repo.Exists(key));
         }
 
+        private static void TestAddWithNotSeededIdForIdentity(IRepositoryFactory repoFactory)
+        {
+            var repo = repoFactory.Create<Customer>();
+
+            var entity1 = new Customer() { Name = "Random Name 1" };
+            var entity2 = new Customer() { Name = "Random Name 2" };
+
+            Assert.False(repo.Exists(x => x.Name == "Random Name 1"));
+            Assert.False(repo.Exists(x => x.Name == "Random Name 2"));
+
+            repo.Add(entity1);
+            repo.Add(entity2);
+
+            // should be one, and two since it is autogenerating identity models
+            Assert.Equal(1, entity1.Id);
+            Assert.Equal(2, entity2.Id);
+        }
+
         private static void TestAddRange(IRepositoryFactory repoFactory)
         {
             var repo = repoFactory.Create<Customer>();
@@ -172,6 +198,24 @@ private static async Task TestAddWithSeededIdForNoneIdentityAsync(IRepositoryFac
             Assert.True(await repo.ExistsAsync(key));
         }
 
+        private static async Task TestAddWithNotSeededIdForIdentityAsync(IRepositoryFactory repoFactory)
+        {
+            var repo = repoFactory.Create<Customer>();
+
+            var entity1 = new Customer() { Name = "Random Name 1" };
+            var entity2 = new Customer() { Name = "Random Name 2" };
+
+            Assert.False(await repo.ExistsAsync(x => x.Name == "Random Name 1"));
+            Assert.False(await repo.ExistsAsync(x => x.Name == "Random Name 2"));
+
+            await repo.AddAsync(entity1);
+            await repo.AddAsync(entity2);
+
+            // should be one, and two since it is autogenerating identity models
+            Assert.Equal(1, entity1.Id);
+            Assert.Equal(2, entity2.Id);
+        }
+
         private static async Task TestAddRangeAsync(IRepositoryFactory repoFactory)
         {
             var repo = repoFactory.Create<Customer>();
