public static void Send(IEventContext eventContext)
{
foreach (var s in Subscribers)
{
s.Receive(eventContext);
}
}
public void Receive(IEventContext context)
{
if (context is ContentEventContext)
{
var contentContext = ((ContentEventContext)context);
if (contentContext.Content.___EnableVersion___)
{
if (contentContext.Content is TextContent)
{
switch (contentContext.ContentAction)
{
case Kooboo.CMS.Content.Models.ContentAction.Delete:
break;
case Kooboo.CMS.Content.Models.ContentAction.Add:
case Kooboo.CMS.Content.Models.ContentAction.Update:
Versioning.VersionManager.LogVersion((TextContent)(contentContext.Content));
break;
default:
break;
}
}
}
}
}
public EventResult Receive(IEventContext context)
{
EventResult eventResult = new EventResult();
if (context is ContentEventContext)
{
try
{
var contentContext = ((ContentEventContext)context);
if (contentContext.Content.___EnableVersion___)
{
if (contentContext.Content is TextContent)
{
switch (contentContext.ContentAction)
{
case Kooboo.CMS.Content.Models.ContentAction.Delete:
break;
case Kooboo.CMS.Content.Models.ContentAction.Add:
case Kooboo.CMS.Content.Models.ContentAction.Update:
Versioning.VersionManager.LogVersion((TextContent)(contentContext.Content));
break;
default:
break;
}
}
}
}
catch (Exception e)
{
eventResult.Exception = e;
}
}
return eventResult;
}
public void Receive(IEventContext context)
{
if (context is ContentEventContext)
{
var contentEventContext = (ContentEventContext)context;
if (contentEventContext.ContentAction == Models.ContentAction.Delete)
{
Task.Factory.StartNew(() =>
{
try
{
var textFolder = contentEventContext.Content.GetFolder().AsActual();
// Delete the child contents in this folder.
DeleteChildContents(contentEventContext.Content, textFolder, textFolder);
if (textFolder.EmbeddedFolders != null)
{
foreach (var folderName in textFolder.EmbeddedFolders)
{
var childFolder = new TextFolder(textFolder.Repository, folderName);
DeleteChildContents(contentEventContext.Content, textFolder, childFolder);
}
}
}
catch (Exception e)
{
Kooboo.HealthMonitoring.Log.LogException(e);
}
});
}
}
}
public EventResult Receive(IEventContext context)
{
EventResult eventResult = new EventResult();
if (context is ContentEventContext)
{
try
{
ContentEventContext contentEventContext = (ContentEventContext)context;
if (contentEventContext.ContentAction == ContentAction.Add && contentEventContext.Content is TextContent)
{
var textContent = (TextContent)contentEventContext.Content;
var folder = (TextFolder)textContent.GetFolder().AsActual();
if (folder.EnabledWorkflow && !string.IsNullOrEmpty(contentEventContext.Content.UserId))
{
Services.ServiceFactory.WorkflowManager.StartWorkflow(textContent.GetRepository()
, folder.WorkflowName
, textContent
, contentEventContext.Content.UserId);
}
}
}
catch (Exception e)
{
eventResult.Exception = e;
}
}
return eventResult;
}
EventResult ISubscriber.Receive(IEventContext context)
{
if (context is ContentEventContext)
{
var contentEventContext = (ContentEventContext)context;
switch (contentEventContext.ContentAction)
{
case ContentAction.Add:
break;
case ContentAction.Delete:
break;
case ContentAction.PreAdd:
break;
case ContentAction.PreDelete:
break;
case ContentAction.PreUpdate:
break;
case ContentAction.Update:
break;
default:
break;
}
}
return new EventResult() { IsCancelled = false };
}
public EventRepository(IEventContext eventContext, IMapToExisting<Event, Event> eventMapper)
{
Check.If(eventContext).IsNotNull();
Check.If(eventMapper).IsNotNull();
_eventContext = eventContext;
_eventMapper = eventMapper;
}
public void Receive(IEventContext context)
{
if (context is ContentEventContext && HttpContext.Current != null)
{
ContentEventContext contentEventContext = (ContentEventContext)context;
var content = contentEventContext.Content;
var result = (contentEventContext.ContentAction & ContentAction.PreAdd) == ContentAction.PreAdd || (contentEventContext.ContentAction & ContentAction.PreUpdate) == ContentAction.PreUpdate;
if (result)
{
var cropField = HttpContext.Current.Request.Form["Kooboo-Image-Crop-Field"];
var toRemove = new List<string>();
if (!string.IsNullOrEmpty(cropField))
{
var fields = cropField.Split(',');
foreach (var field in fields)
{
try
{
var imgParam = JsonHelper.Deserialize<ImageParam>(HttpContext.Current.Request.Form[field + "-hidden"].ToString());
string sourceFilePath = HttpContext.Current.Server.MapPath(imgParam.Url);
toRemove.Add(sourceFilePath);
var contentPath = new TextContentPath(content);
var vPath = Kooboo.Web.Url.UrlUtility.Combine(contentPath.VirtualPath, "kooboo-crop-" + Path.GetFileName(imgParam.Url));
Kooboo.IO.IOUtility.EnsureDirectoryExists(contentPath.PhysicalPath);
var phyPath = HttpContext.Current.Server.MapPath(vPath);
Kooboo.Drawing.ImageTools.CropImage(sourceFilePath, phyPath, imgParam.X, imgParam.Y, imgParam.Width, imgParam.Height);
content[field] = vPath;
}
catch (Exception e)
{
}
}
}
foreach (var r in toRemove)
{
if (File.Exists(r))
{
File.Delete(r);
}
}
}
}
}
public Task HandleAsync(IEventContext <SampleEvent> context, CancellationToken cancellationToken = default)
{
cancellationToken.ThrowIfCancellationRequested();
Interlocked.Increment(ref _received);
_receivedTime = DateTimeOffset.UtcNow;
return(Task.CompletedTask);
}
public Task <Result> HandleAsync(CriticalEvent domainEvent, IEventContext context = null)
{
domainEvent.HandlerData += "B";
domainEvent.NbTries++;
if (domainEvent.NbTries < 3)
{
throw new NotImplementedException();
}
return(Task.FromResult(Result.Ok()));
}
public override ValueTask HandleEvent(UnitState.UnitStateData stateData, UnitEvent.UnitEventData eventData,
IEventContext eventContext)
{
stateData.Item1 = eventData.Item1;
stateData.Item2 = eventData.Item2;
stateData.Item3 = eventData.Item3;
stateData.Item4 = eventData.Item4;
stateData.Item5 = eventData.Item5;
return(new ValueTask());
}
public void Handle(IEventContext context, UserCreated @event)
{
_userDao.Save(new UserModel {
UserID = context.SourceInfo.Id,
LoginId = @event.LoginId,
Password = @event.Password,
UserName = @event.UserName
});
//Console.WriteLine("同步到Q端数据库");
}
/**
* Binds essentials objects at runtime
*/
void Bind()
{
worldGO = GameObject.Find(AW_WORLD_GO_NAME);
IEventContext mec = GetComponent <MonoEventContext> ();
if (mec == null)
{
mec = gameObject.AddComponent <MonoEventContext> ();
}
mainEventContext = mec;
}
public Task ClearAsync()
{
IEventContext context = contextFactory();
foreach (UnPublishedEventEntity entity in context.UnPublishedEvents)
{
context.UnPublishedEvents.Remove(entity);
}
return(context.SaveAsync());
}
/// <summary>
/// Sends the notification to the players intented.
/// </summary>
/// <param name="context">The context for this notification.</param>
public override void Execute(IEventContext context)
{
context.ThrowIfNull(nameof(context));
if (!typeof(INotificationContext).IsAssignableFrom(context.GetType()) || !(context is INotificationContext notificationContext))
{
throw new ArgumentException($"{nameof(context)} must be an {nameof(INotificationContext)}.");
}
this.Send(notificationContext);
}
public async Task <Result> HandleAsync(ParallelEvent domainEvent, IEventContext context = null)
{
await Task.Delay(150).ConfigureAwait(false);
if (domainEvent.RetryMode && domainEvent.NbTries < 2)
{
domainEvent.NbTries++;
throw new InvalidOperationException();
}
domainEvent.AddThreadInfos(Thread.CurrentThread.ManagedThreadId);
return(Result.Ok());
}
public Task <Result> HandleAsync(TestRetryEvent domainEvent, IEventContext context = null)
{
if (domainEvent.NbTries != 2)
{
domainEvent.NbTries++;
throw new Exception("NbTries == 2");
}
else
{
return(Task.FromResult(Result.Ok()));
}
}
protected override void OnSendingHandlerCommand(IEventContext context, ICommand command)
{
try
{
base.OnSendingHandlerCommand(context, command);
}
catch (Exception ex)
{
this.commandRecovery.EnqueueCommand(command, context, ex);
throw new Exception("", ex);
}
}
public async Task <Result> HandleAsync(MessageTreatedEvent domainEvent, IEventContext context = null)
{
var dbMessage = new DbMessage(domainEvent.TreatedMessageId)
{
Message = domainEvent.TreatedMessage
};
_messageRepository.MarkForInsert(dbMessage);
await _messageRepository.SaveAsync().ConfigureAwait(false);
return(Result.Ok());
}
public Task <Result> HandleAsync(EventThree domainEvent, IEventContext context = null)
{
if (domainEvent.Data.Data.ContainsKey((Guid)domainEvent.AggregateId))
{
domainEvent.Data.Data[(Guid)domainEvent.AggregateId] += "3";
}
else
{
domainEvent.Data.Data.Add((Guid)domainEvent.AggregateId, "3");
}
return(Task.FromResult(Result.Ok()));
}
public async Task ProcessAsync(IEventContext <T> context)
{
try
{
await context.InvokeNextAsync();
}
catch (Exception ex)
{
_logger.LogError(ex, context.Settings.GetSubscriberName());
context.MessageAcceptor.Accept();
}
}
public void UnbindListener(TofuEvent evnt, Action <EventPayload> action, IEventContext evntContext)
{
evntContext.ContextRemoveEventListener(evnt, this);
if (_listenersToUnbind == null)
{
_listenersToUnbind = new Dictionary <TofuEvent, Action <EventPayload> >();
}
if (!_listenersToUnbind.ContainsKey(evnt))
{
_listenersToUnbind.Add(evnt, action);
}
}
public EventResult Receive(IEventContext context)
{
EventResult eventResult = new EventResult();
if (context is ContentEventContext)
{
try
{
var contentEventContext = (ContentEventContext)context;
switch (contentEventContext.ContentAction)
{
case Kooboo.CMS.Content.Models.ContentAction.Add:
break;
case Kooboo.CMS.Content.Models.ContentAction.Update:
break;
case Kooboo.CMS.Content.Models.ContentAction.Delete:
break;
case Kooboo.CMS.Content.Models.ContentAction.PreAdd:
if (contentEventContext.Content.Sequence == 0)
{
var textFolder = contentEventContext.Content.GetFolder().AsActual();
int sequence = 1;
var maxSequenceContent = textFolder.CreateQuery().OrderByDescending("Sequence").FirstOrDefault();
if (maxSequenceContent != null)
{
sequence = maxSequenceContent.Sequence + 1;
}
contentEventContext.Content.Sequence = sequence;
}
break;
case Kooboo.CMS.Content.Models.ContentAction.PreUpdate:
break;
case Kooboo.CMS.Content.Models.ContentAction.PreDelete:
break;
default:
break;
}
}
catch (Exception e)
{
eventResult.Exception = e;
}
}
return(eventResult);
}
public void Receive(IEventContext context)
{
if (context is ContentEventContext && HttpContext.Current != null)
{
ContentEventContext contentEventContext = (ContentEventContext)context;
var content = contentEventContext.Content;
var result = (contentEventContext.ContentAction & ContentAction.PreAdd) == ContentAction.PreAdd || (contentEventContext.ContentAction & ContentAction.PreUpdate) == ContentAction.PreUpdate;
if (result)
{
var cropField = HttpContext.Current.Request.Form["Kooboo-Image-Crop-Field"];
var toRemove = new List <string>();
if (!string.IsNullOrEmpty(cropField))
{
var fields = cropField.Split(',');
foreach (var field in fields)
{
try
{
var imgParam = JsonHelper.Deserialize <ImageParam>(HttpContext.Current.Request.Form[field + "-hidden"].ToString());
string sourceFilePath = HttpContext.Current.Server.MapPath(imgParam.Url);
toRemove.Add(sourceFilePath);
var contentPath = new TextContentPath(content);
var vPath = Kooboo.Web.Url.UrlUtility.Combine(contentPath.VirtualPath, "kooboo-crop-" + Path.GetFileName(imgParam.Url));
Kooboo.IO.IOUtility.EnsureDirectoryExists(contentPath.PhysicalPath);
var phyPath = HttpContext.Current.Server.MapPath(vPath);
Kooboo.Drawing.ImageTools.CropImage(sourceFilePath, phyPath, imgParam.X, imgParam.Y, imgParam.Width, imgParam.Height);
content[field] = vPath;
}
catch (Exception e)
{
}
}
}
foreach (var r in toRemove)
{
if (File.Exists(r))
{
File.Delete(r);
}
}
}
}
}
void Awake()
{
ServiceContext = new ServiceContext();
HandleUnityObjects();
RegisterPayloads();
BindServices();
InitServices();
IEventContext eventContext = ServiceContext.Fetch("EventContext");
eventContext.TriggerEvent(EventKey.GameServicesInitialized, null);
}
/// <summary>
/// Register asynchronously an event to be processed by the bus.
/// </summary>
/// <param name="event">Event to register.</param>
/// <param name="context">Context associated to the event.</param>
public async Task <Result> PublishEventAsync(IDomainEvent @event, IEventContext context = null)
{
if (@event != null)
{
var eventType = @event.GetType();
_logger.LogDebug(() => $"RabbitMQClientBus : Beginning of publishing event of type {eventType.FullName}");
await Publish(GetEnveloppeFromEvent(@event)).ConfigureAwait(false);
_logger.LogDebug(() => $"RabbitMQClientBus : End of publishing event of type {eventType.FullName}");
return(Result.Ok());
}
return(Result.Fail("RabbitMQClientBus : No event provided to publish method"));
}
public async Task HandleErrorAsync <TEvent>(IEventContext <TEvent> context, Exception exception, EventErrorDelegate <TEvent> next)
where TEvent : class, IEvent
{
try
{
await _engine.NotifyFailAsync(context.Message).ConfigureAwait(false);
}
catch (Exception discardException)
{
_logger.LogError(discardException, ex => $"Unable to discard message: {ex.Message}");
await next(context, exception).ConfigureAwait(false);
}
}
/// <summary>
/// 使用事件上下文初始化对象
/// </summary>
/// <param name="eventContext"></param>
public HandlerCommunication(IEventContext eventContext) : base((eventContext == null || eventContext.Items == null) ? 0 : eventContext.Items.Count)
{
this.Consigner = eventContext.Consigner;
this.Worker = eventContext.Worker;
this.RuntimeModeArray = new List <Aop.IRuntimeMode>(eventContext.RuntimeModeArray ?? new Aop.IRuntimeMode[0]);
if (eventContext.Items != null)
{
foreach (var i in eventContext.Items)
{
this[i.Key] = i;
}
}
}
public override ValueTask HandleEvent(AccountBalanceHistoryInfo stateData, AccountBalanceChangeEvent eventData,
IEventContext eventContext)
{
var queue = stateData.Balances ?? new Queue <decimal>();
queue.Enqueue(eventData.Diff);
while (queue.Count > 10)
{
queue.Dequeue();
}
return(ValueTask.CompletedTask);
}
public void SetUp()
{
_subEventContext = Substitute.For <IEventContext>();
_subServiceContext = TestUtilities.BuildSubServiceContextWithServices(new Dictionary <string, object>()
{
{ "IEventContext", _subEventContext }
});
_subEventContext.When(x => x.TriggerEvent(Arg.Any <EventKey>(), Arg.Any <EventPayload>())).Do(x => { });
_frameUpdateService = new GameObject().AddComponent <FrameUpdateService>();
_frameUpdateService.BindServiceContext(_subServiceContext);
_frameUpdateService.ResolveServiceBindings();
}
public EventResult Receive(IEventContext context)
{
EventResult eventResult = new EventResult();
if (context is ContentEventContext)
{
var eventContext = ((ContentEventContext)context);
if (eventContext.Content is TextContent)
{
try
{
var textContent = (TextContent)eventContext.Content;
var repository = textContent.GetRepository();
var searchService = SearchHelper.OpenService(repository);
switch (eventContext.ContentAction)
{
case Kooboo.CMS.Content.Models.ContentAction.Delete:
searchService.Delete(textContent);
break;
case Kooboo.CMS.Content.Models.ContentAction.Add:
if (textContent.Published.HasValue && textContent.Published.Value == true)
{
searchService.Add(textContent);
}
break;
case Kooboo.CMS.Content.Models.ContentAction.Update:
if (textContent.Published.HasValue && textContent.Published.Value == true)
{
searchService.Update(textContent);
}
else
{
searchService.Delete(textContent);
}
break;
default:
break;
}
}
catch (Exception e)
{
eventResult.Exception = e;
}
}
}
return(eventResult);
}
public HistoricalExcelService(MainRegionViewModel main,
IEventContext eventContext,
IObjectServiceOperations objectServiceOperations,
IInteractionService interactionService,
IHistoricalTimeUtility historicalTimeUtility,
IValueFormatter valueFormatter,
IApplicationProperties appliationProperties)
{
_historicalTimeUtility = historicalTimeUtility;
_valueFormatter = valueFormatter;
_objectServiceOperations = objectServiceOperations;
_interactionService = interactionService;
_appliationProperties = appliationProperties;
}
public async Task <Result> HandleAsync(EventTwo domainEvent, IEventContext context = null)
{
await Task.Delay(10);
if (domainEvent.Data.Data.ContainsKey((Guid)domainEvent.AggregateId))
{
domainEvent.Data.Data[(Guid)domainEvent.AggregateId] += "2";
}
else
{
domainEvent.Data.Data.Add((Guid)domainEvent.AggregateId, "2");
}
return(Result.Ok());
}
public async Task ProcessAsync(IEventContext <T> context)
{
try
{
await context.InvokeNextAsync();
}
catch (Exception ex)
{
_logger.LogError(
ex,
$"Failed to handle the message. Sending it to poison queue {context.Settings.GetSubscriberName()} {context.Settings.QueueName}-poison.");
context.MessageAcceptor.Reject();
}
}
public virtual EventResult Receive(IEventContext context)
{
EventResult eventResult = new EventResult();
try
{
if (context is ContentEventContext)
{
var contentEventContext = (ContentEventContext)context;
//Can not run the content broadcasting in parallel threads, must to make sure the execution by sequence.
//Thread processThread = new Thread(delegate()
//{
var contentContext = (ContentEventContext)context;
try
{
var sendingRepository = contentContext.Content.GetRepository().AsActual();
var sendingSetting = AllowSending(contentContext.Content, sendingRepository, contentContext);
if (sendingSetting != null)
{
var allRepositories = Services.ServiceFactory.RepositoryManager.All().Where(it => string.Compare(it.Name, sendingRepository.Name, true) != 0);
var summarize = contentContext.Content.GetSummary();
foreach (var receiver in allRepositories)
{
var repository = receiver.AsActual();
if (repository.EnableBroadcasting)
{
Services.ServiceFactory.ReceiveSettingManager.ReceiveContent(repository, contentContext.Content, contentContext.ContentAction);
}
}
}
}
catch (Exception e)
{
Kooboo.HealthMonitoring.Log.LogException(e);
}
//});
//processThread.Start();
}
}
catch (Exception e)
{
eventResult.Exception = e;
}
return(eventResult);
}
public async Task DispatchAsync(IEventContext <IEvent> context, CancellationToken cancellationToken = default)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
// TODO(Dan): Cache these generic methods. The Event dispatcher is scoped generally, so that would require consideration.
var methodInfos = GetType().GetMethods(System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.Instance);
var match = methodInfos.First(info => info.Name == nameof(DispatchAsync) && info.IsGenericMethod);
var method = match.MakeGenericMethod(context.Payload.GetType());
await(Task) method.Invoke(this, new object[] { context, cancellationToken });
}
public void Save(IEnumerable <EventModel> events)
{
Ensure.NotNull(events, "events");
IEventContext context = contextFactory();
foreach (EventEntity entity in events.Select(EventEntity.FromModel))
{
context.Events.Add(entity);
context.UnPublishedEvents.Add(new UnPublishedEventEntity(entity));
}
context.Save();
}
public virtual EventResult Receive(IEventContext context)
{
EventResult eventResult = new EventResult();
try
{
if (context is ContentEventContext)
{
var contentEventContext = (ContentEventContext)context;
//Can not run the content broadcasting in parallel threads, must to make sure the execution by sequence.
//Thread processThread = new Thread(delegate()
//{
var contentContext = (ContentEventContext)context;
try
{
var sendingRepository = contentContext.Content.GetRepository().AsActual();
var sendingSetting = AllowSending(contentContext.Content, sendingRepository, contentContext);
if (sendingSetting != null)
{
var allRepositories = Services.ServiceFactory.RepositoryManager.All().Where(it => string.Compare(it.Name, sendingRepository.Name, true) != 0);
var summarize = contentContext.Content.GetSummary();
foreach (var receiver in allRepositories)
{
var repository = receiver.AsActual();
if (repository.EnableBroadcasting)
{
Services.ServiceFactory.ReceiveSettingManager.ReceiveContent(repository, contentContext.Content, contentContext.ContentAction);
}
}
}
}
catch (Exception e)
{
Bsc.Dmtds.Common.HealthMonitoring.Log.LogException(e);
}
//});
//processThread.Start();
}
}
catch (Exception e)
{
eventResult.Exception = e;
}
return eventResult;
}
public void BindListener(TofuEvent evnt, Action <EventPayload> action, IEventContext evntContext)
{
if (_boundListeners == null)
{
_boundListeners = new Dictionary <TofuEvent, List <Action <EventPayload> > >();
}
if (!_boundListeners.ContainsKey(evnt))
{
_boundListeners.Add(evnt, new List <Action <EventPayload> >());
}
evntContext.ContextBindEventListener(evnt, this);
_boundListeners[evnt].Add(action);
}
public virtual EventResult Receive(IEventContext context)
{
EventResult eventResult = new EventResult();
try
{
if (context is ContentEventContext)
{
var contentEventContext = (ContentEventContext)context;
Thread processThread = new Thread(delegate()
{
var contentContext = (ContentEventContext)context;
try
{
var sendingRepository = contentContext.Content.GetRepository().AsActual();
var sendingSetting = AllowSending(contentContext.Content, sendingRepository, contentContext);
if (sendingSetting != null)
{
var allRepositories = Services.ServiceFactory.RepositoryManager.All().Where(it => string.Compare(it.Name, sendingRepository.Name, true) != 0);
var summarize = contentContext.Content.GetSummary();
foreach (var receiver in allRepositories)
{
var repository = receiver.AsActual();
if (repository.EnableBroadcasting)
{
Services.ServiceFactory.ReceiveSettingManager.ReceiveContent(repository, contentContext.Content, contentContext.ContentAction);
}
}
}
}
catch (Exception e)
{
Kooboo.HealthMonitoring.Log.LogException(e);
}
});
processThread.Start();
}
}
catch (Exception e)
{
eventResult.Exception = e;
}
return eventResult;
}
public EventResult Receive(IEventContext context)
{
EventResult eventResult = new EventResult();
if (context is ContentEventContext)
{
var eventContext = ((ContentEventContext)context);
if (eventContext.Content is TextContent)
{
try
{
var textContent = (TextContent)eventContext.Content;
var repository = textContent.GetRepository();
var searchService = SearchHelper.OpenService(repository);
switch (eventContext.ContentAction)
{
case Kooboo.CMS.Content.Models.ContentAction.Delete:
searchService.Delete(textContent);
break;
case Kooboo.CMS.Content.Models.ContentAction.Add:
if (textContent.Published.HasValue && textContent.Published.Value == true)
{
searchService.Add(textContent);
}
break;
case Kooboo.CMS.Content.Models.ContentAction.Update:
if (textContent.Published.HasValue && textContent.Published.Value == true)
{
searchService.Update(textContent);
}
else
{
searchService.Delete(textContent);
}
break;
default:
break;
}
}
catch (Exception e)
{
eventResult.Exception = e;
}
}
}
return eventResult;
}
public void SetUp()
{
_agentContainer = Substitute.For <IAgentContainer>();
_tangibleContainer = Substitute.For <ITangibleContainer>();
_eventContext = Substitute.For <IEventContext>();
_agent = Substitute.For <IAgent>();
_context = TestUtilities.BuildSubServiceContextWithServices(new Dictionary <string, object>
{
{ "IAgentContainer", _agentContainer },
{ "IEventContext", _eventContext },
{ "ITangibleContainer", _tangibleContainer }
});
_sensor = new AgentSensor(_context, _agent);
}
public EventResult Receive(IEventContext context)
{
EventResult eventResult = new EventResult();
if (context is ContentEventContext)
{
try
{
var contentEventContext = (ContentEventContext)context;
switch (contentEventContext.ContentAction)
{
case Kooboo.CMS.Content.Models.ContentAction.Add:
break;
case Kooboo.CMS.Content.Models.ContentAction.Update:
break;
case Kooboo.CMS.Content.Models.ContentAction.Delete:
break;
case Kooboo.CMS.Content.Models.ContentAction.PreAdd:
if (contentEventContext.Content.Sequence == 0)
{
var textFolder = contentEventContext.Content.GetFolder().AsActual();
int sequence = 1;
var maxSequenceContent = textFolder.CreateQuery().OrderByDescending("Sequence").FirstOrDefault();
if (maxSequenceContent != null)
{
sequence = maxSequenceContent.Sequence + 1;
}
contentEventContext.Content.Sequence = sequence;
}
break;
case Kooboo.CMS.Content.Models.ContentAction.PreUpdate:
break;
case Kooboo.CMS.Content.Models.ContentAction.PreDelete:
break;
default:
break;
}
}
catch (Exception e)
{
eventResult.Exception = e;
}
}
return eventResult;
}
public void Receive(IEventContext context)
{
if (context is ContentEventContext)
{
var eventContext = ((ContentEventContext)context);
if (eventContext.Content is TextContent)
{
try
{
var textContent = (TextContent)eventContext.Content;
var repository = textContent.GetRepository();
var searchService = SearchHelper.OpenService(repository);
switch (eventContext.ContentAction)
{
case Kooboo.CMS.Content.Models.ContentAction.Delete:
searchService.Delete(textContent);
break;
case Kooboo.CMS.Content.Models.ContentAction.Add:
if (textContent.Published.HasValue && textContent.Published.Value == true)
{
searchService.Add(textContent);
}
break;
case Kooboo.CMS.Content.Models.ContentAction.Update:
if (textContent.Published.HasValue && textContent.Published.Value == true)
{
searchService.Update(textContent);
}
else
{
searchService.Delete(textContent);
}
break;
default:
break;
}
}
catch (Exception e)
{
Kooboo.HealthMonitoring.Log.LogException(e);
}
}
}
}
public static void Send(IEventContext eventContext)
{
foreach (var s in ResolveAllSubscribers())
{
var eventResult = s.Receive(eventContext);
if (eventResult != null)
{
if (eventResult.Exception != null)
{
Bsc.Dmtds.Common.HealthMonitoring.Log.LogException(eventResult.Exception);
}
if (eventResult.IsCancelled == true)
{
break;
}
}
}
}
public static void Send(IEventContext eventContext)
{
foreach (var s in Subscribers)
{
var eventResult = s.Receive(eventContext);
if (eventResult != null)
{
if (eventResult.Exception != null)
{
Kooboo.HealthMonitoring.Log.LogException(eventResult.Exception);
}
if (eventResult.IsCancelled == true)
{
break;
}
}
}
}
public void Receive(IEventContext context)
{
if (context is ContentEventContext)
{
ContentEventContext contentEventContext = (ContentEventContext)context;
if (contentEventContext.ContentAction == ContentAction.Add && contentEventContext.Content is TextContent)
{
var textContent = (TextContent)contentEventContext.Content;
var folder = (TextFolder)textContent.GetFolder().AsActual();
if (folder.EnabledWorkflow && string.IsNullOrEmpty(contentEventContext.Content.UserId))
{
Services.ServiceFactory.WorkflowManager.StartWorkflow(textContent.GetRepository()
, folder.WorkflowName
, textContent
, contentEventContext.Content.UserId);
}
}
}
}
public virtual void Receive(IEventContext context)
{
if (context is ContentEventContext)
{
var contentEventContext = (ContentEventContext)context;
var site = Site.Current;
Thread processThread = new Thread(delegate()
{
var contentContext = (ContentEventContext)context;
try
{
var sendingRepository = contentContext.Content.GetRepository().AsActual();
var sendingSetting = AllowSending(contentContext.Content, sendingRepository, contentContext);
if (sendingSetting != null)
{
var allRepositories = ServiceFactory.RepositoryManager.All().Where(it => string.Compare(it.Name, sendingRepository.Name, true) != 0);
var summarize = contentContext.Content.GetSummary();
foreach (var receiver in allRepositories)
{
var repository = receiver.AsActual();
if (repository.EnableBroadcasting)
{
ServiceFactory.ReceiveSettingManager.ReceiveContent(repository, contentContext.Content, contentContext.ContentAction);
}
}
if (site != null && (sendingSetting.SendToAllChildSites.HasValue && sendingSetting.SendToAllChildSites.Value == true))
{
SendToChildSites(site, contentEventContext, sendingSetting.KeepStatus);
}
}
}
catch (Exception e)
{
Kooboo.HealthMonitoring.Log.LogException(e);
}
});
processThread.Start();
}
}
public MainRegionViewModel(IEventAggregator eventAggregator,
IResourceDictionaryProvider resourceDictionaryProvider,
IApplicationProperties appliationProperties,
IEventContext eventContext,
IObjectServiceOperations objectServiceOperations,
IInteractionService interactionService,
IHistoricalTimeUtility historicalTimeUtility,
IPropertyNameService columnNameService,
IHistoricalColumnService historicalColumnService,
ISerializationService serializationService,
IHelpExtension helpExtension,
IValueFormatter valueFormatter,
IHdaFileExportService hdaFileExportService,
IDocumentationService documentationService)
: base(eventContext, objectServiceOperations,
interactionService, historicalTimeUtility,
columnNameService, historicalColumnService,
serializationService, helpExtension,
valueFormatter, eventAggregator,
hdaFileExportService, documentationService)
{
_eventAggregator = eventAggregator;
_eventContext = eventContext;
_historicalTimeUtility = historicalTimeUtility;
if (HistoricalExcelService.Current == null)
HistoricalExcelService.Current = new HistoricalExcelService(this,
eventContext, objectServiceOperations, interactionService, historicalTimeUtility, valueFormatter, appliationProperties);
ItemsHistoricalTimePeriodViewModel.Items.CollectionChanged += Items_CollectionChanged;
ListViewModel.ExportCommand = new DelegateCommand(ExportPropertyList);
ListViewModel.ExportCommandText = interactionService.TranslatingService.GetSystemText("Import");
EventListViewModel.ExportCommand = new DelegateCommand(ExportEventList);
EventListViewModel.ExportCommandText = interactionService.TranslatingService.GetSystemText("Import");
SubscribeEvents();
}
public void Receive(IEventContext context)
{
if (context is ContentEventContext)
{
var eventContext = ((ContentEventContext)context);
if (eventContext.Content is TextContent)
{
switch (eventContext.ContentAction)
{
case Kooboo.CMS.Content.Models.ContentAction.Delete:
break;
case Kooboo.CMS.Content.Models.ContentAction.Add:
break;
case Kooboo.CMS.Content.Models.ContentAction.Update:
break;
default:
break;
}
}
}
}
public LogEvent(string eventText, IEventContext rootContext, ICollection<IEventLevel> levels)
{
this._eventText = eventText;
string contextName;
if (eventText.StartsWith("<log4j:event"))
{
var regex =
new Regex(
"logger=\"(?<context>.*)\" level=\"(?<level>.*)\" timestamp=\"(?<timeDate>.*)\" .*log4j:message>(?<message>.*)</log4j:message>",
RegexOptions.Multiline);
var matches = regex.Matches(eventText);
contextName = matches[0].Groups["context"].Value.Trim();
var milliseconds = long.Parse(matches[0].Groups["timeDate"].Value.Trim());
Time = new DateTime(1970, 1, 1).AddMilliseconds(milliseconds);
Time = Time.ToUniversalTime();
Level = matches[0].Groups["level"].Value.Trim();
Message = matches[0].Groups["message"].Value.Trim();
}
else
{
contextName = GetContextName();
}
IsControlMessage = (contextName.ToLower() == "nLogCruncher.Command".ToLower());
Context = rootContext;
foreach (var name in contextName.Split('.'))
{
Context = Context.GetContext(name);
}
if (levels.Count(thisLevel => thisLevel.Name.ToLower() == Level.ToLower()) == 0)
{
levels.Add(new EventLevel(Level));
}
}
public EventResult Receive(IEventContext context)
{
EventResult eventResult = new EventResult();
if (context is ContentEventContext)
{
var contentEventContext = (ContentEventContext)context;
if (contentEventContext.ContentAction == Models.ContentAction.Delete)
{
Task.Factory.StartNew(() =>
{
try
{
var textFolder = contentEventContext.Content.GetFolder().AsActual();
// Delete the child contents in this folder.
DeleteChildContents(contentEventContext.Content, textFolder, textFolder);
if (textFolder.EmbeddedFolders != null)
{
foreach (var folderName in textFolder.EmbeddedFolders)
{
var childFolder = new TextFolder(textFolder.Repository, folderName);
DeleteChildContents(contentEventContext.Content, textFolder, childFolder);
}
}
}
catch (Exception e)
{
eventResult.Exception = e;
}
});
}
}
return eventResult;
}
/// <summary>
/// Instantiates a new Fact event definition.
/// </summary>
/// <remarks>
/// DO NOT ASSERT OR RETRACT FACTS WHEN HANDLING THIS EVENT!
/// </remarks>
/// <param name="fact">The Fact that generated the event.</param>
/// <param name="otherFact">The Other Fact that generated the event.</param>
/// <param name="context">The context of the event.</param>
public NewFactEventArgs(Fact fact, Fact otherFact, IEventContext context)
{
this.fact = fact;
this.otherFact = otherFact;
this.context = context;
}
public EventLogic(IEventContext context)
{
_context = context;
}
public void SetUp()
{
_model = new TestModel();
_eventContext = new EventContext();
}
EventResult ISubscriber.Receive(IEventContext context)
{
return null;
}
public EventStore(IEventContext context)
{
if (context == null) throw new ArgumentNullException(nameof(context));
_context = context;
}
public void OnEvent(IEventContext context)
{
Contexts.Add(context);
}
public void HideEventsInExactContext(IEventContext context)
{
OnFilterChanged();
context.ShowEvents = ShowEvents.HideExact;
_cachedContexts.Add(context);
}
public void HideEventsInContext(IEventContext context)
{
OnFilterChanged();
context.ShowEvents = ShowEvents.HideThisAndChildren;
_cachedContexts.Add(context);
}
