public override object Execute(ParameterList parameters, FunctionContextContainer context) { IComparable valueA = parameters.GetParameter <IComparable>("ValueA"); IComparable valueB = parameters.GetParameter <IComparable>("ValueB"); return(valueA.CompareTo(valueB)); }
public override object Execute(ParameterList parameters, FunctionContextContainer context) { bool isAndQuery = parameters.GetParameter <bool>("IsAndQuery"); Expression <Func <T, bool> > left = parameters.GetParameter <Expression <Func <T, bool> > >("Left"); Expression <Func <T, bool> > right = parameters.GetParameter <Expression <Func <T, bool> > >("Right"); Expression compound; if (isAndQuery) { Expression leftFilter = Expression.Invoke(left, _dataItem); Expression rightFilter = Expression.Invoke(right, _dataItem); compound = Expression.And(leftFilter, rightFilter); } else { Expression leftFilter = Expression.Invoke(left, _dataItem); Expression rightFilter = Expression.Invoke(right, _dataItem); compound = Expression.Or(leftFilter, rightFilter); } Expression <Func <T, bool> > lambdaExpression = Expression.Lambda <Func <T, bool> >(compound, new ParameterExpression[] { _dataItem }); return(lambdaExpression); }
public override object Execute(ParameterList parameters, FunctionContextContainer context) { SitemapScope SitemapScope; if (parameters.TryGetParameter <SitemapScope>("SitemapScope", out SitemapScope) == false) { SitemapScope = SitemapScope.Current; } Guid pageId = Guid.Empty; switch (SitemapScope) { case SitemapScope.Current: pageId = PageRenderer.CurrentPageId; break; case SitemapScope.Parent: case SitemapScope.Level1: case SitemapScope.Level2: case SitemapScope.Level3: case SitemapScope.Level4: IEnumerable <Guid> pageIds = PageStructureInfo.GetAssociatedPageIds(PageRenderer.CurrentPageId, SitemapScope); pageId = pageIds.FirstOrDefault(); break; default: throw new NotImplementedException("Unhandled SitemapScope type: " + SitemapScope.ToString()); } return(pageId); }
/// <exclude /> public static Control Render(XDocument document, FunctionContextContainer contextContainer, IXElementToControlMapper mapper, IPage page) { using (TimerProfilerFacade.CreateTimerProfiler()) { ExecuteEmbeddedFunctions(document.Root, contextContainer); ResolvePageFields(document, page); NormalizeAspNetForms(document); if (document.Root.Name != Namespaces.Xhtml + "html") { return(new LiteralControl(document.ToString())); } XhtmlDocument xhtmlDocument = new XhtmlDocument(document); NormalizeXhtmlDocument(xhtmlDocument); ResolveRelativePaths(xhtmlDocument); PrioritizeHeadNodex(xhtmlDocument); AppendC1MetaTags(page, xhtmlDocument); LocalizationParser.Parse(xhtmlDocument); return(xhtmlDocument.AsAspNetControl(mapper)); } }
public override object Execute(ParameterList parameters, FunctionContextContainer context) { string commaSeparatedSearchTerms = parameters.GetParameter <string>("CommaSeparatedGuids"); if (!commaSeparatedSearchTerms.IsNullOrEmpty()) { ParameterExpression parameter = Expression.Parameter(typeof(Guid), "g"); IEnumerable <string> guidStrings = commaSeparatedSearchTerms.Split(','); Expression body = null; foreach (string guidString in guidStrings) { Guid temp = new Guid(guidString.Trim()); Expression part = Expression.Equal(parameter, Expression.Constant(temp)); body = body.NestedOr(part); } if (body != null) { return(Expression.Lambda <Func <Guid, bool> >(body, parameter)); } } return((Expression <Func <Guid, bool> >)(f => false)); }
private IDictionary <string, object> parseParameters(FunctionContextContainer functionContextContainer) { var result = new Dictionary <string, object>(); foreach (Param param in Parameters) { param.DataBind(); object value; if (param.Controls.Count == 1 && param.Controls[0] is Function) { var nestedFunction = param.Controls[0] as Function; Type returnType; value = nestedFunction.GetValue(functionContextContainer, out returnType); } else { value = param.Value; } result.Add(param.Name, value); } return(result); }
public override object Execute(ParameterList parameters, FunctionContextContainer context) { var httpContext = HttpContext.Current; if (httpContext?.Response == null) { return(null); } var cache = httpContext.Response.Cache; int maxSeconds = parameters.GetParameter <int>(ParameterName_MaxSeconds); if (maxSeconds <= 0) { cache.SetCacheability(HttpCacheability.NoCache); cache.SetNoServerCaching(); cache.SetNoStore(); } else { cache.SetExpires(DateTime.Now.AddSeconds(maxSeconds)); cache.SetMaxAge(TimeSpan.FromSeconds(maxSeconds)); } return(null); }
public object Execute(ParameterList parameters, FunctionContextContainer context) { /* viewContext is set by returning C1View... if this function is called without using a C1View * it will fallback to a normal route-based execution instead of a ChildAction */ ViewContext viewContext = null; try { viewContext = (ViewContext)context.GetParameterValue("viewContext", typeof(ViewContext)); } catch { } var routeValues = new Dictionary <string, object>(); if (_modelType != null) { var model = Activator.CreateInstance(_modelType); foreach (var parameter in ParameterProfiles) { var name = parameter.Name; var value = parameters.GetParameter(name); _modelType.GetProperty(name).SetValue(model, value); } routeValues.Add("FunctionModel", model); } return(viewContext != null?ExecuteChildAction(routeValues, viewContext) : ExecuteDirectRoute(routeValues)); }
public override object Execute(ParameterList parameters, FunctionContextContainer context) { object valueA = parameters.GetParameter <object>("ValueA"); object valueB = parameters.GetParameter <object>("ValueB"); return(valueA.Equals(valueB)); }
public override object Execute(ParameterList parameters, FunctionContextContainer context) { return(new TitleControl { PrefixToRemove = parameters.GetParameter <string>("PrefixToRemove"), PostfixToRemove = parameters.GetParameter <string>("PostfixToRemove") }); }
// IFunctionResultToXElementMapper public bool TryMakeXEmbedable(FunctionContextContainer contextContainer, object resultObject, out XNode resultElement) { var control = resultObject as Control; if (control == null) { resultElement = null; return(false); } string controlMarkerKey; lock (_controls) { controlMarkerKey = string.Format("[Composite.Function.Render.Asp.Net.Control.{0}]", _controls.Count); _controls.Add(controlMarkerKey, control); } resultElement = XElement.Parse(@"<c1marker:{0} xmlns:c1marker=""{1}"" key=""{2}"" />" .FormatWith(_markerElementName.LocalName, _markerElementName.Namespace, controlMarkerKey)); return(true); }
public override object Execute(ParameterList parameters, FunctionContextContainer context) { string valueToFind = parameters.GetParameter <string>("Value"); Expression <Func <string, bool> > predicate = f => f.Contains(valueToFind); return(predicate); }
public override object Execute(ParameterList parameters, FunctionContextContainer context) { int value = parameters.GetParameter <int>("Value"); Expression <Func <int, bool> > predicate = f => f == value; return(predicate); }
public override object Execute(ParameterList parameters, FunctionContextContainer context) { void SetParametersAction(WebPageBase webPageBase) { foreach (var param in parameters.AllParameterNames) { var parameter = Parameters[param]; object parameterValue = parameters.GetParameter(param); parameter.SetValue(webPageBase, parameterValue); } } try { return(RazorHelper.ExecuteRazorPage(VirtualPath, SetParametersAction, ReturnType, context)); } catch (Exception ex) { EmbedExecutionExceptionSourceCode(ex); throw; } }
public override object Execute(ParameterList parameters, FunctionContextContainer context) { return ($"{Constants.PageIdParamName}:\"{parameters.GetParameter<string>(Constants.PageIdParamName)}\";" + $"{Constants.TypeNameParamName}:\"{parameters.GetParameter<string>(Constants.TypeNameParamName)}\";" + $"{Constants.SitemapScopeIdParamName}:\"{parameters.GetParameter<int>(Constants.SitemapScopeIdParamName)}\";"); }
public override object Execute(ParameterList parameters, FunctionContextContainer context) { IEnumerable <string> strings = parameters.GetParameter <IEnumerable <string> >("Strings"); string separator = parameters.GetParameter <string>("Separator"); return(string.Join(separator, strings.ToArray())); }
public override object Execute(ParameterList parameters, FunctionContextContainer context) { if (!parameters.TryGetParameter <SitemapScope>(nameof(SitemapScope), out var sitemapScope)) { sitemapScope = SitemapScope.Current; } var pageId = GetCurrentPageId(); switch (sitemapScope) { case SitemapScope.Current: return(pageId); case SitemapScope.Parent: case SitemapScope.Level1: case SitemapScope.Level2: case SitemapScope.Level3: case SitemapScope.Level4: var pageIds = PageStructureInfo.GetAssociatedPageIds(pageId, sitemapScope); return(pageIds.FirstOrDefault()); default: throw new NotImplementedException("Unhandled SitemapScope type: " + sitemapScope.ToString()); } }
/// <exclude /> public object Execute(ParameterList parameters, FunctionContextContainer context) { EnsureUpdated(); Dictionary <string, object> sqlParameters = new Dictionary <string, object>(); foreach (ParameterProfile profile in ParameterProfiles) { object value = parameters.GetParameter(profile.Name); sqlParameters.Add(profile.Name, value); } ISqlConnection sqlConnection = GetConnection(); string connectionString = sqlConnection.EncryptedConnectionString.Decrypt(); Verify.That(!connectionString.IsNullOrEmpty(), "Connection string is empty"); string result = null; if (sqlConnection.IsMsSql) { result = RunSequel(connectionString, sqlParameters); } else { result = RunOleDbSequel(connectionString, sqlParameters); } return(BuidlXElement(result)); }
public override object Execute(ParameterList parameters, FunctionContextContainer context) { decimal value = parameters.GetParameter <decimal>("Value"); Expression <Func <decimal, bool> > predicate = f => f < value; return(predicate); }
/// <summary> /// Executes the razor page. /// </summary> /// <typeparam name="ResultType">The result type.</typeparam> /// <param name="virtualPath">The virtual path.</param> /// <param name="setParameters">Delegate to set the parameters.</param> /// <param name="functionContextContainer">The function context container.</param> /// <returns></returns> public static ResultType ExecuteRazorPage<ResultType>( string virtualPath, Action<WebPageBase> setParameters, FunctionContextContainer functionContextContainer = null) where ResultType: class { return (ResultType) ExecuteRazorPage(virtualPath, setParameters, typeof(ResultType), functionContextContainer); }
public override object Execute(ParameterList parameters, FunctionContextContainer context) { var metaTags = new List <XElement>(); string contentType = parameters.GetParameter <string>("ContentType"); string designer = parameters.GetParameter <string>("Designer"); bool showGenerator = parameters.GetParameter <bool>("ShowGenerator"); if (!string.IsNullOrWhiteSpace(contentType)) { metaTags.Add(new XElement(Namespaces.Xhtml + "meta", new XAttribute("http-equiv", "Content-Type"), new XAttribute("content", contentType))); } if (!string.IsNullOrWhiteSpace(designer)) { metaTags.Add(new XElement(Namespaces.Xhtml + "meta", new XAttribute("name", "Designer"), new XAttribute("content", designer))); } if (showGenerator) { metaTags.Add(new XElement(Namespaces.Xhtml + "meta", new XAttribute("name", "Generator"), new XAttribute("content", "C1 CMS Foundation - Free Open Source from Orckestra and https://github.com/Orckestra/CMS-Foundation"))); } return(metaTags); }
public override object Execute(ParameterList parameters, FunctionContextContainer context) { if (HttpContext.Current != null && HttpContext.Current.Request != null) { string result = HttpContext.Current.Request.QueryString[parameters.GetParameter <string>("ParameterName")]; if (result != null) { switch (result.ToLowerInvariant()) { case "0": case "false": return(false); case "1": case "true": return(true); default: return(bool.Parse(result)); } } } return(parameters.GetParameter <bool>("FallbackValue")); }
public override object Execute(ParameterList parameters, FunctionContextContainer context) { bool value = parameters.GetParameter <bool>("Value"); Expression <Func <bool?, bool> > predicate = f => f.HasValue && f.Value == value; return(predicate); }
public override object Execute(ParameterList parameters, FunctionContextContainer context) { DateTime value = parameters.GetParameter <DateTime>("Value"); Expression <Func <DateTime, bool> > predicate = f => f > value; return(predicate); }
/// <exclude /> public static Control Render(XDocument document, FunctionContextContainer contextContainer, IXElementToControlMapper mapper, IPage page) { using (TimerProfilerFacade.CreateTimerProfiler()) { using (Profiler.Measure("Executing embedded functions")) { ExecuteEmbeddedFunctions(document.Root, contextContainer); } using (Profiler.Measure("Resolving page fields")) { ResolvePageFields(document, page); } using (Profiler.Measure("Normalizing ASP.NET forms")) { NormalizeAspNetForms(document); } if (document.Root.Name != RenderingElementNames.Html) { return(new LiteralControl(document.ToString())); } var xhtmlDocument = new XhtmlDocument(document); ProcessXhtmlDocument(xhtmlDocument, page); using (Profiler.Measure("Converting XHTML document into an ASP.NET control")) { return(xhtmlDocument.AsAspNetControl(mapper)); } } }
public override object Execute(ParameterList parameters, FunctionContextContainer context) { IEnumerable elements = parameters.GetParameter <IEnumerable>("Elements"); string keyPropertyName = parameters.GetParameter <string>("KeyPropertyName"); string valuePropertyName = parameters.GetParameter <string>("ValuePropertyName"); Dictionary <string, string> resultDictionary = new Dictionary <string, string>(); PropertyInfo keyPropertyInfo = null; PropertyInfo valuePropertyInfo = null; foreach (object element in elements) { if (keyPropertyInfo == null) { keyPropertyInfo = element.GetType().GetProperty(keyPropertyName); } if (valuePropertyInfo == null) { valuePropertyInfo = element.GetType().GetProperty(valuePropertyName); } string keyValue = keyPropertyInfo.GetValue(element, null).ToString(); string valueValue = valuePropertyInfo.GetValue(element, null).ToString(); resultDictionary.Add(keyValue, valueValue); } return(resultDictionary); }
public override object Execute(ParameterList parameters, FunctionContextContainer context) { string stringA = parameters.GetParameter <string>("StringA"); string stringB = parameters.GetParameter <string>("StringB"); string separator = parameters.GetParameter <string>("Separator"); return(stringA + separator + stringB); }
public override object Execute(ParameterList parameters, FunctionContextContainer context) { return(new XsltExtensionDefinition <MarkupParserXsltExtensions> { EntensionObject = new MarkupParserXsltExtensions(), ExtensionNamespace = "#MarkupParserExtensions" }); }
public override object Execute(ParameterList parameters, FunctionContextContainer context) { var result = new List <FormEmail>(); result.AddRange(parameters.GetParameter <IEnumerable <FormEmail> >("EmailA")); result.AddRange(parameters.GetParameter <IEnumerable <FormEmail> >("EmailB")); return(result); }
/// <summary> /// Executes all cacheable (not dynamic) functions and returns <value>True</value> /// if all of the functions were cacheable. /// </summary> /// <param name="element"></param> /// <param name="functionContext"></param> /// <returns></returns> internal static bool ExecuteCacheableFunctions(XElement element, FunctionContextContainer functionContext) { return(ExecuteFunctionsRec(element, functionContext, name => { var function = FunctionFacade.GetFunction(name); return !(function is IDynamicFunction df && df.PreventFunctionOutputCaching); })); }
public virtual object Execute(ParameterList parameters, FunctionContextContainer context) { IList<object> arguments = new List<object>(); foreach (ParameterProfile paramProfile in ParameterProfiles) { arguments.Add(parameters.GetParameter(paramProfile.Name, paramProfile.Type)); } return this.MethodInfo.Invoke(null, arguments.ToArray()); }
public override object Execute(ParameterList parameters, FunctionContextContainer context) { if (_notLoadedInlineFunction != null) { return (_notLoadedInlineFunction as IFunction).Execute(parameters, context); } return base.Execute(parameters, context); }
object IFunction.Execute(ParameterList parameters, FunctionContextContainer context) { if (_errors.CompileErrors.Count > 0) { var error = _errors.CompileErrors[0]; var exception = new InvalidOperationException("{1} Line {0}: {2}".FormatWith(error.Item1, error.Item2, error.Item3)); if (_sourceCode == null) { string filepath = Path.Combine(PathUtil.Resolve(GlobalSettingsFacade.InlineCSharpFunctionDirectory), _function.CodePath); if (C1File.Exists(filepath)) { _sourceCode = C1File.ReadAllLines(filepath); } else { _sourceCode = new string[0]; } } if (_sourceCode.Length > 0) { XhtmlErrorFormatter.EmbedSourceCodeInformation(exception, _sourceCode, error.Item1); } throw exception; } if (_errors.LoadingException != null) { throw _errors.LoadingException; } throw new InvalidOperationException("Function wasn't loaded due to compilation errors"); }
public object Execute(ParameterList parameters, FunctionContextContainer context) { try { var dynamicMethod = DynamicMethodHelper.GetDynamicMethod("<C1 function> " + _functionToWrap.CompositeName()); return dynamicMethod(() => _functionToWrap.Execute(parameters, context)); } catch (Exception ex) { if (_functionToWrap.ReturnType == typeof(XhtmlDocument)) { XElement errorBoxHtml; if (context.ProcessException(_functionToWrap.CompositeName(), ex, LogTitle, out errorBoxHtml)) { XhtmlDocument errorInfoDocument = new XhtmlDocument(); errorInfoDocument.Body.Add(errorBoxHtml); return errorInfoDocument; } } throw; } }