public void Execute(ref Microsoft.BizTalk.Message.Interop.IBaseMessage inmsg, Microsoft.BizTalk.Component.Interop.IPipelineContext pc) { var stream = new MessageModificationTranslatorStream(inmsg.BodyPart.GetOriginalDataStream(), _messageModificationDetails, callToken); inmsg.BodyPart.Data = stream; pc.ResourceTracker.AddResource(stream); }
public Microsoft.BizTalk.Message.Interop.IBaseMessage Execute( IPipelineContext pContext, Microsoft.BizTalk.Message.Interop.IBaseMessage pInMsg) { try { if (pInMsg != null) { Stream originalStream = pInMsg.BodyPart.GetOriginalDataStream(); pInMsg.BodyPart.Data = Decode(originalStream); pContext.ResourceTracker.AddResource(pInMsg.BodyPart.Data); } } catch (Exception ex) { System.Diagnostics.Debug.WriteLine( @"Exception caught in ZipDecodeComponent::Execute: " + ex.Message); throw new ApplicationException( @"ZipDecodeComponent was unable to decompress input stream. This may occur if there is more than one file in the zip archive. See inner exception for more information.", ex); } return(pInMsg); }
public void Execute(ref Microsoft.BizTalk.Message.Interop.IBaseMessage inmsg, Microsoft.BizTalk.Component.Interop.IPipelineContext pc) { if (xmlFactsApplicationStage == XMLFactsApplicationStageEnum.Explicit) { TypedXMLDocumentWrapper.ApplyTypedXMLDocument(document, inmsg, pc, callToken); } }
/// <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(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); }
public Microsoft.BizTalk.Message.Interop.IBaseMessage Execute( IPipelineContext pContext, Microsoft.BizTalk.Message.Interop.IBaseMessage pInMsg) { pInMsg.BodyPart.Data = new XmlNamespaceRemoverStream( pInMsg.BodyPart.GetOriginalDataStream()); return pInMsg; }
public static Microsoft.BizTalk.Message.Interop.IBaseMessage Test_FF_Assembler_Pipeline <T1>(Microsoft.BizTalk.Message.Interop.IBaseMessage iBaseMsg) { Microsoft.BizTalk.Component.Interop.IBaseComponent comp = PTL.Simple.Assembler .FlatFile() .WithDocumentSpec <T1>().End(); PTL.SendPipelineWrapper pipeline = PTL.Simple.Pipelines.Send() .WithAssembler(comp) .WithSpec <T1>(); // Execute the send pipeline Microsoft.BizTalk.Message.Interop.IBaseMessage outputMessage = pipeline.Execute(iBaseMsg); return(outputMessage); }
/// <summary> /// Static method to apply a TypedXMLDocument to a BizTalk message body /// </summary> /// <param name="document"></param> /// <param name="inmsg"></param> /// <param name="pc"></param> /// <param name="callToken"></param> public static void ApplyTypedXMLDocument(TypedXmlDocument document, Microsoft.BizTalk.Message.Interop.IBaseMessage inmsg, Microsoft.BizTalk.Component.Interop.IPipelineContext pc, string callToken) { TraceManager.PipelineComponent.TraceInfo("{0} - Applying typed XML document (overwriting current message body)", callToken); XmlDocument doc = (XmlDocument)document.Document; VirtualStream ms = new VirtualStream(); doc.Save(ms); ms.Position = 0; inmsg.BodyPart.Data = ms; // Add the new message body part's stream to the Pipeline Context's resource tracker so that it will be disposed off correctly pc.ResourceTracker.AddResource(ms); }
public static PTL.MessageCollection Test_FF_Disassembler_Pipeline <T1>(Microsoft.BizTalk.Message.Interop.IBaseMessage iBaseMsg) { Microsoft.BizTalk.Component.Interop.IBaseComponent comp = PTL.Simple.Disassembler .FlatFile().WithValidation(false) .WithDocumentSpec <T1>().End(); PTL.ReceivePipelineWrapper pipeline = PTL.Simple.Pipelines.Receive() .WithDisassembler(comp) .WithSpec <T1>(); // Execute the send pipeline PTL.MessageCollection outputMessage = pipeline.Execute(iBaseMsg); return(outputMessage); }
public void Execute(ref Microsoft.BizTalk.Message.Interop.IBaseMessage inmsg, Microsoft.BizTalk.Component.Interop.IPipelineContext pc) { StringBuilder outboundHeadersBuilder = new StringBuilder(); foreach (KeyValuePair <string, string> kp in outboundHTTPHeadersCollection) { outboundHeadersBuilder.AppendFormat("{0}: {1}", kp.Key, kp.Value); outboundHeadersBuilder.Append(Environment.NewLine); } string outboundHeaders = outboundHeadersBuilder.ToString(); TraceManager.PipelineComponent.TraceInfo(callToken + " - Adding outbound HTTP headers to the message with the below value " + Environment.NewLine + outboundHeaders); inmsg.Context.Write(BizTalkWCFPropertySchemaEnum.HttpHeaders.ToString(), ContextPropertyNamespaces._WCFPropertyNamespace, outboundHeaders); inmsg.Context.Write(BizTalkGlobalPropertySchemaEnum.IsDynamicSend.ToString(), ContextPropertyNamespaces._BTSPropertyNamespace, true); }
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> /// Determine whether the message being probed exists in our assembly /// </summary> /// <param name="messageType"></param> /// <returns></returns> //private bool CanHandleMessage(string messageType, string docSpecName) //{ // bool canHandle = false; // //query the biztalk management database to see if the messageType is defined in our Assembly (actually our docSpecName) // SqlDbHelper. //} /// <summary> /// Read the incoming message to determine the messageType /// </summary> /// <param name="inMsg">The Biztalk Message to read</param> /// <returns>The messageType (namespace+rootnodename)</returns> private string GetMessageType(Microsoft.BizTalk.Message.Interop.IBaseMessage inMsg, out string rootNodeName) { string messageType = string.Empty; //string messageType = (string)inMsg.Context.Read("MessageType", MessageContext.SystemPropertiesNamespace); //if (messageType != null) //{ // return messageType; //} //read the message body to determine rootnode and namespace //Wrap the originalStream in a seekable stream so that position can be rewound to 0 before returning var originalStream = inMsg.BodyPart.GetOriginalDataStream(); Stream seekableStream; if (!originalStream.CanSeek) { seekableStream = new ReadOnlySeekableStream(originalStream); inMsg.BodyPart.Data = seekableStream; } else { seekableStream = originalStream; } //Stream that will be set to the xml extracted from the incoming message using (var copiedStream = new MemoryStream()) { seekableStream.CopyTo(copiedStream); copiedStream.Position = 0; seekableStream.Position = 0; XDocument xDoc = XDocument.Load(copiedStream); messageType = string.Format("{0}#{1}", xDoc.Root.Name.NamespaceName, xDoc.Root.Name.LocalName); rootNodeName = xDoc.Root.Name.LocalName; } //_logger.DebugFormat("XmlSchemaResolver:: GetMessageType: Processing Message, determined message type {0}", messageType); return(messageType); }
Execute(IPipelineContext pContext, Microsoft.BizTalk.Message.Interop.IBaseMessage pInMsg) { try { if (pInMsg != null) { Stream originalStream = pInMsg.BodyPart. GetOriginalDataStream(); pInMsg.BodyPart.Data = Decode(originalStream); pContext.ResourceTracker.AddResource(pInMsg.BodyPart.Data); } } catch (Exception ex) { System.Diagnostics.Debug.WriteLine( @"Exception caught in GnuPGDecodeComponent::Execute: " + ex.Message); } 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) { #region Handle CORS Requests // Detect of the incoming message is an HTTP CORS request // http://www.w3.org/TR/cors/ // If it is, we will promote both the RouteDirectToTP property and the // EpmRRCorrelationToken so that the request is immediately routed // back to the send pipeline of this receive port object httpMethod = null; httpMethod = inmsg.Context.Read(HTTP_METHOD_PROPNAME, WCF_PROPERTIES_NS); if (httpMethod != null && (httpMethod as string) == OPTIONS_METHOD) { object curCorrToken = inmsg.Context.Read(EPM_RR_CORRELATION_TOKEN_PROPNAME, SYSTEM_PROPERTIES_NS); inmsg.Context.Promote(EPM_RR_CORRELATION_TOKEN_PROPNAME, SYSTEM_PROPERTIES_NS, curCorrToken); inmsg.Context.Promote(ROUTE_DIRECT_TO_TP_PROPNAME, SYSTEM_PROPERTIES_NS, true); var corsDoc = new XmlDocument(); corsDoc.AppendChild(corsDoc.CreateElement(DEFAULT_PREFIX, CORS_MSG_ROOT, JSON_SCHEMAS_NS)); writeMessage(inmsg, corsDoc); return(inmsg); } #endregion #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 = inmsg.Context.Read(JSONP_CALLBACK_PROPNAME, JSON_SCHEMAS_NS); string jsonpCallbackName = (jsonpCallback ?? (object)string.Empty) as string; if (!string.IsNullOrWhiteSpace(jsonpCallbackName)) { var jsonpDoc = new XmlDocument(); jsonpDoc.AppendChild(jsonpDoc.CreateElement(DEFAULT_PREFIX, JSONP_MSG_ROOT, JSON_SCHEMAS_NS)); writeMessage(inmsg, jsonpDoc); return(inmsg); } #endregion // Determine the current operation. We will use this as the root node // of the document if there isn't one specified as a property on the // component object operation = null; operation = inmsg.Context.Read(OPERATION_NAME_PROPNAME, SYSTEM_PROPERTIES_NS); string operationName = (operation ?? (object)string.Empty) as string; // 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); } // We are going to do something terrible and bring the entire message in memory. // Then we are going to create a string out of it, because that's how the library // wants it. // Please don't use this code for production purposes with large messages. // You have been warned. MemoryStream jsonStream = new MemoryStream(); inmsg.BodyPart.Data.CopyTo(jsonStream); inmsg.BodyPart.Data.Seek(0, SeekOrigin.Begin); // I am not going to assume any specific encoding. The BodyPart tells us // which encoding to use, so we will use that to get the string -- except // when it doesn't, then I will be a horrible person and assume an encoding. var jsonString = jsonStream.Length == 0 ? string.Empty : Encoding.GetEncoding(inmsg.BodyPart.Charset ?? Encoding.UTF8.WebName).GetString(jsonStream.ToArray()); var rawDoc = JsonConvert.DeserializeXmlNode(jsonString, string.IsNullOrWhiteSpace(this.RootNode) ? operationName : this.RootNode, true); // Here we are ensuring that the custom namespace shows up on the root node // so that we have a nice clean message type on the request messages var xmlDoc = new XmlDocument(); xmlDoc.AppendChild(xmlDoc.CreateElement(DEFAULT_PREFIX, rawDoc.DocumentElement.LocalName, this.Namespace)); xmlDoc.DocumentElement.InnerXml = rawDoc.DocumentElement.InnerXml; // All of the heavy lifting has been done, now we just have to shuffle this // new data over to the output message writeMessage(inmsg, xmlDoc); return(inmsg); }
/// <summary> /// Examine the incoming message and determine which document spec name (specifically which strong name) to assign. /// </summary> /// <param name="pContext"></param> /// <param name="pInMsg"></param> /// <returns></returns> public bool Probe(IPipelineContext pContext, Microsoft.BizTalk.Message.Interop.IBaseMessage pInMsg) { bool handled = false; //the messagetype is not unique, which is why the biztalk resolver fails. However, the docSpecName IS unique as it contains //the FQN, eg the docspecName for the SAM unLockBAResponse is ES.FS.WG.SAM.Schemas.SAMSchemas.SAMServiceSchemas.SamServiceService_servlet_x2esam_x2eedscs_x2eeds_x2ecom+unLockBAResponse //Whereas the docSpecName for the STAX unLockBAResponse is ES.FS.WG.STAX.Schemas.SAMSchemas.SamServiceService_servlet_x2esam_x2eedscs_x2eeds_x2ecom+unLockBAResponse. string rootNodeName = string.Empty; string messageType = GetMessageType(pInMsg, out rootNodeName); //Is this a messageType we know how to handle //ie does the messageType exist in the schema assembly we are resolving to. //NOTE: If the schema contains only a single root node, the docSpecName does NOT include the rootNodeName string docSpecName = string.Empty; if (_multiElementSchema) { docSpecName = string.Format("{0}.{1}+{2}", DocSpecQN, DocSpecClassName, rootNodeName); } else { docSpecName = string.Format("{0}.{1}", DocSpecQN, DocSpecClassName); } string docSpecStrongName = string.Format("{0}, {1}", docSpecName, AssemblyStrongName); IDocumentSpec docSpec = null; try { //determine if this is a valid doc spec name by loading the doc spec (effectively queries the BT mgt database for us) //look up from Biztalk to ensure strongname is valid, if lookup fails an exception is thrown docSpec = pContext.GetDocumentSpecByName(docSpecStrongName); //first check the cache, if not in cache retrieve from Biztalk and place in cache //if it is in the cache, it is inherently a valid docSpecStrongName as it must have already been looked up from Biztalk //so no need to do anything further, just assign the strong name to the message //if (!StrongNameCache.ContainsKey(rootNodeName)) //{ // //look up from Biztalk to ensure strongname is valid, if lookup fails an exception is thrown // docSpec = pContext.GetDocumentSpecByName(docSpecStrongName); // //if capacity reached, remove the first entry added to the cache. // if (StrongNameCache.Count == CacheCapacity) // { // string keyToRemove = StrongNameCache.ElementAt(0).Key; // StrongNameCache.Remove(keyToRemove); // } // StrongNameCache[rootNodeName] = docSpec.DocSpecStrongName; //} //make sure the incoming message matches the docSpec we found handled = (docSpec.DocType == messageType); } catch (Exception) { //consume the exception and return false (not handled by this component) //_logger.DebugFormat("XmlSchemaResolver:: Probe: Message not being handled {0}, DocSpecName {1}", messageType, docSpecStrongName); } if (handled) { pInMsg.Context.Write("DocumentSpecName", "http://schemas.microsoft.com/BizTalk/2003/xmlnorm-properties", docSpecStrongName); } else { handled = _xmlDissambler.Probe(pContext, pInMsg); } return(handled); }
public void Disassemble(IPipelineContext pContext, Microsoft.BizTalk.Message.Interop.IBaseMessage pInMsg) { _xmlDissambler.Disassemble(pContext, pInMsg); }
public void Execute(ref Microsoft.BizTalk.Message.Interop.IBaseMessage inmsg, Microsoft.BizTalk.Component.Interop.IPipelineContext pc) { inmsg = PipelineExecutionHelper.Execute(component, inmsg, pc); }
/// <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 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); var outmsg = 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 pc, Microsoft.BizTalk.Message.Interop.IBaseMessage inmsg) { var readyWarehouseId = RushOrderHelper.WarehouseFinder.GetNextReadyWarehouse(); inmsg.Context.Promote(WAREHOUSE_ID_PROPERTY_NAME, WAREHOUSE_ID_PROPERTY_NAMESPACE, readyWarehouseId); 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 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 = 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> /// Saves out a message to a file, using tracked filename and timestamp where possible. /// </summary> /// <param name="messageIdentifier">Message guid</param> public void ExtractMessage(string messageIdentifier) { bool retry = false; messageIdentifier = messageIdentifier.Trim(); Guid messageId = new Guid(messageIdentifier); Console.Write("Processing {0}. ", messageIdentifier); do { try { retry = false; Microsoft.BizTalk.Message.Interop.IBaseMessage msg = _btsOps.GetTrackedMessage(messageId, _trackingDatabase); // Build an output filename string saveFileName = msg.MessageID.ToString(); string saveFileExtension = ".txt"; string receivedFileName = (string)msg.Context.Read(_settings.FilenameProperty, _settings.FilenameSchema); // If we've obtained a filename from the context if (receivedFileName != null) { saveFileName = Path.GetFileNameWithoutExtension(receivedFileName); saveFileExtension = Path.GetExtension(receivedFileName); } // Loop each message part for (int i = 0; i < msg.PartCount; i++) { string partName; Microsoft.BizTalk.Message.Interop.IBaseMessagePart part = msg.GetPartByIndex(i, out partName); if (part != null && part.Data != null) { // Attempt to construct a file name based on part data string fileName = String.Empty; string partFileName = part.PartProperties.Read("FileName", "http://schemas.microsoft.com/BizTalk/2003/mime-properties") as String; string partFileExtension = saveFileExtension; // Use the partName if there is no mime name if (partFileName == null) { partFileName = partName; } else // Use the extension from the filename for this part { partFileExtension = Path.GetExtension(partFileName); partFileName = Path.GetFileNameWithoutExtension(partFileName); } // Handle duplicate files names with an incrementing counter int fileNameDuplicate = -1; do { fileName = CleanFilename(String.Format("{0}_{1}{3}{2}", saveFileName, partFileName, partFileExtension, fileNameDuplicate++ >= 0 ? fileNameDuplicate.ToString() : String.Empty)); } while (File.Exists(fileName)); Console.WriteLine("Saving message to {0}", fileName); using (FileStream fs = new FileStream(fileName, FileMode.CreateNew)) { byte[] buffer = new byte[1024]; int length = 0; while ((length = part.Data.Read(buffer, 0, buffer.Length)) > 0) { fs.Write(buffer, 0, length); } fs.Flush(); } DateTime createdTime = DateTime.Now; // Try to get the file created time object prop = msg.Context.Read("FileCreationTime", "http://schemas.microsoft.com/BizTalk/2003/file-properties"); if (prop == null) { // If there was no file created time (e.g. it was a SOAP message), get the adapter finished time prop = msg.Context.Read("AdapterReceiveCompleteTime", "http://schemas.microsoft.com/BizTalk/2003/messagetracking-properties"); } if (prop != null) { createdTime = (DateTime)prop; } File.SetLastWriteTime(fileName, createdTime); } } } catch (Exception ex) { WriteError(ex); do { string prompt = PromptFor <string>("Would you like to retry this message? [Y/N]"); switch (prompt.ToUpper().Trim()) { case "N": return; case "Y": retry = true; break; default: WriteColourfulLine(CON_COLOUR_WARN, "Invalid answer, Y or N please."); break; } } while (!retry); // impossible for a false retry as we'll return on a N } } while (retry); }
public void Execute(ref Microsoft.BizTalk.Message.Interop.IBaseMessage inmsg, Microsoft.BizTalk.Component.Interop.IPipelineContext pc) { dynamic transformMetaData; SchemaMetadata sourceSchemaMetadata; string schemaName; SchemaMetadata targetSchemaMetadata; try { transformMetaData = TransformMetaData.For(mapType); sourceSchemaMetadata = transformMetaData.SourceSchemas[0]; schemaName = sourceSchemaMetadata.SchemaName; targetSchemaMetadata = transformMetaData.TargetSchemas[0]; } catch (Exception e) { throw new Exception(String.Format("Exception encountered while trying to instantiate map {0}, exception details - {1}", mapName, e.Message)); } if (validateSourceSchema == TransformationSourceSchemaValidation.ValidateSourceSchema || validateSourceSchema == TransformationSourceSchemaValidation.ValidateSourceSchemaIfKnown) { object property = inmsg.Context.Read(BizTalkGlobalPropertySchemaEnum.MessageType.ToString(), ContextPropertyNamespaces._BTSPropertyNamespace); if (property == null) { if (validateSourceSchema == TransformationSourceSchemaValidation.ValidateSourceSchema) { throw new Exception("Unable to read source messageType while performing transformation against map " + mapName); } } else { string messageType = property.ToString(); if (!string.IsNullOrEmpty(messageType)) { if (string.Compare(messageType, schemaName, false, CultureInfo.CurrentCulture) != 0) { throw new Exception(String.Format("Transformation mismatch exception for map {0}, was expecting source schema to be {1} but was actually {2}.", mapName, schemaName, messageType)); } } } } try { dynamic transform = transformMetaData.Transform2; Stream output = new VirtualStream(); TraceManager.PipelineComponent.TraceInfo("{0} - Applying transformation {1} to the message", callToken, mapName); TraceManager.PipelineComponent.TraceInfo("{0} - Message is being transformed from message type {1} to message type {2}", callToken, schemaName, targetSchemaMetadata.SchemaName); //TODO figure out what is suppose to go in this null object instead of null. transform.Transform(inmsg.BodyPart.GetOriginalDataStream(), null, output); output.Position = 0; pc.ResourceTracker.AddResource(output); inmsg.BodyPart.Data = output; inmsg.Context.Write(BizTalkGlobalPropertySchemaEnum.SchemaStrongName.ToString(), ContextPropertyNamespaces._BTSPropertyNamespace, null); inmsg.Context.Promote(BizTalkGlobalPropertySchemaEnum.MessageType.ToString(), ContextPropertyNamespaces._BTSPropertyNamespace, targetSchemaMetadata.SchemaName); } catch (Exception e) { throw new Exception("Exception encountered while trying to execute map - " + e.Message); } }
/// <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) { string ActivityID = Guid.NewGuid().ToString(); string ShareLocation = "D:\\Share\\TrackingArchive\\"; // Should be an UNC Path with desired access granted to the User Account string FileExtension = ".txt"; string FullFilePath = ShareLocation + ActivityID + FileExtension; StringBuilder SBContext = new StringBuilder(); ReadOnlySeekableStream stream = new ReadOnlySeekableStream(inmsg.BodyPart.GetOriginalDataStream()); Stream sourceStream = inmsg.BodyPart.GetOriginalDataStream(); if (!sourceStream.CanSeek) { ReadOnlySeekableStream seekableStream = new ReadOnlySeekableStream(sourceStream); inmsg.BodyPart.Data = seekableStream; sourceStream = inmsg.BodyPart.Data; } if (inmsg.BodyPart != null) { VirtualStream virtualStream = new VirtualStream(sourceStream); PipelineHelper.ArchiveToFileLocation(virtualStream, FullFilePath); PipelineHelper.ArchivetoStorage(pc, inmsg, FullFilePath, true); sourceStream.Position = 0; inmsg.BodyPart.Data = sourceStream; inmsg.BodyPart.Data.Position = 0; } return(inmsg); #endregion }