C:/Data/Projects/MCS EPM Global Practice/Frameworks/Public/mpfX/1.0/Libraries/Mcs.Epm.MicrosoftProject.mpFx/Events.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.Data;
using System.Reflection;
using Mcs.Epm.MicrosoftProject.mpFx.EventsWebService;

namespace Mcs.Epm.MicrosoftProject.mpFx
{
    /// <summary>
    /// Wraps the events web service
    /// </summary>
    public class Events
    {
        #region Public Properties

        public ProjectServer Parent { get; set; }

        #endregion

        #region Constructors

        public Events(ProjectServer parent)
        {
            if (parent == null)
            {
                throw new ArgumentNullException("parent");
            }

            Parent = parent;
        }

        #endregion

        #region Public Methods

        public EventHandlersDataSet ReadEventHandlerAssociationsForEvent(PSEventID eventId)
        {
            return Parent.WebServices.Events.ReadEventHandlerAssociationsForEvent(eventId);
        }

        public bool IsEventHandlerRegisteredForClass(PSEventID eventId, string className)
        {
            using (EventHandlersDataSet eventHandlers = Parent.Events.ReadEventHandlerAssociationsForEvent(eventId))
            {
                if (eventHandlers.EventHandlers.Count == 0)
                {
                    return false;
                }

                foreach (EventHandlersDataSet.EventHandlersRow eventHandler in eventHandlers.EventHandlers)
                {
                    if (eventHandler.ClassName.Equals(className))
                    {
                        return true;
                    }
                }
            }

            return false;
        }

        public PSEventID? GetEventID(string sourceName, string eventName)
        {
            using (EventsDataSet eventsDataSet = Parent.WebServices.Events.ReadEventsList())
            {
                DataView dataView = new DataView(eventsDataSet.Event);

                dataView.RowFilter = string.Format("{0} = '{1}'", 
                                                   eventsDataSet.Event.Columns["SourceName"].ColumnName, 
                                                   sourceName);

                dataView.RowFilter = string.Format("{0} AND {1} = '{2}'", 
                                                   dataView.RowFilter, 
                                                   eventsDataSet.Event.Columns["EventName"].ColumnName, 
                                                   eventName);

                if (dataView.Count == 0)
                {
                    return null;
                }
                    
                DataRowView dataRowView = dataView[0];

                return (PSEventID) dataRowView["EventId"];
                
            }
        }

        public Guid? Install(PSEventID eventID, 
                             string assemblyName, 
                             string sourceName, 
                             string eventName, 
                             string eventMethod, 
                             string className, 
                             string description)
        {
            if (IsEventHandlerRegisteredForClass(eventID, className))
            {
                return null;
            }

            using (EventHandlersDataSet eventHandlerDataSet = Parent.WebServices.Events.ReadEventHandlerAssociationsForEvent(eventID))
            {
                int order = 0;

                foreach (EventHandlersDataSet.EventHandlersRow eventHandlersRow in eventHandlerDataSet.EventHandlers.Rows)
                {
                    order = Math.Max(order, eventHandlersRow.Order);
                }

                order++;
                 
                EventHandlersDataSet.EventHandlersRow newHandler = eventHandlerDataSet.EventHandlers.NewEventHandlersRow();

                newHandler.Order = order;
                newHandler.AssemblyName = assemblyName;
                newHandler.ClassName = className;
                newHandler.Description = description;
                newHandler.EventHandlerUid = Guid.NewGuid();
                newHandler.EventId = (int) eventID;
                newHandler.Name = string.Format("{0} {1} {2}", className, sourceName, eventName); 
                
                eventHandlerDataSet.EventHandlers.AddEventHandlersRow(newHandler);

                Parent.WebServices.Events.CreateEventHandlerAssociations(eventHandlerDataSet);

                return newHandler.EventHandlerUid;
            }
        }

        public EventHandlersDataSet Read()
        {
            return Parent.WebServices.Events.ReadEventHandlerAssociations();
        }

        #endregion

        #region Private Methods

        private void AddAssemblyEventHandlers(Assembly eventHandlerAssembly)
        {
            foreach (Type type in eventHandlerAssembly.GetTypes())
            {
                //  Inspect only types based on events receiver 
                if (type.IsClass && type.BaseType.Module.Name.EndsWith("Microsoft.Office.Project.Server.Events.Receivers.dll"))
                {
                    foreach (MethodInfo method in type.GetMethods())
                    {
                        //  Make sure only implemented event handlers are registered 
                        if (method.DeclaringType.FullName ==
                            type.FullName)
                        {
                            int index = type.BaseType.Name.LastIndexOf("EventReceiver");
                            string sourceName = type.BaseType.Name.Substring(0, index);
                            string eventName = method.Name.Substring(2);
                            string eventMethod = method.Name;
                            string className = type.FullName;

                            PSEventID? eventId = GetEventID(sourceName, eventName);

                            if (eventId == null)
                            {
                                throw new ArgumentOutOfRangeException("eventHandlerAssembly");
                            }

                            Install((PSEventID) eventId,
                                    eventHandlerAssembly.FullName,
                                    sourceName,
                                    eventName,
                                    eventMethod,
                                    className,
                                    string.Empty);
                        }
                    }
                }
            }
        }

        #endregion
    }    
}

---