/// <summary>
/// copies all message parts part of the inbound message onto the outbound message
/// </summary>
/// <param name="pc">the <see cref="IPipelineContext"/> this message belongs to</param>
/// <param name="inmsg">the inbound message</param>
/// <param name="outmsg">the outbound message</param>
/// <param name="bodyPart">the body part</param>
/// <param name="allowUnrecognizeMessage">whether to allow unrecognized messages</param>
public static void CopyMessageParts(
IPipelineContext pc,
IBaseMessage inmsg,
IBaseMessage outmsg,
IBaseMessagePart bodyPart,
bool allowUnrecognizeMessage)
{
string text1 = inmsg.BodyPartName;
for (int num1 = 0; num1 < inmsg.PartCount; num1++)
{
string text2 = null;
IBaseMessagePart part1 = inmsg.GetPartByIndex(num1, out text2);
if ((part1 == null) && !allowUnrecognizeMessage)
{
throw new ArgumentNullException("otherOutPart[" + num1 + "]");
}
if (text1 != text2)
{
outmsg.AddPart(text2, part1, false);
}
else
{
outmsg.AddPart(text1, bodyPart, true);
}
}
}
private IBaseMessage BuildBTSMessage(IPipelineContext pContext, IBaseMessageContext sourceContext, List <Part> partList)
{
IBaseMessage newMessage = pContext.GetMessageFactory().CreateMessage();
IBaseMessagePart msgPart = pContext.GetMessageFactory().CreateMessagePart();
newMessage.Context = sourceContext;
foreach (Part part in partList)
{
if (part.Data != null)
{
msgPart.Charset = "utf-8";
msgPart.ContentType = part.ContentType;
msgPart.Data = GetPartStream(part.Data);
newMessage.AddPart(part.PartName, msgPart, part.IsBodyPart);
}
else
{
System.IO.MemoryStream memStrm = new MemoryStream();
StreamWriter sw = new StreamWriter(memStrm);
sw.Write(part.RawData);
sw.Flush();
memStrm.Position = 0;
msgPart.ContentType = part.ContentType;
msgPart.Data = memStrm;
newMessage.AddPart(part.PartName, msgPart, part.IsBodyPart);
}
}
return(newMessage);
}
/// <summary>
/// Synchronously executes the task using the specified <see cref="RuntimeTaskExecutionContext"/> execution context object.
/// </summary>
/// <param name="context">The execution context.</param>
public override void Run(RuntimeTaskExecutionContext context)
{
var callToken = TraceManager.CustomComponent.TraceIn();
IBaseMessageFactory msgFactory = context.PipelineContext.GetMessageFactory();
IBaseMessage responseMsg = msgFactory.CreateMessage();
IBaseMessageContext responseMsgCtx = msgFactory.CreateMessageContext();
IBaseMessageContext requestMsgCtx = context.Message.Context;
responseMsg.Context = responseMsgCtx;
if (BizTalkUtility.ContainsResponsePart(context.Message))
{
IBaseMessagePart responsePart = BizTalkUtility.GetResponsePart(context.Message);
responseMsg.AddPart(context.Message.BodyPartName, responsePart, true);
}
else
{
responseMsg.AddPart(context.Message.BodyPartName, context.Message.BodyPart, true);
}
responseMsgCtx.Promote(EpmRRCorrelationToken.Name.Name, EpmRRCorrelationToken.Name.Namespace, requestMsgCtx.Read(EpmRRCorrelationToken.Name.Name, EpmRRCorrelationToken.Name.Namespace));
responseMsgCtx.Promote(RouteDirectToTP.Name.Name, RouteDirectToTP.Name.Namespace, true);
responseMsgCtx.Promote(CorrelationToken.Name.Name, CorrelationToken.Name.Namespace, requestMsgCtx.Read(CorrelationToken.Name.Name, CorrelationToken.Name.Namespace));
responseMsgCtx.Promote(ReqRespTransmitPipelineID.Name.Name, ReqRespTransmitPipelineID.Name.Namespace, requestMsgCtx.Read(ReqRespTransmitPipelineID.Name.Name, ReqRespTransmitPipelineID.Name.Namespace));
responseMsgCtx.Write(ReceivePipelineResponseConfig.Name.Name, ReceivePipelineResponseConfig.Name.Namespace, requestMsgCtx.Read(ReceivePipelineResponseConfig.Name.Name, ReceivePipelineResponseConfig.Name.Namespace));
context.Message = responseMsg;
TraceManager.CustomComponent.TraceOut(callToken);
}
public static void CloneAndAddMessageParts(IPipelineContext pipelineContext, IBaseMessage sourceMessage, IBaseMessage destinationMessage)
{
if (pipelineContext == null)
{
throw new ArgumentNullException("pipelineContext");
}
if (sourceMessage == null)
{
throw new ArgumentNullException("sourceMessage");
}
if (destinationMessage == null)
{
throw new ArgumentNullException("destinationMessage");
}
try
{
string bodyPartName = sourceMessage.BodyPartName;
for (int index = 0; index < sourceMessage.PartCount; ++index)
{
string partName = (string)null;
IBaseMessagePart partByIndex = sourceMessage.GetPartByIndex(index, out partName);
IBaseMessagePart part = MessageHelper.CloneMessagePart(pipelineContext, partByIndex);
bool bBody = string.Compare(partName, bodyPartName, true, CultureInfo.CurrentCulture) == 0;
destinationMessage.AddPart(partName, part, bBody);
}
}
catch (Exception ex)
{
DECore.TraceProvider.Logger.TraceError(ex);
throw;
}
}
public IBaseMessage Execute(IPipelineContext pContext, IBaseMessage pInMsg)
{
XmlDocument sourceDoc = new XmlDocument();
pInMsg.BodyPart.Data.Position = 0;
sourceDoc.Load(pInMsg.BodyPart.Data);
XmlDocument outputDoc = Tools.ApplyXSLTransform(sourceDoc, TransformResources.MAP_ToMockService);
byte[] arrByte = System.Text.Encoding.UTF8.GetBytes(outputDoc.OuterXml.Replace("utf-16", "utf-8"));
MemoryStream tempStream = new MemoryStream(arrByte);
tempStream.Seek(0, SeekOrigin.Begin);
IBaseMessage outMsg = pContext.GetMessageFactory().CreateMessage();
IBaseMessagePart bodyMsgPart = pContext.GetMessageFactory().CreateMessagePart();
bodyMsgPart.Data = tempStream;
bodyMsgPart.Charset = "utf-8";
outMsg.AddPart("body", bodyMsgPart, true);
outMsg.Context = pInMsg.Context;
outMsg.Context.Promote(BTSProperties.messageType.Name.Name, BTSProperties.messageType.Name.Namespace, "http://NWT.Mocking.Services#SubmitMessage");
pContext.ResourceTracker.AddResource(tempStream);
return(outMsg);
}
/// <summary>
/// Populates a body part with content from an XML document. If no body part exists, a new one
/// is created.
/// </summary>
/// <param name="message">The massage to which the body part will be added.</param>
/// <param name="part">The existing part</param>
/// <param name="pc">The pipeline context.</param>
/// <returns>A message with a body part populated by the XML document content.</returns>
public static bool PopulateBodyPartFromExistingPart(this IBaseMessage message, IBaseMessagePart part, IPipelineContext pc)
{
if (message == null || part == null)
{
return(false);
}
Func <IBaseMessagePart> clonedPart = () =>
{
var newPart = pc.GetMessageFactory().CreateMessagePart();
newPart.Data = part.GetOriginalDataStream().Clone();
return(newPart);
};
var outPart = part.IsMutable
? clonedPart()
: part.WithStreamAtStart();
// Add a body part if none exists.
if (message.BodyPart == null)
{
message.AddPart("Body", outPart, true);
}
return(true);
}
void IAssemblerComponent.AddDocument(IPipelineContext pContext, IBaseMessage pInMsg)
{
if (this.GetFault(pInMsg) != null)
{
qOutputMsgs.Enqueue(pInMsg);
}
else
{
MultipartMessageDefinition tempMessage = MultipartMessageManager.GenerateFromMessage(pInMsg);
StringWriter sw = new StringWriter();
XmlSerializer ser = new XmlSerializer(typeof(MultipartMessageDefinition), Constants.SUBMISSION_NAMESPACE);
ser.Serialize(sw, tempMessage);
byte[] arrByte = System.Text.Encoding.UTF8.GetBytes(sw.ToString().Replace("utf-16", "utf-8")); //GetBytes(sw.ToString().Replace("utf-16", "utf-8")); //GetBytes(sw.ToString());
MemoryStream tempStream = new MemoryStream(arrByte);
tempStream.Seek(0, SeekOrigin.Begin);
IBaseMessage outMsg = pContext.GetMessageFactory().CreateMessage();
IBaseMessagePart outPart = pContext.GetMessageFactory().CreateMessagePart();
outPart.Data = tempStream;
outPart.Charset = "utf-8";
outMsg.AddPart("ConstructedPart", outPart, true);
//outMsg.BodyPart.Data = tempStream;
outMsg.Context = pInMsg.Context;
outMsg.Context.Promote(BTSProperties.messageType.Name.Name, BTSProperties.messageType.Name.Namespace, "http://BizWTF.Mocking.Schemas.Submission#MultipartMessage");
qOutputMsgs.Enqueue(outMsg);
pContext.ResourceTracker.AddResource(tempStream);
}
}
/// <summary>
/// Create the output message when validation errors are captured
/// </summary>
/// <param name="pContext">Pipeline context</param>
/// <param name="pInMsg">Input message in the pipeline</param>
/// <param name="errorStream">Stream for the Validation Errors</param>
/// <param name="requestId">Request Id</param>
/// <returns></returns>
public static IBaseMessage CreateOutPutMessage(IPipelineContext pContext, IBaseMessage pInMsg, VirtualStream errorStream, string requestId)
{
VirtualStream seekableStream = new VirtualStream(pInMsg.BodyPart.GetOriginalDataStream());
seekableStream.Position = 0;
errorStream.Position = 0;
VirtualStream outMsgStream = CreateValidationErrorMessage(seekableStream, errorStream, requestId);
outMsgStream.Position = 0;
IBaseMessageFactory messageFactory = pContext.GetMessageFactory();
IBaseMessage pOutMsg = messageFactory.CreateMessage();
IBaseMessagePart pOutMsgBodyPart = messageFactory.CreateMessagePart();
IBasePropertyBag pOutPb = PipelineUtil.CopyPropertyBag(pInMsg.BodyPart.PartProperties, messageFactory);
pOutMsg.Context = PipelineUtil.CloneMessageContext(pInMsg.Context);
pOutMsgBodyPart.Charset = Constants.BodyPartCharSet;
pOutMsgBodyPart.ContentType = Constants.BodyPartContentType;
pOutMsgBodyPart.Data = outMsgStream;
string outMessageType = string.Format("{0}#{1}", Constants.AIBPValidationErrorNameSpace, Constants.AIBPValidationErrorRootNode);
pOutMsg.Context.Promote(Constants.MessageTypePropName, Constants.SystemPropertiesNamespace, outMessageType);
pOutMsg.AddPart("Body", pOutMsgBodyPart, true);
// Add resources to the resource tracker to be disposed of at correct time
pContext.ResourceTracker.AddResource(seekableStream);
pContext.ResourceTracker.AddResource(outMsgStream);
pContext.ResourceTracker.AddResource(errorStream);
return(pOutMsg);
}
public object Clone()
{
int partCount = this.PartCount;
IBaseMessageFactory factory = new MessageFactory();
IBaseMessage message = factory.CreateMessage();
Message message2 = (Message)message;
message2.messageId = this.MessageID;
IBaseMessageContext oldCtx = this.Context;
if (oldCtx != null)
{
IBaseMessageContext context2 = PipelineUtil.CloneMessageContext(oldCtx);
message.Context = context2;
}
Exception errorInfo = this.GetErrorInfo();
if (errorInfo != null)
{
message.SetErrorInfo(errorInfo);
}
string bodyPartName = this.BodyPartName;
for (int i = 0; i < partCount; i++)
{
string str2;
IBaseMessagePart partByIndex = this.GetPartByIndex(i, out str2);
IBaseMessagePart part = ((MessagePart)partByIndex).CopyMessagePart(factory);
message.AddPart(str2, part, bodyPartName == str2);
}
return(message);
}
private IBaseMessage CreateMessage(Shared.Components.Entry message)
{
MemoryStream mem = new MemoryStream(UTF8Encoding.UTF8.GetBytes(message.Content));
IBaseMessageFactory factory = this.transportProxy.GetMessageFactory();
IBaseMessagePart part = factory.CreateMessagePart();
part.Data = mem;
IBaseMessage msg = factory.CreateMessage();
msg.AddPart("body", part, true);
// We must add these context properties
SystemMessageContext context = new SystemMessageContext(msg.Context);
context.InboundTransportLocation = this.uri;
context.InboundTransportType = this.transportType;
//Set ActionOnFailure to zero in the context property of each messaqe that you do not want BizTalk Server to suspend on a processing exception.
//Failure to set this property allows BizTalk Server to fall back to its default behavior
//of suspending the message on a processing exception.
//context.ActionOnFailure = 0;
//we could promote entity id and updated, msg.Context.Promote(ns, message.Id
return(msg);
}
/// <summary>
/// Creates IBaseMessage object from string
/// </summary>
/// <param name="mf">Reference to BizTalk message factory object</param>
/// <param name="url">Address of receive location where this message will be submitted</param>
/// <param name="data">Payload of the message</param>
/// <returns>BizTalk message object</returns>
public static IBaseMessage CreateMessage(IBaseMessageFactory mf, string url, string data)
{
IBaseMessagePart part = null;
IBaseMessageContext ctx = null;
IBaseMessage msg = null;
SystemMessageContext smc = null;
// Write the data to a new stream...
StreamWriter sw = new StreamWriter(new MemoryStream());
sw.Write(data);
sw.Flush();
sw.BaseStream.Seek(0, SeekOrigin.Begin);
// Create a new message
msg = mf.CreateMessage();
part = mf.CreateMessagePart();
part.Data = sw.BaseStream;
ctx = msg.Context;
msg.AddPart("body", part, true);
// Set the system context properties
smc = new SystemMessageContext(ctx);
if (null != url)
{
smc.InboundTransportLocation = url;
}
return(msg);
}
private IBaseMessage CreateMessage(BrokeredMessage message)
{
Stream stm = message.GetBody <Stream>();
IBaseMessageFactory factory = this.transportProxy.GetMessageFactory();
IBaseMessagePart part = factory.CreateMessagePart();
part.Data = stm;
IBaseMessage msg = factory.CreateMessage();
msg.AddPart("body", part, true);
// We must add these context properties
SystemMessageContext context = new SystemMessageContext(msg.Context);
context.InboundTransportLocation = this.uri;
context.InboundTransportType = this.transportType;
msg.Context.Promote("SequenceNumber", this.propertyNamespace, message.SequenceNumber.ToString());
return(msg);
}
/// <summary>
/// (1) Gets the file from the sftp host
/// (2) Creates a IBaseMessage
/// (3) Sets varius properties such as uri, messagepart, transporttype etc
/// (4) Adds the message to the batch
/// </summary>
/// <param name="fileName"></param>
/// <param name="uri"></param>
/// <param name="size"></param>
/// <returns></returns>
internal IBaseMessage CreateMessage(string fileName, string uri, long size,
SftpReceiveProperties.AfterGetActions afterGetAction, string afterGetFilename)
{
Stream stream;
IBaseMessage message = null;
try
{
TraceMessage("[SftpReceiverEndpoint] Reading file to stream " + fileName);
// Retrieves the message from sftp server.
stream = this._sftp.Get(fileName);
stream.Position = 0;
// Creates new message
IBaseMessageFactory messageFactory = this._transportProxy.GetMessageFactory();
IBaseMessagePart part = messageFactory.CreateMessagePart();
part.Data = stream;
message = messageFactory.CreateMessage();
message.AddPart(MESSAGE_BODY, part, true);
// Setting metadata
SystemMessageContext context = new SystemMessageContext(message.Context);
context.InboundTransportLocation = uri;
context.InboundTransportType = this._transportType;
// Write/Promote any adapter specific properties on the message context
message.Context.Write(REMOTEFILENAME, this._propertyNamespace, (object)fileName);
SetReceivedFileName(message, fileName);
message.Context.Write("ReceivedFileName", "http://schemas.microsoft.com/BizTalk/2003/" +
this._transportType.ToLower() + "-properties", fileName);
message.Context.Write("ReceivedFileName", "http://schemas.microsoft.com/BizTalk/2003/file-properties", fileName);
// Add the file to the batch
this.Files.Add(new BatchMessage(message, fileName, BatchOperationType.Submit, afterGetAction, afterGetFilename));
// Greg Sharp: Let the caller set this as the file size may be stale
// Add the size of the file to the stream
//if (message.BodyPart.Data.CanWrite)
// message.BodyPart.Data.SetLength(size);
return(message);
}
catch (Exception ex)
{
TraceMessage("[SftpReceiverEndpoint] Error Adding file [" + fileName + "]to batch. Error: " + ex.Message);
if (this._useLoadBalancing)
{
DataBaseHelper.CheckInFile(uri, Path.GetFileName(fileName), this._traceFlag);
}
return(null);
}
}
/// <summary>
/// called by the messaging engine when a new message arrives
/// </summary>
/// <param name="pc">the pipeline context</param>
/// <param name="inmsg">the actual message</param>
public void Disassemble(Microsoft.BizTalk.Component.Interop.IPipelineContext pc, Microsoft.BizTalk.Message.Interop.IBaseMessage inmsg)
{
//
// TODO: implement message retrieval logic
IBaseMessagePart Body = inmsg.BodyPart;
if (Body != null)
{
Stream originalStream = Body.GetOriginalDataStream();
if (originalStream != null)
{
var xml = XElement.Load(originalStream);
var rootElement = xml.Name;
// Child elements from source file to split by.
var childNodes = xml.Descendants(this.DescendantElement);
// This is the total number of elements to be sliced up into
// separate files.
int cnt = childNodes.Count();
var skip = 0;
var take = this.BatchSize;
var fileno = 0;
// Split elements into chunks and save to disk.
while (skip < cnt)
{
// Extract portion of the xml elements.
var c1 = childNodes
.Skip(skip)
.Take(take);
// Setup number of elements to skip on next iteration.
skip += take;
// File sequence no for split file.
fileno += 1;
// Filename for split file.
// Create a partial xml document.
XElement frag = new XElement(rootElement, c1);
// Save to disk.
var newStream = new MemoryStream();
frag.Save(newStream);
newStream.Position = 0;
pc.ResourceTracker.AddResource(newStream);
IBaseMessage newmsg = pc.GetMessageFactory().CreateMessage();
newmsg.AddPart("Body", pc.GetMessageFactory().CreateMessagePart(), true);
newmsg.BodyPart.Data = newStream;
newmsg.Context = PipelineUtil.CloneMessageContext(inmsg.Context);
//outMsg.Context.Promote("MessageType", "http://schemas.microsoft.com/BizTalk/2003/system-properties", "Namespace#Root");
var msgtype = (string.IsNullOrEmpty(rootElement.Namespace.NamespaceName)?"" : rootElement.Namespace.NamespaceName + "#") + rootElement.LocalName;
newmsg.Context.Write("MessageType", "http://schemas.microsoft.com/BizTalk/2003/system-properties", msgtype);
newmsg.Context.Promote("MessageType", "http://schemas.microsoft.com/BizTalk/2003/system-properties", msgtype);
_msgs.Enqueue(newmsg);
}
}
}
}
/// <summary>
/// Copy message parts from source to destination message.
/// </summary>
/// <param name="sourceMessage">Source message</param>
/// <param name="destinationMessage">Destination message</param>
/// <param name="newBodyPart">New message body part</param>
private void CopyMessageParts(IBaseMessage sourceMessage, IBaseMessage destinationMessage, IBaseMessagePart newBodyPart)
{
string bodyPartName = sourceMessage.BodyPartName;
for (int c = 0; c < sourceMessage.PartCount; ++c)
{
string partName = null;
IBaseMessagePart messagePart = sourceMessage.GetPartByIndex(c, out partName);
if (partName != bodyPartName)
{
destinationMessage.AddPart(partName, messagePart, false);
}
else
{
destinationMessage.AddPart(bodyPartName, newBodyPart, true);
}
}
}
/// <summary>
/// Creates a multi-part message from an array
/// of streams. The first stream in the array will be marked
/// as the message body part
/// </summary>
/// <param name="parts">One stream for each part</param>
/// <returns>The new message</returns>
public static IBaseMessage Create(params Stream[] parts)
{
if (parts == null || parts.Length < 1)
throw new ArgumentException("Need to specify at least one part", "parts");
IBaseMessage message = CreateFromStream(parts[0]);
for (int i = 1; i < parts.Length; i++)
message.AddPart("part" + i, CreatePartFromStream(parts[i]), false);
return message;
}
public static IBaseMessage CreateMessage(IBaseMessageFactory factory, string fileName)
{
IBaseMessage message = factory.CreateMessage();
message.Context = factory.CreateMessageContext();
IBaseMessagePart part = factory.CreateMessagePart();
part.Data = new FileStream(fileName, FileMode.Open, FileAccess.Read);
message.AddPart("body", part, true);
return(message);
}
/// <summary>
/// Adds a new message part to the specified request message which is intended to be used as a response part.
/// </summary>
/// <param name="msgFactory">The <see cref="Microsoft.BizTalk.Message.Interop.IBaseMessageFactory"/> factory object providing message part creation capabilities.</param>
/// <param name="requestMsg">The request message represented by the <see cref="Microsoft.BizTalk.Message.Interop.IBaseMessage"/> object.</param>
/// <returns>A new message part represented by the <see cref="Microsoft.BizTalk.Message.Interop.IBaseMessagePart"/> object.</returns>
public static IBaseMessagePart CreateResponsePart(IBaseMessageFactory msgFactory, IBaseMessage requestMsg)
{
Guard.ArgumentNotNull(msgFactory, "msgFactory");
Guard.ArgumentNotNull(requestMsg, "requestMsg");
IBaseMessagePart responsePart = msgFactory.CreateMessagePart();
requestMsg.AddPart(Resources.ResponseBodyPartName, responsePart, false);
return(responsePart);
}
public static IBaseMessage CreateMessage(IBaseMessageFactory factory, string fileName, StringCollection parts)
{
IBaseMessage message = CreateMessage(factory, fileName);
for (int i = 0; i < parts.Count; i++)
{
IBaseMessagePart part = factory.CreateMessagePart();
part.Data = new FileStream(parts[i], FileMode.Open, FileAccess.Read);
message.AddPart(string.Format(CultureInfo.CurrentCulture, "part{0}", new object[] { i }), part, false);
}
return(message);
}
/// <summary>
/// Reads the response message from the server
/// </summary>
/// <param name="msg">Response message from the server</param>
/// <returns>Flag to delete message from the server or not</returns>
public bool TransmitMessage(IBaseMessage msg)
{
// Note: We need to read the stream which will execute the
// pipeline, we then replace the stream with the one we
// have created
IBaseMessagePart bodyPart = msg.BodyPart;
Stream s = null;
if (bodyPart != null)
{
s = bodyPart.GetOriginalDataStream();
}
// Create a memory stream to copy the data into
Stream memStrm = new MemoryStream();
byte[] buff = new byte[4096];
int dataRead = 0, readOffSet = 0, writeOffSet = 0;
if (s != null)
{
s.Seek(0, SeekOrigin.Begin);
// Copy the data from the src stream
do
{
dataRead = s.Read(buff, readOffSet, 4096);
memStrm.Write(buff, writeOffSet, dataRead);
} while (dataRead > 0);
}
// Create a new message
IBaseMessage response = BizTalkMessaging._mf.CreateMessage();
// Copy over the context
response.Context = msg.Context;
// Copy over the body part, note, only support single part messages
IBaseMessagePart messageBodyPart = BizTalkMessaging._mf.CreateMessagePart();
messageBodyPart.Data = memStrm;
memStrm.Seek(0, SeekOrigin.Begin);
response.AddPart(msg.BodyPartName, messageBodyPart, true);
_msg = response;
ThreadPool.QueueUserWorkItem(DeleteTransmitMessage, msg);
// Return false.
// We'll issue a Batch.DeleteMessage() later.
return(false);
}
private static void CloneParts(IPipelineContext pc, IBaseMessage inmsg, IBaseMessage outmsg, IBaseMessagePart bodyPart)
{
for (int i = 0; i < inmsg.PartCount; i++)
{
string partName = null;
IBaseMessagePart currentPart = inmsg.GetPartByIndex(i, out partName);
if (currentPart == null) continue;
outmsg.AddPart(partName, partName == inmsg.BodyPartName ? bodyPart : currentPart, partName == inmsg.BodyPartName);
}
}
public static void CopyMessageParts(IPipelineContext pc, IBaseMessage inmsg, IBaseMessage outmsg, IBaseMessagePart bodyPart, bool allowUnrecognizeMessage)
{
string bodyPartName = inmsg.BodyPartName;
for (int i = 0; i < inmsg.PartCount; i++)
{
string partName = null;
IBaseMessagePart partByIndex = inmsg.GetPartByIndex(i, out partName);
if ((partByIndex == null) && !allowUnrecognizeMessage)
{
throw new ArgumentNullException("otherOutPart[" + i + "]");
}
if (bodyPartName != partName)
{
outmsg.AddPart(partName, partByIndex, false);
}
else
{
outmsg.AddPart(bodyPartName, bodyPart, true);
}
}
}
/// <summary>
/// Copy over all parts of the message from a source message to a destination message, choosing which part should be the body part
/// </summary>
private void CopyMessageParts(IBaseMessage sourceMessage, IBaseMessage destinationMessage, IBaseMessagePart newBodyPart)
{
//Explicitly clear the collection in case this has gone through a disassembler with multiple messages and there are leftovers from the last time
partNames.Clear();
string bodyPartName = sourceMessage.BodyPartName;
for (int partCounter = 0; partCounter < sourceMessage.PartCount; ++partCounter)
{
string partName = null;
IBaseMessagePart messagePart = sourceMessage.GetPartByIndex(partCounter, out partName);
partNames.Add(partCounter, partName);
if (partName != bodyPartName)
{
destinationMessage.AddPart(partName, messagePart, false);
}
else
{
destinationMessage.AddPart(bodyPartName, newBodyPart, true);
}
}
}
/// <summary>
/// Create a new message with the specified stream as
/// the body part.
/// </summary>
/// <param name="body">Body of the message</param>
/// <returns>A new message object</returns>
public static IBaseMessage CreateFromStream(Stream body)
{
if (body == null)
throw new ArgumentNullException("body");
IBaseMessage message = _factory.CreateMessage();
message.Context = _factory.CreateMessageContext();
IBaseMessagePart bodyPart = CreatePartFromStream(body);
message.AddPart("body", bodyPart, true);
return message;
}
public static IBaseMessage createMsg(params Stream[] parts)
{
if (parts == null || parts.Length < 1)
{
throw new ArgumentException("Need to specify at least one part", "parts");
}
IBaseMessage message = createMessageFromStream(parts[0]);
for (int i = 1; i < parts.Length; i++)
{
message.AddPart("part" + i, getMsgFromStream(parts[i]), false);
}
return(message);
}
/// <summary>
/// Create a BizTalk message given the name of a file on disk optionally renaming
/// the file while the message is being submitted into BizTalk.
/// </summary>
/// <param name="srcFilePath">The File to create the message from</param>
/// <param name="renamedFileName">Optional, if specified the file will be renamed to this value.</param>
/// <returns>The message to be submitted to BizTalk.</returns>
private IBaseMessage CreateMessage(string srcFilePath, string renamedFileName)
{
Stream fs;
bool renamed = false;
// Open the file
try
{
if (!String.IsNullOrEmpty(renamedFileName))
{
Trace.WriteLine("[DotNetFileReceiverEndpoint] Renaming file " + srcFilePath);
File.Move(srcFilePath, renamedFileName);
renamed = true;
fs = File.Open(renamedFileName, FileMode.Open, FileAccess.Read, FileShare.None);
}
else
{
fs = File.Open(srcFilePath, FileMode.Open, FileAccess.Read, FileShare.None);
}
}
catch (Exception)
{
// If we renamed the file, rename it back
if (renamed)
{
File.Move(renamedFileName, srcFilePath);
}
return(null);
}
IBaseMessagePart part = this.messageFactory.CreateMessagePart();
part.Data = fs;
IBaseMessage message = this.messageFactory.CreateMessage();
message.AddPart(MESSAGE_BODY, part, true);
SystemMessageContext context = new SystemMessageContext(message.Context);
context.InboundTransportLocation = this.properties.Uri;
context.InboundTransportType = this.transportType;
//Write/Promote any adapter specific properties on the message context
message.Context.Write(DOT_NET_FILE_PROP_REMOTEFILENAME, this.propertyNamespace, (object)srcFilePath);
return(message);
}
private static void CloneParts(IPipelineContext pc, IBaseMessage inmsg, IBaseMessage outmsg, IBaseMessagePart bodyPart)
{
for (int i = 0; i < inmsg.PartCount; i++)
{
string partName = null;
IBaseMessagePart currentPart = inmsg.GetPartByIndex(i, out partName);
if (currentPart == null)
{
continue;
}
outmsg.AddPart(partName, partName == inmsg.BodyPartName ? bodyPart : currentPart, partName == inmsg.BodyPartName);
}
}
private static void LoadPart(IBaseMessage msg, XPathNavigator node, string contextFile)
{
// don't care about the id because we can't set it anyway
string name = node.GetAttribute("Name", "");
string filename = node.GetAttribute("FileName", "");
string charset = node.GetAttribute("Charset", "");
string contentType = node.GetAttribute("ContentType", "");
bool isBody = XmlConvert.ToBoolean(node.GetAttribute("IsBodyPart", ""));
XmlResolver resolver = new XmlUrlResolver();
Uri realfile = resolver.ResolveUri(new Uri(contextFile), filename);
IBaseMessagePart part = CreatePartFromStream(File.OpenRead(realfile.LocalPath));
part.Charset = charset;
part.ContentType = contentType;
msg.AddPart(name, part, isBody);
}
private IBaseMessage CreateMessage(IBaseMessageFactory messageFactory, Stream stream, string taskName)
{
IBaseMessagePart messagePart = messageFactory.CreateMessagePart();
messagePart.Data = stream;
IBaseMessage message = messageFactory.CreateMessage();
message.AddPart("body", messagePart, true);
SystemMessageContext context = new SystemMessageContext(message.Context);
context.InboundTransportLocation = this.uri;
context.InboundTransportType = this.transportType;
message.Context.Write(TaskNameProperty.Name.Name, TaskNameProperty.Name.Namespace, this.properties.Name);
message.Context.Write(NextScheduleTimeProperty.Name.Name, NextScheduleTimeProperty.Name.Namespace, this.properties.Schedule.GetNextActivationTime());
return(message);
}
public void CanCreateMultipartMessage()
{
string body = "<body>Some message content</body>";
IBaseMessage message = MessageHelper.CreateFromString(body);
Assert.IsNotNull(message);
Assert.IsNotNull(message.BodyPart);
Assert.IsNotNull(message.BodyPart.Data);
Assert.IsTrue(message.BodyPart.Data.Length > 0);
IBaseMessagePart part1 = MessageHelper.CreatePartFromString(body);
message.AddPart("part1", part1, false);
Assert.AreEqual(2, message.PartCount);
Assert.IsNotNull(message.GetPart("part1"));
}
//Return message from stream
public static IBaseMessage createMessageFromStream(Stream body)
{
if (body == null)
{
throw new ArgumentNullException("body");
}
IBaseMessage message = msgfactory.CreateMessage();
message.Context = msgfactory.CreateMessageContext();
IBaseMessagePart bodyPart = getMsgFromStream(body);
message.AddPart("body", bodyPart, true);
return(message);
}
private static void LoadPart(IBaseMessage msg, XPathNavigator node, string contextFile)
{
// don't care about the id because we can't set it anyway
string name = node.GetAttribute("Name", "");
string filename = node.GetAttribute("FileName", "");
string charset = node.GetAttribute("Charset", "");
string contentType = node.GetAttribute("ContentType", "");
bool isBody = XmlConvert.ToBoolean(node.GetAttribute("IsBodyPart", ""));
XmlResolver resolver = new XmlUrlResolver();
Uri realfile = resolver.ResolveUri(new Uri(contextFile), filename);
IBaseMessagePart part = CreatePartFromStream(File.OpenRead(realfile.LocalPath));
part.Charset = charset;
part.ContentType = contentType;
msg.AddPart(name, part, isBody);
}