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); }