/// <summary>
/// Creates a command line arguments definition and infers things like Arguments, Actions, etc. from the type's metadata.
/// </summary>
/// <param name="t">The argument scaffold type used to infer the definition</param>
public CommandLineArgumentsDefinition(Type t) : this()
{
ArgumentScaffoldType = t;
Arguments.AddRange(FindCommandLineArguments(t));
Actions.AddRange(FindCommandLineActions(t));
Metadata.AddRange(t.Attrs <IArgMetadata>().AssertAreAllInstanceOf <ICommandLineArgumentsDefinitionMetadata>());
}
private void Signal <TAggregateEvent>(TAggregateEvent aggregateEvent, IMetadata metadata = null)
where TAggregateEvent : class, IAggregateEvent <TestAggregate, TestAggregateId>
{
if (aggregateEvent == null)
{
throw new ArgumentNullException(nameof(aggregateEvent));
}
var aggregateSequenceNumber = Version;
var eventId = EventId.NewDeterministic(
GuidFactories.Deterministic.Namespaces.Events,
$"{Id.Value}-v{aggregateSequenceNumber}");
var now = DateTimeOffset.UtcNow;
var eventMetadata = new Metadata
{
Timestamp = now,
AggregateSequenceNumber = aggregateSequenceNumber,
AggregateName = Name.Value,
AggregateId = Id.Value,
EventId = eventId
};
eventMetadata.Add(MetadataKeys.TimestampEpoch, now.ToUnixTime().ToString());
if (metadata != null)
{
eventMetadata.AddRange(metadata);
}
var domainEvent = new DomainEvent <TestAggregate, TestAggregateId, TAggregateEvent>(Id, aggregateEvent, eventMetadata, now, Version);
Publish(domainEvent);
}
protected virtual void Emit <TEvent>(TEvent aggregateEvent, IMetadata metadata = null)
where TEvent : IAggregateEvent <TAggregate, TIdentity>
{
if (aggregateEvent == null)
{
throw new ArgumentNullException(nameof(aggregateEvent));
}
var aggregateSequenceNumber = Version + 1;
var eventId = EventId.NewDeterministic(
GuidFactories.Deterministic.Namespaces.Events,
$"{Id.Value}-v{aggregateSequenceNumber}");
var now = DateTimeOffset.Now;
var eventMetadata = new Metadata
{
Timestamp = now,
AggregateSequenceNumber = aggregateSequenceNumber,
AggregateName = Name.Value,
AggregateId = Id.Value,
EventId = eventId
};
eventMetadata.Add(MetadataKeys.TimestampEpoch, now.ToUnixTime().ToString());
if (metadata != null)
{
eventMetadata.AddRange(metadata);
}
var uncommittedEvent = new UncommittedEvent(aggregateEvent, eventMetadata);
ApplyEvent(aggregateEvent);
_uncommittedEvents.Add(uncommittedEvent);
}
/// <summary>
/// Emits the specified aggregate event.
/// </summary>
/// <typeparam name="TEvent">The type of the event.</typeparam>
/// <param name="aggregateEvent">The aggregate event.</param>
/// <param name="metadata">The metadata.</param>
/// <exception cref="ArgumentNullException">aggregateEvent</exception>
protected override void Emit <TEvent>(TEvent aggregateEvent, IMetadata metadata = null)
{
if (EqualityComparer <TEvent> .Default.Equals(aggregateEvent, default(TEvent)))
{
throw new ArgumentNullException(nameof(aggregateEvent));
}
//Version = (int)sequenceStore.GetNextSequence(EventSequenceTableName);
var aggregateSequenceNumber = Version + 1;
var eventId = EventId.NewDeterministic(
GuidFactories.Deterministic.Namespaces.Events,
$"{Id.Value}-v{aggregateSequenceNumber}");
var now = DateTimeOffset.Now;
var eventMetadata = new Metadata
{
Timestamp = now,
AggregateSequenceNumber = (int)aggregateSequenceNumber,
AggregateName = Name.Value,
AggregateId = Id.Value,
EventId = eventId
};
eventMetadata.Add(MetadataKeys.TimestampEpoch, now.ToUnixTime().ToString());
if (metadata != null)
{
eventMetadata.AddRange(metadata);
}
var uncommittedEvent = new UncommittedEvent(aggregateEvent, eventMetadata);
ApplyEvent(aggregateEvent);
uncommittedEvents.Add(uncommittedEvent);
}
/// <summary>
/// Creates a command line arguments definition and infers things like Arguments, Actions, etc. from the type's metadata.
/// </summary>
/// <param name="t">The argument scaffold type used to infer the definition</param>
public CommandLineArgumentsDefinition(Type t) : this()
{
ArgumentScaffoldType = t;
ExceptionBehavior = t.HasAttr <ArgExceptionBehavior>() ? t.Attr <ArgExceptionBehavior>() : new ArgExceptionBehavior();
Arguments.AddRange(FindCommandLineArguments(t));
Actions.AddRange(FindCommandLineActions(t));
Metadata.AddRange(t.Attrs <IArgMetadata>().AssertAreAllInstanceOf <ICommandLineArgumentsDefinitionMetadata>());
}
internal TokenMintTransactionBody(Hashgraph.Address token, IEnumerable <ReadOnlyMemory <byte> > metadata) : this()
{
if (metadata is null)
{
throw new ArgumentOutOfRangeException(nameof(metadata), "Metadata for creating assets was not provided.");
}
Token = new TokenID(token);
Metadata.AddRange(metadata.Select(m => ByteString.CopyFrom(m.Span)));
}
/// <summary>
/// Creates a command line argument of the given type and sets the first default alias.
/// </summary>
/// <param name="t">The CLR type of the argument</param>
/// <param name="defaultAlias">The default name that users will use to specify this argument</param>
/// <param name="ignoreCase">If true, the parser will match this argument even if the specifier doesn't match case. True by default.</param>
public CommandLineArgument(Type t, string defaultAlias, bool ignoreCase = true) : this()
{
if (t == null)
{
throw new InvalidArgDefinitionException("Argument types cannot be null");
}
ArgumentType = t;
IgnoreCase = ignoreCase;
Aliases.Add(defaultAlias);
Metadata.AddRange(t.Attrs <IArgMetadata>().AssertAreAllInstanceOf <ICommandLineArgumentMetadata>());
}
public void Add(InProcessTransactionResponse response)
{
if (response.Nodes.Count > 0)
{
Nodes.AddRange(response.Nodes);
}
if (response.Relationships.Count > 0)
{
Relationships.AddRange(response.Relationships);
}
if (response.Metadata.Count > 0)
{
Metadata.AddRange(response.Metadata);
}
}
protected virtual object FromObject(object aggregateEvent, long version, IMetadata metadata = null)
{
if (aggregateEvent is IAggregateEvent)
{
_eventDefinitionService.Load(aggregateEvent.GetType());
var eventDefinition = _eventDefinitionService.GetDefinition(aggregateEvent.GetType());
var aggregateSequenceNumber = version + 1;
var eventId = EventId.NewDeterministic(
GuidFactories.Deterministic.Namespaces.Events,
$"{Id.Value}-v{aggregateSequenceNumber}");
var now = DateTimeOffset.UtcNow;
var eventMetadata = new Metadata
{
Timestamp = now,
AggregateSequenceNumber = aggregateSequenceNumber,
AggregateName = Name.Value,
AggregateId = Id.Value,
EventId = eventId,
EventName = eventDefinition.Name,
EventVersion = eventDefinition.Version
};
eventMetadata.Add(MetadataKeys.TimestampEpoch, now.ToUnixTime().ToString());
if (metadata != null)
{
eventMetadata.AddRange(metadata);
}
var genericType = typeof(CommittedEvent <, ,>)
.MakeGenericType(typeof(TAggregateSaga), typeof(TIdentity), aggregateEvent.GetType());
var committedEvent = Activator.CreateInstance(
genericType,
Id,
aggregateEvent,
eventMetadata,
now,
aggregateSequenceNumber);
return(committedEvent);
}
throw new InvalidOperationException("could not perform the required mapping for committed event.");
}
protected virtual void Emit <TAggregateEvent>(TAggregateEvent aggregateEvent, IMetadata metadata = null)
where TAggregateEvent : IAggregateEvent <TAggregateSaga, TIdentity>
{
if (aggregateEvent == null)
{
throw new ArgumentNullException(nameof(aggregateEvent));
}
var aggregateSequenceNumber = Version + 1;
var eventId = EventId.NewDeterministic(
GuidFactories.Deterministic.Namespaces.Events,
$"{Id.Value}-v{aggregateSequenceNumber}");
var now = DateTimeOffset.UtcNow;
var eventMetadata = new Metadata
{
Timestamp = now,
AggregateSequenceNumber = aggregateSequenceNumber,
AggregateName = Name.Value,
AggregateId = Id.Value,
EventId = eventId
};
eventMetadata.Add(MetadataKeys.TimestampEpoch, now.ToUnixTime().ToString());
if (metadata != null)
{
eventMetadata.AddRange(metadata);
}
var aggregateApplyMethod = GetEventApplyMethods(aggregateEvent);
Persist(aggregateEvent, aggregateApplyMethod);
Logger.Info($"[{Name}] With Id={Id} Commited [{typeof(TAggregateEvent).PrettyPrint()}]");
Version++;
var domainEvent = new DomainEvent <TAggregateSaga, TIdentity, TAggregateEvent>(aggregateEvent, eventMetadata, now, Id, Version);
Publish(domainEvent);
}
private void Signal <TAggregateEvent>(TAggregateEvent aggregateEvent, IMetadata metadata = null)
where TAggregateEvent : IAggregateEvent <TestAggregate, TestAggregateId>
{
if (aggregateEvent == null)
{
throw new ArgumentNullException(nameof(aggregateEvent));
}
EventDefinitionService.Load(aggregateEvent.GetType());
var eventDefinition = EventDefinitionService.GetDefinition(aggregateEvent.GetType());
var aggregateSequenceNumber = Version;
var eventId = EventId.NewDeterministic(
GuidFactories.Deterministic.Namespaces.Events,
$"{Id.Value}-v{aggregateSequenceNumber}");
var now = DateTimeOffset.UtcNow;
var eventMetadata = new Metadata
{
Timestamp = now,
AggregateSequenceNumber = aggregateSequenceNumber,
AggregateName = Name.Value,
AggregateId = Id.Value,
EventId = eventId,
EventName = eventDefinition.Name,
EventVersion = eventDefinition.Version
};
eventMetadata.Add(MetadataKeys.TimestampEpoch, now.ToUnixTime().ToString());
if (metadata != null)
{
eventMetadata.AddRange(metadata);
}
Logger.Info($"[{Name}] With Id={Id} Commited [{typeof(TAggregateEvent).PrettyPrint()}]");
var domainEvent = new DomainEvent <TestAggregate, TestAggregateId, TAggregateEvent>(Id, aggregateEvent, eventMetadata, now, Version);
Publish(domainEvent);
}
public virtual CommittedEvent <TAggregateSaga, TIdentity, TAggregateEvent> From <TAggregateEvent>(TAggregateEvent aggregateEvent,
long version, IMetadata metadata = null)
where TAggregateEvent : class, IAggregateEvent <TAggregateSaga, TIdentity>
{
if (aggregateEvent == null)
{
throw new ArgumentNullException(nameof(aggregateEvent));
}
_eventDefinitionService.Load(aggregateEvent.GetType());
var eventDefinition = _eventDefinitionService.GetDefinition(aggregateEvent.GetType());
var aggregateSequenceNumber = version + 1;
var eventId = EventId.NewDeterministic(
GuidFactories.Deterministic.Namespaces.Events,
$"{Id.Value}-v{aggregateSequenceNumber}");
var now = DateTimeOffset.UtcNow;
var eventMetadata = new Metadata
{
Timestamp = now,
AggregateSequenceNumber = aggregateSequenceNumber,
AggregateName = Name.Value,
AggregateId = Id.Value,
EventId = eventId,
EventName = eventDefinition.Name,
EventVersion = eventDefinition.Version
};
eventMetadata.Add(MetadataKeys.TimestampEpoch, now.ToUnixTime().ToString());
if (metadata != null)
{
eventMetadata.AddRange(metadata);
}
var committedEvent = new CommittedEvent <TAggregateSaga, TIdentity, TAggregateEvent>(Id, aggregateEvent, eventMetadata, now, aggregateSequenceNumber);
return(committedEvent);
}
protected virtual void Emit <TAggregateEvent>(TAggregateEvent aggregateEvent, IMetadata metadata = null)
where TAggregateEvent : IAggregateEvent <TAggregateSaga, TIdentity>
{
if (aggregateEvent == null)
{
throw new ArgumentNullException(nameof(aggregateEvent));
}
_eventDefinitionService.Load(typeof(TAggregateEvent));
var eventDefinition = _eventDefinitionService.GetDefinition(typeof(TAggregateEvent));
var aggregateSequenceNumber = Version + 1;
var eventId = EventId.NewDeterministic(
GuidFactories.Deterministic.Namespaces.Events,
$"{Id.Value}-v{aggregateSequenceNumber}");
var now = DateTimeOffset.UtcNow;
var eventMetadata = new Metadata
{
Timestamp = now,
AggregateSequenceNumber = aggregateSequenceNumber,
AggregateName = Name.Value,
AggregateId = Id.Value,
EventId = eventId,
EventName = eventDefinition.Name,
EventVersion = eventDefinition.Version,
};
eventMetadata.Add(MetadataKeys.TimestampEpoch, now.ToUnixTime().ToString());
if (metadata != null)
{
eventMetadata.AddRange(metadata);
}
var committedEvent = new CommittedEvent <TAggregateSaga, TIdentity, TAggregateEvent>(Id, aggregateEvent, eventMetadata, now, Version);
Persist(committedEvent, ApplyCommittedEvents);
Logger.Info($"[{Name}] With Id={Id} Commited [{typeof(TAggregateEvent).PrettyPrint()}]");
Version++;
var aggregateApplyMethod = GetEventApplyMethods(aggregateEvent);
Persist(aggregateEvent, aggregateApplyMethod);
Logger.Info($"[{Name}] With Id={Id} Commited [{typeof(TAggregateEvent).PrettyPrint()}]");
Version++;
var domainEvent = new DomainEvent <TAggregateSaga, TIdentity, TAggregateEvent>(Id, aggregateEvent, eventMetadata, now, Version);
Publish(domainEvent);
if (SnapshotStrategy.ShouldCreateSnapshot(this))
{
var aggregateSnapshot = CreateSnapshot();
if (aggregateSnapshot != null)
{
var t = aggregateSnapshot.GetType();
_snapshotDefinitionService.Load(aggregateSnapshot.GetType());
var snapshotDefinition = _snapshotDefinitionService.GetDefinition(aggregateSnapshot.GetType());
var snapshotMetadata = new Aggregates.Snapshot.SnapshotMetadata
{
AggregateId = Id.Value,
AggregateName = Name.Value,
AggregateSequenceNumber = Version,
SnapshotName = snapshotDefinition.Name,
SnapshotVersion = snapshotDefinition.Version
};
var commitedSnapshot =
new ComittedSnapshot <TAggregateSaga, TIdentity, IAggregateSnapshot <TAggregateSaga, TIdentity> >(
Id,
aggregateSnapshot,
snapshotMetadata,
now, Version);
SaveSnapshot(commitedSnapshot);
}
}
}
