MonoRail/Castle.MonoRail.Framework/WizardActionProvider.cs

   1 // Copyright 2004-2007 Castle Project - http://www.castleproject.org/
   2 //
   3 // Licensed under the Apache License, Version 2.0 (the "License");
   4 // you may not use this file except in compliance with the License.
   5 // You may obtain a copy of the License at
   6 //
   7 //     http://www.apache.org/licenses/LICENSE-2.0
   8 //
   9 // Unless required by applicable law or agreed to in writing, software
  10 // distributed under the License is distributed on an "AS IS" BASIS,
  11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12 // See the License for the specific language governing permissions and
  13 // limitations under the License.
  14
  15 namespace Castle.MonoRail.Framework
  16 {
  17         using System;
  18         using System.Collections;
  19
  20         using Castle.MonoRail.Framework.Helpers;
  21         using Castle.MonoRail.Framework.Internal;
  22
  23         /// <summary>
  24         /// Provide easy to use Wizard-like support.
  25         /// </summary>
  26         /// <seealso cref="IWizardController"/>
  27         /// <remarks>
  28         /// MonoRail uses the DynamicAction infrastructure to provide
  29         /// wizard support so we dont force
  30         /// the programmer to inherit from a specific Controller
  31         /// which can be quite undesirable in real world projects.
  32         /// <para>
  33         /// Nevertheless we do require that the programmer
  34         /// implements <see cref="IWizardController"/> on the wizard controller.
  35         /// </para>
  36         /// </remarks>
  37         public class WizardActionProvider : IDynamicActionProvider, IDynamicAction
  38         {
  39                 private WizardStepPage[] steps;
  40                 private WizardStepPage currentStepInstance;
  41                 private IControllerLifecycleExecutor currentStepExecutor;
  42                 private String rawAction;
  43                 private String innerAction;
  44                 private String requestedAction;
  45                 private UrlInfo urlInfo;
  46
  47                 /// <summary>
  48                 /// Initializes a new instance of the <see cref="WizardActionProvider"/> class.
  49                 /// </summary>
  50                 public WizardActionProvider()
  51                 {
  52                 }
  53
  54                 /// <summary>
  55                 /// Implementation of IDynamicActionProvider.
  56                 /// <para>
  57                 /// Grab all steps related to the wizard
  58                 /// and register them as dynamic actions.
  59                 /// </para>
  60                 /// </summary>
  61                 /// <param name="controller">Wizard controller (must implement <see cref="IWizardController"/></param>
  62                 public void IncludeActions(Controller controller)
  63                 {
  64                         IRailsEngineContext context = controller.Context;
  65
  66                         // Primordial assert
  67
  68                         IWizardController wizardController = controller as IWizardController;
  69
  70                         if (wizardController == null)
  71                         {
  72                                 throw new RailsException("The controller {0} must implement the interface " +
  73                                         "IWizardController to be used as a wizard", controller.Name);
  74                         }
  75
  76                         // Grab all Wizard Steps
  77
  78                         steps = wizardController.GetSteps(controller.Context);
  79
  80                         if (steps == null || steps.Length == 0)
  81                         {
  82                                 throw new RailsException("The controller {0} returned no WizardStepPage", controller.Name);
  83                         }
  84
  85                         IList stepList = new ArrayList();
  86
  87                         // Include the "start" dynamic action, which resets the wizard state
  88
  89                         controller.DynamicActions["start"] = this;
  90
  91                         // Find out the action request (and possible inner action)
  92                         //   Each action will be a step name, or maybe the step name + action (ie Page1-Save)
  93
  94                         urlInfo = controller.Context.UrlInfo;
  95
  96                         rawAction = urlInfo.Action;
  97
  98                         requestedAction = ObtainRequestedAction(rawAction, out innerAction);
  99
 100                         // If no inner action was found, fallback to 'RenderWizardView'
 101
 102                         if (innerAction == null || innerAction == String.Empty)
 103                         {
 104                                 innerAction = "RenderWizardView";
 105                         }
 106
 107                         IControllerLifecycleExecutorFactory execFactory =
 108                                 (IControllerLifecycleExecutorFactory) context.GetService(typeof(IControllerLifecycleExecutorFactory));
 109
 110                         // Initialize all steps and while we are at it,
 111                         // discover the current step
 112
 113                         foreach(WizardStepPage step in steps)
 114                         {
 115                                 String actionName = step.ActionName;
 116
 117                                 if (String.Compare(requestedAction, actionName, true) == 0)
 118                                 {
 119                                         currentStepInstance = step;
 120
 121                                         if (innerAction != null)
 122                                         {
 123                                                 // If there's an inner action, we invoke it as a step too
 124                                                 controller.DynamicActions[rawAction] =
 125                                                         new DelegateDynamicAction(new ActionDelegate(OnStepActionRequested));
 126                                         }
 127
 128                                         context.CurrentController = step;
 129                                 }
 130
 131                                 controller.DynamicActions[actionName] =
 132                                         new DelegateDynamicAction(new ActionDelegate(OnStepActionRequested));
 133
 134                                 stepList.Add(actionName);
 135
 136                                 IControllerLifecycleExecutor stepExec = execFactory.CreateExecutor(step, context);
 137                                 stepExec.InitializeController(controller.AreaName, controller.Name, innerAction);
 138                                 step.Initialize(controller);
 139
 140                                 if (currentStepInstance == step)
 141                                 {
 142                                         currentStepExecutor = stepExec;
 143
 144                                         if (!stepExec.SelectAction(innerAction, controller.Name))
 145                                         {
 146                                                 stepExec.PerformErrorHandling();
 147
 148                                                 return;
 149                                         }
 150
 151                                         if (!stepExec.RunStartRequestFilters())
 152                                         {
 153                                                 context.UnderlyingContext.Response.End();
 154                                         }
 155                                 }
 156                         }
 157
 158                         context.Items["wizard.step.list"] = stepList;
 159
 160                         SetUpWizardHelper(controller);
 161                         SetUpWizardHelper(currentStepInstance);
 162                 }
 163
 164                 /// <summary>
 165                 /// Invoked as "start" action
 166                 /// </summary>
 167                 /// <param name="controller"></param>
 168                 public void Execute(Controller controller)
 169                 {
 170                         StartWizard(controller, true);
 171                 }
 172
 173                 /// <summary>
 174                 /// Invoked when a step is accessed on the url,
 175                 /// i.e. http://host/mywizard/firststep.rails and
 176                 /// when an inner action is invoked like http://host/mywizard/firststep-save.rails
 177                 /// </summary>
 178                 /// <param name="controller"></param>
 179                 private void OnStepActionRequested(Controller controller)
 180                 {
 181                         if (currentStepInstance != null && !HasRequiredSessionData(controller))
 182                         {
 183                                 StartWizard(controller, false);
 184                         }
 185
 186                         controller.CancelView();
 187
 188                         IRailsEngineContext context = controller.Context;
 189
 190                         IWizardController wizController = (IWizardController) controller;
 191
 192                         String wizardName = WizardUtils.ConstructWizardNamespace(controller);
 193
 194                         String currentStep = (String) context.Session[wizardName + "currentstep"];
 195
 196                         // The step will inherit the controller property bag,
 197                         // this way filters can pass values to the step property without having to know it
 198                         currentStepInstance.PropertyBag = controller.PropertyBag;
 199
 200                         // If OnBeforeStep returns false we stop
 201                         if (!wizController.OnBeforeStep(wizardName, currentStep, currentStepInstance))
 202                         {
 203                                 return;
 204                         }
 205
 206                         // Initialize step data so instance members can be used
 207                         // executor.InitializeController(urlInfo.Area, urlInfo.Controller, innerAction);
 208
 209                         // Record the step we're working with
 210                         WizardUtils.RegisterCurrentStepInfo(controller, currentStepInstance.ActionName);
 211
 212                         // The step cannot be accessed in the current state of matters
 213                         if (!currentStepInstance.IsPreConditionSatisfied(controller.Context))
 214                         {
 215                                 return;
 216                         }
 217
 218                         // Dispatch process
 219                         try
 220                         {
 221                                 // TODO: Invoke Whole step here
 222                                 // currentStepInstance.Process(controller.Context,
 223                                 //      urlInfo.Area, urlInfo.Controller, innerAction);
 224                                 currentStepExecutor.ProcessSelectedAction();
 225                         }
 226                         finally
 227                         {
 228                                 wizController.OnAfterStep(wizardName, currentStep, currentStepInstance);
 229
 230                                 currentStepExecutor.Dispose();
 231                         }
 232                 }
 233
 234                 /// <summary>
 235                 /// Represents an empty (no-op) action.
 236                 /// </summary>
 237                 /// <param name="controller">The controller.</param>
 238                 protected void EmptyAction(Controller controller)
 239                 {
 240                         controller.CancelView();
 241                 }
 242
 243                 /// <summary>
 244                 /// Determines whether all wizard specific information is on the user session.
 245                 /// </summary>
 246                 /// <param name="controller">The controller.</param>
 247                 /// <returns>
 248                 ///     <c>true</c> if has session data; otherwise, <c>false</c>.
 249                 /// </returns>
 250                 protected bool HasRequiredSessionData(Controller controller)
 251                 {
 252                         String wizardName = WizardUtils.ConstructWizardNamespace(controller);
 253
 254                         IRailsEngineContext context = controller.Context;
 255
 256                         return (context.Session.Contains(wizardName + "currentstepindex") &&
 257                                 context.Session.Contains(wizardName + "currentstep"));
 258                 }
 259
 260                 /// <summary>
 261                 /// Starts the wizard by adding the required information to the
 262                 /// session and invoking <see cref="IWizardController.OnWizardStart"/>
 263                 /// and detecting the first step.
 264                 /// </summary>
 265                 /// <param name="controller">The controller.</param>
 266                 /// <param name="redirect">if set to <c>true</c>, a redirect
 267                 /// will be issued to the first step.</param>
 268                 protected void StartWizard(Controller controller, bool redirect)
 269                 {
 270                         ResetSteps(controller);
 271
 272                         IWizardController wizardController = controller as IWizardController;
 273
 274                         IRailsEngineContext context = controller.Context;
 275
 276                         IList stepList = (IList) context.Items["wizard.step.list"];
 277
 278                         String firstStep = (String) stepList[0];
 279
 280                         String wizardName = WizardUtils.ConstructWizardNamespace(controller);
 281
 282                         context.Session[wizardName + "currentstepindex"] = 0;
 283                         context.Session[wizardName + "currentstep"] = firstStep;
 284
 285                         wizardController.OnWizardStart();
 286
 287                         if (redirect)
 288                         {
 289                                 context.Response.Redirect(controller.AreaName, controller.Name, firstStep);
 290                         }
 291                 }
 292
 293                 /// <summary>
 294                 /// Resets the steps by invoking <see cref="WizardStepPage.Reset"/>
 295                 /// on all steps instances.
 296                 /// </summary>
 297                 /// <param name="controller">The controller.</param>
 298                 protected void ResetSteps(Controller controller)
 299                 {
 300                         IWizardController wizardController = controller as IWizardController;
 301
 302                         WizardStepPage[] steps = wizardController.GetSteps(controller.Context);
 303
 304                         foreach(WizardStepPage step in steps)
 305                         {
 306                                 step.InitializeFieldsFromServiceProvider(controller.Context);
 307                                 step.Reset();
 308                         }
 309                 }
 310
 311                 private String ObtainRequestedAction(String action, out String innerAction)
 312                 {
 313                         innerAction = null;
 314
 315                         int index = action.IndexOf('-');
 316
 317                         if (index != -1)
 318                         {
 319                                 innerAction = action.Substring(index + 1);
 320
 321                                 return action.Substring(0, index);
 322                         }
 323
 324                         return action;
 325                 }
 326
 327                 private void SetUpWizardHelper(Controller controller)
 328                 {
 329                         if (controller == null) return;
 330
 331                         WizardHelper helper = new WizardHelper();
 332
 333                         helper.SetController(controller);
 334
 335                         controller.Helpers["wizardhelper"] = helper;
 336                 }
 337         }
 338 }