Spelling: Principal, not Principle

Author: webprofusion-chrisc

src/Certify.Client/CertifyApiClient.cs

@@ -804,10 +804,10 @@ public async Task<string> RefreshAccessToken(AuthContext authContext)
             return _refreshToken;
         }
 
-        public async Task<List<SecurityPrinciple>> GetAccessSecurityPrinciples(AuthContext authContext)
+        public async Task<List<SecurityPrincipal>> GetAccessSecurityPrincipals(AuthContext authContext)
         {
-            var result = await FetchAsync("access/securityprinciples", authContext);
-            return JsonToObject<List<SecurityPrinciple>>(result);
+            var result = await FetchAsync("access/securityprincipals", authContext);
+            return JsonToObject<List<SecurityPrincipal>>(result);
         }
 
         public async Task<Certify.Models.Config.ActionResult> CheckApiTokenHasAccess(AccessToken token, AccessCheck check, AuthContext authContext = null)

src/Certify.Core/Management/Access/AccessControl.cs

@@ -3,7 +3,7 @@
 
 namespace Certify.Models.Hub
 {
-    public enum SecurityPrincipleType
+    public enum SecurityPrincipalType
     {
         User = 1,
         Application = 2,
@@ -17,9 +17,9 @@ public enum SecurityPermissionType
     }
 
     /// <summary>
-    /// A Security Principle is a user or service account which can be assigned roles and other permissions
+    /// A Security Principal is a user or service account which can be assigned roles and other permissions
     /// </summary>
-    public class SecurityPrinciple : ConfigurationStoreItem
+    public class SecurityPrincipal : ConfigurationStoreItem
     {
         public string? Username { get; set; }
         public string? Password { get; set; }
@@ -31,11 +31,11 @@ public class SecurityPrinciple : ConfigurationStoreItem
         public string? Provider { get; set; }
 
         /// <summary>
-        /// If principle is externally controlled, this is the identifier from the external system
+        /// If principal is externally controlled, this is the identifier from the external system
         /// </summary>
         public string? ExternalIdentifier { get; set; }
 
-        public SecurityPrincipleType PrincipleType { get; set; } = SecurityPrincipleType.User;
+        public SecurityPrincipalType PrincipalType { get; set; } = SecurityPrincipalType.User;
 
         public string? AuthKey { get; set; }
 
@@ -44,7 +44,7 @@ public class SecurityPrinciple : ConfigurationStoreItem
     }
 
     /// <summary>
-    /// A role is a collection of policies which can be assigned to a security principle via AssignedRole
+    /// A role is a collection of policies which can be assigned to a security principal via AssignedRole
     /// </summary>
     public class Role : ConfigurationStoreItem
     {
@@ -63,7 +63,7 @@ public Role(string id, string title, string description, List<string>? policies
     }
 
     /// <summary>
-    /// A role assigned to a security principle, optionally specific to a set of resources
+    /// A role assigned to a security principal, optionally specific to a set of resources
     /// </summary>
     public class AssignedRole : ConfigurationStoreItem
     {
@@ -73,26 +73,26 @@ public class AssignedRole : ConfigurationStoreItem
         public string RoleId { get; set; } = default!;
 
         /// <summary>
-        /// Specific security principle assigned to the role
+        /// Specific security principal assigned to the role
         /// </summary>
-        public string SecurityPrincipleId { get; set; } = default!;
+        public string SecurityPrincipalId { get; set; } = default!;
 
         public List<Resource>? IncludedResources { get; set; } = [];
     }
 
     public class AccessCheck
     {
-        public string? SecurityPrincipleId { get; set; } = default!;
+        public string? SecurityPrincipalId { get; set; } = default!;
         public string ResourceType { get; set; } = default!;
         public string ResourceActionId { get; set; } = default!;
         public string? Identifier { get; set; } = default!;
 
         public List<string> ScopedAssignedRoles { get; set; } = [];
 
         public AccessCheck() { }
-        public AccessCheck(string? securityPrincipleId, string resourceType, string resourceActionId, string? identifier = null)
+        public AccessCheck(string? securityPrincipalId, string resourceType, string resourceActionId, string? identifier = null)
         {
-            SecurityPrincipleId = securityPrincipleId;
+            SecurityPrincipalId = securityPrincipalId;
             ResourceType = resourceType;
             ResourceActionId = resourceActionId;
             Identifier = identifier;
@@ -121,7 +121,7 @@ public class AccessToken : ConfigurationStoreItem
     }
     public class AssignedAccessToken : ConfigurationStoreItem
     {
-        public string SecurityPrincipleId { get; set; } = default!;
+        public string SecurityPrincipalId { get; set; } = default!;
 
         /// <summary>
         /// Optional list of Assigned Roles this access token is scoped to. Note this is not the RoleID but the AssignedRoleID.
@@ -183,9 +183,9 @@ public ResourceAction(string id, string title, string resourceType)
 
         public string? ResourceType { get; set; }
     }
-    public class SecurityPrincipleAssignedRoleUpdate
+    public class SecurityPrincipalAssignedRoleUpdate
     {
-        public string SecurityPrincipleId { get; set; } = string.Empty;
+        public string SecurityPrincipalId { get; set; } = string.Empty;
         public List<AssignedRole> AddedAssignedRoles { get; set; } = new List<AssignedRole>();
         public List<AssignedRole> RemovedAssignedRoles { get; set; } = new List<AssignedRole>();
     }

src/Certify.Models/Hub/AccessControl.cs

@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Threading.Tasks;
@@ -80,7 +80,7 @@ public class StandardIdentityProviders
     public class ResourceTypes
     {
         public static string System { get; } = "system";
-        public static string SecurityPrinciple { get; } = "securityprinciple";
+        public static string SecurityPrincipal { get; } = "securityprincipal";
         public static string Role { get; } = "role";
         public static string AccessToken { get; } = "accesstoken";
         public static string Domain { get; } = "domain";
@@ -130,14 +130,14 @@ public static class StandardResourceActions
         public const string StoredCredentialList = "storedcredential_list_action";
         public const string StoredCredentialDownload = "storedcredential_consumer_action";
 
-        public const string SecurityPrincipleList = "securityprinciple_list_action";
-        public const string SecurityPrincipleAdd = "securityprinciple_add_action";
-        public const string SecurityPrincipleUpdate = "securityprinciple_update_action";
-        public const string SecurityPrincipleUpdateAssignedRoles = "securityprinciple_update_assignedroles_action";
-        public const string SecurityPrincipleDelete = "securityprinciple_delete_action";
-        public const string SecurityPrinciplePasswordUpdate = "securityprinciple_password_update_action";
-        public const string SecurityPrinciplePasswordValidate = "securityprinciple_password_validate_action";
-        public const string SecurityPrincipleCheckAccess = "securityprinciple_access_check_action";
+        public const string SecurityPrincipalList = "securityprincipal_list_action";
+        public const string SecurityPrincipalAdd = "securityprincipal_add_action";
+        public const string SecurityPrincipalUpdate = "securityprincipal_update_action";
+        public const string SecurityPrincipalUpdateAssignedRoles = "securityprincipal_update_assignedroles_action";
+        public const string SecurityPrincipalDelete = "securityprincipal_delete_action";
+        public const string SecurityPrincipalPasswordUpdate = "securityprincipal_password_update_action";
+        public const string SecurityPrincipalPasswordValidate = "securityprincipal_password_validate_action";
+        public const string SecurityPrincipalCheckAccess = "securityprincipal_access_check_action";
 
         public const string RoleList = "role_list_action";
 
@@ -249,14 +249,14 @@ public static List<ResourceAction> GetStandardResourceActions()
                 new(StandardResourceActions.StoredCredentialList, "List Stored Credentials", ResourceTypes.StoredCredential),
                 new(StandardResourceActions.StoredCredentialDownload, "Fetch Decrypted Stored Credential", ResourceTypes.StoredCredential),
 
-                new(StandardResourceActions.SecurityPrincipleList, "List Security Principles", ResourceTypes.SecurityPrinciple),
-                new(StandardResourceActions.SecurityPrincipleAdd, "Add New Security Principle", ResourceTypes.SecurityPrinciple),
-                new(StandardResourceActions.SecurityPrincipleUpdate,"Update Security Principles", ResourceTypes.SecurityPrinciple),
-                new(StandardResourceActions.SecurityPrincipleUpdateAssignedRoles,"Update Security Principle Assigned Roles", ResourceTypes.SecurityPrinciple),
-                new(StandardResourceActions.SecurityPrinciplePasswordUpdate, "Update Security Principle Passwords", ResourceTypes.SecurityPrinciple),
-                new(StandardResourceActions.SecurityPrincipleDelete, "Delete Security Principle", ResourceTypes.SecurityPrinciple),
-                new(StandardResourceActions.SecurityPrincipleCheckAccess, "Check Security Principle Access", ResourceTypes.SecurityPrinciple),
-                new(StandardResourceActions.SecurityPrinciplePasswordValidate, "Validate Security Principle Passwords", ResourceTypes.SecurityPrinciple),
+                new(StandardResourceActions.SecurityPrincipalList, "List Security Principals", ResourceTypes.SecurityPrincipal),
+                new(StandardResourceActions.SecurityPrincipalAdd, "Add New Security Principal", ResourceTypes.SecurityPrincipal),
+                new(StandardResourceActions.SecurityPrincipalUpdate,"Update Security Principals", ResourceTypes.SecurityPrincipal),
+                new(StandardResourceActions.SecurityPrincipalUpdateAssignedRoles,"Update Security Principal Assigned Roles", ResourceTypes.SecurityPrincipal),
+                new(StandardResourceActions.SecurityPrincipalPasswordUpdate, "Update Security Principal Passwords", ResourceTypes.SecurityPrincipal),
+                new(StandardResourceActions.SecurityPrincipalDelete, "Delete Security Principal", ResourceTypes.SecurityPrincipal),
+                new(StandardResourceActions.SecurityPrincipalCheckAccess, "Check Security Principal Access", ResourceTypes.SecurityPrincipal),
+                new(StandardResourceActions.SecurityPrincipalPasswordValidate, "Validate Security Principal Passwords", ResourceTypes.SecurityPrincipal),
 
                 new(StandardResourceActions.AccessTokenAdd, "Add Access Token", ResourceTypes.AccessToken),
                 new(StandardResourceActions.AccessTokenDelete, "Delete Access Token", ResourceTypes.AccessToken),
@@ -356,12 +356,12 @@ public static List<ResourcePolicy> GetStandardPolicies()
                     Title = "Access Control Administration",
                     SecurityPermissionType = SecurityPermissionType.ALLOW,
                     ResourceActions = [
-                        StandardResourceActions.SecurityPrincipleList,
-                        StandardResourceActions.SecurityPrincipleAdd,
-                        StandardResourceActions.SecurityPrincipleUpdate,
-                        StandardResourceActions.SecurityPrincipleDelete,
-                        StandardResourceActions.SecurityPrinciplePasswordUpdate,
-                        StandardResourceActions.SecurityPrincipleUpdateAssignedRoles
+                        StandardResourceActions.SecurityPrincipalList,
+                        StandardResourceActions.SecurityPrincipalAdd,
+                        StandardResourceActions.SecurityPrincipalUpdate,
+                        StandardResourceActions.SecurityPrincipalDelete,
+                        StandardResourceActions.SecurityPrincipalPasswordUpdate,
+                        StandardResourceActions.SecurityPrincipalUpdateAssignedRoles
 
                     ]
                 },
@@ -529,8 +529,8 @@ public static List<ResourcePolicy> GetStandardPolicies()
                  SecurityPermissionType = SecurityPermissionType.ALLOW,
                  IsResourceSpecific = true,
                  ResourceActions = [
-                     StandardResourceActions.SecurityPrincipleCheckAccess,
-                     StandardResourceActions.SecurityPrinciplePasswordValidate,
+                     StandardResourceActions.SecurityPrincipalCheckAccess,
+                     StandardResourceActions.SecurityPrincipalPasswordValidate,
                      StandardResourceActions.RoleList,
                  ]
               },
@@ -560,13 +560,13 @@ public static async Task UpdateStandardAccessConfig(IAccessControl access)
         {
             // setup roles with policies
 
-            var adminSvcPrinciple = "admin_01";
+            var adminSvcPrincipal = "admin_01";
 
             var actions = Policies.GetStandardResourceActions();
 
             foreach (var action in actions)
             {
-                await access.AddResourceAction(adminSvcPrinciple, action, bypassIntegrityCheck: true);
+                await access.AddResourceAction(adminSvcPrincipal, action, bypassIntegrityCheck: true);
             }
 
             // setup policies with actions
@@ -576,7 +576,7 @@ public static async Task UpdateStandardAccessConfig(IAccessControl access)
             // add policies to store
             foreach (var r in policies)
             {
-                _ = await access.AddResourcePolicy(adminSvcPrinciple, r, bypassIntegrityCheck: true);
+                _ = await access.AddResourcePolicy(adminSvcPrincipal, r, bypassIntegrityCheck: true);
             }
 
             // setup roles with policies
@@ -585,7 +585,7 @@ public static async Task UpdateStandardAccessConfig(IAccessControl access)
             foreach (var r in roles)
             {
                 // add roles and policy assignments to store
-                await access.AddRole(adminSvcPrinciple, r, bypassIntegrityCheck: true);
+                await access.AddRole(adminSvcPrincipal, r, bypassIntegrityCheck: true);
             }
         }
 
@@ -594,40 +594,40 @@ public static async Task ConfigureStandardUsersAndRoles(IAccessControl access, I
             // setup roles with policies
             await UpdateStandardAccessConfig(access);
 
-            // setup standard security principles
+            // setup standard security principals
 
             // admin user
             var adminSpId = "admin_01";
             var managedInstanceSpId = "managedinstance_sp_01";
 
-            var users = await access.GetSecurityPrinciples(adminSpId);
+            var users = await access.GetSecurityPrincipals(adminSpId);
 
             // add admin user if not already present
             if (!users.Any(u => u.Id == adminSpId))
             {
-                var adminSp = new SecurityPrinciple
+                var adminSp = new SecurityPrincipal
                 {
                     Id = adminSpId,
                     Description = "Primary default admin",
-                    PrincipleType = SecurityPrincipleType.User,
+                    PrincipalType = SecurityPrincipalType.User,
                     Username = Environment.GetEnvironmentVariable("CERTIFY_ADMIN_DEFAULTUSERNAME") ?? "admin",
                     Password = Environment.GetEnvironmentVariable("CERTIFY_ADMIN_DEFAULTPWD") ?? "changeme!",
                     Provider = StandardIdentityProviders.INTERNAL,
                     IsBuiltIn = true
                 };
 
-                await access.AddSecurityPrinciple(adminSp.Id, adminSp, bypassIntegrityCheck: true);
+                await access.AddSecurityPrincipal(adminSp.Id, adminSp, bypassIntegrityCheck: true);
             }
             // get assigned roles for admin and update any missing roles
             var assignedRolesForAdmin = await access.GetAssignedRoles(adminSpId, adminSpId);
 
-            // assign admin role to admin security principle
+            // assign admin role to admin security principal
             var toBeAssignedRoles = new List<AssignedRole> {
                      // administrator
                      new AssignedRole{
                          Id= Guid.NewGuid().ToString(),
                          RoleId=StandardRoles.Administrator.Id,
-                         SecurityPrincipleId=adminSpId
+                         SecurityPrincipalId=adminSpId
                      }
                 };
 
@@ -640,27 +640,27 @@ public static async Task ConfigureStandardUsersAndRoles(IAccessControl access, I
                 }
             }
 
-            // add managed instance service principle if not already present
+            // add managed instance service principal if not already present
             if (!users.Any(u => u.Id == managedInstanceSpId))
             {
-                var managedInstanceServicePrinciple = new SecurityPrinciple
+                var managedInstanceServicePrincipal = new SecurityPrincipal
                 {
                     Id = managedInstanceSpId,
-                    Title = "Managed Instances Service Principle",
-                    PrincipleType = SecurityPrincipleType.Application,
+                    Title = "Managed Instances Service Principal",
+                    PrincipalType = SecurityPrincipalType.Application,
                     Provider = StandardIdentityProviders.INTERNAL,
                     IsBuiltIn = true
                 };
 
-                await access.AddSecurityPrinciple(adminSpId, managedInstanceServicePrinciple, bypassIntegrityCheck: true);
+                await access.AddSecurityPrincipal(adminSpId, managedInstanceServicePrincipal, bypassIntegrityCheck: true);
 
-                // assign managed instance role to  security principle
+                // assign managed instance role to  security principal
                 var assignedRoles = new List<AssignedRole> {
 
                     new AssignedRole{
                         Id= Guid.NewGuid().ToString(),
                         RoleId=StandardRoles.ManagedInstance.Id,
-                        SecurityPrincipleId=managedInstanceSpId
+                        SecurityPrincipalId=managedInstanceSpId
                     }
                 };
 
@@ -674,7 +674,7 @@ public static async Task ConfigureStandardUsersAndRoles(IAccessControl access, I
                 var assignedApiAccessToken = new AssignedAccessToken
                 {
                     Id = Guid.NewGuid().ToString(),
-                    SecurityPrincipleId = managedInstanceSpId,
+                    SecurityPrincipalId = managedInstanceSpId,
                     Title = "Managed Instance Hub Joining Key",
                     AccessTokens = [
                         new AccessToken {