protected void ThrowOnWrongEvent(IInOutStateEvent stateEvent)
{
var id = new System.Text.StringBuilder();
id.Append("[").Append("InOut|");
var stateEntityId = this.DocumentNumber; // Aggregate Id
var eventEntityId = stateEvent.StateEventId.DocumentNumber; // EntityBase.Aggregate.GetStateEventIdPropertyIdName();
if (stateEntityId != eventEntityId)
{
throw DomainError.Named("mutateWrongEntity", "Entity Id {0} in state but entity id {1} in event", stateEntityId, eventEntityId);
}
id.Append(stateEntityId).Append(",");
id.Append("]");
var stateVersion = this.Version;
var eventVersion = stateEvent.StateEventId.Version;
if (stateVersion != eventVersion)
{
throw OptimisticConcurrencyException.Create(stateVersion, eventVersion, id.ToString());
}
}
public virtual void AppendToStream(IIdentity id, long originalVersion, ICollection <IEvent> events)
{
if (events.Count == 0)
{
return;
}
var name = this.IdentityToString(id);
var data = this.SerializeEvent(events.ToArray());
try
{
this.AppendOnlyStore.Append(name, data, originalVersion);
}
catch (AppendOnlyStoreConcurrencyException e)
{
// load server events
var server = this.LoadEventStream(id, 0, int.MaxValue);
// throw a real problem
throw OptimisticConcurrencyException.Create(server.Version, e.ExpectedStreamVersion, id, server.Events, events.ToList());
}
// technically there should be a parallel process that queries new changes
// from the event store and sends them via messages (avoiding 2PC problem).
// however, for demo purposes, we'll just send them to the console from here
Console.ForegroundColor = ConsoleColor.DarkGreen;
foreach (var @event in events)
{
Logger.DebugFormat("{0} r{1} Event: {2}", id, originalVersion, @event);
}
}
private static void ThrowDbUpdateConcurrencyException()
{
const string message = "Store update, insert, or delete statement affected an unexpected number of rows (0). Entities may have been modified or deleted since entities were loaded. See http://go.microsoft.com/fwlink/?LinkId=472540 for information on understanding and handling optimistic concurrency exceptions.";
var innerException = new OptimisticConcurrencyException(message);
throw new DbUpdateConcurrencyException(innerException.Message, innerException);
}
protected void ThrowOnWrongEvent(IInventoryItemRequirementEvent e)
{
var id = new System.Text.StringBuilder();
id.Append("[").Append("InventoryItemRequirement|");
var stateEntityId = this.InventoryItemRequirementId; // Aggregate Id
var eventEntityId = e.InventoryItemRequirementEventId.InventoryItemRequirementId;
if (stateEntityId != eventEntityId)
{
throw DomainError.Named("mutateWrongEntity", "Entity Id {0} in state but entity id {1} in event", stateEntityId, eventEntityId);
}
id.Append(stateEntityId).Append(",");
id.Append("]");
var stateVersion = this.Version;
var eventVersion = e.InventoryItemRequirementEventId.Version;
if (stateVersion != eventVersion)
{
throw OptimisticConcurrencyException.Create(stateVersion, eventVersion, id.ToString());
}
}
protected void ThrowOnWrongEvent(IAttributeSetInstanceExtensionFieldMvoStateEvent stateEvent)
{
var id = new System.Text.StringBuilder();
id.Append("[").Append("AttributeSetInstanceExtensionFieldMvo|");
var stateEntityId = this.AttributeSetInstanceExtensionFieldId; // Aggregate Id
var eventEntityId = stateEvent.StateEventId.AttributeSetInstanceExtensionFieldId; // EntityBase.Aggregate.GetStateEventIdPropertyIdName();
if (stateEntityId != eventEntityId)
{
throw DomainError.Named("mutateWrongEntity", "Entity Id {0} in state but entity id {1} in event", stateEntityId, eventEntityId);
}
id.Append(stateEntityId).Append(",");
id.Append("]");
var stateVersion = this.AttrSetInstEFGroupVersion;
var eventVersion = stateEvent.StateEventId.AttrSetInstEFGroupVersion;
if (stateVersion != eventVersion)
{
throw OptimisticConcurrencyException.Create(stateVersion, eventVersion, id.ToString());
}
}
protected void ThrowOnWrongEvent(IOrderItemShipGroupAssociationMvoEvent e)
{
var id = new System.Text.StringBuilder();
id.Append("[").Append("OrderItemShipGroupAssociationMvo|");
var stateEntityId = this.OrderItemShipGroupAssociationId; // Aggregate Id
var eventEntityId = e.OrderItemShipGroupAssociationMvoEventId.OrderItemShipGroupAssociationId;
if (stateEntityId != eventEntityId)
{
throw DomainError.Named("mutateWrongEntity", "Entity Id {0} in state but entity id {1} in event", stateEntityId, eventEntityId);
}
id.Append(stateEntityId).Append(",");
id.Append("]");
var stateVersion = this.OrderVersion;
var eventVersion = e.OrderItemShipGroupAssociationMvoEventId.OrderVersion;
if (stateVersion != eventVersion)
{
throw OptimisticConcurrencyException.Create(stateVersion, eventVersion, id.ToString());
}
}
public async Task AppendToStream(IIdentity id, long expectedVersion, ICollection <IEvent> events)
{
if (events.Count == 0)
{
return;
}
var name = id.ToString();
var data = this.serializer.SerializeEvent(events.ToArray());
try
{
await this.appender.Append(name, data, expectedVersion);
}
catch (AppendOnlyStoreConcurrencyException e)
{
// load server events
var server = await this.LoadEventStream(id, 0, int.MaxValue);
// throw a real problem
throw OptimisticConcurrencyException.Create(server.Version, e.ExpectedStreamVersion, id, server.Events);
}
foreach (var @event in events)
{
Logger.DebugFormat("{0} r{1} Event: {2}", id, expectedVersion, @event);
}
}
public void AppendEventsToStream(string name, long streamVersion, ICollection <Event> events)
{
if (events.Count == 0)
{
return;
}
// functional events don't have an identity
try
{
_msgStore.AppendToStore(name, streamVersion, events.Cast <object>().ToArray());
}
catch (AppendOnlyStoreConcurrencyException e)
{
// load server events
var server = LoadEventStream(name);
// throw a real problem
throw OptimisticConcurrencyException.Create(server.StreamVersion, e.ExpectedStreamVersion, name, server.Events);
}
// sync handling. Normally we would push this to async
foreach (var @event in events)
{
_msgHandler.Handle(@event);
}
}
public void AfterThrowing(OptimisticConcurrencyException ex)
{
var ctx = new XmlApplicationContext("~/Springs/ErrorSpring.xml");
var errorAdmin = (IErrorBl)ctx["ErrorAdmin"];
errorAdmin.RegistrarErrorServicio(ex.Message, string.Format("MENSAJE :{0}///EXCEPCION INTERNA : {1}///DATA : {2} ///FUENTE : {3}///SITIO_DESTINO : {4}///SEGUIMIENTO DE PILA : {5}", ex.Message, ex.InnerException, ex.Data, ex.Source, ex.TargetSite, ex.StackTrace));
throw new FaultException <Exception>(ex, new FaultReason("Los datos que desea modificar han cambiado. Por favor regrese a la vista principal de datos e intente nuevamente."));
}
public void ShouldThisBeRetried_OptimisticConcurrencyException_ShouldBeRetired(int currentRetryCount, bool expectedShouldThisBeRetried)
{
// Assert
var optimisticConcurrencyException = new OptimisticConcurrencyException(A <string>());
// Act
var shouldThisBeRetried = Sut.ShouldThisBeRetried(optimisticConcurrencyException, A <TimeSpan>(), currentRetryCount);
// Assert
shouldThisBeRetried.ShouldBeRetried.Should().Be(expectedShouldThisBeRetried);
}
public void OptimisticConcurrencyException_with_relationship_entries_is_wrapped_as_IA_update_exception()
{
var original = new OptimisticConcurrencyException("Bang!", null, new[] { CreateEntityEntry(), CreateRelationshipEntry() });
var wrapped = new EagerInternalContext(new Mock <DbContext>().Object).WrapUpdateException(original);
Assert.IsType <DbUpdateException>(wrapped);
Assert.Equal(Strings.DbContext_IndependentAssociationUpdateException, wrapped.Message);
Assert.Empty(wrapped.Entries);
Assert.Same(original, wrapped.InnerException);
}
public void OptimisticConcurrencyException_with_null_entries_is_wrapped_as_normal_update_exception()
{
var original = new OptimisticConcurrencyException("Bang!");
var wrapped = new EagerInternalContext(new Mock <DbContext>().Object).WrapUpdateException(original);
Assert.IsType <DbUpdateConcurrencyException>(wrapped);
Assert.Equal("Bang!", wrapped.Message);
Assert.Empty(wrapped.Entries);
Assert.Same(original, wrapped.InnerException);
}
public void GivenOptimisticConcurrencyException_WhenMapped_ThenReturnsForbiddenHttpStatusWithProperMessage()
{
//Given
var id = Guid.NewGuid();
var version = Guid.NewGuid();
var exception = OptimisticConcurrencyException.For <TestEntity>(id, version);
//When
var codeInfo = ExceptionToHttpStatusMapper.Map(exception);
//Then
codeInfo.Code.Should().Be(HttpStatusCode.Conflict);
codeInfo.Message.Should()
.Be($"Cannot modify {typeof(TestEntity).Name} with id: {id}. Version `{version}` did not match.");
}
public virtual DbUpdateException WrapUpdateException(
UpdateException updateException)
{
if (updateException.StateEntries != null && updateException.StateEntries.Any <ObjectStateEntry>((Func <ObjectStateEntry, bool>)(e => e.Entity == null)))
{
return(new DbUpdateException(this, updateException, true));
}
OptimisticConcurrencyException innerException = updateException as OptimisticConcurrencyException;
if (innerException == null)
{
return(new DbUpdateException(this, updateException, false));
}
return((DbUpdateException) new DbUpdateConcurrencyException(this, innerException));
}
public void UpdateAuto(AutoDto modified, AutoDto original)
{
try
{
WriteActualMethod();
BusinessComponent.UpdateAuto(modified.ConvertToEntity(), original.ConvertToEntity());
}
catch (LocalOptimisticConcurrencyException <Auto> ex)
{
OptimisticConcurrencyException <AutoDto> enThrow = new OptimisticConcurrencyException <AutoDto>();
enThrow.Entity = ex.Entity.ConvertToDto();
throw new FaultException <OptimisticConcurrencyException <AutoDto> >(enThrow);
}
}
public void OptimisticConcurrencyException_without_relationship_entries_is_wrapped_as_normal_update_exception()
{
var entity1 = new object();
var entity2 = new object();
var original = new OptimisticConcurrencyException(
"Bang!", null, new[] { CreateEntityEntry(entity1), CreateEntityEntry(entity2) });
var wrapped = new EagerInternalContext(new Mock <DbContext>().Object).WrapUpdateException(original);
Assert.IsType <DbUpdateConcurrencyException>(wrapped);
Assert.Equal("Bang!", wrapped.Message);
Assert.Equal(2, wrapped.Entries.Count());
Assert.Same(entity1, wrapped.Entries.First().Entity);
Assert.Same(entity2, wrapped.Entries.Skip(1).First().Entity);
Assert.Same(original, wrapped.InnerException);
}
public void UpdateReservation(ReservationDto modified, ReservationDto original)
{
try
{
WriteActualMethod();
BusinessComponent.UpdateReservation(modified.ConvertToEntity(), original.ConvertToEntity());
}
catch (LocalOptimisticConcurrencyException <Reservation> ex)
{
var enThrow = new OptimisticConcurrencyException <ReservationDto> {
Entity = ex.Entity.ConvertToDto()
};
throw new FaultException <OptimisticConcurrencyException <ReservationDto> >(enThrow);
}
}
public void UpdateKunde(KundeDto modified, KundeDto original)
{
try
{
WriteActualMethod();
component.UpdateKunde(modified.ConvertToEntity(), original.ConvertToEntity());
}
catch (LocalOptimisticConcurrencyException <Kunde> ex)
{
var e = new OptimisticConcurrencyException <KundeDto> {
Entity = ex.Entity.ConvertToDto()
};
throw new FaultException <OptimisticConcurrencyException <KundeDto> >(e);
}
}
protected void ThrowOnWrongEvent(IAttributeSetInstanceExtensionFieldStateEvent stateEvent)
{
var id = new System.Text.StringBuilder();
id.Append("[").Append("AttributeSetInstanceExtensionField|");
var stateEntityIdGroupId = (this as IGlobalIdentity <AttributeSetInstanceExtensionFieldId>).GlobalId.GroupId;
var eventEntityIdGroupId = stateEvent.StateEventId.GroupId;
if (stateEntityIdGroupId != eventEntityIdGroupId)
{
throw DomainError.Named("mutateWrongEntity", "Entity Id GroupId {0} in state but entity id GroupId {1} in event", stateEntityIdGroupId, eventEntityIdGroupId);
}
id.Append(stateEntityIdGroupId).Append(",");
var stateEntityIdIndex = (this as IGlobalIdentity <AttributeSetInstanceExtensionFieldId>).GlobalId.Index;
var eventEntityIdIndex = stateEvent.StateEventId.Index;
if (stateEntityIdIndex != eventEntityIdIndex)
{
throw DomainError.Named("mutateWrongEntity", "Entity Id Index {0} in state but entity id Index {1} in event", stateEntityIdIndex, eventEntityIdIndex);
}
id.Append(stateEntityIdIndex).Append(",");
id.Append("]");
if (ForReapplying)
{
return;
}
var stateVersion = this.Version;
var eventVersion = stateEvent.Version;
if (AttributeSetInstanceExtensionFieldState.VersionZero == eventVersion)
{
eventVersion = stateEvent.Version = stateVersion;
}
if (stateVersion != eventVersion)
{
throw OptimisticConcurrencyException.Create(stateVersion, eventVersion, id.ToString());
}
}
protected void ThrowOnWrongEvent(IInOutLineStateEvent stateEvent)
{
var id = new System.Text.StringBuilder();
id.Append("[").Append("InOutLine|");
var stateEntityIdInOutDocumentNumber = (this as IGlobalIdentity <InOutLineId>).GlobalId.InOutDocumentNumber;
var eventEntityIdInOutDocumentNumber = stateEvent.StateEventId.InOutDocumentNumber;
if (stateEntityIdInOutDocumentNumber != eventEntityIdInOutDocumentNumber)
{
throw DomainError.Named("mutateWrongEntity", "Entity Id InOutDocumentNumber {0} in state but entity id InOutDocumentNumber {1} in event", stateEntityIdInOutDocumentNumber, eventEntityIdInOutDocumentNumber);
}
id.Append(stateEntityIdInOutDocumentNumber).Append(",");
var stateEntityIdLineNumber = (this as IGlobalIdentity <InOutLineId>).GlobalId.LineNumber;
var eventEntityIdLineNumber = stateEvent.StateEventId.LineNumber;
if (stateEntityIdLineNumber != eventEntityIdLineNumber)
{
throw DomainError.Named("mutateWrongEntity", "Entity Id LineNumber {0} in state but entity id LineNumber {1} in event", stateEntityIdLineNumber, eventEntityIdLineNumber);
}
id.Append(stateEntityIdLineNumber).Append(",");
id.Append("]");
if (ForReapplying)
{
return;
}
var stateVersion = this.Version;
var eventVersion = stateEvent.Version;
if (InOutLineState.VersionZero == eventVersion)
{
eventVersion = stateEvent.Version = stateVersion;
}
if (stateVersion != eventVersion)
{
throw OptimisticConcurrencyException.Create(stateVersion, eventVersion, id.ToString());
}
}
protected void ThrowOnWrongEvent(IUserClaimStateEvent stateEvent)
{
var id = new System.Text.StringBuilder();
id.Append("[").Append("UserClaim|");
var stateEntityIdUserId = (this as IGlobalIdentity <UserClaimId>).GlobalId.UserId;
var eventEntityIdUserId = stateEvent.StateEventId.UserId;
if (stateEntityIdUserId != eventEntityIdUserId)
{
throw DomainError.Named("mutateWrongEntity", "Entity Id UserId {0} in state but entity id UserId {1} in event", stateEntityIdUserId, eventEntityIdUserId);
}
id.Append(stateEntityIdUserId).Append(",");
var stateEntityIdClaimId = (this as IGlobalIdentity <UserClaimId>).GlobalId.ClaimId;
var eventEntityIdClaimId = stateEvent.StateEventId.ClaimId;
if (stateEntityIdClaimId != eventEntityIdClaimId)
{
throw DomainError.Named("mutateWrongEntity", "Entity Id ClaimId {0} in state but entity id ClaimId {1} in event", stateEntityIdClaimId, eventEntityIdClaimId);
}
id.Append(stateEntityIdClaimId).Append(",");
id.Append("]");
if (ForReapplying)
{
return;
}
var stateVersion = this.Version;
var eventVersion = stateEvent.Version;
if (UserClaimState.VersionZero == eventVersion)
{
eventVersion = stateEvent.Version = stateVersion;
}
if (stateVersion != eventVersion)
{
throw OptimisticConcurrencyException.Create(stateVersion, eventVersion, id.ToString());
}
}
public void AppendEventsToStream(IIdentity id, long streamVersion, ICollection <IEvent> events)
{
if (events.Count == 0)
{
return;
}
// functional events don't have an identity
var name = IdentityToKey(id);
try
{
_store.AppendToStore(name, MessageAttribute.Empty, streamVersion, events.Cast <object>().ToArray());
}
catch (AppendOnlyStoreConcurrencyException e)
{
// load server events
var server = LoadEventStream(id);
// throw a real problem
throw OptimisticConcurrencyException.Create(server.StreamVersion, e.ExpectedStreamVersion, id, server.Events);
}
}
public static HttpStatusCodeInfo Map(Exception exception)
{
if (CustomMaps.ContainsKey(exception.GetType()))
{
return(CustomMaps[exception.GetType()](exception));
}
var code = exception switch
{
ValidationException _ => HttpStatusCode.BadRequest,
System.ComponentModel.DataAnnotations.ValidationException _ => HttpStatusCode.BadRequest,
ArgumentException _ => HttpStatusCode.BadRequest,
UnauthorizedAccessException _ => HttpStatusCode.Unauthorized,
InvalidOperationException _ => HttpStatusCode.Forbidden,
NotFoundException _ => HttpStatusCode.NotFound,
OptimisticConcurrencyException _ => HttpStatusCode.Conflict,
NotImplementedException _ => HttpStatusCode.NotImplemented,
_ => HttpStatusCode.InternalServerError
};
return(new HttpStatusCodeInfo(code, exception.Message));
}
public void An_OptimisticConcurrencyException_is_a_concurrency_exception()
{
var exception = new OptimisticConcurrencyException();
exception.IsConcurrencyException().Should().BeTrue();
}
// <summary>
// Initializes a new instance of the <see cref="DbUpdateConcurrencyException" /> class.
// </summary>
// <param name="context"> The context. </param>
// <param name="innerException"> The inner exception. </param>
internal DbUpdateConcurrencyException(InternalContext context, OptimisticConcurrencyException innerException)
: base(context, innerException, involvesIndependentAssociations: false)
{
}
internal DbUpdateConcurrencyException(
InternalContext context,
OptimisticConcurrencyException innerException)
: base(context, (UpdateException)innerException, false)
{
}
public void An_OptimisticConcurrencyException_is_a_concurrency_exception()
{
var exception = new OptimisticConcurrencyException();
exception.IsConcurrencyException().Should().BeTrue();
}
