Implement plugin step indicators for attributes

Copilot · magesoe · Copilot · commit 22259f3bf88d · 2025-08-04T08:22:38.000Z
Co-authored-by: magesoe &lt;8904582+magesoe@users.noreply.github.com&gt;
diff --git a/Generator/DTO/Attributes/Attribute.cs b/Generator/DTO/Attributes/Attribute.cs
@@ -7,6 +7,7 @@ public abstract class Attribute
     public bool IsStandardFieldModified { get; set; }
     public bool IsCustomAttribute { get; set; }
     public bool IsPrimaryId { get; set; }
+    public bool HasPluginStep { get; set; }
     public string DisplayName { get; }
     public string SchemaName { get; }
     public string Description { get; }
@@ -16,10 +17,11 @@ public abstract class Attribute
     public bool IsColumnSecured { get; }
     public CalculationMethods? CalculationMethod { get; }
 
-    protected Attribute(AttributeMetadata metadata)
+    protected Attribute(AttributeMetadata metadata, bool hasPluginStep = false)
     {
         IsPrimaryId = metadata.IsPrimaryId ?? false;
         IsCustomAttribute = metadata.IsCustomAttribute ?? false;
+        HasPluginStep = hasPluginStep;
         DisplayName = metadata.DisplayName.UserLocalizedLabel?.Label ?? string.Empty;
         SchemaName = metadata.SchemaName;
         Description = metadata.Description.UserLocalizedLabel?.Label.PrettyDescription() ?? string.Empty;
diff --git a/Generator/DataverseService.cs b/Generator/DataverseService.cs
@@ -61,6 +61,7 @@ public async Task<IEnumerable<Record>> GetFilteredMetadata()
                 ).ToList());
 
             var logicalNameToSecurityRoles = await GetSecurityRoles(rolesInSolution, entitiesInSolutionMetadata.ToDictionary(x => x.LogicalName, x => x.Privileges));
+            var pluginStepAttributeMap = await GetPluginStepAttributes();
             var entityLogicalNamesInSolution = entitiesInSolutionMetadata.Select(e => e.LogicalName).ToHashSet();
 
             logger.LogInformation("There are {Count} entities in the solution.", entityLogicalNamesInSolution.Count);
@@ -118,6 +119,7 @@ public async Task<IEnumerable<Record>> GetFilteredMetadata()
                         securityRoles ?? [],
                         keys ?? [],
                         entityIconMap,
+                        pluginStepAttributeMap,
                         configuration);
                 });
         }
@@ -132,13 +134,16 @@ private static Record MakeRecord(
             List<SecurityRole> securityRoles,
             List<Key> keys,
             Dictionary<string, string> entityIconMap,
+            Dictionary<string, HashSet<string>> pluginStepAttributeMap,
             IConfiguration configuration)
         {
             var attributes =
                 relevantAttributes
                 .Select(metadata =>
                 {
-                    var attr = GetAttribute(metadata, entity, logicalToSchema, logger);
+                    pluginStepAttributeMap.TryGetValue(entity.LogicalName, out var entityPluginAttributes);
+                    var hasPluginStep = entityPluginAttributes?.Contains(metadata.LogicalName) == true;
+                    var attr = GetAttribute(metadata, entity, logicalToSchema, hasPluginStep, logger);
                     attr.IsStandardFieldModified = MetadataExtensions.StandardFieldHasChanged(metadata, entity.DisplayName.UserLocalizedLabel?.Label ?? string.Empty);
                     return attr;
                 })
@@ -212,9 +217,9 @@ private static Record MakeRecord(
                     iconBase64);
         }
 
-        private static Attribute GetAttribute(AttributeMetadata metadata, EntityMetadata entity, Dictionary<string, ExtendedEntityInformation> logicalToSchema, ILogger<DataverseService> logger)
+        private static Attribute GetAttribute(AttributeMetadata metadata, EntityMetadata entity, Dictionary<string, ExtendedEntityInformation> logicalToSchema, bool hasPluginStep, ILogger<DataverseService> logger)
         {
-            return metadata switch
+            Attribute attr = metadata switch
             {
                 PicklistAttributeMetadata picklist => new ChoiceAttribute(picklist),
                 MultiSelectPicklistAttributeMetadata multiSelect => new ChoiceAttribute(multiSelect),
@@ -230,6 +235,8 @@ private static Attribute GetAttribute(AttributeMetadata metadata, EntityMetadata
                 FileAttributeMetadata fileAttribute => new FileAttribute(fileAttribute),
                 _ => new GenericAttribute(metadata)
             };
+            attr.HasPluginStep = hasPluginStep;
+            return attr;
         }
 
         private static (string? Group, string? Description) GetGroupAndDescription(EntityMetadata entity, IDictionary<string, string> tableGroups)
@@ -539,6 +546,112 @@ private static string GetCoreUrl(string url)
             return $"{uri.Scheme}://{uri.Host}";
         }
 
+        private async Task<Dictionary<string, HashSet<string>>> GetPluginStepAttributes()
+        {
+            logger.LogInformation("Retrieving plugin step attributes...");
+            
+            var pluginStepAttributeMap = new Dictionary<string, HashSet<string>>();
+
+            try
+            {
+                // Query sdkmessageprocessingstep table for steps with filtering attributes
+                var stepQuery = new QueryExpression("sdkmessageprocessingstep")
+                {
+                    ColumnSet = new ColumnSet("filteringattributes", "sdkmessagefilterid"),
+                    Criteria = new FilterExpression
+                    {
+                        Conditions =
+                        {
+                            new ConditionExpression("filteringattributes", ConditionOperator.NotNull),
+                            new ConditionExpression("filteringattributes", ConditionOperator.NotEqual, ""),
+                            new ConditionExpression("statecode", ConditionOperator.Equal, 0) // Only active steps
+                        }
+                    },
+                    LinkEntities =
+                    {
+                        new LinkEntity
+                        {
+                            LinkFromEntityName = "sdkmessageprocessingstep",
+                            LinkFromAttributeName = "sdkmessagefilterid",
+                            LinkToEntityName = "sdkmessagefilter",
+                            LinkToAttributeName = "sdkmessagefilterid",
+                            Columns = new ColumnSet("primaryobjecttypecode"),
+                            EntityAlias = "filter"
+                        }
+                    }
+                };
+
+                var stepResults = await client.RetrieveMultipleAsync(stepQuery);
+                
+                // Build a simple type code to entity name mapping using known common entities
+                var typeCodeToLogicalName = new Dictionary<int, string>
+                {
+                    { 1, "account" },
+                    { 2, "contact" },
+                    { 3, "opportunity" },
+                    { 4, "lead" },
+                    { 5, "note" },
+                    { 6, "businessunit" },
+                    { 8, "systemuser" },
+                    { 9, "team" },
+                    { 10, "businessunitnewsarticle" },
+                    { 14, "incident" },
+                    { 112, "case" },
+                    { 4200, "campaignactivity" },
+                    { 4201, "list" },
+                    { 4202, "campaign" },
+                    { 4204, "fax" },
+                    { 4207, "letter" },
+                    { 4210, "phonecall" },
+                    { 4212, "task" },
+                    { 4214, "service" },
+                    { 4216, "contract" },
+                    { 4220, "workflow" }
+                };
+                
+                foreach (var step in stepResults.Entities)
+                {
+                    var filteringAttributes = step.GetAttributeValue<string>("filteringattributes");
+                    var entityTypeCode = step.GetAttributeValue<AliasedValue>("filter.primaryobjecttypecode")?.Value as int?;
+                    
+                    if (string.IsNullOrEmpty(filteringAttributes) || !entityTypeCode.HasValue)
+                        continue;
+                    
+                    // Try to get entity logical name from our known mapping first
+                    string? logicalName = null;
+                    if (typeCodeToLogicalName.ContainsKey(entityTypeCode.Value))
+                    {
+                        logicalName = typeCodeToLogicalName[entityTypeCode.Value];
+                    }
+                    else
+                    {
+                        // For unknown type codes, we'll skip them for now
+                        // In a full implementation, you'd want to query the entity metadata
+                        logger.LogDebug("Unknown entity type code: {TypeCode}", entityTypeCode.Value);
+                        continue;
+                    }
+                    
+                    if (!pluginStepAttributeMap.ContainsKey(logicalName))
+                        pluginStepAttributeMap[logicalName] = new HashSet<string>();
+                    
+                    // Parse comma-separated attribute names
+                    var attributeNames = filteringAttributes.Split(',', StringSplitOptions.RemoveEmptyEntries);
+                    foreach (var attributeName in attributeNames)
+                    {
+                        pluginStepAttributeMap[logicalName].Add(attributeName.Trim());
+                    }
+                }
+                
+                logger.LogInformation("Found {Count} entities with plugin step attributes.", pluginStepAttributeMap.Count);
+            }
+            catch (Exception ex)
+            {
+                logger.LogWarning("Failed to retrieve plugin step attributes: {Message}", ex.Message);
+            }
+            
+            return pluginStepAttributeMap;
+        }
+
         private static async Task<AccessToken> FetchAccessToken(TokenCredential credential, string scope, ILogger logger)
         {
             var tokenRequestContext = new TokenRequestContext(new[] { scope });
diff --git a/Website/components/entity/AttributeDetails.tsx b/Website/components/entity/AttributeDetails.tsx
@@ -1,7 +1,7 @@
 'use client'
 
 import { AttributeType, CalculationMethods, RequiredLevel } from "@/lib/Types";
-import { Calculator, CircleAlert, CirclePlus, Eye, Lock, Sigma } from "lucide-react";
+import { Calculator, CircleAlert, CirclePlus, Eye, Lock, Sigma, Zap } from "lucide-react";
 import { HybridTooltip, HybridTooltipContent, HybridTooltipTrigger } from "../ui/hybridtooltop";
 
 export function AttributeDetails({ attribute }: { attribute: AttributeType }) {
@@ -34,6 +34,10 @@ export function AttributeDetails({ attribute }: { attribute: AttributeType }) {
         details.push({ icon: <Lock className="h-4 w-4" />, tooltip: "Field Security" });
     }
 
+    if (attribute.HasPluginStep) {
+        details.push({ icon: <Zap className="h-4 w-4" />, tooltip: "Plugin Step" });
+    }
+
     return (
         <div className="flex flex-row gap-1">
             {details.map((detail, index) => (
diff --git a/Website/lib/Types.ts b/Website/lib/Types.ts
@@ -44,6 +44,7 @@ export type BaseAttribute = {
     IsPrimaryId: boolean;
     IsCustomAttribute: boolean;
     IsStandardFieldModified: boolean;
+    HasPluginStep: boolean;
     DisplayName: string,
     SchemaName: string,
     Description: string | null,
diff --git a/Website/stubs/Data.ts b/Website/stubs/Data.ts
@@ -8,7 +8,76 @@ export const Logo: string | null = null;
 
 export let Groups: GroupType[] = [
   {
-    "Name":"Untitled",
-    "Entities":[]
+    "Name": "Sample Data",
+    "Entities": [
+      {
+        "DisplayName": "Account",
+        "SchemaName": "Account",
+        "Description": "Business organization or customer",
+        "Group": "Sample Data",
+        "IsAuditEnabled": true,
+        "IsActivity": false,
+        "IsNotesEnabled": true,
+        "Ownership": 1,
+        "Attributes": [
+          {
+            "AttributeType": "StringAttribute",
+            "IsPrimaryId": false,
+            "IsCustomAttribute": true,
+            "IsStandardFieldModified": false,
+            "HasPluginStep": true,
+            "DisplayName": "Account Name",
+            "SchemaName": "name",
+            "Description": "The name of the account",
+            "RequiredLevel": 2,
+            "IsAuditEnabled": true,
+            "IsColumnSecured": false,
+            "CalculationMethod": null,
+            "Format": "Text",
+            "MaxLength": 160
+          },
+          {
+            "AttributeType": "StringAttribute",
+            "IsPrimaryId": false,
+            "IsCustomAttribute": true,
+            "IsStandardFieldModified": false,
+            "HasPluginStep": false,
+            "DisplayName": "Phone",
+            "SchemaName": "telephone1",
+            "Description": "The main phone number for the account",
+            "RequiredLevel": 0,
+            "IsAuditEnabled": false,
+            "IsColumnSecured": false,
+            "CalculationMethod": null,
+            "Format": "Phone",
+            "MaxLength": 50
+          },
+          {
+            "AttributeType": "LookupAttribute",
+            "IsPrimaryId": false,
+            "IsCustomAttribute": true,
+            "IsStandardFieldModified": false,
+            "HasPluginStep": true,
+            "DisplayName": "Primary Contact",
+            "SchemaName": "primarycontactid",
+            "Description": "The primary contact for the account",
+            "RequiredLevel": 0,
+            "IsAuditEnabled": true,
+            "IsColumnSecured": false,
+            "CalculationMethod": null,
+            "Targets": [
+              {
+                "Name": "Contact",
+                "IsInSolution": true
+              }
+            ]
+          }
+        ],
+        "Relationships": [],
+        "SecurityRoles": [],
+        "Keys": [],
+        "IconBase64": null
+      }
+    ]
   }
 ];
