/// <summary>
/// Prepare <see cref="InMessage"/> as a message that has yet to be determined what it's endpoint will be.
/// This is used for (quick) saving the incoming message but process the message on a later time.
/// </summary>
/// <returns></returns>
public InMessage BuildAsToBeProcessed()
{
if (_messageUnit == null)
{
throw new InvalidDataException("Builder needs a Message Unit for building an InMessage");
}
var inMessage = new InMessage(_messageUnit.MessageId)
{
EbmsRefToMessageId = _messageUnit.RefToMessageId,
ContentType = _contentType,
InsertionTime = DateTimeOffset.Now,
ModificationTime = DateTimeOffset.Now,
MessageLocation = _location,
EbmsMessageType = DetermineMessageType(_messageUnit),
MEP = _mep,
Operation = Operation.NotApplicable
};
inMessage.SetPModeInformation(_pmode);
inMessage.SetStatus(InStatus.Received);
inMessage.AssignAS4Properties(_messageUnit);
return(inMessage);
}
private void InsertToBeForwardedInMessage(string pmodeId, MessageExchangePattern mep, AS4Message tobeForwarded)
{
foreach (MessageUnit m in tobeForwarded.MessageUnits)
{
string location =
Registry.Instance
.MessageBodyStore
.SaveAS4Message(
_as4Msh.GetConfiguration().InMessageStoreLocation,
tobeForwarded);
var inMessage = new InMessage(m.MessageId)
{
Intermediary = true,
Operation =
m.MessageId == tobeForwarded.PrimaryMessageUnit.MessageId
? Operation.ToBeForwarded
: Operation.NotApplicable,
MessageLocation = location,
MEP = mep,
ContentType = tobeForwarded.ContentType
};
ReceivingProcessingMode forwardPMode =
_as4Msh.GetConfiguration()
.GetReceivingPModes()
.First(p => p.Id == pmodeId);
inMessage.SetPModeInformation(forwardPMode);
inMessage.SetStatus(InStatus.Received);
inMessage.AssignAS4Properties(m);
_databaseSpy.InsertInMessage(inMessage);
}
}
public async Task PModeInformationIsCorrectlyRetrieved()
{
const string messageId = "messageId";
const string pmodeId = "TestPModeId";
using (var db = GetDataStoreContext())
{
var inMessage = new InMessage(messageId)
{
MessageLocation = "test"
};
inMessage.SetPModeInformation(new SendingProcessingMode()
{
Id = pmodeId
});
db.InMessages.Add(inMessage);
await db.SaveChangesAsync();
}
using (var db = GetDataStoreContext())
{
var inMessage = db.InMessages.FirstOrDefault(m => m.EbmsMessageId == messageId);
Assert.NotNull(inMessage);
Assert.False(String.IsNullOrWhiteSpace(inMessage.PModeId));
Assert.False(String.IsNullOrWhiteSpace(inMessage.PMode));
}
}
public async Task PModeInformationIsCorrectlyPersisted()
{
long savedId;
const string pmodeId = "pmodeId";
const string pmodeContent = "<pmode><id>pmodeId</id></pmode>";
using (var db = GetDataStoreContext())
{
var message = new InMessage("some-message-id");
message.SetPModeInformation(pmodeId, pmodeContent);
db.InMessages.Add(message);
await db.SaveChangesAsync();
savedId = message.Id;
}
using (var db = this.GetDataStoreContext())
{
var message = db.InMessages.FirstOrDefault(i => i.Id == savedId);
Assert.NotNull(message);
Assert.Equal(pmodeId, message.PModeId);
Assert.Equal(pmodeContent, message.PMode);
}
}
private static async Task <MessagingContext> PrepareAS4MessageForDeliveryAsync(AS4Message msg, ReceivingProcessingMode pmode)
{
var transformer = new DeliverMessageTransformer();
var entity = new InMessage(msg.GetPrimaryMessageId());
entity.SetPModeInformation(pmode);
return(await transformer.TransformAsync(new ReceivedEntityMessage(entity, msg.ToStream(), msg.ContentType)));
}
private static InMessage CreateInMessageRepresentingUserMessage(
string ebmsMessageId,
AS4Message as4Message,
IPMode pmode)
{
var inMessage = new InMessage(ebmsMessageId)
{
ContentType = as4Message.ContentType,
EbmsMessageType = MessageType.UserMessage,
MEP = MessageExchangePattern.Push,
Operation = Operation.ToBeDelivered,
MessageLocation =
Registry.Instance
.MessageBodyStore
.SaveAS4Message(@"file:///.\database\as4messages\in", as4Message)
};
inMessage.SetPModeInformation(pmode);
return(inMessage);
}
public async Task Create_DeliverMessages_From_UserMessages()
{
// Arrange
string partId1 = $"part-{Guid.NewGuid()}";
var userMessage1 = new UserMessage(
$"user-{Guid.NewGuid()}",
new CollaborationInfo(
new Service($"service-{Guid.NewGuid()}"),
$"action-{Guid.NewGuid()}"),
new Party("Sender", new PartyId($"id-{Guid.NewGuid()}")),
new Party("Receiver", new PartyId($"id-{Guid.NewGuid()}")),
new[] { new PartInfo($"cid:{partId1}") },
new MessageProperty[0]);
string partId2 = $"part-{Guid.NewGuid()}";
var userMessage2 = new UserMessage(
$"user-{Guid.NewGuid()}",
new CollaborationInfo(
new Service($"service-{Guid.NewGuid()}"),
$"action-{Guid.NewGuid()}"),
new Party("Sender", new PartyId($"id-{Guid.NewGuid()}")),
new Party("Receiver", new PartyId($"id-{Guid.NewGuid()}")),
new[] { new PartInfo($"cid:{partId2}") },
new MessageProperty[0]);
AS4Message as4Message = AS4Message.Create(new [] { userMessage1, userMessage2 });
as4Message.AddAttachment(new Attachment(partId1));
as4Message.AddAttachment(new Attachment(partId2));
var receivingPMode = new ReceivingProcessingMode {
Id = "deliver-pmode"
};
var entity1 = new InMessage(userMessage1.MessageId);
entity1.SetPModeInformation(receivingPMode);
var entity2 = new InMessage(userMessage2.MessageId);
entity2.SetPModeInformation(receivingPMode);
var sut = new DeliverMessageTransformer();
// Act
MessagingContext result1 =
await sut.TransformAsync(new ReceivedEntityMessage(entity1, as4Message.ToStream(), as4Message.ContentType));
MessagingContext result2 =
await sut.TransformAsync(new ReceivedEntityMessage(entity2, as4Message.ToStream(), as4Message.ContentType));
// Assert
IEnumerable <string> mappingFailures1 =
DeliverMessageOriginateFrom(
userMessage1,
receivingPMode,
result1.DeliverMessage.Message);
Assert.Empty(mappingFailures1);
IEnumerable <string> mappingFailures2 =
DeliverMessageOriginateFrom(
userMessage2,
receivingPMode,
result2.DeliverMessage.Message);
Assert.Empty(mappingFailures2);
}
protected virtual void SetupDataStore()
{
using (datastoreContext = new DatastoreContext(options, StubConfig.Default))
{
string pmodeString = AS4XmlSerializer.ToString(pmode);
string pmodeId = pmode.Id;
{
var message = new InMessage(ebmsMessageId: InEbmsMessageId1)
{
EbmsRefToMessageId = InEbmsRefToMessageId1,
InsertionTime = DateTime.UtcNow.AddMinutes(-1),
};
message.SetStatus(InStatus.Created);
message.SetPModeInformation(pmodeId, pmodeString);
datastoreContext.InMessages.Add(message);
}
{
var message = new InMessage(ebmsMessageId: InEbmsMessageId2)
{
EbmsRefToMessageId = InEbmsRefToMessageId2,
InsertionTime = DateTime.UtcNow.AddMinutes(-1)
};
message.SetStatus(InStatus.Received);
datastoreContext.InMessages.Add(message);
}
{
var message = new OutMessage(OutEbmsMessageId1)
{
EbmsRefToMessageId = OutEbmsRefToMessageId1,
InsertionTime = DateTime.UtcNow.AddMinutes(-1)
};
message.SetStatus(OutStatus.Created);
datastoreContext.OutMessages.Add(message);
}
{
var message = new OutMessage(OutEbmsMessageId2)
{
EbmsRefToMessageId = OutEbmsRefToMessageId2,
InsertionTime = DateTime.UtcNow.AddMinutes(-1)
};
message.SetStatus(OutStatus.Created);
datastoreContext.OutMessages.Add(message);
}
InException inEx1 = Entities.InException.ForEbmsMessageId(InEbmsMessageId1, InException);
inEx1.InsertionTime = DateTime.UtcNow.AddMinutes(-1);
datastoreContext.InExceptions.Add(inEx1);
InException inEx2 = Entities.InException.ForEbmsMessageId(InEbmsMessageId1, InException);
inEx2.InsertionTime = DateTime.UtcNow.AddMinutes(-1);
datastoreContext.InExceptions.Add(inEx2);
InException inEx3 = Entities.InException.ForMessageBody(MessageLocation, InException);
inEx3.InsertionTime = DateTime.UtcNow.AddMinutes(-1);
datastoreContext.InExceptions.Add(inEx3);
OutException outEx1 = Entities.OutException.ForEbmsMessageId(OutEbmsRefToMessageId1, InException);
outEx1.InsertionTime = DateTime.UtcNow.AddMinutes(-1);
datastoreContext.OutExceptions.Add(outEx1);
OutException outEx2 = OutException.ForEbmsMessageId(InEbmsRefToMessageId1, Exception);
outEx2.InsertionTime = DateTime.UtcNow.AddMinutes(-1);
datastoreContext.OutExceptions.Add(outEx2);
OutException outEx3 = OutException.ForMessageBody(MessageLocation, Exception);
outEx3.InsertionTime = DateTime.UtcNow.AddMinutes(-1);
datastoreContext.OutExceptions.Add(outEx3);
datastoreContext.SaveChanges();
foreach (var inMessage in datastoreContext.InMessages)
{
inMessage.SetPModeInformation(pmodeId, pmodeString);
}
foreach (var outMessage in datastoreContext.OutMessages)
{
outMessage.SetPModeInformation(pmodeId, pmodeString);
}
foreach (var inException in datastoreContext.InExceptions)
{
inException.SetPModeInformation(pmodeId, pmodeString);
}
foreach (var outException in datastoreContext.OutExceptions)
{
outException.SetPModeInformation(pmodeId, pmodeString);
}
datastoreContext.SaveChanges();
}
}
