Experiments/Attic/MVC/Castle.MVC/Configuration/MVCConfigSettings.cs

   1
   2 #region Apache Notice
   3 /*****************************************************************************
   4  *
   5  * Castle.MVC
   6  *
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  *
  19  ********************************************************************************/
  20 #endregion
  21
  22 #region Autors
  23
  24 /************************************************
  25 * Gilles Bayon
  26 *************************************************/
  27 #endregion
  28
  29 #region Using
  30
  31 using System;
  32 using System.Collections.Specialized;
  33 using System.Configuration;
  34 using System.Xml;
  35 #endregion
  36
  37 namespace Castle.MVC.Configuration
  38 {
  39         /// <summary>
  40         /// MVCConfigSettings.
  41         /// </summary>
  42         public class MVCConfigSettings
  43         {
  44                 #region Const
  45                 /// <summary>
  46                 /// Token to retrieve configuration node
  47                 /// </summary>
  48                 private const string NODE_WEB_VIEW_XPATH = "webViews/view";
  49                 private const string NODE_WIN_VIEW_XPATH = "winViews/view";
  50                 private const string ATTRIBUTE_ID = "id";
  51                 private const string ATTRIBUTE_VIEW = "view";
  52                 private const string ATTRIBUTE_PATH = "path";
  53                 private const string ATTRIBUTE_TYPE = "type";
  54                 private const string NODE_COMMANDS_XPATH = "command-mappings/commands";
  55                 private const string NODE_GLOBAL_COMMANDS_XPATH = "global-commands/command";
  56
  57                 #endregion
  58
  59                 #region Fields
  60
  61                 private StringDictionary _urls = new StringDictionary();
  62                 private StringDictionary _webViews= new StringDictionary();
  63                 private HybridDictionary _types = new HybridDictionary();
  64                 private HybridDictionary _winViews= new HybridDictionary();
  65                 private HybridDictionary _mappings = new HybridDictionary();
  66                 private StringDictionary _globalCommands = new StringDictionary();
  67
  68                 #endregion
  69
  70                 #region Constructor
  71
  72                 /// <summary>
  73                 /// Creates MVCConfigSettings from an XmlNode read of the web.config and an IFormatProvider.
  74                 /// </summary>
  75                 /// <param name="configNode">The XmlNode from the configuration file.</param>
  76                 /// <param name="formatProvider">The provider.</param>
  77                 public MVCConfigSettings(XmlNode configNode, IFormatProvider formatProvider)
  78                 {
  79                         LoadWebViews(configNode, formatProvider);
  80                         LoadWinViews(configNode, formatProvider);
  81                         LoadGlobalCommand(configNode);
  82                         LoadCommandMapping(configNode);
  83                 }
  84                 #endregion
  85
  86                 #region Methods
  87
  88                 /// <summary>
  89                 /// Load the global commands
  90                 /// </summary>
  91                 /// <param name="configNode">The XmlNode from the configuration file.</param>
  92                 private void LoadGlobalCommand(XmlNode configNode)
  93                 {
  94                         foreach(XmlNode commandNode in configNode.SelectNodes( NODE_GLOBAL_COMMANDS_XPATH ) )
  95                         {
  96                                 string id = commandNode.Attributes[ATTRIBUTE_ID].Value;
  97                                 string view = commandNode.Attributes[ATTRIBUTE_VIEW].Value;
  98                                 _globalCommands.Add( id, view );
  99                         }
 100                 }
 101
 102                 /// <summary>
 103                 /// Load the command mapping
 104                 /// </summary>
 105                 /// <param name="configNode">The XmlNode from the configuration file.</param>
 106                 private void LoadCommandMapping(XmlNode configNode)
 107                 {
 108                         foreach( XmlNode currentNode in configNode.SelectNodes( NODE_COMMANDS_XPATH ) )
 109                         {
 110                                 CommandsSetting setting = new CommandsSetting( currentNode );
 111                                 _mappings.Add( setting.View, setting );
 112                         }
 113                 }
 114
 115                 /// <summary>
 116                 /// Load the views
 117                 /// </summary>
 118                 /// <param name="configNode">The XmlNode from the configuration file.</param>
 119                 /// <param name="formatProvider">The provider.</param>
 120                 private void LoadWebViews(XmlNode configNode, IFormatProvider formatProvider)
 121                 {
 122                         //Get the views
 123                         foreach( XmlNode viewNode in configNode.SelectNodes( NODE_WEB_VIEW_XPATH ) )
 124                         {
 125                                 string viewName = viewNode.Attributes[ATTRIBUTE_ID].Value;
 126                                 string viewUrl = viewNode.Attributes[ATTRIBUTE_PATH].Value;
 127
 128                                 if( !_webViews.ContainsKey( viewName ) )
 129                                 {
 130                                         _urls.Add( viewName, viewUrl );
 131                                         _webViews.Add( viewUrl, viewName );
 132                                 }
 133                                 else
 134                                 {
 135                                         throw new ConfigurationException( Resource.ResourceManager.FormatMessage( Resource.MessageKeys.ViewAlreadyConfigured, viewName ) );
 136                                 }
 137                         }
 138                 }
 139
 140                 /// <summary>
 141                 /// Load the windows views
 142                 /// </summary>
 143                 /// <param name="configNode">The XmlNode from the configuration file.</param>
 144                 /// <param name="formatProvider">The provider.</param>
 145                 private void LoadWinViews(XmlNode configNode, IFormatProvider formatProvider)
 146                 {
 147                         //Get the views
 148                         foreach( XmlNode viewNode in configNode.SelectNodes( NODE_WIN_VIEW_XPATH ) )
 149                         {
 150                                 string viewId = viewNode.Attributes[ATTRIBUTE_ID].Value;
 151                                 string viewType = viewNode.Attributes[ATTRIBUTE_TYPE].Value;
 152
 153                                 // infer type from viewType
 154                                 Type type = null;
 155                                 if( !_winViews.Contains( type ) )
 156                                 {
 157                                         _types.Add( viewId, type );
 158                                         //_winViews.Add( type, viewId );
 159                                 }
 160                                 else
 161                                 {
 162                                         throw new ConfigurationException( Resource.ResourceManager.FormatMessage( Resource.MessageKeys.ViewAlreadyConfigured, viewId ) );
 163                                 }
 164                         }
 165                 }
 166
 167                 ///<summary>
 168                 ///Looks up a url view based on view name.
 169                 ///</summary>
 170                 ///<param name="viewName">The name of the view to retrieve the settings for.</param>
 171                 public virtual string GetUrl( string viewName )
 172                 {
 173                         return _urls[viewName] as string;
 174                 }
 175
 176                 ///<summary>
 177                 /// Looks up a web view based on his url.
 178                 ///</summary>
 179                 ///<param name="url">The URL.</param>
 180                 public virtual string GetView(string url)
 181                 {
 182                         return _webViews[url] as string;
 183                 }
 184
 185                 ///<summary>
 186                 /// Looks up a windows view based on his type.
 187                 ///</summary>
 188                 ///<param name="type">The view type.</param>
 189                 public virtual string GetView(Type type)
 190                 {
 191                         return _winViews[type] as string;
 192                 }
 193
 194                 ///<summary>
 195                 ///Looks up a next view based on current command id and and current view id.
 196                 ///</summary>
 197                 ///<param name="commandID">The id of the current command.</param>
 198                 ///<param name="viewID">The id of the current view.</param>
 199                 ///<returns>The next web view to go.</returns>
 200                 public virtual string GetNextView(string viewID, string commandID)
 201                 {
 202                         string nextView = string.Empty;
 203
 204                         if (_globalCommands.ContainsKey(commandID))
 205                         {
 206                                 nextView = _globalCommands[commandID];
 207                         }
 208                         else
 209                         {
 210                                 CommandsSetting setting= null;
 211                                 if( _mappings.Contains( viewID ) )
 212                                 {
 213                                         setting = _mappings[viewID] as CommandsSetting;
 214                                 }
 215                                 else
 216                                 {
 217                                         throw new ConfigurationException( Resource.ResourceManager.FormatMessage( Resource.MessageKeys.CantFindCommandMapping, viewID ) );
 218                                 }
 219                                 nextView = setting[commandID];
 220                                 if( nextView==null )
 221                                 {
 222                                         throw new ConfigurationException( Resource.ResourceManager.FormatMessage( Resource.MessageKeys.CantGetNextView, viewID, commandID ) );
 223                                 }
 224                         }
 225
 226                         return nextView;
 227                 }
 228                 #endregion
 229
 230
 231         }
 232 }