Merge pull request #26 from DevExcelerate/feature/create-repo-from-pr

#25 #22 Add pull request processing and related enhancements

Author: Calin Lupas

src/DevExcelerateApi/Core/Extensions/ServiceExtensions.cs

@@ -93,6 +93,7 @@ internal static IServiceCollection AddAppServices(this IServiceCollection servic
             services.AddSingleton<IGitHubClientFactory, GitHubClientFactory>();
             services.AddSingleton<IGitHubHelper, GitHubHelper>();
             services.AddSingleton<IDevExIssuesEventProcessorService, DevExIssuesEventProcessorService>();
+            services.AddSingleton<IDevExPullRequestEventProcessorService, DevExPullRequestEventProcessorService>();
             services.AddSingleton<WebhookEventProcessor, DevExWebhookEventProcessorService>();
             services.AddSingleton<IRepositoryService, RepositoryService>();
             services.AddSingleton<IIssueService, IssueService>();

src/DevExcelerateApi/Helpers/GitHubHelper.cs

@@ -54,6 +54,23 @@ public async Task<string> GetFileContentAsync(string owner, string repo, string
                 throw new InvalidOperationException("GitHub client is not configured.");
             }
 
+            try
+            {
+                await ReferenceExtensions.CreateBranch(_githubClient.Git.Reference, owner, repo, branch, defaultBranchName);
+            }
+            catch(ApiValidationException ex) 
+            {
+                // 422: Reference already exists
+                if (ex.StatusCode == System.Net.HttpStatusCode.UnprocessableEntity)
+                {
+                    // Ignore the exception if the branch already exists
+                }
+                else
+                {
+                    throw;
+                }
+            }
+
             try
             {
                 // Check if the file already exists
@@ -67,8 +84,6 @@ public async Task<string> GetFileContentAsync(string owner, string repo, string
             }
             catch (NotFoundException)
             {
-                await ReferenceExtensions.CreateBranch(_githubClient.Git.Reference, owner, repo, branch, defaultBranchName);
-
                 var createFileRequest = new CreateFileRequest($"Adding file {path}", content, branch);
 
                 return await _githubClient.Repository.Content.CreateFile(owner, repo, path, createFileRequest);
@@ -105,5 +120,55 @@ public async Task<PullRequest> CreatePullRequestAsync(string owner, string repo,
 
             return await _githubClient.PullRequest.Create(owner, repo, newPullRequest);
         }
+
+        public async Task<IReadOnlyList<GitHubCommitFile>> GetCommitFilesAsync(string owner, string repo, string commitSha)
+        {
+            if (_githubClient == null)
+            {
+                throw new InvalidOperationException("GitHub client is not configured.");
+            }
+
+            // Fetch the commit details using the commit SHA
+            var commit = await _githubClient.Repository.Commit.Get(owner, repo, commitSha);
+
+            // Return the list of files associated with the commit
+            return commit.Files;
+        }
+
+        public async Task<Dictionary<string, string>> GetCommitFilesWithContentAsync(string owner, string repo, string commitSha)
+        {
+            if (_githubClient == null)
+            {
+                throw new InvalidOperationException("GitHub client is not configured.");
+            }
+            
+            // Dictionary to store file paths and their content
+            var fileContents = new Dictionary<string, string>();
+
+            var files = await GetCommitFilesAsync(owner, repo, commitSha);
+
+            foreach (var file in files)
+            {
+                if (file.Status == "added" || file.Status == "modified") // Only fetch content for added/modified files
+                {
+                    try
+                    {
+                        // Fetch the raw content of the file
+                        var rawContent = await _githubClient.Repository.Content.GetRawContent(owner, repo, file.Filename);
+                        var contentString = System.Text.Encoding.UTF8.GetString(rawContent);
+
+                        // Add the file path and content to the dictionary
+                        fileContents.Add(file.Filename, contentString);
+                    }
+                    catch (NotFoundException)
+                    {
+                        // Handle cases where the file content is not accessible
+                        fileContents.Add(file.Filename, "Content not accessible");
+                    }
+                }
+            }
+
+            return fileContents;
+        }
     }
 }

src/DevExcelerateApi/Helpers/IGitHubHelper.cs

@@ -9,5 +9,7 @@ public interface IGitHubHelper
         Task<string> GetFileContentAsync(string owner, string repo, string path);
         Task<RepositoryContentChangeSet?> SaveFileAsync(string owner, string repo, string defaultBranchName, string branch, string path, string content);
         Task<PullRequest> CreatePullRequestAsync(string owner, string repo, string headBranch, string baseBranch, string title, string body);
+        Task<IReadOnlyList<GitHubCommitFile>> GetCommitFilesAsync(string owner, string repo, string commitSha);
+        Task<Dictionary<string, string>> GetCommitFilesWithContentAsync(string owner, string repo, string commitSha);
     }
 }

src/DevExcelerateApi/Models/Constants.cs

@@ -9,13 +9,15 @@ public static class Constants
         public const string GitHubPoliciesFolderPath = ".github/policies/";
         public const string GitHubInventoryReposFolderPath = "repositories/";
         public const string GitHubDefaultBranch = "main";
+        public const string GitHubPullRequestTitleIssueNumber = "Issue#";
 
         // Constants for the different types of messages that can be sent
         public const string ERROR_REPO_CREATION = "ERROR_REPO_CREATION";
         public const string ERROR_REPO_EXISTS = "ERROR_REPO_EXISTS";
         public const string ERROR_REPO_TEAM_DOES_NOT_EXISTS = "ERROR_REPO_TEAM_DOES_NOT_EXISTS";
         public const string ERROR_REPO_RULESET_DOES_NOT_EXISTS = "ERROR_REPO_RULESET_DOES_NOT_EXISTS";
         public const string ERROR_REPO_PR_CREATION = "ERROR_REPO_PR_CREATION";
+        public const string ERROR_REPO_PR_NO_CHANGES = "ERROR_REPO_PR_NO_CHANGES";
         public const string VALIDATION_PASSED = "VALIDATION_PASSED";
         public const string ISSUE_APPROVED = "ISSUE_APPROVED";
         public const string ISSUE_COMPLETED = "ISSUE_COMPLETED";

src/DevExcelerateApi/Resources/Services.RepositoryService.fr.resx

@@ -126,6 +126,9 @@
   <data name="ERROR_REPO_PR_CREATION" xml:space="preserve">
     <value>Un problème est survenu lors de la tentative de création de la demande de tirage.</value>
   </data>
+  <data name="ERROR_REPO_PR_NO_CHANGES" xml:space="preserve">
+    <value>La demande de tirage fermée n'a aucun fichier modifié. Fermeture du problème validé associé. Si vous devez mettre à jour la ressource, veuillez créer un nouveau problème. Merci!</value>
+  </data>
   <data name="ERROR_REPO_RULESET_DOES_NOT_EXISTS" xml:space="preserve">
     <value>Le set de règles '{0}' n'existe pas.</value>
   </data>

src/DevExcelerateApi/Resources/Services.RepositoryService.resx

@@ -126,6 +126,9 @@
   <data name="ERROR_REPO_PR_CREATION" xml:space="preserve">
     <value>An issue occurred while attempting to create the pull request.</value>
   </data>
+  <data name="ERROR_REPO_PR_NO_CHANGES" xml:space="preserve">
+    <value>The closed pull request has no files changed. Closing the related validated issue. If you need to update the resource, please create a new issue. Thank you!</value>
+  </data>
   <data name="ERROR_REPO_RULESET_DOES_NOT_EXISTS" xml:space="preserve">
     <value>The '{0}' ruleset does not exist. </value>
   </data>

src/DevExcelerateApi/Services/DevExIssuesEventProcessorService.cs

@@ -4,6 +4,7 @@
 using DevExcelerateApi.Models;
 using Microsoft.Extensions.Localization;
 using Microsoft.Extensions.Options;
+using Octokit;
 using Octokit.Webhooks;
 using Octokit.Webhooks.Events;
 using Octokit.Webhooks.Events.IssueComment;
@@ -57,8 +58,6 @@ public async Task SaveAndProcessIssueCommentEventAsync(WebhookHeaders headers, I
 
             await _gitHubWebhookRepository.SaveWebhookAsync(headers, issueCommentEvent!).ConfigureAwait(false);
 
-            _logger.LogInformation("GitHub Webhook event saved to database.");
-
             switch (action)
             {
                 case IssueCommentActionValue.Created:
@@ -69,6 +68,7 @@ public async Task SaveAndProcessIssueCommentEventAsync(WebhookHeaders headers, I
                     _logger.LogInformation("Not supported action for processing the issue comment.");
                     break;
             }
+            _logger.LogInformation("GitHub Webhook event saved to database and processed for Issue# {number} with action - {action}...", (issueCommentEvent?.Issue.Number), issueCommentEvent?.Action);
         }
 
         private async Task ValidateIssueApproval(IssuesEvent issuesEvent)

src/DevExcelerateApi/Services/DevExPullRequestEventProcessorService.cs

@@ -0,0 +1,62 @@
+using DevExcelerateApi.Data;
+using Octokit;
+using Octokit.Webhooks;
+using Octokit.Webhooks.Events;
+using Octokit.Webhooks.Events.PullRequest;
+using Octokit.Webhooks.Models.PullRequestEvent;
+
+namespace DevExcelerateApi.Services
+{
+    public class DevExPullRequestEventProcessorService(
+        ILogger<DevExPullRequestEventProcessorService> logger,
+        IRepositoryService repositoryService,
+        GitHubWebhookRepository gitHubWebhookRepository) 
+        : IDevExPullRequestEventProcessorService
+    {
+        private readonly ILogger<DevExPullRequestEventProcessorService> _logger = logger;
+        private readonly IRepositoryService _repositoryService = repositoryService;
+        private readonly GitHubWebhookRepository _gitHubWebhookRepository = gitHubWebhookRepository;
+        
+        public async Task SaveAndProcessPullRequestEventAsync(WebhookHeaders headers, PullRequestEvent pullRequestEvent, PullRequestAction action)
+        {
+            _logger.LogInformation("Starting the process of the PullRequest event for PR# {number} with action - {action}...", (pullRequestEvent?.PullRequest.Number), pullRequestEvent?.Action);
+
+            await _gitHubWebhookRepository.SaveWebhookAsync(headers, pullRequestEvent!).ConfigureAwait(false);
+            
+            switch (action)
+            {
+                case PullRequestActionValue.Opened:
+                case PullRequestActionValue.Reopened:
+                case PullRequestActionValue.Edited:
+                case PullRequestActionValue.Labeled:
+                case PullRequestActionValue.Closed:
+                    await ValidatePullRequestApproval(pullRequestEvent!);
+                    break;
+                
+                default:
+                    _logger.LogInformation("Not supported action for processing the pull request.");
+            }
+
+            _logger.LogInformation("GitHub Webhook event saved to database and processed for PR# {number} with action - {action}...", (pullRequestEvent?.PullRequest.Number), pullRequestEvent?.Action);
+        }
+
+        private async Task ValidatePullRequestApproval(PullRequestEvent pullRequestEvent)
+        {
+            var prNumber = (pullRequestEvent?.PullRequest.Number).GetValueOrDefault();
+
+            // Closed & Merged
+            if (pullRequestEvent?.PullRequest.State == PullRequestState.Closed 
+                && pullRequestEvent?.PullRequest.MergedAt != null
+                && pullRequestEvent?.PullRequest.MergeCommitSha != null)
+            {
+                _logger.LogInformation("Pull request #{number} is closed and merged.", prNumber);
+
+                await _repositoryService.SaveRepository(pullRequestEvent!);
+            }
+            else
+            {
+                _logger.LogInformation("Pull request #{number} is still in review.", prNumber);
+            }
+        }
+    }
+}

src/DevExcelerateApi/Services/DevExWebhookEventProcessorService.cs

@@ -5,6 +5,7 @@
 using Octokit.Webhooks.Events;
 using Octokit.Webhooks.Events.IssueComment;
 using Octokit.Webhooks.Events.Issues;
+using Octokit.Webhooks.Events.PullRequest;
 using Octokit.Webhooks.Models;
 
 namespace DevExcelerateApi.Services
@@ -16,18 +17,21 @@ namespace DevExcelerateApi.Services
     public class DevExWebhookEventProcessorService(
         ILogger<DevExWebhookEventProcessorService> logger,
         IOptions<GitHubOptions> gitHubOptions,
-        IDevExIssuesEventProcessorService devExIssuesEventProcessorService) : WebhookEventProcessor
+        IDevExIssuesEventProcessorService devExIssuesEventProcessorService,
+        IDevExPullRequestEventProcessorService devExPullRequestEventProcessorService) : WebhookEventProcessor
     {
         private readonly ILogger<DevExWebhookEventProcessorService> _logger = logger;
         private readonly GitHubOptions _gitHubOptions = gitHubOptions.Value;
         private readonly IDevExIssuesEventProcessorService _devExIssuesEventProcessorService = devExIssuesEventProcessorService;
-        
+        private readonly IDevExPullRequestEventProcessorService _devExPullRequestEventProcessorService = devExPullRequestEventProcessorService;
+
         private readonly IList<string> _allowedWebhookEvents =
         [
             WebhookEventType.Issues,
             WebhookEventType.IssueComment,
             WebhookEventType.Repository,
-            //WebhookEventType.RepositoryRuleset,
+            WebhookEventType.RepositoryRuleset,
+            WebhookEventType.PullRequest
         ];
 
         private readonly IList<IssuesAction> _allowedIssuesActions =
@@ -39,6 +43,15 @@ public class DevExWebhookEventProcessorService(
             IssuesAction.Labeled,
         ];
 
+        private readonly IList<PullRequestAction> _allowedPullRequestActions =
+        [
+            PullRequestAction.Opened,
+            PullRequestAction.Edited,
+            PullRequestAction.Labeled,
+            PullRequestAction.Closed,
+            PullRequestAction.Reopened            
+        ];
+
         public override Task ProcessWebhookAsync(IDictionary<string, StringValues> headers, string body)
         {
             ArgumentNullException.ThrowIfNull(headers);
@@ -73,7 +86,6 @@ protected override Task ProcessIssuesWebhookAsync(WebhookHeaders headers, Issues
                 return Task.CompletedTask;
             }
 
-            _logger.LogInformation("--> Processing the Issues event for Issue# {Number}.", issuesEvent?.Issue?.Number);
             return _devExIssuesEventProcessorService.SaveAndProcessIssueEventAsync(headers, issuesEvent!, action);
         }
 
@@ -86,8 +98,21 @@ protected override Task ProcessIssueCommentWebhookAsync(WebhookHeaders headers,
                 return Task.CompletedTask;
             }
 
-            _logger.LogInformation("--> Processing the Issue Comment event for Issue# {Number}.", issueCommentEvent?.Issue?.Number);
             return _devExIssuesEventProcessorService.SaveAndProcessIssueCommentEventAsync(headers, issueCommentEvent!, action);
         }
+    
+        protected override Task ProcessPullRequestWebhookAsync(WebhookHeaders headers, PullRequestEvent pullRequestEvent, PullRequestAction action)
+        {
+            // Only process issues events in the onboarding repository
+            // Skip if the PR action is not supported
+            if (_gitHubOptions?.RepoInventory != pullRequestEvent?.Repository?.Name
+                || !_allowedPullRequestActions.Contains(action))
+            {
+                _logger.LogInformation("--> Bypassing GitHub Webhook event for PR# {Number} with action: {Action} in repository {RepoName}", pullRequestEvent?.PullRequest?.Number, pullRequestEvent?.Action, pullRequestEvent?.Repository?.Name);
+                return Task.CompletedTask;
+            }
+
+            return _devExPullRequestEventProcessorService.SaveAndProcessPullRequestEventAsync(headers, pullRequestEvent!, action);
+        }
     }
 }

src/DevExcelerateApi/Services/IDevExPullRequestEventProcessorService.cs

@@ -0,0 +1,11 @@
+using Octokit.Webhooks;
+using Octokit.Webhooks.Events;
+using Octokit.Webhooks.Events.PullRequest;
+
+namespace DevExcelerateApi.Services
+{
+    public interface IDevExPullRequestEventProcessorService
+    {
+        Task SaveAndProcessPullRequestEventAsync(WebhookHeaders headers, PullRequestEvent pullRequestEvent, PullRequestAction action);
+    }
+}