public int IndexOf(CustomRedirect customRedirect) { for(int i = 0; i < List.Count; i++) if (this[i] == customRedirect) // Found it return i; return -1; }
/// <summary> /// Create redirects table and SP for version number /// </summary> private static void Create() { bool create = true; var dba = DataAccessBaseEx.GetWorker(); _log.Info("Create 404 handler redirects table START"); string createTableScript = @"CREATE TABLE [dbo].[BVN.NotFoundRequests]( [ID] [int] IDENTITY(1,1) NOT NULL, [OldUrl] [nvarchar](2000) NOT NULL, [Requested] [datetime] NULL, [Referer] [nvarchar](2000) NULL ) ON [PRIMARY]"; create = dba.ExecuteNonQuery(createTableScript); _log.Info("Create 404 handler redirects table END"); if (create) { _log.Info("Create 404 handler version SP START"); string versionSP = @"CREATE PROCEDURE [dbo].[bvn_notfoundversion] AS RETURN " + Configuration.Configuration.CURRENT_VERSION; if (!dba.ExecuteNonQuery(versionSP)) { create = false; _log.Error("An error occured during the creation of the 404 handler version stored procedure. Canceling."); _log.Info("Create 404 handler version SP END"); } } Valid = create; // copy dds items, if there are any. try { // the old redirect class is obsolete, and should only be used for this upgrade var oldCustomrRedirectStore = DataStoreFactory.GetStore(typeof(FileNotFound.CustomRedirects.CustomRedirect)); var oldCustomRedirects = oldCustomrRedirectStore.Items<FileNotFound.CustomRedirects.CustomRedirect>().ToList(); if (oldCustomRedirects.Count > 0) { var newCustomrRedirectStore = DataStoreFactory.GetStore(typeof(CustomRedirect)); DataStoreHandler dsHandler = new DataStoreHandler(); foreach (var oldCustomRedirect in oldCustomRedirects) { var newRedirect = new CustomRedirect(oldCustomRedirect.OldUrl, oldCustomRedirect.NewUrl, oldCustomRedirect.WildCardSkipAppend); dsHandler.SaveCustomRedirect(newRedirect); } // oldCustomrRedirectStore.DeleteAll(); } } catch (Exception ex) { _log.Error("Error during DDS upgrade: " + ex); } }
public Suggestion(CustomRedirect customRedirect, int pageNumber, int pageSize, string searchWord) { CustomRedirect = customRedirect; PageNumber = pageNumber; PageSize = pageSize; SearchWord = searchWord; }
public int IndexOf(CustomRedirect customRedirect) { for (var i = 0; i < List.Count; i++) { if (this[i] == customRedirect) { return(i); // Found } } return(-1); }
public void AddOrUpdate(CustomRedirect redirect) { var match = _redirectLoader.GetByOldUrl(redirect.OldUrl); //if there is a match, replace the value. if (match != null) { redirect.Id = match.Id; } _repository.Save(redirect); }
public void SaveCustomRedirect(CustomRedirect currentCustomRedirect) { // Get hold of the datastore DynamicDataStore store = DataStoreFactory.GetStore(typeof(CustomRedirect)); //check if there is an exisiting object with matching property "OldUrl" CustomRedirect match = store.Find<CustomRedirect>(OLD_URL_PROPERTY_NAME, currentCustomRedirect.OldUrl.ToLower()).SingleOrDefault(); //if there is a match, replace the value. if (match != null) store.Save(currentCustomRedirect, match.Id); else store.Save(currentCustomRedirect); }
private CustomRedirect FindInternal(string url) { object foundRedirect = _quickLookupTable[url]; if (foundRedirect != null) { return(foundRedirect as CustomRedirect); } else { // No exact match could be done, so we'll check if the 404 url // starts with one of the urls we're matching against. This // will be kind of a wild card match (even though we only check // for the start of the url // Example: http://www.mysite.com/news/mynews.html is not found // We have defined an "<old>/news</old>" entry in the config // file. We will get a match on the /news part of /news/myne... // Depending on the skip wild card append setting, we will either // redirect using the <new> url as is, or we'll append the 404 // url to the <new> url. IDictionaryEnumerator _enumerator = _quickLookupTable.GetEnumerator(); while (_enumerator.MoveNext()) { // See if this "old" url (the one that cannot be found) starts with one if (url.StartsWith(_enumerator.Key.ToString(), StringComparison.InvariantCultureIgnoreCase)) { foundRedirect = _quickLookupTable[_enumerator.Key]; CustomRedirect cr = foundRedirect as CustomRedirect; if (cr.State == (int)DataStoreHandler.State.Ignored) { return(null); } if (cr.WildCardSkipAppend == true) { // We'll redirect without appending the 404 url return(cr); } else { // We need to append the 404 to the end of the // new one. Make a copy of the redir object as we // are changing it. CustomRedirect redirCopy = new CustomRedirect(cr); redirCopy.NewUrl = redirCopy.NewUrl + url.Substring(_enumerator.Key.ToString().Length); return(redirCopy); } } } } return(null); }
public static bool HandleRequest(string referer, Uri urlNotFound, out CustomRedirect foundRedirect) { // Try to match the requested url my matching it // to the static list of custom redirects CustomRedirectHandler fnfHandler = CustomRedirectHandler.Current; CustomRedirect redirect = fnfHandler.CustomRedirects.Find(urlNotFound); string pathAndQuery = urlNotFound.PathAndQuery; foundRedirect = null; if (redirect == null) { redirect = fnfHandler.CustomRedirects.FindInProviders(urlNotFound.AbsoluteUri); } if (redirect != null) { // Url has been deleted from this site if (redirect.State.Equals((int)DataStoreHandler.State.Deleted)) { foundRedirect = redirect; return true; } if (redirect.State.Equals((int)DataStoreHandler.State.Saved)) { // Found it, however, we need to make sure we're not running in an // infinite loop. The new url must not be the referrer to this page if (string.Compare(redirect.NewUrl, pathAndQuery, StringComparison.InvariantCultureIgnoreCase) != 0) { foundRedirect = redirect; return true; } } } else { // log request to database - if logging is turned on. if (Configuration.Configuration.Logging == LoggerMode.On) { // Safe logging RequestLogger.Instance.LogRequest(pathAndQuery, referer); } } return false; }
/// <summary> /// Parses the xml file and reads all redirects. /// </summary> /// <returns>A collection of CustomRedirect objects</returns> public CustomRedirectCollection Load() { const string urlpath = "/redirects/urls/url"; var redirects = new CustomRedirectCollection(); // Parse all url nodes var nodes = _customRedirectsXmlFile.SelectNodes(urlpath); foreach (XmlNode node in nodes) { // Each url new url can have several old values // we need to create a redirect object for each pair var newNode = node.SelectSingleNode(Newurl); var oldNodes = node.SelectNodes(Oldurl); foreach (XmlNode oldNode in oldNodes) { var skipWildCardAppend = false; var skipWildCardAttr = oldNode.Attributes[Skipwildcard]; if (skipWildCardAttr != null) { // If value parsing fails, it will be false by default. We do // not really care to check if it fails, as we cannot do anything // about it (throwing an exception is not a good idea here) bool.TryParse(skipWildCardAttr.Value, out skipWildCardAppend); } var redirectType = Data.RedirectType.Permanent; var redirectTypeAttr = oldNode.Attributes[RedirectType]; if (redirectTypeAttr != null) { Enum.TryParse(redirectTypeAttr.Value, out redirectType); } // Create new custom redirect nodes var redirect = new CustomRedirect(oldNode.InnerText, newNode.InnerText, skipWildCardAppend, redirectType); redirects.Add(redirect); } } return(redirects); }
public ActionResult AddDeletedUrl(string oldUrl) { CheckAccess(); // add redirect to dds with state "deleted" var redirect = new CustomRedirect(); redirect.OldUrl = oldUrl; redirect.State = Convert.ToInt32(DataStoreHandler.State.Deleted); DataStoreHandler dsHandler = new DataStoreHandler(); dsHandler.SaveCustomRedirect(redirect); DataStoreEventHandlerHook.DataStoreUpdated(); // delete rows from DB var dbAccess = DataAccessBaseEx.GetWorker(); dbAccess.DeleteRowsForRequest(oldUrl); // List<CustomRedirect> customRedirectList = GetDeletedUrls(); DataStoreEventHandlerHook.DataStoreUpdated(); return Deleted(); }
// TODO: If desired, change parameters to Find method to search based on a property of CustomRedirect. public CustomRedirect Find(Uri urlNotFound) { // Handle absolute addresses first string url = urlNotFound.AbsoluteUri; CustomRedirect foundRedirect = FindInternal(url); // Common case if (foundRedirect == null) { url = urlNotFound.PathAndQuery;; foundRedirect = FindInternal(url); } // Handle legacy databases with encoded values if (foundRedirect == null) { url = HttpUtility.HtmlEncode(url); foundRedirect = FindInternal(url); } return(foundRedirect); }
/// <summary> /// Parses the xml file and reads all redirects. /// </summary> /// <returns>A collection of CustomRedirect objects</returns> public CustomRedirectCollection Load() { const string URLPATH = "/redirects/urls/url"; const string NEWURL = "new"; const string OLDURL = "old"; const string SKIPWILDCARD = "onWildCardMatchSkipAppend"; CustomRedirectCollection redirects = new CustomRedirectCollection(); // Parse all url nodes XmlNodeList nodes = _customRedirectsXmlFile.SelectNodes(URLPATH); foreach (XmlNode node in nodes) { // Each url new url can have several old values // we need to create a redirect object for each pair XmlNode newNode = node.SelectSingleNode(NEWURL); XmlNodeList oldNodes = node.SelectNodes(OLDURL); foreach (XmlNode oldNode in oldNodes) { bool skipWildCardAppend = false; XmlAttribute skipWildCardAttr = oldNode.Attributes[SKIPWILDCARD]; if (skipWildCardAttr != null) { // If value parsing fails, it will be false by default. We do // not really care to check if it fails, as we cannot do anything // about it (throwing an exception is not a good idea here) bool.TryParse(skipWildCardAttr.Value, out skipWildCardAppend); } // Create new custom redirect nodes CustomRedirect redirect = new CustomRedirect(oldNode.InnerText, newNode.InnerText, skipWildCardAppend); redirects.Add(redirect); } } return(redirects); }
/// <summary> /// Parses the xml file and reads all redirects. /// </summary> /// <returns>A collection of CustomRedirect objects</returns> public CustomRedirectCollection Load() { const string URLPATH = "/redirects/urls/url"; const string NEWURL = "new"; const string OLDURL = "old"; const string SKIPWILDCARD = "onWildCardMatchSkipAppend"; CustomRedirectCollection redirects = new CustomRedirectCollection(); // Parse all url nodes XmlNodeList nodes = _customRedirectsXmlFile.SelectNodes(URLPATH); foreach (XmlNode node in nodes) { // Each url new url can have several old values // we need to create a redirect object for each pair XmlNode newNode = node.SelectSingleNode(NEWURL); XmlNodeList oldNodes = node.SelectNodes(OLDURL); foreach (XmlNode oldNode in oldNodes) { bool skipWildCardAppend = false; XmlAttribute skipWildCardAttr = oldNode.Attributes[SKIPWILDCARD]; if (skipWildCardAttr != null) { // If value parsing fails, it will be false by default. We do // not really care to check if it fails, as we cannot do anything // about it (throwing an exception is not a good idea here) bool.TryParse(skipWildCardAttr.Value, out skipWildCardAppend); } // Create new custom redirect nodes CustomRedirect redirect = new CustomRedirect(oldNode.InnerText, newNode.InnerText, skipWildCardAppend); redirects.Add(redirect); } } return redirects; }
public void Remove(CustomRedirect customRedirect) { _quickLookupTable.Remove(customRedirect); List.Remove(customRedirect); }
public int Add(CustomRedirect customRedirect) { // Add to quick look up table too _quickLookupTable.Add(customRedirect.OldUrl, customRedirect); return(List.Add(customRedirect)); }
public CustomRedirect(CustomRedirect redirect) { _oldUrl = redirect._oldUrl; _newUrl = redirect._newUrl; _wildCardSkipAppend = redirect._wildCardSkipAppend; }
public CustomRedirect(CustomRedirect redirect) { _oldUrl = redirect._oldUrl; _newUrl = redirect._newUrl; _wildCardSkipAppend = redirect._wildCardSkipAppend; }
public ActionResult IgnoreRedirect(string oldUrl, int pageNumber, string searchWord, int pageSize) { CheckAccess(); // delete rows from DB var dbAccess = DataAccessBaseEx.GetWorker(); dbAccess.DeleteRowsForRequest(oldUrl); // add redirect to dds with state "ignored" var redirect = new CustomRedirect(); redirect.OldUrl = oldUrl; redirect.State = Convert.ToInt32(DataStoreHandler.State.Ignored); DataStoreHandler dsHandler = new DataStoreHandler(); dsHandler.SaveCustomRedirect(redirect); DataStoreEventHandlerHook.DataStoreUpdated(); List<CustomRedirect> customRedirectList = GetSuggestions(searchWord); string actionInfo = string.Format(LocalizationService.Current.GetString("/gadget/redirects/ignoreredirect"), oldUrl); RedirectIndexViewData viewData = GetRedirectIndexViewData(pageNumber, customRedirectList, actionInfo, searchWord, pageSize, true, true); viewData.HighestSuggestionValue = customRedirectList.First().NotfoundErrorCount; viewData.LowestSuggestionValue = customRedirectList.Last().NotfoundErrorCount; return View("Index", viewData); }
public void Insert(int index, CustomRedirect customRedirect) { _quickLookupTable.Add(customRedirect, customRedirect); List.Insert(index, customRedirect); }
// TODO: If desired, change parameters to Find method to search based on a property of CustomRedirect. public CustomRedirect Find(Uri urlNotFound) { string pathAndQuery = HttpUtility.HtmlEncode(urlNotFound.PathAndQuery); object foundRedirect = _quickLookupTable[urlNotFound.AbsoluteUri] ?? _quickLookupTable[pathAndQuery]; if (foundRedirect != null) { return foundRedirect as CustomRedirect; } else { // No exact match could be done, so we'll check if the 404 url // starts with one of the urls we're matching against. This // will be kind of a wild card match (even though we only check // for the start of the url // Example: http://www.mysite.com/news/mynews.html is not found // We have defined an "<old>/news</old>" entry in the config // file. We will get a match on the /news part of /news/myne... // Depending on the skip wild card append setting, we will either // redirect using the <new> url as is, or we'll append the 404 // url to the <new> url. IDictionaryEnumerator _enumerator = _quickLookupTable.GetEnumerator(); while (_enumerator.MoveNext()) { // See if this "old" url (the one that cannot be found) starts with one if (pathAndQuery.StartsWith(_enumerator.Key.ToString(), StringComparison.InvariantCultureIgnoreCase)) { foundRedirect = _quickLookupTable[_enumerator.Key]; CustomRedirect cr = foundRedirect as CustomRedirect; if (cr.WildCardSkipAppend == true) { // We'll redirect without appending the 404 url return cr; } else { // We need to append the 404 to the end of the // new one. Make a copy of the redir object as we // are changing it. CustomRedirect redirCopy = new CustomRedirect(cr); redirCopy.NewUrl = redirCopy.NewUrl + pathAndQuery.Substring(_enumerator.Key.ToString().Length); return redirCopy; } } } } return null; }
public void Remove(CustomRedirect customRedirect) { _quickLookupTable.Remove(customRedirect); List.Remove(customRedirect); }
public void Insert(int index, CustomRedirect customRedirect) { _quickLookupTable.Add(customRedirect, customRedirect); List.Insert(index, customRedirect); }
// public methods... #region Add public int Add(CustomRedirect customRedirect) { // Add to quick look up table too _quickLookupTable.Add(customRedirect.OldUrl, customRedirect); return List.Add(customRedirect); }