public void UrlForBlogWithEndingWildcardMatchesBlogPostPageInSaidBlog()
{
_stubContextAccessor.Set(new StubHttpContext("~/my-blog/my-blog-post"));
var context = new ConditionEvaluationContext {
FunctionName = "url", Arguments = new[] { "~/my-blog/*" }
};
_urlCondition.Evaluate(context);
Assert.That(context.Result, Is.True);
}
public void Evaluate(ConditionEvaluationContext evaluationContext)
{
if (evaluationContext.FunctionName == "add")
{
evaluationContext.Result = Convert.ToInt32(evaluationContext.Arguments[0]) + Convert.ToInt32(evaluationContext.Arguments[1]);
return;
}
evaluationContext.Result = true;
}
public void UrlForAboutPageWithEndingSlashMatchesAboutPagePath()
{
_stubContextAccessor.Set(new StubHttpContext("~/About/"));
var context = new ConditionEvaluationContext {
FunctionName = "url", Arguments = new[] { "~/about" }
};
_urlCondition.Evaluate(context);
Assert.That(context.Result, Is.True);
}
public void UrlForHomePageDoesNotMatchAboutPagePath()
{
_stubContextAccessor.Set(new StubHttpContext("~/about"));
var context = new ConditionEvaluationContext {
FunctionName = "url", Arguments = new[] { "~/" }
};
_urlCondition.Evaluate(context);
Assert.That(context.Result, Is.False);
}
public void UrlForHomePageMatchesHomePagePathWithUrlPrefix()
{
_stubContextAccessor.Set(new StubHttpContext("~/site1"));
_shellSettings.RequestUrlPrefix = "site1";
var context = new ConditionEvaluationContext {
FunctionName = "url", Arguments = new[] { "~/" }
};
_urlCondition.Evaluate(context);
Assert.That(context.Result, Is.True);
}
public void Evaluate(ConditionEvaluationContext evaluationContext)
{
var ruleContext = new RuleContext {
FunctionName = evaluationContext.FunctionName,
Arguments = evaluationContext.Arguments,
Result = evaluationContext.Result
};
_ruleProviders.Process(ruleContext);
evaluationContext.Result = ruleContext.Result;
}
public void Evaluate(ConditionEvaluationContext evaluationContext)
{
if (!String.Equals(evaluationContext.FunctionName, "contenttype", StringComparison.OrdinalIgnoreCase))
{
return;
}
var contentType = Convert.ToString(evaluationContext.Arguments[0]);
evaluationContext.Result = _displayedContentItemHandler.IsDisplayed(contentType);
}
public void Evaluate(ConditionEvaluationContext evaluationContext)
{
if (!string.Equals(evaluationContext.FunctionName, "url", StringComparison.OrdinalIgnoreCase))
{
return;
}
var context = _httpContextAccessor.Current();
foreach (var argument in evaluationContext.Arguments)
{
var url = Convert.ToString(argument);
if (url.StartsWith("~/"))
{
url = url.Substring(2);
var appPath = context.Request.ApplicationPath;
if (appPath == "/")
{
appPath = "";
}
if (!string.IsNullOrEmpty(_shellSettings.RequestUrlPrefix))
{
appPath = string.Concat(appPath, "/", _shellSettings.RequestUrlPrefix);
}
url = string.Concat(appPath, "/", url);
}
if (!url.Contains("?"))
{
url = url.TrimEnd('/');
}
var requestPath = context.Request.Path;
if (!requestPath.Contains("?"))
{
requestPath = requestPath.TrimEnd('/');
}
if ((url.EndsWith("*") && requestPath.StartsWith(url.TrimEnd('*'), StringComparison.OrdinalIgnoreCase)) ||
string.Equals(requestPath, url, StringComparison.OrdinalIgnoreCase))
{
evaluationContext.Result = true;
return;
}
}
evaluationContext.Result = false;
}
private void ProcessAnyCondition(ConditionEvaluationContext evaluationContext)
{
// parse arguments
var partName = evaluationContext.Arguments[0].ToString();
var fieldName = evaluationContext.Arguments[1].ToString();
// the third argument to the rule is the list of Ids
var termIds = evaluationContext.Arguments.Length == 2
? ""
: evaluationContext.Arguments[2].ToString();
var ids = termIds
.Split(new[] { ',' })
.Select(s => {
int a;
if (int.TryParse(s, out a))
{
return(a);
}
return(0);
})
.Where(i => i > 0);
// validate
if (string.IsNullOrWhiteSpace(partName) || string.IsNullOrWhiteSpace(fieldName))
{
// sanity check
evaluationContext.Result = false;
return;
}
var field = GetTaxonomyField(partName, fieldName);
if (field == null)
{
// current content doesn't have a field like this
evaluationContext.Result = false;
return;
}
// evaluate
if (ids.Any())
{
// if there were Ids, at least one has to be selected
evaluationContext.Result = field.Terms.Any(
t => ids.Contains(t.Id));
}
else
{
// If no Id was provided, any selected Id is fine
evaluationContext.Result = field.Terms.Any();
}
}
public void Evaluate(ConditionEvaluationContext evaluationContext)
{
if (!String.Equals(evaluationContext.FunctionName, "authenticated", StringComparison.OrdinalIgnoreCase))
{
return;
}
if (_authenticationService.GetAuthenticatedUser() != null)
{
evaluationContext.Result = true;
return;
}
evaluationContext.Result = false;
}
public void Evaluate(ConditionEvaluationContext context)
{
// Example: contentitemtype("Page").
if (!String.Equals(context.FunctionName, RuleFunctionName, StringComparison.OrdinalIgnoreCase))
{
return;
}
var contentTypeName = GetArgument(context, 0);
var result = mCurrentContentAccessor.CurrentContentItem?.ContentType == contentTypeName;
Logger.Debug("Layer rule {0}({1}) evaluated to {2}.", RuleFunctionName, contentTypeName, result);
context.Result = result;
}
private void ProcessAllCondition(ConditionEvaluationContext evaluationContext)
{
// parse arguments
var partName = evaluationContext.Arguments[0].ToString();
var fieldName = evaluationContext.Arguments[1].ToString();
// the third argument to the rule is the list of Ids and is mandatory
var termIds = evaluationContext.Arguments[2].ToString();
var ids = termIds
.Split(new[] { ',' })
.Select(s => {
int a;
if (int.TryParse(s, out a))
{
return(a);
}
return(0);
})
.Where(i => i > 0);
// validate
if (string.IsNullOrWhiteSpace(partName) || string.IsNullOrWhiteSpace(fieldName))
{
// sanity check
evaluationContext.Result = false;
return;
}
var field = GetTaxonomyField(partName, fieldName);
if (field == null)
{
// current content doesn't have a field like this
evaluationContext.Result = false;
return;
}
if (!ids.Any())
{
// some valid ids is required
evaluationContext.Result = false;
return;
}
// evaluate
var selectedIds = field.Terms.Select(t => t.Id);
evaluationContext.Result = ids.All(i => selectedIds.Contains(i));
}
public void Evaluate(ConditionEvaluationContext evaluationContext)
{
if (!String.Equals(evaluationContext.FunctionName, "IsOrchardContent", StringComparison.OrdinalIgnoreCase))
{
return;
}
var matches = _currentContentAccessor.CurrentContentItemId.HasValue;
if (matches)
{
evaluationContext.Result = true;
return;
}
evaluationContext.Result = false;
return;
}
public void Evaluate(ConditionEvaluationContext evaluationContext)
{
if (!string.Equals(evaluationContext.FunctionName, "httpheader", StringComparison.OrdinalIgnoreCase))
{
return;
}
if (evaluationContext.Arguments.Length != 2)
{
return;
}
var context = _httpContextAccessor.Current();
var headerKey = evaluationContext.Arguments[0].ToString();
var headerValue = evaluationContext.Arguments[1].ToString();
var currentHeaderValue = context.Request.Headers[headerKey];
if (currentHeaderValue != null)
{
if (currentHeaderValue == headerValue)
{
evaluationContext.Result = true;
return;
}
else if (headerValue.StartsWith(WILDCARD) || headerValue.EndsWith(WILDCARD))
{
if (headerValue.StartsWith(WILDCARD) && headerValue.EndsWith(WILDCARD) && currentHeaderValue.Contains(headerValue.Trim(WILDCARD.ToCharArray())))
{
evaluationContext.Result = true;
return;
}
else if (headerValue.StartsWith(WILDCARD) && currentHeaderValue.EndsWith(headerValue.Trim(WILDCARD.ToCharArray())))
{
evaluationContext.Result = true;
return;
}
else if (headerValue.EndsWith(WILDCARD) && currentHeaderValue.StartsWith(headerValue.Trim(WILDCARD.ToCharArray())))
{
evaluationContext.Result = true;
return;
}
}
}
evaluationContext.Result = false;
}
public void Evaluate(ConditionEvaluationContext evaluationContext)
{
if (!string.Equals(evaluationContext.FunctionName, "tag", StringComparison.OrdinalIgnoreCase))
{
return;
}
var tagName = Convert.ToString(evaluationContext.Arguments[0]);
var _currentContent = GetContentItemForCurrentRequest();
if (_currentContent.Has <TagsPart>())
{
var tagPart = _currentContent.Get <TagsPart>();
evaluationContext.Result = tagPart.CurrentTags != null && tagPart.CurrentTags.Any(tag => tag.Equals(tagName, StringComparison.OrdinalIgnoreCase));
}
else
{
evaluationContext.Result = false;
}
}
public void Evaluate(ConditionEvaluationContext evaluationContext)
{
if (!String.Equals(evaluationContext.FunctionName, "lang", StringComparison.OrdinalIgnoreCase))
{
return;
}
var culture = evaluationContext.Arguments.Cast <String>();
var userCulture = _cultureManager.GetCurrentCulture(_workContextAccessor.GetContext().HttpContext).ToLower();
var matches = culture.Any(c => c.ToLower() == userCulture.ToLower());
if (matches)
{
evaluationContext.Result = true;
return;
}
evaluationContext.Result = false;
return;
}
public void Evaluate(ConditionEvaluationContext evaluationContext)
{
if (!string.Equals(evaluationContext.FunctionName, "contentid", StringComparison.OrdinalIgnoreCase))
{
return;
}
var contentId = -1;
var parsingSuccess = int.TryParse(Convert.ToString(evaluationContext.Arguments[0]), out contentId);
var _currentContent = GetContentItemForCurrentRequest();
if (parsingSuccess)
{
evaluationContext.Result = _currentContent.Id == contentId;
}
else
{
evaluationContext.Result = true;
}
}
public void Evaluate(ConditionEvaluationContext evaluationContext)
{
switch (evaluationContext.FunctionName.ToLowerInvariant())
{
case "taxonomyfieldhasanyterms":
if (evaluationContext.Arguments.Length == 2 || evaluationContext.Arguments.Length == 3)
{
ProcessAnyCondition(evaluationContext);
}
break;
case "taxonomyfieldhasallterms":
if (evaluationContext.Arguments.Length == 3)
{
ProcessAllCondition(evaluationContext);
}
break;
default:
break;
}
}
private static string GetArgument(ConditionEvaluationContext context, int index)
{
return(context.Arguments.Count() - 1 >= index ? (string)context.Arguments[index] : default(string));
}
