public override RedirectRule Add(RedirectRule redirectRule)
{
redirectRule.Id = Identity.NewIdentity();
_redirectsHashSet.Add(redirectRule);
return(redirectRule);
}
public RedirectRule GetRedirect(int id)
{
var rule = _repository.Get(id);
return(rule == null ? null :
RedirectRule.Copy(rule));
}
public void RedirectsAreCreatedCorrectly()
{
Assert.That(_redirectService.GetRedirectsTotalCount(), Is.EqualTo(0));
var role = new RedirectRule {
SourceUrl = "sourceUrl",
DestinationUrl = "destinationUrl",
IsPermanent = false
};
Assert.That(_redirectService.GetRedirectsTotalCount(), Is.EqualTo(0));
PopulateTable(6);
Assert.That(_redirectService.GetRedirectsTotalCount(), Is.EqualTo(6));
var created = _redirectService.GetRedirects().ToArray();
Assert.That(created.Length, Is.EqualTo(6));
var sameObjects = true;
for (int i = 0; i < created.Length; i++)
{
sameObjects &= created[i].SourceUrl == ("sourceUrl" + i.ToString()) &&
created[i].DestinationUrl == ("destinationUrl" + i.ToString()) &&
created[i].IsPermanent == (i % 2 == 0);
}
Assert.That(sameObjects);
}
protected IRedirect ResolveRule <T>(RedirectRule rule, Func <RedirectRule, T> constructRedirect) where T : IRedirect
{
if (rule == null)
{
return(new NullRedirectRule());
}
if (!rule.ContentId.HasValue)
{
return(constructRedirect(rule));
}
if (!_contentLoader.TryGet <PageData>(new ContentReference(rule.ContentId.Value), out var content))
{
return(new NullRedirectRule());
}
var filter = new FilterPublished();
if (filter.ShouldFilter(content))
{
return(new NullRedirectRule());
}
return(constructRedirect(rule));
}
public RedirectBuilder WithContentRedirectRule(out RedirectRule redirectRule, int?contentReferenceId = null)
{
_redirectRule.ContentId = contentReferenceId ?? new Random().Next(1, 1000);
redirectRule = _redirectRule;
_redirect = new ExactMatchRedirect(_redirectRule);
return(this);
}
private PortListener(RedirectRule redirectRule)
{
TcpActor.TcpActorStoppedEvent += this.TcpActor_TcpActorStoppedEvent;
_listenerTask = new Task(ListenForClients);
_redirectRules = new List <RedirectRule>();
Add(redirectRule);
_tcpListener = TcpListenerProvider.Create();
}
public IEnumerable <RedirectRule> GetRedirects(int startIndex = 0, int pageSize = 0)
{
var result = _repository.Table.Skip(startIndex >= 0 ? startIndex : 0);
if (pageSize > 0)
{
return(RedirectRule.Copy(result.Take(pageSize)));
}
return(RedirectRule.Copy(result.ToList()));
}
public RedirectBuilder WithExactMatchRedirectRule(out RedirectRule redirectRule, string newPattern)
{
_redirectRule.RedirectRuleType = RedirectRuleType.ExactMatch;
_redirectRule.NewPattern = newPattern;
redirectRule = _redirectRule;
_redirect = new ExactMatchRedirect(_redirectRule);
return(this);
}
public RedirectRule Add(RedirectRule redirectRule)
{
//FixRedirect(redirectRule);
if (GetSameSourceUrlIds(redirectRule).Any())
{
throw new RedirectRuleDuplicateException(T("Rules with same SourceURL are not valid."));
}
_repository.Create(redirectRule);
return(redirectRule);
}
public bool Remove(RedirectRule redirectRule)
{
if (!_redirectRules.Remove(redirectRule))
{
return(false);
}
//LogHelper.LogMessage(string.Format("Host {0} removed from listener with port {1}. Redirects to {2}:{3}.", string.IsNullOrEmpty(redirectRule.PublicRequestHost) ? "'Any'" : redirectRule.PublicRequestHost, redirectRule.PublicRequestPort, redirectRule.InternalTargetAddress, redirectRule.InternalTargetPort), Issue.IssueLevel.Information);
return(true);
}
public RedirectRule Update(RedirectRule redirectRule)
{
//FixRedirect(redirectRule);
if (GetSameSourceUrlIds(redirectRule).Any(id => id != redirectRule.Id))
{
throw new RedirectRuleDuplicateException(T("Rules with same SourceURL are not valid."));
}
_repository.Update(redirectRule);
_signals.Trigger("Laser.Orchard.Redirects.Changed");
return(redirectRule);
}
public RedirectBuilder WithWildcardRedirectRule(out RedirectRule redirectRule, string oldPattern, string newPattern)
{
_redirectRule.RedirectRuleType = RedirectRuleType.Wildcard;
_redirectRule.OldPattern = oldPattern;
_redirectRule.NewPattern = newPattern;
redirectRule = _redirectRule;
_redirect = new WildcardRedirect(_redirectRule);
return(this);
}
protected static void WriteToModel(RedirectRule redirectRule, RedirectRule redirectRuleToUpdate)
{
redirectRuleToUpdate.Id = redirectRule.Id;
redirectRuleToUpdate.OldPattern = redirectRule.OldPattern;
redirectRuleToUpdate.NewPattern = redirectRule.NewPattern;
redirectRuleToUpdate.RedirectType = redirectRule.RedirectType;
redirectRuleToUpdate.RedirectRuleType = redirectRule.RedirectRuleType;
redirectRuleToUpdate.IsActive = redirectRule.IsActive;
redirectRuleToUpdate.Notes = redirectRule.Notes;
redirectRuleToUpdate.Priority = redirectRule.Priority;
redirectRuleToUpdate.ContentId = redirectRule.ContentId;
}
public ActionResult AddPost()
{
var redirect = new RedirectRule();
//thanks to the _includeProperties, Update succeeds even if we are not adding the id from UI
if (!TryUpdateModel(redirect, _includeProperties))
{
_orchardServices.TransactionManager.Cancel();
return(View(redirect));
}
return(Validate(redirect, (red) => _redirectService.Add(red)));
}
public override RedirectRule Update(RedirectRule redirectRule)
{
var redirectRuleToUpdate =
_redirectsHashSet.FirstOrDefault(r => r.Id == redirectRule.Id);
if (redirectRuleToUpdate == null)
{
throw new KeyNotFoundException("No existing redirect with this GUID");
}
WriteToModel(redirectRule, redirectRuleToUpdate);
return(redirectRule);
}
public void Add(RedirectRule redirectRule)
{
if (this._redirectRules.Count > 0)
{
if (PublicPortRequested != redirectRule.PublicRequestPort)
{
throw new InvalidOperationException(string.Format("Cannot add redirect rule on different ports to the same listener. Current port is {0} and the requests added port {1}.", PublicPortRequested, redirectRule.PublicRequestPort));
}
}
_redirectRules.Add(redirectRule);
//LogHelper.LogMessage(string.Format("Host {0} added to listener with port {1}. Redirects to {2}:{3}.", string.IsNullOrEmpty(redirectRule.PublicRequestHost) ? "'Any'" : redirectRule.PublicRequestHost, redirectRule.PublicRequestPort, redirectRule.InternalTargetAddress, redirectRule.InternalTargetPort), Issue.IssueLevel.Information);
}
public override RedirectRule Update(RedirectRule redirectRule)
{
var redirectRuleToUpdate = GetById(redirectRule.Id.ExternalId);
if (redirectRuleToUpdate == null)
{
throw new Exception("No existing redirect with this GUID");
}
WriteToModel(redirectRule, redirectRuleToUpdate);
DynamicDataStore.Save(redirectRuleToUpdate);
return(redirectRuleToUpdate);
}
private static RedirectRule DtoToModelDelegate(RedirectRuleDto source)
{
var destination = new RedirectRule();
destination.Id = source.Id;
destination.OldPattern = UrlPath.ExtractRelativePath(source.OldPattern);
destination.NewPattern = UrlPath.ExtractRelativePath(source.NewPattern);
destination.RedirectType = source.RedirectType;
destination.RedirectRuleType = source.RedirectRuleType;
destination.IsActive = source.IsActive;
destination.Notes = source.Notes;
destination.ContentId = source.ContentId;
destination.Priority = (source.Priority.HasValue && source.Priority > 0) ? source.Priority.Value : Configuration.Configuration.DefaultRedirectRulePriority;
return(destination);
}
private static RedirectRule MapUrlRewriteToRedirectRule(UrlRewriteModel urlRewriteModel)
{
var redirectRule = new RedirectRule
{
OldPattern = UrlPath.NormalizePath(urlRewriteModel.OldUrl),
NewPattern = urlRewriteModel.NewUrl,
RedirectType = MapStatusCodeToRedirectType(urlRewriteModel.RedirectStatusCode),
CreatedOn = DateTime.SpecifyKind(DateTime.UtcNow, DateTimeKind.Utc),
IsActive = IsMigratedRedirectRuleActive(urlRewriteModel.ContentId),
RedirectOrigin = urlRewriteModel.ContentId != 0 ? RedirectOrigin.System : RedirectOrigin.Import,
Notes = "Migrated from old redirects module",
RedirectRuleType = MapUrlRewriteTypeToRedirectRuleType(urlRewriteModel.Type)
};
return(redirectRule);
}
public RedirectRule GetRedirect(string path)
{
//path = path.TrimStart('/');
try {
var rule = _repository.Get(x => x.SourceUrl == path);
return(rule == null ? null :
RedirectRule.Copy(rule));
} catch (Exception) {
//sqlCE doe not support using strings properly when their length is such that the column
//in the record is of type ntext.
var rules = _repository.Fetch(rr =>
rr.SourceUrl.StartsWith(path) && rr.SourceUrl.EndsWith(path));
var rule = rules.ToList().Where(rr => rr.SourceUrl == path).FirstOrDefault();
return(rule == null ? null :
RedirectRule.Copy(rule));
}
}
private ActionResult RedirectIfUrlsAreSame(RedirectRule redirect, Func <RedirectRule, RedirectRule> doOnSuccess)
{
if (redirect.SourceUrl == redirect.DestinationUrl)
{
ModelState.AddModelError("SourceUrl", T("Source url is equal to Destination url").Text);
_orchardServices.TransactionManager.Cancel();
return(View(redirect));
}
try {
var resultRule = doOnSuccess(redirect);
} catch (RedirectRuleDuplicateException) {
_orchardServices.Notifier.Error(T("A rule for this Source URL already exists."));
}
return(RedirectToAction("Index"));
}
private RedirectRule CreateRedirectRule(RedirectRuleImportRow redirectRow)
{
var matchToContent = redirectRow.ContentId.HasValue;
return(matchToContent == false
? RedirectRule.NewFromImport(redirectRow.OldPattern, redirectRow.NewPattern,
Parser.ParseRedirectType(redirectRow.RedirectType),
Parser.ParseRedirectRuleType(redirectRow.RedirectRuleType),
Parser.ParseBoolean(redirectRow.IsActive),
redirectRow.Notes,
redirectRow.Priority)
: RedirectRule.NewFromImport(redirectRow.OldPattern, redirectRow.ContentId.Value,
Parser.ParseRedirectType(redirectRow.RedirectType),
Parser.ParseRedirectRuleType(redirectRow.RedirectRuleType),
Parser.ParseBoolean(redirectRow.IsActive),
redirectRow.Notes,
redirectRow.Priority));
}
private IEnumerable <int> GetSameSourceUrlIds(RedirectRule redirectRule)
{
try {
return(_repository.Table
.Where(rr => rr.SourceUrl == redirectRule.SourceUrl)
.ToList() //need to force execution of the query, so that it can fail in sqlCE
.Select(rr => rr.Id));
} catch (Exception) {
//sqlCE doe not support using strings properly when their length is such that the column
//in the record is of type ntext.
var rules = _repository.Fetch(rr =>
rr.SourceUrl.StartsWith(redirectRule.SourceUrl) &&
rr.SourceUrl.EndsWith(redirectRule.SourceUrl));
return(rules.ToList()
.Where(rr => rr.SourceUrl == redirectRule.SourceUrl)
.Select(rr => rr.Id));
}
}
private static RedirectRuleDto ModelToDtoDelegate(RedirectRule source)
{
var destination = new RedirectRuleDto();
destination.Id = source.Id.ExternalId;
destination.OldPattern = source.OldPattern;
destination.NewPattern = source.NewPattern;
destination.ContentId = source.ContentId;
destination.RedirectType = source.RedirectType;
destination.RedirectRuleType = source.RedirectRuleType;
destination.RedirectOrigin = source.RedirectOrigin;
destination.IsActive = source.IsActive;
destination.Notes = source.Notes;
destination.CreatedOn = DateTime.SpecifyKind(source.CreatedOn, DateTimeKind.Utc);
destination.CreatedBy = source.CreatedBy;
destination.Priority = source.Priority;
return(destination);
}
public _301Redirection()
{
string cacheName = "TTOL_Cache_OldUrlRedirectionRules";
RedirectRules = HttpContext.Current.Cache[cacheName] as List <RedirectRule>;
if (null == RedirectRules)
{
RedirectRules = new List <RedirectRule>();
try
{
string configFilePath = HttpContext.Current.Server.MapPath("/Config/OldRewriteRules.config");
XmlDocument xmlDoc = new XmlDocument();
xmlDoc.Load(configFilePath);
XmlNodeList nlstRules = xmlDoc.DocumentElement.SelectNodes("//rules/rule");
for (int i = 0; i < nlstRules.Count; i++)
{
RedirectRule rule = new RedirectRule();
rule.Url = nlstRules[i].SelectSingleNode("url").InnerText;
rule.Parameters = nlstRules[i].SelectSingleNode("params").InnerText;
rule.Method = nlstRules[i].SelectSingleNode("method").InnerText;
RedirectRules.Add(rule);
}
XmlNode nodeFileSettingCacheExpire = xmlDoc.DocumentElement.SelectSingleNode("//Configuration/RedirectRulesFile");
long fileSettingCacheExpire = Lib.Object2Long(nodeFileSettingCacheExpire.Attributes["cacheExpire"].Value);
if (fileSettingCacheExpire <= 0)
{
fileSettingCacheExpire = 3600;// default 1h
}
CacheDependency fileDependency = new CacheDependency(configFilePath);
HttpContext.Current.Cache.Insert(cacheName, RedirectRules, fileDependency, DateTime.Now.AddSeconds(fileSettingCacheExpire), TimeSpan.Zero, CacheItemPriority.Normal, null);
}
catch (Exception ex)
{
}
}
}
private ActionResult Validate(RedirectRule redirect, Func <RedirectRule, RedirectRule> doOnSuccess)
{
if (redirect.SourceUrl != "*/" && redirect.DestinationUrl != "*")
{
redirect.SourceUrl = redirect.SourceUrl.TrimEnd('/');
redirect.DestinationUrl = redirect.DestinationUrl.TrimEnd('/');
}
if (redirect.SourceUrl == redirect.DestinationUrl)
{
ModelState.AddModelError("SourceUrl", T("Source url is equal to Destination url").Text);
_orchardServices.TransactionManager.Cancel();
return(View(redirect));
}
try {
var resultRule = doOnSuccess(redirect);
}
catch (RedirectRuleDuplicateException) {
_orchardServices.Notifier.Error(T("A rule for this Source URL already exists."));
}
return(RedirectToAction("Index", new { page = Request["page"] }));
}
public bool Redirect(string currentUrl)
{
bool mustRedirect = false;
Regex rex;
for (int i = 0; i < RedirectRules.Count; i++)
{
RedirectRule rule = RedirectRules[i];
rex = new Regex(rule.Url, RegexOptions.IgnoreCase);
Match match = rex.Match(currentUrl);
if (match.Success)
{
string parameters = rex.Replace(currentUrl, rule.Parameters);
mustRedirect = (bool)this.GetType().InvokeMember(rule.Method, System.Reflection.BindingFlags.InvokeMethod, null, this, new object[] { parameters.Split(',') });
break;
}
}
return(mustRedirect);
}
private static void AddRedirects(PageData pageData, string oldUrl, SystemRedirectReason systemRedirectReason)
{
if (!(pageData.Status == VersionStatus.PreviouslyPublished || pageData.Status == VersionStatus.Published))
{
return;
}
var redirectRule = RedirectRule.NewFromSystem(
UrlPath.NormalizePath(oldUrl),
pageData.ContentLink.ID,
RedirectType.Permanent,
RedirectRuleType.ExactMatch,
SystemRedirectsHelper.GetSystemRedirectReason(systemRedirectReason));
var redirectRuleRepository = ServiceLocator.Current.GetInstance <IRedirectRuleRepository>();
try
{
redirectRuleRepository.Add(redirectRule);
}
catch (ApplicationException) { }
}
public ActionResult Add(FormCollection formCollection)
{
var redirect = new RedirectRule();
if (!TryUpdateModel(redirect, _includeProperties))
{
_orchardServices.TransactionManager.Cancel();
return(View(redirect));
}
if (redirect.SourceUrl == redirect.DestinationUrl)
{
ModelState.AddModelError("SourceUrl", "Source url is equal to Destination url");
_orchardServices.TransactionManager.Cancel();
return(View(redirect));
}
_routingAppService.Add(redirect);
_orchardServices.Notifier.Add(NotifyType.Information, T("Redirect record was added"));
return(RedirectToAction("List"));
}
public void Delete(RedirectRule redirectRule)
{
_repository.Delete(redirectRule);
}
System.Collections.Generic.List<RedirectRule> GetRules()
{
System.Collections.Generic.List<RedirectRule> col = new List<RedirectRule>();
System.Xml.XmlNode _oRules = oDoc.SelectSingleNode("//urlrewrites");
foreach (System.Xml.XmlNode oNode in _oRules.SelectNodes("rule"))
{
//url/text()
if ((oNode.SelectSingleNode("url/text()") != null) && (oNode.SelectSingleNode("rewrite/text()") != null))
{
RedirectRule oR = new RedirectRule();
oR.Name = oNode.Attributes["name"].Value;
oR.URL = oNode.SelectSingleNode("url/text()").Value;
oR.Rewrite = oNode.SelectSingleNode("rewrite/text()").Value;
col.Add(oR);
}
}
return col;
}
