/// <summary>
        /// publis query event
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="eventSource">event source</param>
        /// <param name="datas">datas</param>
        /// <param name="callback">callback</param>
        public static void PublishQuery <T>(Type eventSource, IEnumerable <T> datas, RepositoryEventCallback callback = null)
        {
            if (datas.IsNullOrEmpty())
            {
                return;
            }
            var eventHandlers = GetEventHandlers(eventSource, EventType.QueryData, typeof(T));

            if (eventHandlers.IsNullOrEmpty())
            {
                callback?.Invoke(new QueryEventResult <T>()
                {
                    Datas = datas.ToList()
                });
                return;
            }
            var eventDatas = datas;

            foreach (var handler in eventHandlers)
            {
                QueryEventHandler <T> eventHandler = handler as QueryEventHandler <T>;
                if (eventHandler == null)
                {
                    continue;
                }
                eventDatas = eventHandler.Execute(eventDatas);
            }
            callback?.Invoke(new QueryEventResult <T>()
            {
                Datas = eventDatas.ToList()
            });
        }
Esempio n. 2
0
        /// <summary>
        /// Publis query event
        /// </summary>
        /// <typeparam name="TObject">Data type</typeparam>
        /// <param name="eventSource">Event source</param>
        /// <param name="datas">Datas</param>
        /// <param name="query">Query</param>
        /// <param name="callback">Callback</param>
        public static void PublishQuery <TObject>(Type eventSource, IEnumerable <TObject> datas, IQuery query, RepositoryEventCallback callback = null)
        {
            var eventHandlers = GetEventHandlers(eventSource, EventType.QueryData, typeof(TObject));
            var eventDatas    = datas;

            if (!eventHandlers.IsNullOrEmpty())
            {
                foreach (var handler in eventHandlers)
                {
                    QueryEventHandler <TObject> eventHandler = handler as QueryEventHandler <TObject>;
                    if (eventHandler == null)
                    {
                        continue;
                    }
                    eventDatas = eventHandler.Execute(eventDatas);
                }
            }
            callback?.Invoke(new QueryEventResult <TObject>()
            {
                Datas = eventDatas?.ToList() ?? new List <TObject>(0)
            });
        }
Esempio n. 3
0
        /// <summary>
        /// Publish modify event
        /// </summary>
        /// <param name="eventSource">Event source type</param>
        /// <param name="eventType">Event type</param>
        /// <param name="query">Query</param>
        /// <param name="activationOptions">Activation options</param>
        /// <param name="callback">Callback</param>
        public static void PublishModify <TObject>(Type eventSource, IModify modify, IQuery query, ActivationOptions activationOptions = null, RepositoryEventCallback callback = null)
        {
            var eventHandlers = GetEventHandlers(eventSource, EventType.ModifyExpression, typeof(TObject));

            if (!eventHandlers.IsNullOrEmpty())
            {
                foreach (var handler in eventHandlers)
                {
                    ModifyEventHandler eventHandler = handler as ModifyEventHandler;
                    if (eventHandler == null)
                    {
                        continue;
                    }
                    eventHandler.Execute(modify, query, activationOptions);
                }
            }
            callback?.Invoke(DataOperationEventExecuteResult.Empty);
        }
Esempio n. 4
0
 /// <summary>
 /// Publish remove event
 /// </summary>
 /// <typeparam name="TObject">Data type</typeparam>
 /// <param name="eventSource">Event source type</param>
 /// <param name="query">Query</param>
 /// <param name="activationOptions">Activation options</param>
 /// <param name="callback">Callback</param>
 public static void PublishRemove <TObject>(Type eventSource, IQuery query, ActivationOptions activationOptions = null, RepositoryEventCallback callback = null)
 {
     PublishCondition <TObject>(eventSource, EventType.RemoveByCondition, query, activationOptions, callback);
 }
Esempio n. 5
0
 /// <summary>
 /// Publish remove event
 /// </summary>
 /// <typeparam name="TObject">Data type</typeparam>
 /// <param name="eventSource">Event source type</param>
 /// <param name="datas">Datas</param>
 /// <param name="activationOptions">Activation options</param>
 /// <param name="callback">Callback</param>
 public static void PublishRemove <TObject>(Type eventSource, IEnumerable <TObject> datas, ActivationOptions activationOptions = null, RepositoryEventCallback callback = null)
 {
     PublishDataOperation(eventSource, EventType.RemoveObject, datas, activationOptions, callback);
 }
Esempio n. 6
0
        /// <summary>
        /// Publish data operation
        /// </summary>
        /// <typeparam name="TObject">Data type</typeparam>
        /// <param name="eventSource">Event source type</param>
        /// <param name="eventType">Event type</param>
        /// <param name="datas">Datas</param>
        /// <param name="activationOptions">Activation options</param>
        /// <param name="callback">Callback</param>
        public static void PublishDataOperation <TObject>(Type eventSource, EventType eventType, IEnumerable <TObject> datas, ActivationOptions activationOptions, RepositoryEventCallback callback = null)
        {
            if (datas.IsNullOrEmpty())
            {
                return;
            }
            var eventHandlers = GetEventHandlers(eventSource, eventType, typeof(TObject));

            if (eventHandlers.IsNullOrEmpty())
            {
                callback?.Invoke(DataOperationEventExecuteResult.Empty);
                return;
            }
            foreach (var handler in eventHandlers)
            {
                DataEventHandler <TObject> eventHandler = handler as DataEventHandler <TObject>;
                if (eventHandler == null)
                {
                    continue;
                }
                eventHandler.Execute(datas, activationOptions);
            }
            callback?.Invoke(DataOperationEventExecuteResult.Empty);
        }
        /// <summary>
        /// publish condition
        /// </summary>
        /// <param name="eventSource">event source</param>
        /// <param name="eventType">event type</param>
        /// <param name="query">query</param>
        /// <param name="activationOption">activation option</param>
        /// <param name="callback">callback</param>
        public static void PublishCondition <T>(Type eventSource, EventType eventType, IQuery query, ActivationOption activationOption = null, RepositoryEventCallback callback = null)
        {
            var eventHandlers = GetEventHandlers(eventSource, eventType, typeof(T));

            if (eventHandlers.IsNullOrEmpty())
            {
                callback?.Invoke(DataOperationEventResult.Empty);
                return;
            }
            foreach (var handler in eventHandlers)
            {
                ConditionEventHandler eventHandler = handler as ConditionEventHandler;
                if (eventHandler == null)
                {
                    continue;
                }
                eventHandler.Execute(query, activationOption);
            }
            callback?.Invoke(DataOperationEventResult.Empty);
        }
 /// <summary>
 /// publish save event
 /// </summary>
 /// <typeparam name="T"></typeparam>
 /// <param name="eventSource">event source</param>
 /// <param name="datas">datas</param>
 /// <param name="activationOption">activation option</param>
 /// <param name="callback">callback</param>
 public static void PublishSave <T>(Type eventSource, IEnumerable <T> datas, ActivationOption activationOption = null, RepositoryEventCallback callback = null)
 {
     PublishDataOperation(eventSource, EventType.SaveObject, datas, activationOption, callback);
 }
        /// <summary>
        /// publish modify
        /// </summary>
        /// <param name="eventSource">event source</param>
        /// <param name="eventType">event type</param>
        /// <param name="query">query</param>
        /// <param name="callback">callback</param>
        public static void PublishModify <T>(Type eventSource, IModify modify, IQuery query, RepositoryEventCallback callback = null)
        {
            if (modify == null)
            {
                return;
            }
            var eventHandlers = GetEventHandlers(eventSource, EventType.ModifyExpression, typeof(T));

            if (eventHandlers.IsNullOrEmpty())
            {
                callback?.Invoke(DataOperationEventResult.Empty);
                return;
            }
            foreach (var handler in eventHandlers)
            {
                ModifyEventHandler eventHandler = handler as ModifyEventHandler;
                if (eventHandler == null)
                {
                    continue;
                }
                eventHandler.Execute(modify, query);
            }
            callback?.Invoke(DataOperationEventResult.Empty);
        }
 /// <summary>
 /// publish remove
 /// </summary>
 /// <typeparam name="T"></typeparam>
 /// <param name="eventSource">event source</param>
 /// <param name="query">query</param>
 /// <param name="callback">callback</param>
 public static void PublishRemove <T>(Type eventSource, IQuery query, RepositoryEventCallback callback = null)
 {
     PublishCondition <T>(eventSource, EventType.RemoveByCondition, query, callback);
 }