/// <summary> /// Performs all BAM actions for a BAM steps in a specified directive. This method can /// optionally handle step processing after application of a map. /// </summary> /// <param name="directiveName">The name of the directive that defines the BAM step.</param> /// <param name="data">The BAM step data.</param> /// <param name="afterMap">Indicates if the step is after the application of a map.</param> public void OnStep(string directiveName, BamStepData data, bool afterMap) { var firstBamDirective = this.items.FirstOrDefault(directive => directive.Name == directiveName); if (firstBamDirective != null) { firstBamDirective.OnStep(data, afterMap); } }
/// <summary> /// Retrieves data for a particular step of a BAM activity for the first directive found that /// defines a step. Call this method on every step in which some data may be needed for BAM /// - e.g., at the point a service is called, or at the point of resolution. /// </summary> /// <param name="data">The BAM step data.</param> /// <param name="afterMap">Indicates if the step is after the application of a map.</param> private void OnFirstStep(BamStepData data, bool afterMap) { var firstBamDirective = this.items.FirstOrDefault(item => !string.IsNullOrWhiteSpace(item.BamStepName)) ?? this.items.FirstOrDefault(item => !string.IsNullOrWhiteSpace(item.BamAfterMapStepName)); if (firstBamDirective != null) { firstBamDirective.OnStep(data, afterMap); } }
/// <summary> /// Performs all BAM actions for configured BAM steps in either the first or all /// the directives. Optionally perform BAM actions for all step extensions. /// This method can optionally handle step processing after application of a map. /// </summary> /// <param name="data">The BAM step data.</param> /// <param name="depth"> /// Specify the depth of BAM processing; first or all steps and, optionally, /// each step extension. /// </param> /// <param name="afterMap">Indicates if the step is after the application of a map.</param> public void OnStep(BamStepData data, MultiStepControl depth, bool afterMap) { switch (depth) { case MultiStepControl.AllSteps: foreach (var bamDirective in this.items) { bamDirective.OnStep(data, afterMap); } break; case MultiStepControl.AllStepsWithExtensions: foreach (var bamDirective in this.items) { bamDirective.OnStep(data, afterMap); foreach (var extension in bamDirective.BamStepExtensions) { var eventStream = new TrackpointDirectiveEventStream(bamDirective, data); eventStream.SelectBamStepExtension(extension, afterMap); bamDirective.EventStream = eventStream; bamDirective.OnStep(data, afterMap); } } break; case MultiStepControl.FirstStepOnly: this.OnFirstStep(data, afterMap); break; case MultiStepControl.FirstStepWithExtensions: var firstBamDirective = this.items.FirstOrDefault(item => !string.IsNullOrWhiteSpace(item.BamStepName)) ?? this.items.FirstOrDefault(item => !string.IsNullOrWhiteSpace(item.BamAfterMapStepName)); if (firstBamDirective != null) { firstBamDirective.OnStep(data, afterMap); foreach (var extension in firstBamDirective.BamStepExtensions) { var eventStream = new TrackpointDirectiveEventStream(firstBamDirective, data); eventStream.SelectBamStepExtension(extension, afterMap); firstBamDirective.EventStream = eventStream; firstBamDirective.OnStep(data, afterMap); } } break; } }
/// <summary> /// Performs all BAM actions for a BAM steps in a specified directive. /// </summary> /// <param name="directiveName">The name of the directive that defines the BAM step.</param> /// <param name="data">The BAM step data.</param> public void OnStep(string directiveName, BamStepData data) { this.OnStep(directiveName, data, false); }
/// <summary> /// Performs all BAM actions for configured BAM steps in either the first or /// all the directives. Optionally perform BAM actions for all step extensions. /// </summary> /// <param name="data">The BAM step data.</param> /// <param name="depth"> /// Specify the depth of BAM processing; first or all steps and, optionally, /// each step extension. /// </param> public void OnStep(BamStepData data, MultiStepControl depth) { this.OnStep(data, depth, false); }
/// <summary> /// Performs all BAM actions for configured BAM steps in all the directives. This method /// can optionally handle step processing after application of a map. /// </summary> /// <param name="data">The BAM step data.</param> /// <param name="afterMap">Indicates if the step is after the application of a map.</param> public void OnStep(BamStepData data, bool afterMap) { this.OnStep(data, MultiStepControl.AllSteps, afterMap); }
/// <summary> /// Performs all BAM actions for configured BAM steps in all the directives. /// </summary> /// <param name="data">The BAM step data.</param> public void OnStep(BamStepData data) { this.OnStep(data, MultiStepControl.AllSteps, false); }
/// <summary> /// Transform the message by applying a map. Invoke BAM interception as required. /// </summary> /// <param name="messageIn"> /// The inbound message. /// </param> /// <param name="messageProperties">A dictionary of message properties.</param> /// <returns> /// A transformed XML document. /// </returns> private XmlDocument DoTransformWithInterception(XmlDocument messageIn, IDictionary messageProperties) { if (this.directive == null) { return(messageIn); } // [var] A value indicating whether interception is required. var doInterception = this.directive.DirectiveCategories.Contains("BamInterception"); // Perform any required pre-transformation interception. if (doInterception && !string.IsNullOrEmpty(this.directive.BamStepName)) { var stepDataBefore = new BamStepData { XmlDocument = messageIn }; foreach (var messagePropertyKey in messageProperties.Keys) { if (stepDataBefore.Properties.Contains(messagePropertyKey)) { stepDataBefore.Properties[messagePropertyKey] = messageProperties[messagePropertyKey]; } else { stepDataBefore.Properties.Add(messagePropertyKey, messageProperties[messagePropertyKey]); } } this.OnStep(stepDataBefore); } // [var] The transformed message var transformedMessage = new XmlDocument(); // If there is no XML content, then we cannot perform any transformation if (messageIn != null && messageIn.HasChildNodes) { // We will only transform and do a post-transformation BAM interception if a // transformation has been defined. if (!this.directive.DirectiveCategories.Contains("Transformation")) { return(messageIn); } transformedMessage = this.Transform(messageIn); } // Return the transformed message if no post-transformation interception is required. if (!doInterception || string.IsNullOrEmpty(this.directive.BamAfterMapStepName)) { return(transformedMessage); } // Perform post-transformation interception var stepDataAfter = new BamStepData { XmlDocument = transformedMessage.HasChildNodes ? transformedMessage : messageIn }; foreach (var messagePropertyKey in messageProperties.Keys) { if (stepDataAfter.Properties.Contains(messagePropertyKey)) { stepDataAfter.Properties[messagePropertyKey] = messageProperties[messagePropertyKey]; } else { stepDataAfter.Properties.Add(messagePropertyKey, messageProperties[messagePropertyKey]); } } this.OnStep(stepDataAfter, true); // Return the transformed message return(transformedMessage); }
/// <summary> /// Performs all BAM actions for a configured BAM step. This method can optionally /// handle step processing after application of a map. /// </summary> /// <param name="data">The BAM step data.</param> /// <param name="afterMap">Indicates if the step is after the application of a map.</param> public virtual void OnStep(BamStepData data, bool afterMap) { this.DoOnStep(data.XmlDocument, data.Properties, data.ValueList, afterMap); }
/// <summary> /// Performs all BAM actions for a configured BAM step. /// </summary> /// <param name="data">The BAM step data.</param> public virtual void OnStep(BamStepData data) { this.DoOnStep(data.XmlDocument, data.Properties, data.ValueList, false); }