Merge pull request #37 from DevExcelerate/feature/updates

Feature/updates

Author: Calin Lupas

src/DevExcelerateApi/Core/Extensions/ServiceExtensions.cs

@@ -97,6 +97,10 @@ internal static IServiceCollection AddAppServices(this IServiceCollection servic
             services.AddSingleton<IRepositoryService, RepositoryService>();
             services.AddSingleton<ITeamService, TeamService>();
             services.AddSingleton<IIssueService, IssueService>();
+            services.AddSingleton<IPolicyService, PolicyService>();
+
+            services.AddMemoryCache();
+            services.AddSingleton<ICacheService, CacheService>();
 
             return services;
         }

src/DevExcelerateApi/Models/Constants.cs

@@ -19,6 +19,7 @@ public static class Constants
         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_INVAILD_REPO_NAME = "ERROR_INVAILD_REPO_NAME";
 
         // Repository PR related constants
         public const string ERROR_PR_CREATION = "ERROR_REPO_PR_CREATION";
@@ -29,7 +30,8 @@ public static class Constants
         public const string ERROR_TEAM_EXISTS = "ERROR_TEAM_EXISTS";
         public const string ERROR_PARENT_TEAM_DOES_NOT_EXISTS = "ERROR_PARENT_TEAM_DOES_NOT_EXISTS";
         public const string ERROR_TEAM_MEMBER_DOES_NOT_EXISTS = "ERROR_TEAM_MEMBER_DOES_NOT_EXISTS";
-        
+        public const string ERROR_INVAILD_TEAM_NAME = "ERROR_INVAILD_TEAM_NAME";
+
         public const string VALIDATION_PASSED = "VALIDATION_PASSED";
         public const string ISSUE_APPROVED = "ISSUE_APPROVED";
         public const string ISSUE_COMPLETED = "ISSUE_COMPLETED";

src/DevExcelerateApi/Models/DevExOrganizationPolicies.cs

@@ -0,0 +1,36 @@
+using DevExcelerateApi.Helpers;
+using YamlDotNet.Serialization;
+
+namespace DevExcelerateApi.Models
+{
+    public class DevExOrganizationPolicies
+    {
+        [YamlMember(Alias = "name", Order = 1)]
+        public string? Name { get; set; }
+
+        [YamlMember(Alias = "description", Order = 2)]
+        public string? Description { get; set; }
+
+        [YamlMember(Alias = "resource", Order = 3)]
+        public string? Resource { get; set; }
+
+        /// <summary>
+        /// The naming convention (RegEx) for repositories in the organization.
+        /// </summary>
+        /// <remarks>Example: "^([a-zA-Z0-9]{2,5})(?:-([a-zA-Z0-9]{2,5}))?-([a-zA-Z0-9\-_.]+)$"</remarks>
+        [YamlMember(Alias = "repository_naming_convention", Order = 4)]
+        public string? RepositoryNamingConvention { get; set; }
+
+        /// <summary>
+        /// The naming convention (RegEx) for teams in the organization.
+        /// </summary>
+        [YamlMember(Alias = "team_naming_convention", Order = 5)]
+        public string? TeamNamingConvention { get; set; }
+
+        public static DevExOrganizationPolicies DeserializeFromYaml(string yamlContent)
+        {
+            ArgumentNullException.ThrowIfNull(yamlContent);
+            return YamlHelpers.Deserialize<DevExOrganizationPolicies>(yamlContent);
+        }
+    }
+}

src/DevExcelerateApi/Models/DevExPolicies.cs

@@ -4,12 +4,14 @@ namespace DevExcelerateApi.Models
 {
     public enum DevExPolicies
     {
+        [Description("Organization Policies")]
+        Organization_Policies = 10,
         [Description("Repository Metadata")]
-        Repository_Metadata = 1,
+        Repository_Metadata = 20,
         [Description("Repository Protection")]
-        Repository_Protection,
+        Repository_Protection = 21,
         [Description("Team Metadata")]
-        Team_Metadata
+        Team_Metadata = 30
     }
 
     public static class DevExPoliciesExtensions
@@ -18,6 +20,7 @@ public static string GetPolicyYamlFileName(this DevExPolicies policy)
         {
             return policy switch
             {
+                DevExPolicies.Organization_Policies => "organization-policies.yml",
                 DevExPolicies.Repository_Metadata => "repository-metadata.yml",
                 DevExPolicies.Repository_Protection => "repository-protection.yml",
                 DevExPolicies.Team_Metadata => "team-metadata.yml",

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

@@ -189,4 +189,10 @@
   <data name="ERROR_TEAM_MEMBER_DOES_NOT_EXISTS" xml:space="preserve">
     <value>Le membre d'équipe {0} n'existe pas.</value>
   </data>
+  <data name="ERROR_INVAILD_REPO_NAME" xml:space="preserve">
+    <value>Le nom du dépôt '{0}' est invalide.</value>
+  </data>
+  <data name="ERROR_INVAILD_TEAM_NAME" xml:space="preserve">
+    <value>Le nom de l'équipe '{0}' est invalide.</value>
+  </data>
 </root>

src/DevExcelerateApi/Resources/Services.LocalizationService.resx

@@ -189,4 +189,10 @@
   <data name="ERROR_TEAM_MEMBER_DOES_NOT_EXISTS" xml:space="preserve">
     <value>The team member {0} does not exist.</value>
   </data>
+  <data name="ERROR_INVAILD_REPO_NAME" xml:space="preserve">
+    <value>The repository name '{0}' is invalid.</value>
+  </data>
+  <data name="ERROR_INVAILD_TEAM_NAME" xml:space="preserve">
+    <value>The team name '{0}' is invalid.</value>
+  </data>
 </root>

src/DevExcelerateApi/Services/CacheService.cs

@@ -0,0 +1,43 @@
+using Microsoft.Extensions.Caching.Memory;
+
+namespace DevExcelerateApi.Services
+{
+    public class CacheService(IMemoryCache memoryCache) : ICacheService
+    {
+        private readonly IMemoryCache _memoryCache = memoryCache;
+
+        public Task<T?> GetAsync<T>(string key)
+        {
+            _memoryCache.TryGetValue(key, out T? value);
+            return Task.FromResult(value);
+        }
+
+        public Task SetAsync<T>(string key, T value, TimeSpan? absoluteExpireTime = null, TimeSpan? slidingExpireTime = null)
+        {
+            var options = new MemoryCacheEntryOptions();
+
+            if (absoluteExpireTime.HasValue)
+            {
+                options.AbsoluteExpirationRelativeToNow = absoluteExpireTime;
+            }
+            else if (slidingExpireTime.HasValue)
+            {
+                options.SlidingExpiration = slidingExpireTime;
+            }
+            else
+            {
+                // Default expiration if none provided
+                options.SlidingExpiration = TimeSpan.FromMinutes(5);
+            }
+
+            _memoryCache.Set(key, value, options);
+            return Task.CompletedTask;
+        }
+
+        public Task RemoveAsync(string key)
+        {
+            _memoryCache.Remove(key);
+            return Task.CompletedTask;
+        }
+    }
+}

src/DevExcelerateApi/Services/ICacheService.cs

@@ -0,0 +1,9 @@
+namespace DevExcelerateApi.Services
+{
+    public interface ICacheService
+    {
+        Task<T?> GetAsync<T>(string key);
+        Task SetAsync<T>(string key, T value, TimeSpan? absoluteExpireTime = null, TimeSpan? slidingExpireTime = null);
+        Task RemoveAsync(string key);
+    }
+}

src/DevExcelerateApi/Services/IPolicyService.cs

@@ -0,0 +1,11 @@
+using Octokit.Webhooks;
+using System.ComponentModel.DataAnnotations;
+
+namespace DevExcelerateApi.Services
+{
+    public interface IPolicyService
+    {
+        Task<ValidationResult> ValidateRepositoryNameAsync(string name, WebhookEvent webhookEvent);
+        Task<ValidationResult> ValidateTeamNameAsync(string name, WebhookEvent webhookEvent);
+    }
+}

src/DevExcelerateApi/Services/PolicyService.cs

@@ -0,0 +1,140 @@
+using DevExcelerateApi.Core.Extensions;
+using DevExcelerateApi.Core.Options;
+using DevExcelerateApi.Helpers;
+using DevExcelerateApi.Models;
+using Microsoft.Extensions.Options;
+using Octokit.Webhooks;
+using System.ComponentModel.DataAnnotations;
+using System.Text.RegularExpressions;
+
+namespace DevExcelerateApi.Services
+{
+    public class PolicyService(
+            ILogger<PolicyService> logger,
+            IGitHubClientFactory gitHubClientFactory,
+            IOptions<GitHubOptions> gitHubOptions,
+            ILocalizationService localizationService,
+            ICacheService cacheService)
+            : IPolicyService
+    {
+        private readonly ILogger<PolicyService> _logger = logger;
+        private readonly IGitHubClientFactory _gitHubClientFactory = gitHubClientFactory;
+        private readonly GitHubOptions _gitHubOptions = gitHubOptions.Value;
+        private readonly ILocalizationService _localizationService = localizationService;
+        private readonly ICacheService _cacheService = cacheService;
+
+        public async Task<ValidationResult> ValidateRepositoryNameAsync(string name, WebhookEvent webhookEvent)
+        {
+            return await ValidateNameAgainstPolicyAsync(
+                name,
+                webhookEvent,
+                policies => policies.RepositoryNamingConvention,
+                Constants.ERROR_INVAILD_REPO_NAME,
+                "Repository");
+        }
+
+        public async Task<ValidationResult> ValidateTeamNameAsync(string name, WebhookEvent webhookEvent)
+        {
+             return await ValidateNameAgainstPolicyAsync(
+                name,
+                webhookEvent,
+                policies => policies.TeamNamingConvention,
+                Constants.ERROR_INVAILD_TEAM_NAME,
+                "Team");
+        }
+
+        private async Task<ValidationResult> ValidateNameAgainstPolicyAsync(
+            string name,
+            WebhookEvent webhookEvent,
+            Func<DevExOrganizationPolicies, string?> namingConventionSelector,
+            string errorKey,
+            string entityTypeNameForLog)
+        {
+            if (string.IsNullOrWhiteSpace(name))
+            {
+                var errorMessage = string.Format(_localizationService.GetLocalizedString(errorKey), name ?? "<null>");
+                return new ValidationResult(errorMessage, [nameof(name)]);
+            }
+
+            var policies = await GetDevExOrganizationPolicies(webhookEvent?.Installation?.Id, webhookEvent?.Organization?.Login!);
+
+            if (policies != null)
+            {
+                var namingConvention = namingConventionSelector(policies);
+                if (!string.IsNullOrWhiteSpace(namingConvention))
+                {
+                    if (!Regex.IsMatch(name, namingConvention))
+                    {
+                        var errorMessage = string.Format(_localizationService.GetLocalizedString(errorKey), name);
+                        return new ValidationResult(errorMessage, [nameof(name)]);
+                    }
+                }
+            }
+
+            // If no policy is found or no naming convention is specified, consider it valid.
+            _logger.LogInformation("{EntityType} name '{Name}' validated successfully.", entityTypeNameForLog, name);
+            return ValidationResult.Success!;
+        }
+
+        private async Task<DevExOrganizationPolicies> GetDevExOrganizationPolicies(long? installationId, string owner)
+        {
+            string cacheKey = $"org_policies_{owner}_{_gitHubOptions.RepoPolicy}_{DevExPolicies.Organization_Policies.GetPolicyYamlFileName()}";
+            DevExOrganizationPolicies? orgPolicies = null;
+
+            try
+            {
+                // Try to get from cache first
+                string? policyString = await _cacheService.GetAsync<string>(cacheKey);
+
+                if (!string.IsNullOrEmpty(policyString))
+                {
+                    _logger.LogDebug("Organization policies for '{Owner}' found in cache.", owner);
+                    orgPolicies = DevExOrganizationPolicies.DeserializeFromYaml(policyString);
+                }
+                else
+                {
+                    _logger.LogDebug("Organization policies for '{Owner}' not found in cache. Fetching from GitHub.", owner);
+                    var installationClient = await _gitHubClientFactory.GetInstallationAsync(installationId);
+                    string policyFilePath = $"{Constants.GitHubPoliciesFolderPath}{DevExPolicies.Organization_Policies.GetPolicyYamlFileName()}";
+
+                    try
+                    {
+                        // Get the policy metadata from GitHub
+                        policyString = await installationClient.GetFileContentAsync(
+                                                                                owner,
+                                                                                _gitHubOptions.RepoPolicy,
+                                                                                policyFilePath);
+
+                        if (!string.IsNullOrEmpty(policyString))
+                        {
+                            orgPolicies = DevExOrganizationPolicies.DeserializeFromYaml(policyString);
+                            // Store in cache - consider adding an expiration time via ICacheService options if needed
+                            await _cacheService.SetAsync(cacheKey, policyString);
+                            _logger.LogInformation("Successfully fetched and cached organization policies for '{Owner}'.", owner);
+                        }
+                        else
+                        {
+                            _logger.LogWarning("Fetched empty or null policy string for organization '{Owner}' from '{PolicyRepo}/{PolicyPath}'. Returning default policies.", owner, _gitHubOptions.RepoPolicy, policyFilePath);
+                            // Cache the empty string to indicate the file is empty, preventing repeated fetches for empty files
+                            await _cacheService.SetAsync(cacheKey, string.Empty); // Cache empty string
+                        }
+                    }
+                    catch (Octokit.NotFoundException)
+                    {
+                        _logger.LogWarning("Policy file '{PolicyPath}' not found for organization '{Owner}' in repo '{PolicyRepo}'. Returning default policies and caching 'not found'.", policyFilePath, owner, _gitHubOptions.RepoPolicy);
+                        // Cache the fact that it's not found (e.g., cache empty string) to avoid repeated lookups for a non-existent file
+                        // Consider a specific expiration for "not found" cache entries if desired
+                        await _cacheService.SetAsync(cacheKey, string.Empty); // Cache empty string to represent "not found"
+                    }
+                }
+            }
+            catch (Exception ex) // Catch potential exceptions during cache access or GitHub fetch
+            {
+                 _logger.LogError(ex, "Error retrieving or processing organization policies for '{Owner}'. Returning default policies.", owner);
+            }
+
+            // Ensure we always return a non-null object
+            return orgPolicies ?? new DevExOrganizationPolicies();
+        }
+    }
+}