public virtual string GetPageLink(Item contextItem, ID fieldID)
{
var item = this.GetAccountsSettingsItem(contextItem);
if (item == null)
{
throw new Exception("Page with accounts settings isn't specified");
}
InternalLinkField link = item.Fields[fieldID];
if (link.TargetItem == null)
{
throw new Exception($"{link.InnerField.Name} link isn't set");
}
if (Sitecore.Context.Item.InFxm())
{
UrlOptions options = LinkManager.GetDefaultUrlOptions();
options.SiteResolving = true;
options.AlwaysIncludeServerUrl = true;
return(link.TargetItem.Url(options));
}
else
{
return(link.TargetItem.Url());
}
}
private string GetRewriteUrlFromItemId(Guid itemId)
{
var item = Sitecore.Context.Database.GetItem(new ID(itemId));
if (item == null)
{
return(null);
}
if (item.Paths.IsMediaItem)
{
var mediaUrlOptions = new MediaUrlOptions
{
AlwaysIncludeServerUrl = true
};
var mediaItem = new MediaItem(item);
return(MediaManager.GetMediaUrl(mediaItem, mediaUrlOptions));
}
else
{
var urlOptions = LinkManager.GetDefaultUrlOptions();
urlOptions.AlwaysIncludeServerUrl = true;
urlOptions.SiteResolving = true;
return(LinkManager.GetItemUrl(item, urlOptions));
}
}
public override void Apply(T ruleContext)
{
Assert.ArgumentNotNull((object)ruleContext, "ruleContext");
if (ruleContext.Item == null)
{
return;
}
var urlOptions = LinkManager.GetDefaultUrlOptions();
urlOptions.AlwaysIncludeServerUrl = true;
var url = LinkManager.GetItemUrl(ruleContext.Item, urlOptions);
if (!string.IsNullOrWhiteSpace(ValueOption))
{
switch (ValueOption)
{
case ItemIds.ValueOptions.Value1:
ruleContext.Value1 = url;
break;
case ItemIds.ValueOptions.Value2:
ruleContext.Value2 = url;
break;
case ItemIds.ValueOptions.Value3:
ruleContext.Value3 = url;
break;
}
}
}
protected override void MapSearchResults(ARPSearchSeachResultModel resultModel, SearchResults <BaseIndexModel> searchResultModel)
{
var urlOptions = LinkManager.GetDefaultUrlOptions();
urlOptions.LanguageEmbedding = LanguageEmbedding.AsNeeded;
var result = new List <BaseIndexModel>();
foreach (var model in searchResultModel.Hits.Select(q => q.Document))
{
var item = model.GetItem();
if (item == null)
{
model.ItemUrl = model.Url;
}
else
{
model.ItemUrl = item.Paths.IsMediaItem
? MediaManager.GetMediaUrl((MediaItem)item)
: Sitecore.Links.LinkManager.GetItemUrl(item, urlOptions);
}
result.Add(model);
}
resultModel.Results = result;
}
/// <summary>
/// Gets default url options object with AlwaysIncludeServerUrl set to true - meaning absolute paths!
/// </summary>
/// <returns></returns>
public static UrlOptions GetAbsoluteUrlOptions()
{
var urlOptions = LinkManager.GetDefaultUrlOptions();
urlOptions.AlwaysIncludeServerUrl = true;
return(urlOptions);
}
/// <summary>
/// Use the Sitecore LinkManager to generate the Url for the item for a specified language
/// </summary>
/// <param name="language">The Sitecore language code</param>
/// <returns></returns>
public string GenerateUrl(string language)
{
var options = LinkManager.GetDefaultUrlOptions();
options.Language = Language.Parse(language);
return(LinkManager.GetItemUrl(Item, options));
}
public object ComputeFieldValue(IIndexable indexable)
{
Item item = (Item)(indexable as SitecoreIndexableItem);
if (item == null)
{
return((object)null);
}
if (item.Paths.IsMediaItem)
{
return((object)MediaManager.GetMediaUrl((MediaItem)item));
}
UrlOptions defaultUrlOptions = LinkManager.GetDefaultUrlOptions();
defaultUrlOptions.Site = Sitecore.Configuration.Factory.GetSite("ilightsingapore2019");
defaultUrlOptions.AlwaysIncludeServerUrl = false;
defaultUrlOptions.LanguageEmbedding = LanguageEmbedding.Never;
string url = LinkManager.GetItemUrl(item, defaultUrlOptions);
//hack: last minute fix, not the best thing to do
if (url.ToLower().StartsWith("://" + defaultUrlOptions.Site.HostName))
{
url = url.ToLower().Replace("://" + defaultUrlOptions.Site.HostName, "");
}
return(url);
}
public object ComputeFieldValue(IIndexable indexable)
{
Item item = (Item)(indexable as SitecoreIndexableItem);
if (item == null)
{
return(null);
}
if (item.Paths.IsMediaItem)
{
return(MediaManager.GetMediaUrl(item));
}
UrlOptions defaultUrlOptions = LinkManager.GetDefaultUrlOptions();
//defaultUrlOptions.LanguageEmbedding= LanguageEmbedding.Never;
defaultUrlOptions.SiteResolving = Settings.Rendering.SiteResolving;
var link = LinkManager.GetItemUrl(item, defaultUrlOptions);
var noProtocol = link.Replace("://", String.Empty);
var siteName = noProtocol.Split('/');
var processedLink = noProtocol.Replace(siteName[0], String.Empty);
return(processedLink);
}
public Models.OpenGraphMetadata GetOpenGraphMetadata()
{
if (!this.SitecoreContext.Item.IsDerived(Templates.OpenGraph.ID))
{
return(null);
}
var options = LinkManager.GetDefaultUrlOptions();
options.AlwaysIncludeServerUrl = true;
var metadata = new Models.OpenGraphMetadata()
{
Title = this.GetStringField(Templates.OpenGraph.Fields.Title, (item) => item.Fields[Templates.OpenGraph.Fields.TitleName] != null ? item.Fields[Templates.OpenGraph.Fields.TitleName].Value : string.Empty),
Description = this.GetStringField(Templates.OpenGraph.Fields.Description, (item) => item.Fields[Templates.OpenGraph.Fields.DescriptionName] != null ? item.Fields[Templates.OpenGraph.Fields.DescriptionName].Value : string.Empty),
Type = this.GetStringField(Templates.OpenGraph.Fields.Type, (item) => DefaultType),
ItemUrl = this.SitecoreContext.Item.Url(options),
ImageUrl = this.GetImageField(Templates.OpenGraph.Fields.Image, (item) => {
if (item.Fields[Templates.OpenGraph.Fields.ImageName] == null)
{
return(string.Empty);
}
var imgField = ((Data.Fields.ImageField)item.Fields[Templates.OpenGraph.Fields.ImageName]);
return(Resources.Media.MediaManager.GetMediaUrl(imgField.MediaItem, new Resources.Media.MediaUrlOptions
{
AlwaysIncludeServerUrl = true,
AbsolutePath = true
}));
})
};
return(metadata);
}
/// <summary>
/// Use the Sitecore LinkManager to generate the Url ensuring the host name is always included
/// </summary>
/// <param name="includeHostname">If true the hostname will always be added to the Url</param>
/// <returns></returns>
public virtual string GenerateUrl(bool includeHostname)
{
var options = LinkManager.GetDefaultUrlOptions();
options.AlwaysIncludeServerUrl = includeHostname;
return(LinkManager.GetItemUrl(Item, options));
}
public override string Execute(object value)
{
var item = value as Item;
var options = LinkManager.GetDefaultUrlOptions();
options.AlwaysIncludeServerUrl = true;
return(item != null?item.Url(options) : string.Empty);
}
internal static void GetRedirectUrlOrItemId(LinkField redirectTo, out string actionRewriteUrl, out string redirectItemAnchor)
{
actionRewriteUrl = null;
redirectItemAnchor = null;
var urlOptions = LinkManager.GetDefaultUrlOptions();
urlOptions.AlwaysIncludeServerUrl = true;
urlOptions.SiteResolving = true;
var mediaUrlOptions = new MediaUrlOptions
{
AlwaysIncludeServerUrl = true
};
switch (redirectTo.LinkType.ToLower())
{
case "internal":
// Use LinkMananger for internal links, if link is not empty
actionRewriteUrl = redirectTo.TargetItem != null?Sitecore.Links.LinkManager.GetItemUrl(redirectTo.TargetItem, urlOptions) : string.Empty;
break;
case "media":
// Use MediaManager for media links, if link is not empty
actionRewriteUrl = redirectTo.TargetItem != null?Sitecore.Resources.Media.MediaManager.GetMediaUrl(redirectTo.TargetItem, mediaUrlOptions) : string.Empty;
break;
case "external":
// Just return external links
actionRewriteUrl = redirectTo.Url;
break;
case "mailto":
// Just return mailto link
actionRewriteUrl = redirectTo.Url;
break;
case "javascript":
case "anchor":
throw new ArgumentException("Redirect type is invalid");
}
if (redirectTo.Anchor != null)
{
redirectItemAnchor = redirectTo.Anchor;
}
if (!string.IsNullOrEmpty(redirectTo.QueryString) && actionRewriteUrl != null)
{
var uriBuilder = new UriBuilder(new Uri(actionRewriteUrl))
{
Query = redirectTo.QueryString
};
actionRewriteUrl = uriBuilder.ToString();
}
}
public static string SitecoreCanonicalUrl(this HtmlHelper helper, Item item)
{
var options = LinkManager.GetDefaultUrlOptions();
options.AlwaysIncludeServerUrl = true;
options.LanguageEmbedding = LanguageEmbedding.Always;
options.SiteResolving = true;
return(LinkManager.GetItemUrl(item, options));
}
public static string GetPageNotFoundItem(string itemNotFoundPageItemPath)
{
var item = Context.Database.GetItem(itemNotFoundPageItemPath);
var options = LinkManager.GetDefaultUrlOptions();
options.AlwaysIncludeServerUrl = false;
options.AddAspxExtension = false;
return(LinkManager.GetItemUrl(item, options));
}
// TODO:
/// <summary>
/// Prepares dynamic items - items accessed by wildcard
/// </summary>
/// <param name="wildcardItem">Wildcard Item</param>
/// <param name="sitemapSiteConfiguration">Sitemap site configuration</param>
/// <param name="xml">XmlTextWriter object</param>
//protected virtual void PrepareDynamicItems(Item wildcardItem, SitemapSiteConfiguration sitemapSiteConfiguration, XmlTextWriter xml)
//{
// var dynamicRoute = sitemapSiteConfiguration.DynamicRoutes.SingleOrDefault(x => x["Dynamic Item"] == wildcardItem.ID.ToString());
// if (dynamicRoute != null)
// {
// var datasource = Database.GetItem(dynamicRoute["Data Source"]);
// if (datasource != null && datasource.HasChildren)
// {
// UrlOptions options = GetUrlOptions();
// options.Site = sitemapSiteConfiguration.Site;
// var dynamicItemActualUrl = LinkManager.GetItemUrl(wildcardItem, options);
// foreach (var item in datasource.Children.ToList())
// {
// if (item.Versions.Count > 0 && IsIncluded(item, sitemapSiteConfiguration, true))
// {
// var lastSegment = item.Name;
// lastSegment = options.LowercaseUrls ? lastSegment.ToLower() : lastSegment;
// var url = dynamicItemActualUrl
// .Replace(",-w-,", lastSegment)
// .Replace("*", lastSegment);
// url = DynamicSitemapHelper.EnsureHttpPrefix(url, sitemapSiteConfiguration.ForceHttps);
// if (!String.IsNullOrEmpty(sitemapSiteConfiguration.ServerHost))
// {
// url = DynamicSitemapHelper.ReplaceHost(url, sitemapSiteConfiguration.ServerHost);
// }
// GenerateUrlElement(url, item, sitemapSiteConfiguration, xml);
// }
// }
// }
// }
//}
/// <summary>
/// Gets default UrlOptions
/// </summary>
/// <returns></returns>
protected virtual UrlOptions GetUrlOptions()
{
var urlOptions = LinkManager.GetDefaultUrlOptions();
urlOptions.AlwaysIncludeServerUrl = true;
urlOptions.SiteResolving = true;
return(urlOptions);
}
private static object GetSitecoreItemPropertyValue(Type propertyType, Item item, SitecoreItemPropertyAttribute attribute)
{
object value = null;
switch (attribute.ItemInfoType)
{
case SitecoreItemInfo.Id:
value = item.ID;
break;
case SitecoreItemInfo.DisplayName:
value = item.DisplayName;
break;
case SitecoreItemInfo.FullPath:
value = item.Paths.FullPath;
break;
case SitecoreItemInfo.Language:
value = item.Language;
break;
case SitecoreItemInfo.Name:
value = item.Name;
break;
case SitecoreItemInfo.Path:
value = item.Paths.Path;
break;
case SitecoreItemInfo.TemplateId:
value = item.TemplateID;
break;
case SitecoreItemInfo.TemplateName:
value = item.TemplateName;
break;
case SitecoreItemInfo.Version:
value = item.Version;
break;
case SitecoreItemInfo.HasLayout:
value = item.Visualization.Layout != null;
break;
case SitecoreItemInfo.Uri:
value = item.Uri;
break;
case SitecoreItemInfo.Url:
value = LinkManager.GetItemUrl(item, LinkManager.GetDefaultUrlOptions());
break;
}
return(value);
}
public static ItemInfo FromItem(Item item, IEnumerable <string> websites = null, int?maxDepth = null, Language language = null)
{
var info = new ItemInfo();
info.Id = item.ID.Guid;
info.Name = item.Name;
info.DisplayName = item.DisplayName;
info.Version = item.Version.Number;
info.Language = item.Language.Name;
info.Path = item.Paths.FullPath;
info.ParentId = item.ParentID.Guid;
info.TemplateId = item.TemplateID.Guid;
info.TemplateName = info.TemplateName;
info.HasLayout = item.Fields[FieldIDs.LayoutField] != null &&
!string.IsNullOrEmpty(item.Fields[FieldIDs.LayoutField].Value);
foreach (Field field in item.Fields)
{
info.Fields[field.Name] = field.Value;
}
if (!maxDepth.HasValue || maxDepth > 0)
{
info.Children = item.Children.Select(child => FromItem(child, websites, maxDepth.HasValue ? maxDepth - 1 : null)).ToList();
}
if (websites != null)
{
var current = Context.GetSiteName();
foreach (var website in websites)
{
Context.SetActiveSite(website);
var options = LinkManager.GetDefaultUrlOptions();
options.AlwaysIncludeServerUrl = true;
if (language != null)
{
options.Language = language;
}
info.SiteUrls[website] = new ItemUrl
{
Url = LinkManager.GetItemUrl(item, options),
InSiteContext = item.Paths.FullPath.StartsWith(Context.Site.RootPath + Context.Site.StartItem)
};
}
if (!string.IsNullOrEmpty(current))
{
Context.SetActiveSite(current);
}
}
return(info);
}
private static UrlOptions GetItemUrlOptions(SiteContext siteContext)
{
UrlOptions urlOptions = LinkManager.GetDefaultUrlOptions();
urlOptions.Site = siteContext;
urlOptions.SiteResolving = true;
urlOptions.AlwaysIncludeServerUrl = true;
urlOptions.LanguageEmbedding = LanguageEmbedding.Never;
return(urlOptions);
}
private static string GetItemUrl(Item landingPageItem)
{
var options = LinkManager.GetDefaultUrlOptions();
options.AlwaysIncludeServerUrl = true;
var uri = new Uri(LinkManager.GetItemUrl(landingPageItem, options));
return(uri.PathAndQuery);
}
public override void Process(HttpRequestArgs args)
{
Assert.ArgumentNotNull(args, "args");
string url = args.Context.Request.Url.PathAndQuery;
// if ItemResolver failed to find an Item
if (((Context.Item == null) && string.IsNullOrEmpty(Context.Page.FilePath)) || url.Contains("404;"))
{
// extract 404 url
if (url.Contains("404;"))
{
url = Regex.Replace(HttpUtility.UrlDecode(url), ".*404;(.*)", "$1");
}
// find an Item Redirect
RedirectEntry redirect = RedirectManager.GetRedirect(Sitecore.Context.GetSiteName(), url);
if (redirect != null)
{
UrlString newUrl = null;
Item item = Context.Database.GetItem(new ID(redirect.ItemID));
if (item != null)
{
UrlOptions options = LinkManager.GetDefaultUrlOptions();
newUrl = new UrlString(LinkManager.GetItemUrl(item, options));
}
if (newUrl != null && !string.IsNullOrEmpty(redirect.QueryString))
{
var qsParameters = StringUtil.ParseNameValueCollection(redirect.QueryString, '&', '=');
foreach (string key in qsParameters.AllKeys)
{
newUrl[key] = qsParameters[key];
}
}
// avoid looping
if (newUrl != null && string.Compare(url, newUrl.ToString(), true) != 0)
{
args.AbortPipeline();
RedirectUtils.Do301Redirect(args.Context.Response, newUrl.ToString());
}
}
// no Item redirect found, try a NotFoundRule
else if (url != null)
{
NotFoundRule rule = RedirectManager.ResolveRedirectRule(Sitecore.Context.GetSiteName(), url);
if (rule != null)
{
ExecuteRule(url, rule, args);
}
}
}
}
public string GetTargetUrl(string sitename)
{
Item targetItem = this.GetTargetItem();
if (targetItem != null)
{
UrlOptions defaultUrlOptions = LinkManager.GetDefaultUrlOptions();
defaultUrlOptions.AlwaysIncludeServerUrl = true;
return(LinkManager.GetItemUrl(targetItem));
}
return(null);
}
private string GetRewriteUrlFromItemId(Guid rewriteItemId, Guid?targetLanguage, string rewriteItemAnchor)
{
string rewriteUrl = null;
var db = Sitecore.Context.Database;
if (db != null)
{
var rewriteItem = db.GetItem(new ID(rewriteItemId));
if (rewriteItem != null)
{
if (targetLanguage.HasValue)
{
var language = rewriteItem.Languages.Where(l => LanguageManager.GetLanguageItemId(l, Sitecore.Context.Database).Guid == targetLanguage.Value).FirstOrDefault();
if (language != null)
{
Sitecore.Context.Language = language;
rewriteItem = db.GetItem(rewriteItem.ID, language);
}
}
if (rewriteItem.Paths.IsMediaItem)
{
var mediaUrlOptions = new MediaUrlOptions
{
AlwaysIncludeServerUrl = true
};
rewriteUrl = MediaManager.GetMediaUrl(rewriteItem, mediaUrlOptions);
}
else
{
var urlOptions = LinkManager.GetDefaultUrlOptions();
urlOptions.AlwaysIncludeServerUrl = true;
urlOptions.SiteResolving = true;
rewriteUrl = LinkManager.GetItemUrl(rewriteItem, urlOptions);
}
if (!string.IsNullOrEmpty(rewriteItemAnchor))
{
rewriteUrl += string.Format("#{0}", rewriteItemAnchor);
}
}
}
return(rewriteUrl);
}
public void Process(SitemapItemLinkArgs args)
{
Assert.ArgumentNotNull(args, nameof(args));
using (new SiteContextSwitcher(args.CustomItem.SiteContext))
using (new LanguageSwitcher(args.CustomItem.Item.Language))
{
var urlOptions = LinkManager.GetDefaultUrlOptions();
urlOptions.AlwaysIncludeServerUrl = true;
args.Link = LinkManager.GetItemUrl(args.CustomItem.Item, urlOptions);
}
}
public static void EnrichItemModel(ItemModel model, string defaultLanguage, bool includeEditMode = false)
{
if (model == null)
{
return;
}
if (model.ContainsKey("TemplateID") && !model.ContainsKey("TemplateIDs"))
{
var templateId = new ID((Guid)model["TemplateID"]);
var template = TemplateManager.GetTemplate(templateId, global::Sitecore.Context.Database);
if (template != null)
{
model.Add("TemplateIDs", template.GetBaseTemplates().Select(t => t.ID.Guid).Concat(new[] { templateId.Guid }));
}
}
var scItem = global::Sitecore.Context.Database.GetItem(new ID((Guid)model["ItemID"]));//TODO: should we get it again? Better to fix modelfactory instead
if (scItem == null)
{
return;
}
if (!model.ContainsKey("ParentIds"))
{
model.Add("ParentIds", scItem?.Paths?.LongID?.Split(new[] { '/' }, StringSplitOptions.RemoveEmptyEntries).Select(id => new Guid(id)));
}
if (!model.ContainsKey("ItemUrlExpanded"))
{
var urlOptions = LinkManager.GetDefaultUrlOptions();
urlOptions.AlwaysIncludeServerUrl = false;
urlOptions.SiteResolving = true;
urlOptions.LanguageEmbedding = scItem.Language.Name == defaultLanguage ? LanguageEmbedding.Never : LanguageEmbedding.Always;
urlOptions.LowercaseUrls = true;
model.Add("ItemUrlExpanded", LinkManager.GetItemUrl(scItem, urlOptions));
}
if (includeEditMode)
{
var editor = new Dictionary <string, string>();
foreach (var field in model.Keys)
{
var editfield = EditField(field, scItem);
if (!string.IsNullOrEmpty(editfield))
{
editor.Add(field, editfield);
}
}
model.Add("FieldEditors", editor);
}
}
/// <summary>
/// Retrieves the end user friendly URL that matches the specified Sitecore item.
/// </summary>
/// <param name="helper"></param>
/// <param name="item"></param>
/// <returns></returns>
public static string SitecoreUrl(this HtmlHelper helper, Item item)
{
if (item != null)
{
if (Sitecore.Context.PageMode.IsExperienceEditorEditing)
{
return(LinkManager.GetDynamicUrl(item));
}
var options = LinkManager.GetDefaultUrlOptions();
options.SiteResolving = true;
return(LinkManager.GetItemUrl(item, options));
}
return(string.Empty);
}
public override object ComputeFieldValue(IIndexable indexable)
{
var indexableItem = indexable as SitecoreIndexableItem;
if (indexableItem == null)
{
return(null);
}
var item = indexableItem.Item;
var options = LinkManager.GetDefaultUrlOptions();
options.SiteResolving = true;
return(LinkManager.GetItemUrl(item, options));
}
public override object ComputeFieldValue(IIndexable indexable)
{
Item item = indexable as SitecoreIndexableItem;
if (item == null)
{
return(null);
}
UrlOptions defaultUrlOptions = LinkManager.GetDefaultUrlOptions();
defaultUrlOptions.SiteResolving = true;
var calculateUrl = LinkManager.GetItemUrl(item, defaultUrlOptions);
return(calculateUrl);
}
protected override void Execute(HttpRequestArgs args)
{
if (Sitecore.Context.Site == null)
{
// We can't do anything, exit.
Log.Debug($"Verndale.Feature.LanguageFallback DefaultSiteLanguageResolver: No context site for {HttpContext.Current.Request.Url.OriginalString}", this);
return;
}
// Figure out if the language is in the URL already
var urlLanguage = GetLanguageFromUrl(args);
if (urlLanguage != null)
{
// and if the supplied language is legal for this site.
if (IsUrlLanguageValidForSite(urlLanguage))
{
Sitecore.Context.Language = urlLanguage; // yup, we're done.
return;
}
// Language is not supported. We need to 404.
// We ABSOLUTELY have to redirect here, because this Processor runs BEFORE Item Resolver, so any setting of the
// context item here will be overwritten by the pipeline, which we don't want.
SetLanguageToDefaultForSite(); // This ensures the generated link has the right language.
var target = PageNotFoundRepository.GetPageNotFoundItem(Sitecore.Context.Site, Sitecore.Context.Language, Sitecore.Context.Database);
var options = LinkManager.GetDefaultUrlOptions();
options.LanguageEmbedding = LanguageEmbedding.Always; // force the URL to switch language.
var url = LinkManager.GetItemUrl(target, options);
// Perform's a TransferRequest rather than a redirect.
if (Sitecore.Configuration.Settings.RequestErrors.UseServerSideRedirect)
{
HttpContext.Current.Server.TransferRequest(url);
}
else
{
WebUtil.Redirect(url, true);
}
}
// No valid language in the URL, therefore we can force the site's default language
SetLanguageToDefaultForSite();
}
private void CheckForRegExMatch(Database db, string requestedUrl, string requestedPathAndQuery, HttpRequestArgs args)
{
// Loop through the pattern match items to find a match
foreach (Item possibleRedirectPattern in GetRedirects(db, Constants.Templates.RedirectPattern, Constants.Templates.VersionedRedirectPattern, Sitecore.Configuration.Settings.GetSetting(Constants.Settings.QueryExactMatch)))
{
var redirectPath = string.Empty;
if (Regex.IsMatch(requestedUrl, possibleRedirectPattern[Constants.Fields.RequestedExpression], RegexOptions.IgnoreCase))
{
redirectPath = Regex.Replace(requestedUrl, possibleRedirectPattern[Constants.Fields.RequestedExpression],
possibleRedirectPattern[Constants.Fields.SourceItem], RegexOptions.IgnoreCase);
}
else if (Regex.IsMatch(requestedPathAndQuery, possibleRedirectPattern[Constants.Fields.RequestedExpression], RegexOptions.IgnoreCase))
{
redirectPath = Regex.Replace(requestedPathAndQuery,
possibleRedirectPattern[Constants.Fields.RequestedExpression],
possibleRedirectPattern[Constants.Fields.SourceItem], RegexOptions.IgnoreCase);
}
if (string.IsNullOrEmpty(redirectPath))
{
continue;
}
// Query portion gets in the way of getting the sitecore item.
var pathAndQuery = redirectPath.Split('?');
var path = pathAndQuery[0];
#if (SC82)
if (LinkManager.Provider != null &&
LinkManager.Provider.GetDefaultUrlOptions() != null &&
LinkManager.Provider.GetDefaultUrlOptions().EncodeNames)
#else
if (LinkManager.GetDefaultUrlOptions() != null &&
LinkManager.GetDefaultUrlOptions().EncodeNames)
#endif
{
path = Sitecore.MainUtil.DecodeName(path);
}
var redirectToItem = db.GetItem(path);
if (redirectToItem != null)
{
var query = pathAndQuery.Length > 1 ? "?" + pathAndQuery[1] : "";
var responseStatus = GetResponseStatus(possibleRedirectPattern);
SendResponse(redirectToItem, query, responseStatus, args);
}
}
}
//string currentPage = "/";
public override void ExecuteAction(FormSubmitContext formSubmitContext, string parameters)
{
try
{
Log.Error("Error in Form Submission", "");
string currentPage = "/";
currentPage = HttpContext.Current.Request.Headers["Referer"];
if (string.IsNullOrEmpty(currentPage) || currentPage == "/")
{
Uri referrer = HttpContext.Current.Request.UrlReferrer;
currentPage = referrer.ToString();
}
if (currentPage.Contains("?"))
{
currentPage = currentPage.Split('?')[0];
}
if (this.Execute("", formSubmitContext))
{
var thankyou = currentPage + "?status=success";
var defaultUrlOptions = LinkManager.GetDefaultUrlOptions();
defaultUrlOptions.SiteResolving = Settings.Rendering.SiteResolving;
formSubmitContext.RedirectUrl = thankyou;
formSubmitContext.RedirectOnSuccess = true;
formSubmitContext.Abort();
}
else
{
var errorpage = currentPage + "?status=failed";
var defaultUrlOptions = LinkManager.GetDefaultUrlOptions();
defaultUrlOptions.SiteResolving = Settings.Rendering.SiteResolving;
formSubmitContext.RedirectUrl = errorpage;
formSubmitContext.RedirectOnSuccess = true;
formSubmitContext.Abort();
}
}
catch (Exception e)
{
Log.Error("Error in Form Submission" + e.Message, "");
Log.Error("Error in Form Submission2" + e.StackTrace, "");
Log.Error("Error in Form Submission1" + e.InnerException.ToString(), "");
}
}
