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         /// <remarks>
  27         /// We use the DynamicAction infrastructure to provide
  28         /// wizard support as we dont force
  29         /// the programmer to inherit from a specific Controller
  30         /// which can be quite undesirable in common business projects
  31         /// situations.
  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                 protected void EmptyAction(Controller controller)
 235                 {
 236                         controller.CancelView();
 237                 }
 238
 239                 protected bool HasRequiredSessionData(Controller controller)
 240                 {
 241                         String wizardName = WizardUtils.ConstructWizardNamespace(controller);
 242
 243                         IRailsEngineContext context = controller.Context;
 244
 245                         return (context.Session.Contains(wizardName + "currentstepindex") &&
 246                                 context.Session.Contains(wizardName + "currentstep"));
 247                 }
 248
 249                 protected void StartWizard(Controller controller, bool redirect)
 250                 {
 251                         ResetSteps(controller);
 252
 253                         IWizardController wizardController = controller as IWizardController;
 254
 255                         IRailsEngineContext context = controller.Context;
 256
 257                         IList stepList = (IList) context.Items["wizard.step.list"];
 258
 259                         String firstStep = (String) stepList[0];
 260
 261                         String wizardName = WizardUtils.ConstructWizardNamespace(controller);
 262
 263                         context.Session[wizardName + "currentstepindex"] = 0;
 264                         context.Session[wizardName + "currentstep"] = firstStep;
 265
 266                         wizardController.OnWizardStart();
 267
 268                         if (redirect)
 269                         {
 270                                 context.Response.Redirect(controller.AreaName, controller.Name, firstStep);
 271                         }
 272                 }
 273
 274                 protected void ResetSteps(Controller controller)
 275                 {
 276                         IWizardController wizardController = controller as IWizardController;
 277
 278                         WizardStepPage[] steps = wizardController.GetSteps(controller.Context);
 279
 280                         foreach(WizardStepPage step in steps)
 281                         {
 282                                 step.InitializeFieldsFromServiceProvider(controller.Context);
 283                                 step.Reset();
 284                         }
 285                 }
 286
 287                 private String ObtainRequestedAction(String action, out String innerAction)
 288                 {
 289                         innerAction = null;
 290
 291                         int index = action.IndexOf('-');
 292
 293                         if (index != -1)
 294                         {
 295                                 innerAction = action.Substring(index + 1);
 296
 297                                 return action.Substring(0, index);
 298                         }
 299
 300                         return action;
 301                 }
 302
 303                 private void SetUpWizardHelper(Controller controller)
 304                 {
 305                         if (controller == null) return;
 306
 307                         WizardHelper helper = new WizardHelper();
 308
 309                         helper.SetController(controller);
 310
 311                         controller.Helpers["wizardhelper"] = helper;
 312                 }
 313         }
 314 }