public UrlRule GetCustomModuleRuleByParameters(string CultureCode, int TabId, string Parameters)
{
UrlRule rule = null;
IEnumerable <UrlRule> rules;
if (TabId == Null.NullInteger)
{
rules = _rules.Where(r => r.RuleType == UrlRuleType.Custom && r.Action == UrlRuleAction.Rewrite && r.IsMatch(Parameters) && r.RemoveTab == true);
}
else
{
rules = _rules.Where(r => r.RuleType == UrlRuleType.Custom && r.Action == UrlRuleAction.Rewrite && r.IsMatch(Parameters));
}
rules = rules.Where(r => !r.Url.Contains("[pagename]")); // pagename present, it not possible to know the right url
if (TabId != Null.NullInteger)
{
//with tabid
var tabRules = rules.Where(r => r.TabId == TabId);
rule = GetFirstRule(tabRules, CultureCode);
}
else
{
rule = GetFirstRule(rules, CultureCode);
}
//without tabid
if (rule == null)
{
var tabRules = rules.Where(r => r.TabId <= 0);
rule = GetFirstRule(tabRules, CultureCode);
}
return(rule);
}
private UrlRule GetCategoryLinkRule(DNNArticleInfo article, CategoryInfo category, ModuleInfo module, List <UrlRule> rules)
{
object selectedArticleList = ModuleSetting(MySettings.SelectedArticleList, module, -1); //List module to use to show the results
if (selectedArticleList.ToString() == "-1")
{
return(null);
}
object selectedModule = ModuleSetting(MySettings.SelectedModule, module, -1); //base DNNArticle module
string param = string.Format("cid={0}&smid={1}&tmid={2}", category.ItemID, selectedArticleList, selectedModule);
bool duplicate = rules.Any(urlRule => (urlRule.Parameters.StartsWith(param)) && urlRule.TabId == module.TabID);
UrlRule rule = null;
if (!duplicate)
{
rule = new UrlRule
{
CultureCode = module.CultureCode,
TabId = module.TabID,
RuleType = UrlRuleType.Module,
Parameters = param,
Action = UrlRuleAction.Rewrite,
Url = CleanupUrl(category.Title),
RemoveTab = !_includePageName
};
rule.Url = FullCategoryTitleAsPath(category, module.ModuleID);
}
return(rule);
}
private UrlRule GetRedirectCustomModuleRule(string CultureCode, int TabId, string Url)
{
Url = Url.ToLower();
UrlRule rule = null;
bool RemoveTab = TabId == Null.NullInteger;
var rules = _rules.Where(r => r.RuleType == UrlRuleType.Custom && r.IsMatchRedirectDestination(Url) && r.Action == UrlRuleAction.Rewrite /*&& r.RemoveTab == RemoveTab*/);
//with tabid
if (TabId != Null.NullInteger)
{
var tabRules = rules.Where(r => r.TabId == TabId);
rule = GetFirstRule(tabRules, CultureCode);
}
//without tabid
if (rule == null)
{
rule = GetFirstRule(rules, CultureCode);
}
if (rule != null)
{
rule = new UrlRule()
{
CultureCode = rule.CultureCode,
TabId = rule.TabId,
RuleType = rule.RuleType,
Action = UrlRuleAction.Redirect,
Url = rule.RedirectDestination,
RedirectDestination = rule.Url,
RemoveTab = rule.RemoveTab
};
}
return(rule);
}
public UrlRule GetModuleRuleByParameters(string CultureCode, int TabId, string Parameters)
{
UrlRule rule = null;
IEnumerable <UrlRule> rules;
if (TabId == Null.NullInteger)
{
rules = _rules.Where(r => r.RuleType == UrlRuleType.Module && r.Action == UrlRuleAction.Rewrite && r.Parameters == Parameters && r.RemoveTab == true);
}
else
{
rules = _rules.Where(r => r.RuleType == UrlRuleType.Module && r.Action == UrlRuleAction.Rewrite && r.Parameters == Parameters);
}
if (TabId != Null.NullInteger)
{
//with tabid
var tabRules = rules.Where(r => r.TabId == TabId);
rule = GetFirstRule(tabRules, CultureCode);
}
//without tabid
if (rule == null)
{
rule = GetFirstRule(rules, CultureCode);
}
return(rule);
}
/// <summary>
/// 验证输入是URL
/// </summary>
/// <param name="box">验证框</param>
/// <param name="errorMessage">提示信息</param>
/// <returns></returns>
public static ValidBox Url(this ValidBox box, string errorMessage)
{
var newBox = new UrlRule {
ErrorMessage = errorMessage
}.ToValidBox();
return(ValidBox.Merge(box, newBox));
}
public void EvaluateShouldUseCustomErrorMessage()
{
// arrange
var expected = "Test";
var rule = new UrlRule( expected );
var property = new Property<string>( "Url", "tempuri.org" );
// act
var actual = rule.Evaluate( property );
// assert
Assert.Equal( expected, actual.ErrorMessage );
}
public void EvaluateShouldReturnExpectedResultForInvalidValue()
{
// arrange
var rule = new UrlRule();
var property = new Property<string>( "Url", "foo" );
// act
var actual = rule.Evaluate( property );
// assert
Assert.Equal( "The Url field is not a valid fully-qualified http, https, or ftp URL.", actual.ErrorMessage );
Assert.Equal( 1, actual.MemberNames.Count() );
Assert.Equal( "Url", actual.MemberNames.Single() );
}
public void GivenUrlRuleWhenContainsRuleConfiguredThenShouldCorrectlyMatchValidUrls(string urlToMatch,
string urlFragment, bool expectedOutcome)
{
// Arrange
var sut = new UrlRule();
sut.WhenContains(urlFragment);
// Act
var result = sut.UrlMatches(urlToMatch);
// Assert
Assert.Equal(expectedOutcome, result);
}
private void AddRule(List <UrlRule> rules, UrlRule newrule)
{
if (newrule == null)
{
return;
}
//var found = _rules.Any(rule => (articleRule.Url == rule.Url && articleRule.TabId == rule.TabId && articleRule.Parameters == rule.Parameters));
var found = rules.Any(rule => (newrule.Url == rule.Url && newrule.TabId == rule.TabId && newrule.Parameters == rule.Parameters));
if (!found)
{
rules.Add(newrule);
}
}
public void EvaluateShouldReturnSuccessForNullOrEmpty()
{
// arrange
string value = null;
var rule = new UrlRule();
var property = new Property<string>( "Url", value );
var expected = ValidationResult.Success;
// act
var actual = rule.Evaluate( property );
// assert
Assert.Equal( expected, actual );
}
private UrlRule GetArticleRule(DNNArticleInfo article, ModuleInfo sourcemodule, List <string> urlTemplates, List <UrlRule> rules)
{
var viewmoduleTabid = int.Parse(sourcemodule.ModuleSettings["ViewTab"].ToString());
var urlcandidate = "";
////do we already have a rule for this article on this tab?
if (rules.Any(urlRule => (urlRule.TabId == viewmoduleTabid && urlRule.Parameters == "ArticleId=" + article.ItemId)))
{
return(null);
}
var a = "";
if (article.ItemId == 1379 || article.ItemId == 1480)
{
a = "stop";
}
Dictionary <string, string> fieldlist = LoadTokenValues(urlTemplates, article);
//try different template suggestions to find a valid and unique friendlyUrl
foreach (string urlTemplate in urlTemplates)
{
if (MakeUrl(out urlcandidate, viewmoduleTabid, urlTemplate, fieldlist, rules))
{
break;
}
}
//if no unique Url can be created then we don't make a new rule
if (string.IsNullOrEmpty(urlcandidate))
{
return(null);
}
var rule = new UrlRule
{
CultureCode = sourcemodule.CultureCode,
TabId = viewmoduleTabid, // module.TabID,
RuleType = UrlRuleType.Module,
Parameters = "ArticleId=" + article.ItemId,
Action = UrlRuleAction.Rewrite,
Url = urlcandidate,
RemoveTab = !_includePageName
};
return(rule);
}
public UrlRule GetCustomModuleRule(string CultureCode, int TabId, string Url)
{
UrlRule rule = null;
IEnumerable <UrlRule> rules;
if (TabId == Null.NullInteger)
{
rules = _rules.Where(r => r.RuleType == UrlRuleType.Custom && r.Action == UrlRuleAction.Rewrite && r.IsMatchUrl(Url) && r.RemoveTab == true);
}
else
{
rules = _rules.Where(r => r.RuleType == UrlRuleType.Custom && r.Action == UrlRuleAction.Rewrite && r.IsMatchUrl(Url));
}
if (TabId != Null.NullInteger)
{
//with tabid
var tabRules = rules.Where(r => r.TabId == TabId);
rule = GetFirstRule(tabRules, CultureCode);
}
else
{
rule = GetFirstRule(rules, CultureCode);
}
//without tabid
if (rule == null)
{
var tabRules = rules.Where(r => r.TabId <= 0);
rule = GetFirstRule(tabRules, CultureCode);
}
/*
* if (rule == null)
* {
* // redirection rule from Rewrite rule RedirectDestination
* rule = GetRedirectCustomModuleRule(CultureCode, TabId, Url);
* }
*/
return(rule);
}
/*
* private IEnumerable<UrlRule> GetRules(int portalId)
* {
* if (portalId < 0) // host menu
* return new List<UrlRule>();
* else
* return UrlRuleConfiguration.GenerateConfig(portalId).Rules;
* }
*/
/*
* private IEnumerable<UrlRule> GetRules(int portalId, string CultureCode)
* {
* if (CultureCode == "") CultureCode = null;
* return GetRules(portalId).Where(r => string.Equals(r.CultureCode,CultureCode, StringComparison.OrdinalIgnoreCase));
* }
*/
private UrlRule GetFirstRule(IEnumerable <UrlRule> rules, string CultureCode)
{
UrlRule rule = null;
if (CultureCode == "")
{
CultureCode = null;
}
if (CultureCode == null)
{
rule = rules.FirstOrDefault(r => string.IsNullOrEmpty(r.CultureCode));
}
else
{
rule = rules.FirstOrDefault(r => string.Equals(r.CultureCode, CultureCode, StringComparison.OrdinalIgnoreCase));
if (rule == null)
{
rule = rules.FirstOrDefault(r => string.IsNullOrEmpty(r.CultureCode));
}
}
return(rule);
}
public UrlRule GetModuleRule(string CultureCode, int TabId, string Url)
{
UrlRule rule = null;
IEnumerable <UrlRule> rules;
if (TabId == Null.NullInteger)
{
rules = _rules.Where(r => r.RuleType == UrlRuleType.Module && r.Url == Url && r.RemoveTab == true);
}
else
{
rules = _rules.Where(r => r.RuleType == UrlRuleType.Module && r.Url == Url);
}
if (TabId != Null.NullInteger)
{
//with tabid
var tabRules = rules.Where(r => r.TabId == TabId);
rule = GetFirstRule(tabRules, CultureCode);
}
else
{
rule = GetFirstRule(rules, CultureCode);
}
//without tabid
if (rule == null)
{
var tabRules = rules.Where(r => r.TabId == 0); // added 7/2/2014
rule = GetFirstRule(tabRules, CultureCode);
}
if (rule == null)
{
// redirection rule from Rewrite rule RedirectDestination
rule = GetRedirectModuleRule(CultureCode, TabId, Url);
}
return(rule);
}
public void EvaluateWithKindShouldReturnExpectedResultForValidValue()
{
// arrange
var rule = new UrlRule( UriKind.Relative );
var property = new Property<string>( "Url", "/api/helloworld" );
var expected = ValidationResult.Success;
// act
var actual = rule.Evaluate( property );
// assert
Assert.Equal( expected, actual );
}
public void EvaluateShouldReturnExpectedResultForValidValue()
{
// arrange
var rule = new UrlRule();
var property = new Property<string>( "Url", "http://tempuri.org" );
var expected = ValidationResult.Success;
// act
var actual = rule.Evaluate( property );
// assert
Assert.Equal( expected, actual );
}
// redirection rule from Rewrite rule RedirectDestination
private UrlRule GetRedirectModuleRule(string CultureCode, int TabId, string Url)
{
Url = Url.ToLower();
UrlRule rule = null;
bool RemoveTab = TabId == Null.NullInteger;
var rules = _rules.Where(r => r.RuleType == UrlRuleType.Module && r.RedirectDestination == Url && r.Action == UrlRuleAction.Rewrite /*&& r.RemoveTab == RemoveTab*/);
//with tabid
if (TabId != Null.NullInteger)
{
var tabRules = rules.Where(r => r.TabId == TabId);
rule = GetFirstRule(tabRules, CultureCode);
}
//without tabid
//if (rule == null) 22/3/2016
else
{
rule = GetFirstRule(rules, CultureCode);
}
if (rule != null)
{
rule = new UrlRule()
{
CultureCode = rule.CultureCode,
TabId = rule.TabId,
RuleType = rule.RuleType,
Action = UrlRuleAction.Redirect,
Url = rule.RedirectDestination,
RedirectDestination = rule.Url,
RemoveTab = rule.RemoveTab
};
}
if (rule == null)
{
// try to find a rule with de begin of url match a rule RedirectDestination
rules = _rules.Where(r => r.RuleType == UrlRuleType.Module && Url.StartsWith(r.RedirectDestination + "/") && r.Action == UrlRuleAction.Rewrite /*&& r.RemoveTab == RemoveTab*/);
//with tabid
if (TabId != Null.NullInteger)
{
var tabRules = rules.Where(r => r.TabId == TabId);
rule = GetFirstRule(tabRules, CultureCode);
}
//without tabid
//if (rule == null) 22/3/2016
else
{
rule = GetFirstRule(rules, CultureCode);
}
if (rule != null)
{
rule = new UrlRule()
{
CultureCode = rule.CultureCode,
TabId = rule.TabId,
RuleType = rule.RuleType,
Action = UrlRuleAction.Redirect,
Url = rule.RedirectDestination,
RedirectDestination = rule.Url,
RemoveTab = rule.RemoveTab
};
}
}
return(rule);
}
public static UrlRuleConfiguration GenerateConfig(int portalId)
{
//string cacheKey = "UrlRuleConfig" + portalId;
var config = new UrlRuleConfiguration();
config.Rules = new List <UrlRule>();
var UltimaUrlRule = new UrlRule();
var UltimaUrlRuleInfo = new UrlRuleInfo();
var routine = new int();
var conta = new int();
try
{
// 1 cache by portal
//Logger.Trace("Get cache " + portalId );
//config = (UrlRuleConfiguration)DataCache.GetCache(cacheKey);
//if ((config == null))
{
Stopwatch timer = new Stopwatch();
timer.Start();
Logger.Info("Rebuild cache start " + portalId + " at " + DateTime.Now);
//config = new UrlRuleConfiguration { Rules = new List<UrlRule>() };
// generate admin page
GenerateAdminTab(portalId);
//if (false)
{
var builder = new UrlBuilder();
var Rules = builder.BuildUrlMap(portalId);
config.Rules.AddRange(Rules);
var storedRules = UrlRuleController.GetUrlRules(portalId);
foreach (UrlRuleInfo storedRule in storedRules)
{
routine = 1;
UltimaUrlRuleInfo = storedRule;
if (storedRule.CultureCode == "")
{
storedRule.CultureCode = null;
}
if (storedRule.RedirectDestination == "")
{
storedRule.RedirectDestination = null;
}
if (storedRule.RedirectDestination != null)
{
storedRule.RedirectDestination = storedRule.RedirectDestination.Trim();
}
if (storedRule.Url != null)
{
storedRule.Url = storedRule.Url.Trim();
}
}
// add custom rules to cache
foreach (UrlRuleInfo storedRule in storedRules.Where(r => r.RuleType == (int)UrlRuleType.Custom /* && r.RuleAction == (int)UrlRuleAction.Redirect */)) // custom rule
{
routine = 2;
UltimaUrlRuleInfo = storedRule;
UrlRule rule = new UrlRule()
{
RuleType = (UrlRuleType)storedRule.RuleType,
CultureCode = storedRule.CultureCode,
TabId = storedRule.TabId,
Parameters = storedRule.Parameters,
Action = (UrlRuleAction)storedRule.RuleAction,
RemoveTab = storedRule.RemoveTab,
RedirectDestination = storedRule.RedirectDestination,
RedirectStatus = storedRule.RedirectStatus,
Url = storedRule.Url
};
config.Rules.Add(rule);
}
// add rule for sitemap.xml rewrite to sitemap.aspx
/* replaced by a handler
* UrlRule sitemapRule = new UrlRule()
* {
* RuleType = UrlRuleType.Custom,
* Action = UrlRuleAction.Rewrite,
* RedirectDestination = "~/Sitemap.aspx",
* Url = ".*sitemap.xml"
* };
* config.Rules.Add(sitemapRule);
*/
foreach (UrlRule rule in config.Rules)
{
routine = 3;
UltimaUrlRule = rule;
if (rule.CultureCode == "")
{
rule.CultureCode = null;
}
if (rule.RedirectDestination == "")
{
rule.RedirectDestination = null;
}
rule.Url = rule.Url.ToLower();
// set RedirectDestination for automatic redirections corresponding to rewrite rule
if (rule.RuleType == UrlRuleType.Module && rule.Action == UrlRuleAction.Rewrite && string.IsNullOrEmpty(rule.RedirectDestination))
{
rule.RedirectDestination = rule.Parameters.Replace('=', '/').Replace('&', '/');
}
else if (rule.RuleType == UrlRuleType.Module && rule.Action == UrlRuleAction.Redirect && string.IsNullOrEmpty(rule.RedirectDestination))
{
var rewriteRule = config.Rules.FirstOrDefault(r => r.RuleType == UrlRuleType.Module && r.Parameters == rule.Parameters && r.Action == UrlRuleAction.Rewrite);
if (rewriteRule != null)
{
rule.RedirectDestination = rewriteRule.Url;
}
}
if (rule.RedirectDestination != null)
{
rule.RedirectDestination = rule.RedirectDestination.ToLower();
}
}
var OldRules = new List <UrlRuleInfo>(storedRules);
var DistuctRules = config.Rules.Where(r => r.RuleType != UrlRuleType.Custom)
.GroupBy(r => new { r.RuleType, r.CultureCode, r.TabId, r.Url })
.Select(g => g.First());
conta = 0;
foreach (UrlRule rule in DistuctRules)
{
routine = 4;
UltimaUrlRule = rule;
conta = conta + 1;
var ruleInfoLst = storedRules.Where(r => r.RuleType == (int)rule.RuleType &&
r.CultureCode == rule.CultureCode &&
r.TabId == rule.TabId &&
r.Url == rule.Url);
UrlRuleInfo ruleInfo = ruleInfoLst.FirstOrDefault();
if (ruleInfo == null)
{
if (!string.IsNullOrEmpty(rule.Url) && rule.Url.Length < 500)
{
ruleInfo = new UrlRuleInfo()
{
PortalId = portalId,
DateTime = DateTime.Now,
RuleType = (int)rule.RuleType,
CultureCode = rule.CultureCode,
TabId = rule.TabId,
Url = rule.Url,
Parameters = rule.Parameters,
RuleAction = (int)rule.Action,
RemoveTab = rule.RemoveTab,
RedirectDestination = rule.RedirectDestination,
RedirectStatus = rule.RedirectStatus
};
ruleInfo.UrlRuleId = UrlRuleController.AddUrlRule(ruleInfo);
Logger.Info("AddUrlRule (UrlRuleId=" + ruleInfo.UrlRuleId + ")");
storedRules.Add(ruleInfo);
}
}
else
{
bool FirstOne = true; // for auto correction of double stored rules
foreach (var r in ruleInfoLst)
{
OldRules.Remove(r);
if (FirstOne)
{
if (ruleInfo.Parameters != rule.Parameters ||
ruleInfo.RuleAction != (int)rule.Action ||
ruleInfo.RemoveTab != rule.RemoveTab ||
ruleInfo.RedirectDestination != rule.RedirectDestination ||
ruleInfo.RedirectStatus != rule.RedirectStatus)
{
Logger.Info("UpdateUrlRule (UrlRuleId=" + ruleInfo.UrlRuleId +
(ruleInfo.Parameters == rule.Parameters) + "/" +
(ruleInfo.RuleAction == (int)rule.Action) + "/" +
(ruleInfo.RemoveTab == rule.RemoveTab) + "/" +
(ruleInfo.RedirectDestination == rule.RedirectDestination) + "/" +
(ruleInfo.RedirectStatus == rule.RedirectStatus) + "-" +
ruleInfo.Parameters + "/" + rule.Parameters + "/" +
ruleInfo.RuleAction + "/" + (int)rule.Action + "/" +
ruleInfo.RemoveTab + "/" + rule.RemoveTab + "/" +
ruleInfo.RedirectDestination + "/" + rule.RedirectDestination + "/" +
ruleInfo.RedirectStatus + "/" + rule.RedirectStatus +
")");
ruleInfo.Parameters = rule.Parameters;
ruleInfo.RuleAction = (int)rule.Action;
ruleInfo.RemoveTab = rule.RemoveTab;
ruleInfo.RedirectDestination = rule.RedirectDestination;
ruleInfo.RedirectStatus = rule.RedirectStatus;
UrlRuleController.UpdateUrlRule(ruleInfo);
}
}
else
{
UrlRuleController.DeleteUrlRule(ruleInfo.UrlRuleId);
Logger.Info("DeleteUrlRule (UrlRuleId=" + ruleInfo.UrlRuleId + ")");
}
FirstOne = false;
}
}
}
foreach (var storedRule in OldRules.Where(r => r.RuleType == (int)UrlRuleType.Tab ||
r.RuleType == (int)UrlRuleType.Module))
{
routine = 5;
UltimaUrlRuleInfo = storedRule;
if (storedRule.RuleAction == (int)UrlRuleAction.Rewrite)
{
var actualRule = Rules.FirstOrDefault(r => r.RuleType == (UrlRuleType)storedRule.RuleType &&
r.CultureCode == storedRule.CultureCode &&
r.TabId == storedRule.TabId &&
r.Parameters == storedRule.Parameters);
if (actualRule != null)
{
UrlRule rule = new UrlRule()
{
RuleType = (UrlRuleType)storedRule.RuleType,
CultureCode = storedRule.CultureCode,
TabId = storedRule.TabId,
Parameters = storedRule.Parameters,
Action = UrlRuleAction.Redirect,
RemoveTab = storedRule.RemoveTab,
RedirectDestination = actualRule.Url,
RedirectStatus = storedRule.RedirectStatus,
Url = storedRule.Url
};
config.Rules.Add(rule);
}
}
}
}
//Logger.MethodExit();
//DataCache.SetCache("UrlRuleConfig", config, TimeSpan.FromDays(1));
//int intCacheTimeout = 20 * Convert.ToInt32(DotNetNuke.Entities.Host.Host.PerformanceSetting);
timer.Stop();
double responseTime = timer.ElapsedMilliseconds / 1000.0;
Logger.Info("Rebuild cache end " + portalId + " (" + responseTime + ")" + " at " + DateTime.Now);
//DataCache.SetCache(cacheKey, config, TimeSpan.FromMinutes(intCacheTimeout));
//var onRemove = new CacheItemRemovedCallback(config.RemovedCallBack);
//DateTime absoluteExpiration = DateTime.UtcNow.Add(TimeSpan.FromMinutes(intCacheTimeout));
//DataCache.SetCache(cacheKey, config, null, absoluteExpiration, Cache.NoSlidingExpiration, CacheItemPriority.AboveNormal, onRemove, false);
}
}
catch (Exception ex)
{
//log it
var objEventLog = new EventLogController();
var objEventLogInfo = new LogInfo()
{
LogTypeKey = "GENERAL_EXCEPTION"
};
objEventLogInfo.AddProperty("UrlRewriter.UrlRuleConfig", "GetConfig Failed");
objEventLogInfo.AddProperty("UrlRewriter.RedirectDestination", UltimaUrlRule.RedirectDestination);
objEventLogInfo.AddProperty("UrlRewriter.UrlRule", UltimaUrlRule.Url);
objEventLogInfo.AddProperty("UrlRewriter.UrlRuleConfig", "GetConfig Failed");
objEventLogInfo.AddProperty("ExceptionMessage", ex.Message);
objEventLogInfo.AddProperty("PortalId", portalId.ToString());
//objEventLogInfo.LogTypeKey = EventLogController.EventLogType.HOST_ALERT.ToString();
objEventLogInfo.AddProperty("Exception Type", ex.GetType().ToString());
objEventLogInfo.AddProperty("Message", ex.Message);
objEventLogInfo.AddProperty("Stack Trace", ex.StackTrace);
if (ex.InnerException != null)
{
objEventLogInfo.AddProperty("Inner Exception Message", ex.InnerException.Message);
objEventLogInfo.AddProperty("Inner Exception Stacktrace", ex.InnerException.StackTrace);
}
objEventLogInfo.BypassBuffering = true;
objEventLog.AddLog(objEventLogInfo);
Logger.Error(ex);
//DataCache.SetCache(cacheKey, config, TimeSpan.FromMinutes(60));
}
return(config);
}
/// <summary>
/// 验证输入是URL
/// </summary>
/// <param name="box">验证框</param>
/// <returns></returns>
public static ValidBox Url(this ValidBox box)
{
var newBox = new UrlRule().ToValidBox();
return(ValidBox.Merge(box, newBox));
}
