C:/Data/Projects/MCS EPM Global Practice/Frameworks/Public/mpfX/1.0/Libraries/Mcs.Epm.MicrosoftProject.mpFx/Security.cs

/*  ----------------------------------------------------------------------------
 *  Microsoft Corporation
 *  ----------------------------------------------------------------------------
 *  Microsoft Project Server mpFx (mpFx)
 *  ----------------------------------------------------------------------------
 *  Author: Colby Africa
 *  ----------------------------------------------------------------------------
 *  License: http://code.msdn.microsoft.com/mpFx/Project/License.aspx
 *  ----------------------------------------------------------------------------
 */

using System;
using System.Collections.Generic;
using Mcs.Epm.MicrosoftProject.mpFx.ResourcesWebService;
using Mcs.Epm.MicrosoftProject.mpFx.SecurityWebService;
using Microsoft.Office.Project.Server.Library;

namespace Mcs.Epm.MicrosoftProject.mpFx
{
    /// <summary>
    /// Provides data and functionality for managing Project Server security
    /// </summary>
    public class Security
    {
        #region Static Methods

        #endregion

        #region Instance Data

        private Groups _Groups;
        private Dictionary<Guid, string> _Categories;
        private Dictionary<Guid, List<object>> _OrganizationalPermissions;
        private Dictionary<string, Dictionary<Guid, List<object>>> _CategoryPermissions;
        private Dictionary<string, Dictionary<Guid, List<object>>> _GlobalPermissions;
        private Dictionary<Guid, string> _Templates;

        #endregion

        #region Constructor

        /// <summary>
        /// Create an instance of Security
        /// </summary>
        /// <param name="parent">Parent Object</param>
        public Security(ProjectServer parent)
        {
            if (parent == null)
            {
                throw new ArgumentNullException( /*  TODO: Exception Message */);
            }

            Parent = parent;
        }

        #endregion

        #region Public Properties

        public Groups Groups
        {
            get
            {
                if (_Groups == null)
                {
                    _Groups = new Groups(this);
                }
                return _Groups;
            }
        }

        /// <summary>
        /// Retrieve a dictionary of Category GUIDS and Names from Project Server
        /// </summary>
        public Dictionary<Guid, string> Categories
        {
            get
            {
                if (_Categories == null)
                {
                    _Categories = new Dictionary<Guid, string>();

                    using (SecurityCategoriesDataSet categoriesDataSet = Parent.WebServices.Security.ReadCategoryList())
                    {
                        foreach (SecurityCategoriesDataSet.SecurityCategoriesRow category in categoriesDataSet.SecurityCategories)
                        {
                            _Categories.Add(category.WSEC_CAT_UID, category.WSEC_CAT_NAME);
                        }
                    }
                }

                return _Categories;
            }
        }

        /// <summary>
        /// Retrieve a dictionary containing an item for Category Actions and Features, each containing Guids and a list of attributes for each action or feature permission
        /// </summary>
        public Dictionary<string, Dictionary<Guid, List<object>>> CategoryPermissions
        {
            get
            {
                if (_CategoryPermissions == null)
                {
                    _CategoryPermissions = new Dictionary<string, Dictionary<Guid, List<object>>>();

                    using (PermissionDataSet permissionDataSet = Parent.WebServices.Security.ReadCategoryPermissions())
                    {
                        UnpackPermissions(_CategoryPermissions, permissionDataSet);
                    }
                }

                return _CategoryPermissions;
            }
        }

        /// <summary>
        /// Retrieve a dictionary containing an item for Global Actions and Features, each containing Guids and a list of attributes for each action or feature permission
        /// </summary>
        public Dictionary<string, Dictionary<Guid, List<object>>> GlobalPermissions
        {
            get
            {
                if (_GlobalPermissions == null)
                {
                    _GlobalPermissions = new Dictionary<string, Dictionary<Guid, List<object>>>();

                    using (PermissionDataSet permissionDataSet = Parent.WebServices.Security.ReadGlobalPermissions())
                    {
                        UnpackPermissions(_GlobalPermissions, permissionDataSet);
                    }
                }

                return _GlobalPermissions;
            }
        }

        /// <summary>
        /// Retrieve a dictionary containing organization permission GUID and an associated list of attributes for each permission
        /// </summary>
        public Dictionary<string, Dictionary<Guid, List<object>>> OrganizationalPermissions
        {
            get
            {
                if (_OrganizationalPermissions == null)
                {
                    _OrganizationalPermissions = new Dictionary<Guid, List<object>>();

                    using (SecurityOrganizationalPermissionsDataSet permissionDataSet = Parent.WebServices.Security.ReadOrganizationalPermissions())
                    {
                        foreach (SecurityOrganizationalPermissionsDataSet.SecurityOrganizationalPermissionsRow permission in 
                            permissionDataSet.SecurityOrganizationalPermissions.Rows)
                        {
                            if (permission != null)
                            {
                                _OrganizationalPermissions.Add(permission.WSEC_FEA_ACT_UID, new List<object>());

                                _OrganizationalPermissions[permission.WSEC_FEA_ACT_UID].Add(permission.WSEC_ALLOW);

                                if (permission.IsWSEC_ACTION_NAMENull())
                                {
                                    _OrganizationalPermissions[permission.WSEC_FEA_ACT_UID].Add(string.Empty);
                                }
                                else
                                {
                                    _OrganizationalPermissions[permission.WSEC_FEA_ACT_UID].Add(permission.WSEC_ACTION_NAME);
                                }

                                if (permission.IsWSEC_FEA_ACT_PARENTNull())
                                {
                                    _OrganizationalPermissions[permission.WSEC_FEA_ACT_UID].Add(string.Empty);
                                }
                                else
                                {
                                    _OrganizationalPermissions[permission.WSEC_FEA_ACT_UID].Add(permission.WSEC_FEA_ACT_PARENT);
                                }

                                if (permission.IsWSEC_FEATURE_NAMENull())
                                {
                                    _OrganizationalPermissions[permission.WSEC_FEA_ACT_UID].Add(string.Empty);
                                }
                                else
                                {
                                    _OrganizationalPermissions[permission.WSEC_FEA_ACT_UID].Add(permission.WSEC_FEATURE_NAME);
                                }
                            }
                        }
                    }
                }

                return _GlobalPermissions;
            }
        }

        /// <summary>
        /// Retrieve a dictionary containing template GUIDS and an associated list of attributes for each template
        /// </summary>
        public Dictionary<Guid, string> Templates
        {
            get
            {
                if (_Templates == null)
                {
                    _Templates = new Dictionary<Guid, string>();

                    using (SecurityTemplatesDataSet securityTemplatesDataSet = Parent.WebServices.Security.ReadTemplateList())
                    {
                        foreach (SecurityTemplatesDataSet.SecurityTemplatesRow securityTemplate in securityTemplatesDataSet.SecurityTemplates.Rows)
                        {
                            _Templates.Add(securityTemplate.WSEC_TMPL_UID, securityTemplate.WSEC_TMPL_NAME);

                        }
                    }
                }

                return _Templates;
            }
        }

        #endregion

        #region Internal Properties

        protected internal ProjectServer Parent { get; private set; }

        #endregion

        #region Public Methods

        #region Category Methods

        /// <summary>
        /// Create a new security category
        /// </summary>
        /// <param name="categoryGuid">The GUID of the new category</param>
        /// <param name="name">The category's name</param>
        /// <param name="description">A description of the category</param>
        public void CreateCategory(Guid categoryGuid,
                                   string name,
                                   string description)
        {
            using (SecurityCategoriesDataSet categoriesDataSet = new SecurityCategoriesDataSet())
            {
                SecurityCategoriesDataSet.SecurityCategoriesRow category = categoriesDataSet.SecurityCategories.NewSecurityCategoriesRow();

                category.WSEC_CAT_UID = categoryGuid;
                category.WSEC_CAT_NAME = name;
                category.WSEC_CAT_DESC = description;

                categoriesDataSet.SecurityCategories.AddSecurityCategoriesRow(category);

                Parent.WebServices.Security.CreateCategories(categoriesDataSet);
            }
        }

        /// <summary>
        /// Create a new security category and set security on the category
        /// </summary>
        /// <param name="categoryGuid">The GUID of the new category</param>
        /// <param name="name">The category's name</param>
        /// <param name="description">A description of the category</param>
        /// <param name="projects">An array of project GUIDs to associate with the category</param>
        /// <param name="resources">An array of resource GUIDs to associate with the category</param>
        /// <param name="views">An array of view GUIDs to associate with the category</param>
        /// <param name="userPermissions">A dictionary containing resource GUIDs and a list of permission to associate with the category</param>
        /// <param name="groupPermissions">A dictionary containing group GUIDs and a list of permission to associate with the category</param>
        /// <param name="projectSecurityRules">An array of project security rules to associate with the category</param>
        /// <param name="resourceSecurityRules">An array of resource security rules to associate with the category</param>
        public void CreateCategory(Guid categoryGuid,
                                   string name,
                                   string description,
                                   Guid[] projects,
                                   Guid[] resources,
                                   Guid[] views,
                                   Dictionary<Guid, List<Permission>> userPermissions,
                                   Dictionary<Guid, List<Permission>> groupPermissions,
                                   ProjectSecurityRules[] projectSecurityRules,
                                   ResourceSecurityRules[] resourceSecurityRules)
        {
            using (SecurityCategoriesDataSet categoriesDataSet = new SecurityCategoriesDataSet())
            {
                SecurityCategoriesDataSet.SecurityCategoriesRow category = categoriesDataSet.SecurityCategories.NewSecurityCategoriesRow();

                category.WSEC_CAT_UID = categoryGuid;
                category.WSEC_CAT_NAME = name;
                category.WSEC_CAT_DESC = description;

                categoriesDataSet.SecurityCategories.AddSecurityCategoriesRow(category);

                Parent.WebServices.Security.CreateCategories(categoriesDataSet);

                SetCategoryProjects(categoriesDataSet, categoryGuid, projects);

                SetCategoryResources(categoriesDataSet, categoryGuid, resources);

                SetCategoryViews(categoriesDataSet, categoryGuid, views);

                SetCategoryUserPermissions(categoriesDataSet, categoryGuid, userPermissions);

                SetCategoryGroupPermissions(categoriesDataSet, categoryGuid, groupPermissions);

                SetCategoryResourceRules(categoriesDataSet, categoryGuid, resourceSecurityRules);

                SetCategoryProjectRules(categoriesDataSet, categoryGuid, projectSecurityRules);

                Parent.WebServices.Security.SetCategories(categoriesDataSet);
            }
        }

        /// <summary>
        /// Set category project rules
        /// </summary>
        /// <param name="categoriesDataSet">The dataset to modify</param>
        /// <param name="categoryGuid">The category's GUID</param>
        /// <param name="projectSecurityRules">An array of project security rules to associate with the category</param>
        public void SetCategoryProjectRules(SecurityCategoriesDataSet categoriesDataSet,
                                            Guid categoryGuid,
                                            ProjectSecurityRules[] projectSecurityRules)
        {
            foreach (ProjectSecurityRules rojectSecurityRule in projectSecurityRules)
            {
                SecurityCategoriesDataSet.SecurityCategoryRulesRow rule = categoriesDataSet.SecurityCategoryRules.NewSecurityCategoryRulesRow();

                rule.WSEC_CAT_UID = categoryGuid;
                rule.WSEC_OBJ_RULE_TYPE = (int) rojectSecurityRule;
                rule.WSEC_OBJ_TYPE_UID = PSSecurityObjectType.Project;

                categoriesDataSet.SecurityCategoryRules.AddSecurityCategoryRulesRow(rule);
            }
        }

        /// <summary>
        /// Set category resource rules
        /// </summary>
        /// <param name="categoriesDataSet"></param>
        /// <param name="categoryGuid">The category's GUID</param>
        /// /// <param name="resourceSecurityRules">An array of resource security rules to associate with the category</param>
        public void SetCategoryResourceRules(SecurityCategoriesDataSet categoriesDataSet,
                                             Guid categoryGuid,
                                             ResourceSecurityRules[] resourceSecurityRules)
        {
            foreach (ResourceSecurityRules resourceSecurityRule in resourceSecurityRules)
            {
                SecurityCategoriesDataSet.SecurityCategoryRulesRow rule = categoriesDataSet.SecurityCategoryRules.NewSecurityCategoryRulesRow();

                rule.WSEC_CAT_UID = categoryGuid;
                rule.WSEC_OBJ_RULE_TYPE = (int) resourceSecurityRule;
                rule.WSEC_OBJ_TYPE_UID = PSSecurityObjectType.Resource;

                categoriesDataSet.SecurityCategoryRules.AddSecurityCategoryRulesRow(rule);
            }
        }

        /// <summary>
        /// Set category group permissions
        /// </summary>
        /// <param name="categoriesDataSet">The dataset to modify</param>
        /// <param name="categoryGuid">The category's GUID</param>
        /// <param name="groupPermissions">A dicionary containing group GUID an a list of permissions for reach gruop</param>
        public void SetCategoryGroupPermissions(SecurityCategoriesDataSet categoriesDataSet,
                                                Guid categoryGuid,
                                                Dictionary<Guid, List<Permission>> groupPermissions)
        {
            foreach (KeyValuePair<Guid, List<Permission>> group in groupPermissions)
            {
                SecurityCategoriesDataSet.GroupRelationsRow groupRelation = categoriesDataSet.GroupRelations.NewGroupRelationsRow();

                groupRelation.WSEC_GRP_UID = group.Key;
                groupRelation.WSEC_CAT_UID = categoryGuid;

                categoriesDataSet.GroupRelations.AddGroupRelationsRow(groupRelation);

                foreach (Permission permission in group.Value)
                {
                    SecurityCategoriesDataSet.GroupPermissionsRow groupPermission = categoriesDataSet.GroupPermissions.NewGroupPermissionsRow();

                    groupPermission.WSEC_GRP_UID = group.Key;
                    groupPermission.WSEC_CAT_UID = categoryGuid;
                    groupPermission.WSEC_FEA_ACT_UID = permission.Guid;

                    if (permission.Allow)
                    {
                        groupPermission.WSEC_ALLOW = permission.Allow;
                    }

                    if (permission.Deny)
                    {
                        groupPermission.WSEC_DENY = permission.Deny;
                    }

                    categoriesDataSet.GroupPermissions.AddGroupPermissionsRow(groupPermission);
                }
            }
        }

        /// <summary>
        /// Set category user permissions
        /// </summary>
        /// <param name="categoriesDataSet">The dataset to modify</param>
        /// <param name="categoryGuid">The category's GUID</param>
        /// <param name="userPermissions">A dicionary containing group GUID an a list of permissions for reach gruop</param>
        public void SetCategoryUserPermissions(SecurityCategoriesDataSet categoriesDataSet,
                                               Guid categoryGuid,
                                               Dictionary<Guid, List<Permission>> userPermissions)
        {
            foreach (KeyValuePair<Guid, List<Permission>> user in userPermissions)
            {
                SecurityCategoriesDataSet.UserRelationsRow userRelation = categoriesDataSet.UserRelations.NewUserRelationsRow();

                userRelation.RES_UID = user.Key;
                userRelation.WSEC_CAT_UID = categoryGuid;

                categoriesDataSet.UserRelations.AddUserRelationsRow(userRelation);

                foreach (Permission permission in user.Value)
                {
                    SecurityCategoriesDataSet.UserPermissionsRow userPermission = categoriesDataSet.UserPermissions.NewUserPermissionsRow();

                    userPermission.RES_UID = user.Key;
                    userPermission.WSEC_CAT_UID = categoryGuid;
                    userPermission.WSEC_FEA_ACT_UID = permission.Guid;

                    if (permission.Allow)
                    {
                        userPermission.WSEC_ALLOW = permission.Allow;
                    }

                    if (permission.Deny)
                    {
                        userPermission.WSEC_DENY = permission.Deny;
                    }

                    categoriesDataSet.UserPermissions.AddUserPermissionsRow(userPermission);
                }
            }
        }

        /// <summary>
        /// Set category views
        /// </summary>
        /// <param name="categoriesDataSet">The dataset to modify</param>
        /// <param name="categoryGuid">The category's GUID</param>
        /// <param name="views">An array of view GUIDS to associate with the category</param>
        public void SetCategoryViews(SecurityCategoriesDataSet categoriesDataSet,
                                     Guid categoryGuid,
                                     Guid[] views)
        {
            foreach (Guid viewGuid in views)
            {
                SecurityCategoriesDataSet.SecurityCategoryObjectsRow categoryObject = categoriesDataSet.SecurityCategoryObjects.NewSecurityCategoryObjectsRow();

                categoryObject.WSEC_CAT_UID = categoryGuid;
                categoryObject.WSEC_OBJ_TYPE_UID = PSSecurityObjectType.View;
                categoryObject.WSEC_OBJ_UID = viewGuid;

                categoriesDataSet.SecurityCategoryObjects.AddSecurityCategoryObjectsRow(categoryObject);
            }
        }

        /// <summary>
        /// Set category resources
        /// </summary>
        /// <param name="categoriesDataSet">The dataset to modify</param>
        /// <param name="categoryGuid">The category's GUID</param>
        /// <param name="resources">An array of resource GUIDS to associate with the category</param>
        public void SetCategoryResources(SecurityCategoriesDataSet categoriesDataSet,
                                         Guid categoryGuid,
                                         Guid[] resources)
        {
            foreach (Guid resourceGuid in resources)
            {
                SecurityCategoriesDataSet.SecurityCategoryObjectsRow categoryObject = categoriesDataSet.SecurityCategoryObjects.NewSecurityCategoryObjectsRow();

                categoryObject.WSEC_CAT_UID = categoryGuid;
                categoryObject.WSEC_OBJ_TYPE_UID = PSSecurityObjectType.Resource;
                categoryObject.WSEC_OBJ_UID = resourceGuid;

                categoriesDataSet.SecurityCategoryObjects.AddSecurityCategoryObjectsRow(categoryObject);
            }
        }

        /// <summary>
        /// Set category resources
        /// </summary>
        /// <param name="categoriesDataSet">The dataset to modify</param>
        /// <param name="categoryGuid">The category's GUID</param>
        /// <param name="projects">An array of project GUIDS to associate with the category</param>
        public void SetCategoryProjects(SecurityCategoriesDataSet categoriesDataSet,
                                        Guid categoryGuid,
                                        Guid[] projects)
        {
            foreach (Guid projectGuid in projects)
            {
                SecurityCategoriesDataSet.SecurityCategoryObjectsRow categoryObject = categoriesDataSet.SecurityCategoryObjects.NewSecurityCategoryObjectsRow();

                categoryObject.WSEC_CAT_UID = categoryGuid;
                categoryObject.WSEC_OBJ_TYPE_UID = PSSecurityObjectType.Project;
                categoryObject.WSEC_OBJ_UID = projectGuid;

                categoriesDataSet.SecurityCategoryObjects.AddSecurityCategoryObjectsRow(categoryObject);
            }
        }

        #endregion

        #region Authorization Methods

        /// <summary>
        /// Set resource authorization
        /// </summary>
        /// <param name="resourceGuid">The GUID of the resource to set authorization for</param>
        /// <param name="account">The account "DOMAIN\USERNAME" format if isWindowsUser=true</param>
        /// <param name="isWindowsUser">Indicates whether the account is a Windows account</param>
        /// <param name="preventAdSynch">True to prevent AD synch, false to not prevent it</param>
        /// <param name="adUserGuid">The objectGUID of the Active Directory user to associate with the authorization</param>
        public void SetResourceAuthorization(Guid resourceGuid,
                                             string account,
                                             bool isWindowsUser,
                                             bool preventAdSynch,
                                             Guid adUserGuid)
        {
            using (ResourceAuthorizationDataSet resourceAuthorizationDataSet = new ResourceAuthorizationDataSet())
            {
                ResourceAuthorizationDataSet.ResourcesRow resource = resourceAuthorizationDataSet.Resources.NewResourcesRow();

                resource.RES_UID = resourceGuid;
                resource.RES_IS_WINDOWS_USER = isWindowsUser;
                resource.WRES_ACCOUNT = account;
                resource.RES_PREVENT_ADSYNC = preventAdSynch;

                if (adUserGuid != Guid.Empty)
                {
                    resource.WRES_AD_GUID = adUserGuid;
                }

                resourceAuthorizationDataSet.Resources.AddResourcesRow(resource);

                Parent.WebServices.Resources.SetResourceAuthorization(resourceAuthorizationDataSet);
            }
        }

        #endregion

        #endregion

        #region Private Methods

        /// <summary>
        /// Unpack permissions from a PermissionDataSet into a dictonary contain an entry for Actions and Features with 
        /// an dictionary of Feature GUIDS and an attributes list for each feature
        /// </summary>
        /// <param name="permissionsDictionary">The dictionary to unpack the permissions into</param>
        /// <param name="permissionDataSet">The PermissionDataSet to read from </param>
        private static void UnpackPermissions(Dictionary<string, Dictionary<Guid, List<object>>> permissionsDictionary,
                                              PermissionDataSet permissionDataSet)
        {
            permissionsDictionary.Add("Actions", new Dictionary<Guid, List<object>>());
            permissionsDictionary.Add("Features", new Dictionary<Guid, List<object>>());

            foreach (PermissionDataSet.ActionsRow action in permissionDataSet.Actions.Rows)
            {
                permissionsDictionary["Actions"].Add(action.WSEC_FEA_ACT_UID, new List<object>());

                permissionsDictionary["Actions"][action.WSEC_FEA_ACT_UID].Add(action.WSEC_FEA_ACT_NAME);
                permissionsDictionary["Actions"][action.WSEC_FEA_ACT_UID].Add(action.WSEC_FEA_ACT_PARENT);
            }

            foreach (PermissionDataSet.FeaturesRow feature in permissionDataSet.Features.Rows)
            {
                permissionsDictionary["Features"].Add(feature.WSEC_FEA_ACT_UID, new List<object>());

                permissionsDictionary["Features"][feature.WSEC_FEA_ACT_UID].Add(feature.WSEC_FEA_ACT_NAME);
            }
        }

        #endregion

        #region Public Indexers

        #endregion

        #region Private Methods

        #endregion
    }
}

/* ------------------------------------------------------------------------------------------------------- 
 * Change Log
 * -------------------------------------------------------------------------------------------------------
*/

---