C:/Data/Projects/MCS EPM Global Practice/Frameworks/Public/mpfX/1.0/Libraries/Mcs.Epm.MicrosoftProject.mpFx/ResourceCollection.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;
using System.Collections.Generic;
using Mcs.Epm.MicrosoftProject.mpFx.CustomFieldsWebService;
using Mcs.Epm.MicrosoftProject.mpFx.ResourcesWebService;

namespace Mcs.Epm.MicrosoftProject.mpFx
{
    /// <summary>
    /// 
    /// </summary>
    public sealed class ResourceCollection : IEnumerable<Guid>
    {
        #region Instance Data

        private readonly ProjectServer _Parent;
        private CustomFieldDataSet _CustomFields;
        private Dictionary<Guid, EnterpriseResource> _ResourceCollection;

        #endregion

        #region Constructors

        /// <summary>
        /// Creates a Resources class with a ProjectServer parent--cannot be called outside assembly
        /// </summary>
        /// <param name="parent"></param>
        internal ResourceCollection(ProjectServer parent)
        {
            if (parent == null)
            {
                throw new InvalidOperationException( /*  TODO:Exception Message  */);
            }

            _Parent = parent;
        }

        #endregion

        #region Public Properties

        /// <summary>
        /// Given an index, return the enterprise resource
        /// </summary>
        /// <param name="index">Ordinal</param>
        /// <returns></returns>
        public EnterpriseResource this[int index]
        {
            get
            {
                if (_ResourceCollection == null)
                {
                    LoadResourceCollection();
                }

                if (index > _ResourceCollection.Keys.Count)
                {
                    throw new ArgumentOutOfRangeException( /*  TODO: Exception messsage  */);
                }

                Dictionary<Guid, EnterpriseResource>.KeyCollection.Enumerator enumerator = _ResourceCollection.Keys.GetEnumerator();

                for (int i = 0; i <= index; i++)
                {
                    enumerator.MoveNext();
                }

                return _ResourceCollection[enumerator.Current];
            }
        }

        /// <summary>
        /// Given a resource GUID, return the enterprise resource
        /// </summary>
        /// <param name="resourceGuid">Resource Guid</param>
        /// <returns></returns>
        public EnterpriseResource this[Guid resourceGuid]
        {
            get
            {
                if (_ResourceCollection == null)
                {
                    LoadResourceCollection();
                }

                if (!_ResourceCollection.ContainsKey(resourceGuid))
                {
                    return null;
                }
                return _ResourceCollection[resourceGuid];
            }
        }

        /// <summary>
        /// Return the raw PSI custom field dataset
        /// </summary>
        public CustomFieldDataSet CustomFieldsDataSet
        {
            get
            {
                if (_CustomFields == null)
                {
                    LoadResourceCustomFields();
                }
                return _CustomFields;
            }
        }

        #endregion

        #region Public Methods

        public void AddAuthorization(Guid resourceUid, string Account, bool WindowsUser)
        {
            using (ResourceAuthorizationDataSet resourceAuthDs = new ResourceAuthorizationDataSet())
            {
                ResourceAuthorizationDataSet.ResourcesRow resourceAuthRow = resourceAuthDs.Resources.NewResourcesRow();

                resourceAuthRow.RES_UID = resourceUid;

                resourceAuthRow.RES_IS_WINDOWS_USER = WindowsUser;

                resourceAuthRow.WRES_ACCOUNT = Account;

                resourceAuthDs.Resources.AddResourcesRow(resourceAuthRow);

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


        public void Refresh()
        {
            LoadResourceCollection();
        }

        public EnterpriseResource FindByName(string resourceName)
        {
            if (_ResourceCollection == null)
            {
                LoadResourceCollection();
            }

            if (_ResourceCollection != null)
            {
                foreach (KeyValuePair<Guid, EnterpriseResource> resource in _ResourceCollection)
                {
                    if (resource.Value.Name.Equals(resourceName, StringComparison.CurrentCultureIgnoreCase))
                    {
                        return resource.Value;
                    }
                }
            }

            return null;
        }

        public void Create(ResourceDataSet resourceDataSet, bool validateOnly, bool autoCheckIn)
        {
            _Parent.WebServices.Resources.CreateResources(resourceDataSet, validateOnly, autoCheckIn);
        }

        /// <summary>
        /// Determine if the guid is present in the resource collection
        /// </summary>
        /// <param name="resourceGuid">The guid</param>
        /// <returns>True or false</returns>
        public bool ContainsKey(Guid resourceGuid)
        {
            if (_ResourceCollection == null)
            {
                LoadResourceCollection();
            }
            return _ResourceCollection.ContainsKey(resourceGuid);
        }

        /// <summary>
        /// Load custom field definitions defined for enterprise resources in Project Server
        /// </summary>
        public void LoadResourceCustomFields()
        {
            if (_CustomFields != null)
            {
                _CustomFields.Dispose();
            }

            _CustomFields = new CustomFieldDataSet();

            _CustomFields = Parent.WebServices.CustomFields.ReadCustomFieldsByEntity(new Guid(Utilities.GetEntityGuidStringFromName("Resource")));
        }

        /// <summary>
        /// Given a resource name, return its EnterpriseResource object
        /// </summary>
        /// <param name="resourceName">Resource name to search for</param>
        /// <returns>EnterpriseResource if found, null otherwise</returns>
        public EnterpriseResource GetResourceGuidByName(string resourceName)
        {
            if (_ResourceCollection == null)
            {
                LoadResourceCollection();
            }

            foreach (KeyValuePair<Guid, EnterpriseResource> enterpriseResource in _ResourceCollection)
            {
                if (enterpriseResource.Value.Name.Equals(resourceName, StringComparison.CurrentCultureIgnoreCase))
                {
                    return enterpriseResource.Value;
                }
            }

            return null;
        }

        public ResourceDataSet.ResourcesRow GetResourceGuidByAccount(string account)
        {
            using (ResourceDataSet resourceDataSet = _Parent.WebServices.Resources.ReadResources(ResourceFilters.ItemBasicInformationByAccount(account), false))
            {
                if (resourceDataSet == null || resourceDataSet.Resources.Rows.Count != 1)
                {
                    return null;
                }

                return (ResourceDataSet.ResourcesRow)resourceDataSet.Resources.Rows[0];
            }
        }


        /// <summary>
        /// Read resources from Project Server
        /// </summary>
        /// <param name="xmlFilter">The resource filter</param>
        /// <param name="autoCheckout">True to check out read resources, false to not</param>
        /// <returns>The ResourceDataSet</returns>
        public ResourceDataSet ReadResources(string xmlFilter, bool autoCheckout)
        {
            return Parent.WebServices.Resources.ReadResources(xmlFilter, autoCheckout);
        }

        #endregion

        #region Internal Methods

        /// <summary>
        /// Read basic resource information from Project Server and pop
        /// </summary>
        internal void LoadResourceCollection()
        {
            if (_ResourceCollection == null)
            {
                _ResourceCollection = new Dictionary<Guid, EnterpriseResource>();
            }
            else
            {
                _ResourceCollection.Clear();
            }

            using (ResourceDataSet resourceDataSet = Parent.WebServices.Resources.ReadResources(ResourceFilters.ListMinimumResourceInformation, false))
            {
                foreach (ResourceDataSet.ResourcesRow resource in resourceDataSet.Resources.Rows)
                {
                    _ResourceCollection.Add(resource.RES_UID, new EnterpriseResource(this, resource.RES_UID, resource.RES_NAME));
                }
            }
        }

        #endregion

        #region Internal Properties

        internal Resource ResourcesWebService
        {
            get { return Parent.WebServices.Resources; }
        }

        internal ProjectServer Parent
        {
            get { return _Parent; }
        }

        #endregion

        #region IEnumerable Implementation

        IEnumerator<Guid> IEnumerable<Guid>.GetEnumerator()
        {
            if (_ResourceCollection == null)
            {
                LoadResourceCollection();
            }

            foreach (KeyValuePair<Guid, EnterpriseResource> pair in _ResourceCollection)
            {
                yield return pair.Key;
            }
        }

        public IEnumerator GetEnumerator()
        {
            return ((IEnumerable<Guid>)this).GetEnumerator();
        }

        #endregion
    }
}

---