Permissions Attribute class Helper Extension Methods - Part 3

Articles in this Series

• Introduction - A DynamicData Attribute Based Permission Solution using User Roles.
• Part 1 - Permissions Attribute (Metadata) Classes.
• Part 2 - Sample Metadata for project.
• Part 3 - The Helper Extension Methods.
• Part 4 - Limit Tables shown on Default page and List, Edit & Details etc.
• Part 5 - Generate Columns/Rows (using IAutoFieldGenerator)
• Part 6 - Miscellaneous bits
• Part 7 - Updating the ListDetails Page
• DynamicData - Limit the Filter Fields
• DynamicData - Automatic Column Update

Helper Extension Methods

The attribute data is held in:

• MetaTable.Attributes
• MetaColumn.Attributes
• MetaForeignKeyColumn.ParentTable.Attribute
• MetaChildrenColumn.ChildTable.Attributes

Form the above list four extension methods will be needed on to deal with each type.

• What data type should the extension method operate on? The obvious type would be AttributeCollection but would move unnecessary casting in some of the other extension methods. The types will be MetaTable for the table permissions extension method and MetaColumn for the others and any casting will then be hidden in the extension methods themselves.
• What type should the extension method return? The obvious and correct type would be the TablePermissionsAttribute.Permissions or FieldPermissionsAttribute.Permissions types and since there could be multiple entries per class/property then a generic List<T> of the type should be returned.
• What other parameter will be need? A role of type String, but because a user can have several roles it should be roles of type String[] because this is what is returned by Roles.GetRolesForUser().

If a breakpoint is set at an instance of column of type MetaColumn (see Figure 1) it can be seen that the column.Attributes is of type System.ComponentModel.AttributeCollection and 1 & 2 are FieldPermissionsAttributes this means that the collection will need to be iterated through to pick out the FieldPermissionsAttributes.

Figure 1

Let us look at the extension method definition for MetaColumn.Attributes.

public static List<FieldPermissionsAttribute.Permissions>
GetFieldPermissions(this MetaColumn column, String[] roles)
{
    List<FieldPermissionsAttribute.Permissions> permissions = 
        new List<FieldPermissionsAttribute.Permissions>();

    //TODO: get attributes permissions
    return permissions;
}

Listing 1

Calling the GetFieldPermissions extension method:

var fieldPermissions = column.GetFieldPermissions(Roles.GetRolesForUser());

In Listing 1 each attribute is checked to see if it has one of the users roles passed in from the GetRolesForUser() method of the Roles class. If a match is found then the permission is added to “permissions” local variable.

public static List<FieldPermissionsAttribute.Permissions>
    GetFieldPermissions(this MetaColumn column, String[] roles)
{
    var permissions = new List<FieldPermissionsAttribute.Permissions>();

    // you could put: 
    // var attributes = column.Attributes;
    // but to make it clear what type we are using:
    System.ComponentModel.AttributeCollection attributes = column.Attributes;

    // check to see if any roles passed
    if (roles.Count() > 0)
    {
        // using Linq to Object to get 
        // the permissions foreach role
        permissions =
            (from a in attributes.OfType<FieldPermissionsAttribute>()
             where a.HasAnyRole(roles)
             select a.Permission).ToList<FieldPermissionsAttribute.Permissions>();
    }
    return permissions;
}

Listing 2

Above in Listing 2 is the full helper extension method GetFieldPermissions three more extension methods are required to cater for:

• Table
• ChileTable
• ParentTable

MetaColumn Types. Below in Listing 3 are all the extension methods for the Permissions Attributes classes.

/// <summary>
/// Permissions Attributes Helper Extension Methods
/// </summary>
public static class PermissionsAttributesHelper
{
    /// <summary>
    /// Get a list of permissions for the specified role
    /// </summary>
    /// <param name="attributes">
    /// Is a AttributeCollection taken 
    /// from the column of a MetaTable
    /// </param>
    /// <param name="role">
    /// name of the role to be matched with
    /// </param>
    /// <returns>A List of permissions</returns>
    public static List<FieldPermissionsAttribute.Permissions>
    GetFieldPermissions(this MetaColumn column, String[] roles)
    {
        var permissions = new List<FieldPermissionsAttribute.Permissions>();

        // you could put: 
        // var attributes = column.Attributes;
        // but to make it clear what type we are using:
        System.ComponentModel.AttributeCollection attributes = column.Attributes;

        // check to see if any roles passed
        if (roles.Count() > 0)
        {
            // using Linq to Object to get 
            // the permissions foreach role
            permissions =
                (from a in attributes.OfType<FieldPermissionsAttribute>()
                 where a.HasAnyRole(roles)
                 select a.Permission).ToList<FieldPermissionsAttribute.Permissions>();
        }
        return permissions;
    }

    /// <summary>
    /// Get a list of permissions for the specified role
    /// </summary>
    /// <param name="attributes">
    /// Is a AttributeCollection taken from the column of a MetaTable
    /// </param>
    /// <param name="role">name of the role to be matched with</param>
    /// <returns>A List of permissions</returns>
    public static List<TablePermissionsAttribute.Permissions>
        GetTablePermissions(this MetaTable table, String[] roles)
    {
        var permissions = new List<TablePermissionsAttribute.Permissions>();
        var attributes = table.Attributes;

        // check to see if any roles passed
        if (roles.Count() > 0)
        {
            // using Linq to Object to get 
            // the permissions foreach role
            permissions =
                (from a in attributes.OfType<TablePermissionsAttribute>()
                 where a.HasAnyRole(roles)
                 select a.Permission).ToList<TablePermissionsAttribute.Permissions>();
        }
        return permissions;
    }

    /// <summary>
    /// Get a list of permissions for the specified role
    /// </summary>
    /// <param name="attributes">
    /// Is a AttributeCollection taken from the column of a MetaTable
    /// </param>
    /// <param name="role">name of the role to be matched with</param>
    /// <returns>A List of permissions</returns>
    public static List<TablePermissionsAttribute.Permissions>
        GetFkTablePermissions(this MetaColumn column, String[] roles)
    {
        var permissions = new List<TablePermissionsAttribute.Permissions>();
        var foreignKeyColumn = column as MetaForeignKeyColumn;
        var attributes = foreignKeyColumn.ParentTable.Attributes;

        // check to see if any roles passed
        if (roles.Count() > 0)
        {
            // using Linq to Object to get 
            // the permissions foreach role
            permissions =
                (from a in attributes.OfType<TablePermissionsAttribute>()
                 where a.HasAnyRole(roles)
                 select a.Permission).ToList<TablePermissionsAttribute.Permissions>();
        }
        return permissions;
    }

    /// <summary>
    /// Get a list of permissions for the specified role
    /// </summary>
    /// <param name="attributes">
    /// Is a AttributeCollection taken from the column of a MetaTable
    /// </param>
    /// <param name="role">name of the role to be matched with</param>
    /// <returns>A List of permissions</returns>
    public static List<TablePermissionsAttribute.Permissions>
        GetChildrenTablePermissions(this MetaColumn column, String[] roles)
    {
        var permissions = new List<TablePermissionsAttribute.Permissions>();
        var childrenColumn = column as MetaChildrenColumn;
        var attributes = childrenColumn.Attributes;

        // check to see if any roles passed
        if (roles.Count() > 0)
        {
            // using Linq to Object to get 
            // the permissions foreach role
            permissions =
                (from a in attributes.OfType<TablePermissionsAttribute>()
                 where a.HasAnyRole(roles)
                 select a.Permission).ToList<TablePermissionsAttribute.Permissions>();
        }
        return permissions;
    }

    /// <summary>
    /// Returns a copy of the array of string 
    /// all in lowercase
    /// </summary>
    /// <param name="strings">Array of strings</param>
    /// <returns>array of string all in lowercase</returns>
    public static String[] AllToLower(this String[] strings)
    {
        String[] temp = new String[strings.Count()];
        for (int i = 0; i < strings.Count(); i++)
        {
            temp[i] = strings[i].ToLower();
        }
        return temp;
    }
}

Listing 3

Next putting it all together in the Generate Columns/Rows (using IAutoFieldGenerator)