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

namespace Mcs.Epm.MicrosoftProject.mpFx
{
    /// <summary>
    /// Wraps an enterprise project
    /// </summary>
    public class EnterpriseProject
    {
        #region Instance Data

        private ProjectCustomFieldsCollection _ProjectCustomFieldsCollection;
        private ProjectDataSet.ProjectCustomFieldsDataTable _CustomFields;

        private string _Filter;

        #endregion

        #region Constructors

        /// <summary>
        /// Protected constructor
        /// </summary>
        /// <param name="parent">ProjectCollection parent</param>
        /// <param name="projectGuid">GUID of the project</param>
        /// <param name="name">Name of the project</param>
        /// <param name="store">Store from which the project was read</param>
        protected internal EnterpriseProject(ProjectCollection parent,
                                             Guid projectGuid,
                                             string name,
                                             DataStoreEnum store)
        {
            ProjectGuid = projectGuid;
            Parent = parent;
            Name = name;
            DataStore = store;
        }

        #endregion

        #region Public Properties

        /// <summary>
        /// Retrieve and privately set the project name
        /// </summary>
        public string Name { get; private set; }

        /// <summary>
        /// Retrieve and privately set the project GUID
        /// </summary>
        public Guid ProjectGuid { get; private set; }

        /// <summary>
        /// Retrieve the custom field dataset
        /// </summary>
        public ProjectDataSet.ProjectCustomFieldsDataTable CustomFieldsDataSet
        {
            get
            {
                if (_CustomFields == null)
                {
                    LoadProjectCustomFields();
                }

                return _CustomFields;
            }
            protected internal set
            {
                if (_CustomFields != null)
                {
                    _CustomFields.Dispose();
                }
                _CustomFields = value;
            }
        }

        /// <summary>
        /// Retrieve and privately set the ProjectTeamData
        /// </summary>
        public ProjectTeamDataSet ProjectTeamDataSet { get; protected internal set; }

        /// <summary>
        /// Retrieve and privately set the data store
        /// </summary>
        public DataStoreEnum DataStore { get; private set; }

        /// <summary>
        /// Retrieve the project custom fields collection
        /// </summary>
        public ProjectCustomFieldsCollection ProjectCustomFieldsCollection
        {
            get
            {
                if (_ProjectCustomFieldsCollection == null)
                {
                    _ProjectCustomFieldsCollection = new ProjectCustomFieldsCollection(this);
                }

                return _ProjectCustomFieldsCollection;
            }
        }

        /// <summary>
        /// Read status information for the project
        /// </summary>
        public ProjectDataSet.ProjectRow StatusInformation
        {
            get
            {
                using (ProjectDataSet projectDataSet = Parent.Parent.WebServices.Projects.ReadProjectStatus(ProjectGuid, Parent.Parent.Store, string.Empty, (int)Project.ProjectType.Project))
                {
                    if (projectDataSet != null)
                    {
                        Trace.Assert(projectDataSet.Project.Rows.Count == 1);

                        return (ProjectDataSet.ProjectRow)projectDataSet.Project.Rows[0];
                    }
                }

                return null;
            }
        }


        public ProjectDataSet AllInformation
        {
            get
            {
                return Parent.Parent.WebServices.Projects.ReadProject(ProjectGuid, Parent.Parent.Store);
            }
        }

        public ProjectDataSet StandardInformation
        {
            get
            {
                return Parent.Parent.WebServices.Projects.ReadProjectEntities(ProjectGuid, (int)ProjectEntityType.Project, Parent.Parent.Store);
            }
        }

        #endregion

        #region Protected Properties

        /// <summary>
        /// Retrieve and privately set the Project Collection 
        /// </summary>
        protected internal ProjectCollection Parent { get; private set; }

        #endregion

        #region Public Methods

        /// <summary>
        /// Load the project custom fields from Project Server
        /// </summary>
        public void LoadProjectCustomFields()
        {
            using (ProjectDataSet projectDataSet = Parent.Parent.WebServices.Projects.ReadProjectEntities(ProjectGuid, (int) ProjectEntityType.ProjectCustomFields, Parent.Parent.Store))
            {                
                _CustomFields = projectDataSet.ProjectCustomFields;
            }
        }

        /// <summary>
        /// Set the filter which directs which fields to read from Project Server
        /// </summary>
        /// <param name="filter">The XML filter string</param>
        public void SetFilter(string filter)
        {
            if (!filter.Equals(_Filter, StringComparison.CurrentCultureIgnoreCase))
            {
                _Filter = filter;
            }
        }

        /// <summary>
        /// Create a task with a Must Start On constraint
        /// </summary>
        /// <param name="taskName">The name of the task</param>
        /// <param name="startDate">The start date</param>
        /// <param name="duration">The duration</param>
        /// <param name="checkOutProject">True to check out the project, false to assume checked out already</param>
        /// <param name="autoCheckIn">True to automatically check-in the project</param>
        /// <param name="sessionGuid">The session GUID</param>
        /// <param name="taskGuid">The task GUID</param>
        /// <param name="errorMessage">On out, the error message returned by the queue</param>
        /// <returns>True or false</returns>
        public bool CreateTask(string taskName,
                               DateTime startDate,
                               int duration,
                               bool checkOutProject,
                               bool autoCheckIn,
                               Guid sessionGuid,
                               out Guid taskGuid,
                               out string errorMessage)
        {
            errorMessage = string.Empty;
            taskGuid = Guid.Empty;
            bool checkedOut = false;

            try
            {
                if (checkOutProject)
                {
                    Parent.Parent.Projects.CheckOut(ProjectGuid, sessionGuid, Parent.Parent.Settings.DefaultSessionDescription);
                    checkedOut = true;
                }

                using (ProjectDataSet projectDataSet = new ProjectDataSet())
                {
                    ProjectDataSet.TaskRow task = projectDataSet.Task.NewTaskRow();

                    taskGuid = Guid.NewGuid();

                    task.PROJ_UID = ProjectGuid;
                    task.TASK_UID = taskGuid;
                    task.TASK_NAME = taskName;
                    task.TASK_START_DATE = startDate;
                    task.TASK_CONSTRAINT_DATE = startDate;
                    task.TASK_CONSTRAINT_TYPE = (short)Task.ConstraintType.MustStartOn;
                    task.TASK_DUR_IS_EST = false;
                    task.TASK_IS_EFFORT_DRIVEN = false;
                    task.TASK_IS_MILESTONE = false;
                    task.TASK_WORK = duration;
                    task.TASK_DUR = duration;

                    task.AddPosition = (int)Task.AddPositionType.Last;

                    projectDataSet.Task.AddTaskRow(task);

                    Guid jobGuid = Guid.NewGuid();

                    Parent.Parent.WebServices.Projects.QueueAddToProject(jobGuid, sessionGuid, projectDataSet, false);

                    if (!Parent.Parent.Queue.WaitOnJobStatus(jobGuid,
                                                             JobState.Success,
                                                             Parent.Parent.Settings.QueueStatusRetryCount,
                                                             Parent.Parent.Settings.QueueStatusSleepDuration,
                                                             out errorMessage))
                    {

                        return false;
                    }
                }

                return true;
            }
            finally
            {
                if (checkedOut && autoCheckIn)
                {
                    Parent.Parent.Projects.CheckIn(ProjectGuid, sessionGuid, false, true, out errorMessage);
                }
            }
        }

        /// <summary>
        /// Create an assignment
        /// </summary>
        /// <param name="assignmentGuid">The assignment GUID</param>
        /// <param name="taskGuid">The task GUID</param>
        /// <param name="resourceGuid">The resource GUID</param>
        /// <param name="autoAddResourceToTeam">True to automatically add the resource to the project team</param>
        /// <param name="checkOutProject">True to check out the project, false to assume checked out already</param>
        /// <param name="autoCheckIn">True to automatically check-in the project</param>
        /// <param name="sessionGuid">The session GUID</param>
        /// <param name="taskGuid">The task GUID</param>
        /// <param name="errorMessage">On out, the error message returned by the queue</param>
        /// <returns>True or false</returns>
        public bool CreateAssignment(Guid assignmentGuid,
                                     Guid taskGuid,
                                     Guid resourceGuid,
                                     bool autoAddResourceToTeam,
                                     bool checkOutProject,
                                     bool autoCheckIn,
                                     Guid sessionGuid,
                                     out string errorMessage)
        {
            bool checkedOut = false;
            bool forceCheckIn = false;
            errorMessage = string.Empty;

            try
            {
                if (checkOutProject)
                {
                    Parent.Parent.Projects.CheckOut(ProjectGuid, sessionGuid, Parent.Parent.Settings.DefaultSessionDescription);
                    checkedOut = true;
                }

                using (ProjectDataSet projectDataSet = new ProjectDataSet())
                using (ProjectTeamDataSet projectTeamDataSet = Parent.Parent.Projects.ReadTeam(ProjectGuid, false))
                {
                    if (projectTeamDataSet.ProjectTeam.FindByRES_UIDPROJ_UID(resourceGuid, ProjectGuid) == null)
                    {
                        if (autoAddResourceToTeam)
                        {
                            if (!AddResourceToTeam(sessionGuid, projectTeamDataSet, resourceGuid, true, out errorMessage))
                            {
                                return false;
                            }
                        }
                        else
                        {
                            errorMessage = "Resource is not assigned to the project team";
                            return false;
                        }
                    }

                    ProjectDataSet.AssignmentRow assignment = projectDataSet.Assignment.NewAssignmentRow();

                    assignment.PROJ_UID = ProjectGuid;
                    assignment.TASK_UID = taskGuid;
                    assignment.RES_UID = resourceGuid;
                    assignment.ASSN_UID = assignmentGuid;

                    projectDataSet.Assignment.AddAssignmentRow(assignment);

                    Guid jobGuid = Guid.NewGuid();

                    Parent.Parent.WebServices.Projects.QueueAddToProject(jobGuid, sessionGuid, projectDataSet, false);

                    if (!Parent.Parent.Queue.WaitOnJobStatus(jobGuid,
                                                             JobState.Success,
                                                             Parent.Parent.Settings.QueueStatusRetryCount,
                                                             Parent.Parent.Settings.QueueStatusSleepDuration,
                                                             out errorMessage))
                    {

                        forceCheckIn = errorMessage.Contains("AssignmentAlreadyExists");

                        if (forceCheckIn)
                        {
                            Parent.Parent.WebServices.Queue.CancelJob(jobGuid, true, true);
                        }

                        return false;
                    }
                }
                return true;
            }
            finally
            {
                if (checkedOut && autoCheckIn)
                {
                    try
                    {
                        string checkinError;
                        Parent.Parent.Projects.CheckIn(ProjectGuid, sessionGuid, forceCheckIn, true, out checkinError);
                    }
                    catch (SoapException)
                    {

                    }
                }
            }
        }

        /// <summary>
        /// Set a task custom field value to a valid lookup table item GUID
        /// </summary>
        /// <param name="sessionGuid">The session GUID</param>
        /// <param name="taskGuid">The task GUID</param>
        /// <param name="customFieldGuid">The custom field GUID</param>
        /// <param name="lookupTableValueGuid">The GUID of the lookup table item</param>
        public void SetTaskCustomFieldValue(Guid sessionGuid, Guid taskGuid, Guid customFieldGuid, Guid lookupTableValueGuid)
        {
            using (ProjectDataSet projectDataSet = new ProjectDataSet())
            {
                ProjectDataSet.TaskCustomFieldsRow customField =
                    projectDataSet.TaskCustomFields.NewTaskCustomFieldsRow();

                customField.CODE_VALUE = lookupTableValueGuid;
                customField.CUSTOM_FIELD_UID = Guid.NewGuid();
                customField.MD_PROP_UID = customFieldGuid;
                customField.PROJ_UID = ProjectGuid;
                customField.TASK_UID = taskGuid;
                customField.FIELD_TYPE_ENUM = (int)PSDataType.STRING;

                projectDataSet.TaskCustomFields.AddTaskCustomFieldsRow(customField);

                Guid jobGuid = Guid.NewGuid();

                Parent.Parent.WebServices.Projects.QueueAddToProject(jobGuid, sessionGuid, projectDataSet, false);
            }
        }

        /// <summary>
        /// Set a task complete
        /// </summary>
        /// <param name="taskGuid">The task GUID</param>
        /// <param name="durationInSeconds">Duration in seconds</param>
        /// <param name="sessionGuid">The session GUID</param>
        /// <param name="wait">True to wait for the operation to complete</param>
        /// <param name="errorMessage">If wait = true, the error message returned by the queue if the operation fails</param>
        /// <returns>True or false</returns>
        public bool SetTaskComplete(Guid taskGuid, int durationInSeconds, Guid sessionGuid, bool wait, out string errorMessage)
        {
            errorMessage = string.Empty;

            using (ProjectDataSet projectDataSet = Parent.Parent.WebServices.Projects.ReadProjectEntities(ProjectGuid, (int)ProjectEntityType.Task, DataStoreEnum.WorkingStore))
            {
                ProjectDataSet.TaskRow task = projectDataSet.Task.FindByTASK_UIDPROJ_UID(taskGuid, ProjectGuid);

                task.TASK_DUR = task.TASK_DUR + durationInSeconds;
                task.TASK_DUR_IS_EST = false;
                task.TASK_PCT_WORK_COMP = 100;

                Guid jobGuid = Guid.NewGuid();

                Parent.Parent.WebServices.Projects.QueueUpdateProject(jobGuid, sessionGuid, projectDataSet, false);

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

            }

            return true;
        }

        /// <summary>
        /// Update task work actual duration
        /// </summary>
        /// <param name="taskGuid">The task GUID</param>
        /// <param name="duration">The duration in seconds</param>
        /// <param name="sessionGuid">The session GUID</param>
        /// <param name="wait">True to wait for the operation to complete</param>
        /// <param name="errorMessage">If wait = true, the error message returned by the queue if the operation fails</param>
        /// <returns>True or false</returns>
        public bool UpdateTaskWorkToActualWorkWithDuration(Guid taskGuid, double duration, Guid sessionGuid, bool wait, out string errorMessage)
        {
            errorMessage = string.Empty;

            using (ProjectDataSet projectDataSet = Parent.Parent.WebServices.Projects.ReadProjectEntities(ProjectGuid, (int)ProjectEntityType.Task, DataStoreEnum.WorkingStore))
            {
                ProjectDataSet.TaskRow task = projectDataSet.Task.FindByTASK_UIDPROJ_UID(taskGuid, ProjectGuid);

                task.TASK_WORK = task.TASK_ACT_WORK + duration;

                Guid jobGuid = Guid.NewGuid();

                Parent.Parent.WebServices.Projects.QueueUpdateProject(jobGuid, sessionGuid, projectDataSet, false);

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

            }

            return true;
        }

        #endregion

        #region Private Methods

        /// <summary>
        /// Add a resource to a project team
        /// </summary>
        /// <param name="sessionGuid">The session GUID</param>
        /// <param name="projectTeamDataSet">The project team dataset</param>
        /// <param name="resourceGuid">The resource GUID</param>
        /// <param name="wait">True to wait for the operation to complete</param>
        /// <param name="errorMessage">If wait = true, the error message returned by the queue if the operation fails</param>
        /// <returns>True or false</returns>
        private bool AddResourceToTeam(Guid sessionGuid, ProjectTeamDataSet projectTeamDataSet, Guid resourceGuid, bool wait, out string errorMessage)
        {
            errorMessage = string.Empty;

            ProjectTeamDataSet.ProjectTeamRow teamMember = projectTeamDataSet.ProjectTeam.NewProjectTeamRow();

            teamMember.RES_UID = resourceGuid;
            teamMember.PROJ_UID = ProjectGuid;
            teamMember.NEW_RES_UID = resourceGuid;
            teamMember.RES_IS_ENTERPRISE_RESOURCE = true;
            teamMember.RES_TYPE = (int)Resource.Type.WorkResource;

            projectTeamDataSet.ProjectTeam.AddProjectTeamRow(teamMember);

            Guid jobGuid = Guid.NewGuid();
            Parent.Parent.WebServices.Projects.QueueUpdateProjectTeam(jobGuid, sessionGuid, ProjectGuid, projectTeamDataSet);

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

                    return false;
                }
            }
            return true;
        }

        #endregion

    }
}

---