SiteMapSettings.cs

// Copyright © 2007 Jeffrey Bazinet, http://www.vwd-cms.com/
using System;
using System.Configuration;
using System.Web;
using System.Web.Util;
using System.Web.Configuration;
using System.Collections.Specialized;
using System.Collections;
using System.IO;
using System.Collections.Generic;

namespace VwdCms.Configuration
{
    public class SiteMapSettings
    {
        //public StringCollection PageExtensions = new StringCollection();
        //public StringCollection HiddenFolders = new StringCollection();
        //public StringCollection HiddenPages = new StringCollection();

        private Dictionarystring, string _pageExtensions = new Dictionarystring, string();
        private Dictionarystring, string _hiddenFolders = new Dictionarystring, string();
        private Dictionarystring, string _hiddenPages = new Dictionarystring, string();

        private Hashtable _pageExtensionsHashtable = null;
        private Hashtable _hiddenFoldersHashtable = null;
        private Hashtable _hiddenPagesHashtable = null;

        public CmsConfig CmsConfig = null;

        public SiteMapSettings(CmsConfig cmsconfig)
        {
            this.CmsConfig = cmsconfig;
        }

        public SiteMapSettings(CmsConfig cmsconfig, System.Xml.XmlNode node)
        {
            this.CmsConfig = cmsconfig;
            if (node != null  node.ChildNodes.Count  0)
            {
                // <pageextensions> 
                LoadCollection(this.PageExtensions, "pageextensions", node);

                // <hiddenfolders> 
                LoadCollection(this.HiddenFolders, "hiddenfolders", node);

                // <hiddenpages> 
                LoadCollection(this.HiddenPages, "hiddenpages", node);
            }
        }

        public Dictionarystring, string PageExtensions
        {
            get { return _pageExtensions; }
        }

        public Dictionarystring, string HiddenFolders
        {
            get { return _hiddenFolders; }
        }

        public Dictionarystring, string HiddenPages
        {
            get { return _hiddenPages; }
        }

        [NotPersisted]
        public Hashtable PageExtensionsHashtable
        {
            get
            {
                if (_pageExtensionsHashtable == null)
                {
                    LoadPageExtensionsHashtable();
                }
                return _pageExtensionsHashtable;
            }
        }

        [NotPersisted]
        public Hashtable HiddenFoldersHashtable
        {
            get
            {
                if (_hiddenFoldersHashtable == null)
                {
                    LoadHiddenFoldersHashtable();
                }
                return _hiddenFoldersHashtable;
            }
        }

        [NotPersisted]
        public Hashtable HiddenPagesHashtable
        {
            get
            {
                if (_hiddenPagesHashtable == null)
                {
                    LoadHiddenPagesHashtable();
                }
                return _hiddenPagesHashtable;
            }
        }

        //private void LoadCollection(StringCollection col, string collectionName, System.Xml.XmlNode node)
        private void LoadCollection(Dictionarystring, string col, string collectionName, System.Xml.XmlNode node)
        {
            if (node != null  node.ChildNodes.Count  0)
            {
                System.Xml.XmlNode colnode = null;
                string name = "./";
                string val = null;

                colnode = node.SelectSingleNode(name + collectionName);

                if (colnode != null  colnode.ChildNodes.Count  0)
                {
                    foreach (System.Xml.XmlNode n in colnode.ChildNodes)
                    {
                        if (n != null  n.NodeType == System.Xml.XmlNodeType.Element)
                        {
                            val = n.InnerText;
                            if (!string.IsNullOrEmpty(val))
                            {
                                val = val.Trim();
                                if (val != string.Empty)
                                {
                                    val = val.ToLower();
                                    if (!col.ContainsKey(val))
                                    {
                                        col.Add(val, val);
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }

        private void LoadHiddenFoldersHashtable()
        {
            _hiddenFoldersHashtable = new Hashtable();

            string vpSitePath = VwdCms.Configuration.Utilities.SitePath;
            string lpSitePath = HttpContext.Current.Server.MapPath(vpSitePath);

            DirectoryInfo diHidden = null;
            DirectoryInfo[] diChildren = null;
            string lpFolder = null;
            string key = null;
            string folder = null;

            foreach (KeyValuePairstring, string kvp in this.HiddenFolders)
            {
                folder = kvp.Value;
                lpFolder = lpSitePath + folder;
                if (Directory.Exists(lpFolder))
                {
                    diHidden = new DirectoryInfo(lpFolder);
                    if (diHidden != null)
                    {
                        key = diHidden.FullName.ToLower();
                        if (!_hiddenFoldersHashtable.ContainsKey(key))
                        {
                            _hiddenFoldersHashtable.Add(key, key);
                        }

                        diChildren = diHidden.GetDirectories("*", SearchOption.AllDirectories);
                        if (diChildren != null  diChildren.Length  0)
                        {
                            foreach (DirectoryInfo diChild in diChildren)
                            {
                                key = diChild.FullName.ToLower();
                                if (!_hiddenFoldersHashtable.ContainsKey(key))
                                {
                                    _hiddenFoldersHashtable.Add(key, key);
                                }
                            }
                        }
                    }
                }
            }
        }

        private void LoadHiddenPagesHashtable()
        {
            _hiddenPagesHashtable = new Hashtable();

            string vpSitePath = VwdCms.Configuration.Utilities.SitePath;
            string lpSitePath = HttpContext.Current.Server.MapPath(vpSitePath);

            FileInfo fiHidden = null;
            string lpFile = null;
            string key = null;
            string file = null;

            foreach (KeyValuePairstring,string kvp in this.HiddenPages)
            {
                file = kvp.Value;
                lpFile = lpSitePath + file;
                if (File.Exists(lpFile))
                {
                    fiHidden = new FileInfo(lpFile);
                    if (fiHidden != null)
                    {
                        key = fiHidden.FullName.ToLower();
                        if (!_hiddenPagesHashtable.ContainsKey(key))
                        {
                            _hiddenPagesHashtable.Add(key, key);
                        }
                    }
                }
            }
        }

        private void LoadPageExtensionsHashtable()
        {
            string key = null;
            _pageExtensionsHashtable = new Hashtable();
            string ext = null;
            foreach(KeyValuePairstring, string kvp in this.PageExtensions)
            {
                ext = kvp.Value;
                if (!string.IsNullOrEmpty(ext))
                {
                    key = ext.ToLower();
                    if (!_pageExtensionsHashtable.ContainsKey(key))
                    {
                        _pageExtensionsHashtable.Add(key, key);
                    }
                }
            }
        }
    }
}

This code sample has been automatically colorized by the VwdCms.CodeViewer control, an ASP.NET server control code colorizer that supports HTML, ASPX, XML, C#, and JavaScript code formats.