public async Task <Response> Handle(UpdateGrapeBlendCommand cmd)
{
var pagne =
await AggregateRepo.LoadAsync <Domain.Aggregates.Champagne.Champagne>(new AggregateId(cmd.ChampagneId));
if (pagne == null)
{
throw DomainError.Because($"Champagne with Id '{cmd.ChampagneId}' could not be found");
}
var grapes = cmd.Grapes.Select(x =>
new GrapeBlend(new GrapeBlendPercentage(x.Percentage), new GrapeVariety(x.GrapeVariety)));
pagne.Execute(new UpdateGrapeBlend(new AggregateId(cmd.ChampagneId), grapes));
await AggregateRepo.StoreAsync(pagne);
return(Response.Success());
}
void ThrowOnInvalidStateTransition(ICommand <UserId> e)
{
if (_state.Version == 0)
{
if (e is CreateUser)
{
return;
}
throw DomainError.Named("premature", "Can't do anything to unexistent aggregate");
}
if (_state.Version == -1)
{
throw DomainError.Named("zombie", "Can't do anything to deleted aggregate.");
}
if (e is CreateUser)
{
throw DomainError.Named("rebirth", "Can't create aggregate that already exists");
}
}
public virtual void ThrowOnInvalidStateTransition(ICommand c)
{
if (((IPhysicalInventoryLineMvoStateProperties)_state).PhysicalInventoryVersion == PhysicalInventoryLineMvoState.VersionZero)
{
if (IsCommandCreate((IPhysicalInventoryLineMvoCommand)c))
{
return;
}
throw DomainError.Named("premature", "Can't do anything to unexistent aggregate");
}
if (_state.Deleted)
{
throw DomainError.Named("zombie", "Can't do anything to deleted aggregate.");
}
if (IsCommandCreate((IPhysicalInventoryLineMvoCommand)c))
{
throw DomainError.Named("rebirth", "Can't create aggregate that already exists");
}
}
public override async Task ExecuteAsync(
KontoAggregate aggregate,
KontoEroeffnenCommand command,
CancellationToken cancellationToken)
{
var query = new KontoByBenutzerQuery(command.Benutzer, false);
if (await this.queryProcessor.ProcessAsync(query, cancellationToken) != null)
{
throw DomainError.With($"Konto für Benutzer {command.Benutzer} existiert bereits.");
}
aggregate.Eroeffnen(command.Benutzer);
if (command.Bezahlung != null)
{
aggregate.BezahlungZuordnen(command.Bezahlung);
}
}
public virtual ShipmentPackageContentMvoStateCreatedOrMergePatchedOrDeletedDto ToShipmentPackageContentMvoStateEventDto(IShipmentPackageContentMvoEvent stateEvent)
{
if (stateEvent.EventType == StateEventType.Created)
{
var e = (IShipmentPackageContentMvoStateCreated)stateEvent;
return(ToShipmentPackageContentMvoStateCreatedDto(e));
}
else if (stateEvent.EventType == StateEventType.MergePatched)
{
var e = (IShipmentPackageContentMvoStateMergePatched)stateEvent;
return(ToShipmentPackageContentMvoStateMergePatchedDto(e));
}
else if (stateEvent.EventType == StateEventType.Deleted)
{
var e = (IShipmentPackageContentMvoStateDeleted)stateEvent;
return(ToShipmentPackageContentMvoStateDeletedDto(e));
}
throw DomainError.Named("invalidEventType", String.Format("Invalid state event type: {0}", stateEvent.EventType));
}
public virtual OrderItemShipGrpInvReservationStateCreatedOrMergePatchedOrDeletedDto ToOrderItemShipGrpInvReservationStateEventDto(IOrderItemShipGrpInvReservationEvent stateEvent)
{
if (stateEvent.EventType == StateEventType.Created)
{
var e = (IOrderItemShipGrpInvReservationStateCreated)stateEvent;
return(ToOrderItemShipGrpInvReservationStateCreatedDto(e));
}
else if (stateEvent.EventType == StateEventType.MergePatched)
{
var e = (IOrderItemShipGrpInvReservationStateMergePatched)stateEvent;
return(ToOrderItemShipGrpInvReservationStateMergePatchedDto(e));
}
else if (stateEvent.EventType == StateEventType.Deleted)
{
var e = (IOrderItemShipGrpInvReservationStateDeleted)stateEvent;
return(ToOrderItemShipGrpInvReservationStateDeletedDto(e));
}
throw DomainError.Named("invalidEventType", String.Format("Invalid state event type: {0}", stateEvent.EventType));
}
public virtual ProductCategoryStateCreatedOrMergePatchedOrDeletedDto ToProductCategoryStateEventDto(IProductCategoryEvent stateEvent)
{
if (stateEvent.EventType == StateEventType.Created)
{
var e = (IProductCategoryStateCreated)stateEvent;
return(ToProductCategoryStateCreatedDto(e));
}
else if (stateEvent.EventType == StateEventType.MergePatched)
{
var e = (IProductCategoryStateMergePatched)stateEvent;
return(ToProductCategoryStateMergePatchedDto(e));
}
else if (stateEvent.EventType == StateEventType.Deleted)
{
var e = (IProductCategoryStateDeleted)stateEvent;
return(ToProductCategoryStateDeletedDto(e));
}
throw DomainError.Named("invalidEventType", String.Format("Invalid state event type: {0}", stateEvent.EventType));
}
public virtual MovementConfirmationLineStateCreatedOrMergePatchedOrRemovedDto ToMovementConfirmationLineStateEventDto(IMovementConfirmationLineEvent stateEvent)
{
if (stateEvent.EventType == StateEventType.Created)
{
var e = (IMovementConfirmationLineStateCreated)stateEvent;
return(ToMovementConfirmationLineStateCreatedDto(e));
}
else if (stateEvent.EventType == StateEventType.MergePatched)
{
var e = (IMovementConfirmationLineStateMergePatched)stateEvent;
return(ToMovementConfirmationLineStateMergePatchedDto(e));
}
else if (stateEvent.EventType == StateEventType.Removed)
{
var e = (IMovementConfirmationLineStateRemoved)stateEvent;
return(ToMovementConfirmationLineStateRemovedDto(e));
}
throw DomainError.Named("invalidEventType", String.Format("Invalid state event type: {0}", stateEvent.EventType));
}
public virtual GoodIdentificationTypeStateCreatedOrMergePatchedOrDeletedDto ToGoodIdentificationTypeStateEventDto(IGoodIdentificationTypeEvent stateEvent)
{
if (stateEvent.EventType == StateEventType.Created)
{
var e = (IGoodIdentificationTypeStateCreated)stateEvent;
return(ToGoodIdentificationTypeStateCreatedDto(e));
}
else if (stateEvent.EventType == StateEventType.MergePatched)
{
var e = (IGoodIdentificationTypeStateMergePatched)stateEvent;
return(ToGoodIdentificationTypeStateMergePatchedDto(e));
}
else if (stateEvent.EventType == StateEventType.Deleted)
{
var e = (IGoodIdentificationTypeStateDeleted)stateEvent;
return(ToGoodIdentificationTypeStateDeletedDto(e));
}
throw DomainError.Named("invalidEventType", String.Format("Invalid state event type: {0}", stateEvent.EventType));
}
public static void Throw(DomainError domainError, object domainInstance, object relatedInstance,
IEnumerable <object> relatedInstances)
{
var error = ErrorCode(domainError);
if (relatedInstance != null)
{
throw new DomainException(domainError.ToString(), error.Message, error.Type, domainInstance,
relatedInstance);
}
if (relatedInstances != null)
{
throw new DomainException(domainError.ToString(), error.Message, error.Type, domainInstance,
relatedInstances);
}
throw new DomainException(domainError.ToString(), error.Message, error.Type, domainInstance);
}
public void AddPermissionToSecurityItem(UserId userId, string permission)
{
if (string.IsNullOrEmpty(permission))
{
throw DomainError.Named("empty", "Permission can't be empty");
}
if (!_state.ContainsUser(userId))
{
throw DomainError.Named("invalid-user", "User {0} does not exist", userId.Id);
}
var user = _state.GetUser(userId);
if (!user.Permissions.Contains(permission))
{
Apply(new PermissionAddedToSecurityItem(_state.Id, user.Id, user.DisplayName, permission, user.Token));
}
}
public virtual AttributeAliasStateCreatedOrMergePatchedOrRemovedDto ToAttributeAliasStateEventDto(IAttributeAliasEvent stateEvent)
{
if (stateEvent.EventType == StateEventType.Created)
{
var e = (IAttributeAliasStateCreated)stateEvent;
return(ToAttributeAliasStateCreatedDto(e));
}
else if (stateEvent.EventType == StateEventType.MergePatched)
{
var e = (IAttributeAliasStateMergePatched)stateEvent;
return(ToAttributeAliasStateMergePatchedDto(e));
}
else if (stateEvent.EventType == StateEventType.Removed)
{
var e = (IAttributeAliasStateRemoved)stateEvent;
return(ToAttributeAliasStateRemovedDto(e));
}
throw DomainError.Named("invalidEventType", String.Format("Invalid state event type: {0}", stateEvent.EventType));
}
public virtual DamageHandlingMethodStateCreatedOrMergePatchedOrDeletedDto ToDamageHandlingMethodStateEventDto(IDamageHandlingMethodEvent stateEvent)
{
if (stateEvent.EventType == StateEventType.Created)
{
var e = (IDamageHandlingMethodStateCreated)stateEvent;
return(ToDamageHandlingMethodStateCreatedDto(e));
}
else if (stateEvent.EventType == StateEventType.MergePatched)
{
var e = (IDamageHandlingMethodStateMergePatched)stateEvent;
return(ToDamageHandlingMethodStateMergePatchedDto(e));
}
else if (stateEvent.EventType == StateEventType.Deleted)
{
var e = (IDamageHandlingMethodStateDeleted)stateEvent;
return(ToDamageHandlingMethodStateDeletedDto(e));
}
throw DomainError.Named("invalidEventType", String.Format("Invalid state event type: {0}", stateEvent.EventType));
}
public void AssignEmployeeToFactory(string employeeName)
{
ThrowExceptionIfFactoryIsNotOpen();
if (_aggregateState.ListOfEmployeeNames.Contains(employeeName))
{
// yes, this is a really weird check, but this factory has really strict rules.
throw DomainError.Named("employee-name-already-taken", ":> the name of '{0}' only one employee can have", employeeName);
}
if (employeeName == "bender")
{
throw DomainError.Named("bender-employee", ":> Guys with name 'bender' are trouble.");
}
DoPaperWork("Assign employee to the factory");
RecordAndRealizeThat(new EmployeeAssignedToFactory(_aggregateState.Id, employeeName));
}
public virtual void ThrowOnInvalidStateTransition(ICommand c)
{
if (((IOrderItemShipGrpInvReservationStateProperties)_state).Version == OrderItemShipGrpInvReservationState.VersionZero)
{
if (IsCommandCreate((IOrderItemShipGrpInvReservationCommand)c))
{
return;
}
throw DomainError.Named("premature", "Can't do anything to unexistent aggregate");
}
if (_state.Deleted)
{
throw DomainError.Named("zombie", "Can't do anything to deleted aggregate.");
}
if (IsCommandCreate((IOrderItemShipGrpInvReservationCommand)c))
{
throw DomainError.Named("rebirth", "Can't create aggregate that already exists");
}
}
public virtual AttributeSetInstanceExtensionFieldStateCreatedOrMergePatchedOrDeletedDto ToAttributeSetInstanceExtensionFieldStateEventDto(IAttributeSetInstanceExtensionFieldEvent stateEvent)
{
if (stateEvent.EventType == StateEventType.Created)
{
var e = (IAttributeSetInstanceExtensionFieldStateCreated)stateEvent;
return(ToAttributeSetInstanceExtensionFieldStateCreatedDto(e));
}
else if (stateEvent.EventType == StateEventType.MergePatched)
{
var e = (IAttributeSetInstanceExtensionFieldStateMergePatched)stateEvent;
return(ToAttributeSetInstanceExtensionFieldStateMergePatchedDto(e));
}
else if (stateEvent.EventType == StateEventType.Deleted)
{
var e = (IAttributeSetInstanceExtensionFieldStateDeleted)stateEvent;
return(ToAttributeSetInstanceExtensionFieldStateDeletedDto(e));
}
throw DomainError.Named("invalidEventType", String.Format("Invalid state event type: {0}", stateEvent.EventType));
}
public virtual void ThrowOnInvalidStateTransition(ICommand c)
{
if (((IAttributeSetInstanceExtensionFieldGroupStateProperties)_state).Version == AttributeSetInstanceExtensionFieldGroupState.VersionZero)
{
if (IsCommandCreate((IAttributeSetInstanceExtensionFieldGroupCommand)c))
{
return;
}
throw DomainError.Named("premature", "Can't do anything to unexistent aggregate");
}
if (_state.Deleted)
{
throw DomainError.Named("zombie", "Can't do anything to deleted aggregate.");
}
if (IsCommandCreate((IAttributeSetInstanceExtensionFieldGroupCommand)c))
{
throw DomainError.Named("rebirth", "Can't create aggregate that already exists");
}
}
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(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());
}
}
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());
}
}
public virtual UserLoginMvoStateCreatedOrMergePatchedOrDeletedDto ToUserLoginMvoStateEventDto(IUserLoginMvoStateEvent stateEvent)
{
if (stateEvent.StateEventType == StateEventType.Created)
{
var e = (IUserLoginMvoStateCreated)stateEvent;
return(ToUserLoginMvoStateCreatedDto(e));
}
else if (stateEvent.StateEventType == StateEventType.MergePatched)
{
var e = (IUserLoginMvoStateMergePatched)stateEvent;
return(ToUserLoginMvoStateMergePatchedDto(e));
}
else if (stateEvent.StateEventType == StateEventType.Deleted)
{
var e = (IUserLoginMvoStateDeleted)stateEvent;
return(ToUserLoginMvoStateDeletedDto(e));
}
throw DomainError.Named("invalidStateEventType", String.Format("Invalid state event type: {0}", stateEvent.StateEventType));
}
internal void Create(RegisterPerson cmd)
{
if (State.Version > 0)
{
if (State.Name == cmd.Name)
{
return;
}
else
{
throw DomainError.Named("PersonAlreadyRegistered", $"A person named {State.Name} is already registered with id {State.Id}");
}
}
var e = new PersonRegistered()
{
Id = cmd.Id, Name = cmd.Name
};
Apply(e);
PublishedEvents.Add(e);
}
public void AssignEmployeeToFactory(string employeeName)
{
//Print("?> Command: Assign employee {0} to factory", employeeName);
ThrowExceptionIfNotOpenFactory();
if (_state.ListOfEmployeeNames.Contains(employeeName))
{
// yes, this is really weird check, but this factory has really strict rules.
// manager should've remembered that
throw DomainError.Named("more than 1 person", ":> the name of '{0}' only one employee can have", employeeName);
}
if (employeeName == "bender")
{
throw DomainError.Named("bender-employee", ":> Guys with name 'bender' are trouble.");
}
DoPaperWork("Assign employee to the factory");
Apply(new EmployeeAssignedToFactory(_state.Id, employeeName));
}
/// <summary>
/// Creates an system error from an exception
/// </summary>
/// <param name="exception">Exception</param>
/// <param name="additionalInformation">Additional information about this error (if any).</param>
/// <param name="handled">Informs whether the exception was properly handled.</param>
/// <returns>Error object.</returns>
public static Error CreateError(Exception exception, bool handled = true, string additionalInformation = null)
{
Check.Argument.IsNotNull(exception, "exception");
Error error;
if (exception is DomainException)
{
error = new DomainError();
}
else
{
error = new GenericError();
}
error.GeneratedAt = DateTime.Now;
error.Type = exception.GetType().FullName;
error.Message = exception.Message;
error.Details = ExceptionManager.GetExceptionAsString(exception);
error.AdditionalInformation = additionalInformation;
error.Handled = handled;
return error;
}
/// <summary>
/// Add error messages.
/// </summary>
/// <param name="domainError">Domain error.</param>
public IResponseError AddError(DomainError domainError)
{
if (domainError != null && ResponseStatusEnum.IsErrorStatus(Status))
{
var error = _errors.FirstOrDefault(x => x.Property == domainError.Property);
if (error != null)
{
foreach (var message in domainError.Messages)
{
error.Messages.Add(message);
}
return(this);
}
_errors.Add(domainError);
}
Data = _errors;
return(this);
}
public static void ThrowOnHttpResponseError(ApiResponse resp)
{
var httpResponseMessage = new HttpResponseMessage()
{
StatusCode = resp.StatusCode,
Content = resp.RawContent,
ReasonPhrase = resp.ReasonPhrase
};
if (httpResponseMessage.IsSuccessStatusCode)
{
return;
}
try
{
if (resp.StatusCode == HttpStatusCode.InternalServerError)
{
IEnumerable <string> headerValues = new List <string>();
if (resp.RawContent != null && resp.RawContent.Headers != null)
{
resp.RawContent.Headers.TryGetValues("Content-Type", out headerValues);
}
if (headerValues.Any(hv => hv.ToLowerInvariant().Contains("json")))
{
JObject jObj = JObject.Parse(httpResponseMessage.Content.ReadAsStringAsync().GetAwaiter().GetResult());
var errorName = jObj.GetValue("ErrorName").ToObject <string>();
var errorMessage = jObj.GetValue("ErrorMessage").ToObject <string>();
throw DomainError.Named(errorName, errorMessage);
}
}
throw new HttpResponseException(httpResponseMessage);
}
catch
{
throw new HttpResponseException(httpResponseMessage);
}
}
/// <summary>
/// Creates an system error from an exception
/// </summary>
/// <param name="exception">Exception</param>
/// <param name="additionalInformation">Additional information about this error (if any).</param>
/// <param name="handled">Informs whether the exception was properly handled.</param>
/// <returns>Error object.</returns>
public static Error CreateError(Exception exception, bool handled = true, string additionalInformation = null)
{
Check.Argument.IsNotNull(exception, "exception");
Error error;
if (exception is DomainException)
{
error = new DomainError();
}
else
{
error = new GenericError();
}
error.GeneratedAt = DateTime.Now;
error.Type = exception.GetType().FullName;
error.Message = exception.Message;
error.Details = ExceptionManager.GetExceptionAsString(exception);
error.AdditionalInformation = additionalInformation;
error.Handled = handled;
return(error);
}
public AddUserProfileCommandResult(AddUserProfileCommand command, DomainError error) : base(command, error)
{
}
protected CommandResult(U command, DomainError error)
: base(error)
{
Command = command;
}
protected QueryResult(DomainError error)
: base(error)
{
}
public UpdateUserProfileCommandResult(UpdateUserProfileCommand command, DomainError error) : base(command, error)
{
}
