private ReqOld ConvertSubmitMessageToReqOld(SubmitMessage submit)
{
var req = new ReqOld.Builder();
if (submit.ParamJSON != null)
{
req.ParamJSON = ByteString.CopyFrom(DuiHelperConvert.ObjectToByteArray(submit.ParamJSON));
}
if (submit.ParamStringList != null)
{
req.ParamStringList = ByteString.CopyFrom(DuiHelperConvert.ObjectToByteArray(submit.ParamStringList));
}
if (submit.ParamString != null)
{
req.ParamString = ByteString.CopyFrom(DuiHelperConvert.ObjectToByteArray(submit.ParamString));
}
if (submit.ParamBytes != null)
{
req.ParamBytes = ByteString.CopyFrom(DuiHelperConvert.ObjectToByteArray(submit.ParamBytes));
}
if (submit.ParamByteList != null)
{
req.ParamByteList = ByteString.CopyFrom(DuiHelperConvert.ObjectToByteArray(submit.ParamByteList));
}
req.Marker = submit.Marker ?? "";
req.IsUseZip = submit.IsUseZip;
req.TranName = submit.TranName ?? "";
req.Function = submit.Function ?? "";
req.Action = submit.Action ?? "";
req.DBMarker = submit.DBMarker ?? "";
req.Json = submit.Json ?? "";
return(req.Build());
}
/// <summary>
/// Puts a <see cref="SubmitMessage"/> with a given reference to a <see cref="SendingProcessingMode"/>
/// and with optional payloads references on disk so they get picked-up by the AS4 component.
/// </summary>
/// <param name="pmodeId">The identifier to reference a <see cref="SendingProcessingMode"/>.</param>
/// <param name="payloads">The sequence of submit payloads to include in the message.</param>
/// <param name="setCustomFixtures">The function to place custom settings to the created message.</param>
public void PutSubmitMessage(
string pmodeId,
Action <SubmitMessage> setCustomFixtures,
params Payload[] payloads)
{
var submitMessage = new SubmitMessage
{
Collaboration =
{
AgreementRef =
{
PModeId = pmodeId,
Value = "http://agreements.holodeckb2b.org/examples/agreement0"
},
ConversationId = "eu:edelivery:as4:sampleconversation",
Action = Constants.Namespaces.TestAction,
Service =
{
Type = Constants.Namespaces.TestService,
Value = Constants.Namespaces.TestService
}
},
Payloads = payloads
};
setCustomFixtures(submitMessage);
string xml = AS4XmlSerializer.ToString(submitMessage);
string fileName = Path.Combine(FullOutputPath, $"submit-{pmodeId}.xml");
Console.WriteLine($@"Putting {fileName}");
File.WriteAllText(fileName, xml);
}
private static SubmitMessage CreateSubmitMessageWithMpc(string mpc)
{
var message = new SubmitMessage();
message.MessageInfo.Mpc = mpc;
return(message);
}
private static string ResolveConversationId(SubmitMessage submit)
{
string submitConversationId = submit?.Collaboration?.ConversationId;
return(String.IsNullOrEmpty(submitConversationId)
? CollaborationInfo.DefaultConversationId
: submitConversationId);
}
private static void AssertMessageProperty(SubmitMessage submitMessage, MessagingContext messagingContext)
{
SubmitMessageProperty submitMessageProperty = submitMessage.MessageProperties.First();
UserMessageProperty userMessageMessageProperty =
messagingContext.AS4Message.FirstUserMessage.MessageProperties.First();
Assert.Equal(submitMessageProperty.Value, userMessageMessageProperty.Value);
Assert.Equal(submitMessageProperty.Name, userMessageMessageProperty.Name);
}
private static void AssertAgreementReference(SubmitMessage submitMessage, MessagingContext messagingContext)
{
AS4.Model.PMode.AgreementReference pmodeAgreementRef =
submitMessage.PMode.MessagePackaging.CollaborationInfo.AgreementReference;
AS4.Model.Core.AgreementReference userMessageAgreementRef =
messagingContext.AS4Message.FirstUserMessage.CollaborationInfo.AgreementReference.UnsafeGet;
Assert.Equal(pmodeAgreementRef.Value, userMessageAgreementRef.Value);
Assert.Equal(Maybe <string> .Nothing, userMessageAgreementRef.Type);
}
private static MemoryStream WriteSubmitMessageToStream(SubmitMessage submitMessage)
{
var memoryStream = new MemoryStream();
var serializer = new XmlSerializer(typeof(SubmitMessage));
serializer.Serialize(memoryStream, submitMessage);
memoryStream.Position = 0;
return(memoryStream);
}
private SubmitMessage BuildMessage(MessagePayload submitInfo, SendingProcessingMode sendingPmode, List <FilePayload> payloads)
{
var submitMessage = new SubmitMessage {
MessageInfo = { MessageId = $"{Guid.NewGuid()}@{Environment.MachineName}" }
};
submitMessage.Collaboration.AgreementRef.PModeId = sendingPmode.Id;
submitMessage.Payloads = payloads.Select(x => x.ToPayload(CreatePayloadId(submitInfo, x.FileName, submitMessage.MessageInfo.MessageId))).ToArray();
return(submitMessage);
}
private async Task SubmitMessage(SubmitMessage message, string toLocation)
{
client.SendAs4Message(AS4XmlSerializer.ToString(message), message.MessageInfo.MessageId);
var handler = messageHandlers.First(x => x.CanHandle(toLocation));
if (handler == null)
{
throw new Exception($"No message handler found for {toLocation}");
}
await handler.Handle(message, toLocation);
}
private void Connect(string ip, int port)
{
for (int i = 0; i < 1000; i++)
{
try
{
//Thread.Sleep(1000);
var client = new DuiAsynSocket.SocketClient();
client.IsSplitPack = true;
client.HeartBeatsEnable = true;
client.IsUseHeartBeatCertificate = true;
client.OnConnChangeEvent += _client_OnConnChangeEvent;
client.OnReceivedEvent += _client_OnReceivedEvent;
client.Connect(ip, port);
string[] loginInfos = new string[]
{
"yangxinwen",
Md5Hash.GetMd5Hash("12345678"),
"933f63a173540f09b587fb7f95625bbb",
"1.1.1"
};
SubmitMessage submitMsg = new SubmitMessage()
{
ParamString = loginInfos,
TranName = "UserLogin",
IsUseZip = false,
Marker = "Local"
};
client.Send(GetData(submitMsg));
var submit = new SubmitMessage()
{
TranName = "GetHQCache", Marker = "Local"
};
client.Send(GetData(submit));
submit = new SubmitMessage()
{
TranName = "GetConfigCache", Marker = "Local"
};
submit.ParamString = new string[] { "sdfsdf" };
client.Send(GetData(submit));
}
catch (Exception)
{
}
}
}
public async Task ThenStepFailsToCreateAS4MessageWhenSubmitMessageTriesToOVerrideSenderPartyAsync()
{
// Arrange
SubmitMessage submitMessage = SubmitWithTwoPayloads();
submitMessage.PartyInfo = CreatePopulatedSubmitPartyInfo();
submitMessage.PMode = DefaultSendPMode();
var internalMessage = new MessagingContext(submitMessage);
// Act / Assert
await Assert.ThrowsAnyAsync <Exception>(() => ExerciseCreateAS4Message(internalMessage));
}
private byte[] GetData(SubmitMessage submit)
{
var request = new RequestBase.Builder();
request.FunCode = 1;
if ("HQServer".Equals(submit.Marker))
{
request.IsHQ = true;
}
request.Body = ConvertSubmitMessageToReqOld(submit).ToByteString();
return(request.Build().ToByteArray());
}
public void ThenHasPayloadsIsCorrectFalse()
{
// Arrange
var submitMessage = new SubmitMessage();
var internalMessage = new MessagingContext(submitMessage);
// Act
bool hasPayloads = internalMessage.SubmitMessage.HasPayloads;
// Assert
Assert.False(hasPayloads);
}
public void Creates_ToParty_From_Either_Submit_Or_SendingPMode(
bool allowOverride,
string submitToParty,
string pmodeToParty,
Mapped expected)
{
// Arrange
var submit = new SubmitMessage
{
PartyInfo =
{
ToParty = submitToParty != null
? new AS4.Model.Common.Party
{
Role = Guid.NewGuid().ToString(),
PartyIds = new[] { new AS4.Model.Common.PartyId {
Id = submitToParty
} }
}
: null
}
};
var sendingPMode = new SendingProcessingMode
{
AllowOverride = allowOverride,
MessagePackaging =
{
PartyInfo = new PartyInfo
{
ToParty = pmodeToParty != null
? new Party(Guid.NewGuid().ToString(), new PartyId(pmodeToParty))
: null
}
}
};
// Act
UserMessage result = SubmitMessageMap.CreateUserMessage(submit, sendingPMode);
// Assert
Mapped actual =
result.Receiver.PartyIds.First().Id == pmodeToParty
? Mapped.PMode
: result.Receiver.PartyIds.First().Id == submitToParty
? Mapped.Submit
: Mapped.Default;
Assert.Equal(expected, actual);
Assert.True(
(actual == Mapped.Default) == (result.Receiver.Equals(AS4.Model.Core.Party.DefaultTo)),
"fallback on default ToParty when none in Submit and SendingPMode is defined");
}
public async Task ThenStepCreatesAS4MessageWithMpcFromSubmitMessage()
{
SubmitMessage submitMessage = CreateSubmitMessageWithMpc("some-mpc");
submitMessage.PMode = DefaultSendPMode();
submitMessage.Collaboration.AgreementRef.PModeId = submitMessage.PMode.Id;
submitMessage.PMode.AllowOverride = true;
var context = new MessagingContext(submitMessage);
StepResult result = await ExerciseCreateAS4Message(context);
Assert.Equal(result.MessagingContext.AS4Message.FirstUserMessage.Mpc, submitMessage.MessageInfo.Mpc);
}
/// <summary>
/// Transform a <see cref="SubmitMessage" />
/// to a <see cref="MessagingContext"/>
/// </summary>
/// <param name="message"></param>
/// <returns></returns>
public async Task <MessagingContext> TransformAsync(ReceivedMessage message)
{
if (message == null)
{
throw new ArgumentNullException(nameof(message));
}
Logger.Trace("Start deserializing to a SubmitMessage...");
SubmitMessage submitMessage = DeserializeSubmitMessage(message);
Logger.Trace("Successfully deserialized to a SubmitMessage");
return(await Task.FromResult(new MessagingContext(submitMessage)));
}
public void ThenHasPayloadsIsCorrectTrue()
{
// Arrange
var submitMessage = new SubmitMessage {
Payloads = new[] { new Payload(string.Empty) }
};
var internalMessage = new MessagingContext(submitMessage);
// Act
bool hasPayloads = internalMessage.SubmitMessage.HasPayloads;
// Assert
Assert.True(hasPayloads);
}
/// <summary>
/// Initializes a new instance of the <see cref="MessagingContext" /> class.
/// Create and Internal Message with a given <see cref="Submit.SubmitMessage" />
/// </summary>
/// <param name="submitMessage">
/// </param>
public MessagingContext(SubmitMessage submitMessage)
{
if (submitMessage == null)
{
throw new ArgumentNullException(nameof(submitMessage));
}
SubmitMessage = submitMessage;
ReceivedMessage = null;
AS4Message = null;
DeliverMessage = null;
NotifyMessage = null;
Mode = MessagingContextMode.Submit;
}
public async Task ThenStepCreatesAS4MessageWithSubmitMessageProperties()
{
// Arrange
SubmitMessage submitMessage = SubmitWithTwoPayloads();
submitMessage.PMode = DefaultSendPMode();
var internalMessage = new MessagingContext(submitMessage);
// Act
StepResult result = await ExerciseCreateAS4Message(internalMessage);
// Assert
AssertMessageProperty(submitMessage, result.MessagingContext);
}
public async Task ThenStepCreatesAS4MessageWithMpcFromSendingPMode()
{
SubmitMessage submitMessage = new SubmitMessage();
submitMessage.PMode = DefaultSendPMode();
submitMessage.Collaboration.AgreementRef.PModeId = submitMessage.PMode.Id;
submitMessage.MessageInfo.Mpc = null;
submitMessage.PMode.MessagePackaging.Mpc = "some-mpc";
var context = new MessagingContext(submitMessage);
StepResult result = await ExerciseCreateAS4Message(context);
Assert.Equal("some-mpc", result.MessagingContext.AS4Message.FirstUserMessage.Mpc);
}
public async Task ThenStepCreatesAS4MessageWithGeneratedMessageId()
{
// Arrange
SubmitMessage submitMessage = SubmitWithTwoPayloads();
submitMessage.MessageInfo.MessageId = null;
submitMessage.PMode = DefaultSendPMode();
var internalMessage = new MessagingContext(submitMessage);
// Act
StepResult result = await ExerciseCreateAS4Message(internalMessage);
// Assert
Assert.NotEmpty(result.MessagingContext.AS4Message.FirstUserMessage.MessageId);
}
private static void ValidateSubmitMessage(SubmitMessage submitMessage)
{
SubmitMessageValidator
.Instance
.Validate(submitMessage)
.Result(
result => Logger.Trace($"SubmitMessage \"{submitMessage.MessageInfo?.MessageId}\" is valid"),
result =>
{
string description = result.AppendValidationErrorsToErrorMessage("SubmitMessage was invalid");
Logger.Error(description);
throw new InvalidMessageException(description);
});
}
private static async Task StoreToBeSentUserMessage(string mpc)
{
var submit = new SubmitMessage
{
MessageInfo = new MessageInfo(messageId: null, mpc: mpc),
Collaboration =
{
AgreementRef =
{
PModeId = "pullsendagent-pmode"
}
}
};
await SubmitMessageToSubmitAgent(AS4XmlSerializer.ToString(submit));
}
public void Fails_When_Submit_Tries_To_Override_Mpc()
{
// Arrange
var submit = new SubmitMessage {
MessageInfo = { Mpc = Guid.NewGuid().ToString() }
};
var sendingPMode = new SendingProcessingMode
{
AllowOverride = false,
MessagePackaging = { Mpc = Guid.NewGuid().ToString() }
};
// Act / Assert
Assert.Throws <NotSupportedException>(
() => SubmitMessageMap.CreateUserMessage(submit, sendingPMode));
}
public async Task ThenStepCreatesAS4Message()
{
// Arrange
SubmitMessage submitMessage = SubmitWithTwoPayloads();
submitMessage.PMode = DefaultSendPMode();
var context = new MessagingContext(submitMessage);
// Act
StepResult result = await ExerciseCreateAS4Message(context);
// Assert
UserMessage userMessage = result.MessagingContext.AS4Message.FirstUserMessage;
Assert.NotNull(userMessage);
}
public async Task ThenStepCreatesAS4MessageWithAction()
{
// Arrange
SubmitMessage submitMessage = SubmitWithTwoPayloads();
submitMessage.PMode = DefaultSendPMode();
var internalMessage = new MessagingContext(submitMessage);
// Act
StepResult result = await ExerciseCreateAS4Message(internalMessage);
// Assert
string pmodeAction = submitMessage.PMode.MessagePackaging.CollaborationInfo.Action;
string userMessageAction = result.MessagingContext.AS4Message.FirstUserMessage.CollaborationInfo.Action;
Assert.Equal(pmodeAction, userMessageAction);
}
/// <summary>
/// Handles the specified message.
/// </summary>
/// <param name="message">The message.</param>
/// <param name="toLocation">To location.</param>
/// <returns></returns>
/// <exception cref="BusinessException"></exception>
public async Task Handle(SubmitMessage message, string toLocation)
{
try
{
await Task.Run(() =>
{
var serializer = new XmlSerializer(typeof(SubmitMessage));
using (var fs = File.Create(Path.Combine(toLocation, $"{message.MessageInfo.MessageId}.xml")))
{
serializer.Serialize(fs, message);
}
});
}
catch (Exception)
{
throw new BusinessException($"Could not save file to location {toLocation}. Check that the server has access and that the to location is valid.");
}
}
public async Task AssignsAttachmentLocations()
{
// Arrange
SubmitMessage message = SubmitWithTwoPayloads();
message.PMode = DefaultSendPMode();
var context = new MessagingContext(message);
// Act
StepResult result = await ExerciseCreateAS4Message(context);
// Assert
AS4Message actual = result.MessagingContext.AS4Message;
Assert.True(actual.HasAttachments);
Assert.Equal(Stream.Null, actual.Attachments.First().Content);
}
public async Task ThenStepCreatesAS4MessageWithReceiverParty()
{
// Arrange
SubmitMessage submitMessage = SubmitWithTwoPayloads();
submitMessage.PMode = DefaultSendPMode();
var internalMessage = new MessagingContext(submitMessage);
// Act
StepResult result = await ExerciseCreateAS4Message(internalMessage);
// Assert
var pmodeParty = submitMessage.PMode.MessagePackaging.PartyInfo.ToParty;
Party userMessageParty = result.MessagingContext.AS4Message.FirstUserMessage.Receiver;
Assert.Equal(pmodeParty.Role, userMessageParty.Role);
Assert.Equal(pmodeParty.PrimaryPartyId, userMessageParty.PrimaryPartyId);
}
public async Task NoPayloadsToRetrieve()
{
// Arrange
SubmitMessage submit = SubmitWithTwoPayloads();
submit.PMode = DefaultSendPMode();
submit.Payloads = null;
var context = new MessagingContext(submit);
// Act
StepResult result = await ExerciseCreateAS4Message(context);
// Assert
AS4Message actual = result.MessagingContext.AS4Message;
Assert.False(actual.HasAttachments);
}
