/// <summary>
/// Implements IComponent.Execute method.
/// </summary>
/// <param name="pc">Pipeline context</param>
/// <param name="inmsg">Input message</param>
/// <returns>Original input message</returns>
/// <remarks>
/// IComponent.Execute method is used to initiate
/// the processing of the message in this pipeline component.
/// </remarks>
public Microsoft.BizTalk.Message.Interop.IBaseMessage Execute(Microsoft.BizTalk.Component.Interop.IPipelineContext pc,
Microsoft.BizTalk.Message.Interop.IBaseMessage inmsg)
{
/*************************************************************************************************************************
* This component will read the MessageType from the Message Context Properties. *
* BTS.MessageType: Specifies the type of the message. The message type is defined as a concatenation of document *
* schema namespace and document root node: http://<MyNamespace>#<MyRootNode>. *
* and will promote the Operation property based on the content on the Root node "<MyRootNode>" specified on the *
* message type "http://<MyNamespace>#<MyRootNode>" of the message. *
* *
* Ex: Message Type = "http://schemas.integration.com#GetClientInfo" *
* Operation will be defined as "GetClientInfo" *
************************************************************************************************************************/
// Note:
// System properties are mostly used internally by BizTalk Messaging Engine and its components.
// In general, changing the values set by the engine for those properties is not recommended, because it may affect
// the execution logic of the engine. However, there are a large number of properties that you can change.
string msgType = Convert.ToString(inmsg.Context.Read("MessageType",
"http://schemas.microsoft.com/BizTalk/2003/system-properties"));
string operation = msgType.Substring(msgType.LastIndexOf('#') + 1);
inmsg.Context.Promote("Operation", "http://schemas.microsoft.com/BizTalk/2003/system-properties",
operation);
return(inmsg);
}
private string ProcessFTPPropertiesMacros(string Target, Microsoft.BizTalk.Message.Interop.IBaseMessage Message)
{
try
{
string UpdatedTarget = "";
string ReceivedFileName = "";
string FileName = "";
string FileExtension = "";
ReceivedFileName = Message.Context.Read("ReceivedFileName", "http://schemas.microsoft.com/BizTalk/2003/ftp-properties") as string;
int Index = 0;
//int Index2 = 0;
int FileNameLength = 0;
Index = ReceivedFileName.LastIndexOf(".");
FileExtension = ReceivedFileName.Substring(Index);
FileNameLength = ReceivedFileName.Length - FileExtension.Length;
FileName = ReceivedFileName.Substring(0, FileNameLength);
UpdatedTarget = Target.Replace("%FTPReceivedFileName%", FileName);
UpdatedTarget = UpdatedTarget.Replace("%FTPReceivedFileExtension%", FileExtension);
return(UpdatedTarget);
}
catch (Exception ex)
{
throw ex;
}
}
/// <summary>
/// called by the messaging engine when a new message arrives
/// checks if the incoming message is in a recognizable format
/// if the message is in a recognizable format, only this component
/// within this stage will be execute (FirstMatch equals true)
/// </summary>
/// <param name="pc">the pipeline context</param>
/// <param name="inmsg">the actual message</param>
public bool Probe(Microsoft.BizTalk.Component.Interop.IPipelineContext pc, Microsoft.BizTalk.Message.Interop.IBaseMessage inmsg)
{
//
// TODO: check whether you're interested in the given message
//
return(true);
}
/// <summary>
/// called by the messaging engine until returned null, after disassemble has been called
/// </summary>
/// <param name="pc">the pipeline context</param>
/// <returns>an IBaseMessage instance representing the message created</returns>
public Microsoft.BizTalk.Message.Interop.IBaseMessage GetNext(Microsoft.BizTalk.Component.Interop.IPipelineContext pc)
{
// get the next message from the Queue and return it
Microsoft.BizTalk.Message.Interop.IBaseMessage msg = null;
if ((_msgs.Count > 0))
{
msg = ((Microsoft.BizTalk.Message.Interop.IBaseMessage)(_msgs.Dequeue()));
}
return(msg);
}
/// <summary>
/// Set the message back to the original message, ensure it's body part is seekable, set the position back to 0, and apply RIP context properties
/// </summary>
private void HandleRIPException(Microsoft.BizTalk.Message.Interop.IBaseMessage inmsg, Exception e)
{
TraceManager.PipelineComponent.TraceInfo("{0} - Handling error in a recoverable interchange processing fashion", callToken);
_BREPipelineMetaInstructionCollection.InMsg = inmsg;
_BREPipelineMetaInstructionCollection.InMsg.BodyPart.Data = originalStream;
_BREPipelineMetaInstructionCollection.InMsg.BodyPart.Data.Position = 0;
_BREPipelineMetaInstructionCollection.InMsg.SetErrorInfo(e);
_BREPipelineMetaInstructionCollection.InMsg.Context.Write(BizTalkGlobalPropertySchemaEnum.MessageDestination.ToString(), ContextPropertyNamespaces._BTSPropertyNamespace,
"SuspendQueue");
}
private string ProcessMessageMacros(string Target, Microsoft.BizTalk.Message.Interop.IBaseMessage Message)
{
try
{
string UpdatedTarget = "";
UpdatedTarget = Target.Replace("%BodyPartName%", Message.BodyPartName.ToString());
UpdatedTarget = UpdatedTarget.Replace("%MessageID%", Message.MessageID.ToString());
UpdatedTarget = UpdatedTarget.Replace("%PartCount%", Message.PartCount.ToString());
return(UpdatedTarget);
}
catch (Exception ex)
{
throw ex;
}
}
private static void WriteMessage(Microsoft.BizTalk.Message.Interop.IBaseMessage inmsg, XmlDocument xmlDoc)
{
var outputStream = new VirtualStream();
using (var writer = XmlWriter.Create(outputStream, new XmlWriterSettings()
{
CloseOutput = false,
Encoding = Encoding.UTF8
}))
{
xmlDoc.WriteTo(writer);
writer.Flush();
}
outputStream.Seek(0, SeekOrigin.Begin);
inmsg.BodyPart.Charset = Encoding.UTF8.WebName;
inmsg.BodyPart.Data = outputStream;
}
/// <summary>
/// Implements IComponent.Execute method.
/// </summary>
/// <param name="pc">Pipeline context</param>
/// <param name="inmsg">Input message</param>
/// <returns>Original input message</returns>
/// <remarks>
/// IComponent.Execute method is used to initiate
/// the processing of the message in this pipeline component.
/// </remarks>
public Microsoft.BizTalk.Message.Interop.IBaseMessage Execute(Microsoft.BizTalk.Component.Interop.IPipelineContext pc,
Microsoft.BizTalk.Message.Interop.IBaseMessage inmsg)
{
XmlDocument message = new XmlDocument();
message.Load(inmsg.BodyPart.Data);
string targetNS = this._TargetNamespace.Trim();
message.DocumentElement.SetAttribute("xmlns", targetNS);
MemoryStream outStream = new MemoryStream();
message.Save(outStream);
outStream.Position = 0;
inmsg.BodyPart.Data = outStream;
return(inmsg);
}
private string ProcessDateTimeMacros(string Target, Microsoft.BizTalk.Message.Interop.IBaseMessage Message)
{
try
{
string UpdatedTarget = "";
string Time = "";
UpdatedTarget = Target.Replace("%Date%", DateTime.Now.Year.ToString() + DateTime.Now.Month.ToString() + DateTime.Now.Day.ToString());
UpdatedTarget = UpdatedTarget.Replace("%Day%", DateTime.Now.Day.ToString());
UpdatedTarget = UpdatedTarget.Replace("%Month%", DateTime.Now.Month.ToString());
Time = DateTime.Now.TimeOfDay.ToString().Replace(":", ".");
UpdatedTarget = UpdatedTarget.Replace("%Time%", Time);
UpdatedTarget = UpdatedTarget.Replace("%Year%", DateTime.Now.Year.ToString());
return(UpdatedTarget);
}
catch (Exception ex)
{
throw ex;
}
}
/// <summary>
/// Implements IComponent.Execute method.
/// </summary>
/// <param name="pc">Pipeline context</param>
/// <param name="inmsg">Input message</param>
/// <returns>Original input message</returns>
/// <remarks>
/// IComponent.Execute method is used to initiate
/// the processing of the message in this pipeline component.
/// </remarks>
public Microsoft.BizTalk.Message.Interop.IBaseMessage Execute(Microsoft.BizTalk.Component.Interop.IPipelineContext pc, Microsoft.BizTalk.Message.Interop.IBaseMessage inmsg)
{
/*************************************************************************************************************************
* This component will read the Custom SOAPHeader from the Message Context Properties. *
* The custom header name will be defined on the component configuration and we can read it from the targert *
* http://schemas.microsoft.com/BizTalk/2003/SOAPHeader *
* and will add the header in the OutboundCustomHeaders (used by the WCF-BasicHTTP Adapter) *
* Specify the custom SOAP headers for outgoing messages. When this property is used, the property must have *
* the <headers> element as the root element. All of the custom SOAP headers must be placed inside the *
* <headers> element. *
* If the custom SOAP header value is an empty string, you must assign <headers></headers> or <headers> to this*
* property. *
* *
* Ex: BusinessServiceHeader with "http://schemas.microsoft.com/BizTalk/2003/SOAPHeader" namespace *
************************************************************************************************************************/
if (!string.IsNullOrEmpty(this.SOAPHeaderName))
{
string soapHeader = Convert.ToString(inmsg.Context.Read(this.SOAPHeaderName,
"http://schemas.microsoft.com/BizTalk/2003/SOAPHeader"));
if (!string.IsNullOrEmpty(soapHeader))
{
XDocument xdoc = XDocument.Parse(soapHeader);
xdoc.Declaration = null;
Console.WriteLine(xdoc.ToString().Replace(System.Environment.NewLine, ""));
string outboundHeader = "<headers>" + xdoc.ToString().Replace(System.Environment.NewLine, "") + "</headers>";
inmsg.Context.Promote("IsDynamicSend", "http://schemas.microsoft.com/BizTalk/2003/system-properties", true);
inmsg.Context.Write("OutboundCustomHeaders", "http://schemas.microsoft.com/BizTalk/2006/01/Adapters/WCF-properties", outboundHeader);
}
}
return(inmsg);
}
/// <summary>
/// If the BizTalk message in the _BREPipelineMetaInstructionCollection and/or it's body part are null then instantiate them and copy
/// context over from the original message
/// </summary>
private void RecreateBizTalkMessageAndBodyPartIfNecessary(Microsoft.BizTalk.Component.Interop.IPipelineContext pc, Microsoft.BizTalk.Message.Interop.IBaseMessage inmsg)
{
// If the BizTalk message has been nullified then create the message again and copy over the context from the original message
if (_BREPipelineMetaInstructionCollection.InMsg == null)
{
TraceManager.PipelineComponent.TraceInfo("{0} - Instantiating the message since it was null and the pipeline component needs to assign the TypedXMLDocument to it.", callToken);
_BREPipelineMetaInstructionCollection.InMsg = pc.GetMessageFactory().CreateMessage();
_BREPipelineMetaInstructionCollection.InMsg.Context = PipelineUtil.CloneMessageContext(inmsg.Context);
}
// If the message body part is null then instantiate it again so we can assign the typed xml document stream to it
if (_BREPipelineMetaInstructionCollection.InMsg.BodyPart == null)
{
TraceManager.PipelineComponent.TraceInfo("{0} - Instantiating the message body part since it was null and the pipeline component needs to assign the TypedXMLDocument to it.", callToken);
IBaseMessagePart messageBodyPart = pc.GetMessageFactory().CreateMessagePart();
_BREPipelineMetaInstructionCollection.InMsg.AddPart("Body", messageBodyPart, true);
}
}
//Get the list of stream types that require reading before the pipeline executes from the pipeline parameters and read a character from the stream
//to ensure that the stream reading logic gets exercised (especially important if the stream in question writes to the message context such as in
//the case of the Microsoft.BizTalk.Component.XmlDasmStreamWrapper)
private void ReadStreamIfNecessary(Microsoft.BizTalk.Component.Interop.IPipelineContext pc, Microsoft.BizTalk.Message.Interop.IBaseMessage inmsg, IBaseMessagePart copiedBodyPart, string streamType)
{
if (!string.IsNullOrEmpty(streamsToReadBeforeExecution))
{
streamsToReadBeforeExecution.Replace(" ", "");
List<string> streamsToReadBeforeExecutionList = new List<string>(streamsToReadBeforeExecution.Split(new string[] { "," }, StringSplitOptions.RemoveEmptyEntries));
if (streamsToReadBeforeExecutionList.Contains(streamType))
{
TraceManager.PipelineComponent.TraceInfo("{0} - Reading stream to ensure it's read logic get's executed prior to pipeline component execution", callToken);
StreamReader reader = new StreamReader(copiedBodyPart.Data);
reader.Read();
pc.ResourceTracker.AddResource(reader);
copiedBodyPart.Data.Position = 0;
}
else
{
TraceManager.PipelineComponent.TraceInfo("{0} - No need to read stream as stream type does not match entries in StreamsToReadBeforeExecution parameter", callToken);
}
}
else
{
TraceManager.PipelineComponent.TraceInfo("{0} - No need to read stream as there are no entries in StreamsToReadBeforeExecution parameter", callToken);
}
}
/// <summary>
/// Setup the BREPipelineMetaInstructionCollection by copying over the body and context from the input message
/// </summary>
private void SetupBREPipelineMetaInstructionCollection(Microsoft.BizTalk.Component.Interop.IPipelineContext pc, Microsoft.BizTalk.Message.Interop.IBaseMessage inmsg)
{
_BREPipelineMetaInstructionCollection = new BREPipelineMetaInstructionCollection(_XMLFactsApplicationStage, instructionExecutionOrder, partNames, callToken);
_BREPipelineMetaInstructionCollection.Pc = pc;
// Create a copy of the original body part and copy over it's properties as well
IBaseMessagePart copiedBodyPart = pc.GetMessageFactory().CreateMessagePart();
string streamType = inmsg.BodyPart.Data.GetType().ToString();
TraceManager.PipelineComponent.TraceInfo("{0} - Inbound message body had a stream type of {1}", callToken, streamType);
// If the input stream is not seekable then wrap it with a ReadOnlySeekableStream so that it can have it's position set
if (!inmsg.BodyPart.GetOriginalDataStream().CanSeek)
{
TraceManager.PipelineComponent.TraceInfo("{0} - Inbound message body stream was not seekable so wrapping it with a ReadOnlySeekableStream", callToken);
ReadOnlySeekableStream seekableDataStream = new ReadOnlySeekableStream(inmsg.BodyPart.GetOriginalDataStream());
originalStream = seekableDataStream;
pc.ResourceTracker.AddResource(seekableDataStream);
}
else
{
TraceManager.PipelineComponent.TraceInfo("{0} - Inbound message body stream was seekable so no need to wrap it", callToken);
originalStream = inmsg.BodyPart.GetOriginalDataStream();
}
//Explicitly set the stream position to 0 in case the position was shifted while referencing it
originalStream.Position = 0;
pc.ResourceTracker.AddResource(originalStream);
copiedBodyPart.Data = originalStream;
ReadStreamIfNecessary(pc, inmsg, copiedBodyPart, streamType);
//Copy over part properties
copiedBodyPart.PartProperties = inmsg.BodyPart.PartProperties;
// Create a new message in the _BREPipelineMetaInstructionCollection and copy over the body and any additional parts
_BREPipelineMetaInstructionCollection.InMsg = pc.GetMessageFactory().CreateMessage();
CopyMessageParts(inmsg, _BREPipelineMetaInstructionCollection.InMsg, copiedBodyPart);
// Copy over context by reference, this is to ensure that context isn't lost if using an XML Disassembler prior to BRE component
// and not reading the stream prior to cloning context
_BREPipelineMetaInstructionCollection.InMsg.Context = inmsg.Context;
}
/// <summary>
/// Implements IComponent.Execute method.
/// </summary>
/// <param name="pc">Pipeline context</param>
/// <param name="inmsg">Input message</param>
/// <returns>Original input message</returns>
/// <remarks>
/// IComponent.Execute method is used to initiate
/// the processing of the message in this pipeline component.
/// </remarks>
public Microsoft.BizTalk.Message.Interop.IBaseMessage Execute(Microsoft.BizTalk.Component.Interop.IPipelineContext pc, Microsoft.BizTalk.Message.Interop.IBaseMessage inmsg)
{
long ticks = TraceIn();
if (_Enabled)
{
// Setup the BREPipelineMetaInstructionCollection by copying over the body and context from the input message
SetupBREPipelineMetaInstructionCollection(pc, inmsg);
// Instantiate a TypedXMLDocumentWrapper class pointing to the body part's stream, a SQLDataConnectionCollection, and a MessageUtility object, passing in the
// body part's stream, and if available the message type context property value as well
InstantiateInstructionLoaderPolicyFacts(pc);
// Set ApplicationContext to String.Empty if it has a null value since that would cause the rules engine to crash
if (applicationContext == null)
{
applicationContext = string.Empty;
}
try
{
// Execute the InstructionLoaderPolicy
if (!string.IsNullOrEmpty(instructionLoaderPolicy))
{
object[] instructionLoaderFacts = { applicationContext, _BREPipelineMetaInstructionCollection, documentWrapper, sqlConnectionCollection, utility };
ExecutePolicy(instructionLoaderPolicy, instructionLoaderFacts, instructionLoaderPolicyVersion);
}
// If the InstructionLoaderPolicy returned a handled error then throw that now
if (_BREPipelineMetaInstructionCollection.BREException != null)
{
throw _BREPipelineMetaInstructionCollection.BREException;
}
// Override the default ExecutionPolicy name and version, ApplicationContext, and XMLFactsApplicationStage if an override instruction was set by the InstructionLoaderPolicy
ApplyOverrides();
// Add out of the box MetaInstructions and custom MetaInstructions set on the pipeline component parameters
// to the collection so they can be used in any ExecutionPolicy
AddOutOfTheBoxMetaInstructions();
AddMetaInstructionsFromPipelineComponentParameters();
// Execute the ExecutionPolicy using the instantiated MetaInstructions as facts and passing in the TypedXMLDocument from within the wrapper if properly setup
// as well as any DataConnections that were setup in the InstructionLoaderPolicy
if (!string.IsNullOrEmpty(executionPolicy))
{
object[] pipelineMetaInstructionFacts = SetupExecutionPolicyFacts();
// Execute the Execution policy in question, utilizing the DebugTrackingInspector if a TrackingFolder has been specified
ExecutePolicy(executionPolicy, pipelineMetaInstructionFacts, executionPolicyVersion);
// If any of the MetaInstructions have returned exceptions then throw them now.
_BREPipelineMetaInstructionCollection.ThrowExceptions();
try
{
// If a TypedXMLDocument had been setup and xmlFactsApplicationStage is set to BeforeInstructionExecution then fetch
// the potentially updated body from the asserted fact and replace the message body stream with this
if (_XMLFactsApplicationStage == XMLFactsApplicationStageEnum.BeforeInstructionExecution && documentWrapper.DocumentCount == 1)
{
TypedXMLDocumentWrapper.ApplyTypedXMLDocument((TypedXmlDocument)pipelineMetaInstructionFacts[2], _BREPipelineMetaInstructionCollection.InMsg, pc, callToken);
}
// Execute all the instructions that have been loaded into the MetaInstructions by the ExecutionPolicy
_BREPipelineMetaInstructionCollection.Execute();
// If a TypedXMLDocument had been setup and xmlFactsApplicationStage is set to AfterInstructionExecution then fetch
// the potentially updated body from the asserted fact and replace the message body stream with this. First check to see if the
// message and/or body part are null and if so create them with context copied from the original message
if (_XMLFactsApplicationStage == XMLFactsApplicationStageEnum.AfterInstructionExecution && documentWrapper.DocumentCount == 1)
{
RecreateBizTalkMessageAndBodyPartIfNecessary(pc, inmsg);
TypedXMLDocumentWrapper.ApplyTypedXMLDocument((TypedXmlDocument)pipelineMetaInstructionFacts[2], _BREPipelineMetaInstructionCollection.InMsg, pc, callToken);
}
}
catch (Exception)
{
// Call compensation methods on all MetaInstructions before throwing the error
_BREPipelineMetaInstructionCollection.Compensate();
throw;
}
}
}
catch (Exception e)
{
TraceManager.PipelineComponent.TraceError(e, true, Guid.Parse(callToken));
// Handle any exception in a recoverable fashion if RIP has been setup, otherwise throw the exception
if (recoverableInterchangeProcessingEnabled)
{
HandleRIPException(inmsg, e);
}
else
{
_BREPipelineMetaInstructionCollection.InMsg.BodyPart.Data.Position = 0;
TraceManager.PipelineComponent.TraceEndScope(callToken, ticks);
TraceManager.PipelineComponent.TraceOut(callToken);
throw;
}
}
finally
{
//Close all SQLConnections in the collection
if (sqlConnectionCollection.SQLConnectionCount > 0)
{
sqlConnectionCollection.CloseSQLConnections();
}
}
// If RIP has been setup then apply the appropriate context properties to ensure that routing failures are handled in a recoverable fashion
if (recoverableInterchangeProcessingEnabled)
{
_BREPipelineMetaInstructionCollection.InMsg.Context.Write(BizTalkGlobalPropertySchemaEnum.SuspendMessageOnRoutingFailure.ToString(), ContextPropertyNamespaces._BTSPropertyNamespace,
true);
}
TraceManager.PipelineComponent.TraceEndScope(callToken, ticks);
TraceManager.PipelineComponent.TraceOut(callToken);
// Return the updated message
return _BREPipelineMetaInstructionCollection.InMsg;
}
TraceManager.PipelineComponent.TraceEndScope(callToken, ticks);
TraceManager.PipelineComponent.TraceInfo("{0} - BRE Pipeline Framework pipeline component was disabled so acting like a pass through pipeline component.",callToken);
TraceManager.PipelineComponent.TraceOut(callToken);
// Return the original message, treating this pipeline component as if it were a pass through pipeline component if the Enabled property is set to false
return inmsg;
}
/// <summary>
/// Implements IComponent.Execute method.
/// </summary>
/// <param name="pc">Pipeline context</param>
/// <param name="inmsg">Input message</param>
/// <returns>Original input message</returns>
/// <remarks>
/// IComponent.Execute method is used to initiate
/// the processing of the message in this pipeline component.
/// </remarks>
public Microsoft.BizTalk.Message.Interop.IBaseMessage Execute(Microsoft.BizTalk.Component.Interop.IPipelineContext pc, Microsoft.BizTalk.Message.Interop.IBaseMessage inmsg)
{
System.IO.Stream st = inmsg.BodyPart.GetOriginalDataStream();
System.IO.StreamReader reader = new System.IO.StreamReader(st);
string body = reader.ReadToEnd();
body = body.Replace(_FindString, _ReplaceWith);
System.IO.MemoryStream m = new System.IO.MemoryStream();
System.IO.StreamWriter writer = new System.IO.StreamWriter(m);
writer.AutoFlush = true;
writer.Write(body);
m.Position = 0;
inmsg.BodyPart.Data = m;
reader.Close();
return(inmsg);
}
/// <summary>
/// Implements IComponent.Execute method.
/// </summary>
/// <param name="pc">Pipeline context</param>
/// <param name="inmsg">Input message</param>
/// <returns>Original input message</returns>
/// <remarks>
/// IComponent.Execute method is used to initiate
/// the processing of the message in this pipeline component.
/// </remarks>
public Microsoft.BizTalk.Message.Interop.IBaseMessage ExecuteFive(Microsoft.BizTalk.Component.Interop.IPipelineContext pc, Microsoft.BizTalk.Message.Interop.IBaseMessage inmsg)
{
#region Handle CORS Requests
// Detect of the incoming message is an HTTP CORS request
// http://www.w3.org/TR/cors/
object httpMethod = null;
//httpMethod = inmsg.Context.Read(HTTP_METHOD_PROPNAME, WCF_PROPERTIES_NS);
//if (httpMethod != null && (httpMethod as string) == OPTIONS_METHOD)
//{
// // Remove the message body before returning
// var emptyOutputStream = new VirtualStream();
// inmsg.BodyPart.Data = emptyOutputStream;
// return inmsg;
//}
#endregion
// Make message seekable
if (!inmsg.BodyPart.Data.CanSeek)
{
var originalStream = inmsg.BodyPart.Data;
Stream seekableStream = new ReadOnlySeekableStream(originalStream);
inmsg.BodyPart.Data = seekableStream;
pc.ResourceTracker.AddResource(originalStream);
}
// Here again we are loading the entire document into memory
// this is still a bad plan, and shouldn't be done in production
// if you expect larger message sizes
XmlDocument xmlDoc = new XmlDocument();
xmlDoc.Load(inmsg.BodyPart.Data);
if (xmlDoc.FirstChild.LocalName == "xml")
{
xmlDoc.RemoveChild(xmlDoc.FirstChild);
}
// Remove any root-level attributes added in the process of creating the XML
// (Think xmlns attributes that have no meaning in JSON)
xmlDoc.DocumentElement.Attributes.RemoveAll();
string jsonString = ""; // JsonConvert.SerializeXmlNode(xmlDoc, Newtonsoft.Json.Formatting.Indented, true);
#region Handle JSONP Request
// Here we are detecting if there has been any value promoted to the jsonp callback property
// which will contain the name of the function that should be passed the JSON data returned
// by the service.
object jsonpCallback = null; // inmsg.Context.Read(JSONP_CALLBACK_PROPNAME, JSON_SCHEMAS_NS);
string jsonpCallbackName = (jsonpCallback ?? (object)string.Empty) as string;
if (!string.IsNullOrWhiteSpace(jsonpCallbackName))
{
jsonString = string.Format("{0}({1});", jsonpCallbackName, jsonString);
}
#endregion
var outputStream = new VirtualStream(new MemoryStream(Encoding.UTF8.GetBytes(jsonString)));
inmsg.BodyPart.Data = outputStream;
return(inmsg);
}
/// <summary>
/// Implements IComponent.Execute method.
/// </summary>
/// <param name="pc">Pipeline context</param>
/// <param name="inmsg">Input message</param>
/// <returns>Original input message</returns>
/// <remarks>
/// IComponent.Execute method is used to initiate
/// the processing of the message in this pipeline component.
/// </remarks>
public Microsoft.BizTalk.Message.Interop.IBaseMessage Execute(Microsoft.BizTalk.Component.Interop.IPipelineContext pc, Microsoft.BizTalk.Message.Interop.IBaseMessage inmsg)
{
//
// TODO: implement component logic
//
// this way, it's a passthrough pipeline component
IBaseMessageContext context = inmsg.Context;
Stream inStream = inmsg.BodyPart.Data;
XslTransmitHelper transmit = new XslTransmitHelper(this.XslPath, this.XPathSourceFileName, this.EnableValidateNamespace, this.AllowPassThruTransmit);
if (!string.IsNullOrEmpty(this.XPathSourceFileName))
{
string sourceFileName = transmit.GetSourceFileName(XmlReader.Create(inStream), this.XPathSourceFileName);
if (!string.IsNullOrEmpty(sourceFileName))
{
context.Write("ReceivedFileName", "http://schemas.microsoft.com/BizTalk/2003/file-properties", sourceFileName);
context.Promote("ReceivedFileName", "http://schemas.microsoft.com/BizTalk/2003/file-properties", sourceFileName);
}
inStream.Seek(0, SeekOrigin.Begin);
}
var outStream = transmit.Transmit(inStream);
inmsg.BodyPart.Data = outStream;
pc.ResourceTracker.AddResource(outStream);
return(inmsg);
}
public Microsoft.BizTalk.Message.Interop.IBaseMessage ExecuteThree(IPipelineContext pContext, Microsoft.BizTalk.Message.Interop.IBaseMessage pInMsg)
{
IBaseMessagePart bodyPart = pInMsg.BodyPart;
Stream inboundStream = bodyPart.GetOriginalDataStream();
VirtualStream virtualStream = new VirtualStream(0x280, 0x100000);
ReadOnlySeekableStream readOnlySeekableStream = new ReadOnlySeekableStream(inboundStream, virtualStream, 0x280);
XmlTextReader xmlTextReader = new XmlTextReader(readOnlySeekableStream);
//XPathCollection xPathCollection = new XPathCollection();
//xPathCollection.Add("/*[local-name()='LFT' and namespace-uri()='http://Codit.LFT.Schemas']/*[local-name()='TempFile' and namespace-uri()='']");
//XPathReader xPathReader = new XPathReader(xmlTextReader, xPathCollection);
bool ok = false;
string val = string.Empty;
//while (xPathReader.ReadUntilMatch())
//{
// if (xPathReader.Match(0) && !ok)
// {
// val = xPathReader.ReadString();
// ok = true;
// }
//}
if (ok)
{
VirtualStream outboundStream = new VirtualStream(0x280, 0xA00000);
using (FileStream fs = new FileStream(val, FileMode.Open, FileAccess.Read, FileShare.Read))
{
byte[] buffer = new byte[4096];
int bytesRead = fs.Read(buffer, 0, buffer.Length);
while (bytesRead != 0)
{
outboundStream.Write(buffer, 0, bytesRead);
outboundStream.Flush();
bytesRead = fs.Read(buffer, 0, buffer.Length);
}
}
outboundStream.Position = 0;
bodyPart.Data = outboundStream;
}
return(pInMsg);
}
/// <summary>
/// Implements IComponent.Execute method.
/// </summary>
/// <param name="pc">Pipeline context</param>
/// <param name="inmsg">Input message</param>
/// <returns>Original input message</returns>
/// <remarks>
/// IComponent.Execute method is used to initiate
/// the processing of the message in this pipeline component.
/// </remarks>
public Microsoft.BizTalk.Message.Interop.IBaseMessage Execute(Microsoft.BizTalk.Component.Interop.IPipelineContext pc, Microsoft.BizTalk.Message.Interop.IBaseMessage inmsg)
{
var stream = GetSeekeableMessageStream(inmsg);
EdifactCharacterSet targetCharSet;
var syntax = inmsg.Context.Read("UNB1_1", "http://schemas.microsoft.com/BizTalk/2006/edi-properties") as string;
if (syntax == null || Enum.TryParse <EdifactCharacterSet>(syntax, out targetCharSet) == false)
{
targetCharSet = _targetCharSet;
}
var result = new MemoryStream();
var settings = new XmlWriterSettings {
Encoding = Encoding.UTF8, OmitXmlDeclaration = true
};
var separators = _extraCharsToReplace.ToCharArray();
using (var reader = XmlReader.Create(stream))
using (var writer = XmlWriter.Create(result, settings))
{
while (reader.Read())
{
switch (reader.NodeType)
{
case XmlNodeType.Element:
writer.WriteStartElement(reader.Prefix, reader.LocalName, reader.NamespaceURI);
writer.WriteAttributes(reader, true);
if (reader.IsEmptyElement)
{
writer.WriteEndElement();
}
break;
case XmlNodeType.Text:
var value = reader.Value;
var sb = new StringBuilder();
foreach (var c in value)
{
var step1 = c.Translate(targetCharSet, _fallbackChar);
var step2 = separators.Contains(step1) ? _fallbackChar : step1;
var step3 = this.Normalize && char.IsControl(step2) ? ' ' : step2;
sb.Append(step3);
}
writer.WriteString(this.Normalize ? sb.ToString().Trim() : sb.ToString());
break;
case XmlNodeType.EndElement:
writer.WriteFullEndElement();
break;
case XmlNodeType.XmlDeclaration:
case XmlNodeType.ProcessingInstruction:
//writer.WriteProcessingInstruction(reader.Name, reader.Value);
break;
case XmlNodeType.SignificantWhitespace:
writer.WriteWhitespace(reader.Value);
break;
}
}
writer.Flush();
}
result.Seek(0, SeekOrigin.Begin);
inmsg.BodyPart.Data = result;
pc.ResourceTracker.AddResource(result);
return(inmsg);
}
/// <summary>
/// Implements IComponent.Execute method.
/// </summary>
/// <param name="pc">Pipeline context</param>
/// <param name="inmsg">Input message</param>
/// <returns>Original input message</returns>
/// <remarks>
/// IComponent.Execute method is used to initiate
/// the processing of the message in this pipeline component.
/// </remarks>
public Microsoft.BizTalk.Message.Interop.IBaseMessage Execute(Microsoft.BizTalk.Component.Interop.IPipelineContext pc, Microsoft.BizTalk.Message.Interop.IBaseMessage inmsg)
{
try
{
if (inmsg.BodyPart != null) //Verify the message is different from null
{
MemoryStream memStrm = new MemoryStream();
Stream originalStrm = inmsg.BodyPart.GetOriginalDataStream();
StreamReader sReader = new StreamReader(originalStrm, System.Text.Encoding.Default);
string original = sReader.ReadToEnd();
StreamWriter swriter = new StreamWriter(memStrm, System.Text.Encoding.Default); //Modify message
if (string.IsNullOrEmpty(original))
{
swriter.Write(AppendedValue);
swriter.Flush();
memStrm.Seek(0, System.IO.SeekOrigin.Begin);
inmsg.BodyPart.Data = memStrm;
pc.ResourceTracker.AddResource(memStrm);
}
else
{
swriter.Write(original);
swriter.Flush();
memStrm.Seek(0, System.IO.SeekOrigin.Begin);
inmsg.BodyPart.Data = memStrm;
pc.ResourceTracker.AddResource(memStrm);
}
}
}
catch (Exception ex)
{
System.Diagnostics.EventLog.WriteEntry("IKT-Agder.Felles.PipelineComponents",
"Occurred an error on validating the message: " + ex.Message + "\n" + ex.StackTrace,
System.Diagnostics.EventLogEntryType.Error);
throw (ex);
}
return(inmsg);
}
/// <summary>
/// Output new IBaseMessage output from a file.
/// </summary>
/// <param name="pContext"></param>
/// <param name="pInMsg"></param>
/// <returns></returns>
public Microsoft.BizTalk.Message.Interop.IBaseMessage Execute(IPipelineContext pContext, Microsoft.BizTalk.Message.Interop.IBaseMessage pInMsg)
{
IBaseMessagePart bodyPart = pInMsg.BodyPart;
Stream inboundStream = bodyPart.GetOriginalDataStream();
VirtualStream virtualStream = new VirtualStream(0x280, 0x100000);
ReadOnlySeekableStream readOnlySeekableStream = new ReadOnlySeekableStream(inboundStream, virtualStream, 0x280);
string tempFile = Path.GetTempFileName();
using (FileStream fs = new FileStream(tempFile, FileMode.Open, FileAccess.Write, FileShare.Read))
{
byte[] buffer = new byte[0x280];
int bytesRead = readOnlySeekableStream.Read(buffer, 0, buffer.Length);
while (bytesRead != 0)
{
fs.Write(buffer, 0, bytesRead);
fs.Flush();
bytesRead = readOnlySeekableStream.Read(buffer, 0, buffer.Length);
}
}
VirtualStream outputStream = new VirtualStream();
using (XmlWriter xw = XmlWriter.Create(outputStream))
{
const string NameSpace = "http://Codit.LFT.Schemas";
xw.WriteStartDocument();
xw.WriteStartElement("ns0", "LFT", NameSpace);
xw.WriteElementString("TempFile", tempFile);
xw.WriteEndDocument();
}
outputStream.Position = 0;
pContext.ResourceTracker.AddResource(outputStream);
pInMsg.BodyPart.Data = outputStream;
return(pInMsg);
}
/// <summary>
/// Implements IComponent.Execute method.
/// </summary>
/// <param name="pc">Pipeline context</param>
/// <param name="inmsg">Input message</param>
/// <returns>Original input message</returns>
/// <remarks>
/// IComponent.Execute method is used to initiate
/// the processing of the message in this pipeline component.
/// </remarks>
public Microsoft.BizTalk.Message.Interop.IBaseMessage Execute(Microsoft.BizTalk.Component.Interop.IPipelineContext pc, Microsoft.BizTalk.Message.Interop.IBaseMessage inmsg)
{
Stream originalStrm = null;
FileStream fileArchive = null;
BinaryWriter binWriter = null;
IBaseMessagePart bodyPart = null;
const int bufferSize = 1024;
try
{
if (Enabled)
{
//IBaseMessagePart bodyPart = inmsg.BodyPart;
bodyPart = inmsg.BodyPart;
if (bodyPart != null)
{
string FullPath = "";
//string TransportType = "";
FullPath = MakeFullPath(FilePath, FileName);
//TransportType = inmsg.Context.Read("OutboundTransportType", "http://schemas.microsoft.com/BizTalk/2003/system-properties") as string;
//if (TransportType == null)
//{
// TransportType = inmsg.Context.Read("InboundTransportType", "http://schemas.microsoft.com/BizTalk/2003/system-properties") as string;
//}
//FullPath = ProcessDateTimeMacros(FullPath, inmsg);
//FullPath = ProcessMessageMacros(FullPath, inmsg);
//FullPath = ProcessSystemPropertiesMacros(FullPath, TransportType, inmsg);
//switch (TransportType)
//{
// case "FILE":
// FullPath = ProcessFilePropertiesMacros(FullPath, inmsg);
// break;
// case "FTP":
// FullPath = ProcessFTPPropertiesMacros(FullPath, inmsg);
// break;
//}
if (!Directory.Exists(Path.GetDirectoryName(FullPath)))
{
Directory.CreateDirectory(Path.GetDirectoryName(FullPath));
}
if (!Overwrite)
{
if (File.Exists(FullPath + FileMask))
{
FullPath = FullPath + inmsg.MessageID.ToString();
}
}
FullPath = FullPath + FileMask;
originalStrm = bodyPart.GetOriginalDataStream();
if (!originalStrm.CanSeek)
{
ReadOnlySeekableStream seekableStream = new ReadOnlySeekableStream(originalStrm);
inmsg.BodyPart.Data = seekableStream;
originalStrm = inmsg.BodyPart.Data;
}
pc.ResourceTracker.AddResource(originalStrm);
fileArchive = new FileStream(FullPath, FileMode.Create, FileAccess.Write);
binWriter = new BinaryWriter(fileArchive);
byte[] buffer = new byte[bufferSize];
int sizeRead = 0;
while ((sizeRead = originalStrm.Read(buffer, 0, bufferSize)) != 0)
{
binWriter.Write(buffer, 0, sizeRead);
}
}
}
}
catch (Exception ex)
{
System.Diagnostics.EventLog.WriteEntry(ex.Source, ex.Message + "\n" + ex.StackTrace, EventLogEntryType.Warning);
}
finally
{
if (binWriter != null)
{
binWriter.Flush();
binWriter.Close();
}
if (originalStrm != null)
{
originalStrm.Seek(0, SeekOrigin.Begin);
}
}
return(inmsg);
}
public static void ArchivetoStorage(Microsoft.BizTalk.Component.Interop.IPipelineContext pc, Microsoft.BizTalk.Message.Interop.IBaseMessage inmsg, string FullFilePath, bool ReadFullContext)
{
StringBuilder SBContext = new StringBuilder();
ReadOnlySeekableStream stream = new ReadOnlySeekableStream(inmsg.BodyPart.GetOriginalDataStream());
Stream sourceStream = inmsg.BodyPart.GetOriginalDataStream();
List <JsonContextProperty> jsonContextpropertylist = new List <JsonContextProperty>();
if (!sourceStream.CanSeek)
{
ReadOnlySeekableStream seekableStream = new ReadOnlySeekableStream(sourceStream);
inmsg.BodyPart.Data = seekableStream;
sourceStream = inmsg.BodyPart.Data;
}
if (inmsg.BodyPart != null)
{
string json = "NA";
VirtualStream virtualStream = new VirtualStream(sourceStream);
//ArchiveToFileLocation(virtualStream, FullFilePath);
//virtualStream.Seek(0, SeekOrigin.Begin);
inmsg.BodyPart.Data = virtualStream;
if (ReadFullContext == true)
{
IBaseMessageContext ctx = inmsg.Context;
string name;
string nspace;
for (int loop = 0; loop < ctx.CountProperties; loop++)
{
ctx.ReadAt(loop, out name, out nspace);
string value = ctx.Read(name, nspace).ToString();
jsonContextpropertylist.Add(new JsonContextProperty()
{
Name = name,
NameSpace = nspace,
Value = value
});
}
json = JsonConvert.SerializeObject(jsonContextpropertylist);
}
string InterchangeID = inmsg.Context.Read("InterchangeID", "http://schemas.microsoft.com/BizTalk/2003/system-properties").ToString();
string ServiceName = "NA";
if (inmsg.Context.Read("ReceivePortID", "http://schemas.microsoft.com/BizTalk/2003/system-properties") != null)
{
ServiceName = inmsg.Context.Read("ReceiveLocationName", "http://schemas.microsoft.com/BizTalk/2003/system-properties").ToString();
}
else if (inmsg.Context.Read("SPID", "http://schemas.microsoft.com/BizTalk/2003/system-properties") != null)
{
ServiceName = inmsg.Context.Read("SPName", "http://schemas.microsoft.com/BizTalk/2003/system-properties").ToString();
}
string msgId = inmsg.MessageID.ToString();
SqlConnection Conn = new SqlConnection("Server=BT360DEV34\\MSSQLSERVER1;Database=B360_BAM;Integrated Security=True;");
SqlCommand command = new SqlCommand(
"INSERT INTO [dbo].[CustomTrackTbl] " +
"([ActivityID] " +
",[CorrelationID] " +
",[StartTime] " +
",[EndTime] " +
",[ServiceName] " +
",[MsgContext] " +
",[StreamMsgPayload] " +
",[RawMsgPayload] " +
",[Status] " +
",[MessageArchiveLocation])" +
"VALUES(@ActivityID,@CorrelationID,@StartTime,@EndTime,@ServiceName,@MsgContext,@StreamMsgPayload,@RawMsgPayload,@Status,@MessageArchiveLocation)", Conn);
command.Parameters.Add("@ActivityID", SqlDbType.VarChar).Value = msgId;
command.Parameters.Add("@CorrelationID", SqlDbType.VarChar).Value = InterchangeID;
command.Parameters.Add("@StartTime", SqlDbType.VarChar).Value = DateTime.Now.ToString();
command.Parameters.Add("@EndTime", SqlDbType.VarChar).Value = DateTime.Now.ToString();
command.Parameters.Add("@ServiceName", SqlDbType.VarChar).Value = ServiceName;
command.Parameters.Add("@MsgContext", SqlDbType.VarChar).Value = json;
sourceStream.Position = 0;
command.Parameters.Add("@StreamMsgPayload", SqlDbType.Binary).Value = sourceStream;
command.Parameters.Add("@RawMsgPayload", SqlDbType.VarChar).Value = "NA";
command.Parameters.Add("@Status", SqlDbType.VarChar, 255).Value = "Success";
command.Parameters.Add("@MessageArchiveLocation", SqlDbType.VarChar).Value = FullFilePath;
Conn.Open();
command.ExecuteNonQuery();
Conn.Close();
}
}
/// <summary>
/// Implements IComponent.Execute method.
/// </summary>
/// <param name="pc">Pipeline context</param>
/// <param name="inmsg">Input message</param>
/// <returns>Original input message</returns>
/// <remarks>
/// IComponent.Execute method is used to initiate
/// the processing of the message in this pipeline component.
/// </remarks>
public Microsoft.BizTalk.Message.Interop.IBaseMessage Execute(Microsoft.BizTalk.Component.Interop.IPipelineContext pc, Microsoft.BizTalk.Message.Interop.IBaseMessage inmsg)
{
if (_ArchiveFiles)
{
string archiveFileName = inmsg.Context.Read(_FileNameProperty, _FileNamePropertyNamespace) as string;
if (archiveFileName != null && !string.IsNullOrEmpty(archiveFileName))
{
if (archiveFileName.Contains("\\"))
{
archiveFileName = archiveFileName.Substring(archiveFileName.LastIndexOf("\\") + 1);
}
ArchivingStream archivingStream = new ArchivingStream(inmsg.BodyPart.Data, _ArchivePath + "\\" + archiveFileName);
pc.ResourceTracker.AddResource(archivingStream);
inmsg.BodyPart.Data = archivingStream;
}
}
return(inmsg);
}
/// <summary>
/// Implements IComponent.Execute method.
/// </summary>
/// <param name="pc">Pipeline context</param>
/// <param name="inmsg">Input message</param>
/// <returns>Original input message</returns>
/// <remarks>
/// IComponent.Execute method is used to initiate
/// the processing of the message in this pipeline component.
/// </remarks>
public Microsoft.BizTalk.Message.Interop.IBaseMessage Execute(Microsoft.BizTalk.Component.Interop.IPipelineContext pc, Microsoft.BizTalk.Message.Interop.IBaseMessage inmsg)
{
#region Copy input stream
try
{
IBaseMessagePart bodyPart = inmsg.BodyPart;
if (bodyPart != null)
{
Stream originalStream = bodyPart.GetOriginalDataStream();
// Biztalk will not do property promotion in time if we do not touch the stream. Seems to be a quirk of how the send pipeline works.
// If original message is returned no property promotion will happen before the EDI assembler component gets the message.
if (originalStream != null)
{
StreamReader sReader = new StreamReader(originalStream);
VirtualStream vStream = new VirtualStream();
StreamWriter sWriter = new StreamWriter(vStream);
//Write message body to a virutal memory stream
sWriter.Write(sReader.ReadToEnd());
sWriter.Flush();
sReader.Close();
vStream.Seek(0, SeekOrigin.Begin);
pc.ResourceTracker.AddResource(vStream);
inmsg.BodyPart.Data = vStream;
}
}
#endregion
#region Property promotion
// Set the identificators. Make sure to set " " if missing to get property promoted (will make Biztalk fail the file on missing party)
if (string.IsNullOrEmpty((string)inmsg.Context.Read(_senderId, _propertyNameSpace)))
{
inmsg.Context.Promote("DestinationPartySenderIdentifier", _edifactPropertyNamespace, " ");
}
else
{
inmsg.Context.Promote("DestinationPartySenderIdentifier", _edifactPropertyNamespace,
inmsg.Context.Read(_senderId, _propertyNameSpace));
}
if (string.IsNullOrEmpty((string)inmsg.Context.Read(_receiverId, _propertyNameSpace)))
{
inmsg.Context.Promote("DestinationPartyReceiverIdentifier", _edifactPropertyNamespace, " ");
}
else
{
inmsg.Context.Promote("DestinationPartyReceiverIdentifier", _edifactPropertyNamespace,
inmsg.Context.Read(_receiverId, _propertyNameSpace));
}
// If no qualifier is set in pipeline use " " since that will resolve as <no qualifier> in Biztalk.
if (string.IsNullOrEmpty(_senderIdQualifier))
{
inmsg.Context.Promote("DestinationPartySenderQualifier", _edifactPropertyNamespace, " ");
}
else
{
// If no value is found on property set space as value (<No qualifier>)
if (string.IsNullOrEmpty((string)inmsg.Context.Read(_senderIdQualifier, _propertyNameSpace)))
{
inmsg.Context.Promote("DestinationPartySenderQualifier", _edifactPropertyNamespace, " ");
}
else
{
inmsg.Context.Promote("DestinationPartySenderQualifier", _edifactPropertyNamespace,
inmsg.Context.Read(_senderIdQualifier, _propertyNameSpace));
}
}
// If no qualifier is set in pipeline use " " since that will resolve as <no qualifier> in Biztalk.
if (string.IsNullOrEmpty(_receiverIdQualifier))
{
inmsg.Context.Promote("DestinationPartyReceiverQualifier", _edifactPropertyNamespace, " ");
}
else
{
// If no value is found on property set space as value (<No qualifier>)
if (string.IsNullOrEmpty((string)inmsg.Context.Read(_receiverIdQualifier, _propertyNameSpace)))
{
inmsg.Context.Promote("DestinationPartyReceiverQualifier", _edifactPropertyNamespace, " ");
}
else
{
inmsg.Context.Promote("DestinationPartyReceiverQualifier", _edifactPropertyNamespace,
inmsg.Context.Read(_receiverIdQualifier, _propertyNameSpace));
}
}
return(inmsg);
#endregion
}
catch (Exception ex)
{
if (inmsg != null)
{
inmsg.SetErrorInfo(ex);
}
throw;
}
}
/// <summary>
/// Implements IComponent.Execute method.
/// </summary>
/// <param name="pc">Pipeline context</param>
/// <param name="inmsg">Input message</param>
/// <returns>Original input message</returns>
/// <remarks>
/// IComponent.Execute method is used to initiate
/// the processing of the message in this pipeline component.
/// </remarks>
public Microsoft.BizTalk.Message.Interop.IBaseMessage ExecuteFour(Microsoft.BizTalk.Component.Interop.IPipelineContext pc, Microsoft.BizTalk.Message.Interop.IBaseMessage inmsg)
{
Stream dataStream = new VirtualStream(VirtualStream.MemoryFlag.AutoOverFlowToDisk);
pc.ResourceTracker.AddResource(dataStream);
using (XmlWriter writer = XmlWriter.Create(dataStream))
{
// Start creating the message body
writer.WriteStartDocument();
//writer.WriteStartElement("ns0", ROOT_NODE_NAME, TARGET_NAMESPACE);
for (int i = 0; i < inmsg.Context.CountProperties; i++)
{
// Read in current property information
string propName = null;
string propNamespace = null;
object propValue = inmsg.Context.ReadAt(i, out propName, out propNamespace);
// Skip properties that we don't care about due to configuration (default is to allow all properties)
//if (ExcludeSystemProperties && propNamespace == SYSTEM_NAMESPACE) continue;
//if (!String.IsNullOrWhiteSpace(CustomPropertyNamespace) &&
// propNamespace != CustomPropertyNamespace) continue;
// Create Property element
//writer.WriteStartElement(PROPERTY_NODE_NAME);
//// Create attributes on Property element
//writer.WriteStartAttribute(NAMESPACE_ATTRIBUTE);
//writer.WriteString(propNamespace);
//writer.WriteEndAttribute();
//writer.WriteStartAttribute(NAME_ATTRIBUTE);
writer.WriteString(propName);
writer.WriteEndAttribute();
// Write value inside property element
writer.WriteString(Convert.ToString(propValue));
writer.WriteEndElement();
}
// Finish out the message
writer.WriteEndElement();
writer.WriteEndDocument();
writer.Flush();
}
dataStream.Seek(0, SeekOrigin.Begin);
IBaseMessage outmsg = null;// = Utility.CloneMessage(inmsg, pc);
//outmsg.BodyPart.Data = dataStream;
return(outmsg);
}
/// <summary>
/// Implements IComponent.Execute method.
/// </summary>
/// <param name="pc">Pipeline context</param>
/// <param name="inmsg">Input message</param>
/// <returns>Original input message</returns>
/// <remarks>
/// IComponent.Execute method is used to initiate
/// the processing of the message in this pipeline component.
/// </remarks>
public Microsoft.BizTalk.Message.Interop.IBaseMessage Execute(Microsoft.BizTalk.Component.Interop.IPipelineContext pipelineContext,
Microsoft.BizTalk.Message.Interop.IBaseMessage inputMsg)
{
System.Diagnostics.Debug.WriteLine("At top of Execute method for DBASE pipeline");
IBaseMessagePart bodyPart = inputMsg.BodyPart;
if (bodyPart != null)
{
try
{
// First write the ODBC file to disk so can query it.
BinaryReader binaryReader = new BinaryReader(bodyPart.Data);
string folderName = this.TempDropFolderLocation;
if (folderName.Substring(folderName.Length - 1, 1) != "\\")
{
folderName += "\\";
}
string extension = (this.TypeToProcess == odbcType.Excel) ? ".xls" : ".dbf";
string filename = System.IO.Path.GetRandomFileName();
filename = filename.Remove(8);
filename += extension;
string folderNameAndFileName = folderName + filename;
FileStream fileStream = new FileStream(folderNameAndFileName, FileMode.CreateNew);
BinaryWriter binaryWriter = new BinaryWriter(fileStream);
binaryWriter.Write(binaryReader.ReadBytes(Convert.ToInt32(binaryReader.BaseStream.Length)));
binaryWriter.Close();
binaryReader.Close();
// Create the Connection String for the ODBC File
string dataSource;
if (this.TypeToProcess == odbcType.Excel)
{
dataSource = "Data Source=" + folderNameAndFileName + ";";
}
else // dbf
{
dataSource = "Data Source=" + folderName + ";";
}
string odbcConnectionString = this.connectionString;
if (odbcConnectionString.Substring(odbcConnectionString.Length - 1, 1) != ";")
{
odbcConnectionString += ";";
}
odbcConnectionString += dataSource;
OleDbConnection oConn = new OleDbConnection();
oConn.ConnectionString = odbcConnectionString;
// Create the Select Statement for the ODBC File
OleDbDataAdapter oCmd;
// Get the filter if there is one
string whereClause = "";
if (Filter.Trim() != "")
{
whereClause = " Where " + Filter.Trim();
}
if (this.TypeToProcess == odbcType.Excel)
{
oCmd = new OleDbDataAdapter(this.SqlStatement.Trim() + whereClause, oConn);
}
else // dbf
{
oCmd = new OleDbDataAdapter(this.SqlStatement.Trim() + " From " + filename + whereClause, oConn);
}
oConn.Open();
// Perform the Select statement from above into a dataset, into a DataSet.
DataSet odbcDataSet = new DataSet();
oCmd.Fill(odbcDataSet, this.DataNodeName);
oConn.Close();
// Delete the message
if (this.DeleteTempMessages)
{
System.IO.File.Delete(folderNameAndFileName);
}
// Write the XML From this DataSet into a String Builder
System.Text.StringBuilder stringBuilder = new StringBuilder();
System.IO.StringWriter stringWriter = new System.IO.StringWriter(stringBuilder);
odbcDataSet.Tables[0].WriteXml(stringWriter);
System.Xml.XmlDocument fromDataSetXMLDom = new System.Xml.XmlDocument();
fromDataSetXMLDom.LoadXml(stringBuilder.ToString());
// Create the Final XML Document. Root Node Name and Target Namespace
// come from properties set on the pipeline
System.Xml.XmlDocument finalMsgXmlDom = new System.Xml.XmlDocument();
System.Xml.XmlElement xmlElement;
xmlElement = finalMsgXmlDom.CreateElement("ns0", this.RootNodeName, this.NameSpace);
finalMsgXmlDom.AppendChild(xmlElement);
// Add the XML to the finalMsgXmlDom from the DataSet XML,
// After this the XML Message will be complete
finalMsgXmlDom.FirstChild.InnerXml = fromDataSetXMLDom.FirstChild.InnerXml;
Stream strm = new MemoryStream();
// Save final XML Document to Stream
finalMsgXmlDom.Save(strm);
strm.Position = 0;
bodyPart.Data = strm;
pipelineContext.ResourceTracker.AddResource(strm);
}
catch (System.Exception ex)
{
throw ex;
}
}
return(inputMsg);
}
private string ProcessSystemPropertiesMacros(string Target, string TransportType, Microsoft.BizTalk.Message.Interop.IBaseMessage Message)
{
try
{
string UpdatedTarget = "";
string Variable = "";
UpdatedTarget = Target.Replace("%TransportType%", TransportType);
Variable = Message.Context.Read("InterchangeID", "http://schemas.microsoft.com/BizTalk/2003/system-properties") as string;
UpdatedTarget = UpdatedTarget.Replace("%InterchangeID%", Variable);
Variable = Message.Context.Read("InterchangeSequenceNumber", "http://schemas.microsoft.com/BizTalk/2003/system-properties") as string;
UpdatedTarget = UpdatedTarget.Replace("%InterchangeSequenceNumber%", Variable);
Variable = Message.Context.Read("ReceivePortName", "http://schemas.microsoft.com/BizTalk/2003/system-properties") as string;
UpdatedTarget = UpdatedTarget.Replace("%ReceivePortName%", Variable);
return(UpdatedTarget);
}
catch (Exception ex)
{
throw ex;
}
}
/// <summary>
/// Implements IComponent.Execute method.
/// </summary>
/// <param name="pc">Pipeline context</param>
/// <param name="inmsg">Input message</param>
/// <returns>Original input message</returns>
/// <remarks>
/// IComponent.Execute method is used to initiate
/// the processing of the message in this pipeline component.
/// </remarks>
public Microsoft.BizTalk.Message.Interop.IBaseMessage Execute(Microsoft.BizTalk.Component.Interop.IPipelineContext pc, Microsoft.BizTalk.Message.Interop.IBaseMessage inmsg)
{
Stream originalStrm = null;
FileStream fileArchive = null;
BinaryWriter binWriter = null;
const int bufferSize = 1024;
try
{
IBaseMessagePart bodyPart = inmsg.BodyPart;
if (bodyPart != null)
{
string path = filePath + "." + fileExtension;
path = path.Replace("%MessageID%", inmsg.MessageID.ToString());
originalStrm = bodyPart.GetOriginalDataStream();
fileArchive = new FileStream(path, FileMode.Create, FileAccess.Write);
binWriter = new BinaryWriter(fileArchive);
byte[] buffer = new byte[bufferSize];
int sizeRead = 0;
while ((sizeRead = originalStrm.Read(buffer, 0, bufferSize)) != 0)
{
binWriter.Write(buffer, 0, sizeRead);
}
}
}
catch (Exception ex)
{
System.Diagnostics.EventLog.WriteEntry(ex.Source, ex.Message + "\n" + ex.StackTrace, EventLogEntryType.Error);
}
finally
{
if (binWriter != null)
{
binWriter.Flush();
binWriter.Close();
}
originalStrm.Seek(0, SeekOrigin.Begin);
}
return(inmsg);
}
/// <summary>
/// Implements IComponent.Execute method.
/// </summary>
/// <param name="pc">Pipeline context</param>
/// <param name="inmsg">Input message</param>
/// <returns>Original input message</returns>
/// <remarks>
/// IComponent.Execute method is used to initiate
/// the processing of the message in this pipeline component.
/// </remarks>
// Here we go... this is where the real work is done!
public Microsoft.BizTalk.Message.Interop.IBaseMessage Execute(Microsoft.BizTalk.Component.Interop.IPipelineContext pc, Microsoft.BizTalk.Message.Interop.IBaseMessage inmsg)
{
// The 'SpreadsheetDocument.Open' method throws a System.IndexOutOfRange exception when you use the stream from inmsg directly. This is because this is a Microsoft.BizTalk.Message.Interop.StreamViewOfIStream occurence. So first I copy it to a regular MemoryStream.
Stream instream = CopyStream(inmsg.BodyPart.GetOriginalDataStream());
//try
//{
string xml = string.Empty;
XmlDocument xmldoc = new XmlDocument();
XmlElement root = xmldoc.CreateElement(RootElementName, NamespaceName);
xmldoc.AppendChild(root);
using (SpreadsheetDocument doc = SpreadsheetDocument.Open(instream, false))
{
// I'm not going into all the details of the OpenXml format. You can find it all in the SDK.
WorkbookPart wbp = doc.WorkbookPart;
SharedStringTablePart shareStringPart = doc.WorkbookPart.GetPartsOfType <SharedStringTablePart>().First();
SharedStringItem[] items = shareStringPart.SharedStringTable.Elements <SharedStringItem>().ToArray();
Sheet sheet = wbp.Workbook.Descendants <Sheet>().First();
Worksheet worksheet = ((WorksheetPart)doc.WorkbookPart.GetPartById(sheet.Id)).Worksheet;
Hashtable columnHeaders = new Hashtable();
if (_UseColumnNamesFromFirstRow)
{
// Here is the part where I look for the column headers. I loop through the rows of the sheet to find the top row (RowIndex.Value == 1) and then put all cell values into a Hashtable. (There's probably an easier way to get the first row, but I couldn't figure it out, and this works too ;-)
foreach (Row row in worksheet.Descendants <Row>())
{
if (row.RowIndex.Value == 1)
{
foreach (Cell cell in row)
{
string columnheader = GetCellValue(cell, items).Replace(' ', '_');
if (!string.IsNullOrEmpty(columnheader))
{
string col = GetCellColumn(cell);
// As explained above, I'm adding the column as a prefix.
columnHeaders.Add(col, col + "_" + columnheader);
}
}
break;
}
}
}
foreach (Row row in worksheet.Descendants <Row>())
{
if (!(_UseColumnNamesFromFirstRow && row.RowIndex.Value == 1))
{
// And here the XmlDocument is being build.
XmlElement rownode = xmldoc.CreateElement(RowElementName, NamespaceName);
root.AppendChild(rownode);
foreach (Cell cell in row)
{
string col = GetCellColumn(cell);
string nodename;
if (columnHeaders.ContainsKey(col))
{
nodename = (string)columnHeaders[col];
}
else
{
nodename = "Col" + col;
}
string cellvalue = GetCellValue(cell, items).Trim();
if (!string.IsNullOrEmpty(cellvalue))
{
XmlElement node = xmldoc.CreateElement(nodename, NamespaceName);
node.InnerText = cellvalue;
rownode.AppendChild(node);
}
}
}
}
}
// Finally write the XmlDocument contents to a stream and replace the pipeline stream with this new stream.
MemoryStream memStr = new MemoryStream();
StreamWriter strOut = new StreamWriter(memStr);
strOut.Write(xmldoc.OuterXml);
strOut.Flush();
memStr.Position = 0;
pc.ResourceTracker.AddResource(memStr);
inmsg.BodyPart.Data = memStr;
//}
//catch (Exception exc)
//{
// You can do your own error handling here...
//}
return(inmsg);
}
