C:/Data/Projects/MCS EPM Global Practice/Frameworks/Public/mpfX/1.0/Libraries/Mcs.Epm.MicrosoftProject.mpFx/ProjectServer.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.Net;
using System.Reflection;
using System.Resources;
using System.Security;
using System.Web.Services.Protocols;
using Mcs.Epm.MicrosoftProject.mpFx.Interfaces;
using Mcs.Epm.MicrosoftProject.mpFx.LoginFormsWebService;
using Mcs.Epm.MicrosoftProject.mpFx.LoginWindowsWebService;
using Mcs.Epm.MicrosoftProject.mpFx.ProjectsWebService;
using LibraryResources = Mcs.Epm.MicrosoftProject.mpFx.Properties.Resources;

[assembly: CLSCompliant(true)]
namespace Mcs.Epm.MicrosoftProject.mpFx
{
    /// <summary>
    /// Class library to wrap and extend the Microsoft Office Project Server Interface
    /// </summary>
    public class ProjectServer : IDisposable
    {        
        #region Static Fields

        internal static readonly ResourceManager _ResourceManager = new ResourceManager("Mcs.Epm.MicrosoftProject.mpFx.Properties.Resources",
                                                                                        Assembly.GetAssembly(typeof(ProjectServer)));

        #endregion

        #region Public Static Methods

        public static ProjectProfiles ImportProjectProfiles()
        {
            return new ProjectProfiles(true);
        }

        #endregion

        #region Instance Data

        #region General

        private bool _Disposed;
        private readonly ILog _Log;
        private Guid _CurrentUserGuid;

        #endregion

        #region Object Model

        private Calendars _CalendarsCollection;
        private CustomFields _CustomFields;
        private LookupTables _LookupTables;
        private Timesheets _Timesheet;
        private Events _Events;
        private ProjectCollection _ProjectCollection;
        private Queue _Queue;
        private ResourceCollection _ResourceCollection;
        private Security _Security;
        
        #endregion

        #endregion

        #region Constructors

        /// <summary>
        /// Constructor for Windows authentication
        /// </summary>
        /// <param name="projectServerUrl">Project Server URL</param>
        /// <param name="store">The store on which subsequent operations will be executed.</param>
        /// <param name="log">Log object</param>
        public ProjectServer(string projectServerUrl, DataStoreEnum store, ILog log)
        {            
            try
            {
                _Log = log;

                if (!Utilities.IsValidUrl(projectServerUrl))
                {
                    throw new ArgumentException(LibraryResources.InvalidProjectServerUrl);
                }

                Settings = new ProjectServerSettings();
                WebServices = new WebServices(this);
                Site = new Uri(projectServerUrl);
                Store = store;

                NetworkCredential = CredentialCache.DefaultNetworkCredentials;
                AuthenticationType = AuthenticationType.Windows;

                WebServices.LoginWindows = new LoginWindows
                {
                    Url = WebServices.AppendPath(projectServerUrl, ServicePaths.WindowsLoginService),
                    UseDefaultCredentials = true
                };

                WriteLogEntry(LogArea.Constructor, 
                    LogEntryType.Information, 
                    string.Format(LibraryResources.LogConstructor, AuthenticationType, projectServerUrl));

                WebServices.LoginWindows.Login();

                Settings.ListSeparator = WebServices.Projects.ReadServerListSeparator();

            }
            catch (SoapException exception)
            {
                throw MpFxException.Create(exception, _Log, LogArea.Constructor, LogEntryType.Error);
            }
            catch (ArgumentException exception)
            {
                throw MpFxException.Create(exception, _Log, LogArea.Constructor, LogEntryType.Error);
            }
            catch (Exception exception)
            {
                throw MpFxException.Create(exception, _Log, LogArea.Constructor, LogEntryType.Error);
            }
        }

        /// <summary>
        /// Constructor used with Forms authentication
        /// </summary>
        /// <param name="projectServerUrl">URL to the Project Server instance</param>
        /// <param name="userName">User name</param>
        /// <param name="password">Pasword</param>
        /// <param name="store">The store to operate on</param>
        /// <param name="log">Log object</param>
        public ProjectServer(string projectServerUrl,
                             string userName,
                             string password,
                             DataStoreEnum store, ILog log)
        {
            _Log = log;
            WebServices = new WebServices(this);
            Settings = new ProjectServerSettings();
            Store = store;

            Site = new Uri(projectServerUrl);

            string servicePath = WebServices.AppendPath(projectServerUrl, ServicePaths.FormsLoginService);

            AuthenticationType = AuthenticationType.Forms;

            WebServices.LoginForms = new LoginForms { Url = servicePath };

            // Even though we are not using Windows authentication, we populate _NetworkCredential for the UserName property
            NetworkCredential = new NetworkCredential(userName, password);

            CookieContainer = new CookieContainer();

            WebServices.LoginForms.CookieContainer = CookieContainer;

            if (WebServices.LoginForms.Login(userName, password))
            {
                Settings.ListSeparator = WebServices.Projects.ReadServerListSeparator();
            }
            else
            {
                AuthenticationType = AuthenticationType.NotAuthenticated;

                throw new SecurityException(_ResourceManager.GetString("FormsAuthenticationFailed"));
            }
        }

        /// <summary>
        /// Constructor used for impersonation
        /// </summary>
        /// <param name="projectServerUrl"></param>
        /// <param name="sspBaseUrl"></param>
        /// <param name="store"></param>
        /// <param name="log">Log object</param>
        public ProjectServer(string projectServerUrl, string sspBaseUrl, DataStoreEnum store, ILog log)
        {
            _Log = log;
            Site = new Uri(projectServerUrl);
            SPPBaseURL = sspBaseUrl;

            Store = store;
            WebServices = new WebServices(this);
            Settings = new ProjectServerSettings();

            AuthenticationType = AuthenticationType.Windows;

            try
            {
                string siteURL;
                string siteID;

                WebServices.SiteData.GetSiteUrl(projectServerUrl, out siteURL, out siteID);
                SiteID = new Guid(siteID);

                IsImpersonating = true;
            }
            catch (Exception exception)
            {
                Debug.WriteLine(exception.Message);
                throw;
            }
        }

        public ProjectServer(string projectServerUrl, string sspBaseUrl, Guid siteGuid, DataStoreEnum store)
        {
            Site = new Uri(projectServerUrl);
            SPPBaseURL = sspBaseUrl;

            Store = store;
            WebServices = new WebServices(this);
            Settings = new ProjectServerSettings();

            AuthenticationType = AuthenticationType.Windows;

            SiteID = siteGuid;

            IsImpersonating = true;
        }

        internal string SPPBaseURL { get; set; }

        public Guid SiteID { get; set; }

        #endregion

        #region Public Events

        #endregion

        #region Public Properties

        public ProjectServerSettings Settings { get; private set; }

        public DataStoreEnum Store { get; private set; }

        public AuthenticationType AuthenticationType { get; private set; }

        public Uri Site { get; private set; }

        public string UserName
        {
            get
            {
                switch (AuthenticationType)
                {
                    case AuthenticationType.NotAuthenticated:
                        return string.Empty;
                    case AuthenticationType.Windows:
                        return string.Format(@"{0}\{1}", NetworkCredential.Domain, NetworkCredential.UserName);

                    case AuthenticationType.Forms:
                        return NetworkCredential.UserName;

                    default:
                        throw new InvalidOperationException();
                }
            }
        }

        public Guid CurrentUserGuid
        {
            get
            {
                if (_CurrentUserGuid == Guid.Empty)
                {
                    _CurrentUserGuid = WebServices.Resources.GetCurrentUserUid();
                }

                return _CurrentUserGuid;
            }
        }

        public ProjectCollection Projects
        {
            get
            {
                if (_ProjectCollection == null)
                {
                    _ProjectCollection = new ProjectCollection(this);
                }

                return _ProjectCollection;
            }
        }

        public CustomFields CustomFields
        {
            get
            {
                if (_CustomFields == null)
                {
                    _CustomFields = new CustomFields(this);
                }

                return _CustomFields;
            }
        }

        public ResourceCollection Resources
        {
            get
            {
                if (_ResourceCollection == null)
                {
                    _ResourceCollection = new ResourceCollection(this);
                }

                return _ResourceCollection;
            }
        }

        public LookupTables LookupTables
        {
            get
            {
                if (_LookupTables == null)
                {
                    _LookupTables = new LookupTables(this, true);
                }

                return _LookupTables;
            }
        }

        public Queue Queue
        {
            get
            {
                if (_Queue == null)
                {
                    _Queue = new Queue(this);
                }

                return _Queue;
            }
        }

        public Security Security
        {
            get
            {
                if (_Security == null)
                {
                    _Security = new Security(this);
                }

                return _Security;
            }
        }

        public Calendars Calendars
        {
            get
            {
                if (_CalendarsCollection == null)
                {
                    _CalendarsCollection = new Calendars(this);
                }

                return _CalendarsCollection;
            }
        }
        public Timesheets Timesheets
        {
            get
            {
                if (_Timesheet == null)
                {
                    _Timesheet = new Timesheets(this);
                }

                return _Timesheet;
            }
        }
        public Events Events
        {
            get
            {

                if (_Events == null)
                {
                    _Events = new Events(this);
                }

                return _Events;
            }
        }

        #endregion

        #region Internal Properties

        public WebServices WebServices { get; private set; }

        protected internal NetworkCredential NetworkCredential { get; private set; }

        protected internal CookieContainer CookieContainer { get; private set; }

        #endregion

        #region Public Methods

        public bool IsImpersonating { get; private set; }

        public ILog Log
        {
            get { return _Log; }
        }

        /// <summary>
        /// Disposal
        /// </summary>
        public void Dispose()
        {
            Dispose(true);
            GC.SuppressFinalize(this);
        }

        public void SetImpersonationContext(bool isWindowsUser,
                                                   string userName,
                                                   Guid userGuid,
                                                   Guid trackingGuid,
                                                   Guid siteGuid,
                                                   string lcid)
        {



            WebServices.Calendars.SetImpersonationContext(isWindowsUser, userName, userGuid, trackingGuid, siteGuid, lcid);
            WebServices.CustomFields.SetImpersonationContext(isWindowsUser, userName, userGuid, trackingGuid, siteGuid, lcid);
            WebServices.LookupTables.SetImpersonationContext(isWindowsUser, userName, userGuid, trackingGuid, siteGuid, lcid);
            WebServices.Projects.SetImpersonationContext(isWindowsUser, userName, userGuid, trackingGuid, siteGuid, lcid);
            WebServices.Resources.SetImpersonationContext(isWindowsUser, userName, userGuid, trackingGuid, siteGuid, lcid);
            WebServices.Statusing.SetImpersonationContext(isWindowsUser, userName, userGuid, trackingGuid, siteGuid, lcid);
            WebServices.Queue.SetImpersonationContext(isWindowsUser, userName, userGuid, trackingGuid, siteGuid, lcid);
            WebServices.Security.SetImpersonationContext(isWindowsUser, userName, userGuid, trackingGuid, siteGuid, lcid);
            WebServices.Timesheet.SetImpersonationContext(isWindowsUser, userName, userGuid, trackingGuid, siteGuid, lcid);
            WebServices.Administration.SetImpersonationContext(isWindowsUser, userName, userGuid, trackingGuid, siteGuid, lcid);
        }

        public void ClearImpersonation()
        {
            WebServices.Calendars.ContextString = null;
            WebServices.CustomFields.ContextString = null;
            WebServices.LookupTables.ContextString = null;
            WebServices.Projects.ContextString = null;
            WebServices.Resources.ContextString = null;
            WebServices.Statusing.ContextString = null;
            WebServices.Queue.ContextString = null;
            WebServices.Security.ContextString = null;
        }

        /// <summary>
        /// Causes full refresh on the object model
        /// </summary>
        public void Refresh()
        {
            DisposeResourceCollection();

            if (_ResourceCollection == null)
            {
                _ResourceCollection = new ResourceCollection(this);
            }

            _ResourceCollection.LoadResourceCollection();
            _ResourceCollection.LoadResourceCustomFields();

            if (_ProjectCollection == null)
            {
                _ProjectCollection = new ProjectCollection(this);
            }

            _ProjectCollection.LoadProjectCollection();

            if (_CalendarsCollection == null)
            {
                _CalendarsCollection = new Calendars(this);
            }

            _CalendarsCollection.LoadCalendars();

            _CustomFields = null;
        }

        public Guid GetSiteGuid()
        {
            try
            {
                string siteURL;
                string siteID;

                WebServices.SiteData.GetSiteUrl(Site.OriginalString, out siteURL, out siteID);

                return new Guid(siteID);
            }
            catch (Exception exception)
            {
                Debug.WriteLine(exception.Message);
                throw;
            }
        }

        #endregion

        #region Private Methods

        private void Dispose(bool disposing)
        {
            if (!_Disposed)
            {
                if (disposing)
                {
                    try
                    {
                        switch (AuthenticationType)
                        {
                            case AuthenticationType.NotAuthenticated:
                                break;
                            case AuthenticationType.Windows:
                                if (WebServices.LoginWindows != null)
                                {
                                    WebServices.LoginWindows.Logoff();
                                }
                                break;
                            case AuthenticationType.Forms:
                                if (WebServices.LoginForms != null)
                                {
                                    WebServices.LoginForms.Logoff();
                                }
                                break;
                            default:
                                break;
                        }

                        WebServices.Dispose(WebServices.LoginWindows);
                        WebServices.Dispose(WebServices.LoginForms);
                        WebServices.Dispose(WebServices.Projects);
                        WebServices.Dispose(WebServices.Resources);
                        WebServices.Dispose(WebServices.CustomFields);
                        WebServices.Dispose(WebServices.LookupTables);

                        DisposeResourceCollection();
                    }
                    catch (Exception exception)
                    {
                        Debug.WriteLine(exception.Message);
                        Debug.WriteLine(exception.StackTrace);

                        /*  Swallow */
                    }
                }

                _Disposed = true;
            }
        }

        private void DisposeResourceCollection()
        {
            if (_ResourceCollection != null)
            {
                foreach (Guid index in _ResourceCollection)
                {
                    _ResourceCollection[index].Dispose();
                }
            }
        }

        #endregion

        internal void WriteLogEntry(LogArea logArea, LogEntryType type, string message)
        {
            if (_Log != null)
            {
                if (type == LogEntryType.Information && !_Log.Verbose)
                {
                    return;
                }

                _Log.WriteEntry(logArea, type, message);
            }
        }
    }
}

---