/// <summary>
/// Handles all types of command asynchronously.
/// </summary>
/// <param name="command">The command.</param>
/// <returns></returns>
/// <exception cref="ArgumentNullException">If command is null</exception>
/// <exception cref="ArgumentOutOfRangeException">If command has unsupported type</exception>
/// <exception cref="Exception">In case of more generic exception</exception>
public async Task <BaseItemEvent> HandleAsync(BaseItemCommand command)
{
try
{
if (command == null)
{
throw new ArgumentNullException(nameof(command));
}
BaseItemEvent evt;
switch (command)
{
case CreateItemCommand create:
evt = new ItemCreatedEvent(create.Item.Id, create.Item.Name, command.UserName, Guid.NewGuid(), DateTime.UtcNow);
break;
case DeleteItemCommand delete:
evt = new ItemDeletedEvent(delete.ItemId, delete.UserName, Guid.NewGuid(), DateTime.UtcNow);
break;
case UpdateItemCommand update:
evt = new ItemUpdatedEvent(update.Item.Id, update.Item.Name, update.UserName, Guid.NewGuid(), DateTime.UtcNow);
break;
default:
throw new ArgumentOutOfRangeException(nameof(command));
}
var applicationResult = await this.root.ApplyEventAsync(evt);
switch (applicationResult)
{
case SuccessAggregateApplicationResult success:
await this.root.CommitAsync();
await this.publisher.PublishAsync(evt);
return(evt);
case ItemNotFoundApplicationResult notFound:
throw new ItemNotFoundException();
case ItemAlreadyExistsApplicationResult itemExists:
throw new ItemAlreadyExistsException(itemExists.Message);
case FailedAggregateApplicationResult failed:
throw new Exception(failed.Error);
default:
throw new ArgumentOutOfRangeException(nameof(applicationResult));
}
}
catch (Exception e)
{
await this.root.RollbackAsync();
this.logger.LogError(e, $"Failed to process command {command.GetType().Name}");
throw;
}
}
private void EventServiceOnItemUpdated(object sender, ItemUpdatedEvent eventObject)
{
if (eventObject.Target == Name)
{
Updated?.Invoke(this, eventObject);
}
}
/// <summary>
/// Applies the specified item updated event.
/// </summary>
/// <param name="itemUpdatedEvent">The item updated event.</param>
/// <exception cref="System.InvalidOperationException">Cannot update an item based on a different Item Definition.</exception>
public void Apply(ItemUpdatedEvent itemUpdatedEvent)
{
if (itemUpdatedEvent.ItemDefinitionCode != ItemDefinitionCode)
{
throw new InvalidOperationException("Cannot update an item based on a different Item Definition.");
}
Value = itemUpdatedEvent.Value;
}
/// <summary>Updates the item.</summary>
/// <param name="itemDefinition">The item definition.</param>
/// <param name="value">The value.</param>
public virtual void UpdateItem(ItemDefinition itemDefinition, object value)
{
//TODO: Figure out how to make sure item definition is valid for this assessment.
var itemUpdatedEvent = new ItemUpdatedEvent(Key, Version, itemDefinition.CodedConcept.Code, value, itemDefinition.GetIsRequired());
AssessmentRuleEngineExecutor.CreateRuleEngineExecutor(this)
.ForItemInstance(new ItemInstance(itemDefinition.CodedConcept.Code, value, itemDefinition.GetIsRequired()))
.Execute(() => RaiseEvent(itemUpdatedEvent));
}
public void Handle(ItemUpdatedEvent @event)
{
if (!string.IsNullOrEmpty(@event.Name))
{
Name = @event.Name;
}
if (@event.Quantity.HasValue)
{
Quantity = @event.Quantity.Value;
}
}
public void Update(string name, int quantity)
{
var itemUpdatedEvent = new ItemUpdatedEvent
{
AggregateId = Id,
Name = name,
Quantity = quantity
};
ApplyChange(itemUpdatedEvent);
Events.Add(itemUpdatedEvent);
}
private void Apply(ItemUpdatedEvent itemUpdatedEvent)
{
var itemInstance = ItemInstances.FirstOrDefault(ii => ii.ItemDefinitionCode == itemUpdatedEvent.ItemDefinitionCode);
var isNull = itemUpdatedEvent.Value == null || string.IsNullOrEmpty(itemUpdatedEvent.Value.ToString());
if (itemInstance != null && isNull)
{
_itemInstances.Remove(itemInstance);
}
if (itemInstance == null)
{
itemInstance = new ItemInstance(itemUpdatedEvent.ItemDefinitionCode, itemUpdatedEvent.Value, itemUpdatedEvent.IsRequired);
if (!isNull)
{
_itemInstances.Add(itemInstance);
}
}
else
{
itemInstance.Apply(itemUpdatedEvent);
}
var skippingContext = new SkippingContext();
if (_cachedRuleEngineExecutor == null)
{
var assessmentRuleCollectionFactory = new AssessmentRuleCollectionFactory();
_cachedRuleEngineExecutor = new RuleEngineExecutor <AssessmentInstance> (
this,
assessmentRuleCollectionFactory.CreateRuleCollection(this.AssessmentName));
}
_cachedRuleEngineExecutor
.ForRuleSet("ItemUpdatedRuleSet" + itemInstance.ItemDefinitionCode)
.WithContext(itemInstance, itemInstance.ItemDefinitionCode)
.WithContext(skippingContext)
.Execute();
skippingContext.SkippedItemDefinitions.ForEach(
item =>
{
if (item.GetIsRequired() && !_skippedItemDefinitions.Contains(item))
{
_skippedItemDefinitions.Add(item);
}
if (ItemInstances.Any(i => i.ItemDefinitionCode == item.CodedConcept.Code))
{
UpdateItem(item, null);
}
});
skippingContext.UnSkippedItemDefinitions.ForEach(item => _skippedItemDefinitions.Remove(item));
}
private void Apply(ItemUpdatedEvent itemUpdatedEvent)
{
var itemInstance = ItemInstances.FirstOrDefault(ii => ii.ItemDefinitionCode == itemUpdatedEvent.ItemDefinitionCode);
if (itemInstance == null)
{
_itemInstances.Add(new ItemInstance(itemUpdatedEvent.ItemDefinitionCode, itemUpdatedEvent.Value));
}
else
{
itemInstance.Apply(itemUpdatedEvent);
}
}
public void UpdateItem(string itemDefinitionCode, object value)
{
//TODO: Figure out how to make sure item definition is valid for this assessment.
//if ( !AssessmentDefinition.ItemDefinitions.Contains ( itemDefinition ) )
//{
// throw new ArgumentException("Assessment Definition does not contain the item definition.","itemDefinition");
//}
var itemUpdatedEvent = new ItemUpdatedEvent(Key, Version, itemDefinitionCode, value);
AssessmentRuleEngineExecutor.CreateRuleEngineExecutor(this)
.ForItemDefinitionCode(itemDefinitionCode)
.WithContext(itemUpdatedEvent)
.Execute(() => RaiseEvent(itemUpdatedEvent));
}
public void Handle(ItemUpdatedEvent message)
{
var lastModified = _assessmentInstanceRepository.GetLastModifiedDate(message.Key);
const string cmd =
@"UPDATE AssessmentModule.AssessmentInstance SET LastModifiedTime = @LastModifiedTime
where AssessmentInstanceKey = @AssessmentInstanceKey";
using (IDbConnection connection = _connectionFactory.CreateConnection())
{
connection.Execute(cmd, new
{
AssessmentInstanceKey = message.Key,
LastModifiedTime = lastModified,
});
}
}
/// <summary>Handles the specified message.</summary>
/// <param name="message">The message.</param>
public void Handle(ItemUpdatedEvent message)
{
var lastModified = _assessmentInstanceRepository.GetLastModifiedDate(message.Key);
var assessmentInstance = _assessmentInstanceRepository.GetByKey(message.Key);
const string Cmd =
@"UPDATE AssessmentModule.AssessmentInstance SET LastModifiedTime = @LastModifiedTime
where AssessmentInstanceKey = @AssessmentInstanceKey";
using (var connection = _connectionFactory.CreateConnection())
{
connection.Execute(
Cmd,
new
{
AssessmentInstanceKey = message.Key,
LastModifiedTime = lastModified,
});
connection.Execute(
"UPDATE AssessmentModule.AssessmentInstance SET PercentComplete = @PercentComplete WHERE AssessmentInstanceKey = @AssessmentInstanceKey",
new { assessmentInstance.CalculateCompleteness().PercentComplete, AssessmentInstanceKey = assessmentInstance.Key });
}
}
public async Task <EventResult <int> > Handle(ItemUpdatedEvent request, CancellationToken cancellationToken)
{
return(await Task.FromResult(new EventResult <int>(request.Entity.Description.Length)));
}
public void Publish(ItemUpdatedEvent itemUpdatedEvent)
{
_bus.Publish(itemUpdatedEvent);
}
public virtual void Update(ItemUpdatedEvent message)
{
}
public void Handle(ItemUpdatedEvent @event)
{
hub.Clients.All.globalMessageRecieved(@event);
}
