C:/Data/Projects/MCS EPM Global Practice/Frameworks/Public/mpfX/1.0/Libraries/Mcs.Epm.MicrosoftProject.mpFx/ProjectCollection.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 System.Diagnostics;
using System.Web.Services.Protocols;
using Mcs.Epm.MicrosoftProject.mpFx.CustomFieldsWebService;
using Mcs.Epm.MicrosoftProject.mpFx.ProjectsWebService;
using Mcs.Epm.MicrosoftProject.mpFx.QueueWebService;
using Project = Microsoft.Office.Project.Server.Library.Project;

namespace Mcs.Epm.MicrosoftProject.mpFx
{
    /// <summary>
    ///  Provides data and functionality for working with enterprise projects
    /// </summary>
    public class ProjectCollection : IEnumerable<EnterpriseProject>, IEnumerable<Guid>
    {
        #region Instance Data

        private Dictionary<Guid, EnterpriseProject> _projectsCollection;
        private CustomFieldDataSet _CustomFields;

        #endregion

        #region Internal Constructor

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

            Parent = parent;

        }

        #endregion

        #region Public Events

        public event EventHandler<ProjectReadCompleteArgs> OnProjectReadComplete;
        public event EventHandler<ProjectTeamReadArgs> OnProjectTeamReadComplete;

        #endregion

        #region Public Properties

        /// <summary>
        /// Given an integer index, return the project name
        /// </summary>
        /// <param name="index">Index</param>
        /// <returns>Project Name</returns>
        public EnterpriseProject this[int index]
        {
            get
            {
                if (_projectsCollection == null)
                {
                    LoadProjectCollection();
                }

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

                Dictionary<Guid, EnterpriseProject>.KeyCollection.Enumerator enumerator = _projectsCollection.Keys.GetEnumerator();

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

                return _projectsCollection[enumerator.Current];
            }
        }

        /// <summary>
        /// Given a project GUID, return the project name
        /// </summary>
        /// <param name="projectGuid">Project GUID</param>
        /// <returns>Project Name</returns>
        public EnterpriseProject this[Guid projectGuid]
        {
            get
            {
                if (_projectsCollection == null)
                {
                    LoadProjectCollection();
                }

                return _projectsCollection[projectGuid];
            }
        }

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

        #endregion

        #region Public Methods

        public bool TryGetProjectGuidByName(string name, ref Guid projectGuid)
        {
            if (_projectsCollection == null)
            {
                LoadProjectCollection();
            }

            foreach (KeyValuePair<Guid, EnterpriseProject> project in _projectsCollection)
            {
                if (project.Value.Name.Equals(name, StringComparison.CurrentCultureIgnoreCase))
                {
                    projectGuid = project.Value.ProjectGuid;
                    return true;
                }
            }

            return false;
        }

        public ProjectDataSet ReadProject(Guid guid,
                                          DataStoreEnum store,
                                          bool asynch)
        {
            if (asynch)
            {
                Parent.WebServices.Projects.ReadProjectCompleted += ProjectsReadProjectCompleted;
                Parent.WebServices.Projects.ReadProjectAsync(guid, store);
                return null;
            }

            ProjectDataSet projectDataSet = Parent.WebServices.Projects.ReadProject(guid, store);

            _projectsCollection[guid].CustomFieldsDataSet = projectDataSet.ProjectCustomFields;

            return projectDataSet;
        }

        /// <summary>
        /// Callback for ReadProject asynchronously
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void ProjectsReadProjectCompleted(object sender,
                                                  ReadProjectCompletedEventArgs e)
        {
            if (OnProjectReadComplete != null)
            {
                if (e.Cancelled == false && e.Error == null && e.Result != null)
                {
                    Debug.Assert(e.Result.Project.Count == 1);

                    _projectsCollection[e.Result.Project[0].PROJ_UID].CustomFieldsDataSet = e.Result.ProjectCustomFields;
                }

                OnProjectReadComplete(this, new ProjectReadCompleteArgs(e.Cancelled, e.Error, e.Result));
            }
            else
            {
                if (e.Result != null)
                {
                    e.Result.Dispose();
                }
            }
        }

        /// <summary>
        /// Read a project from Project Server.
        /// </summary>
        /// <param name="projectGuid">The project's GUID</param>
        /// <param name="store">The data store from which to read the project.</param>
        /// <param name="asynch">True to execute asynchronously, false otherwise</param>
        /// <param name="sessionDescription">The session description.</param>
        /// <param name="sessionGuid">Out parameter containing the session GUID</param>
        /// <returns>Project Data Set</returns>
        public ProjectDataSet ReadProject(Guid projectGuid,
                                          DataStoreEnum store,
                                          bool asynch,
                                          string sessionDescription,
                                          out Guid sessionGuid)
        {
            sessionGuid = Guid.NewGuid();

            Parent.WebServices.Projects.CheckOutProject(projectGuid, sessionGuid, sessionDescription);

            return ReadProject(projectGuid, store, asynch);
        }

        /// <summary>
        /// Create a project in Project Server.
        /// </summary>
        /// <param name="project">Project</param>
        /// <param name="validateOnly">Indicates whether the operation should validate only or perform the creation</param>
        /// <param name="wait">Indicates whether the call should wait on the queued job.</param>
        /// <returns>Queue job GUID</returns>
        public Guid Create(ProjectDataSet project,
                           bool validateOnly,
                           bool wait)
        {
            try
            {
                Guid jobGuid = Guid.NewGuid();

                Parent.WebServices.Projects.QueueCreateProject(jobGuid, project, validateOnly);                

                if (wait)
                {
                    string errorMessage;

                    Parent.Queue.WaitOnJobStatus(jobGuid,
                                                 JobState.Success,
                                                 Parent.Settings.QueueStatusRetryCount,
                                                 Parent.Settings.QueueStatusSleepDuration,
                                                 out errorMessage);

                    MpFxException.ThrowIfError(errorMessage, Parent.Log, LogArea.CreateProject, LogEntryType.Error);                    
                }

                return jobGuid;

            }
            catch (SoapException exception)
            {
                throw MpFxException.Create(exception, Parent.Log, LogArea.CreateProject, LogEntryType.Error);
            }
            catch (Exception exception)
            {
                throw MpFxException.Create(exception, Parent.Log, LogArea.CreateProject, LogEntryType.Error);
            }
        }

        /// <summary>
        /// Deletes a specific project from Project Server
        /// </summary>
        /// <param name="projectGuid">The GUID of the project to delete</param>
        /// <param name="deleteWSS">Indicates whether the associated SharePoint content will be deleted</param>
        /// <param name="deleteBoth">Indicates whether both the drafts and published versions of the project will be deleted</param>
        /// <param name="wait">Indicates whether the call should wait on the queued job.</param>
        /// <param name="errorString">Out parameter containing an error string if the queued job failed</param>
        /// <returns>True for succcess, false for failure</returns>
        public bool Delete(Guid projectGuid,
                           bool deleteWSS,
                           bool deleteBoth,
                           bool wait,
                           out string errorString)
        {
            Guid jobGuid = Guid.NewGuid();

            errorString = string.Empty;

            Parent.WebServices.Projects.QueueDeleteProjects(jobGuid, deleteWSS, new[] { projectGuid }, deleteBoth);

            _projectsCollection.Remove(projectGuid);

            if (wait)
            {
                return Parent.Queue.WaitOnJobStatus(jobGuid, JobState.Success, Parent.Settings.QueueStatusRetryCount, Parent.Settings.QueueStatusSleepDuration, out errorString);
            }

            errorString = "";
            return true;
        }

        /// <summary>
        /// Read the specified project's team from Project Server
        /// </summary>
        /// <param name="projectGuid">The GUID of the project to read</param>
        /// <param name="asynch">True to read asynchronously, false if not</param>
        /// <returns>If asynch = true, null; otherwise the resultant ProjectTeamDataSet</returns>
        public ProjectTeamDataSet ReadTeam(Guid projectGuid,
                                           bool asynch)
        {
            if (asynch)
            {
                Parent.WebServices.Projects.ReadProjectTeamCompleted += ProjectCollection_OnProjectTeamReadComplete;
                Parent.WebServices.Projects.ReadProjectTeamAsync(projectGuid);
                return null;
            }
            return Parent.WebServices.Projects.ReadProjectTeam(projectGuid);
        }

        /// <summary>
        /// Event handler for asynchronous calls to ReadTeam
        /// </summary>
        /// <param name="sender">This</param>
        /// <param name="e">Results</param>
        private void ProjectCollection_OnProjectTeamReadComplete(object sender,
                                                                 ReadProjectTeamCompletedEventArgs e)
        {
            if (OnProjectTeamReadComplete != null)
            {
                if (e.Cancelled == false && e.Error == null && e.Result != null)
                {
                    _projectsCollection[e.Result.ProjectTeam[0].PROJ_UID].ProjectTeamDataSet = e.Result;
                }

                if (e.Error == null)
                {
                    OnProjectTeamReadComplete(this, new ProjectTeamReadArgs(e.Cancelled, e.Error, e.Result));
                }
                else
                {
                    OnProjectTeamReadComplete(this, new ProjectTeamReadArgs(e.Cancelled, e.Error, null));
                }

                Parent.WebServices.Projects.ReadProjectTeamCompleted -= ProjectCollection_OnProjectTeamReadComplete;
            }
            else
            {
                if (e.Result != null)
                {
                    e.Result.Dispose();
                }
            }
        }

        /// <summary>
        /// Determines whether a specific project GUID exists in the projects collection
        /// </summary>
        /// <param name="projectGuid">The project GUID to search for</param>
        /// <returns>True if GUID is found, false if not.</returns>
        public bool ContainsKey(Guid projectGuid)
        {
            if (_projectsCollection == null)
            {
                LoadProjectCollection();
            }

            return _projectsCollection.ContainsKey(projectGuid);
        }

        /// <summary>
        /// Checks in the specified project.
        /// </summary>
        /// <param name="projectGuid">The GUID of the project to checkin</param>
        /// <param name="sessionGuid">The session GUID under which the project was originally checked out</param>
        /// <param name="force">Indicates whether the project checkin should be forced</param>
        /// <param name="wait">Indicates whether the call should wait on the queued job.</param>
        /// <param name="errorString">Out parameter containing error message if queued job fails</param>
        /// /// <returns>True for succcess, false for failure</returns>
        public bool CheckIn(Guid projectGuid,
                            Guid sessionGuid,
                            bool force,
                            bool wait,
                            out string errorString)
        {
            Guid jobGuid = Guid.NewGuid();
            errorString = string.Empty;

            Parent.WebServices.Projects.QueueCheckInProject(jobGuid, projectGuid, force, sessionGuid, Parent.Settings.DefaultSessionDescription);

            if (wait)
            {
                return Parent.Queue.WaitOnJobStatus(jobGuid, JobState.Success, Parent.Settings.QueueStatusRetryCount, Parent.Settings.QueueStatusSleepDuration, out errorString);
            }

            errorString = string.Empty;
            return true;
        }

        /// <summary>
        /// Determines whether the specified project is checked out to the current user
        /// </summary>
        /// <param name="projectGuid">The GUID of the project to check</param>
        /// <param name="store">The data store to check.</param>
        /// <returns>True if the project is checked out to the current user, false if not</returns>
        public bool IsProjectCheckedOutByCurrentUser(Guid projectGuid,
                                                     DataStoreEnum store)
        {
            using (ProjectDataSet project = Parent.WebServices.Projects.ReadProjectStatus(projectGuid, store, string.Empty, (int)Project.ProjectType.Project))
            {
                Debug.Assert(project.Project.Rows.Count == 1);

                if (project.Project[0].IsPROJ_CHECKOUTBYNull())
                {
                    return false;
                }

                return project.Project[0].PROJ_CHECKOUTBY == Parent.CurrentUserGuid;
            }
        }

        #endregion

        #region Private Methods

        private void LoadProjectCustomFields()
        {
            if (_CustomFields != null)
            {
                _CustomFields.Dispose();
            }

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

        #endregion

        #region Internal Methods

        /// <summary>
        /// Loads the projects collection from Project Server data.
        /// </summary>
        internal void LoadProjectCollection()
        {
            if (_projectsCollection == null)
            {
                _projectsCollection = new Dictionary<Guid, EnterpriseProject>();
            }
            else
            {
                _projectsCollection.Clear();
            }

            using (ProjectDataSet projectDataSet = Parent.WebServices.Projects.ReadProjectStatus(Guid.Empty, Parent.Store, string.Empty, (int)Project.ProjectType.Project))
            {
                foreach (ProjectDataSet.ProjectRow project in projectDataSet.Project.Rows)
                {
                    if (project.PROJ_UID != Guid.Empty)
                    {
                        _projectsCollection.Add(project.PROJ_UID, new EnterpriseProject(this, project.PROJ_UID, project.PROJ_NAME, Parent.Store));
                    }
                }
            }
        }

        #endregion

        #region Internal Properties

        /// <summary>
        /// Retrieve the parent object
        /// </summary>
        protected internal ProjectServer Parent { get; private set; }

        #endregion

        #region IEnumerable Implementation

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

        IEnumerator<Guid> IEnumerable<Guid>.GetEnumerator()
        {
            if (_projectsCollection == null)
            {
                LoadProjectCollection();
            }

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

        IEnumerator<EnterpriseProject> IEnumerable<EnterpriseProject>.GetEnumerator()
        {
            if (_projectsCollection == null)
            {
                LoadProjectCollection();
            }

            foreach (KeyValuePair<Guid, EnterpriseProject> pair in _projectsCollection)
            {
                yield return pair.Value;
            }
        }
        
        #endregion

        public void Refresh()
        {
            LoadProjectCollection();
        }

        public void CheckOut(Guid projectGuid, Guid sessionGuid, string sessionDescription)
        {
            Parent.WebServices.Projects.CheckOutProject(projectGuid, sessionGuid, sessionDescription);
        }

        public bool Publish(Guid guid, bool fullPublish, string wssUrl, bool wait, out string errorMessage)
        {
            Guid jobGuid = Guid.NewGuid();
            errorMessage = string.Empty;

            Parent.WebServices.Projects.QueuePublish(jobGuid, guid, fullPublish, wssUrl);

            if (wait)
            {
                return Parent.Queue.WaitOnJobStatus(jobGuid, JobState.Success, Parent.Settings.QueueStatusRetryCount, Parent.Settings.QueueStatusSleepDuration, out errorMessage);
            }

            return true;
        }

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

    }
}

---