public async Task Received_Bundled_Response_Should_Process_All_Messages()
{
// Arrange
string pullSenderUrl = RetrievePullingUrlFromConfig();
string storedMessageId = "stored-" + Guid.NewGuid();
StoreToBeAckOutMessage(storedMessageId);
AS4Message bundled = CreateBundledMultipleUserMessagesWithRefTo();
bundled.AddMessageUnit(new Receipt($"receipt-{Guid.NewGuid()}", storedMessageId));
// Act
await RespondToPullRequestAsync(
pullSenderUrl,
response =>
{
response.ContentType = bundled.ContentType;
response.StatusCode = 200;
using (Stream output = response.OutputStream)
{
SerializerProvider.Default
.Get(bundled.ContentType)
.Serialize(bundled, output);
}
});
// Assert
IEnumerable <InMessage> storedBundled =
await PollUntilPresent(
() => _databaseSpy.GetInMessages(bundled.UserMessages.Select(u => u.MessageId).ToArray())
.Where(m => m.Operation == Operation.ToBeDelivered),
timeout : TimeSpan.FromSeconds(20));
Assert.Collection(
storedBundled,
userMessage1 =>
{
Assert.Equal(MessageExchangePattern.Pull, userMessage1.MEP);
Assert.Equal(InStatus.Received, userMessage1.Status.ToEnum <InStatus>());
Assert.Equal(Operation.ToBeDelivered, userMessage1.Operation);
},
userMessage2 =>
{
Assert.Equal(MessageExchangePattern.Pull, userMessage2.MEP);
Assert.Equal(InStatus.Received, userMessage2.Status.ToEnum <InStatus>());
Assert.Equal(Operation.ToBeDelivered, userMessage2.Operation);
});
Assert.Collection(
_databaseSpy.GetInMessages(bundled.SignalMessages.Select(s => s.MessageId).ToArray()),
signal =>
{
Assert.Equal(MessageExchangePattern.Pull, signal.MEP);
Assert.Equal(InStatus.Received, signal.Status.ToEnum <InStatus>());
Assert.Equal(Operation.ToBeNotified, signal.Operation);
});
Assert.Collection(
_databaseSpy.GetOutMessages(storedMessageId),
stored => Assert.Equal(OutStatus.Ack, stored.Status.ToEnum <OutStatus>()));
}
public async Task Fails_To_Store_SignalMessage_When_ReplyPattern_Response_For_Pulled_UserMessage()
{
// Arrange
string userMessageId = $"user-{Guid.NewGuid()}";
GetDataStoreContext.InsertInMessage(
new InMessage(userMessageId)
{
MEP = MessageExchangePattern.Pull
});
var receipt = new Receipt($"receipt-{Guid.NewGuid()}", userMessageId);
var context = new MessagingContext(
AS4Message.Create(receipt),
MessagingContextMode.Receive)
{
SendingPMode = new SendingProcessingMode {
Id = "shortcut-send-pmode-retrieval"
},
ReceivingPMode = new ReceivingProcessingMode
{
ReplyHandling = { ReplyPattern = ReplyPattern.Response }
}
};
// Act / Assert
await Assert.ThrowsAsync <InvalidOperationException>(
() => ExerciseStoreSignalMessageAsync(context));
}
protected MessagingContext CreateEncryptedAS4Message()
{
Stream attachmentStream = new MemoryStream(Encoding.UTF8.GetBytes("Hello, encrypt me"));
var attachment = new Attachment("attachment-id", attachmentStream, "text/plain");
AS4Message as4Message = AS4Message.Empty;
as4Message.AddMessageUnit(new UserMessage($"user-{Guid.NewGuid()}"));
as4Message.AddAttachment(attachment);
var message = new MessagingContext(as4Message, MessagingContextMode.Unknown)
{
SendingPMode = new SendingProcessingMode()
};
message.SendingPMode.Security.Encryption.IsEnabled = true;
message.SendingPMode.Security.Encryption.Algorithm = "http://www.w3.org/2009/xmlenc11#aes128-gcm";
message.SendingPMode.Security.Encryption.CertificateType = PublicKeyCertificateChoiceType.CertificateFindCriteria;
message.SendingPMode.Security.Encryption.EncryptionCertificateInformation = new CertificateFindCriteria()
{
CertificateFindType = X509FindType.FindBySerialNumber,
CertificateFindValue = "some dummy value"
};
return(message);
}
public async Task CanCreateMessageWithPModeWithoutToParty()
{
// Arrange
var sendingParty = CreatePModeParty("sender", "c2", "eu.edelivery.services");
var pmode = CreateSendingPMode(fromParty: sendingParty, toParty: null);
var receivingParty = CreateSubmitMessageParty("receiver", "type", "c3");
var submitMessage = CreateSubmitMessage(pmode, fromParty: null, toParty: receivingParty);
var context = new MessagingContext(submitMessage)
{
SendingPMode = pmode
};
// Act
var result = await ExerciseCreation(context);
// Assert
Assert.True(result.Succeeded);
AS4Message as4Message = result.MessagingContext.AS4Message;
Assert.False(as4Message.IsEmpty);
Assert.True(as4Message.IsUserMessage);
Assert.Equal(receivingParty.Role, as4Message.FirstUserMessage.Receiver.Role);
Assert.Equal(receivingParty.PartyIds.First().Id, as4Message.FirstUserMessage.Receiver.PartyIds.First().Id);
Assert.Equal(receivingParty.PartyIds.First().Type, as4Message.FirstUserMessage.Receiver.PartyIds.First().Type.UnsafeGet);
}
private static VerifySignatureConfig CreateVerifyOptionsForAS4Message(AS4Message as4Message, SigningVerification v)
{
bool allowUnknownRootCertificateAuthority =
v?.AllowUnknownRootCertificate ?? new SigningVerification().AllowUnknownRootCertificate;
return(new VerifySignatureConfig(allowUnknownRootCertificateAuthority, as4Message.Attachments));
}
public async Task TestIfAttachmentContentTypeIsSetBackToOriginal()
{
// Arrange
AS4Message as4Message = await GetEncryptedAS4MessageAsync();
var context = new MessagingContext(as4Message, MessagingContextMode.Receive)
{
ReceivingPMode = new ReceivingProcessingMode
{
Security = { Decryption =
{
Encryption = Limit.Allowed,
DecryptCertificateInformation = new CertificateFindCriteria {
CertificateFindType = X509FindType.FindBySerialNumber
}
} }
}
};
// Act
StepResult result = await ExerciseDecryption(context);
// Assert
IEnumerable <Attachment> attachments = result.MessagingContext.AS4Message.Attachments;
Assert.All(attachments, a => Assert.Equal("image/jpeg", a.ContentType));
}
private async Task <StepResult> ExerciseVerifyNRRReceipt(
IAS4MessageBodyStore messageStore,
AS4Message signedReceiptResult,
bool verifyNrr)
{
var verifyNrrPMode = new SendingProcessingMode {
ReceiptHandling = { VerifyNRR = verifyNrr }
};
var verifySignaturePMode = new ReceivingProcessingMode {
Security = { SigningVerification = { Signature = Limit.Required } }
};
var step = new VerifySignatureAS4MessageStep(
GetDataStoreContext,
messageStore);
return(await step.ExecuteAsync(
new MessagingContext(
signedReceiptResult,
MessagingContextMode.Receive)
{
SendingPMode = verifyNrrPMode,
ReceivingPMode = verifySignaturePMode
}));
}
public Property Multiple_UserMessages_Their_Attachments_Gets_Decompressed(NonEmptyArray <Guid> attachmentIds)
{
Action act = () =>
{
// Arrange
AS4Message as4Message = attachmentIds.Get.Distinct().Aggregate(
AS4Message.Empty,
(as4, id) =>
{
as4.AddMessageUnit(UserMessageWithCompressedInfo(id.ToString()));
as4.AddAttachment(CompressedAttachment(id.ToString()));
return(as4);
});
// Act
StepResult result = ExerciseDecompress(as4Message);
// Assert
Assert.All(
result.MessagingContext.AS4Message.Attachments,
a => Assert.NotEqual("application/gzip", a.ContentType));
Assert.All(
result.MessagingContext.AS4Message.UserMessages.SelectMany(u => u.PayloadInfo),
p => Assert.Equal("application/gzip", p.CompressionType));
};
return(act.When(attachmentIds.Get.Distinct().Any()));
}
/// <summary>
/// Determines whether a pull-request is authorized
/// </summary>
/// <param name="pullRequestMessage">An AS4 Message for which the primary signal-message is a PullRequest.</param>
/// <returns>True if the PullRequest is allowed to be processed.</returns>
public bool IsPullRequestAuthorized(AS4Message pullRequestMessage)
{
if (pullRequestMessage == null)
{
throw new ArgumentNullException(nameof(pullRequestMessage));
}
if (pullRequestMessage.IsPullRequest == false)
{
throw new InvalidMessageException("The AS4 Message is not a PullRequest message");
}
var mpc = ((PullRequest)pullRequestMessage.FirstSignalMessage).Mpc;
var authorizationEntries = _mapProvider.RetrievePullRequestAuthorizationEntriesForMpc(mpc);
if (authorizationEntries == null || authorizationEntries.Any() == false)
{
return(true);
}
if (pullRequestMessage.SecurityHeader.IsSigned == false && authorizationEntries.Any())
{
return(false);
}
var certificateThumbPrint = RetrieveSigningCertificateThumbPrint(pullRequestMessage, _certificateRepository);
var authorizationEntriesForCertificate =
authorizationEntries.Where(a => StringComparer.OrdinalIgnoreCase.Equals(a.CertificateThumbprint, certificateThumbPrint));
return(authorizationEntriesForCertificate.Any() && authorizationEntriesForCertificate.All(a => a.Allowed));
}
/// <summary>
/// Execute the step for a given <paramref name="messagingContext" />.
/// </summary>
/// <param name="messagingContext">Message used during the step execution.</param>
/// <returns></returns>
public async Task <StepResult> ExecuteAsync(MessagingContext messagingContext)
{
var pullRequest = messagingContext?.AS4Message?.FirstSignalMessage as PullRequest;
if (pullRequest == null)
{
throw new InvalidMessageException(
"The received message is not a PullRequest message, " +
"therefore no UserMessage can be selected to return to the sender");
}
(bool hasMatch, OutMessage match) = RetrieveUserMessageForPullRequest(pullRequest);
if (hasMatch)
{
// Retrieve the existing MessageBody and put that stream in the MessagingContext.
// The HttpReceiver processor will make sure that it gets serialized to the http response stream.
Stream messageBody = await match.RetrieveMessageBody(_messageBodyStore).ConfigureAwait(false);
messagingContext.ModifyContext(
new ReceivedMessage(messageBody, match.ContentType),
MessagingContextMode.Send);
messagingContext.SendingPMode = AS4XmlSerializer.FromString <SendingProcessingMode>(match.PMode);
return(StepResult.Success(messagingContext));
}
AS4Message pullRequestWarning = AS4Message.Create(Error.CreatePullRequestWarning(IdentifierFactory.Instance.Create()));
messagingContext.ModifyContext(pullRequestWarning);
return(StepResult.Success(messagingContext).AndStopExecution());
}
/// <summary>
/// Creates a <see cref="JournalLogEntry"/> based on a given <see cref="AS4Message"/>.
/// </summary>
/// <param name="msg">The message to create a log entry from.</param>
/// <param name="details">The log details collected with the message.</param>
public static JournalLogEntry CreateFrom(AS4Message msg, string details)
{
if (msg == null)
{
throw new ArgumentNullException(nameof(msg));
}
if (msg.IsEmpty)
{
throw new NotSupportedException(
$"Can't create {nameof(JournalLogEntry)} from an AS4Message without message units");
}
if (msg.PrimaryMessageUnit is UserMessage um)
{
return(new JournalLogEntry(
um.MessageId,
um.RefToMessageId,
um.CollaborationInfo.Service.Value,
um.CollaborationInfo.Action,
um.Receiver.PrimaryPartyId,
um.Sender.PrimaryPartyId,
new [] { details }));
}
return(new JournalLogEntry(
msg.PrimaryMessageUnit.MessageId,
msg.PrimaryMessageUnit.RefToMessageId,
new[] { details }));
}
private void InsertUserMessage(string mpc, MessageExchangePattern pattern, Operation operation)
{
var sendingPMode = new SendingProcessingMode()
{
Id = "SomePModeId",
MessagePackaging = { Mpc = mpc }
};
UserMessage userMessage = SendingPModeMap.CreateUserMessage(sendingPMode);
AS4Message as4Message = AS4Message.Create(userMessage, sendingPMode);
var om = new OutMessage(userMessage.MessageId)
{
MEP = pattern,
Mpc = mpc,
ContentType = as4Message.ContentType,
EbmsMessageType = MessageType.UserMessage,
Operation = operation,
MessageLocation =
InMemoryMessageBodyStore.Default.SaveAS4Message(location: "some-location", message: as4Message)
};
om.SetPModeInformation(sendingPMode);
GetDataStoreContext.InsertOutMessage(om);
}
/// <summary>
/// Sends an AS4 Message to the endpoint that listens at the specified url.
/// </summary>
/// <param name="url">The url of the endpoint to send the message to.</param>
/// <param name="as4Message">The AS4Message that must be sent.</param>
/// <returns></returns>
public static async Task <HttpResponseMessage> SendAS4Message(string url, AS4Message as4Message)
{
var request = await CreatePostRequestMessage(url, as4Message);
Console.WriteLine($@"Send AS4Message as HTTP POST request to: {url}, Content-Type: {as4Message.ContentType}");
return(await Client.SendAsync(request));
}
private static AS4Message CreateBundledMultipleUserMessagesWithRefTo()
{
var userMessage1 = new UserMessage(
messageId: "user1-" + Guid.NewGuid(),
collaboration: new CollaborationInfo(
agreement: new AgreementReference(
value: "http://agreements.europa.org/agreement",
pmodeId: "pullreceive_bundled_pmode"),
service: new Service(
value: "bundling",
type: "as4:net:pullreceive:bundling"),
action: "as4:net:pullreceive:bundling",
conversationId: "as4:net:pullreceive:conversation"));
var userMessage2 = new UserMessage(
messageId: "user2-" + Guid.NewGuid(),
collaboration: new CollaborationInfo(
agreement: new AgreementReference(
value: "http://agreements.europa.org/agreement",
pmodeId: "some-other-pmode-id"),
service: new Service(
value: "bundling",
type: "as4:net:pullreceive:bundling"),
action: "as4:net:pullreceive:bundling",
conversationId: "as4:net:pullreceive:conversation"));
var bundled = AS4Message.Create(userMessage1);
bundled.AddMessageUnit(userMessage2);
return(bundled);
}
private static AS4Message UserMessageWithAttachment(string argRefPModeId)
{
var user = new UserMessage(
Guid.NewGuid().ToString(),
HolodeckCollaboration(argRefPModeId),
new Party(Constants.Namespaces.EbmsDefaultFrom, new PartyId(Constants.Namespaces.EbmsDefaultFrom)),
new Party(HolodeckPartyRole, new PartyId(HolodeckBId, HolodeckBId)),
new[]
{
new PartInfo(
href: "cid:earth",
properties: new Dictionary <string, string>
{
["Part Property"] = "Some Holodeck required Part Property"
},
schemas: new Schema[0])
},
new Model.Core.MessageProperty[0]);
AS4Message userMessage = AS4Message.Create(user, new SendingProcessingMode {
MessagePackaging = { IsMultiHop = true }
});
userMessage.AddAttachment(ImageAttachment(id: "earth"));
return(userMessage);
}
public async Task ForwardingWithPushOnPull()
{
// Arrange
const string messageId = "user-message-id";
var tobeForwarded = AS4Message.Create(CreateForwardPushUserMessage(messageId));
// Act
InsertToBeForwardedInMessage(
pmodeId: "Forward_Push",
mep: MessageExchangePattern.Pull,
tobeForwarded: tobeForwarded);
// Assert: if an OutMessage is created with the correct status and operation
await PollUntilPresent(
() => _databaseSpy.GetInMessageFor(m =>
m.EbmsMessageId == messageId &&
m.Operation == Operation.Forwarded),
TimeSpan.FromSeconds(20));
OutMessage outMessage = await PollUntilPresent(
() => _databaseSpy.GetOutMessageFor(m => m.EbmsMessageId == messageId),
TimeSpan.FromSeconds(5));
var sendingPMode = AS4XmlSerializer.FromString <SendingProcessingMode>(outMessage.PMode);
Assert.NotNull(sendingPMode);
Assert.Equal(Operation.ToBeProcessed, outMessage.Operation);
Assert.Equal(MessageExchangePattern.Push, outMessage.MEP);
Assert.Equal(sendingPMode.MessagePackaging.Mpc, outMessage.Mpc);
}
public async Task ThenExecuteStepSucceedsAsync()
{
// Arrange
AS4Message as4Message = await GetEncryptedAS4MessageAsync();
var context = new MessagingContext(as4Message, MessagingContextMode.Receive)
{
ReceivingPMode = new ReceivingProcessingMode
{
Security = { Decryption =
{
Encryption = Limit.Allowed,
DecryptCertificateInformation = new CertificateFindCriteria
{
CertificateFindValue = "",
CertificateFindType = X509FindType.FindByIssuerName
}
} }
}
};
// Act
StepResult stepResult = await ExerciseDecryption(context);
// Assert
Assert.False(stepResult.MessagingContext.AS4Message.IsEncrypted);
}
public async Task OutMessageIsCreatedForToBeForwardedMessage()
{
// Arrange
const string messageId = "message-id";
var as4Message = AS4Message.Create(CreateForwardPushUserMessage(messageId));
// Act
InsertToBeForwardedInMessage(
pmodeId: "Forward_Push",
mep: MessageExchangePattern.Push,
tobeForwarded: as4Message);
// Assert: if an OutMessage is created with the correct status and operation.
InMessage inMessage = await PollUntilPresent(
() => _databaseSpy.GetInMessageFor(
m => m.EbmsMessageId == messageId &&
m.Operation == Operation.Forwarded),
TimeSpan.FromSeconds(15));
Assert.NotNull(AS4XmlSerializer.FromString <ReceivingProcessingMode>(inMessage.PMode));
OutMessage outMessage = await PollUntilPresent(
() => _databaseSpy.GetOutMessageFor(m => m.EbmsMessageId == messageId),
timeout : TimeSpan.FromSeconds(5));
Assert.True(outMessage.Intermediary);
Assert.Equal(Operation.ToBeProcessed, outMessage.Operation);
Assert.NotNull(AS4XmlSerializer.FromString <SendingProcessingMode>(outMessage.PMode));
}
public async Task Takes_Sending_PMode_Into_Account_When_Verifies_Non_Multihop_Signal()
{
// Arrange
var as4Msg = AS4Message.Create(new Receipt($"receipt-{Guid.NewGuid()}", $"reftoid-{Guid.NewGuid()}"));
as4Msg.AddMessageUnit(new UserMessage(messageId: $"user-{Guid.NewGuid()}"));
var ctx = new MessagingContext(as4Msg, MessagingContextMode.Receive)
{
ReceivingPMode = new ReceivingProcessingMode
{
Security = { SigningVerification = { Signature = Limit.Required } }
},
SendingPMode = new SendingProcessingMode
{
Security = { SigningVerification = { Signature = Limit.Ignored } }
}
};
// Act
StepResult result = await ExerciseVerify(ctx);
// Assert
Assert.True(result.CanProceed);
}
public async Task SignalMessage_Gets_Saved_As_Duplicate_When_InMessage_Exists_With_Same_EbmsRefToMessageId()
{
// Arrange
string ebmsMessageId = $"receipt-{Guid.NewGuid()}";
string ebmsRefToMessageId = $"user-{Guid.NewGuid()}";
GetDataStoreContext.InsertInMessage(
new InMessage(ebmsMessageId)
{
EbmsRefToMessageId = ebmsRefToMessageId
});
var receipt = new Receipt(ebmsMessageId, ebmsRefToMessageId);
var context = new MessagingContext(
AS4Message.Create(receipt),
new ReceivedMessage(Stream.Null),
MessagingContextMode.Receive);
// Act
await Step.ExecuteAsync(context);
// Assert
InMessage actual = GetDataStoreContext.GetInMessage(
m => m.EbmsMessageId == ebmsMessageId &&
m.EbmsRefToMessageId == ebmsRefToMessageId &&
m.IsDuplicate);
Assert.True(actual != null, "Saved Receipt should be marked as duplicate");
}
private static async Task WriteAS4MessageToResponseAsync(AS4Message message, HttpListenerResponse response)
{
try
{
using (Stream responseStream = response.OutputStream)
{
if (message.IsEmpty == false)
{
ISerializer serializer = SerializerProvider.Default.Get(message.ContentType);
await serializer.SerializeAsync(message, responseStream);
}
}
}
catch (Exception exception)
{
Logger.Error($"An error occured while writing the Response to the ResponseStream: {exception.Message}");
if (Logger.IsTraceEnabled)
{
Logger.Trace(exception.StackTrace);
}
throw;
}
}
public async Task ThenExecuteStepUpdatesDuplicateReceiptMessage()
{
// Arrange
SignalMessage signalMessage = new Receipt($"receipt-{Guid.NewGuid()}", "ref-to-message-id");
signalMessage.IsDuplicate = false;
using (MessagingContext messagingContext =
CreateReceivedMessagingContext(AS4Message.Create(signalMessage), null))
{
// Act
// Execute the step twice.
StepResult stepResult = await Step.ExecuteAsync(messagingContext);
Assert.False(stepResult.MessagingContext.AS4Message.FirstSignalMessage.IsDuplicate);
}
using (MessagingContext messagingContext =
CreateReceivedMessagingContext(AS4Message.Create(signalMessage), null))
{
StepResult stepResult = await Step.ExecuteAsync(messagingContext);
// Assert
Assert.True(stepResult.MessagingContext.AS4Message.FirstSignalMessage.IsDuplicate);
}
}
/// <summary>
/// Transform to a <see cref="MessagingContext" />
/// with a <see cref="AS4Message" /> included
/// </summary>
/// <param name="message"></param>
/// <returns></returns>
public async Task <MessagingContext> TransformAsync(ReceivedMessage message)
{
if (message == null)
{
throw new ArgumentNullException(nameof(message));
}
if (message.UnderlyingStream == null)
{
throw new InvalidDataException(
$"The incoming stream from {message.Origin} is not an ebMS Message");
}
if (!ContentTypeSupporter.IsContentTypeSupported(message.ContentType))
{
throw new InvalidDataException(
$"ContentType {nameof(message.ContentType)} is not supported");
}
VirtualStream messageStream = await CopyIncomingStreamToVirtualStream(message);
AS4Message as4Message = await DeserializeMessage(message.ContentType, messageStream, CancellationToken.None);
return(new MessagingContext(as4Message, message, MessagingContextMode.Unknown));
}
public async Task Deliver_Message_Only_When_Referenced_Payloads_Are_Delivered()
{
AS4Message as4Message = await CreateAS4MessageFrom(deliveragent_message);
string deliverLocation = DeliverPayloadLocationOf(as4Message.Attachments.First());
CleanDirectoryAt(Path.GetDirectoryName(deliverLocation));
// Act
IPMode pmode = CreateReceivedPMode(
deliverMessageLocation: DeliveryRoot,
deliverPayloadLocation: @"%# \ (+_O) / -> Not a valid path");
InMessage inMessage = CreateInMessageRepresentingUserMessage(as4Message.GetPrimaryMessageId(), as4Message, pmode);
await InsertInMessageAsync(inMessage);
// Assert
var spy = DatabaseSpy.Create(_as4Msh.GetConfiguration());
InMessage actual = await PollUntilPresent(
() => spy.GetInMessageFor(im => im.Id == inMessage.Id && im.Status == InStatus.Exception.ToString()),
TimeSpan.FromSeconds(10));
Assert.Empty(Directory.EnumerateFiles(DeliveryRoot));
Assert.Equal(InStatus.Exception, actual.Status.ToEnum <InStatus>());
Assert.Equal(Operation.DeadLettered, actual.Operation);
}
public async Task ThenAgreementRefIsNotEnoughAsync(string name, string type)
{
// Arrange
var agreementRef = new AS4.Model.PMode.AgreementReference {
Value = name, Type = type, PModeId = "pmode-id"
};
ArrangePModeThenAgreementRefIsNotEnough(agreementRef);
var userMessage = new UserMessage(
Guid.NewGuid().ToString(),
new AS4.Model.Core.CollaborationInfo(
agreement: new AgreementReference(name, type, "pmode-id"),
service: new Service("service"),
action: "action",
conversationId: "1"));
var messagingContext = new MessagingContext(AS4Message.Create(userMessage), MessagingContextMode.Receive);
// Act
StepResult result = await _step.ExecuteAsync(messagingContext);
// Assert
Assert.False(result.Succeeded);
ErrorResult errorResult = result.MessagingContext.ErrorResult;
Assert.Equal(ErrorCode.Ebms0010, errorResult.Code);
}
/// <summary>
/// Execute the step for a given <paramref name="messagingContext" />.
/// </summary>
/// <param name="messagingContext">Message used during the step execution.</param>
/// <returns></returns>
public Task <StepResult> ExecuteAsync(MessagingContext messagingContext)
{
if (messagingContext == null)
{
throw new ArgumentNullException(nameof(messagingContext));
}
if (messagingContext.AS4Message == null)
{
throw new InvalidOperationException(
$"{nameof(VerifyPullRequestAuthorizationStep)} requires a MessagingContext with a AS4Message to verify the PullRequest");
}
AS4Message as4Message = messagingContext.AS4Message;
var authorizationMap = new PullAuthorizationMapService(_pullAuthorizationMapProvider);
if (authorizationMap.IsPullRequestAuthorized(as4Message))
{
return(StepResult.SuccessAsync(messagingContext));
}
string mpc = (as4Message.FirstSignalMessage as PullRequest)?.Mpc ?? string.Empty;
throw new SecurityException(
$"{messagingContext.LogTag} PullRequest for MPC {mpc} is not authorized. " +
"Either change the PullRequest MPC or add the MPC value to the authorization map");
}
private async Task ExerciseLog(AS4Message as4Message, ErrorResult error)
{
var sut = new LogReceivedProcessingErrorStep(GetDataStoreContext);
await sut.ExecuteAsync(
new MessagingContext(as4Message, MessagingContextMode.Send) { ErrorResult = error });
}
private async Task <MessagingContext> InsertReceivedAS4MessageAsync(MessagingContext messagingContext)
{
using (DatastoreContext context = _createDatastoreContext())
{
MessageExchangePattern messageExchangePattern =
messagingContext.Mode == MessagingContextMode.PullReceive
? MessageExchangePattern.Pull
: MessageExchangePattern.Push;
try
{
var service = new InMessageService(_config, new DatastoreRepository(context));
AS4Message as4Message = await service
.InsertAS4MessageAsync(
messagingContext.AS4Message,
messagingContext.ReceivedMessage,
messagingContext.SendingPMode,
messageExchangePattern,
_messageBodyStore)
.ConfigureAwait(false);
messagingContext.ModifyContext(as4Message);
await context.SaveChangesAsync().ConfigureAwait(false);
return(messagingContext);
}
catch (Exception ex)
{
return(new MessagingContext(ex));
}
}
}
/// <summary>
/// Asserts the party information.
/// </summary>
/// <param name="expected">The expected.</param>
/// <param name="actual">The actual.</param>
public static void AssertPartyInfo(AS4Message expected, MessageEntity actual)
{
Func <Party, string> getPartyId = p => p.PartyIds.First().Id;
Assert.Equal(getPartyId(expected.FirstUserMessage.Sender), actual.FromParty);
Assert.Equal(getPartyId(expected.FirstUserMessage.Receiver), actual.ToParty);
}
private async Task <AS4Message> ParseStreamToAS4MessageAsync(
Stream inputStream,
string contentType,
CancellationToken cancellationToken)
{
if (inputStream == null)
{
throw new ArgumentNullException(nameof(inputStream));
}
List <MimePart> bodyParts = TryParseBodyParts(inputStream, cancellationToken);
Stream envelopeStream = bodyParts.First().ContentObject?.Open();
AS4Message message = await _soapSerializer
.DeserializeAsync(envelopeStream, contentType, cancellationToken).ConfigureAwait(false);
foreach (var userMessage in message.UserMessages)
{
IEnumerable <PartInfo> referencedPartInfos =
userMessage.PayloadInfo ?? Enumerable.Empty <PartInfo>();
IEnumerable <Attachment> attachments = BodyPartsAsAttachments(bodyParts, referencedPartInfos);
message.AddAttachments(attachments);
}
return(message);
}
