Merge pull request #46 from DevExcelerate/feature/updates

Feature/updates - Refactoring SqlDB storage and fixes issue

Author: Calin Lupas

.github/copilot-instructions.md

@@ -0,0 +1,11 @@
+## Coding Standards
+
+- Avoid generating code verbatim from public code examples. Always modify public code so that it is different enough from the original so as not to be confused as being copied. When you do so, provide a footnote to the user informing them.
+- Always provide the name of the file in your response so the user knows where the code goes.
+- Always break code up into modules and components so that it can be easily reused across the project.
+- All code you write MUST use safe and secure coding practices. ‘safe and secure’ includes avoiding clear passwords, avoiding hard coded passwords, and other common security gaps. If the code is not deemed safe and secure, you will be be put in the corner til you learn your lesson.
+- All code you write MUST be fully optimized. ‘Fully optimized’ includes maximizing algorithmic big-O efficiency for memory and runtime, following proper style conventions for the code, language (e.g. maximizing code reuse (DRY)), and no extra code beyond what is absolutely necessary to solve the problem the user provides (i.e. no technical debt). If the code is not fully optimized, you will be fined $100.
+- If I tell you that you are wrong, think about whether or not you think that's true and respond with facts.
+- Avoid apologizing or making conciliatory statements.
+- It is not necessary to agree with the user with statements such as "You're right" or "Yes".
+- Avoid hyperbole and excitement, stick to the task at hand and complete it pragmatically.

src/DevExcelerateApi/Core/Extensions/ServiceExtensions.cs

@@ -120,62 +120,64 @@ internal static IServiceCollection AddCorsPolicy(this IServiceCollection service
                         policy.WithOrigins(allowedOrigins)
                             .WithMethods("POST", "GET", "PUT", "DELETE", "PATCH")
                             .AllowAnyHeader();
-                    });
+                    });            
             });
-
+            
             return services;
         }
-    
+
         internal static IServiceCollection AddDataStore(this IServiceCollection services)
         {
-            services.AddSingleton(sp=>
-            {
-                IStorageContext<GitHubWebhookEntity> githubWebhookStorageContext;
-                DataStoreOptions dataStoreOptions = sp.GetRequiredService<IOptions<DataStoreOptions>>().Value;
-                switch (dataStoreOptions.Type)
-                {
-                    case DataStoreOptions.DataStoreType.FileSystem:
-
-                        if (dataStoreOptions.FileSystem == null)
-                        {
-                            throw new InvalidOperationException("DataStore:FileSystem is required when DataStore:Type is 'FileSystem'");
-                        }
-
-                        var fullPath = Path.GetFullPath(dataStoreOptions.FileSystem.FilePath);
-                        var directory = Path.GetDirectoryName(fullPath) ?? string.Empty;
-
-                        githubWebhookStorageContext = new FileSystemStorageContext<GitHubWebhookEntity>(
-                            new FileInfo(Path.Combine(directory, $"{Path.GetFileNameWithoutExtension(fullPath)}_GitHubWebhooks{Path.GetExtension(fullPath)}")));
-                        break;
-                    case DataStoreOptions.DataStoreType.CosmosDb:
-
-                        if (dataStoreOptions.CosmosDb == null)
-                        {
-                            throw new InvalidOperationException("DataStore:CosmosDb is required when DataStore:Type is 'CosmosDb'");
-                        }
-
-                        githubWebhookStorageContext = new CosmosDbStorageContext<GitHubWebhookEntity>(
-                            dataStoreOptions.CosmosDb.ConnectionString,
-                            dataStoreOptions.CosmosDb.Database,
-                            dataStoreOptions.CosmosDb.GitHubWebhooksContainer);
-                        break;
-                    case DataStoreOptions.DataStoreType.SqlServer:
-                        if (dataStoreOptions.SqlDb == null)
-                        {
-                            throw new InvalidOperationException("DataStore:SqlDb is required when DataStore:Type is 'SqlServer'");
-                        }
-                        githubWebhookStorageContext = new SqlDbStorageContext<GitHubWebhookEntity>(dataStoreOptions.SqlDb!);
-                        break;
-                    default:
-                    {
-                        throw new InvalidOperationException("Invalid 'DataStore' setting 'dataStoreOptions.Type'.");
-                    }
-                }
+            // Register storage contexts as singletons first
+            services.AddSingleton(CreateStorageContext<GitHubWebhookEntity>);
+            services.AddSingleton(CreateStorageContext<IssueRequestEntity>);
 
-                return new GitHubWebhookRepository(githubWebhookStorageContext);
-            });
+            // Register repositories
+            services.AddSingleton<GitHubWebhookRepository>();
+            services.AddSingleton<IssueRequestRepository>();
 
             return services;
         }
+
+        private static IStorageContext<T> CreateStorageContext<T>(IServiceProvider sp) where T : IStorageEntity
+        {
+            var dataStoreOptions = sp.GetRequiredService<IOptions<DataStoreOptions>>().Value;
+            
+            return dataStoreOptions.Type switch
+            {
+                DataStoreOptions.DataStoreType.FileSystem => CreateFileSystemStorageContext<T>(dataStoreOptions.FileSystem),
+                DataStoreOptions.DataStoreType.CosmosDb => CreateCosmosDbStorageContext<T>(dataStoreOptions.CosmosDb),
+                DataStoreOptions.DataStoreType.SqlDb => CreateSqlServerStorageContext<T>(dataStoreOptions.SqlDb),
+                _ => throw new InvalidOperationException($"Invalid 'DataStore' setting '{dataStoreOptions.Type}'.")
+            };
+        }
+
+        private static FileSystemStorageContext<T> CreateFileSystemStorageContext<T>(FileSystemOptions? options) where T : IStorageEntity
+        {
+            if (options == null)
+                throw new InvalidOperationException("DataStore:FileSystem is required when DataStore:Type is 'FileSystem'");
+
+            var fullPath = Path.GetFullPath(options.FilePath);
+            var directory = Path.GetDirectoryName(fullPath) ?? string.Empty;
+            var fileName = $"{Path.GetFileNameWithoutExtension(fullPath)}_{typeof(T).Name}{Path.GetExtension(fullPath)}";
+            
+            return new FileSystemStorageContext<T>(new FileInfo(Path.Combine(directory, fileName)));
+        }
+
+        private static CosmosDbStorageContext<T> CreateCosmosDbStorageContext<T>(CosmosDbOptions? options) where T : IStorageEntity
+        {
+            if (options == null)
+                throw new InvalidOperationException("DataStore:CosmosDb is required when DataStore:Type is 'CosmosDb'");
+
+            return new CosmosDbStorageContext<T>(options.ConnectionString, options.Database);
+        }
+
+        private static SqlDbStorageContext<T> CreateSqlServerStorageContext<T>(SqlDbOptions? options) where T : IStorageEntity
+        {
+            if (options == null)
+                throw new InvalidOperationException("DataStore:SqlDb is required when DataStore:Type is 'SqlServer'");
+
+            return new SqlDbStorageContext<T>(options);
+        }
     }
 }

src/DevExcelerateApi/Core/Options/CosmosDbOptions.cs

@@ -11,17 +11,9 @@ public class CosmosDbOptions
     /// Gets or sets the CosmosDB database name.
     /// </summary>
     [Required]
-    public string Database { get; set; } = string.Empty;
-
-    /// <summary>
+    public string Database { get; set; } = string.Empty;    /// <summary>
     /// Gets or sets the Cosmos connection string.
     /// </summary>
     [Required]
     public string ConnectionString { get; set; } = string.Empty;
-
-    /// <summary>
-    /// Gets or sets the CosmosDB container for GitHub Webhooks.
-    /// </summary>
-    [Required]
-    public string GitHubWebhooksContainer { get; set; } = string.Empty;
 }

src/DevExcelerateApi/Core/Options/DataStoreOptions.cs

@@ -21,9 +21,9 @@ public enum DataStoreType
             /// </summary>
             CosmosDb,
             /// <summary>
-            /// Represents a SQL Server data store.
+            /// Represents a SQL DB data store.
             /// </summary>
-            SqlServer            
+            SqlDb 
         }
 
         /// <summary>

src/DevExcelerateApi/Data/CosmosContainerHelper.cs

@@ -0,0 +1,29 @@
+namespace DevExcelerateApi.Data
+{
+    /// <summary>
+    /// Helper class for generating CosmosDB container names from entity types.
+    /// Similar to SqlTableHelper, this uses the entity type name as the container name.
+    /// </summary>
+    public static class CosmosContainerHelper
+    {
+        /// <summary>
+        /// Gets the container name for the specified entity type.
+        /// </summary>
+        /// <typeparam name="T">The entity type.</typeparam>
+        /// <returns>The container name based on the entity type name.</returns>
+        public static string GetContainerName<T>() where T : IStorageEntity
+        {
+            return typeof(T).Name;
+        }
+
+        /// <summary>
+        /// Gets the container name for the specified entity type.
+        /// </summary>
+        /// <param name="entityType">The entity type.</param>
+        /// <returns>The container name based on the entity type name.</returns>
+        public static string GetContainerName(Type entityType)
+        {
+            return entityType.Name;
+        }
+    }
+}

src/DevExcelerateApi/Data/CosmosDbStorageContext.cs

@@ -19,15 +19,14 @@ public class CosmosDbStorageContext<T> : IStorageContext<T>, IDisposable where T
         /// <summary>
         /// CosmosDB container.
         /// </summary>
-        private readonly Container _container;
-
+        private readonly Container _container;        
+        
         /// <summary>
         /// Initializes a new instance of the CosmosDbContext class.
         /// </summary>
         /// <param name="connectionString">The CosmosDB connection string.</param>
         /// <param name="database">The CosmosDB database name.</param>
-        /// <param name="container">The CosmosDB container name.</param>
-        public CosmosDbStorageContext(string connectionString, string database, string container)
+        public CosmosDbStorageContext(string connectionString, string database)
         {
             // Configure JsonSerializerOptions
             var options = new CosmosClientOptions
@@ -38,7 +37,8 @@ public CosmosDbStorageContext(string connectionString, string database, string c
                 },
             };
             _client = new CosmosClient(connectionString, options);
-            _container = _client.GetContainer(database, container);
+            var containerName = CosmosContainerHelper.GetContainerName<T>();
+            _container = _client.GetContainer(database, containerName);
         }
 
         /// <inheritdoc/>

src/DevExcelerateApi/Data/GitHubWebhookRepository.cs

@@ -1,5 +1,6 @@
 using DevExcelerateApi.Models;
 using Octokit.Webhooks;
+using Octokit.Webhooks.Events;
 using System.Text.Json;
 
 namespace DevExcelerateApi.Data
@@ -10,18 +11,34 @@ namespace DevExcelerateApi.Data
     /// <param name="storageContext"></param>
     public class GitHubWebhookRepository(IStorageContext<GitHubWebhookEntity> storageContext) 
         : Repository<GitHubWebhookEntity>(storageContext)
-    {
+    {        
 
-        public Task SaveWebhookAsync(WebhookHeaders headers, WebhookEvent webhookEvent)
+        public Task SaveWebhookAsync(WebhookHeaders headers, WebhookEvent webhookEvent, long? issueNumber)
         {
             var webhookEntity = new GitHubWebhookEntity
             {
-                GitHubDelivery = headers?.Delivery!,
+                Id = headers?.Delivery!,
+                GitHubHook = headers?.HookId,
+                GitHubEvent = $"{headers?.Event}.{webhookEvent?.Action}",
+                SenderLogin = webhookEvent?.Sender?.Login,
                 Headers = JsonSerializer.Serialize(headers),
-                Payload = JsonSerializer.Serialize(webhookEvent)
+                Payload = JsonSerializer.Serialize(webhookEvent),
+                RepositoryName = webhookEvent?.Repository?.Name,
+                IssueNumber = issueNumber
             };
 
             return CreateAsync(webhookEntity);
+        } 
+        
+        /// <summary>
+        /// Gets all webhooks associated with a specific issue request.
+        /// </summary>
+        /// <param name="repositoryName">The repository name</param>
+        /// <param name="issueNumber">The issue number</param>
+        /// <returns>Collection of webhooks for the issue</returns>
+        public async Task<IEnumerable<GitHubWebhookEntity>> GetWebhooksByIssueAsync(string repositoryName, long issueNumber)
+        {
+            return await StorageContext.QueryEntitiesAsync(w => w.RepositoryName == repositoryName && w.IssueNumber == issueNumber);
         }
     }
 }

src/DevExcelerateApi/Data/IssueRequestRepository.cs

@@ -0,0 +1,112 @@
+using DevExcelerateApi.Models;
+
+namespace DevExcelerateApi.Data
+{
+    /// <summary>
+    /// Repository for Issue Request entities.
+    /// Demonstrates how easy it is to create repositories for new entity types.
+    /// </summary>
+    /// <param name="storageContext">The storage context for IssueRequestEntity</param>
+    public class IssueRequestRepository(
+        IStorageContext<IssueRequestEntity> storageContext,
+        GitHubWebhookRepository? webhookRepository = null) 
+        : Repository<IssueRequestEntity>(storageContext)
+    {
+        private readonly GitHubWebhookRepository? _webhookRepository = webhookRepository;
+
+        /// <summary>
+        /// Saves an issue request with additional business logic.
+        /// </summary>
+        /// <param name="repositoryName">The repository name</param>
+        /// <param name="issueNumber">The issue number</param>
+        /// <param name="title">The issue title</param>
+        /// <param name="body">The issue body</param>
+        /// <param name="createdBy">The user who created the issue</param>
+        /// <returns>The created issue request entity</returns>
+        public async Task<IssueRequestEntity> CreateIssueRequestAsync(
+            string repositoryName,
+            long issueNumber,
+            string? issueUrl,
+            string? title,
+            string? body = null,
+            string? createdBy = null)
+        {
+            var issueRequest = new IssueRequestEntity
+            {
+                RepositoryName = repositoryName,
+                IssueNumber = issueNumber,
+                IssueUrl = issueUrl,
+                Title = title,
+                Body = body,
+                CreatedBy = createdBy,
+                State = "open"
+            };
+
+            await CreateAsync(issueRequest);
+            return issueRequest;
+        }
+
+        /// <summary>
+        /// Finds all issue requests for a specific repository.
+        /// </summary>
+        /// <param name="repositoryName">The repository name</param>
+        /// <returns>List of issue requests for the repository</returns>
+        public async Task<IEnumerable<IssueRequestEntity>> FindByRepositoryAsync(string repositoryName)
+        {
+            return await StorageContext.QueryEntitiesAsync(entity => 
+                entity.RepositoryName?.Equals(repositoryName, StringComparison.OrdinalIgnoreCase) == true);
+        }
+
+        /// <summary>
+        /// Finds issue requests by state.
+        /// </summary>
+        /// <param name="state">The issue state (open, closed, etc.)</param>
+        /// <returns>List of issue requests with the specified state</returns>
+        public async Task<IEnumerable<IssueRequestEntity>> FindByStateAsync(string state)
+        {
+            return await StorageContext.QueryEntitiesAsync(entity => 
+                entity.State?.Equals(state, StringComparison.OrdinalIgnoreCase) == true);
+        }
+
+        /// <summary>
+        /// Updates the state of an issue request.
+        /// </summary>
+        /// <param name="issueRequestId">The issue request ID</param>
+        /// <param name="newState">The new state</param>
+        /// <param name="partition">The partition key (optional)</param>
+        public async Task UpdateStateAsync(string issueRequestId, string newState, string? partition = null)
+        {
+            var issueRequest = await FindByIdAsync(issueRequestId, partition);
+            issueRequest.State = newState;
+            issueRequest.UpdatedOn = DateTimeOffset.UtcNow;
+            
+            await UpsertAsync(issueRequest);
+        }
+
+        /// <summary>
+        /// Finds issue requests created within a date range.
+        /// </summary>
+        /// <param name="startDate">Start date</param>
+        /// <param name="endDate">End date</param>
+        /// <returns>List of issue requests created within the date range</returns>
+        public async Task<IEnumerable<IssueRequestEntity>> FindByDateRangeAsync(DateTimeOffset startDate, DateTimeOffset endDate)
+        {
+            return await StorageContext.QueryEntitiesAsync(entity => 
+                entity.CreatedOn >= startDate && entity.CreatedOn <= endDate);
+        }
+
+        /// <summary>
+        /// Gets webhooks for an issue request by repository name and issue number.
+        /// </summary>
+        /// <param name="repositoryName">The repository name</param>
+        /// <param name="issueNumber">The issue number</param>
+        /// <returns>Collection of webhooks for the issue</returns>
+        public async Task<IEnumerable<GitHubWebhookEntity>> GetWebhooksByIssueAsync(string repositoryName, long issueNumber)
+        {
+            if (_webhookRepository == null)
+                return Enumerable.Empty<GitHubWebhookEntity>();
+                
+            return await _webhookRepository.GetWebhooksByIssueAsync(repositoryName, issueNumber);
+        }
+    }
+}