using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Ease.CoreV35;
using Payroll.BO;
using Ease.CoreV35.Model;
using Ease.CoreV35.DataAccess;
using Ease.CoreV35.Caching;
using System.Data;

namespace Payroll.Service
{
    public class WFSetupService : ServiceTemplate, IWFSetupService
    {
        #region Cache Store
        Cache _cache = new Cache(typeof(WFSetup));
        Cache _cache_WFSetupRule = new Cache(typeof(WFSetupRule));
        Cache _cache_WFDetailDesignation = new Cache(typeof(WFRuleDetailDesignation));
        Cache _cache_WFRuleDetailOS = new Cache(typeof(WFRuleDetailOS));
        Cache _cache_WFRuleNode = new Cache(typeof(WFRuleDetailNode));
        #endregion

        #region Constructor
        public WFSetupService()
        { }
        #endregion

        #region WFSetup

        #region WFSetup Mapping
        private void MapObject(WFSetup wfSetup, DataReader oReader)
        {
            base.SetObjectID(wfSetup, oReader.GetID("WFSETUPID"));
            wfSetup.WFTypeId = oReader.GetID("WFTYPEID");
            wfSetup.CreatedBy = oReader.GetID("CREATEDBY");
            wfSetup.CreatedDate = oReader.GetDateTime("CREATEDDATE").Value;
            wfSetup.ModifiedBy = oReader.GetID("MODIFIEDBY");
            wfSetup.ModifiedDate = oReader.GetDateTime("MODIFIEDDATE");
            wfSetup.Sequence = oReader.GetInt32("SEQUENCENO").Value;
            this.SetObjectState(wfSetup, Ease.CoreV35.ObjectState.Saved);
        }
        protected override T CreateObject<T>(DataReader oReader)
        {
            WFSetup wfSetup = new WFSetup();
            MapObject(wfSetup, oReader);
            return wfSetup as T;
        }
        protected WFSetup CreateObject(DataReader oReader)
        {
            WFSetup wfSetup = new WFSetup();
            MapObject(wfSetup, oReader);
            return wfSetup;
        }

        #endregion

        #region Service Implementation

        #region Save

        public ID Save(WFSetup wfSetup)
        {
            TransactionContext tc = null;

            try
            {
                ObjectsTemplate<WFSetupRule> oSetupRules = null;
                if (wfSetup.IsNew == false) oSetupRules = this.Get4WFSetupRule(wfSetup.ID);
                tc = TransactionContext.Begin(true);

                int id = 0;
                if (wfSetup.IsNew)
                {
                    id = tc.GenerateID("WFSETUP", "WFSETUPID");
                    base.SetObjectID(wfSetup, ID.FromInteger(id));
                    WFSetupDA.Insert(tc, wfSetup);
                }
                else
                {
                    WFSetupDA.Update(tc, wfSetup);
                    
                    WFSetupDA.DeleteWFRuleDetailDesignation(tc, wfSetup.ID);
                    WFSetupDA.DeleteWFRuleDetailOS(tc, wfSetup.ID);
                    WFSetupDA.DeleteWFRuleDetailNode(tc, wfSetup.ID);
                    WFSetupDA.DeleteWFRuleDetailManual(tc, wfSetup.ID);

                    if (oSetupRules != null && oSetupRules.Count > 0)
                    {
                        foreach (WFSetupRule oRule in oSetupRules)
                        {
                            WFSetupRule odeletedRule = wfSetup.WFSetupRules.GetItem(oRule.ID);
                            if (odeletedRule == null) WFSetupDA.DeleteWFSetupRulebyRuleID(tc, oRule.ID);
                        }
                    }
                }

                foreach (WFSetupRule wfSetupRule in wfSetup.WFSetupRules)
                {
                    if (wfSetupRule.IsNew)
                    {
                        id = tc.GenerateID("WFSETUPRULE", "WFSETUPRULEID");
                        wfSetupRule.WFSetupId = wfSetup.ID;
                        base.SetObjectID(wfSetupRule, ID.FromInteger(id));
                        WFSetupDA.InsertWFSetupRule(tc, wfSetupRule);
                    }
                    else
                    {
                        WFSetupDA.UpdateWFSetupRule(tc, wfSetupRule);
                    }

                    if (wfSetupRule.WFRuleType == EnumWFRuleType.Designation)
                    {
                        foreach (WFRuleDetailDesignation wfDetailDesig in wfSetupRule.WFRuleDeatilDesignations)
                        {
                            id = tc.GenerateID("WFRDDESIGNATION", "WFRULEDETAILID");
                            wfDetailDesig.WfSetupId = wfSetup.ID;
                            wfDetailDesig.WfSetupRuleId = wfSetupRule.ID;
                            base.SetObjectID(wfDetailDesig, ID.FromInteger(id));
                            WFSetupDA.InsertWFRuleDetailDesignation(tc, wfDetailDesig);
                        }
                    }
                    if (wfSetupRule.WFRuleType == EnumWFRuleType.OrganizationStructure)
                    {
                        foreach (WFRuleDetailOS wfRuleDOS in wfSetupRule.WFRuleDeatilOSs)
                        {
                            id = tc.GenerateID("WFRDETAILOS", "WFRULEDETAILID");
                            wfRuleDOS.WfSetupId = wfSetup.ID;
                            wfRuleDOS.WfSetupRuleId = wfSetupRule.ID;
                            base.SetObjectID(wfRuleDOS, ID.FromInteger(id));
                            WFSetupDA.InsertRuleDetailOS(tc, wfRuleDOS);
                        }
                    }
                    if (wfSetupRule.WFRuleType == EnumWFRuleType.FixedOGNode)
                    {
                        foreach (WFRuleDetailNode wfRuleNode in wfSetupRule.WFRuleDetailNodes)
                        {
                            id = tc.GenerateID("WFRULEDNODE", "WFRULEDNODEID");
                            wfRuleNode.WfSetupId = wfSetup.ID;
                            wfRuleNode.WfSetupRuleId = wfSetupRule.ID;
                            base.SetObjectID(wfRuleNode, ID.FromInteger(id));
                            WFSetupDA.InsertRuleDetailNode(tc, wfRuleNode);
                        }
                    }

                    if (wfSetupRule.WFRuleType == EnumWFRuleType.Manual)
                    {
                        foreach (WFRuleDetailManual wfRulemn in wfSetupRule.WFRuleDetailManual)
                        {
                            id = tc.GenerateID("WFRuleManual", "WFRULEDETAILID");
                            wfRulemn.WfSetupId = wfSetup.ID;
                            wfRulemn.WfSetupRuleId = wfSetupRule.ID;
                            base.SetObjectID(wfRulemn, ID.FromInteger(id));
                            WFSetupDA.InsertRuleManual(tc, wfRulemn);
                        }
                    }
                }
                tc.End();

                return wfSetup.ID;
            }
            catch (Exception e)
            {
                #region Handle Exception
                if (tc != null)
                    tc.HandleError();
                ExceptionLog.Write(e);
                throw new ServiceException(e.Message, e);
                #endregion
            }

        }

        #endregion

        #region Delete

        public void Delete(ID id)
        {
            TransactionContext tc = null;
            try
            {
                tc = TransactionContext.Begin(true);
                WFSetupDA.Delete(tc, id);
                tc.End();
            }
            catch (Exception e)
            {
                #region Handle Exception
                if (tc != null)
                    tc.HandleError();
                ExceptionLog.Write(e);
                throw new ServiceException(e.Message, e);
                #endregion
            }
        }

        #endregion

        #region Get

        public WFSetup Get(ID id)
        {
            WFSetup oWFSetup = new WFSetup();
            #region Cache Header
            oWFSetup = _cache["Get", id] as WFSetup;
            if (oWFSetup != null)
                return oWFSetup;
            #endregion
            TransactionContext tc = null;
            try
            {
                tc = TransactionContext.Begin();
                DataReader oreader = new DataReader(WFSetupDA.Get(tc, id));
                if (oreader.Read())
                {
                    oWFSetup = this.CreateObject<WFSetup>(oreader);
                }
                oreader.Close();
                if (oWFSetup != null && oWFSetup.IsNew == false)
                {
                    DataReader dr = new DataReader(WFSetupDA.Get4WFSetupRule(tc, id));
                    oWFSetup.WFSetupRules = this.CreateWFSetupRuleObject(dr);
                    dr.Close();

                    foreach (WFSetupRule oRule in oWFSetup.WFSetupRules)
                    {
                        DataReader drd = new DataReader(WFSetupDA.Get4WFRuleDD(tc, oRule.ID.Integer));
                        oRule.WFRuleDeatilDesignations = this.CreateWFRuleDDObject(drd);
                        drd.Close();

                        DataReader drdnode = new DataReader(WFSetupDA.Get4WFRuleNode(tc, oRule.ID.Integer));
                        oRule.WFRuleDetailNodes = this.CreateWFRuleNodeObject(drdnode);
                        drdnode.Close();

                        DataReader drdnos = new DataReader(WFSetupDA.Get4WFRuleDetailOS(tc, oRule.WFSetupId.Integer, oRule.ID.Integer));
                        oRule.WFRuleDeatilOSs = this.CreateWFRuleDetailOSObject(drdnos);
                        drdnos.Close();

                        DataReader drmanual = new DataReader(WFSetupDA.Get4WFRuleDetailManual(tc, oRule.WFSetupId.Integer, oRule.ID.Integer));
                        oRule.WFRuleDetailManual = this.CreateWFRuleDetailManualObject(drmanual);
                        drmanual.Close();
                    }

                }
                tc.End();
            }
            catch (Exception e)
            {
                #region Handle Exception
                if (tc != null)
                    tc.HandleError();
                ExceptionLog.Write(e);
                throw new ServiceException(e.Message, e);
                #endregion
            }
            #region Cache Footer
            _cache.Add(oWFSetup, "Get", id);
            #endregion
            return oWFSetup;
        }

        public WFSetup GetByWFTypeID(ID nType)
        {
            WFSetup oWFSetup = new WFSetup();
            #region Cache Header
            oWFSetup = (WFSetup)_cache["GetByWFTypeID", nType];
            if (oWFSetup != null)
                return oWFSetup;
            #endregion
            #region WF Setup
            TransactionContext tc = null;
            try
            {
                DataReader oReader = null;
                tc = TransactionContext.Begin();
                oReader = new DataReader(WFSetupDA.Get(tc, nType));
                if (oReader.Read())
                    oWFSetup = CreateObject(oReader);
                oReader.Close();

                if (oWFSetup != null)
                {
                    oReader = new DataReader(WFSetupDA.Get4WFSetupRule(tc, oWFSetup.ID));
                    oWFSetup.WFSetupRules = CreateWFSetupRuleObject(oReader);
                    oReader.Close();

                    if (oWFSetup.WFSetupRules != null)
                    {
                        foreach (WFSetupRule oItem in oWFSetup.WFSetupRules)
                        {
                            oReader = new DataReader(WFSetupDA.Get4WFRuleDD(tc, oItem.ID.Integer));
                            oItem.WFRuleDeatilDesignations = CreateWFRuleDDObject(oReader);
                            oReader.Close();

                            oReader = new DataReader(WFSetupDA.Get4WFRuleDetailOS(tc, oWFSetup.ID.Integer, oItem.ID.Integer));
                            oItem.WFRuleDeatilOSs = CreateWFRuleDetailOSObject(oReader);
                            oReader.Close();

                            oReader = new DataReader(WFSetupDA.Get4WFRuleNode(tc, oItem.ID.Integer));
                            oItem.WFRuleDetailNodes = CreateWFRuleNodeObject(oReader);
                            oReader.Close();
                        }
                    }
                }
                tc.End();
            }
            catch (ServiceException ex)
            {
                #region Handle Exception
                if (tc != null)
                    tc.HandleError();
                ExceptionLog.Write(ex);
                throw new ServiceException("Failed to Get Work Flow Setup");
                #endregion
            }
            #endregion
            #region Cache Footer
            _cache.Add(oWFSetup, "GetByWFTypeID", nType);
            #endregion
            return oWFSetup;
        }

        public ObjectsTemplate<WFSetup> Get()
        {
            #region Cache Header

            ObjectsTemplate<WFSetup> wfSetups = _cache["Get"] as ObjectsTemplate<WFSetup>;
            if (wfSetups != null)
                return wfSetups;
            #endregion
            TransactionContext tc = null;
            try
            {
                tc = TransactionContext.Begin();
                DataReader dr = new DataReader(WFSetupDA.Get(tc));
                wfSetups = this.CreateObjects<WFSetup>(dr);
                dr.Close();
                tc.End();
            }
            catch (Exception e)
            {
                #region Handle Exception
                if (tc != null)
                    tc.HandleError();
                ExceptionLog.Write(e);
                throw new ServiceException(e.Message, e);
                #endregion
            }

            #region Cache Footer
            _cache.Add(wfSetups, "Get");
            #endregion
            return wfSetups;
        }





        public ObjectsTemplate<WFRuleDetailDesignation> Get4WFRuleDD(ID id)
        {
            #region Cache Header

            ObjectsTemplate<WFRuleDetailDesignation> wfRuleDDs = _cache["Get4WFRuleDD", id] as ObjectsTemplate<WFRuleDetailDesignation>;
            if (wfRuleDDs != null)
                return wfRuleDDs;
            #endregion
            TransactionContext tc = null;
            try
            {
                tc = TransactionContext.Begin();
                DataReader dr = new DataReader(WFSetupDA.Get4WFRuleDD(tc, id.Integer));
                wfRuleDDs = this.CreateWFRuleDDObject(dr);
                dr.Close();
                tc.End();
            }
            catch (Exception e)
            {
                #region Handle Exception
                if (tc != null)
                    tc.HandleError();
                ExceptionLog.Write(e);
                throw new ServiceException(e.Message, e);
                #endregion
            }

            #region Cache Footer
            _cache.Add(wfRuleDDs, "Get4WFRuleDD", id);
            #endregion
            return wfRuleDDs;
        }

        public ObjectsTemplate<WFRuleDetailNode> Get4WFRuleNode(ID id)
        {
            #region Cache Header

            ObjectsTemplate<WFRuleDetailNode> wfRuleDns = _cache["Get4WFRuleNode", id] as ObjectsTemplate<WFRuleDetailNode>;
            if (wfRuleDns != null)
                return wfRuleDns;
            #endregion
            TransactionContext tc = null;
            try
            {
                tc = TransactionContext.Begin();
                DataReader dr = new DataReader(WFSetupDA.Get4WFRuleNode(tc, id.Integer));
                wfRuleDns = this.CreateWFRuleNodeObject(dr);
                dr.Close();
                tc.End();
            }
            catch (Exception e)
            {
                #region Handle Exception
                if (tc != null)
                    tc.HandleError();
                ExceptionLog.Write(e);
                throw new ServiceException(e.Message, e);
                #endregion
            }

            #region Cache Footer
            _cache.Add(wfRuleDns, "Get4WFRuleNode", id);
            #endregion
            return wfRuleDns;
        }

        public ObjectsTemplate<WFSetupRule> Get4WFSetupRule(ID id)
        {
            #region Cache Header

            ObjectsTemplate<WFSetupRule> wfSetupRs = _cache["Get4WFSetupRule", id] as ObjectsTemplate<WFSetupRule>;
            if (wfSetupRs != null)
                return wfSetupRs;
            #endregion
            TransactionContext tc = null;
            try
            {
                tc = TransactionContext.Begin();
                DataReader dr = new DataReader(WFSetupDA.Get4WFSetupRule(tc, id));
                wfSetupRs = this.CreateWFSetupRuleObject(dr);
                dr.Close();

                tc.End();
            }
            catch (Exception e)
            {
                #region Handle Exception
                if (tc != null)
                    tc.HandleError();
                ExceptionLog.Write(e);
                throw new ServiceException(e.Message, e);
                #endregion
            }

            #region Cache Footer
            _cache.Add(wfSetupRs, "Get4WFSetupRule", id);
            #endregion
            return wfSetupRs;
        }

        public ObjectsTemplate<WFRuleDetailOS> Get4WFRuleDetailOS(ID id)
        {
            #region Cache Header

            ObjectsTemplate<WFRuleDetailOS> wfRDOSs = _cache["Get4WFRuleDetailOS", id] as ObjectsTemplate<WFRuleDetailOS>;
            if (wfRDOSs != null)
                return wfRDOSs;
            #endregion
            TransactionContext tc = null;
            try
            {
                tc = TransactionContext.Begin();
                DataReader dr = new DataReader(WFSetupDA.Get4WFRuleDetailOS(tc, id));
                wfRDOSs = this.CreateWFRuleDetailOSObject(dr);
                dr.Close();
                tc.End();
            }
            catch (Exception e)
            {
                #region Handle Exception
                if (tc != null)
                    tc.HandleError();
                ExceptionLog.Write(e);
                throw new ServiceException(e.Message, e);
                #endregion
            }

            #region Cache Footer
            _cache.Add(wfRDOSs, "Get4WFRuleDetailOS", id);
            #endregion
            return wfRDOSs;
        }



        public ObjectsTemplate<WFRuleDetailManual> Get4WFRuleDetailManual(ID id)
        {
            ObjectsTemplate<WFRuleDetailManual> wfRDOSs = null;

            TransactionContext tc = null;
            try
            {
                tc = TransactionContext.Begin();
                DataReader dr = new DataReader(WFSetupDA.Get4WFRuleDetailManual(tc, id));
                wfRDOSs = this.CreateWFRuleDetailManualObject(dr);
                dr.Close();
                tc.End();
            }
            catch (Exception e)
            {
                #region Handle Exception
                if (tc != null)
                    tc.HandleError();
                ExceptionLog.Write(e);
                throw new ServiceException(e.Message, e);
                #endregion
            }

            return wfRDOSs;
        }

        #endregion

        #endregion

        #endregion

        #region WFSetupRule Mapping

        private void MapWFSetupRuleObject(WFSetupRule wfSetupRule, DataReader oReader)
        {
            base.SetObjectID(wfSetupRule, oReader.GetID("WFSETUPRULEID"));
            //wfSetupRule.Name = oReader.GetString("Name");
            wfSetupRule.WFSetupId = oReader.GetID("WFSETUPID");
            wfSetupRule.StAuthorityLevel = oReader.GetInt32("STAUTHORITYLEVEL").Value;
            wfSetupRule.Priority = oReader.GetInt32("PRIORITY").Value;
            wfSetupRule.WFRuleType = (EnumWFRuleType)oReader.GetInt32("WFRULETYPE");
            wfSetupRule.LevelDepth = oReader.GetInt32("LEVELDEPTH").Value;
            wfSetupRule.ReqAppAll = oReader.GetBoolean("REQAPPALL").Value;
            wfSetupRule.AutoNotificationNode = oReader.GetID("AUTONOTIFICATIONNODE");
            wfSetupRule.FinalDestinationNode = oReader.GetID("FINALDESTINATIONNODE");
            wfSetupRule.IsRAuthority = (bool)oReader.GetBoolean("RAUTHORITY");
            //wfSetupRule.CreatedBy = oReader.GetID("CREATEDBY");
            //wfSetupRule.CreatedDate = oReader.GetDateTime("CREATEDDATE").Value;
            //wfSetupRule.ModifiedBy = oReader.GetID("MODIFIEDBY");
            //wfSetupRule.ModifiedDate = oReader.GetDateTime("MODIFIEDDATE");


            this.SetObjectState(wfSetupRule, Ease.CoreV35.ObjectState.Saved);
        }

        protected ObjectsTemplate<WFSetupRule> CreateWFSetupRuleObject(DataReader oReader)
        {
            ObjectsTemplate<WFSetupRule> wfSetupRules = new ObjectsTemplate<WFSetupRule>();
            while (oReader.Read())
            {
                WFSetupRule wfSetupRule = new WFSetupRule();
                MapWFSetupRuleObject(wfSetupRule, oReader);
                wfSetupRules.Add(wfSetupRule);
            }
            return wfSetupRules;
        }

        #endregion

        #region WFRuleDetailDesignation Mapping

        private void MapWFRuleDDObject(WFRuleDetailDesignation wfDetailDesig, DataReader oReader)
        {
            base.SetObjectID(wfDetailDesig, oReader.GetID("WFRULEDETAILID"));
            wfDetailDesig.DesignationId = oReader.GetID("DESIGNATIONID");
            wfDetailDesig.WfSetupId = oReader.GetID("WFSETUPID");
            wfDetailDesig.WfSetupRuleId = oReader.GetID("WFSETUPRULEID");
            wfDetailDesig.SequenceId = oReader.GetInt32("SEQUENCEID").Value;
            this.SetObjectState(wfDetailDesig, Ease.CoreV35.ObjectState.Saved);
        }

        protected ObjectsTemplate<WFRuleDetailDesignation> CreateWFRuleDDObject(DataReader oReader)
        {
            ObjectsTemplate<WFRuleDetailDesignation> wfDetailDesigs = new ObjectsTemplate<WFRuleDetailDesignation>();
            while (oReader.Read())
            {
                WFRuleDetailDesignation wfDetailDesig = new WFRuleDetailDesignation();
                MapWFRuleDDObject(wfDetailDesig, oReader);
                wfDetailDesigs.Add(wfDetailDesig);
            }
            return wfDetailDesigs;
        }

        #endregion

        #region WFRuleDetailNode Mapping

        private void MapWFRuleDetailNodeObject(WFRuleDetailNode wfRuleNode, DataReader oReader)
        {
            base.SetObjectID(wfRuleNode, oReader.GetID("WFRULEDNODEID"));
            wfRuleNode.NodeId = oReader.GetID("NODEID");
            wfRuleNode.WfSetupId = oReader.GetID("WFSETUPID");
            wfRuleNode.WfSetupRuleId = oReader.GetID("WFSETUPRULEID");
            wfRuleNode.SequenceId = oReader.GetInt32("SEQUENCEID").Value;
            this.SetObjectState(wfRuleNode, Ease.CoreV35.ObjectState.Saved);
        }

        protected ObjectsTemplate<WFRuleDetailNode> CreateWFRuleNodeObject(DataReader oReader)
        {
            ObjectsTemplate<WFRuleDetailNode> wfRuleNodes = new ObjectsTemplate<WFRuleDetailNode>();
            while (oReader.Read())
            {
                WFRuleDetailNode wfRuleNode = new WFRuleDetailNode();
                MapWFRuleDetailNodeObject(wfRuleNode, oReader);
                wfRuleNodes.Add(wfRuleNode);
            }
            return wfRuleNodes;
        }

        #endregion

        #region WFRuleDetailOS Mapping
        private void MapWFRuleDetailOSObject(WFRuleDetailOS wfRuleDOS, DataReader oReader)
        {

            base.SetObjectID(wfRuleDOS, oReader.GetID("WFRULEDETAILID"));
            wfRuleDOS.OsID = oReader.GetID("OSID");
            wfRuleDOS.WfSetupId = oReader.GetID("WFSETUPID");
            wfRuleDOS.WfSetupRuleId = oReader.GetID("WFSETUPRULEID");
            wfRuleDOS.SequenceId = oReader.GetInt32("SEQUENCEID").Value;
            this.SetObjectState(wfRuleDOS, Ease.CoreV35.ObjectState.Saved);
        }
        protected ObjectsTemplate<WFRuleDetailOS> CreateWFRuleDetailOSObject(DataReader oReader)
        {
            ObjectsTemplate<WFRuleDetailOS> wfRuleDOSs = new ObjectsTemplate<WFRuleDetailOS>();
            while (oReader.Read())
            {
                WFRuleDetailOS wfRuleDOS = new WFRuleDetailOS();
                MapWFRuleDetailOSObject(wfRuleDOS, oReader);
                wfRuleDOSs.Add(wfRuleDOS);
            }
            return wfRuleDOSs;
        }
        #endregion


        #region WFRuleDetailOS Mapping
        private void MapWFRuleDetailManual(WFRuleDetailManual wfRuleManual, DataReader oReader)
        {

            base.SetObjectID(wfRuleManual, oReader.GetID("WFRULEDETAILID"));
            wfRuleManual.ObjectID = oReader.GetInt32("ObjectId").Value;
            wfRuleManual.RuleType = (enumWFRuleManual)oReader.GetInt32("RuleType");
            wfRuleManual.WfSetupId = oReader.GetID("WFSETUPID");
            wfRuleManual.WfSetupRuleId = oReader.GetID("WFSETUPRULEID");
            wfRuleManual.SequenceId = oReader.GetInt32("SEQUENCEID").Value;
            this.SetObjectState(wfRuleManual, Ease.CoreV35.ObjectState.Saved);
        }


        protected ObjectsTemplate<WFRuleDetailManual> CreateWFRuleDetailManualObject(DataReader oReader)
        {
            ObjectsTemplate<WFRuleDetailManual> wfRuleDOSs = new ObjectsTemplate<WFRuleDetailManual>();
            while (oReader.Read())
            {
                WFRuleDetailManual wfRuleDOS = new WFRuleDetailManual();
                MapWFRuleDetailManual(wfRuleDOS, oReader);
                wfRuleDOSs.Add(wfRuleDOS);
            }
            return wfRuleDOSs;
        }
        #endregion


    }
}