public virtual string SerializeMessage(ITransportMessage <BaseMessage> transportMessage)
{
return(JsonConvert.SerializeObject(new
{
transportMessage.CorrelationId,
Type = transportMessage.Payload.GetType().Name,
Version = this.version.ToString(),
transportMessage.RequestTimestamp,
transportMessage.EventTimestamp,
transportMessage.UserId,
transportMessage.Payload
}, this.serializerSettings));
}
public void SendMessage(ITransportMessage message, TimeSpan?delay = default(TimeSpan?))
{
var client = StorageAccount.CreateCloudQueueClient( );
var queue = client.GetQueueReference(message.Name);
queue.CreateIfNotExists( );
queue.AddMessage(new CloudQueueMessage(JsonConvert.SerializeObject(message)),
null, delay, null, new OperationContext( )
{
ClientRequestID = message.ID
});
}
public async Task <DomainResult> SaveEvent(ITransportMessage <DomainEvent <TAggregateId> > @event)
{
var result = await this.elasticClient.UpdateAsync <ITransportMessage <DomainEvent <TAggregateId>, TAggregateId>, object>(
new DocumentPath <ITransportMessage <DomainEvent <TAggregateId>, TAggregateId> >(@event.Payload.Id),
u => u
.Routing(@event.Payload.AggregateId.ToString())
.Doc(@event)
.DocAsUpsert());
if (result.IsValid != true)
{
return(new DomainResult(result.IsValid, result.OriginalException, result.ServerError?.Error?.Reason));
}
return(DomainResult.Ok);
}
public void Serialize(object[] obj, ITransportMessage message)
{
var serialize = serializer.Serialize(
from o in obj
where o != null
let type = o.GetType()
select new
{
Type = type.FullName + ", " + type.Assembly.FullName,
Values = reflection.ForAllOf<DateTime>(o, d => d.ToUniversalTime())
}
);
var stream = new MemoryStream();
var streamWriter = new StreamWriter(stream);
streamWriter.Write(serialize);
streamWriter.Flush();
message.BodyStream = stream;
}
public object[] Deserialize(ITransportMessage message)
{
var streamReader = new StreamReader(message.BodyStream);
var deserializeObjects = (object[])serializer.DeserializeObject(streamReader.ReadToEnd());
var messages = new List<object>();
foreach (IDictionary<string, object> serializedObject in deserializeObjects)
{
var typeName = (string)serializedObject["Type"];
var msg = serializedObject["Values"];
var values = msg as IDictionary<string, object>;
if (values != null)
{
msg = SetMessagesValues(values, typeName);
}
messages.Add(msg);
}
return messages.ToArray();
}
public async Task <DomainResult> DispatchEvent(
ITransportMessage <DomainEvent <TAggregateId>, TAggregateId> transportEvent)
{
try
{
var topicName = "";
switch (transportEvent.Payload)
{
case IntegrationEvent <TAggregateId> _:
topicName = this.IntegrationTopicName; break;
case EventSourcedDomainEvent <TAggregateId> _:
topicName = this.EventSourcedTopicName; break;
case FailedDomainEvent <TAggregateId> _:
topicName = this.FailedEventsTopicName; break;
default: break;
}
if (!string.IsNullOrEmpty(topicName))
{
var message = this.messageSerializer.SerializeMessage(transportEvent);
var result = await this.producer.ProduceAsync(topicName,
transportEvent.Payload.AggregateId.ToString(), message);
if (result.Error.HasError)
{
return(new DomainResult(result.Error.Reason));
}
}
return(DomainResult.Ok);
}
catch (Exception ex)
{
return(new DomainResult(ex));
}
}
public MessageResult(ITransportMessage <BaseMessage> message)
{
Message = message;
}
