public static Redirect ToRedirectAction(this RedirectItem redirectItem)
{
if (redirectItem == null)
{
return(null);
}
var redirectAction = new Redirect
{
Name = redirectItem.Name
};
GetBaseRewriteUrlItem(redirectItem.BaseRedirectItem.BaseRewriteUrlItem, redirectAction);
var baseAppendQueryString = redirectItem.BaseRedirectItem.BaseAppendQuerystringItem;
GetBaseAppendQueryStringItem(baseAppendQueryString, redirectAction);
var stopProcessingItem = redirectItem.BaseRedirectItem.BaseStopProcessingItem;
GetStopProcessing(stopProcessingItem, redirectAction);
var redirectTypeItem = redirectItem.BaseRedirectItem.BaseRedirectTypeItem;
GetStatusCode(redirectTypeItem, redirectAction);
var httpCacheabilityTypeItem = redirectItem.BaseRedirectItem.BaseCacheItem;
GetCacheability(httpCacheabilityTypeItem, redirectAction);
return(redirectAction);
}
public async Task <IActionResult> NewRedirectAdded(RedirectItem input)
{
bool isSafe = await _sba.CheckUrl(input.URL);
if (!isSafe)
{
var app = _applications.GetByApiKey(_applicationApiKey);
app.UnsafeURLSubmissions++;
_applications.Update(app);
_logger.Info("Unsafe link submitted through website", input);
return(View("Hardfall"));
}
RedirectItem redirect = new RedirectItem
{
URL = input.URL,
DateAdded = DateTime.Now,
TimesLoaded = 0,
CreatedByApplicationId = _applicationId
};
redirect = _DAL.AddNewRedirectItem(redirect);
return(View(redirect));
}
public object AddRedirect([FromBody] JObject m)
{
var model = m.ToObject <AddRedirectOptions>();
try {
// Some input validation
if (string.IsNullOrWhiteSpace(model.OriginalUrl))
{
throw new RedirectsException(Localize("redirects/errorNoUrl") + "----");
}
if (string.IsNullOrWhiteSpace(model.Destination?.Url))
{
throw new RedirectsException(Localize("redirects/errorNoDestination") + "\r\n\r\n" + m);
}
// Add the redirect
RedirectItem redirect = _redirects.AddRedirect(model);
// Return the redirect
return(redirect);
} catch (RedirectsException ex) {
// Generate the error response
return(Request.CreateResponse(JsonMetaResponse.GetError(HttpStatusCode.InternalServerError, ex.Message)));
}
}
/// <summary>
/// Adds the section to section redirect.
/// </summary>
/// <param name="item">The item.</param>
/// <returns>Redirect item</returns>
private static RedirectItem AddSectionToSectionRedirect(Item item)
{
if (item == null)
{
return null;
}
var sectionToSection = new SectionToSection(item);
if (string.IsNullOrEmpty(sectionToSection.BaseSection.Value) || sectionToSection.TargetSection.TargetItem == null)
{
return null;
}
if (!CheckPresentation(sectionToSection.TargetSection.TargetItem))
{
return null;
}
var redirectItem = new RedirectItem
{
ItemId = sectionToSection.ID,
Target = UrlNormalizer.GetItemUrl(sectionToSection.TargetSection.TargetItem),
Base = UrlNormalizer.Normalize(sectionToSection.BaseSection.Value),
RedirectCode = sectionToSection.RedirectCode,
Multisites = ConvertMultisites(sectionToSection.Multisites),
UseOnDefault = sectionToSection.UseOnDefault.Checked
};
return redirectItem;
}
private void GetSelectedItem(int selectedItemID)
{
//if (session["RedirectListItem"] != null)
// itemList = (List<RedirectItem>)session["RedirectListItem"];
RedirectItem i = itemList[selectedItemID];
view.AllHistory = i.AllHistory;
view.AllScans = i.AllScans;
view.CommandID = i.CommandID;
view.OrganizationalUnitId = i.OrganizationalUnitID;
view.Employees = service.GetEmployees(view.OrganizationalUnitId);
view.EmployeeId = i.EmployeeID;
view.WorkOnPaper = i.WorkOnPaper;
view.Note = i.Note;
if (i.WorkOnPaper)
{
view.AllHistoryEnable = false;
view.AllScanEnable = false;
}
else
{
view.AllHistoryEnable = true;
view.AllScanEnable = true;
}
}
/// <summary>
/// Prepares the redirect URL.
/// </summary>
/// <param name="item">The item.</param>
/// <returns>
/// The redirect URL.
/// </returns>
private static string PrepareRedirectUrl(RedirectItem item)
{
if (item == null)
{
return string.Empty;
}
var queryString = item.TargetQueryString;
var targetUrl = item.Target;
if (!string.IsNullOrEmpty(queryString))
{
targetUrl = !string.IsNullOrEmpty(Context.Request.QueryString.ToString()) ?
string.Format("{0}?{1}&{2}", targetUrl, queryString, Context.Request.QueryString) :
string.Format("{0}?{1}", targetUrl, queryString);
}
else
{
if (!string.IsNullOrEmpty(Context.Request.QueryString.ToString()))
{
targetUrl = string.Format("{0}?{1}", targetUrl, Context.Request.QueryString);
}
}
if (!item.External)
{
targetUrl = string.Format("{0}{1}", UrlNormalizer.GetVirtualVolder(), targetUrl);
}
return UrlNormalizer.EncodeUrl(targetUrl);
}
/// <summary>
/// This is where a CsvRow gets parsed into a RedirectItem. The aim here is not to validate but
/// to get everything into a nicely typed model. It's not pretty mainly because of old skool
/// null checks.
/// </summary>
/// <param name="row"></param>
/// <returns></returns>
private RedirectItem Parse(CsvRow row)
{
var redirectItemRow = new RedirectItemDto
{
Id = 0,
IsPermanent = true,
IsRegex = false,
ForwardQueryString = false,
QueryString = string.Empty,
Created = DateTime.Now,
Updated = DateTime.Now
};
var sourceUrl = row.Cells[0]?.Value.Replace("\"", string.Empty).Trim().ToUri();
if (sourceUrl != null)
{
var lastSlash = sourceUrl.AbsolutePath.LastIndexOf('/');
var sourceUrlNoTrailingSlash = (lastSlash > 0) ? sourceUrl.AbsolutePath.Substring(0, lastSlash) : sourceUrl.AbsolutePath;
redirectItemRow.Url = sourceUrlNoTrailingSlash;
if (!string.IsNullOrEmpty(sourceUrl.Query.TrimStart('?')))
{
redirectItemRow.ForwardQueryString = true;
redirectItemRow.QueryString = sourceUrl.Query.TrimStart('?');
}
}
var destinationUrl = row.Cells[1]?.Value.Replace("\"", string.Empty).Trim().ToUri();
if (destinationUrl != null)
{
var lastSlash = destinationUrl.AbsolutePath.LastIndexOf('/');
var destUrlNoTrailingSlash = (lastSlash > 0) ? destinationUrl.AbsolutePath.Substring(0, lastSlash) : destinationUrl.AbsolutePath;
var destinationUrlContent = contentFinder.Find(destUrlNoTrailingSlash);
if (destinationUrlContent != null)
{
redirectItemRow.DestinationType = RedirectDestinationType.Content.ToString().ToLower();
redirectItemRow.DestinationId = destinationUrlContent.Id;
redirectItemRow.DestinationUrl = destinationUrlContent.Url;
}
else
{
var linkModeRaw = row.Cells[2].Value == null?RedirectDestinationType.Url.ToString() : row.Cells[2].Value.Replace("\"", string.Empty).Trim();
Enum.TryParse(linkModeRaw, out RedirectDestinationType linkMode);
redirectItemRow.DestinationType = linkMode.ToString().ToLower();
redirectItemRow.DestinationUrl = destinationUrl.AbsolutePath;
}
}
var redirectItem = new RedirectItem(redirectItemRow);
return(redirectItem);
}
private void ContextOnEndRequest(object sender, EventArgs eventArgs)
{
HttpApplication application = (HttpApplication)sender;
// Ignore if not a 404 response
if (application.Response.StatusCode != 404)
{
return;
}
var request = application.Request;
// Get the Umbraco domain of the current request
Domain domain = GetUmbracoDomain(application.Request);
// Get the root node/content ID of the domain (no domain = 0)
int rootNodeId = domain?.ContentId ?? 0;
// Look for a redirect matching the URL (and domain)
RedirectItem redirect = null;
if (rootNodeId > 0)
{
redirect = _redirects.GetRedirectByUrl(rootNodeId, application.Request.RawUrl);
}
redirect = redirect ?? _redirects.GetRedirectByUrl(0, application.Request.RawUrl);
if (redirect == null)
{
return;
}
var redirectUrl = redirect.LinkUrl;
if (redirect.ForwardQueryString)
{
redirectUrl = _redirects.HandleForwardQueryString(redirect, application.Request.RawUrl);
}
//if (redirect.IsRegex)
//{
// var regex = new Regex(redirect.Url);
// if (_capturingGroupsRegex.IsMatch(redirectUrl))
// {
// redirectUrl = regex.Replace(redirect.Url, redirectUrl);
// }
//}
// Redirect to the URL
if (redirect.IsPermanent)
{
application.Response.RedirectPermanent(redirectUrl);
}
else
{
application.Response.Redirect(redirectUrl);
}
}
public IActionResult Index(RedirectItem input)
{
if (!string.IsNullOrWhiteSpace(input.URL) || !string.IsNullOrWhiteSpace(input.Key))
{
return(View("redirect", input));
}
_logger.Info("Home page requested");
return(View());
}
private void EditItem()
{
bool isDuplicate = false;
RedirectItem item = itemList[view.SelectedItemID];
//sprawdzenie czy juz taki pracownik i wydzial nie zostal wczesniej dodany do listy
for (int i = 0; i < itemList.Count; i++)
{
if ((view.SelectedItemID != i) && (((RedirectItem)itemList[i]).EmployeeID == view.EmployeeId && ((RedirectItem)itemList[i]).OrganizationalUnitID == view.OrganizationalUnitId))
{
isDuplicate = true;
break;
}
}
if (!isDuplicate)
{
item.Note = view.Note;
item.AllHistory = view.AllHistory;
item.AllScans = view.AllScans;
item.CommandID = view.CommandID;
item.WorkOnPaper = view.WorkOnPaper;
item.OrganizationalUnitID = view.OrganizationalUnitId;
item.EmployeeID = view.EmployeeId;
item.EmployeeName = view.EmpName;
item.OrganizationalUnitName = view.OUName;
if (item.WorkOnPaper)
{
for (int j = 0; j < itemList.Count; j++)
{
if (j != view.SelectedItemID)
{
((RedirectItem)itemList[j]).WorkOnPaper = false;
((RedirectItem)itemList[j]).AllHistory = false;
((RedirectItem)itemList[j]).AllScans = false;
}
}
}
view.SelectedItemID = -1;
view.AddToRedirectButtonName = "Dodaj do dekretacji";
//dodane 1
view.ShowCancelChangesButton = false;
ClearForm();
session["RedirectListItem"] = itemList;
}
else
{
view.Message = "Wybrany wydzia³ i pracownik widnieje ju¿ na liœcie.";
view.AddToRedirectButtonName = "Zapisz zmiany";
//dodane 1
view.ShowCancelChangesButton = true;
}
}
private void SaveItem()
{
bool isDuplicate = false;
//sprawdzenie czy juz taki pracownik i wydzial nie zostal wczesniej dodany do listy
for (int i = 0; i < itemList.Count; i++)
{
if (((RedirectItem)itemList[i]).EmployeeID == view.EmployeeId && ((RedirectItem)itemList[i]).OrganizationalUnitID == view.OrganizationalUnitId)
{
isDuplicate = true;
break;
}
}
if (!isDuplicate)
{
itemList.Add(new RedirectItem(
//int.Parse(session["idDokumentu"].ToString()),
documentID,
view.OrganizationalUnitId,
view.OUName,
view.EmployeeId,
view.EmpName,
view.Note,
view.WorkOnPaper,
view.CommandID,
view.AllHistory,
view.AllScans
));
if (view.WorkOnPaper)
{
RedirectItem currentItem = null;
for (int j = 0; j < itemList.Count; j++)
{
if (j != itemList.Count - 1)
{
currentItem = (RedirectItem)itemList[j];
currentItem.WorkOnPaper = false;
currentItem.AllHistory = false;
currentItem.AllScans = false;
}
}
}
session["RedirectListItem"] = itemList;
ClearForm();
}
else
{
view.Message = "Wybrany wydzia³ i pracownik widnieje ju¿ na liœcie.";
}
}
public void Remove(RedirectItem item)
{
lock (Locker)
{
var redirects = _cacheRetriever.FindAll().ToList();
redirects.RemoveAll(x => x.ItemId == item.ItemId);
HttpContext.Current.Cache.Insert(_configurationSettings.CacheId, redirects);
}
}
/// <summary>
/// Adds the item to list.
/// </summary>
/// <param name="item">The item.</param>
/// <param name="list">The list.</param>
/// <returns>
/// The list with added item.
/// </returns>
private static List<RedirectItem> AddItemToList(RedirectItem item, List<RedirectItem> list)
{
if (item != null)
{
if (!CheckDuplicates(item.Base, list))
{
list.Add(item);
}
}
return list;
}
private int IncrementLoadCount(RedirectItem input)
{
input.TimesLoaded++;
using (SqlConnection conn = new SqlConnection(_connectionString))
{
conn.Open();
SqlCommand cmd = new SqlCommand(_SQL_IncrementLoadCount, conn);
cmd.Parameters.AddWithValue("@url_key", input.Key);
cmd.Parameters.AddWithValue("@times_loaded", input.TimesLoaded);
cmd.ExecuteNonQuery();
}
return(input.TimesLoaded);
}
public void Setup()
{
_redirectItem = new RedirectItem
{
RedirectUrl = "/extension",
External = false,
ItemId = new Guid(),
Site = "",
Target = "/Test",
TargetQueryString = ""
};
_redirectItemToTargetUrl = new RedirectItemToTargetUrl();
}
/// <summary>
/// This is where an Excel Row gets parsed into a RedirectItem. The aim here is not to validate but
/// to get everything into a nicely typed model. It's not pretty mainly because of old skool
/// null checks.
/// </summary>
/// <param name="row"></param>
/// <returns></returns>
private RedirectItem Parse(Row row)
{
var redirectItemRow = new RedirectItemRow();
redirectItemRow.UniqueId = Guid.NewGuid().ToString();
redirectItemRow.RootNodeId = 0;
redirectItemRow.IsPermanent = true;
redirectItemRow.IsRegex = false;
redirectItemRow.ForwardQueryString = true;
ParseSourceUrl(row.GetCellByColumnName("A").Value.ToString(), redirectItemRow);
var destinationUrlRaw = row.GetCellByColumnName("B").Value == null ? null : row.GetCellByColumnName("B").Value.ToString().Trim();
var destinationUrl = destinationUrlRaw.ToUri();
if (destinationUrl != null)
{
redirectItemRow.LinkUrl = destinationUrl.AbsolutePath;
}
RedirectLinkMode linkMode;
var linkModeRaw = row.GetCellByColumnName("C").Value == null?RedirectLinkMode.Url.ToString() : row.GetCellByColumnName("C").Value.ToString().Trim();
Enum.TryParse(linkModeRaw, out linkMode);
redirectItemRow.LinkMode = linkMode.ToString().ToLower();
if (destinationUrl != null)
{
var urlContent = contentFinder.Find(destinationUrl.AbsolutePath);
if (urlContent != null)
{
redirectItemRow.LinkMode = RedirectLinkMode.Content.ToString().ToLower();
redirectItemRow.LinkId = urlContent.Id;
redirectItemRow.LinkName = urlContent.Name;
redirectItemRow.LinkUrl = urlContent.Url;
}
else
{
redirectItemRow.LinkUrl = destinationUrl.AbsolutePath;
}
}
var redirectItem = new RedirectItem(redirectItemRow);
return(redirectItem);
}
public string Create(RedirectItem item)
{
if (item == null)
{
throw new Exception("Item cannot be null");
}
var targetUrl = item.Target;
if (!string.IsNullOrEmpty(item.TargetQueryString))
{
targetUrl = string.Format("{0}?{1}", targetUrl, item.TargetQueryString);
}
return(targetUrl);
}
public object EditRedirect(int rootNodeId, string redirectId, string url, string linkMode, int linkId, string linkUrl, string linkName = null)
{
try {
// Get the redirect from the database
RedirectItem redirect = Repository.GetRedirectById(redirectId);
if (redirect == null)
{
throw new RedirectNotFoundException();
}
if (String.IsNullOrWhiteSpace(url))
{
throw new RedirectsException("You must specify a URL for the redirect.");
}
if (String.IsNullOrWhiteSpace(linkUrl))
{
throw new RedirectsException("You must specify a destination link for the redirect.");
}
if (String.IsNullOrWhiteSpace(linkMode))
{
throw new RedirectsException("You must specify a destination link for the redirect.");
}
// Initialize a new link picker item
RedirectLinkItem link = RedirectLinkItem.Parse(new JObject {
{ "id", linkId },
{ "name", linkName + "" },
{ "url", linkUrl },
{ "mode", linkMode }
});
string[] urlParts = url.Split('?');
url = urlParts[0].TrimEnd('/');
string query = urlParts.Length == 2 ? urlParts[1] : "";
redirect.RootNodeId = rootNodeId;
redirect.Url = url;
redirect.QueryString = query;
redirect.Link = link;
Repository.SaveRedirect(redirect);
return(redirect);
} catch (RedirectsException ex) {
return(Request.CreateResponse(JsonMetaResponse.GetError(HttpStatusCode.InternalServerError, ex.Message)));
}
}
public object EditRedirect(Guid redirectId, [FromBody] EditRedirectOptions model)
{
try {
// Get a reference to the redirect
RedirectItem redirect = _redirects.GetRedirectByKey(redirectId);
if (redirect == null)
{
throw new RedirectNotFoundException();
}
// Some input validation
if (string.IsNullOrWhiteSpace(model.OriginalUrl))
{
throw new RedirectsException(Localize("redirects/errorNoUrl"));
}
if (string.IsNullOrWhiteSpace(model.Destination?.Url))
{
throw new RedirectsException(Localize("redirects/errorNoDestination"));
}
// Split the URL and query string
string[] urlParts = model.OriginalUrl.Split('?');
string url = urlParts[0].TrimEnd('/');
string query = urlParts.Length == 2 ? urlParts[1] : string.Empty;
redirect.RootId = model.RootNodeId;
redirect.RootKey = model.RootNodeKey;
redirect.Url = url;
redirect.QueryString = query;
redirect.LinkId = model.Destination.Id;
redirect.LinkKey = model.Destination.Key;
redirect.LinkUrl = model.Destination.Url;
redirect.LinkMode = model.Destination.Type;
redirect.IsPermanent = model.IsPermanent;
redirect.ForwardQueryString = model.ForwardQueryString;
// Save/update the redirect
_redirects.SaveRedirect(redirect);
// Return the redirect
return(redirect);
} catch (RedirectsException ex) {
// Generate the error response
return(Request.CreateResponse(JsonMetaResponse.GetError(HttpStatusCode.InternalServerError, ex.Message)));
}
}
public object DeleteRedirect(string redirectId)
{
try {
// Get the redirect from the database
RedirectItem redirect = Repository.GetRedirectById(redirectId);
if (redirect == null)
{
throw new RedirectNotFoundException();
}
Repository.DeleteRedirect(redirect);
return(redirect);
} catch (RedirectsException ex) {
return(Request.CreateResponse(JsonMetaResponse.GetError(HttpStatusCode.InternalServerError, ex.Message)));
}
}
/// <summary>
/// This is where an Excel Row gets parsed into a RedirectItem. The aim here is not to validate but
/// to get everything into a nicely typed model. It's not pretty mainly because of old skool
/// null checks.
/// </summary>
/// <param name="row"></param>
/// <returns></returns>
private RedirectItem Parse(Row row)
{
var redirectOptions = new AddRedirectOptions();
redirectOptions.RootNodeId = 0;
redirectOptions.IsPermanent = true;
redirectOptions.IsRegex = false;
redirectOptions.ForwardQueryString = true;
ParseSourceUrl(row.GetCellByColumnName("A").Value.ToString(), redirectOptions);
var destinationUrlRaw = row.GetCellByColumnName("B").Value == null ? null : row.GetCellByColumnName("B").Value.ToString().Trim();
var destinationUrl = destinationUrlRaw.ToUri();
RedirectDestinationType linkMode;
var linkModeRaw = row.GetCellByColumnName("C").Value == null?RedirectDestinationType.Url.ToString() : row.GetCellByColumnName("C").Value.ToString().Trim();
Enum.TryParse(linkModeRaw, out linkMode);
redirectOptions.Destination.Type = linkMode;
if (destinationUrl != null)
{
var urlContent = contentFinder.Find(destinationUrl.AbsolutePath);
if (urlContent != null)
{
redirectOptions.Destination = new RedirectDestination(urlContent.Id, Guid.Empty, urlContent.Url, linkMode);
//redirectOptions. = RedirectDestinationType.Content.ToString().ToLower();
//redirectOptions.LinkId = urlContent.Id;
//redirectOptions.LinkName = urlContent.Name;
//redirectOptions.LinkUrl = urlContent.Url;
}
else
{
redirectOptions.Destination = new RedirectDestination(0, Guid.Empty, destinationUrl.AbsolutePath, linkMode);
}
}
var redirectItem = new RedirectItem(redirectOptions);
return(redirectItem);
}
public IActionResult Link()
{
RedirectItem input = new RedirectItem
{
Key = RouteData.Values["url"].ToString()
};
if (_DAL.IsValidLinkCode(input.Key))
{
input = _DAL.GetRedirectItem(input);
if (!string.IsNullOrEmpty(input.URL))
{
return(RedirectPermanent(input.URL));
}
}
return(View("LinkNotFound", input));
}
public RedirectItem GetRedirectItemFromURL(RedirectItem input)
{
RedirectItem output = new RedirectItem();
using (SqlConnection conn = new SqlConnection(_connectionString))
{
conn.Open();
SqlCommand cmd = new SqlCommand(_SQL_GetRedirectItemFromUrl, conn);
cmd.Parameters.AddWithValue("@url", input.URL);
SqlDataReader reader = cmd.ExecuteReader();
while (reader.Read())
{
output = new RedirectItem(reader);
}
}
return(output);
}
/// <summary>
/// Adds the section to item redirect.
/// </summary>
/// <param name="item">The item.</param>
/// <returns>Redirect item</returns>
private static RedirectItem AddSectionToItemRedirect(Item item)
{
if (item == null)
{
return(null);
}
var sectionToItem = new SectionToItem(item);
if (string.IsNullOrEmpty(sectionToItem.BaseSection.Value) ||
sectionToItem.TargetItem == null ||
(sectionToItem.TargetItem.TargetItem == null && string.IsNullOrEmpty(sectionToItem.TargetItem.Url)))
{
return(null);
}
var external = true;
var targetUrl = sectionToItem.TargetItem.Url;
if (sectionToItem.TargetItem.IsInternal)
{
if (!CheckPresentation(sectionToItem.TargetItem.TargetItem))
{
return(null);
}
targetUrl = UrlNormalizer.CheckPageExtension(UrlNormalizer.GetItemUrl(sectionToItem.TargetItem.TargetItem));
external = false;
}
var redirectItem = new RedirectItem
{
ItemId = sectionToItem.ID,
Target = targetUrl,
TargetQueryString = sectionToItem.TargetItem.QueryString,
Base = UrlNormalizer.RemovePageExtension(UrlNormalizer.Normalize(sectionToItem.BaseSection.Value)),
External = external,
RedirectCode = sectionToItem.RedirectCode,
Multisites = ConvertMultisites(sectionToItem.Multisites),
UseOnDefault = sectionToItem.UseOnDefault.Checked
};
return(redirectItem);
}
private bool DeleteSelectedItem(int selectedItemID)
{
bool state = false;
//if (session["RedirectListItem"] != null)
// itemList = (List<RedirectItem>)session["RedirectListItem"];
RedirectItem i = itemList[selectedItemID];
if (!i.WorkOnPaper)
{
itemList.RemoveAt(selectedItemID);
session["RedirectListItem"] = itemList;
state = true;
ClearForm();
}
view.SelectedItemID = -1;
return(state);
}
public object AddRedirect(int rootNodeId, string url, string linkMode, int linkId, string linkUrl, string linkName = null, bool permanent = true, bool regex = false, bool forward = false)
{
try {
// Some input validation
if (String.IsNullOrWhiteSpace(url))
{
throw new RedirectsException(Localize("redirects/errorNoUrl"));
}
if (String.IsNullOrWhiteSpace(linkUrl))
{
throw new RedirectsException(Localize("redirects/errorNoDestination"));
}
if (String.IsNullOrWhiteSpace(linkMode))
{
throw new RedirectsException(Localize("redirects/errorNoDestination"));
}
// Parse the link mode
RedirectLinkMode mode;
switch (linkMode)
{
case "content": mode = RedirectLinkMode.Content; break;
case "media": mode = RedirectLinkMode.Media; break;
case "url": mode = RedirectLinkMode.Url; break;
default: throw new RedirectsException(Localize("redirects/errorUnknownLinkMode"));
}
// Initialize a new link item
RedirectLinkItem destination = new RedirectLinkItem(linkId, linkName, linkUrl, mode);
// Add the redirect
RedirectItem redirect = Repository.AddRedirect(rootNodeId, url, destination, permanent, regex, forward);
// Return the redirect
return(redirect);
} catch (RedirectsException ex) {
// Generate the error response
return(Request.CreateResponse(JsonMetaResponse.GetError(HttpStatusCode.InternalServerError, ex.Message)));
}
}
public override List <RedirectItemValidationResult> HandleValidation(RedirectItem redirectItem, IEnumerable <RedirectItem> otherRedirectItems)
{
var response = new RedirectItemValidationResult();
var linkUrl = string.Empty;
if (!string.IsNullOrEmpty(redirectItem.LinkUrl))
{
linkUrl = redirectItem.LinkUrl;
}
var destinationRedirect = otherRedirectItems.FirstOrDefault(item => item.Url == linkUrl && item.QueryString == redirectItem.QueryString && item.UniqueId != redirectItem.UniqueId);
if (destinationRedirect != null)
{
if (destinationRedirect.LinkUrl == redirectItem.Url)
{
response.Status = ImportErrorLevel.Error;
response.ErrorMessage = string.Format("This redirect would create a redirect loop as another redirect exists with the URL ({0}) in the file. It has not been imported.", redirectItem.LinkUrl);
ErrorsResult.Add(response);
return(ErrorsResult);
}
response.Status = ImportErrorLevel.Warning;
response.ErrorMessage = string.Format("This redirect links to the URL ({0}) in the file. This will result in a redirect chain", redirectItem.LinkUrl);
ErrorsResult.Add(response);
return(ErrorsResult);
}
if (Successor != null)
{
return(Successor.HandleValidation(redirectItem, otherRedirectItems));
}
ErrorsResult.Add(response);
return(ErrorsResult);
}
public object DeleteRedirect(string redirectId)
{
try {
// Get a reference to the redirect
RedirectItem redirect = Repository.GetRedirectById(redirectId);
if (redirect == null)
{
throw new RedirectNotFoundException();
}
// Delete the redirect
Repository.DeleteRedirect(redirect);
// Return the redirect
return(redirect);
} catch (RedirectsException ex) {
// Generate the error response
return(Request.CreateResponse(JsonMetaResponse.GetError(HttpStatusCode.InternalServerError, ex.Message)));
}
}
/// <summary>
/// Adds the item to item redirect.
/// </summary>
/// <param name="item">The item.</param>
/// <returns>Redirect item</returns>
private static RedirectItem AddItemToItemRedirect(Item item)
{
if (item == null)
{
return null;
}
var itemToItem = new ItemToItem(item);
if ((string.IsNullOrEmpty(itemToItem.TargetItem.Url) && itemToItem.TargetItem.TargetItem == null)
|| string.IsNullOrEmpty(itemToItem.BaseItem.Value))
{
return null;
}
var external = true;
var targetUrl = itemToItem.TargetItem.Url;
if (itemToItem.TargetItem.IsInternal)
{
if (!CheckPresentation(itemToItem.TargetItem.TargetItem))
{
return null;
}
targetUrl = UrlNormalizer.GetItemUrl(itemToItem.TargetItem.TargetItem);
external = false;
}
var redirectItem = new RedirectItem
{
ItemId = itemToItem.ID,
Target = targetUrl,
TargetQueryString = itemToItem.TargetItem.QueryString,
Base = UrlNormalizer.CheckPageExtension(UrlNormalizer.Normalize(itemToItem.BaseItem.Value)),
External = external,
RedirectCode = itemToItem.RedirectCode,
Multisites = ConvertMultisites(itemToItem.Multisites),
UseOnDefault = itemToItem.UseOnDefault.Checked
};
return redirectItem;
}
/// <summary>
/// Virtual method for handling inbound redirects created by editors through Skybrud's redirects package.
///
/// The redirects handled by this method are the ones retrived through the <see cref="IRedirectsService"/> service.
/// </summary>
/// <param name="request">The current request.</param>
/// <returns><c>true</c> if a redirect was found, otherwise <c>false</c>.</returns>
protected virtual bool HandleSkybrudRedirect(SpaRequest request)
{
// Look for a global Skybrud redirect
RedirectItem redirect = RedirectsService.GetRedirectByUrl(0, HttpUtility.UrlDecode(request.Url));
// If nothing is found at this point, look for a site specific Skybrud redirect
if (request.SiteId > 0 && redirect == null)
{
redirect = RedirectsService.GetRedirectByUrl(request.SiteId, HttpUtility.UrlDecode(request.Url));
}
if (redirect == null)
{
return(false);
}
// Return a redirect response based on the Skybrud redirect
request.Response = ReturnRedirect(request, redirect.LinkUrl, redirect.IsPermanent);
return(true);
}
/// <summary>
/// Prepares the redirect URL.
/// </summary>
/// <param name="item">The item.</param>
/// <returns>
/// The redirect URL.
/// </returns>
private static string PrepareRedirectUrl(RedirectItem item)
{
if (item == null)
{
return string.Empty;
}
var queryString = item.TargetQueryString;
var targetUrl = item.Target;
if (!string.IsNullOrEmpty(queryString))
{
targetUrl = !string.IsNullOrEmpty(Context.Request.QueryString.ToString()) ?
string.Format("{0}?{1}&{2}", targetUrl, queryString, Context.Request.QueryString) :
string.Format("{0}?{1}", targetUrl, queryString);
}
else
{
if (!string.IsNullOrEmpty(Context.Request.QueryString.ToString()))
{
targetUrl = string.Format("{0}?{1}", targetUrl, Context.Request.QueryString);
}
}
if (!item.External)
{
targetUrl = string.Format("{0}{1}", UrlNormalizer.GetVirtualVolder(), targetUrl);
}
return UrlNormalizer.EncodeUrl(targetUrl);
}
/// <summary>
/// Adds the section to section redirect.
/// </summary>
/// <param name="item">The item.</param>
/// <returns>Redirect item</returns>
private static RedirectItem AddSectionToSectionRedirect(Item item)
{
if (item == null)
{
return null;
}
var sectionToSection = new SectionToSection(item);
if (string.IsNullOrEmpty(sectionToSection.BaseSection.Value) || sectionToSection.TargetSection.TargetItem == null)
{
return null;
}
if (!CheckPresentation(sectionToSection.TargetSection.TargetItem))
{
return null;
}
var redirectItem = new RedirectItem
{
ItemId = sectionToSection.ID,
Target = UrlNormalizer.GetItemUrl(sectionToSection.TargetSection.TargetItem),
Base = UrlNormalizer.Normalize(sectionToSection.BaseSection.Value),
RedirectCode = sectionToSection.RedirectCode,
Multisites = ConvertMultisites(sectionToSection.Multisites),
UseOnDefault = sectionToSection.UseOnDefault.Checked
};
return redirectItem;
}
/// <summary>
/// Adds the section to item redirect.
/// </summary>
/// <param name="item">The item.</param>
/// <returns>Redirect item</returns>
private static RedirectItem AddSectionToItemRedirect(Item item)
{
if (item == null)
{
return null;
}
var sectionToItem = new SectionToItem(item);
if (string.IsNullOrEmpty(sectionToItem.BaseSection.Value)
|| (string.IsNullOrEmpty(sectionToItem.TargetItem.Url) && sectionToItem.TargetItem.TargetItem == null))
{
return null;
}
var external = true;
var targetUrl = sectionToItem.TargetItem.Url;
if (sectionToItem.TargetItem.IsInternal)
{
if (!CheckPresentation(sectionToItem.TargetItem.TargetItem))
{
return null;
}
targetUrl = UrlNormalizer.GetItemUrl(sectionToItem.TargetItem.TargetItem);
external = false;
}
var redirectItem = new RedirectItem
{
ItemId = sectionToItem.ID,
Target = targetUrl,
TargetQueryString = sectionToItem.TargetItem.QueryString,
Base = UrlNormalizer.RemovePageExtension(UrlNormalizer.Normalize(sectionToItem.BaseSection.Value)),
External = external,
RedirectCode = sectionToItem.RedirectCode,
Multisites = ConvertMultisites(sectionToItem.Multisites),
UseOnDefault = sectionToItem.UseOnDefault.Checked
};
return redirectItem;
}
/// <summary>
/// Adds the section descendants.
/// </summary>
/// <param name="targetItemId">The target item id.</param>
/// <param name="baseSectionUrl">The base section URL.</param>
/// <param name="targetSectionUrl">The target section URL.</param>
/// <param name="itemId">The item id.</param>
/// <param name="redirectCode">The redirect code.</param>
/// <param name="multisites">The multisites.</param>
/// <param name="useOnDefaultSite">if set to <c>true</c> [use on default site].</param>
/// <returns>
/// list of items redirects
/// </returns>
private static IEnumerable<RedirectItem> AddSectionDescendants(
string targetItemId, string baseSectionUrl, string targetSectionUrl, ID itemId, int redirectCode, string multisites, bool useOnDefaultSite)
{
var sectionItem = Factory.GetDatabase(Configuration.Database).GetItem(targetItemId);
if (sectionItem == null)
{
return null;
}
var list = new List<RedirectItem>();
if (CheckPresentation(sectionItem))
{
var sectionRedirectItem = new RedirectItem
{
ItemId = itemId,
Target = targetSectionUrl,
Base = UrlNormalizer.CheckPageExtension(baseSectionUrl),
RedirectCode = redirectCode,
Multisites = multisites,
UseOnDefault = useOnDefaultSite
};
list.Add(sectionRedirectItem);
}
baseSectionUrl = UrlNormalizer.Normalize(baseSectionUrl);
targetSectionUrl = UrlNormalizer.RemovePageExtension(targetSectionUrl);
if (targetSectionUrl == "/")
{
list.AddRange(
from item in sectionItem.Axes.GetDescendants().Where(CheckPresentation)
select UrlNormalizer.GetItemUrl(item)
into targetUrl
let baseUrl = string.Format("{0}{1}", baseSectionUrl, targetUrl)
select new RedirectItem
{
ItemId = itemId,
Target = targetUrl,
Base = baseUrl,
External = false,
RedirectCode = redirectCode,
Multisites = multisites,
UseOnDefault = useOnDefaultSite
});
}
else
{
list.AddRange(
from item in sectionItem.Axes.GetDescendants().Where(CheckPresentation)
select UrlNormalizer.GetItemUrl(item)
into targetUrl
let baseUrl = targetUrl.Replace(targetSectionUrl, baseSectionUrl)
select new RedirectItem
{
ItemId = itemId,
Target = targetUrl,
Base = baseUrl,
External = false,
RedirectCode = redirectCode,
Multisites = multisites,
UseOnDefault = useOnDefaultSite
});
}
return list;
}
/// <summary>
/// Adds the item to list.
/// </summary>
/// <param name="item">The item.</param>
/// <param name="list">The list.</param>
/// <returns>
/// The list with added item.
/// </returns>
private static List<RedirectItem> AddItemToList(RedirectItem item, List<RedirectItem> list)
{
if (item != null)
{
if (!CheckDuplicates(item.Base, list))
{
list.Add(item);
}
}
return list;
}
