public IRecordService <TID> ExecuteAction(IExecutableAction <TID> implementation, bool executeAgainstAggregate = false) { this.policy.Execute(() => { if (executeAgainstAggregate) { implementation.Execute(AggregateId); } else { if (!CreatedRecords.Any()) { throw new ArgumentException("You must create records before executing an action against them"); } implementation.Execute(CreatedRecords.Last().Key); } }); return(this); }
/// <summary> /// Identifies if no filter should run for the given action. /// </summary> /// <param name="action">The action.</param> /// <returns></returns> protected virtual bool ShouldSkipFilters(IExecutableAction action) { if (filters == null) { // No filters, so skip return true; } return action.ShouldSkipAllFilters; // ActionMetaDescriptor actionMeta = MetaDescriptor.GetAction(method); // // if (actionMeta.SkipFilters.Count == 0) // { // // Nothing against filters declared for this action // return false; // } // // foreach(SkipFilterAttribute skipfilter in actionMeta.SkipFilters) // { // // SkipAllFilters handling... // if (skipfilter.BlanketSkip) // { // return true; // } // // filtersToSkip[skipfilter.FilterType] = String.Empty; // } // // return false; }
private void RunAfterRenderingFilters(IExecutableAction action) { if (action.ShouldSkipAllFilters) { return; } ProcessFilters(action, ExecuteWhen.AfterRendering); }
private void RunAfterActionFilters(IExecutableAction action, out bool cancel) { cancel = false; if (action == null) { return; } if (action.ShouldSkipAllFilters) { return; } if (!ProcessFilters(action, ExecuteWhen.AfterAction)) { cancel = true; return; // A filter returned false... so we stop } }
/// <summary> /// Ensures the action is accessible with current HTTP verb. /// </summary> /// <param name="action">The action.</param> protected virtual void EnsureActionIsAccessibleWithCurrentHttpVerb(IExecutableAction action) { Verb allowedVerbs = action.AccessibleThroughVerb; if (allowedVerbs == Verb.Undefined) { return; } string method = engineContext.Request.HttpMethod; Verb currentVerb = (Verb) Enum.Parse(typeof(Verb), method, true); if ((allowedVerbs & currentVerb) != currentVerb) { throw new MonoRailException(403, "Forbidden", string.Format("Access to the action [{0}] " + "on controller [{1}] is not allowed to the http verb [{2}].", Action, Name, method)); } }
/// <summary> /// Configures the cache policy. /// </summary> /// <param name="action">The action.</param> protected virtual void ConfigureCachePolicy(IExecutableAction action) { ICachePolicyConfigurer configurer = action.CachePolicyConfigurer ?? MetaDescriptor.CacheConfigurer; configurer.Configure(Response.CachePolicy); }
/// <summary> /// Resolves the layout override for the specified action /// </summary> /// <param name="action">The action.</param> protected virtual void ResolveLayout(IExecutableAction action) { if (action.LayoutOverride != null && action.LayoutOverride.Length != 0) { context.LayoutNames = action.LayoutOverride; } }
private void ExecuteAction(IExecutableAction action) { threading.ReentrancyGuard.ExecuteOrQueue(EternalLifetime.Instance, "AgentAction", () => actionManager.ExecuteActionIfAvailable(action)); }
/// <summary> /// Creates the controller level resources. /// </summary> /// <param name="action">The action.</param> protected virtual void CreateActionLevelResources(IExecutableAction action) { CreateResources(action.Resources); }
private IEnumerable<FilterDescriptor> GetActionLevelFilters(IExecutableAction action) { return action.ActionLevelFilters.OrderBy(descriptor => descriptor.ExecutionOrder); }
protected virtual bool ProcessFilters(IExecutableAction action, ExecuteWhen when) { foreach(var desc in filters.Union(GetActionLevelFilters(action))) { if (action.ShouldSkipFilter(desc.FilterType)) { continue; } if ((desc.When & when) != 0) { if (!ProcessFilter(when, desc)) { return false; } } } return true; }
protected override IExecutableAction GetShortcutAction(TextWriter textwriter) { IExecutableAction jumpToTestFileAction = JumpToTestFileAction.CreateWith(CreateJetPopMenuShowToWriterAction(textwriter)); return(jumpToTestFileAction); }
public void RemoveHandler(IExecutableAction handler) { //_handlers.RemoveHandler(handler); }
public void AddHandler(Lifetime lifetime, IExecutableAction handler) { // _handlers.AddHandler(handler); }
private bool ProcessFilters(IExecutableAction action, ExecuteWhen when) { foreach(FilterDescriptor desc in filters) { if (action.ShouldSkipFilter(desc.FilterType)) { continue; } if ((desc.When & when) != 0) { if (!ProcessFilter(when, desc)) { return false; } } } return true; }
/// <summary> /// /// </summary> /// <param name="action"></param> protected virtual void CreateTransformsFilters(IExecutableAction action) { if (action == null) { return; } ITransformFilterFactory transformFilterFactory = engineContext.Services.TransformFilterFactory; foreach(TransformFilterDescriptor transformFilter in action.TransformFilters) { ITransformFilter filter = transformFilterFactory.Create(transformFilter.TransformFilterType, engineContext.UnderlyingContext.Response.Filter); engineContext.UnderlyingContext.Response.Filter = filter as Stream; } }
/// <summary> /// Performs the rescue. /// </summary> /// <param name="action">The action (can be null in the case of dynamic actions).</param> /// <param name="actionException">The exception.</param> /// <returns></returns> protected virtual bool ProcessRescue(IExecutableAction action, Exception actionException) { if (action != null && action.ShouldSkipRescues) { return false; } Type exceptionType = actionException.GetType(); RescueDescriptor desc = action != null ? action.GetRescueFor(exceptionType) : null; if (desc == null) { desc = GetControllerRescueFor(exceptionType); } if (desc != null) { try { if (desc.RescueController != null) { CreateAndProcessRescueController(desc, actionException); } else { context.SelectedViewName = Path.Combine("rescues", desc.ViewName); ProcessView(); } return true; } catch(Exception exception) { // In this situation, the rescue view could not be found // So we're back to the default error exibition if (logger.IsFatalEnabled) { logger.Fatal("Failed to process rescue view. View name " + context.SelectedViewName, exception); } } } return false; }
/// <summary> /// Execute Action against the id of the last created record /// </summary> /// <typeparam name="T"></typeparam> /// <param name="implementation"></param> /// <returns></returns> public IRecordService <TID> ExecuteAction <T>(IExecutableAction <T, TID> implementation) { implementation.Execute(CreatedRecords.Last().Key); return(this); }