C:/Data/Projects/MCS EPM Global Practice/Frameworks/Public/mpfX/1.0/Libraries/Mcs.Epm.MicrosoftProject.mpFx/WebServices.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.Net;
using System.Web.Services.Protocols;
using Mcs.Epm.MicrosoftProject.mpFx.LoginFormsWebService;
using Mcs.Epm.MicrosoftProject.mpFx.LoginWindowsWebService;
using Mcs.Epm.MicrosoftProject.mpFx.Proxies;
using Mcs.Epm.MicrosoftProject.mpFx.SiteDataWebService;

using LibraryResources = Mcs.Epm.MicrosoftProject.mpFx.Properties.Resources;

namespace Mcs.Epm.MicrosoftProject.mpFx
{
    /// <summary>
    /// Wraps the PSI web services
    /// </summary>
    public class WebServices
    {
        #region Private Static Methods

        /// <summary>
        /// Return a Project Server instance URL plus a path
        /// </summary>
        /// <param name="url">Base url</param>
        /// <param name="path">Path to append</param>
        /// <returns></returns>
        internal static string AppendPath(string url,
                                          string path)
        {
            if (!url.EndsWith("/", StringComparison.OrdinalIgnoreCase))
            {
                url = url + "/";
            }

            return url + path;
        }

        #endregion

        #region Instance Data

        private ProjectServer _Parent;
        private CustomFieldsProxy _CustomFieldsWebService;
        private LookupTableProxy _LookupTablesWebService;
        private ProjectProxy _ProjectWebService;
        private QueueSystemProxy _QueueWebService;
        private ResourceProxy _ResourceWebService;
        private CalendarProxy _CalendarsWebService;
        private SecurityProxy _SecurityWebService;
        private StatusingProxy _StatusingWebService;
        private SiteData _SiteDataWebService;
        private AdminProxy _AdminProxy;
        private TimesheetProxy _TimesheetProxy;
        private EventsProxy _EventsProxy;

        #endregion

        #region Constructor

        /// <summary>
        /// Construct an instance of Services
        /// </summary>
        /// <param name="parent">_Parent Object</param>
        internal WebServices(ProjectServer parent)
        {
            _Parent = parent;
        }

        #endregion

        #region public Properties

        /*  ------------------------------------------------------------------------ 
         *  On Services' Properties
         *  ------------------------------------------------------------------------
         *  With the exception of LoginWindows, LoginForms, and Projects, the 
         *  property gets are lazy loaded.  LoginWindows, LoginForms, and Projects
         *  are instantiated in the ProjectServer contructors.
         *  ------------------------------------------------------------------------
         */

        public LoginWindows LoginWindows { get; set; }

        public LoginForms LoginForms { get; set; }

        public ProjectProxy Projects
        {
            get
            {
                if (_ProjectWebService == null)
                {
                    _ProjectWebService = new ProjectProxy();

                    if (_Parent.IsImpersonating)
                    {
                        ConfigureService(_ProjectWebService, LocalServicePaths.ProjectService, true);
                    }
                    else
                    {
                        ConfigureService(_ProjectWebService, ServicePaths.ProjectService, true);
                    }
                }

                return _ProjectWebService;
            }
            set { _ProjectWebService = value; }
        }

        public ResourceProxy Resources
        {
            get
            {
                if (_ResourceWebService == null)
                {
                    _ResourceWebService = new ResourceProxy();

                    if (_Parent.IsImpersonating)
                    {
                        ConfigureService(_ResourceWebService, LocalServicePaths.ResourceService, true);
                    }
                    else
                    {
                        ConfigureService(_ResourceWebService, ServicePaths.ResourceService, true);
                    }

                }

                return _ResourceWebService;
            }
        }

        public CustomFieldsProxy CustomFields
        {
            get
            {
                if (_CustomFieldsWebService == null)
                {
                    _CustomFieldsWebService = new CustomFieldsProxy();

                    if (_Parent.IsImpersonating)
                    {
                        ConfigureService(_CustomFieldsWebService, LocalServicePaths.CustomFieldsService, true);
                    }
                    else
                    {
                        ConfigureService(_CustomFieldsWebService, ServicePaths.CustomFieldsService, true);
                    }
                }
                return _CustomFieldsWebService;
            }
        }

        public LookupTableProxy LookupTables
        {
            get
            {
                if (_LookupTablesWebService == null)
                {
                    _LookupTablesWebService = new LookupTableProxy();

                    if (_Parent.IsImpersonating)
                    {
                        ConfigureService(_LookupTablesWebService, LocalServicePaths.LookupTableService, true);
                    }
                    else
                    {
                        ConfigureService(_LookupTablesWebService, ServicePaths.LookupTableService, true);
                    }
                }

                return _LookupTablesWebService;
            }
        }

        public QueueSystemProxy Queue
        {
            get
            {
                if (_QueueWebService == null)
                {
                    _QueueWebService = new QueueSystemProxy();

                    if (_Parent.IsImpersonating)
                    {
                        ConfigureService(_QueueWebService, LocalServicePaths.QueueService, true);
                    }
                    else
                    {
                        ConfigureService(_QueueWebService, ServicePaths.QueueService, true);
                    }
                }

                return _QueueWebService;
            }
        }

        public CalendarProxy Calendars
        {
            get
            {
                if (_CalendarsWebService == null)
                {
                    _CalendarsWebService = new CalendarProxy();

                    if (_Parent.IsImpersonating)
                    {
                        ConfigureService(_CalendarsWebService, LocalServicePaths.CalendarsService, true);
                    }
                    else
                    {
                        ConfigureService(_CalendarsWebService, ServicePaths.CalendarsService, true);
                    }
                }

                return _CalendarsWebService;
            }
        }

        public SecurityProxy Security
        {
            get
            {
                if (_SecurityWebService == null)
                {
                    _SecurityWebService = new SecurityProxy();

                    if (_Parent.IsImpersonating)
                    {
                        ConfigureService(_SecurityWebService, LocalServicePaths.SecurityWebService, true);
                    }
                    else
                    {
                        ConfigureService(_SecurityWebService, ServicePaths.SecurityWebService, true);
                    }
                }

                return _SecurityWebService;
            }
        }

        public StatusingProxy Statusing
        {
            get
            {
                if (_StatusingWebService == null)
                {
                    _StatusingWebService = new StatusingProxy();

                    if (_Parent.IsImpersonating)
                    {
                        ConfigureService(_StatusingWebService, LocalServicePaths.StatusingWebService, true);
                    }
                    else
                    {
                        ConfigureService(_StatusingWebService, ServicePaths.StatusingWebService, true);
                    }
                }

                return _StatusingWebService;
            }
        }

        public SiteData SiteData
        {
            get
            {
                if (_SiteDataWebService == null)
                {
                    _SiteDataWebService = new SiteData();

                    ConfigureService(_SiteDataWebService, ServicePaths.SiteDataWebService, false);
                }

                return _SiteDataWebService;
            }
        }

        public TimesheetProxy Timesheet
        {
            get
            {
                if (_TimesheetProxy == null)
                {
                    _TimesheetProxy = new TimesheetProxy();

                    if (_Parent.IsImpersonating)
                    {
                        ConfigureService(_TimesheetProxy, LocalServicePaths.TimesheetWebService, true);
                    }
                    else
                    {
                        ConfigureService(_TimesheetProxy, ServicePaths.TimesheetWebService, true);
                    }
                }

                return _TimesheetProxy;
            }
        }

        public AdminProxy Administration
        {
            get
            {
                if (_AdminProxy == null)
                {
                    _AdminProxy = new AdminProxy();

                    if (_Parent.IsImpersonating)
                    {
                        ConfigureService(_AdminProxy, LocalServicePaths.AdminWebService, true);
                    }
                    else
                    {
                        ConfigureService(_AdminProxy, ServicePaths.AdminWebService, true);
                    }
                }

                return _AdminProxy;
            }
        }

        public EventsProxy Events
        {
            get
            {
                if (_EventsProxy == null)
                {
                    _EventsProxy = new EventsProxy();

                    if (_Parent.IsImpersonating)
                    {
                        ConfigureService(_EventsProxy, LocalServicePaths.EventsWebService, true);
                    }
                    else
                    {
                        ConfigureService(_EventsProxy, ServicePaths.EventsWebService, true);
                    }
                }

                return _EventsProxy;
            }
        }

        #endregion

        #region Private Methods

        /// <summary>
        /// Given a service, configure the URL and security properties
        /// </summary>
        /// <param name="service">The service to configure</param>
        /// <param name="servicePath">The service path to append to the _Parent's Site property.</param>
        /// <param name="checkImpersonation">True if impersonating to resolve base url to SSP or site URL</param>
        private void ConfigureService(HttpWebClientProtocol service,
                                      string servicePath,
                                      bool checkImpersonation)
        {

            service.Credentials = CredentialCache.DefaultNetworkCredentials;

            if (_Parent.IsImpersonating && checkImpersonation)
            {
                service.Url = AppendPath(_Parent.SPPBaseURL, servicePath);
                service.UseDefaultCredentials = false;
            }
            else
            {
                service.Url = AppendPath(_Parent.Site.OriginalString, servicePath);
                service.UseDefaultCredentials = true;
            }

            switch (_Parent.AuthenticationType)
            {
                case AuthenticationType.Windows:
                    break;
                case AuthenticationType.Forms:
                    service.CookieContainer = _Parent.CookieContainer;
                    break;
                default:
                    throw new ArgumentOutOfRangeException(LibraryResources.InvalidAuthenticationType);
            }
        }

        #endregion

        #region Internal Methods

        protected internal static void Dispose(SoapHttpClientProtocol service)
        {
            if (service != null)
            {
                service.Dispose();
            }
        }

        #endregion
    }
}

---