private void UpdateModuleStatus(IUnitOfWork uow, bool isLoadEvent, AggregateEvent agEvent)
{
var thisModule = uow.ModuleRepository.FindSingle(x => x.Name == agEvent.SerialNumber);
if (thisModule != null)
{
bool atFeeder = uow.SettingsRepository.EventAtFeeder(agEvent);
bool atGinYard = uow.SettingsRepository.EventOnGinYard(agEvent);
if (!isLoadEvent && atFeeder)
{
thisModule.ModuleStatus = ModuleStatus.ON_FEEDER;
}
else if (!isLoadEvent && atGinYard)
{
thisModule.ModuleStatus = ModuleStatus.AT_GIN;
}
else if (isLoadEvent && !atFeeder && !atGinYard)
{
thisModule.ModuleStatus = ModuleStatus.PICKED_UP;
}
else if (!isLoadEvent && !atFeeder && !atGinYard)
{
thisModule.ModuleStatus = ModuleStatus.IN_FIELD;
}
uow.ModuleRepository.Save(thisModule);
uow.SaveChanges();
}
}
public IEvent TestApplication([FromBody] ChangePersonName command)
{
return(AggregateEvent.CreateEvent(nameof(PersonNameChanged), command, new PersonNameChanged()
{
PersonName = command.PersonName
}, 1));
}
/// <summary>
/// Dispatches the specified event across the listeners that can consume the event.
/// </summary>
/// <param name="incomingEvent">The event.</param>
public void Dispatch(AggregateEvent incomingEvent)
{
Check.NotNull(() => incomingEvent);
this.enqueuedEvents.Enqueue(incomingEvent);
if (!this.processingSync)
{
this.processingSync = true;
while (this.enqueuedEvents.Count > 0)
{
var eventToProcess = this.enqueuedEvents.Dequeue();
if (eventToProcess.ControlEvent == false)
{
foreach (var listener in this.syncListeners)
{
listener.Consume(eventToProcess);
}
}
if (eventToProcess.ControlEvent == false)
{
var eventDispatcherData = new EventDispatcherData
{
AggregateUid = eventToProcess.AggregateUid
};
this.eventDelayer.Call(eventDispatcherData);
}
}
this.processingSync = false;
}
}
private void OnEventPublished(AggregateEvent aggregateEvent)
{
if (Performed != null)
{
Performed(aggregateEvent);
}
}
/// <summary>
/// Dispatches the specified event.
/// </summary>
/// <param name="incomingEvent">The event.</param>
/// <exception cref="System.NotImplementedException"></exception>
public void Consume(AggregateEvent incomingEvent)
{
foreach (var job in this.jobs)
{
job.Consume(incomingEvent);
}
}
private void ConsumeEventByListeners(AggregateEvent @event, IEnumerable <IAsyncListener> listeners)
{
using (var context = new ThreadContextContainer())
{
this.eventContext.LoadFromEvent(@event);
foreach (var listener in listeners)
{
try
{
listener.Consume(@event);
}
catch
{
var message = S.Invariant(
$@"Error processing the listener {listener.GetType().ToString()}
for aggregate {@event.AggregateUid},
version {@event.AggregateVersion},
event type {@event.GetType().ToString()}");
this.log.LogError(message);
throw;
}
}
this.work.MarkEventAsAsyncProcessed(@event);
work.Commit();
}
}
public void Commit()
{
for (int i = 0; i < Events.Count; i++)
{
AggregateEvent @evt = _aggregate._unsavedEvents.Dequeue();
_aggregate._savedEvents.Enqueue(@evt);
}
}
/// <summary>
/// Consumes the specified incoming event.
/// </summary>
/// <param name="incomingEvent">The incoming event.</param>
public void Consume(AggregateEvent incomingEvent)
{
Check.NotNull(() => incomingEvent);
this.GetType()
.GetMethod("ApplyGeneric")
.MakeGenericMethod(incomingEvent.GetType())
.Invoke(this, new object[] { incomingEvent });
}
private void HandleRestoreReadModelEvent(AggregateEvent aggregateEvent)
{
var eventType = Type.GetType(aggregateEvent.EventType);
var @event = _eventSerializationStrategy.DeserializeEvent(aggregateEvent.SerializedEvent, eventType);
GetType().GetMethod("HandleEvent", BindingFlags.NonPublic | BindingFlags.Instance)
.MakeGenericMethod(eventType)
.Invoke(Instance, new[] { @event });
}
public async Task <CarCreated> Handle(RequestCreateCar request, CancellationToken cancellationToken)
{
var car = await _carModel.CreateNewCarFromEvent(request);
var carCreated = CarCreated.From(car);
await _mediator.Publish(AggregateEvent.Create <RequestCreateCar>(car.Id, carCreated, request));
await _mediator.Publish(carCreated);
return(carCreated);
}
public async Task <CarManufactureChanged> Handle(RequestChangeCarManufacture request, CancellationToken cancellationToken)
{
var result = await _carModel.ChangeCarManufacture(request);
var evt = CarManufactureChanged.From(result);
await _mediator.Publish(AggregateEvent.Create <RequestChangeCarManufacture>(evt.AggregateId, evt, request));
await _mediator.Publish(evt);
return(evt);
}
private void CorrectLoadNumber(IUnitOfWork uow, bool isLoadEvent, AggregateEvent agEvent)
{
if (!isLoadEvent && !uow.SettingsRepository.CoordsOnGinYard(agEvent.AverageLat, agEvent.AverageLong) && !uow.SettingsRepository.CoordsAtFeeder(agEvent.AverageLat, agEvent.AverageLong))
{
//string lastLoadNumber = uow.TruckRepository.GetLastLoadNumber();
uow.TruckRepository.ClearLoadNumber(agEvent.SerialNumber);
foreach (var evt in _aggregateEvents.Where(a => a.SerialNumber == agEvent.SerialNumber))
{
evt.LoadNumber = "";
}
uow.SaveChanges();
}
}
private void NewAggregateEvent(AggregateEvent aggEvent)
{
try
{
System.Windows.Application.Current.Dispatcher.Invoke(new Action(() =>
{
AggregateEvents.Add(aggEvent);
}));
}
catch (System.Threading.ThreadInterruptedException intExc)
{
System.Diagnostics.Trace.Write(intExc.Message);
}
}
public async Task AddEventAsync(AggregateEvent @event)
{
string serialized = _eventSerializer.Serialize(@event);
var entity = new EventEntity
{
Id = @event.Id,
AggregateId = @event.AggregateId,
AggregateVersion = @event.AggregateVersion,
Serialized = serialized
};
await _context.GetDbSet().AddAsync(entity);
await _context.SaveChangesAsync();
}
private async Task ProcessEvent(AggregateEvent @event)
{
var sagaEvent = EventSerializer.DeserializeEvent(@event);
switch (sagaEvent)
{
case Executing executing:
_runningSagas.Add(executing.Id);
break;
case Compensating compensating:
_runningSagas.Add(compensating.Id);
break;
case Executed executed:
_runningSagas.Remove(executed.Id);
break;
case Compensated compensated:
_runningSagas.Remove(compensated.Id);
break;
case Suspended suspended:
_runningSagas.Remove(suspended.Id);
break;
case Cancelled cancelled:
_runningSagas.Remove(cancelled.Id);
break;
case Faulted faulted:
_runningSagas.Remove(faulted.Id);
break;
default:
break;
}
_lastReceivedEventId = @event.Id;
if (_lastReceivedEventId % 100 == 0)
{
await ApplyEvent(
new CheckPointCreated { LastProcessedEventId = _lastReceivedEventId },
@event.RootEventId,
@event.ParentEventId
);
}
}
private void ProcessAggregatedEvent(AggregateEvent data)
{
Logging.Logger.Log("DEBUG", "Processing load/unload event in pickup list.");
if (pickupList != null)
{
LoadData(ListID);
if (data.EventType == EventType.LOADED)
{
if (_windowService.IsWindowOpen(WindowType.LoadingWindow))
{
_windowService.CloseModalWindow(WindowType.LoadingWindow);
}
}
}
}
public async Task AddEventAsync(AggregateEvent @event)
{
string serialized = _eventSerializer.Serialize(@event);
string filePath = GetAggregateFilePath(@event.AggregateId, createFolderIfNotExist: true);
using (var fs = new FileStream(filePath, FileMode.Append, FileAccess.Write, FileShare.None))
using (var sw = new StreamWriter(fs))
{
if (fs.Position > 0)
{
await sw.WriteAsync(_options.Value.EventSeparator);
}
await sw.WriteAsync(serialized);
}
}
private void ProcessEvent(AggregateEvent @event, bool theLastOne)
{
IEnumerable <IAsyncListener> listeners;
if (theLastOne)
{
listeners = this.asyncListeners;
}
else
{
listeners = this.asyncListeners.Where(x => !x.ConsumeOnlyLastEvent).ToArray();
}
this.ConsumeEventByListeners(@event, listeners);
}
public async Task Receive(AggregateEvent @event)
{
if (@event.Id > _lastReceivedEventId)
{
// check to see if any events were missed
if (@event.Id != _lastReceivedEventId + 1)
{
await RecoverEventQueue(_lastReceivedEventId);
_logger.LogWarning($"Missed event, recovered={_lastReceivedEventId}, received={@event.Id}");
return;
}
// process event
await ProcessEvent(@event);
}
}
private async Task ApplyEvent(AggregateEvent @event)
{
foreach (var projectorInfo in _projectionSchema.Projectors)
{
if (!projectorInfo.Events.Any(i => i.Type == @event.GetType()))
{
continue;
}
var projector = (Projector)Activator.CreateInstance(projectorInfo.Type);
var id = projector.RunIdGetterMethod(@event);
var view = await _viewStore.Load(projectorInfo.AggregateView, id);
if (view == null)
{
view = (AggregateView)Activator.CreateInstance(projectorInfo.AggregateView.Type);
view.AggregateId = id;
}
try
{
projector.Apply(view, @event);
}
catch (Exception _)
{
view = (AggregateView)Activator.CreateInstance(projectorInfo.AggregateView.Type);
view.AggregateId = id;
var events = await _eventStore.LoadEvents(projectorInfo.Events);
foreach (var e in events)
{
var idFromEvent = projector.RunIdGetterMethod(e);
if (!idFromEvent.Equals(view.AggregateId))
{
continue;
}
projector.Apply(view, @event);
}
projector.Apply(view, @event);
}
await _viewStore.Save(view);
_logger.LogTrace("'{projector}' updated '{view}' according to '{event}'", projectorInfo, projectorInfo.AggregateView, @event);
}
}
private async Task ReactToEvent(AggregateEvent @event)
{
var eventInfo = _logicSchema.GetAggregateEvent(@event.GetType());
foreach (var sagaInfo in _logicSchema.GetReactingSagas(eventInfo))
{
var saga = (Saga)Activator.CreateInstance(sagaInfo.Type);
var commands = await saga.Handle(@event);
foreach (var command in commands)
{
await _commandBus.Send(command);
_logger.LogTrace("'{saga}' produced '{command}' in reaction to '{event}'", sagaInfo, command, eventInfo);
}
}
}
public static EventData ToEventData(this AggregateEvent message, IDictionary <string, object> headers)
{
var data = Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(message, SerializerSettings));
var eventHeaders = new Dictionary <string, object>(headers)
{
{
EventMetaDataKeys.EventClrType, message.GetType().AssemblyQualifiedName
}
};
var metadata = Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(eventHeaders, SerializerSettings));
var typeName = message.GetType().Name;
var eventId = Guid.NewGuid();
return(new EventData(eventId, typeName, true, data, metadata));
}
protected override void ApplyEvent(AggregateEvent @event)
{
if (@event is GiftCardCreated created)
{
Balance = created.InitialCredit;
}
else if (@event is GiftCardDebited debited)
{
if (Balance >= debited.Amount)
{
Balance -= debited.Amount;
}
else
{
throw new InvalidOperationException("Not enough credit");
}
}
}
/// <summary>
/// Inserts event for a manual unload override
/// </summary>
/// <param name="SerialNumber"></param>
public static void ForceUnload(string SerialNumber)
{
using (var uow = SimpleIoc.Default.GetInstance <IUnitOfWorkFactory>().CreateUnitOfWork())
{
var truck = uow.SettingsRepository.GetCurrentTruck();
var driver = uow.SettingsRepository.GetCurrentDriver();
var aggEvt = instance._aggregateEvents.FirstOrDefault(evt => evt.SerialNumber == SerialNumber && !string.IsNullOrEmpty(evt.Epc));
string epc = (aggEvt != null) ? aggEvt.Epc : "";
AggregateEvent agEvent = new AggregateEvent();
agEvent.Timestamp = DateTime.Now.ToUniversalTime();
var gpsCoords = GPSDataProvider.GetLastCoords();
double lat = GPSHelper.SafeLat(gpsCoords);
double lng = GPSHelper.SafeLong(gpsCoords);
agEvent.SerialNumber = SerialNumber;
agEvent.Epc = epc;
agEvent.AverageLat = lat;
agEvent.AverageLong = lng;
agEvent.MedianLat = lat;
agEvent.MedianLong = lng;
agEvent.FirstLat = lat;
agEvent.FirstLong = lng;
agEvent.LastLat = lat;
agEvent.LastLong = lng;
agEvent.TruckID = (truck != null) ? truck.Id : "";
agEvent.DriverID = (driver != null) ? driver.Id : "";
agEvent.EventType = EventType.UNLOADED;
agEvent.Created = DateTime.Now.ToUniversalTime();
instance._aggregateEvents.Add(agEvent);
uow.AggregateEventRepository.Add(agEvent);
uow.SaveChanges();
instance.CorrectLoadNumber(uow, false, agEvent);
instance.UpdateModuleStatus(uow, false, agEvent);
//Messenger.Default.Send<AggregateEvent>(agEvent);
}
}
public async Task <CarAddedToInventory> Handle(RequestAddCarToInventory request, CancellationToken cancellationToken)
{
var ivt = new Inventory
{
Id = request.AggregateId,
CarId = request.CarId,
Lot = request.Lot,
Quantity = request.Quanity
};
context.Inventory.Add(ivt);
await context.SaveChangesAsync();
var evt = CarAddedToInventory.From(ivt);
await mediator.Publish(AggregateEvent.Create <RequestAddCarToInventory>(request.AggregateId, evt, request));
await mediator.Publish(evt);
return(evt);
}
public void EventAppended(AggregateEvent <IInventoryItemAggregate, IInventoryItemState> e)
{
if (!(e.Event != null && e.Event is IInventoryItemEvent))
{
return;
}
IInventoryItemEvent inventoryItemEvent = (IInventoryItemEvent)e.Event;
IEnumerable <IInventoryItemEntryStateCreated> itemEntriesCreated = null;
if (inventoryItemEvent is IInventoryItemStateCreated)
{
itemEntriesCreated = ((IInventoryItemStateCreated)inventoryItemEvent).InventoryItemEntryEvents;
}
else if (inventoryItemEvent is IInventoryItemStateMergePatched)
{
itemEntriesCreated = ((IInventoryItemStateMergePatched)inventoryItemEvent).InventoryItemEntryEvents
.Where(ie => ie is IInventoryItemEntryStateCreated).Cast <IInventoryItemEntryStateCreated>();
}
if (itemEntriesCreated == null)
{
return;
}
foreach (var iie in itemEntriesCreated)
{
foreach (var pr in GetPostingRules(iie.InventoryItemEntryEventId.InventoryItemId))
{
var outputQuantity = GetOutputQuantity(pr, iie);
if (outputQuantity.Equals(0))
{
continue;
}
var tid = GetOrCreateInventoryPRTriggered(pr, iie);
var outputItemId = GetOutputInventoryItemId(pr, iie.InventoryItemEntryEventId.InventoryItemId);
//_log.Debug(outputItemId.ProductId + ", " + outputItemId.LocatorId + ", " + outputItemId.AttributeSetInstanceId);
CreateOrUpdateOutputAccount(pr.OutputAccountName, outputQuantity, tid, outputItemId);
}
}
}
public ICollection <AggregateEvent <TDomainEvent> > ReadEventsByType <TDomainEvent>() where TDomainEvent : IDomainEvent
{
var streamName = "$et-" + EventExtensions.UnifiedEventName(typeof(TDomainEvent));
var eventsForAggregate = new List <AggregateEvent <TDomainEvent> >();
StreamEventsSlice currentSlice;
var nextSliceStart = 0L;
do
{
currentSlice = connection
.ReadStreamEventsForwardAsync(streamName, nextSliceStart, Settings.ReadPageSize, true)
.Result;
nextSliceStart = currentSlice.NextEventNumber;
foreach (var evnt in currentSlice.Events)
{
var metaData = Serializer.DeserializeMetadata(evnt.Event.Metadata);
var e = (TDomainEvent)Serializer.DeserializeEvent(evnt.Event.Metadata, evnt.Event.Data);
var k = evnt.Event.EventStreamId;
System.Console.WriteLine(k);
var aggregateStreamType = metaData[Settings.AggregateClrTypeHeader]?.ToString();
var aggregateStreamId = metaData[Settings.AggregateIdHeader]?.ToString() ?? Guid.NewGuid().ToString(); // k.Substring(k.IndexOf('-') + 1);
System.Console.WriteLine(aggregateStreamId);
var aggregateKey = new AggregateKey(Type.GetType(aggregateStreamType), Guid.Parse(aggregateStreamId));
var aggrEvent = new AggregateEvent <TDomainEvent>(aggregateKey, e);
eventsForAggregate.Add(aggrEvent);
}
} while (!currentSlice.IsEndOfStream);
return(eventsForAggregate);
}
public async Task Publish(AggregateEvent @event)
{
if (@event == null)
{
throw new ArgumentNullException(nameof(@event));
}
_queue.Enqueue(@event);
_logger.LogInformation("{event} published (agg: {aggId})", @event.GetType(), @event.AggregateId);
if (_busy)
{
return;
}
try
{
_busy = true;
await HandleQueue();
}
finally
{
_busy = false;
}
}
protected void When(AggregateEvent e)
{
}
public void Apply(AggregateEvent e)
{
ApplyInternal(e);
}
protected override void Apply(AggregateEvent e)
{
this._events.Add(e);
ApplyInternal(e);
}
private void OnEventPublished(AggregateEvent aggregateEvent)
{
if (Performed != null)
Performed(aggregateEvent);
}
