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);
}
private static UserMessage CreateMultihopUserMessage(string receivePModeId, SendingProcessingMode pmode)
{
var collaboration =
new Model.Core.CollaborationInfo(
new Model.Core.AgreementReference(
value: "http://agreements.europa.org/agreement",
pmodeId: receivePModeId),
service: new Model.Core.Service(
value: "Forward_Push_Service",
type: "eu:europa:services"),
action: "Forward_Push_Action",
conversationId: "eu:europe:conversation");
IEnumerable <MessageProperty> properties =
pmode.MessagePackaging?.MessageProperties?.Select(
p => new MessageProperty(p.Name, p.Value, p.Type)) ?? new MessageProperty[0];
Party p1 = pmode.MessagePackaging?.PartyInfo.FromParty;
Party p2 = pmode.MessagePackaging?.PartyInfo.ToParty;
return(new UserMessage(
$"multihop-message-id-{Guid.NewGuid()}",
collaboration,
SendingPModeMap.ResolveSender(p1),
SendingPModeMap.ResolveSender(p2),
new Model.Core.PartInfo[0],
properties));
}
/// <summary>
/// Start creating a <see cref="AS4Message" />
/// </summary>
/// <param name="messagingContext"></param>
/// <returns></returns>
public async Task <StepResult> ExecuteAsync(MessagingContext messagingContext)
{
if (messagingContext == null)
{
throw new ArgumentNullException(nameof(messagingContext));
}
if (messagingContext.AS4Message == null)
{
throw new InvalidOperationException(
$"{nameof(CreateDefaultAS4MessageStep)} requires an AS4Message to assign the default UserMessage to but no AS4Message is present in the MessagingContext");
}
SendingProcessingMode pmode = _config.GetSendingPMode(DefaultPmode);
IEnumerable <PartInfo> parts =
messagingContext.AS4Message.Attachments.Select(PartInfo.CreateFor);
UserMessage userMessage =
SendingPModeMap.CreateUserMessage(pmode, parts.ToArray());
messagingContext.AS4Message.AddMessageUnit(userMessage);
messagingContext.SendingPMode = pmode;
Logger.Info($"{messagingContext.LogTag} Default AS4Message is created using SendingPMode {pmode.Id}");
return(await StepResult.SuccessAsync(messagingContext));
}
public void ThenResolverGetsDefaultService()
{
// Arrange
var pmode = new SendingProcessingMode();
// Act
AS4.Model.Core.Service service = SendingPModeMap.ResolveService(pmode);
// Assert
Assert.Equal(AS4.Model.Core.Service.TestService, service);
}
public void ThenResolverGetsDefaultAction()
{
// Arrange
var pmode = new SendingProcessingMode();
// Act
string action = SendingPModeMap.ResolveAction(pmode);
// Assert
Assert.Equal(Constants.Namespaces.TestAction, action);
}
public void ThenResolverGetService()
{
// Arrange
SendingProcessingMode pmode = CreateDefaultSendingPMode();
// Act
AS4.Model.Core.Service actual = SendingPModeMap.ResolveService(pmode);
// Assert
var expected = pmode.MessagePackaging.CollaborationInfo.Service;
Assert.Equal(expected.Value, actual.Value);
Assert.Equal(Maybe.Just(expected.Type), actual.Type);
}
public void ThenResolverGetsAgreementRefWithPModeId()
{
// Arrange
SendingProcessingMode pmode = CreateSendingPMode(includePMode: true);
// Act
AS4.Model.Core.AgreementReference agreementRef = SendingPModeMap.ResolveAgreementReference(pmode).UnsafeGet;
// Assert
AgreementReference pmodeRef = pmode.MessagePackaging.CollaborationInfo.AgreementReference;
Assert.Equal(pmodeRef.Value, agreementRef.Value);
Assert.Equal(Maybe.Just(pmodeRef.Type), agreementRef.Type);
Assert.Equal(Maybe.Just(pmode.Id), agreementRef.PModeId);
}
public Property Then_Receiver_Gets_Populated_When_Present(
NonEmptyString role,
NonEmptyString partyId)
{
return(Prop.ForAll(
ArbParty(role, partyId),
p =>
{
var actual = SendingPModeMap.ResolveReceiver(p);
bool isDefault = actual.Equals(CoreParty.DefaultTo);
bool isResolved = actual.Role == role.Get && actual.PrimaryPartyId == partyId.Get;
return (isDefault == (p == null)).And(isResolved == (p != null));
}));
}
public void ThenResolverGetsAction()
{
// Arrange
var pmode = new SendingProcessingMode
{
MessagePackaging = { CollaborationInfo = new AS4.Model.PMode.CollaborationInfo {
Action = "action"
} }
};
// Act
string action = SendingPModeMap.ResolveAction(pmode);
// Assert
Assert.Equal(pmode.MessagePackaging.CollaborationInfo.Action, action);
}
private static string ResolveAction(SubmitMessage submit, SendingProcessingMode sendingPMode)
{
string submitAction = submit?.Collaboration?.Action;
string pmodeAction = sendingPMode?.MessagePackaging?.CollaborationInfo?.Action;
if (sendingPMode?.AllowOverride == false &&
!String.IsNullOrEmpty(submitAction) &&
!String.IsNullOrEmpty(pmodeAction) &&
!StringComparer.OrdinalIgnoreCase.Equals(submitAction, pmodeAction))
{
throw new NotSupportedException(
$"SubmitMessage is not allowed by SendingPMode {sendingPMode.Id} to override Action");
}
if (!String.IsNullOrEmpty(submitAction))
{
return(submit.Collaboration.Action);
}
return(SendingPModeMap.ResolveAction(sendingPMode));
}
private static Service ResolveService(SubmitMessage submit, SendingProcessingMode sendingPMode)
{
var pmodeService = sendingPMode?.MessagePackaging?.CollaborationInfo?.Service;
var submitService = submit?.Collaboration?.Service;
if (sendingPMode?.AllowOverride == false &&
!String.IsNullOrEmpty(submitService?.Value) &&
!String.IsNullOrEmpty(pmodeService?.Value) &&
!StringComparer.OrdinalIgnoreCase.Equals(submitService.Value, pmodeService.Value))
{
throw new NotSupportedException(
$"SubmitMessage is not allowed by SendingPMode {sendingPMode.Id} to override CollaborationInfo.Service");
}
if (submitService?.Value != null)
{
return(new Service(submitService.Value, submitService.Type));
}
return(SendingPModeMap.ResolveService(sendingPMode));
}
private static Party ResolveSenderParty(SubmitMessage submit, SendingProcessingMode sendingPMode)
{
var pmodeParty = sendingPMode?.MessagePackaging?.PartyInfo?.FromParty;
var submitParty = submit?.PartyInfo?.FromParty;
if (sendingPMode?.AllowOverride == false &&
submitParty != null &&
pmodeParty != null &&
!submitParty.Equals(pmodeParty))
{
throw new NotSupportedException(
$"SubmitMessage is not allowed by SendingPMode {sendingPMode.Id} to override Sender Party");
}
if (submitParty != null)
{
var ids = submitParty.PartyIds ?? Enumerable.Empty <Model.Common.PartyId>();
return(new Party(submitParty.Role, ids.Select(x => new PartyId(x.Id, x.Type)).ToArray()));
}
return(SendingPModeMap.ResolveSender(pmodeParty));
}