C:/Data/Projects/MCS EPM Global Practice/Frameworks/Public/mpfX/1.0/Libraries/Mcs.Epm.MicrosoftProject.mpFx/Groups.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 System.Diagnostics;
using System.DirectoryServices;
using Mcs.Epm.MicrosoftProject.mpFx.SecurityWebService;

namespace Mcs.Epm.MicrosoftProject.mpFx
{
    /// <summary>
    /// Wraps a Project Server security group
    /// </summary>
    public class Groups
    {
        #region Instance Data

        private Dictionary<Guid, string> _Groups;

        #endregion

        #region Constructors

        protected internal Groups(Security parent)
        {
            Parent = parent;
        }

        #endregion

        #region Internal Properties

        protected internal Security Parent { get; protected set; }

        #endregion

        #region Public Methods

        /// <summary>
        /// Retrieve a dictionary of Group GUIDS and Names from Project Server
        /// </summary>
        public Dictionary<Guid, string> GetGroupsList(bool refresh)
        {
            if (_Groups == null || refresh)
            {
                _Groups = new Dictionary<Guid, string>();

                using (SecurityGroupsDataSet securityGroupsDataSet = Parent.Parent.WebServices.Security.ReadGroupList())
                {
                    foreach (SecurityGroupsDataSet.SecurityGroupsRow group in securityGroupsDataSet.SecurityGroups.Rows)
                    {
                        _Groups.Add(group.WSEC_GRP_UID, group.WSEC_GRP_NAME);
                    }
                }
            }

            return _Groups;
        }

        public Guid this[string name]
        {
            get
            {
                if (_Groups == null)
                {
                    GetGroupsList(true);
                }

                if (_Groups != null)
                {
                    if (_Groups.ContainsValue(name))
                    {
                        foreach (KeyValuePair<Guid, string> pair in _Groups)
                        {
                            Debug.WriteLine(pair.Value);
                            if (pair.Value != null && pair.Value.Equals(name, StringComparison.CurrentCultureIgnoreCase))
                            {
                                return pair.Key;
                            }
                        }
                    }
                }

                return Guid.Empty;
            }
        }

        /// <summary>
        /// Create a new group
        /// </summary>
        /// <param name="groupGuid">The group's GUID</param>
        /// <param name="name">The group's name</param>
        /// <param name="description">A description of the group</param>
        /// <param name="adGroupName">The group's Active Directory if relevant</param>
        /// <param name="adGroupGuid">The group's Active Directory objectGUID if relevant</param>
        public void CreateGroup(Guid groupGuid,
                                string name,
                                string description,
                                string adGroupName,
                                Guid adGroupGuid)
        {
            using (SecurityGroupsDataSet securityGroupsDataSet = new SecurityGroupsDataSet())
            {
                SecurityGroupsDataSet.SecurityGroupsRow group = securityGroupsDataSet.SecurityGroups.NewSecurityGroupsRow();

                group.WSEC_GRP_UID = groupGuid;
                group.WSEC_GRP_NAME = name;
                group.WSEC_GRP_DESC = description;
                group.WSEC_GRP_AD_GROUP = adGroupName;

                if (adGroupGuid != Guid.Empty)
                {
                    group.WSEC_GRP_AD_GUID = adGroupGuid;
                }

                securityGroupsDataSet.SecurityGroups.AddSecurityGroupsRow(group);

                Parent.Parent.WebServices.Security.CreateGroups(securityGroupsDataSet);
            }
        }

        /// <summary>
        /// Create a new group and add resources to it
        /// </summary>
        /// <param name="groupGuid">The group's GUID</param>
        /// <param name="name">The group's name</param>
        /// <param name="description">A description of the group</param>
        /// <param name="adGroupName">The group's Active Directory if relevant</param>
        /// <param name="adGroupGuid">The group's Active Directory objectGUID if relevant</param>
        /// <param name="resourceGuids">An array of resource GUID for which memebership we be established</param>
        public void CreateGroup(Guid groupGuid,
                                string name,
                                string description,
                                string adGroupName,
                                Guid adGroupGuid,
                                Guid[] resourceGuids)
        {
            CreateGroup(groupGuid, name, description, adGroupName, adGroupGuid);
            AddResourcesToGroup(groupGuid, resourceGuids);
        }

        /// <summary>
        /// Add users to a group
        /// </summary>
        /// <param name="groupGuid">The GUID of the group</param>
        /// <param name="resourceGuids">An array of resource GUID for which memebership we be established</param>
        public void AddResourcesToGroup(Guid groupGuid,
                                        Guid[] resourceGuids)
        {
            if (groupGuid == Guid.Empty || !_Groups.ContainsKey(groupGuid))
            {
                throw new ArgumentException("Invalid group");
            }

            using (SecurityGroupsDataSet securityGroupsDataSet = Parent.Parent.WebServices.Security.ReadGroup(groupGuid))
            {
                foreach (Guid resourceGuid in resourceGuids)
                {
                    if (securityGroupsDataSet.GroupMembers.FindByRES_UIDWSEC_GRP_UID(resourceGuid, groupGuid) == null)
                    {
                        SecurityGroupsDataSet.GroupMembersRow groupMembership = securityGroupsDataSet.GroupMembers.NewGroupMembersRow();

                        groupMembership.RES_UID = resourceGuid;
                        groupMembership.WSEC_GRP_UID = groupGuid;

                        securityGroupsDataSet.GroupMembers.AddGroupMembersRow(groupMembership);
                    }
                }

                Parent.Parent.WebServices.Security.SetGroups(securityGroupsDataSet);
            }
        }

        /// <summary>
        /// Retrieve dictionary of Active Directory groups for the current default search root
        /// </summary>
        /// <returns></returns>
        public Dictionary<string, Guid> GetADGroups()
        {
            DirectorySearcher directorySearcher = new DirectorySearcher {Filter = "(&(objectCategory=group))", SearchScope = SearchScope.Subtree};

            directorySearcher.PropertiesToLoad.Add("name");
            directorySearcher.PropertiesToLoad.Add("objectGUID");

            SearchResultCollection searchResultCollection = directorySearcher.FindAll();

            Dictionary<string, Guid> results = new Dictionary<string, Guid>();

            foreach (SearchResult result in searchResultCollection)
            {
                Debug.Assert(result.Properties["name"].Count == 1 && result.Properties["objectGUID"].Count == 1);

                results.Add(result.Properties["name"][0].ToString(), new Guid((byte[]) result.Properties["objectGUID"][0]));
            }

            return results;
        }

        #endregion
        
    }
}

---