WS-Transfer Service for Workflow

//*****************************************************************************
//    Description.....WCFFilters - Pipeline of the Message Filters
//                                
//    Author..........Roman Kiss, rkiss@pathcom.com
//    Copyright � 2005 ATZ Consulting Inc. - see license.rtf file      
//                        
//    Date Created:    05/05/06
//
//    Date        Modified By     Description
//-----------------------------------------------------------------------------
//    05/05/06    Roman Kiss     Initial Revision
//    07/07/06    Roman Kiss     migrating to JuneCTP 
//*****************************************************************************
//  
#region References
using System;
using System.Configuration;
using System.Collections.Specialized;
using System.Collections.ObjectModel;
using System.Collections.Generic;
using System.Runtime.Serialization;
using System.Xml;
using System.Xml.Serialization;
using System.ServiceModel;
using System.ServiceModel.Channels;
using System.ServiceModel.Description;
using System.ServiceModel.Dispatcher;
using System.ServiceModel.Configuration;
using System.Reflection;
#endregion


namespace RKiss.Filters
{
    /// <summary>
    /// Base class for filter
    /// </summary>
    public abstract class FilterBase
    {
        #region Properties
        HybridDictionary _properties;
        public HybridDictionary Properties
        {
            get { return _properties; }
        }
        #endregion

        #region Constructors
        protected FilterBase() : this(null)
        {
        }
        protected FilterBase(HybridDictionary properties)
        {
            _properties = properties;
        }
        #endregion

        public abstract bool ProcessMessage(ref Message message); 
    }
  
    /// <summary>
    /// Configuration object - Filter  
    /// </summary>
    [Serializable]
    public class Filter : HybridDictionary, IXmlSerializable
    {
        private string _name;
        public string Name
        {
            get { return _name; }
            set { _name = value; }
        }

        private Type _type;
        public Type Type
        {
            get { return _type; }
            set { _type = value; }
        }

        #region Constructors
        public Filter()
        {
        }
        public Filter(XmlReader reader)
        {
            ReadXml(reader);
        }
        #endregion

        #region IXmlSerializable Members
        public System.Xml.Schema.XmlSchema GetSchema()
        {
            return null;
        }
        public void ReadXml(XmlReader reader)
        {
            if (reader.IsStartElement("Filter"))
            {
                this.Name = reader.GetAttribute("name");
                this.Type = Type.GetType(reader.GetAttribute("type"));
                if (reader.HasAttributes)
                {
                    reader.MoveToFirstAttribute();
                    do
                    {
                        base.Add(reader.Name, reader.Value);
                    }
                    while (reader.MoveToNextAttribute());
                }
                reader.ReadElementString();
            }
            else
            {
                throw new Exception(string.Format("Failed at element {0}, expected element is {1}", reader.Name, "Filter"));
            }
        }
        public void WriteXml(XmlWriter writer)
        {
            throw new Exception("The method or operation is not implemented.");
        }
        #endregion
    }

    /// <summary>
    /// Configuration object - List of Input Filters  
    /// </summary>
    [Serializable]
    public class InputFilters : List<Filter>, IXmlSerializable
    {
        #region Constructors
        public InputFilters()
        {       
        }
        public InputFilters(XmlReader reader)
        {
            ReadXml(reader);
        }
        #endregion

        #region IXmlSerializable Members
        public System.Xml.Schema.XmlSchema GetSchema()
        {
            return null;
        }
        public void ReadXml(XmlReader reader)
        {
            if (reader.IsStartElement("InputFilters"))
            {
                while (reader.NodeType != XmlNodeType.EndElement)
                {
                    reader.ReadToDescendant("Filter");
                    base.Add(new Filter(reader));
                    reader.MoveToContent();
                }
                reader.ReadEndElement();
            }
            else
            {
                throw new Exception(string.Format("Failed at element {0}, expected element is {1}", reader.Name, "InputFilters"));
            }
        }
        public void WriteXml(XmlWriter writer)
        {
            throw new Exception("The method or operation is not implemented.");
        }
        #endregion
    }

    /// <summary>
    /// Configuration object - List of Output Filters  
    /// </summary>
    [Serializable]
    public class OutputFilters : List<Filter>, IXmlSerializable
    {
        #region Constructors
        public OutputFilters()
        {
        }
        public OutputFilters(XmlReader reader)
        {
            ReadXml(reader);
        }
        #endregion

        #region IXmlSerializable Members
        public System.Xml.Schema.XmlSchema GetSchema()
        {
            return null;
        }
        public void ReadXml(XmlReader reader)
        {
            if (reader.IsStartElement("OutputFilters"))
            {
                while (reader.NodeType != XmlNodeType.EndElement)
                {
                    reader.ReadToDescendant("Filter");
                    base.Add(new Filter(reader));
                    reader.MoveToContent();
                }
                reader.ReadEndElement();
            }
            else
            {
                throw new Exception(string.Format("Failed at element {0}, expected element is {1}", reader.Name, "OutputFilters"));
            }
        }
        public void WriteXml(XmlWriter writer)
        {
            throw new Exception("The method or operation is not implemented.");
        }
        #endregion
    }


    /// <summary>
    /// Configuration object - Pipeline  
    /// </summary>
    [Serializable]
    public class Pipeline : IXmlSerializable  
    {
        InputFilters _inputFilters;
        OutputFilters _outputFilters;

        public InputFilters InputFilters
        {
            get { return _inputFilters; }
            set { _inputFilters = value; }
        }
        public OutputFilters OutputFilters
        {
            get { return _outputFilters; }
            set { _outputFilters = value; }
        }

        #region Constructors
        public Pipeline()
        {
        }
        public Pipeline(XmlReader reader)
        {
            ReadXml(reader);
        }
        #endregion

        #region IXmlSerializable Members
        public System.Xml.Schema.XmlSchema GetSchema()
        {
            return null;
        }
        public void ReadXml(XmlReader reader)
        {
            while (reader.NodeType != XmlNodeType.EndElement)
            {
                if (reader.IsStartElement("InputFilters"))
                {
                    InputFilters filters = new InputFilters(reader);
                    string enableAttribute = reader.GetAttribute("enable");
                    if (Convert.ToBoolean(enableAttribute == null ? "true" : enableAttribute))
                        _inputFilters = filters;
                }
                else if (reader.IsStartElement("OutputFilters"))
                {
                    OutputFilters filters = new OutputFilters(reader);
                    string enableAttribute = reader.GetAttribute("enable");
                    if (Convert.ToBoolean(enableAttribute == null ? "true" : enableAttribute))
                        _outputFilters = filters;
                }
                else
                {
                    throw new Exception(string.Format("Failed at element {0}, expected elements are {1}", reader.Name, "InputFilters or OutputFilters"));  
                }
                reader.MoveToContent();
            }
            reader.ReadEndElement();            
        }
        public void WriteXml(XmlWriter writer)
        {
            throw new Exception("The method or operation is not implemented.");
        }
        #endregion
    }
}