public ActionManager(IEngineContext context)
{
undo = new Stack<IUserAction>();
redo = new Stack<IUserAction>();
this.context = context;
}
/// <summary>
/// Calculates the param points. Implementers should return value equals or greater than
/// zero indicating whether the parameter can be bound successfully. The greater the value (points)
/// the more successful the implementation indicates to the framework
/// </summary>
/// <param name="context">The context.</param>
/// <param name="controller">The controller.</param>
/// <param name="controllerContext">The controller context.</param>
/// <param name="parameterInfo">The parameter info.</param>
/// <returns>
/// </returns>
public int CalculateParamPoints(IEngineContext context, IController controller, IControllerContext controllerContext, ParameterInfo parameterInfo)
{
var token = context.Request[parameterName];
if (CanConvert(parameterInfo.ParameterType, token))
return 10;
return 0;
}
public virtual void Setup()
{
response = new StubResponse();
var url = new UrlInfo("eleutian.com", "www", virtualDirectory, "http", 80,
Path.Combine(Path.Combine("Area", "Controller"), "Action"), "Area", "Controller", "Action", "rails", "");
var stubEngineContext = new StubEngineContext(new StubRequest(), response, new StubMonoRailServices(), url)
{
Server = MockRepository.GenerateMock<IServerUtility>()
};
railsContext = stubEngineContext;
serverUtility = railsContext.Server;
argumentConversionService = MockRepository.GenerateMock<IArgumentConversionService>();
controller = new TestController();
controller.Contextualize(railsContext, MockRepository.GenerateStub<IControllerContext>());
parameters = new Hashtable();
services = MockRepository.GenerateMock<ICodeGeneratorServices>();
services.Expect(s => s.ArgumentConversionService).Return(argumentConversionService).Repeat.Any();
services.Expect(s => s.Controller).Return(controller).Repeat.Any();
services.Expect(s => s.RailsContext).Return(railsContext).Repeat.Any();
argumentConversionService.Expect(s => s.CreateParameters()).Return(parameters).Repeat.Any();
}
public void LoadContent(GraphicsDevice graphicsDevice, IEngineContext context)
{
this.context = context;
this.startpoint = GetNegativeOne();
this.endpoint = GetNegativeOne();
}
public bool Perform(ExecuteWhen exec, IEngineContext context, IController controller, IControllerContext controllerContext)
{
/*
ArrayList admins = new ArrayList();
admins.Add("jpino");
admins.Add("logas");
admins.Add("lmolina");
if (admins.Contains (context.CurrentUser.Identity.Name.ToLower()))
return true;
else {
context.Flash["TypeMsg"] = "alert alert-error";
context.Flash["Msg"] = "Error : No eres admin";
context.Response.RedirectToUrl ("/");
return false;
}
*/
if (context.CurrentUser.IsInRole ("admin"))
return true;
else {
context.Flash["TypeMsg"] = "alert alert-error";
context.Flash["Msg"] = "Error : No eres admin";
context.Response.RedirectToUrl ("/");
return false;
}
}
public void LoadEngineContext(IEngineContext context)
{
this.context = context;
this.soundpath = context.Configuration[EngineConfigurationName.SoundsRoot];
this.isloaded = true;
}
/// <summary>
/// Sets the context.
/// </summary>
/// <param name="context">The context.</param>
public override void SetContext(IEngineContext context)
{
base.SetContext(context);
urlBuilder = (IUrlBuilder) context.GetService(typeof(IUrlBuilder));
currentUrl = context.UrlInfo;
}
/// <summary>
/// Sets the context for the controller
/// </summary>
/// <param name="engineContext">The engine context.</param>
/// <param name="context">The controller context.</param>
public virtual void Contextualize(IEngineContext engineContext, IControllerContext context)
{
this.context = context;
SetEngineContext(engineContext);
renderingSupport = new RenderingSupport(context, engineContext);
isContextualized = true;
}
public static void SetAuthCookie(IEngineContext context, User user)
{
var username = user.GetType().FullName + "_" + user.Id;
FormsAuthentication.SetAuthCookie(username, true);
context.CurrentUser = user;
Thread.CurrentPrincipal = user;
}
public static User Authenticate(IEngineContext context)
{
var cookieText = context.Request.ReadCookie(FormsAuthentication.FormsCookieName);
if (string.IsNullOrEmpty(cookieText))
{
return null;
}
if (context.CurrentUser.Identity.IsAuthenticated == false)
throw new SecurityException("Er is geen gebruiker ingelogd");
int userId;
var name = context.CurrentUser.Identity.Name;
name = name.Replace(typeof(User).FullName + "_", string.Empty);
var result = int.TryParse(name, out userId);
if (result == false)
{
throw new SecurityException("De gebruikersidentificatie is niet geldig");
}
var user = User.Find(userId);
if (user == null)
{
throw new SecurityException("Deze gebruiker staat niet in de database");
}
context.CurrentUser = user;
Thread.CurrentPrincipal = user;
return user;
}
public NavData GetNav(IEngineContext context, string section)
{
Logger.Debug("Getting nav for {0}", section);
if (section == "navigation")
{
return new NavData
{
Items = new[]
{
Item(context, "Home", "home", "index"),
Item(context, "About", "home", "about"),
Item(context, "Login", "account", "login")
}
};
}
if (section == "contents")
{
return new NavData
{
Items = new[]
{
Item(context, "Products", "products", "index"),
Item(context, "About", "home", "about"),
Item(context, "Contact Us", "home", "contact"),
Item(context, "Register", "account", "register")
}
};
}
throw new ApplicationException("Unknown nav section " + section);
}
protected override void OnAfterRendering(IEngineContext context, IController controller,
IControllerContext controllerContext){
var mvc = MvcContext.Create((Controller) controller);
var logname = acl.token(mvc).Replace("/", ".").Substring(1);
var log = logger.get(logname);
log.info(() => myapp.usrName + "\t\tAFTER_RENDER:\t" + acl.token(mvc));
}
/// <summary>
/// Invokes the next handler.
/// </summary>
/// <param name="context">The context.</param>
protected void InvokeNext(IEngineContext context)
{
if (nextHandler != null)
{
nextHandler.Process(context);
}
}
public void LoadEngineContext(IEngineContext context)
{
if(context != null)
this.worldmanager = context.WorldManager;
this.isloaded = true;
}
protected override void OnAfterRendering(IEngineContext context, IController controller,
IControllerContext controllerContext){
if (writeAfterAction){
return;
}
doLog(context);
}
public void Init()
{
mocks = new MockRepository();
factory = new SparkViewFactory();
engineContext = mocks.CreateMock<IEngineContext>();
server = new MockServerUtility();
request = mocks.CreateMock<IRequest>();
response = mocks.CreateMock<IResponse>();
controller = mocks.CreateMock<IController>();
controllerContext = mocks.CreateMock<IControllerContext>();
routingEngine = mocks.CreateMock<IRoutingEngine>();
output = new StringWriter();
helpers = new HelperDictionary();
propertyBag = new Dictionary<string, object>();
flash = new Flash();
session = new Dictionary<string, object>();
requestParams = new NameValueCollection();
contextItems = new Dictionary<string, object>();
SetupResult.For(engineContext.Server).Return(server);
SetupResult.For(engineContext.Request).Return(request);
SetupResult.For(engineContext.Response).Return(response);
SetupResult.For(engineContext.CurrentController).Return(controller);
SetupResult.For(engineContext.CurrentControllerContext).Return(controllerContext);
SetupResult.For(engineContext.Flash).Return(flash);
SetupResult.For(engineContext.Session).Return(session);
SetupResult.For(engineContext.Items).Return(contextItems);
SetupResult.For(request.Params).Return(requestParams);
SetupResult.For(controllerContext.LayoutNames).Return(new[] { "default" });
SetupResult.For(controllerContext.Helpers).Return(helpers);
SetupResult.For(controllerContext.PropertyBag).Return(propertyBag);
SetupResult.For(routingEngine.IsEmpty).Return(true);
var urlBuilder = new DefaultUrlBuilder(server, routingEngine);
var serviceProvider = mocks.CreateMock<IServiceProvider>();
var viewSourceLoader = new FileAssemblyViewSourceLoader("Views");
SetupResult.For(serviceProvider.GetService(typeof(IViewSourceLoader))).Return(viewSourceLoader);
SetupResult.For(serviceProvider.GetService(typeof(ILoggerFactory))).Return(new NullLogFactory());
SetupResult.For(serviceProvider.GetService(typeof(ISparkViewEngine))).Return(null);
SetupResult.For(serviceProvider.GetService(typeof(IUrlBuilder))).Return(urlBuilder);
SetupResult.For(serviceProvider.GetService(typeof(IViewComponentFactory))).Return(null);
mocks.Replay(serviceProvider);
SetupResult.For(engineContext.GetService(null)).IgnoreArguments().Do(
new Func<Type, object>(serviceProvider.GetService));
factory.Service(serviceProvider);
manager = new DefaultViewEngineManager();
manager.RegisterEngineForExtesionLookup(factory);
manager.RegisterEngineForView(factory);
}
public void Init()
{
mocks = new MockRepository();
MockServices services = new MockServices();
services.ViewSourceLoader = new FileAssemblyViewSourceLoader("Views");
services.AddService(typeof(IViewSourceLoader), services.ViewSourceLoader);
viewComponentFactory = new DefaultViewComponentFactory();
viewComponentFactory.Initialize();
services.AddService(typeof(IViewComponentFactory), viewComponentFactory);
services.AddService(typeof(IViewComponentRegistry), viewComponentFactory.Registry);
controller = mocks.DynamicMock<IController>();
engineContext = new MockEngineContext(new UrlInfo("", "Home", "Index", "/", "castle"));
controllerContext = new ControllerContext();
factory = new SparkViewFactory();
factory.Service(services);
engineContext.AddService(typeof(IViewComponentFactory), viewComponentFactory);
engineContext.AddService(typeof(IViewComponentRegistry), viewComponentFactory.Registry);
manager = new DefaultViewEngineManager();
manager.RegisterEngineForExtesionLookup(factory);
manager.RegisterEngineForView(factory);
}
/// <summary>
/// Creates the JS code generator info. Temporarily on IViewEngineManager
/// </summary>
/// <param name="engineContext">The engine context.</param>
/// <param name="controller">The controller.</param>
/// <param name="controllerContext">The controller context.</param>
/// <returns></returns>
public JSCodeGeneratorInfo CreateJSCodeGeneratorInfo(IEngineContext engineContext, IController controller,
IControllerContext controllerContext)
{
var codeGen = new JSCodeGenerator();
return new JSCodeGeneratorInfo(codeGen, new PrototypeGenerator(codeGen), new object[0], new object[0]);
}
/// <summary>
///
/// </summary>
/// <param name="context"></param>
public static void RedirectToLoginAction(IEngineContext context)
{
// redirect to login or automatically relogin using cookie.
NameValueCollection queryStringParameters = new NameValueCollection();
queryStringParameters.Add("returnUrl", context.Request.Url);
context.Response.Redirect("authentication", "login", queryStringParameters);
}
public void Undo(IEngineContext context)
{
var world = context.WorldManager.GetWorlds().Values.FirstOrDefault();
var map = world.Maps.Values.FirstOrDefault();
map.Map.SetLayerValue(x, y, layer, lastvalue);
}
private void doLog(IEngineContext context){
if (waserror){
return;
}
try{
var conversation = myapp.conversation.Current;
var stopwatch = conversation.Data[_stopwatch] as DateRange;
stopwatch.Finish = DateTime.Now;
conversation.Data.Remove(_stopwatch);
var log = storage.New();
log.Range = stopwatch;
log.Elapsed = (int) (stopwatch.Finish - stopwatch.Start).TotalMilliseconds;
log.Usr = myapp.usrName;
log.System = context.Request.Uri.GetLeftPart(UriPartial.Path).find(@"^\w+://[^/]+?/\w+");
log.Url = context.Request.Url;
prepareLogEntry(log, context);
using (var s = new TemporaryTransactionSession()){
storage.Save(log);
s.Commit();
}
}
catch (Exception ex){
logger.get("comdiv.sys").Error("operation log error", ex);
waserror = true;
}
}
public AddComment(NewsPost post, Comment comment, IEngineContext context)
{
this.post = post;
this.comment = comment;
this.context = context;
this.context = context;
}
public void Trigger(BaseCharacter character, IEngineContext context)
{
String worldname = this.Parameters["World"];
String pos = this.Parameters["EntryPointName"];
IMapEvent tmpevent = null;
MapHeader tmpheader = null;
foreach(MapHeader header in context.WorldManager.GetWorld(worldname).Maps.Values)
{
tmpevent = context.EventProvider.GetMapsEvents(header.Map).Where( m => m.GetStringType() == "EntryPoint" && m.Parameters["Name"] == pos).FirstOrDefault();
if(tmpevent != null)
{
tmpheader = header;
break;
}
}
if(tmpevent == null || tmpheader == null)
return;
context.MovementProvider.EndMove (character, false, true);
character.WorldName = worldname;
character.Location = new MapPoint (tmpevent.Rectangle.X + tmpheader.MapLocation.X,
tmpevent.Rectangle.Y + tmpheader.MapLocation.Y).ToScreenPoint ();
character.CurrentMap = null;
context.SceneProvider.Cameras["camera1"].CenterOnCharacter (character);
}
public object Bind(IEngineContext context, IController controller, IControllerContext controllerContext, ParameterInfo parameterInfo)
{
string token = context.Request[parameterInfo.Name];
Type type = parameterInfo.ParameterType;
if (CanConvert(type, token))
return Convert.ChangeType(token, type);
return value;
}
protected override bool OnBeforeAction(IEngineContext context, IController controller,
IControllerContext controllerContext){
// ioc.get<IRequestConversationHandler>().PrepareConversationOnBegin();
((Controller) controller).PropertyBag["conversation"] = myapp.conversation.Current;
((Controller) controller).PropertyBag["conversationKey"] = myapp.conversation.Current.Code;
return true;
}
public void Init(IControllerContext controllerContext, IEngineContext engineContext)
{
Invariant.ArgumentNotNull(controllerContext, "controllerContext");
ViewContext = engineContext;
PropertyBag = controllerContext.PropertyBag;
}
/// <summary>
/// Binds the specified parameters for the action.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="controller">The controller.</param>
/// <param name="controllerContext">The controller context.</param>
/// <param name="parameterInfo">The parameter info.</param>
/// <returns>
/// </returns>
public object Bind(IEngineContext context, IController controller, IControllerContext controllerContext, ParameterInfo parameterInfo)
{
var token = context.Request[parameterName];
if (CanConvert(parameterInfo.ParameterType, token) == false)
return null;
return Convert.ChangeType(token, parameterInfo.ParameterType);
}
protected override bool OnBeforeAction(IEngineContext context, IController controller,
IControllerContext controllerContext){
var mvc = MvcContext.Create((Controller) controller);
var logname = acl.token(mvc).Replace("/", ".").Substring(1);
var log = logger.get(logname);
log.info(() => myapp.usrName + "\t\tBEFORE_ACTION:\t" + acl.token(mvc));
return true;
}
/// <summary>
/// Initializes a new instance of the <see cref="BaseHttpHandler"/> class.
/// </summary>
/// <param name="engineContext">The engine context.</param>
/// <param name="controller">The controller.</param>
/// <param name="controllerContext">The controller context.</param>
/// <param name="sessionless">if set to <c>true</c> then we wont have a session to work.</param>
protected BaseHttpHandler(IEngineContext engineContext,
IController controller, IControllerContext controllerContext, bool sessionless)
{
this.controller = controller;
this.controllerContext = controllerContext;
this.engineContext = engineContext;
this.sessionless = sessionless;
}
protected override void OnAfterAction(IEngineContext context, IController controller,
IControllerContext controllerContext){
var partitions = Container.get<IPartitionsSource>().GetPartitions(controller);
((Controller) controller).PropertyBag["partitions"] = partitions;
foreach (var partition in partitions){
partition.Execute(controller);
}
}
public virtual void Initialize(AspViewEngine newViewEngine, TextWriter output, IEngineContext newContext,
IController newController, IControllerContext newControllerContext)
{
if (initialized)
{
throw new ApplicationException("Sorry, but a view instance cannot be initialized twice");
}
initialized = true;
viewEngine = newViewEngine;
outputWriter = output;
context = newContext;
controller = newController;
controllerContext = newControllerContext;
InitProperties();
dictionaryAdapterFactory = new DictionaryAdapterFactory();
outputWriters = new Stack <TextWriter>();
viewFilters = new Stack <IViewFilter>();
}
public override object Execute(IEngineContext context, IController controller, IControllerContext controllerContext)
{
base.Execute(context, controller, controllerContext);
var method = context.GetParameter("_method") ?? context.Request.HttpMethod;
switch (method.ToUpper())
{
case "GET":
return(ExecuteList(context, controller, controllerContext));
case "POST":
controllerContext.Action = "create";
return(ExecuteCreate(context, controller, controllerContext));
default:
throw new MonoRailException("Unsupported method.");
}
}
/// <summary>
/// Implementors should perform the action
/// on the exception. Note that the exception
/// is available in <see cref="IEngineContext.LastException"/>
/// </summary>
/// <param name="context"></param>
public override void Process(IEngineContext context)
{
var emailSender = (IEmailSender)context.GetService(typeof(IEmailSender));
var message = BuildStandardMessage(context);
try
{
emailSender.Send(mailFrom, mailTo,
"MonoRail Exception: " + context.LastException.GetType().Name, message);
}
catch (Exception)
{
// We ignore errors during send
}
InvokeNext(context);
}
public object Bind(IEngineContext context, IController controller, IControllerContext controllerContext,
ParameterInfo parameterInfo)
{
var key = parameterInfo.Name;
var ret = new List <HttpPostedFile>();
var httpFileCollection = context.UnderlyingContext.Request.Files;
for (var i = 0; i < httpFileCollection.Count; i++)
{
if (httpFileCollection.GetKey(i) == key)
{
ret.Add(httpFileCollection[i]);
}
}
return(ret);
}
public override void RenderStaticWithinLayout(String contents, IEngineContext context, IController controller,
IControllerContext controllerContext)
{
var ctx = CreateContext(context, controller, controllerContext);
AdjustContentType(context);
var hasLayout = controllerContext.LayoutNames != null && controllerContext.LayoutNames.Length != 0;
if (hasLayout)
{
ProcessLayout(contents, controller, controllerContext, ctx, context, context.Response.Output);
}
else
{
context.Response.Output.Write(contents);
}
}
public InstanceInfo(StrongIdentifierValue name, IEngineContext context, IStorage parentStorage)
: base(context.Logger)
{
Name = name;
_context = context;
_localCodeExecutionContext = new LocalCodeExecutionContext();
var localStorageSettings = RealStorageSettingsHelper.Create(context, parentStorage);
_storage = new LocalStorage(localStorageSettings);
_localCodeExecutionContext.Storage = _storage;
_localCodeExecutionContext.Holder = Name;
#if DEBUG
//Log($"_localCodeExecutionContext = {_localCodeExecutionContext}");
#endif
_triggersResolver = new TriggersResolver(context);
}
public override object Bind(IEngineContext context, IController controller, IControllerContext controllerContext, ParameterInfo parameterInfo)
{
var binder = (ARDataBinder)CreateBinder();
var validatorAccessor = controller as IValidatorAccessor;
ConfigureValidator(validatorAccessor, binder);
binder.AutoLoad = AutoLoad;
binder.TreatEmptyGuidAsNull = TreatEmptyGuidAsNull;
var node = context.Request.ObtainParamsNode(From);
var instance = binder.BindObject(parameterInfo.ParameterType, Prefix, Exclude, Allow, Expect, node);
BindInstanceErrors(validatorAccessor, binder, instance);
PopulateValidatorErrorSummary(validatorAccessor, binder, instance);
return(instance);
}
/// <summary>
/// Implementors should perform the action
/// on the exception. Note that the exception
/// is available in <see cref="IEngineContext.LastException"/>
/// </summary>
/// <param name="context"></param>
public override void Process(IEngineContext context)
{
var factory = (ILoggerFactory)context.GetService(typeof(ILoggerFactory));
if (factory == null)
{
// No factory configured, but we can throw exception
return;
}
if (context.CurrentController != null)
{
var logger = factory.Create(context.CurrentController.GetType());
logger.Error(BuildStandardMessage(context));
}
InvokeNext(context);
}
/// <summary>
/// Executes the basic flow which is
/// <list type="number">
/// <item><description>Resolve the <see cref="ActiveRecordModel"/></description></item>
/// <item><description>Resolve the layout (if not is associated with the controller, defaults to "scaffold")</description></item>
/// <item><description>Invokes <see cref="PerformActionProcess"/> which should perform the correct process for this action</description></item>
/// <item><description>Resolves the template name that the developer might provide by using <see cref="ComputeTemplateName"/></description></item>
/// <item><description>If the template exists, renders it. Otherwise invokes <see cref="RenderStandardHtml"/></description></item>
/// </list>
/// </summary>
/// <param name="engineContext">The engine context.</param>
/// <param name="controller">The controller.</param>
/// <param name="controllerContext">The controller context.</param>
public object Execute(IEngineContext engineContext, IController controller, IControllerContext controllerContext)
{
// Cancel any rendering
controllerContext.SelectedViewName = null;
// We make sure the code is always surrounded by a SessionScope.
// If none is found, we create one
SessionScope scope = null;
if (SessionScope.Current == null)
{
scope = new SessionScope(FlushAction.Never);
}
try
{
model = GetARModel();
PerformActionProcess(engineContext, controller, controllerContext);
var templateName = ComputeTemplateName(controllerContext);
if (engineContext.Services.ViewEngineManager.HasTemplate(templateName))
{
controllerContext.SelectedViewName = templateName;
}
else
{
controllerContext.SelectedViewName = null;
RenderStandardHtml(engineContext, controller, controllerContext);
}
}
finally
{
if (scope != null)
{
scope.Dispose();
}
}
return(null);
}
public EngineRestScalar([NotNull] IEngineContext <TItem> context, [NotNull] IDeferredItem <TItem> item, [NotNull] INamedField <TItem> field)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
if (item == null)
{
throw new ArgumentNullException(nameof(item));
}
if (field == null)
{
throw new ArgumentNullException(nameof(field));
}
_context = context;
_item = item;
_field = field;
}
public virtual void Setup()
{
_mocks = new MockRepository();
_services = _mocks.DynamicMock <ICodeGeneratorServices>();
_response = new StubResponse();
UrlInfo url =
new UrlInfo("eleutian.com", "www", _virtualDirectory, "http", 80,
Path.Combine(Path.Combine("Area", "Controller"), "Action"), "Area", "Controller", "Action", "rails",
"");
_railsContext =
new StubEngineContext(new StubRequest(), _response, new StubMonoRailServices(), url);
((StubEngineContext)_railsContext).Server = _mocks.DynamicMock <IServerUtility>();
_serverUtility = _railsContext.Server;
_argumentConversionService = _mocks.DynamicMock <IArgumentConversionService>();
_controller = new TestController();
}
public void Bind(IEngineContext context,
IController controller,
IControllerContext controllerContext,
Type returnType,
object returnValue)
{
if (returnValue == null)
{
return;
}
var type = returnValue.GetType();
var flags = BindingFlags.Public | BindingFlags.Instance | BindingFlags.GetProperty;
foreach (var property in type.GetProperties(flags))
{
controllerContext.PropertyBag[property.Name] = property.GetValue(returnValue, null);
}
}
public override void Process(string templateName, string layoutName, TextWriter output,
IDictionary <string, object> parameters)
{
IEngineContext engineContext = null;
if (HttpContext.Current != null)
{
engineContext = (IEngineContext)HttpContext.Current.Items["currentmrengineinstance"];
}
var controllerContext = new BasicControllerContext
{
SelectedViewName = templateName
};
if (!string.IsNullOrEmpty(layoutName))
{
controllerContext.LayoutNames = new[] { layoutName }
}
;
if (parameters != null)
{
foreach (var parameter in parameters)
{
controllerContext.PropertyBag[parameter.Key] = parameter.Value;
}
}
if (engineContext != null)
{
var controller = engineContext.CurrentController as Controller;
if (controller != null)
{
foreach (string key in controller.Helpers.Keys)
{
controllerContext.Helpers.Add(key, controller.Helpers[key]);
}
}
}
Process(templateName, output, engineContext, null, controllerContext);
}
public static void ErrorMessages(this IEngineContext context, int statuscode, params string[] messages)
{
context.Response.StatusCode = statuscode;
if (context.Flash["errormessages"] != null)
{
var errormessages = context.Flash["errormessages"] as List <string>;
if (errormessages == null)
{
errormessages = new List <string>();
context.Flash["errormessages"] = errormessages;
}
errormessages.AddRange(messages);
}
else
{
var errormessages = new List <string>(messages);
context.Flash["errormessages"] = errormessages;
}
}
public override void Process(string templateName, TextWriter output, IEngineContext context, IController controller,
IControllerContext controllerContext)
{
var viewName = Path.GetFileName(templateName);
var location = Path.GetDirectoryName(templateName);
string masterName = null;
if (controllerContext.LayoutNames != null)
{
masterName = string.Join(" ", controllerContext.LayoutNames);
}
var view = (SparkView)Engine.CreateInstance(location, viewName, masterName);
view.Contextualize(context, controllerContext, this);
view.Logger = Logger;
view.RenderView(output);
}
/// <summary>
/// This takes a filename and return an instance of the view ready to be used.
/// If the file does not exist, an exception is raised
/// The cache is checked to see if the file has already been compiled, and it had been
/// a check is made to see that the compiled instance is newer then the file's modification date.
/// If the file has not been compiled, or the version on disk is newer than the one in memory, a new
/// version is compiled.
/// Finally, an instance is created and returned
/// </summary>
public BrailBase GetCompiledScriptInstance(
string file,
TextWriter output,
IEngineContext context,
IController controller, IControllerContext controllerContext)
{
var batch = options.BatchCompile;
// normalize filename - replace / or \ to the system path seperator
var filename = file.Replace('/', Path.DirectorySeparatorChar)
.Replace('\\', Path.DirectorySeparatorChar);
filename = EnsurePathDoesNotStartWithDirectorySeparator(filename);
Log("Getting compiled instnace of {0}", filename);
Type type;
if (compilations.ContainsKey(filename))
{
type = (Type)compilations[filename];
if (type != null)
{
Log("Got compiled instance of {0} from cache", filename);
return(CreateBrailBase(context, controller, controllerContext, output, type));
}
// if file is in compilations and the type is null,
// this means that we need to recompile. Since this usually means that
// the file was changed, we'll set batch to false and procceed to compile just
// this file.
Log("Cache miss! Need to recompile {0}", filename);
batch = false;
}
type = CompileScript(filename, batch);
if (type == null)
{
throw new MonoRailException("Could not find a view with path " + filename);
}
return(CreateBrailBase(context, controller, controllerContext, output, type));
}
public bool Perform(ExecuteWhen exec,
IEngineContext context,
IController controller,
IControllerContext controllerContext)
{
controllerContext.PropertyBag["ViewName"] =
Path.GetFileNameWithoutExtension(context.Request.Uri.Segments.Last());
controllerContext.PropertyBag["LocalPath"] =
Path.GetFileNameWithoutExtension(context.Request.Uri.LocalPath);
if (context.Session["AdminId"] != null)
{
ArHelper.WithSession(s => {
context.Session["Admin"] = s.Get <Admin>(context.Session["AdminId"]);
});
}
controllerContext.PropertyBag["AccessEditLink"] = context.Session["Admin"] != null;
controllerContext.PropertyBag["SiteAdress"] = context.ApplicationPath + "/";
return(true);
}
/// <summary>
/// Creating default stub and mocks
/// </summary>
protected virtual void CreateDefaultStubsAndMocks()
{
writer = writer ?? new StringWriter();
engine = engine ?? new AspViewEngine();
engine.GetType().GetField("options", BindingFlags.Static | BindingFlags.NonPublic).SetValue(engine, new AspViewEngineOptions());
cookies = cookies ?? new Dictionary <string, HttpCookie>();
request = request ?? new StubRequest(cookies);
response = response ?? new StubResponse(cookies);
url = url ?? new UrlInfo("", "Stub", "Stub");
trace = trace ?? new StubTrace();
propertyBag = propertyBag ?? new Hashtable();
monoRailServices = monoRailServices ?? new StubMonoRailServices();
context = context ?? new StubEngineContext(request, response, monoRailServices, url);
AspViewEngine.InitializeViewsStack(context);
flash = flash ?? context.Flash;
controller = controller ?? new ControllerStub();
controllerContext = controllerContext ?? new ControllerContextStub();
controllerContext.PropertyBag = propertyBag;
context.Flash = flash;
}
/// <summary>
/// Gets the name of the next step.
/// </summary>
/// <param name="engineContext">The engine context.</param>
/// <param name="controller">The controller.</param>
/// <param name="controllerContext">The controller context.</param>
/// <returns></returns>
public static String GetNextStepName(IEngineContext engineContext, IController controller, IControllerContext controllerContext)
{
if (!IsOnWizard(engineContext, controllerContext))
{
return(null);
}
var wizardName = ConstructWizardNamespace(controllerContext);
var curIndex = (int)engineContext.Session[wizardName + "currentstepindex"];
var stepList = (IList)engineContext.Items["wizard.step.list"];
if ((curIndex + 1) < stepList.Count)
{
return((String)stepList[curIndex + 1]);
}
return(null);
}
/// <summary>
/// Initializes the specified service instance.
/// </summary>
/// <param name="serviceInstance">The service instance.</param>
/// <param name="engineContext">The engine context.</param>
public void Initialize(object serviceInstance, IEngineContext engineContext)
{
var controller = engineContext.CurrentController;
var controllerCtx = engineContext.CurrentControllerContext;
var ctxAware = serviceInstance as IContextAware;
if (ctxAware != null)
{
ctxAware.SetContext(engineContext);
}
var aware = serviceInstance as IControllerAware;
if (aware != null)
{
aware.SetController(controller, controllerCtx);
}
Initialize(serviceInstance, engineContext.Services);
}
public void Init()
{
_context = MockRepository.GenerateMock <IEngineContext>();
_context
.Stub(x => x.Services)
.Return(MockRepository.GenerateMock <IMonoRailServices>());
_context.Services
.Stub(x => x.CacheProvider)
.Return(MockRepository.GenerateMock <ICacheProvider>());
var httpContext = new HttpContext(new HttpRequest("", "http://localhost", ""), new HttpResponse(null));
_context
.Stub(x => x.UnderlyingContext)
.Return(httpContext);
foreach (var key in HttpRuntime.Cache.OfType <DictionaryEntry>().Select(x => x.Key))
{
HttpRuntime.Cache.Remove(Convert.ToString(key));
}
}
public override void ProcessPartial(String partialName, TextWriter output, IEngineContext context,
IController controller, IControllerContext controllerContext)
{
var ctx = CreateContext(context, controller, controllerContext);
var view = ResolveTemplateName(partialName);
try
{
var template = velocity.GetTemplate(view);
template.Merge(ctx, output);
}
catch (Exception ex)
{
if (Logger.IsErrorEnabled)
{
Logger.Error("Could not render partial", ex);
}
throw new MonoRailException("Could not render partial " + view, ex);
}
}
/// <summary>
/// Selects the an action.
/// </summary>
/// <param name="engineContext">The engine context.</param>
/// <param name="controller">The controller.</param>
/// <param name="context">The context.</param>
/// <param name="actionType">Type of the action.</param>
/// <returns></returns>
public IExecutableAction Select(IEngineContext engineContext, IController controller, IControllerContext context,
ActionType actionType)
{
var actionName = context.Action;
// Look for the target method
var actionMethod = SelectActionMethod(controller, context, context.Action, actionType);
if (actionMethod == null)
{
// If we couldn't find a method for this action, look for a dynamic action
IDynamicAction dynAction = null;
if (context.DynamicActions.ContainsKey(actionName))
{
dynAction = context.DynamicActions[actionName];
}
if (dynAction != null)
{
return(new DynamicActionExecutor(dynAction));
}
}
else
{
var actionDesc = context.ControllerDescriptor.GetAction(actionMethod);
return(new ActionMethodExecutor(actionMethod, actionDesc ?? new ActionMetaDescriptor()));
}
var executableAction = RunSubSelectors(engineContext, controller, context, actionType);
if (executableAction != null)
{
return(executableAction);
}
// Last try:
return(ResolveDefaultMethod(context.ControllerDescriptor, controller, context, actionType));
}
/// <summary>
/// Gets the locale id.
/// </summary>
/// <param name="context">The context.</param>
/// <returns></returns>
private String GetLocaleId(IEngineContext context)
{
switch (setup.Store)
{
case RequestStore.Session:
return(context.Session[setup.Key] as String);
case RequestStore.Cookie:
return(context.Request.ReadCookie(setup.Key));
case RequestStore.QueryString:
return(context.Request.QueryString[setup.Key]);
case RequestStore.Form:
return(context.Request.Form[setup.Key]);
case RequestStore.Params:
return(context.Request.Params[setup.Key]);
}
return(null);
}
private BrailBase CreateBrailBase(IEngineContext context, IController controller, IControllerContext controllerContext,
TextWriter output, Type type)
{
var constructor = (ConstructorInfo)constructors[type];
if (constructor == null)
{
var message = "Could not find a constructor for " + type + ", but it was found in the compilation cache. Clearing the compilation cache for the type, please try again";
Log(message);
var key = this.typeToFileName[type];
if (key != null)
{
compilations.Remove(key);
}
throw new MonoRailException(message);
}
return(useFastCreateInstance
? FastCreateInstance(type, constructor, output, context, controller, controllerContext)
: ActivatorCreateInstance(type, output, context, controller, controllerContext));
}
/// <summary>
/// Builds the standard message.
/// </summary>
/// <param name="context">The context.</param>
/// <returns></returns>
protected string BuildStandardMessage(IEngineContext context)
{
var sbMessage = new StringBuilder();
sbMessage.Append("Controller details\r\n");
sbMessage.Append("==================\r\n\r\n");
sbMessage.AppendFormat("Url {0}\r\n", context.Request.Url);
sbMessage.AppendFormat("Area {0}\r\n", context.UrlInfo.Area);
sbMessage.AppendFormat("Controller {0}\r\n", context.UrlInfo.Controller);
sbMessage.AppendFormat("Action {0}\r\n", context.UrlInfo.Action);
sbMessage.AppendFormat("Extension {0}\r\n\r\n", context.UrlInfo.Extension);
sbMessage.Append("Exception details\r\n");
sbMessage.Append("=================\r\n\r\n");
sbMessage.AppendFormat("Exception occured at {0}\r\n", DateTime.Now);
RecursiveDumpException(context.LastException, sbMessage, 0);
sbMessage.Append("\r\nEnvironment and params");
sbMessage.Append("\r\n======================\r\n\r\n");
sbMessage.AppendFormat("Machine {0}\r\n", Environment.MachineName);
sbMessage.AppendFormat("ApplicationPath {0}\r\n", context.ApplicationPath);
// sbMessage.AppendFormat("ApplicationPhysicalPath {0}\r\n", context.ApplicationPhysicalPath);
sbMessage.AppendFormat("HttpMethod {0}\r\n", context.Request.HttpMethod);
sbMessage.AppendFormat("UrlReferrer {0}\r\n", context.Request.UrlReferrer);
if (context.CurrentUser != null)
{
sbMessage.AppendFormat("CurrentUser.Name {0}\r\n", context.CurrentUser.Identity.Name);
sbMessage.AppendFormat("CurrentUser.AuthenticationType {0}\r\n", context.CurrentUser.Identity.AuthenticationType);
sbMessage.AppendFormat("CurrentUser.IsAuthenticated {0}\r\n", context.CurrentUser.Identity.IsAuthenticated);
}
DumpDictionary(context.Flash, "Flash", sbMessage);
DumpDictionary(context.Request.QueryString, "QueryString", sbMessage);
DumpDictionary(context.Request.Form, "Form", sbMessage);
DumpDictionary(context.Session, "Session", sbMessage);
return(sbMessage.ToString());
}
public virtual AspViewBase GetView(string fileName, TextWriter output, IEngineContext context, IController controller, IControllerContext controllerContext)
{
fileName = NormalizeFileName(fileName);
string className = GetClassName(fileName);
if (needsRecompiling)
{
CompileViewsInMemory();
needsRecompiling = false;
}
Type viewType = compilations[className] as Type;
if (viewType == null)
{
throw new AspViewException("Cannot find view type for {0}.",
fileName);
}
// create a view instance
AspViewBase theView;
try
{
theView = CreateView(viewType, output, context, controller, controllerContext);
}
catch (Exception ex)
{
throw new AspViewException(string.Format(
"Cannot create view instance from '{0}'.",
fileName), ex);
}
if (theView == null)
{
throw new AspViewException(string.Format(
"Cannot find view '{0}'", fileName));
}
return(theView);
}
public virtual object Execute(IEngineContext context, IController controller, IControllerContext controllerContext)
{
SetContext(context);
controllerContext.PropertyBag["templateobjectname"] = TemplateObjectName;
Orderbys.AddRange(
context.CurrentController.GetType().GetAttrs <QueryOrderByAttribute>().Select(qo => qo.OrderBy)
);
Fetches.AddRange(
context.CurrentController.GetType().GetAttrs <FetchAttribute>()
.SelectMany(a => a.FetchProperties)
);
Queryfilters.AddRange(
context.CurrentController.GetType().GetAttrs <QueryFilterAttribute>().Select(attr => {
var cw = attr as IContextAware;
if (cw != null)
{
cw.SetContext(context);
}
return(attr.QueryFilter);
})
);
DontDoManyFetch = controller.GetType().GetAttr <DontDoManyFetch>() == null;
CreateAllowedProperties = controller.GetType().GetAttrs <CreateExcludeAttribute>().Select(a => a.Properties).FirstOrDefault();
CreateExcludedProperties = controller.GetType().GetAttrs <CreateIncludeAttribute>().Select(a => a.Properties).FirstOrDefault();
var idattr = controller.GetType().GetAttr <IdAttribute>();
IdParameter = idattr != null ? idattr.IdParam : "id";
var pgattr = controller.GetType().GetAttr <PageSizeAttribute>();
if (pgattr != null)
{
PageSize = pgattr.PageSize;
}
return(null);
}
public object ExecuteList(IEngineContext context, IController controller, IControllerContext controllerContext)
{
OnPreList(controller);
try {
var source = context.Request.HttpMethod == "GET" ? context.Request.QueryString : context.Request.Form;
var store = BuildCompositeNode(source, Queryfilters, false);
IFutureValue <long> count = null;
Query
.AddOrderBy(Orderbys)
.AddQueryFilter(Queryfilters)
.SetupPaging(PageSize)
.AddEager(Fetches);
var items = Query.Run(store, ref count);
if (Query.PageSize == 0)
{
controllerContext.PropertyBag["items"] = new CustomPage <T>(items, Query.Page, Convert.ToInt32(count.Value), Convert.ToInt32(count.Value));
}
else
{
controllerContext.PropertyBag["items"] = new LazyPage <T>(items, Query.Page, Query.PageSize, count);
}
OnPostList(controller, items);
} catch (Exception ex) {
context.HandleError(500, ex);
} finally {
controllerContext.PropertyBag["qs"] = Query.Querystring;
foreach (var key in Query.Querystring.Keys)
{
controllerContext.PropertyBag[key] = Query.Querystring[key];
}
}
return(null);
}
public override void ProcessPartial(string partialName, TextWriter output, IEngineContext context,
IController controller, IControllerContext controllerContext)
{
Log("Generating partial for {0}", partialName);
try
{
var file = ResolveTemplateName(partialName);
var view = GetCompiledScriptInstance(file, output, context, controller, controllerContext);
Log("Executing partial view {0}", partialName);
view.Run();
Log("Finished executing partial view {0}", partialName);
}
catch (Exception ex)
{
if (Logger != null && Logger.IsErrorEnabled)
{
Logger.Error("Could not generate JS", ex);
}
throw new MonoRailException("Error generating partial: " + partialName, ex);
}
}
