protected void ImportLinksToCommentTable(IList<App.Models.Questions.Questions> questions)
{
CommentManager commentManager = new CommentManager();
IList<Comment> comments = commentManager.GetList();
LinkManager linkManager = new LinkManager();
foreach (App.Models.Questions.Questions question in questions)
{
IList<Link> links = linkManager.GetLinksForQuestion(question.QuestionID);
if(links != null && links.Count > 0)
AddLinksToTheCommentTable(links, comments, question.QuestionID);
}
}
public override void Process(HttpRequestArgs args)
{
var site = Sitecore.Context.Site.GetSiteSettings <IPWhiteListSiteSettings>();
if (site == null)
{
return;
}
if (site.WhiteListingEnabled && (Context.Item == null || !Context.Item.ID.Guid.Equals(site.RestrictedAccessPageId)))
{
IPAddress clientIP = null;
if (IPAddress.TryParse(args.Context.Request.UserHostAddress, out clientIP))
{
var globalFolder = Context.Database.GetItem(new Sitecore.Data.ID(GlobalRulesFolderID));
var siteFolder = Context.Database.GetItem(new Sitecore.Data.ID(site.SiteConfigurationId)).Children.Where(a => a.DisplayName == "IP White List").FirstOrDefault();;
foreach (var ip in GetIPs(globalFolder, "GlobalWhiteListedIPs"))
{
if (clientIP.Equals(ip))
{
return;
}
}
foreach (var range in GetRanges(globalFolder, "GlobalWhiteListedRanges"))
{
if (range.IsInRange(clientIP))
{
return;
}
}
if (siteFolder != null)
{
foreach (var ip in GetIPs(siteFolder, site.SiteConfigurationId + "WhiteListedIPs"))
{
if (clientIP.Equals(ip))
{
return;
}
}
foreach (var range in GetRanges(siteFolder, site.SiteConfigurationId + "WhiteListedRanges"))
{
if (range.IsInRange(clientIP))
{
return;
}
}
}
//We're not White Listed, try custom page with 302 redirect
try
{
var restricedPageUrl = LinkManager.GetItemUrl(Context.Database.GetItem(new Sitecore.Data.ID(site.RestrictedAccessPageId)));
args.Context.Response.Status = "302 Moved Temporarily";
args.Context.Response.StatusCode = (int)System.Net.HttpStatusCode.Moved;
args.Context.Response.AddHeader("Location", restricedPageUrl);
args.Context.Response.End();
}
catch
{
//use default IIS 403 instead
args.Context.Response.StatusCode = (int)System.Net.HttpStatusCode.Forbidden;
args.Context.Response.End();
}
}
}
}
/// <summary>
/// Sets the field.
/// </summary>
/// <param name="field">The field.</param>
/// <param name="value">The value.</param>
/// <param name="config">The config.</param>
/// <param name="context">The context.</param>
/// <exception cref="Glass.Mapper.MapperException">
/// No item with ID {0}. Can not update Link linkField.Formatted(newId)
/// or
/// No item with ID {0}. Can not update Link linkField.Formatted(newId)
/// </exception>
public override void SetField(Field field, object value, SitecoreFieldConfiguration config, SitecoreDataMappingContext context)
{
Link link = value as Link;
if (field == null)
{
return;
}
var item = field.Item;
LinkField linkField = new LinkField(field);
if (link == null || link.Type == LinkType.NotSet)
{
linkField.Clear();
return;
}
switch (link.Type)
{
case LinkType.Internal:
linkField.LinkType = "internal";
if (linkField.TargetID.Guid != link.TargetId)
{
if (link.TargetId == Guid.Empty)
{
ItemLink iLink = new ItemLink(item.Database.Name, item.ID, linkField.InnerField.ID, linkField.TargetItem.Database.Name, linkField.TargetID, linkField.TargetItem.Paths.FullPath);
linkField.RemoveLink(iLink);
}
else
{
ID newId = new ID(link.TargetId);
Item target = item.Database.GetItem(newId);
if (target != null)
{
linkField.TargetID = newId;
ItemLink nLink = new ItemLink(item.Database.Name, item.ID, linkField.InnerField.ID, target.Database.Name, target.ID, target.Paths.FullPath);
linkField.UpdateLink(nLink);
linkField.Url = LinkManager.GetItemUrl(target);
}
else
{
throw new MapperException("No item with ID {0}. Can not update Link linkField".Formatted(newId));
}
}
}
break;
case LinkType.Media:
linkField.LinkType = "media";
if (linkField.TargetID.Guid != link.TargetId)
{
if (link.TargetId == Guid.Empty)
{
ItemLink iLink = new ItemLink(item.Database.Name, item.ID, linkField.InnerField.ID, linkField.TargetItem.Database.Name, linkField.TargetID, linkField.TargetItem.Paths.FullPath);
linkField.RemoveLink(iLink);
}
else
{
ID newId = new ID(link.TargetId);
Item target = item.Database.GetItem(newId);
if (target != null)
{
global::Sitecore.Data.Items.MediaItem media = new global::Sitecore.Data.Items.MediaItem(target);
linkField.TargetID = newId;
ItemLink nLink = new ItemLink(item.Database.Name, item.ID, linkField.InnerField.ID, target.Database.Name, target.ID, target.Paths.FullPath);
linkField.UpdateLink(nLink);
linkField.Url = global::Sitecore.Resources.Media.MediaManager.GetMediaUrl(media);
}
else
{
throw new MapperException("No item with ID {0}. Can not update Link linkField".Formatted(newId));
}
}
}
break;
case LinkType.External:
linkField.LinkType = "external";
linkField.Url = link.Url;
break;
case LinkType.Anchor:
linkField.LinkType = "anchor";
linkField.Url = link.Anchor;
break;
case LinkType.MailTo:
linkField.LinkType = "mailto";
linkField.Url = link.Url;
break;
case LinkType.JavaScript:
linkField.LinkType = "javascript";
linkField.Url = link.Url;
break;
}
if (!link.Anchor.IsNullOrEmpty())
{
linkField.Anchor = link.Anchor;
}
if (!link.Class.IsNullOrEmpty())
{
linkField.Class = link.Class;
}
if (!link.Text.IsNullOrEmpty())
{
linkField.Text = link.Text;
}
if (!link.Title.IsNullOrEmpty())
{
linkField.Title = link.Title;
}
if (!link.Query.IsNullOrEmpty())
{
linkField.QueryString = link.Query;
}
if (!link.Target.IsNullOrEmpty())
{
linkField.Target = link.Target;
}
}
private void CreateRedirectItem(Item item, Item oldParent)
{
// we only want a redirect on pages and media assets
if (oldParent.Paths.IsContentItem || oldParent.Paths.IsMediaItem)
{
string oldPath = LinkManager.GetItemUrl(oldParent).Replace("/sitecore/shell", "") + "/" + LinkManager.GetItemUrl(item).Split('/').Last();
Database db = Sitecore.Configuration.Factory.GetDatabase("master");
// Get the generated folder underneath the redirects folder. It is a bucketed item.
Item parentItem = db.GetItem(new ID("{46CE2092-FF8D-454E-B826-A2ADDB7E0BA3}"));
if (parentItem != null)
{
//Now we need to get the template from which the item is created (Redirect Url)
TemplateItem template = db.GetTemplate(new ID("{B5967A68-7F70-42D3-9874-0E4D001DBC20}"));
if (template != null)
{
// Create the item
Item newItem = parentItem.Add(ItemUtil.ProposeValidItemName(oldPath.Replace('/', ' ')), template);
newItem.Editing.BeginEdit();
try
{
// Assign values to the fields of the new item
newItem.Fields["Requested Url"].Value = oldPath;
newItem.Fields["Response Status Code"].Value = "{3184B308-C050-4A16-9F82-D77190A28F0F}"; // 301
newItem.Fields["Redirect To Item"].Value = item.ID.ToString();
newItem.Editing.EndEdit();
}
catch (System.Exception ex)
{
// The update failed, write a message to the log
Sitecore.Diagnostics.Log.Error("Could not update item " + newItem.Paths.FullPath + ": " + ex.Message, this);
newItem.Editing.CancelEdit();
}
}
}
}
}
public static string ItemUrl(this SitecoreHelper sitecoreHelper, Item item)
{
return(LinkManager.GetItemUrl(item));
}
/// <summary>
/// Maps data from the CMS value to the .Net property value
/// </summary>
/// <param name="mappingContext">The mapping context.</param>
/// <returns>System.Object.</returns>
/// <exception cref="Glass.Mapper.MapperException">SitecoreInfoType {0} not supported.Formatted(scConfig.Type)</exception>
public override object MapToProperty(AbstractDataMappingContext mappingContext)
{
var context = mappingContext as SitecoreDataMappingContext;
if (context == null)
{
throw new NullReferenceException("Mapping Context has not been set.");
}
var item = context.Item;
var scConfig = Configuration as SitecoreInfoConfiguration;
if (scConfig == null)
{
throw new NullReferenceException("Configuration has not been set.");
}
//TODO: move this to the config?
var urlOptions = Utilities.CreateUrlOptions(scConfig.UrlOptions);
switch (scConfig.Type)
{
case SitecoreInfoType.ContentPath:
return(item.Paths.ContentPath);
case SitecoreInfoType.DisplayName:
return(item[Global.Fields.DisplayName]);
case SitecoreInfoType.FullPath:
return(item.Paths.FullPath);
case SitecoreInfoType.Name:
return(item.Name);
case SitecoreInfoType.Key:
return(item.Key);
case SitecoreInfoType.MediaUrl:
var media = new MediaItem(item);
return(MediaManager.GetMediaUrl(media));
case SitecoreInfoType.Path:
return(item.Paths.Path);
case SitecoreInfoType.TemplateId:
if (scConfig.PropertyInfo != null && scConfig.PropertyInfo.PropertyType == typeof(ID))
{
return(item.TemplateID);
}
return(item.TemplateID.Guid);
case SitecoreInfoType.TemplateName:
return(item.TemplateName);
case SitecoreInfoType.Url:
urlOptions.Language = null;
return(LinkManager.GetItemUrl(item, urlOptions));
case SitecoreInfoType.Version:
if (scConfig.PropertyInfo != null && scConfig.PropertyInfo.PropertyType == typeof(string))
{
return(item.Version.Number.ToString());
}
return(item.Version.Number);
case SitecoreInfoType.Language:
if (scConfig.PropertyInfo != null && scConfig.PropertyInfo.PropertyType == typeof(string))
{
return(item.Language.Name);
}
return(item.Language);
case SitecoreInfoType.BaseTemplateIds:
Template template = TemplateManager.GetTemplate(item.TemplateID, item.Database);
if (scConfig.PropertyInfo != null &&
scConfig.PropertyInfo.PropertyType == typeof(IEnumerable <ID>))
{
return(template.GetBaseTemplates().Select(x => x.ID));
}
return(template.GetBaseTemplates().Select(x => x.ID.Guid));
case SitecoreInfoType.ItemUri:
return(new ItemUri(item.ID, item.Language, item.Version, item.Database));
#if SC81
case SitecoreInfoType.OriginalLanguage:
return(item.OriginalLanguage);
case SitecoreInfoType.OriginatorId:
return(item.OriginatorId);
#endif
default:
throw new MapperException("SitecoreInfoType {0} not supported".Formatted(scConfig.Type));
}
}
/// <summary>
/// Page unload - remove eventhandler for LinkManager.EnsureQueries
/// </summary>
protected void Page_Unload(object sender, EventArgs e)
{
LinkManager.UnregisterEnsureQueries(LinkManager_EnsureQueries);
}
protected void RenderToScreen(SavedQuery query, PXModel model, string defaultLayout, string page, bool safe)
{
if (query.Sources.Count < 1)
{
throw new Exception("No source specified"); //TODO fix message
}
var src = query.Sources[0];
if (string.Compare(src.SourceIdType, "path") != 0)
{
throw new Exception("Incompatible source type"); //TODO fix
}
string layout;
if (query.Output.Params.ContainsKey("layout"))
{
layout = query.Output.Params["layout"] ?? defaultLayout;
}
else
{
layout = defaultLayout;
}
string path = src.Source;
var tableName = GetTableName(src);
path = path.Substring(0, path.Length - (tableName.Length + 1));
if (string.Compare(query.Sources[0].Type, "CNMM") == 0)
{
if (!path.StartsWith("START"))
{
path = "START__" + path;
}
}
path = path.Replace(@"/", PxPathHandler.NODE_DIVIDER);
string url = null;
if (RouteInstance.RouteExtender == null)
{
List <LinkManager.LinkItem> linkItems = new List <LinkManager.LinkItem>();
linkItems.Add(new LinkManager.LinkItem(PxUrl.TABLE_KEY, tableName));
linkItems.Add(new LinkManager.LinkItem(PxUrl.PATH_KEY, path.ToString()));
linkItems.Add(new LinkManager.LinkItem(PxUrl.DB_KEY, src.DatabaseId));
linkItems.Add(new LinkManager.LinkItem(PxUrl.LANGUAGE_KEY, model.Meta.CurrentLanguage));
linkItems.Add(new LinkManager.LinkItem(PxUrl.LAYOUT_KEY, layout));
url = LinkManager.CreateLink(page, false, linkItems.ToArray());
}
else
{
string tableId = RouteInstance.RouteExtender.GetTableIdByName(tableName);
url = RouteInstance.RouteExtender.GetPresentationRedirectUrl(tableId, layout);
}
//info about loaded saved query in query string
if (Settings.Current.Features.SavedQuery.ShowPeriodAndId)
{
var tvar = model.Meta.Variables.FirstOrDefault(v => v.IsTime);
if (tvar != null)
{
if (!string.IsNullOrEmpty(query.LoadedQueryName))
{
url += "?loadedQueryId=" + System.IO.Path.GetFileNameWithoutExtension(query.LoadedQueryName);
}
string timeType = "item"; //default
string timeValue = null;
var timeQueryItem = query.Sources[0].Quieries.FirstOrDefault(x => x.Code == tvar.Code);
if (timeQueryItem != null)
{
if (timeQueryItem.Selection.Filter == "top")
{
timeType = "top";
timeValue = timeQueryItem.Selection.Values[0];
}
else if (timeQueryItem.Selection.Filter == "from")
{
timeType = "from";
timeValue = timeQueryItem.Selection.Values[0];
}
url += "&timeType=" + timeType;
if (timeValue != null)
{
url += "&timeValue=" + timeValue;
}
}
}
}
PCAxis.Web.Core.Management.LocalizationManager.ChangeLanguage(model.Meta.CurrentLanguage);
PCAxis.Web.Core.Management.PaxiomManager.PaxiomModel = model;
PaxiomManager.OperationsTracker = new OperationsTracker(query.Workflow.ToArray());
if (!safe)
{
PaxiomManager.OperationsTracker.IsUnsafe = true;
}
PaxiomManager.OperationsTracker.IsTimeDependent = query.TimeDependent;
HttpContext.Current.Response.Redirect(url);
}
/// <summary>
/// Get the Paxiom model built for selection (only metadata)
/// </summary>
/// <param name="db">Database id</param>
/// <param name="path">Path to PX-file or datatable</param>
/// <param name="table">Table name (PX-file or CNMM datatable)</param>
/// <param name="prefLang">Preferred language</param>
/// <returns>The Paxiom model built for selection</returns>
public static PCAxis.Paxiom.PXModel GetPaxiomForSelection(string db, string path, string table, string prefLang)
{
//Verify that user is authorized to view the table
if (!AuthorizationUtil.IsAuthorized(db, path, table)) //TODO: Should be dbid, menu and selection. Only works for SCB right now... (2018-11-14)
{
HttpContext.Current.Response.Redirect(LinkManager.CreateLink("~/Menu.aspx", new LinkManager.LinkItem()
{
Key = "msg", Value = "UnauthorizedTable"
}));
}
string tablePath;
//path = ItemSelectionHelper.CreateFromString(path).Selection;
PCAxis.Paxiom.IPXModelBuilder builder;
DatabaseInfo dbi = PXWeb.Settings.Current.General.Databases.GetDatabase(db);
PCAxis.Web.Controls.PathHandler pHandler;
pHandler = PCAxis.Web.Controls.PathHandlerFactory.Create(dbi.Type);
tablePath = pHandler.CombineTable(db, path, table);
if (PCAxis.Web.Core.Management.PaxiomManager.PaxiomModelBuilder == null)
{
builder = CreatePaxiomBuilder(db, tablePath);
PCAxis.Web.Core.Management.PaxiomManager.PaxiomModelBuilder = builder;
}
else
{
string newpath;
if (dbi.Type == PCAxis.Web.Core.Enums.DatabaseType.PX)
{
// PX
newpath = System.IO.Path.Combine(
System.Web.HttpContext.Current.Server.MapPath(Settings.Current.General.Paths.PxDatabasesPath),
tablePath);
}
else
{
// CNMM
newpath = tablePath;
}
if (PCAxis.Web.Core.Management.PaxiomManager.PaxiomModelBuilder.Path.Equals(newpath))
{
// Existing builder is built against the wanted table
builder = PCAxis.Web.Core.Management.PaxiomManager.PaxiomModelBuilder;
}
else
{
// Existing builder is built against a differnt builder - Create new builder!!!
builder = CreatePaxiomBuilder(db, tablePath);
PCAxis.Web.Core.Management.PaxiomManager.PaxiomModelBuilder = builder;
}
}
if (builder.BuilderState < PCAxis.Paxiom.ModelBuilderStateType.BuildForSelection)
{
string lang;
if (!string.IsNullOrEmpty(prefLang))
{
lang = prefLang;
}
else if (!string.IsNullOrEmpty(PXWeb.Settings.Current.General.Language.DefaultLanguage))
{
lang = PXWeb.Settings.Current.General.Language.DefaultLanguage;
}
else
{
lang = "en";
}
if (dbi.Type == PCAxis.Web.Core.Enums.DatabaseType.CNMM)
{
// Check if the language exist in the CNMM database, if not use the default language of the database
string dbid = PxContext.GetDbId(tablePath);
lang = PxContext.GetCnmmDbLanguage(dbid, lang);
}
builder.SetPreferredLanguage(lang);
builder.BuildForSelection();
}
return(builder.Model);
}
/// <summary>
/// Gets the menu object for the specified database
/// </summary>
/// <remarks></remarks>
/// <returns>A menu object</returns>
public static PxMenuBase GetMenu(string db, string nodeId, string lang)
{
//Verifies that the user is authorized to view the database
var dbcfg = Settings.Current.Database[db];
if (dbcfg != null)
{
if (dbcfg.Protection.IsProtected)
{
if (log.IsDebugEnabled)
{
log.Debug("Check if authenticated");
}
if (!HttpContext.Current.User.Identity.IsAuthenticated)
{
//TODO Auth
//PXWeb.Security.IAuthentication auth = GetAuthentication(dbcfg.Protection.AuthenticationMethod);
//auth.Autenticate();
}
else
{
if (log.IsDebugEnabled)
{
log.Debug("Loged on user: "******"~/Default.aspx", new LinkManager.LinkItem()
{
Key = "msg", Value = "UnauthorizedDatabase"
}));
}
}
}
DatabaseInfo dbi = PXWeb.Settings.Current.General.Databases.GetDatabase(db);
if (dbi == null)
{
return(null);
}
try
{
if (dbi.Type == PCAxis.Web.Core.Enums.DatabaseType.PX)
{
return(GetPxMenu(db, nodeId, lang));
}
else if (dbi.Type == PCAxis.Web.Core.Enums.DatabaseType.CNMM)
{
return(GetCnmmMenu(db, nodeId, lang));
}
return(null);
}
catch (Exception e)
{
log.Error("Something went wrong when trying to getMenu", e);
return(null);
}
}
public virtual void SetLink(string productId)
{
this.ProductUrl = productId.Equals(this.StorefrontContext.CurrentStorefront.GiftCardProductId, StringComparison.OrdinalIgnoreCase) ? this.StorefrontContext.CurrentStorefront.GiftCardPageLink : LinkManager.GetDynamicUrl(this.SearchManager.GetProduct(productId, this.StorefrontContext.CurrentStorefront.Catalog));
}
/// <summary>
/// 加载通用标签
/// </summary>
protected void LoadDefault()
{
#region 全局
th.Put(TagFields.SITE_NAME, SettingManager.GetSetting().SiteName);
th.Put(TagFields.SITE_DESCRIPTION, SettingManager.GetSetting().SiteDescription);
th.Put(TagFields.META_KEYWORDS, SettingManager.GetSetting().MetaKeywords);
th.Put(TagFields.META_DESCRIPTION, SettingManager.GetSetting().MetaDescription);
th.Put(TagFields.FOOTER_HTML, SettingManager.GetSetting().FooterHtml);
th.Put(TagFields.VERSION, SettingManager.GetSetting().Version);
th.Put(TagFields.PAGE_TITLE, "首页");
th.Put(TagFields.SITE_PATH, ConfigHelper.SitePath);
th.Put(TagFields.SITE_URL, ConfigHelper.SiteUrl);
th.Put(TagFields.THEME_PATH, ConfigHelper.SitePath + "themes/" + themeName + "/");
th.Put(TagFields.THEME_URL, ConfigHelper.SiteUrl + "themes/" + themeName + "/");
th.Put(TagFields.IS_DEFAULT, "0");
th.Put(TagFields.IS_POST, "0");
//th.Put(TagFields.FEED_URL, ConfigHelper.SiteUrl + "feed/post" + SettingManager.GetSetting().RewriteExtension);
//th.Put(TagFields.FEED_COMMENT_URL, ConfigHelper.SiteUrl + "feed/comment" + SettingManager.GetSetting().RewriteExtension);
th.Put(TagFields.FEED_URL, ConfigHelper.SiteUrl + "feed/post.aspx");
th.Put(TagFields.FEED_COMMENT_URL, ConfigHelper.SiteUrl + "feed/comment.aspx");
th.Put(TagFields.PAGER, string.Empty);
th.Put(TagFields.PAGER_INDEX, RequestHelper.QueryInt("page", 1));
th.Put(TagFields.URL, RequestHelper.CurrentUrl);
th.Put(TagFields.DATE, DateTime.Now);
th.Put(TagFields.ARCHIVES, ArchiveManager.GetArchive());
th.Put(TagFields.SEARCH_KEYWORD, string.Empty);
th.Put(TagFields.QUERY_COUNT, 0);
th.Put(TagFields.PROCESS_TIME, 0);
th.Put(TagFields.ENABLE_VERIFYCODE, SettingManager.GetSetting().EnableVerifyCode);
string headhtml = string.Empty;
headhtml += string.Format("<meta name=\"generator\" content=\"Loachs {0}\" />\n", SettingManager.GetSetting().Version);
headhtml += "<meta name=\"author\" content=\"Loachs Team\" />\n";
headhtml += string.Format("<meta name=\"copyright\" content=\"2008-{0} Loachs Team.\" />\n", DateTime.Now.Year);
headhtml += string.Format("<link rel=\"alternate\" type=\"application/rss+xml\" title=\"{0}\" href=\"{1}\" />\n", SettingManager.GetSetting().SiteName, ConfigHelper.SiteUrl + "feed/post" + SettingManager.GetSetting().RewriteExtension);
headhtml += string.Format("<link rel=\"EditURI\" type=\"application/rsd+xml\" title=\"RSD\" href=\"{0}xmlrpc/rsd.aspx\" />\n", ConfigHelper.SiteUrl);
headhtml += string.Format("<link rel=\"wlwmanifest\" type=\"application/wlwmanifest+xml\" href=\"{0}xmlrpc/wlwmanifest.aspx\" />", ConfigHelper.SiteUrl);
th.Put(TagFields.HEAD, headhtml);
//if (Utils.IsSupportUrlRewriter == false)
//{
// th.Put(TagFields.SEARCH_URL, ConfigHelper.SiteUrl + "default.aspx?type=search&keyword=");
//}
//else
//{
// th.Put(TagFields.SEARCH_URL, ConfigHelper.SiteUrl + "search");
// }
#endregion
#region 文章
//th.Put(TagFields.POST, null);
//th.Put(TagFields.POST_MESSAGE, null);
//th.Put(TagFields.POSTS, null);
th.Put(TagFields.RECENT_POSTS, PostManager.GetPostList(SettingManager.GetSetting().SidebarPostCount, -1, -1, -1, 1, -1, 0));
th.Put(TagFields.RECOMMEND_POSTS, PostManager.GetPostList(SettingManager.GetSetting().SidebarPostCount, -1, -1, 1, 1, -1, 0));
th.Put(TagFields.TOP_POSTS, PostManager.GetPostList(Int32.MaxValue, -1, -1, -1, 1, 1, 0));
//th.Put(TagFields.FEED_POSTS, null);
#endregion
#region 评论
//th.Put(TagFields.COMMENTS, null);
th.Put(TagFields.RECENT_COMMENTS, CommentManager.GetCommentListByRecent(SettingManager.GetSetting().SidebarCommentCount));
if (PageUtils.IsLogin)
{
UserInfo user = UserManager.GetUser(PageUtils.CurrentUserId);
if (user != null)
{
th.Put(TagFields.COMMENT_AUTHOR, user.Name);
th.Put(TagFields.COMMENT_EMAIL, user.Email);
th.Put(TagFields.COMMENT_SITEURL, user.SiteUrl);
}
}
else
{
th.Put(TagFields.COMMENT_AUTHOR, Server.UrlDecode(PageUtils.GetCookie(TagFields.COMMENT_AUTHOR)));
th.Put(TagFields.COMMENT_EMAIL, Server.UrlDecode(PageUtils.GetCookie(TagFields.COMMENT_EMAIL)));
th.Put(TagFields.COMMENT_SITEURL, Server.UrlDecode(PageUtils.GetCookie(TagFields.COMMENT_SITEURL)));
}
th.Put(TagFields.COMMENT_CONTENT, string.Empty);
th.Put(TagFields.COMMENT_MESSAGE, string.Empty);
#endregion
#region 作者,分类,标签
th.Put(TagFields.AUTHORS, UserManager.GetUserList().FindAll(delegate(UserInfo user) { return(user.Status == 1); }));
th.Put(TagFields.CATEGORIES, CategoryManager.GetCategoryList());
th.Put(TagFields.RECENT_TAGS, TagManager.GetTagList(SettingManager.GetSetting().SidebarTagCount));
#endregion
#region 连接
List <LinkInfo> a = LinkManager.GetLinkList(-1, 1);
th.Put(TagFields.LINKS, LinkManager.GetLinkList(-1, 1));
th.Put(TagFields.NAV_LINKS, LinkManager.GetLinkList((int)LinkPosition.Navigation, 1));
th.Put(TagFields.GENERAL_LINKS, LinkManager.GetLinkList((int)LinkPosition.General, 1));
#endregion
#region 统计
th.Put(TagFields.POST_COUNT, StatisticsManager.GetStatistics().PostCount);
th.Put(TagFields.COMMENT_COUNT, StatisticsManager.GetStatistics().CommentCount);
th.Put(TagFields.VIEW_COUNT, StatisticsManager.GetStatistics().VisitCount);
th.Put(TagFields.AUTHOR_COUNT, UserManager.GetUserList().FindAll(delegate(UserInfo user) { return(user.Status == 1); }).Count);
#endregion
}
public static string GetItemUrl(this Item item)
{
return(LinkManager.GetItemUrl(item));
}
/// <summary>
/// Maps data from the CMS value to the .Net property value
/// </summary>
/// <param name="mappingContext">The mapping context.</param>
/// <returns>System.Object.</returns>
/// <exception cref="Glass.Mapper.MapperException">SitecoreInfoType {0} not supported.Formatted(scConfig.Type)</exception>
public override object MapToProperty(AbstractDataMappingContext mappingContext)
{
var context = mappingContext as SitecoreDataMappingContext;
var item = context.Item;
var scConfig = Configuration as SitecoreInfoConfiguration;
//TODO: move this to the config?
var urlOptions = Utilities.CreateUrlOptions(scConfig.UrlOptions);
switch (scConfig.Type)
{
case SitecoreInfoType.ContentPath:
return(item.Paths.ContentPath);
case SitecoreInfoType.DisplayName:
return(item.DisplayName);
case SitecoreInfoType.FullPath:
return(item.Paths.FullPath);
case SitecoreInfoType.Name:
return(item.Name);
case SitecoreInfoType.Key:
return(item.Key);
case SitecoreInfoType.MediaUrl:
var media = new global::Sitecore.Data.Items.MediaItem(item);
return(global::Sitecore.Resources.Media.MediaManager.GetMediaUrl(media));
case SitecoreInfoType.Path:
return(item.Paths.Path);
case SitecoreInfoType.TemplateId:
if (scConfig.PropertyInfo != null && scConfig.PropertyInfo.PropertyType == typeof(Sitecore.Data.ID))
{
return(item.TemplateID);
}
return(item.TemplateID.Guid);
case SitecoreInfoType.TemplateName:
return(item.TemplateName);
case SitecoreInfoType.Url:
urlOptions.Language = null;
return(LinkManager.GetItemUrl(item, urlOptions));
case SitecoreInfoType.Version:
if (scConfig.PropertyInfo != null && scConfig.PropertyInfo.PropertyType == typeof(string))
{
return(item.Version.Number.ToString());
}
return(item.Version.Number);
case SitecoreInfoType.Language:
if (scConfig.PropertyInfo != null && scConfig.PropertyInfo.PropertyType == typeof(string))
{
return(item.Language.Name);
}
return(item.Language);
case SitecoreInfoType.BaseTemplateIds:
Template template = TemplateManager.GetTemplate(item.TemplateID, item.Database);
if (scConfig.PropertyInfo != null &&
scConfig.PropertyInfo.PropertyType == typeof(IEnumerable <Sitecore.Data.ID>))
{
return(template.GetBaseTemplates().Select(x => x.ID));
}
return(template.GetBaseTemplates().Select(x => x.ID.Guid));
default:
throw new MapperException("SitecoreInfoType {0} not supported".Formatted(scConfig.Type));
}
}
/// <summary>
///
/// </summary>
public void Initialize()
{
IsInitialized = false;
m_serverurl = string.Format(m_surlformat, ConfigurationManager.AppSettings["stingserverip"], ConfigurationManager.AppSettings["stingserverport"]);
if (File.Exists(ConfigurationManager.AppSettings["scorebugscenepath"]))
{
m_scorebugscenepath = ConfigurationManager.AppSettings["scorebugscenepath"];
}
else if (File.Exists(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "Resources", "ScoreBug.w3d")))
{
m_scorebugscenepath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "Resources", "ScoreBug.w3d");
}
if (!string.IsNullOrEmpty(m_scorebugscenepath) && ConfigurationManager.AppSettings["stingserverip"] != null)
{
string sLinkID = string.Empty;
LinkManager objLinkManager = new LinkManager();
AppLink = objLinkManager.GetLink(LINKTYPE.TCP, out sLinkID);
AppLink.OnEngineConnected += new EventHandler<EngineArgs>(objLink_OnEngineConnected);
AppLink.Connect(m_serverurl);
objLinkManager.OnEngineDisConnected += objLinkManager_OnEngineDisConnected;
}
}
private async void GenerateEvents(MessageItem email, Funnel funnelDefinition, List <ContactData> contactsForThisEmail)
{
if (funnelDefinition == null)
{
return;
}
var contactIndex = 1;
foreach (var contactId in contactsForThisEmail)
{
_specification.Job.Status = $"Generating events for contact {contactIndex++} of {contactsForThisEmail.Count}";
var contact = _contactService.GetContact(contactId.ContactId);
if (contact == null)
{
continue;
}
if (_random.NextDouble() < funnelDefinition.Bounced / 100d)
{
ExmEventsGenerator.GenerateBounce(_managerRoot.Settings.BaseURL, contact.ContactId.ToID(),
email.MessageId.ToID(), email.StartTime.AddMinutes(1));
}
else
{
var userAgent = _userAgent();
var geoData = _geoData();
var eventDay = _eventDay();
var seconds = _random.Next(60, 86400);
var eventDate = email.StartTime.AddDays(eventDay).AddSeconds(seconds);
var spamPercentage = funnelDefinition.SpamComplaints / 100d;
if (_random.NextDouble() < funnelDefinition.OpenRate / 100d)
{
if (_random.NextDouble() < funnelDefinition.ClickRate / 100d)
{
spamPercentage = Math.Min(spamPercentage, 0.01);
var link = "/";
if (_goalId != null)
{
var goal = _goalId();
ID goalId;
if (ID.TryParse(goal, out goalId) && !ID.IsNullOrEmpty(goalId))
{
var goalItem = _db.GetItem(goalId);
if (goalItem != null)
{
link = LinkManager.GetItemUrl(goalItem);
}
}
}
ExmEventsGenerator.GenerateHandlerEvent(_managerRoot.Settings.BaseURL, contact.ContactId, email,
ExmEvents.Click, eventDate, userAgent, geoData, link);
eventDate = eventDate.AddSeconds(_random.Next(10, 300));
}
else
{
ExmEventsGenerator.GenerateHandlerEvent(_managerRoot.Settings.BaseURL, contact.ContactId, email,
ExmEvents.Open, eventDate, userAgent, geoData);
eventDate = eventDate.AddSeconds(_random.Next(10, 300));
}
}
if (_random.NextDouble() < spamPercentage)
{
await ExmEventsGenerator.GenerateSpamComplaint(_managerRoot.Settings.BaseURL, contact.ContactId.ToID(), email.MessageId.ToID(), "email", eventDate);
eventDate = eventDate.AddSeconds(_random.Next(10, 300));
}
var unsubscribePercentage = funnelDefinition.Unsubscribed / 100d;
if (_random.NextDouble() < unsubscribePercentage)
{
//TODO - Warning: UnsubscribeFromAll not supported
var unsubscribeFromAllPercentage = 0.5;
ExmEvents unsubscribeEvent;
if (_random.NextDouble() < unsubscribeFromAllPercentage)
{
unsubscribeEvent = ExmEvents.UnsubscribeFromAll;
_unsubscribeFromAllContacts.Add(contact.ContactId);
}
else
{
unsubscribeEvent = ExmEvents.Unsubscribe;
}
ExmEventsGenerator.GenerateHandlerEvent(_managerRoot.Settings.BaseURL, contact.ContactId, email,
unsubscribeEvent, eventDate, userAgent, geoData);
}
}
_specification.Job.CompletedEvents++;
}
}
/// <summary>
/// Gets the social sharing service friendly URL for the provided content page
/// </summary>
/// <param name="pageItem"></param>
/// <returns></returns>
private static string GetContentPageSharingUrl(Item pageItem)
{
return(LinkManager.GetItemUrl(pageItem, new UrlOptions {
AlwaysIncludeServerUrl = true
}));
}
protected string GetLimersAround(int distance, LimeRCellTracker tracker)
{
string _serialedMessages = JsonConvert.SerializeObject(LinkManager.GetTrackersinDistance(distance, tracker.LastLon, tracker.LastLat, tracker.TrackerId, tracker.Vibe));
return("{\"Trackers\":" + _serialedMessages + "}");
}
protected void Page_Load(object sender, EventArgs e)
{
btnUnderstoodBlog.HRef = LinkManager.GetItemUrl(Sitecore.Context.Database.GetItem("{401A4297-3D08-4BB5-8F19-EC32A38C82C6}"));
}
protected void Page_Init(object sender, EventArgs e)
{
if (!PXWeb.Settings.Current.Selection.StandardApplicationHeadTitle)
{
HeadTitle = Server.HtmlEncode(GetLocalizedString("PxWebApplicationTitle"));
}
if (DoNotUseBreadCrumb())
{
Page.Controls.Remove(this.breadcrumb1);
}
//Add eventhandlers
LinkManager.RegisterEnsureQueries(new EnsureQueriesEventHandler(LinkManager_EnsureQueries));
if (PxUrlObj.Language != null)
{
if (!(LocalizationManager.CurrentCulture.Name == PxUrlObj.Language))
{
if (PxUrlObj.Database != null)
{
DatabaseInfo dbi = null;
dbi = PXWeb.Settings.Current.General.Databases.GetDatabase(PxUrlObj.Database);
if (dbi.Type == DatabaseType.CNMM)
{
PCAxis.Web.Core.Management.PaxiomManager.PaxiomModelBuilder = null;
PCAxis.Web.Core.Management.PaxiomManager.PaxiomModel = null;
}
}
LocalizationManager.ChangeLanguage(PxUrlObj.Language);
}
}
else
{
string lang = PXWeb.Settings.Current.General.Language.DefaultLanguage;
LocalizationManager.ChangeLanguage(lang);
List <LinkManager.LinkItem> linkItems = new List <LinkManager.LinkItem>();
linkItems.Add(new LinkManager.LinkItem(PxUrl.LANGUAGE_KEY, lang));
//Replaced Request.Url.AbsolutePath with Request.AppRelativeCurrentExecutionFilePath
//so that the links will be right even if the site is running without UserFriendlyURL
string url = PCAxis.Web.Core.Management.LinkManager.CreateLink(Request.AppRelativeCurrentExecutionFilePath, linkItems.ToArray());
Response.Redirect(url);
}
////Add eventhandlers
//LinkManager.EnsureQueries += new LinkManager.EnsureQueriesEventHandler(LinkManager_EnsureQueries);
_imagesPath = PXWeb.Settings.Current.General.Paths.ImagesPath;
_logoPath = PXWeb.Settings.Current.General.Site.LogoPath;
LoadPageContent();
if (!IsPostBack)
{
if (!DoNotUseBreadCrumb())
{
InitializeBreadcrumb();
}
if (PXWeb.Settings.Current.Navigation.ShowNavigationFlow)
{
InitializeNavigationFlow();
}
}
if (!DoNotUseBreadCrumb())
{
breadcrumb1.GetMenu = GetMenu;
}
//navigationFlowControl.GetMenu = GetMenu;
}
public override void Process(PublishItemContext context)
{
Database sourceDB = context.PublishOptions.SourceDatabase;
Item item = context.PublishOptions.TargetDatabase.GetItem(context.ItemId);
if (item == null)
{
return;
}
foreach (SiteInfo current in Settings.Sites)
{
if (!Config.IgnoredSites.Contains(current.Name, StringComparer.OrdinalIgnoreCase) && item.Paths.ContentPath.StartsWith(current.StartItem, StringComparison.OrdinalIgnoreCase))
{
SiteContext siteContext = SiteContextFactory.GetSiteContext(current.Name);
string homeItemPath = siteContext.StartPath.ToString();
Item startItem = sourceDB.GetItem(homeItemPath);
ID homeItemID = startItem.ID;
ID publishedItemID = item.ID;
string text = "";
if (publishedItemID != homeItemID)
{
text = LinkManager.GetItemUrl(context.PublishOptions.TargetDatabase.GetItem(context.ItemId), GetItemUrlOptions(siteContext));
}
else
{
text = LinkManager.GetItemUrl(context.PublishOptions.TargetDatabase.GetItem(context.ItemId), GetHomeUrlOptions(siteContext));
}
if (text.StartsWith("://"))
{
text = "http" + text;
}
string localPath;
try
{
Uri uri = new Uri(text);
localPath = uri.LocalPath;
}
catch (UriFormatException innerException)
{
throw new ApplicationException(string.Format("Redirect Manager failed parsing item url generated by linkmanager. Url : {0} ItemId : {1}, ", text, context.ItemId), innerException);
}
if (!Redirector.Provider.Exists(localPath))
{
Redirector.Provider.CreateRedirect(localPath, context.ItemId.ToString(), true);
}
else
{
Redirector.Provider.DeleteRedirect(localPath);
Redirector.Provider.CreateRedirect(localPath, context.ItemId.ToString(), true);
}
}
}
}
public override void Process(HttpRequestArgs args)
{
var site = Sitecore.Context.Site.GetMultiSiteContext();
// only do redirects if no item is found or if request parameters match the configuration settings
if (ProcessUrl() && Context.Database != null && site != null)
{
// Grab the actual requested path for use in both the item and pattern match sections.
var requestedUrl = HttpContext.Current.Request.Url.ToString();
var requestedUrlOnly = requestedUrl.IndexOf("?") > 0 ? requestedUrl.Substring(0, requestedUrl.IndexOf("?")) : requestedUrl;
requestedUrl = requestedUrl.EndsWith("/") ? requestedUrl.Substring(0, requestedUrl.Length - 1) : requestedUrl;
var requestedPath = HttpContext.Current.Request.Url.AbsolutePath;
var requestedPathAndQuery = HttpContext.Current.Request.Url.PathAndQuery;
var db = Context.Database;
// In case allowed extensions are defined, only process pipeline when the extension of the request in included in the list
// of allowed extensions.
// If the request does not contain an extension, pipeline will always be processed
if (allowedExtensions != null && allowedExtensions.Count() > 0)
{
var extensionWithDot = Path.GetExtension(requestedPath);
if (string.IsNullOrEmpty(extensionWithDot) == false)
{
if (allowedExtensions.Contains(extensionWithDot.Substring(1).ToLower()) == false)
{
return;
}
}
}
var ruleFolder = db.GetItem(new Sitecore.Data.ID(site.SiteId)).Children.Where(a => a.DisplayName == "Redirection Rules").FirstOrDefault();
if (ruleFolder == null)
{
return;
}
// Loop through the exact match entries to look for a match.
foreach (Item possibleRedirect in GetRedirects(ruleFolder, "Redirect Url"))
{
if (possibleRedirect.HasField("Enabled"))
{
var enabled = ((CheckboxField)possibleRedirect.Fields["Enabled"]).Checked;
if (!enabled)
{
continue;
}
}
bool Is302 = false;
bool IsVanity = false;
if (possibleRedirect.HasField("Type"))
{
string type = possibleRedirect["Type"];
if (type.StartsWith("302"))
{
Is302 = true;
IsVanity = false;
}
if (type.ToLower().StartsWith("vanity"))
{
Is302 = false;
IsVanity = true;
}
}
if (requestedUrl.Equals(possibleRedirect["Requested Url"], StringComparison.OrdinalIgnoreCase) ||
requestedPath.Equals(possibleRedirect["Requested Url"], StringComparison.OrdinalIgnoreCase) ||
requestedUrlOnly.Equals(possibleRedirect["Requested Url"], StringComparison.OrdinalIgnoreCase))
{
var redirectToItemId = possibleRedirect.Fields["Target Item"];
if (redirectToItemId.HasValue && !string.IsNullOrEmpty(redirectToItemId.ToString()))
{
var redirectToItem = Context.Database.GetItem(ID.Parse(redirectToItemId));
var redirectToUrl = GetRedirectToUrl(redirectToItem);
if (possibleRedirect.HasField("Goal") && possibleRedirect.Fields["Goal"].HasValue)
{
var goal = ((ReferenceField)possibleRedirect.Fields["Goal"]).TargetItem;
var encodedUrl = HttpUtility.UrlEncode(redirectToUrl);
redirectToUrl = string.Format("/redirect/{0}?u={1}", goal.ID.ToGuid().ToString("N"), encodedUrl);
}
if (Is302)
{
SendTemporaryResponse(redirectToUrl, HttpContext.Current.Request.Url.Query, args);
}
else if (IsVanity)
{
SendContent(redirectToUrl, HttpContext.Current.Request.Url.Query, args);
}
else
{
//default is 301 permanent
SendResponse(redirectToUrl, HttpContext.Current.Request.Url.Query, args);
}
}
}
}
// Loop through the pattern match items to find a match
foreach (Item possibleRedirectPattern in GetRedirects(ruleFolder, "Redirect Pattern"))
{
if (possibleRedirectPattern.HasField("Enabled"))
{
var enabled = ((CheckboxField)possibleRedirectPattern.Fields["Enabled"]).Checked;
if (!enabled)
{
continue;
}
}
bool Is302 = false;
bool IsVanity = false;
if (possibleRedirectPattern.HasField("Type"))
{
string type = possibleRedirectPattern["Type"];
if (type.StartsWith("302"))
{
Is302 = true;
IsVanity = false;
}
if (type.ToLower().StartsWith("vanity"))
{
Is302 = false;
IsVanity = true;
}
}
var redirectPath = string.Empty;
if (Regex.IsMatch(requestedUrl, possibleRedirectPattern["Source Expression"], RegexOptions.IgnoreCase))
{
redirectPath = Regex.Replace(requestedUrl, possibleRedirectPattern["Source Expression"],
possibleRedirectPattern["Target Expression"], RegexOptions.IgnoreCase);
}
else if (Regex.IsMatch(requestedPathAndQuery, possibleRedirectPattern["Source Expression"], RegexOptions.IgnoreCase))
{
redirectPath = Regex.Replace(requestedPathAndQuery,
possibleRedirectPattern["Source Expression"],
possibleRedirectPattern["Target Expression"], RegexOptions.IgnoreCase);
}
if (string.IsNullOrEmpty(redirectPath))
{
continue;
}
if (redirectPath.ToLower().StartsWith("/sitecore"))
{
// Query portion gets in the way of getting the sitecore item.
var pathAndQuery = redirectPath.Split(new char[] { '?' }, StringSplitOptions.RemoveEmptyEntries);
var path = pathAndQuery[0];
if (LinkManager.GetDefaultUrlOptions() != null &&
LinkManager.GetDefaultUrlOptions().EncodeNames)
{
path = MainUtil.DecodeName(path);
}
var redirectToItem = db.GetItem(path);
if (redirectToItem != null)
{
var redirectToUrl = GetRedirectToUrl(redirectToItem);
if (possibleRedirectPattern.HasField("Goal") && possibleRedirectPattern.Fields["Goal"].HasValue)
{
var goal = ((ReferenceField)possibleRedirectPattern.Fields["Goal"]).TargetItem;
var encodedUrl = HttpUtility.UrlEncode(redirectToUrl);
redirectToUrl = string.Format("/redirect/{0}?u={1}", goal.ID.ToGuid().ToString("N"), encodedUrl);
}
var query = pathAndQuery.Length > 1 ? "?" + pathAndQuery[1] : "";
if (Is302)
{
SendTemporaryResponse(redirectToUrl, query, args);
}
else if (IsVanity)
{
SendContent(redirectToUrl, query, args);
}
else
{
SendResponse(redirectToUrl, query, args);
}
}
}
else
{
//validate it's a URI
Uri outUri = null;
if (Uri.TryCreate(redirectPath, UriKind.Absolute, out outUri) &&
(outUri.Scheme == Uri.UriSchemeHttp || outUri.Scheme == Uri.UriSchemeHttps))
{
var redirectToUrl = outUri.GetLeftPart(UriPartial.Path);
if (possibleRedirectPattern.HasField("Goal") && possibleRedirectPattern.Fields["Goal"].HasValue)
{
var goal = ((ReferenceField)possibleRedirectPattern.Fields["Goal"]).TargetItem;
var encodedUrl = HttpUtility.UrlEncode(redirectToUrl);
redirectToUrl = string.Format("/redirect/{0}?u={1}", goal.ID.ToGuid().ToString("N"), encodedUrl);
}
var query = outUri.Query;
if (Is302)
{
SendTemporaryResponse(redirectToUrl, query, args);
}
else if (IsVanity)
{
SendContent(redirectToUrl, query, args);
}
else
{
SendResponse(redirectToUrl, query, args);
}
}
}
}
}
}
public static object GetItemInfo(SitecoreInfoType infoType, Item item, global::Sitecore.Links.UrlOptions urlOptions)
{
if (urlOptions == null)
{
urlOptions = new UrlOptions();
}
if (urlOptions.Language == null)
{
urlOptions.Language = item.Language;
}
switch (infoType)
{
case SitecoreInfoType.ContentPath:
return(item.Paths.ContentPath);
case SitecoreInfoType.DisplayName:
return(item.DisplayName);
case SitecoreInfoType.FullPath:
return(item.Paths.FullPath);
case SitecoreInfoType.Name:
return(item.Name);
case SitecoreInfoType.Key:
return(item.Key);
case SitecoreInfoType.MediaUrl:
global::Sitecore.Data.Items.MediaItem media = new global::Sitecore.Data.Items.MediaItem(item);
return(global::Sitecore.Resources.Media.MediaManager.GetMediaUrl(media));
break;
case SitecoreInfoType.Path:
return(item.Paths.Path);
case SitecoreInfoType.TemplateId:
return(item.TemplateID.Guid);
case SitecoreInfoType.TemplateName:
return(item.TemplateName);
case SitecoreInfoType.Url:
return(LinkManager.GetItemUrl(item, urlOptions));
case SitecoreInfoType.FullUrl:
return(LinkManager.GetItemUrl(item, new UrlOptions()
{
AlwaysIncludeServerUrl = true
}));
case SitecoreInfoType.Version:
return(item.Version.Number);
case SitecoreInfoType.Language:
return(item.Language);
default:
throw new NotSupportedException("Value {0} not supported".Formatted(infoType.ToString()));
}
}
protected void Page_Load(object sender, EventArgs e)
{
//Path for selection should always contain tableid and not table name
if (RouteInstance.RouteExtender != null && RouteInstance.RouteExtender.DoesSelectionPathContainTableName(this))
{
var linkItems = new List <LinkManager.LinkItem>();
linkItems.Add(new LinkManager.LinkItem(PXWeb.PxUrl.TABLE_KEY, PxUrl.Table));
string redirectLink = LinkManager.CreateLinkMethod("Selection.aspx", false, linkItems.ToArray());
Response.Redirect(redirectLink, true);
}
if (RouteInstance.RouteExtender != null)
{
var tableId = RouteInstance.RouteExtender.GetTableIdByName(PxUrl.Table);
bool hasTableData = RouteInstance.RouteExtender.HasTableData(tableId);
if (!hasTableData)
{
Response.Redirect(RouteInstance.RouteExtender.GetRedirectNoDataPath(tableId), true);
}
}
((PxWeb)this.Master).FooterText = "Selection";
string lang = PxUrl.Language;
string db = PxUrl.Database;
string path = PxUrl.Path;
string table = PxUrl.Table;
string partTable = "";
//Check if the queryStrings contains partTable
if (QuerystringManager.GetQuerystringParameter("partTable") != null)
{
partTable = QuerystringManager.GetQuerystringParameter("partTable");
}
// Bug 273
// If we have no builder the groupings should be reloaded
if (PCAxis.Web.Core.Management.PaxiomManager.PaxiomModelBuilder == null)
{
VariableSelector1.ReloadGroupings = true;
}
if (PCAxis.Web.Core.Management.PaxiomManager.PaxiomModel != null)
{
_previousModel = PCAxis.Web.Core.Management.PaxiomManager.PaxiomModel;
VariableSelector1.PreSelectFirstContentAndTime = false;
}
else
{
VariableSelector1.PreSelectFirstContentAndTime = PXWeb.Settings.Current.Selection.PreSelectFirstContentAndTime;
}
// Check if we are being called from a saved query with the ?select switch. If that is the case we should always clear the PxModel.
bool clearModel = false;
if (HttpContext.Current.Session["SelectionClearPxModel"] != null)
{
clearModel = (bool)HttpContext.Current.Session["SelectionClearPxModel"];
HttpContext.Current.Session.Remove("SelectionClearPxModel");
}
PCAxis.Web.Core.Management.PaxiomManager.PaxiomModel = PXWeb.Management.PxContext.GetPaxiomForSelection(db, path, table, lang, clearModel);
if (!IsPostBack)
{
Master.HeadTitle = PCAxis.Web.Core.Management.LocalizationManager.GetLocalizedString("PxWebTitleSelection");
imgShowInformationExpander.ImageUrl = Page.ClientScript.GetWebResourceUrl(typeof(BreadcrumbCodebehind), "PCAxis.Web.Controls.spacer.gif");
imgShowFootnotesExpander.ImageUrl = Page.ClientScript.GetWebResourceUrl(typeof(BreadcrumbCodebehind), "PCAxis.Web.Controls.spacer.gif");
imgShowMetadataExpander.ImageUrl = Page.ClientScript.GetWebResourceUrl(typeof(BreadcrumbCodebehind), "PCAxis.Web.Controls.spacer.gif");
Master.SetBreadcrumb(PCAxis.Web.Controls.Breadcrumb.BreadcrumbMode.Selection);
Master.SetNavigationFlowMode(PCAxis.Web.Controls.NavigationFlow.NavigationFlowMode.Second);
Master.SetNavigationFlowVisibility(PXWeb.Settings.Current.Navigation.ShowNavigationFlow);
InitializeVariableSelector();
InitializeTableInformation();
InitializeMetatags();
InitializeMetadata(path);
//Check if the queryStrings contains partTable and the database type is CNMM
//if so download subtable variables
if (!string.IsNullOrEmpty(partTable))
{
DatabaseInfo dbi = PXWeb.Settings.Current.General.Databases.GetDatabase(db);
if (dbi.Type == PCAxis.Web.Core.Enums.DatabaseType.CNMM)
{
SetValuesFromPartTable(partTable);
}
}
}
DisplayTableMetadataLinks();
VariableSelector1.PxActionEvent += new PCAxis.Web.Controls.PxActionEventHandler(HandlePxAction);
VariableSelector1.MetadataInformationSelected += new VariableSelector.MetadataInformationSelectedEventHandler(HandleMetaDataInformationAction);
if (_previousModel != null && _previousModel.IsComplete && !IsPostBack)
{
VariableSelector1.InitializeSelectedValuesetsAndGroupings(_previousModel);
}
}
/// <summary>
/// Raises the <see cref="E:System.Web.UI.Control.Load"/> event and try to resolve the raw data for the error page.
/// At the end, outputs the raw data of the content we want to display.
/// </summary>
/// <param name="e">The <see cref="T:System.EventArgs"/> object that contains the event data.</param>
protected override void OnLoad(EventArgs e)
{
base.OnLoad(e);
// initial parameters
Language lang = UrlUtil.ResolveLanguage();
SiteContext site = UrlUtil.ResolveSite(lang);
string url = string.Empty;
// Use the static error page if the site or the database is not available
if (site == null || site.Database == null)
{
url = Sitecore.Web.WebUtil.GetServerUrl() + Sitecore.Configuration.Settings.GetSetting(SettingsKey + ".Static");
}
else
{
string availableLanguages = site.Properties["availableLanguages"];
// general options for generating url
UrlOptions options = UrlOptions.DefaultOptions;
options.LanguageEmbedding = LanguageEmbedding.Always;
options.LanguageLocation = LanguageLocation.QueryString;
options.Language = lang;
options.Site = site;
options.AlwaysIncludeServerUrl = true;
// get the error item
string path = Settings.GetBoolSetting("ErrorManager.UseRootPath", false) ? site.RootPath : site.StartPath;
Item item = site.Database.GetItem(path + Sitecore.Configuration.Settings.GetSetting(SettingsKey + ".Item"));
// resolve the url for the error page
if (item != null && item.HasLanguageVersion(lang, availableLanguages))
{
url = LinkManager.GetItemUrl(item, options);
}
else
{
Language.TryParse(!string.IsNullOrEmpty(site.Properties["language"]) ? site.Properties["language"] : LanguageManager.DefaultLanguage.Name, out lang);
if (item != null && lang != null && item.HasLanguageVersion(lang, availableLanguages))
{
options.Language = lang;
url = LinkManager.GetItemUrl(item, options);
}
else
{
url = Sitecore.Web.WebUtil.GetServerUrl() + Sitecore.Configuration.Settings.GetSetting(SettingsKey + ".Static");
}
}
// append current raw url
url += url.IndexOf("?") == -1 ? "?" : "&";
url += "rawUrl=" + Server.UrlEncode(Sitecore.Web.WebUtil.GetRawUrl());
}
// parse the page
HttpWebRequest request = (HttpWebRequest)HttpWebRequest.Create(url);
bool ignoreInvalidSSLCertificates = Sitecore.Configuration.Settings.GetBoolSetting("ErrorManager.IgnoreInvalidSSLCertificates", false);
// add user cookies to the request
if (Sitecore.Configuration.Settings.GetBoolSetting("ErrorManager.SendClientCookies", false))
{
request.CookieContainer = new CookieContainer();
HttpCookieCollection userCookies = Request.Cookies;
for (int userCookieCount = 0; userCookieCount < userCookies.Count; userCookieCount++)
{
HttpCookie httpCookie = userCookies.Get(userCookieCount);
if (httpCookie.Name != "ASP.NET_SessionId")
{
Cookie cookie = new Cookie();
/* We have to add the target host because the cookie does not contain the domain information.
* In this case, this behaviour is not a security issue, because the target is our own platform.
* Further information: http://stackoverflow.com/a/460990
*/
cookie.Domain = request.RequestUri.Host;
cookie.Expires = httpCookie.Expires;
cookie.Name = httpCookie.Name;
cookie.Path = httpCookie.Path;
cookie.Secure = httpCookie.Secure;
// Encode cookie value for handling commas (and other possibly unsupported chars)
// Furhter information: http://stackoverflow.com/q/1136405
cookie.Value = HttpUtility.UrlEncode(httpCookie.Value);
request.CookieContainer.Add(cookie);
}
}
}
HttpWebResponse response = null;
bool hasAddedValidationCallback = false;
try
{
int timeout = 0;
Int32.TryParse(Sitecore.Configuration.Settings.GetSetting("ErrorManager.Timeout"), out timeout);
if (timeout == 0)
{
timeout = 60 * 1000;
}
int maxRedirects = 0;
Int32.TryParse(Sitecore.Configuration.Settings.GetSetting("ErrorManager.MaxRedirects"), out maxRedirects);
if (maxRedirects == 0)
{
maxRedirects = 3;
}
if (ignoreInvalidSSLCertificates)
{
ServicePointManager.ServerCertificateValidationCallback += new RemoteCertificateValidationCallback(ValidateRemoteCertificate);
hasAddedValidationCallback = true;
}
// do the request
request.Timeout = timeout;
request.MaximumAutomaticRedirections = maxRedirects;
response = (HttpWebResponse)request.GetResponse();
}
catch (WebException ex)
{
// we need to catch this, because statuscode of the sitecore default error pages may throwing an exception in the HttpWebResponse object
response = (HttpWebResponse)ex.Response;
}
finally
{
// Remove the custom RemoteCertificateValidationCallback due to the global nature of the ServicePointManager
if (hasAddedValidationCallback)
{
ServicePointManager.ServerCertificateValidationCallback -= new RemoteCertificateValidationCallback(ValidateRemoteCertificate);
}
}
// outputs the page
if (response != null)
{
string body = new StreamReader(response.GetResponseStream()).ReadToEnd();
// Insert image with request to the static page if Analytics is enabled.
// This is a hotfix for a Sitecore bug, see Sitecore issue #378950
if (Settings.GetBoolSetting("Analytics.Enabled", false) && site.EnableAnalytics)
{
body = body.Replace("</body>", string.Format("<img src=\"{0}?{1}\" height=\"1\" width=\"1\" border=\"0\"></body>", Sitecore.Configuration.Settings.GetSetting(SettingsKey + ".Static"), base.Request.QueryString));
}
Response.Write(body);
}
else
{
Response.Write("Statuscode: " + StatusCode);
}
// set statuscode
if (StatusCode > 0)
{
Response.StatusCode = StatusCode;
}
// pass through the response we create here
Response.TrySkipIisCustomErrors = true;
}
public void ListItemChildren()
{
Database masterDatabase = Sitecore.Configuration.Factory.GetDatabase("master");
if (masterDatabase != null)
{
//Get Item nm1124
Item nm1124Item = masterDatabase.GetItem(new ID("{91594D09-E4C0-458D-8C3E-3FD60413D352}"));
if (nm1124Item != null)
{
ChildList children = nm1124Item.GetChildren();
if (children != null && children.Count > 0)
{
this.Log(string.Format("Listing Item : {0}{{{1}}} \nListing Children :", nm1124Item.Name, nm1124Item.ID.ToString()));
foreach (Item child in children)
{
this.Log(string.Format("\t\tChild Item : {0}{{{1}}} [{2}]", child.Name, child.ID.ToString(), LinkManager.GetItemUrl(child)));
}
}
}
}
}
/// <summary>
/// Gets the payment link URL.
/// </summary>
/// <param name="fieldName">Name of the field.</param>
/// <returns>The payment link URL.</returns>
protected string ExtractPaymentLinkUrl(string fieldName)
{
Assert.IsNotNullOrEmpty(fieldName, "fieldName");
if (Sitecore.Web.WebUtil.IsExternalUrl(fieldName))
{
return(fieldName);
}
BusinessCatalogSettings businessCatalogSettings = Context.Entity.GetConfiguration <BusinessCatalogSettings>();
Item paymentsItem = Sitecore.Context.Database.GetItem(businessCatalogSettings.PaymentSystemsLink);
Assert.IsNotNull(paymentsItem, "Payments item is null");
Assert.IsNotNull(paymentsItem.Fields[fieldName], string.Concat("Payments item does not contains field: '", fieldName, "'"));
LinkField linkField = paymentsItem.Fields[fieldName];
Assert.IsNotNull(linkField, string.Concat("'", fieldName, "' is not a link field"));
// If link is not internal just return url value.
string externalUrl = linkField.Url;
if (!linkField.LinkType.Equals("internal"))
{
return(externalUrl);
}
// If the site doesn't contains Business Catalog/Payments item under itself, Payment pages urls are wrong.
// E.g.: Site path is: '/sitecore/content/Examples/Home';
// Business Catalog path is: '/sitecore/content/Examples/Business Catalog';
// Payment item path is: '/sitecore/content/Examples/Business Catalog/Payments';
// In this case return page url is: '/Examples/Home/checkout/paymentreturnpage.aspx';
// But should be: '/checkout/paymentreturnpage.aspx';
Item targetPageItem = Sitecore.Context.Database.GetItem(linkField.TargetID);
Assert.IsNotNull(targetPageItem, string.Concat("'", fieldName, "' contains invalid target item"));
UrlOptions urlOptions = new UrlOptions
{
SiteResolving = true,
ShortenUrls = true,
AddAspxExtension = true,
EncodeNames = true,
LanguageEmbedding = LanguageEmbedding.AsNeeded
};
string relativeTargetPageUrl = LinkManager.GetItemUrl(targetPageItem, urlOptions);
Assert.IsNotNull(HttpContext.Current.Request, "Http request is null");
// If non regular http ports are used with instances on different ports like in Azure local emulation, HttpContext.Current.Request.Url.Port contains incorrect port.
// This can be removed if/when issue is fixed by Microsoft.
string host;
var port = HttpContext.Current.Request.Url.Port;
if (port == 80 || port == 443)
{
host = HttpContext.Current.Request.Url.Host;
}
else
{
host = HttpContext.Current.Request.ServerVariables["HTTP_HOST"];
}
UrlString url = new UrlString
{
HostName = host,
Path = relativeTargetPageUrl
};
return(url.ToString());
}
/// <summary>
/// Gets the field.
/// </summary>
/// <param name="field">The field.</param>
/// <param name="config">The config.</param>
/// <param name="context">The context.</param>
/// <returns>System.Object.</returns>
public override object GetField(Sitecore.Data.Fields.Field field, SitecoreFieldConfiguration config, SitecoreDataMappingContext context)
{
if (field == null || field.Value.Trim().IsNullOrEmpty())
{
return(null);
}
Link link = new Link();
LinkField linkField = new LinkField(field);
switch (linkField.LinkType)
{
case "anchor":
link.Url = linkField.Anchor;
link.Type = LinkType.Anchor;
break;
case "external":
link.Url = linkField.Url;
link.Type = LinkType.External;
break;
case "mailto":
link.Url = linkField.Url;
link.Type = LinkType.MailTo;
break;
case "javascript":
link.Url = linkField.Url;
link.Type = LinkType.JavaScript;
break;
case "media":
if (linkField.TargetItem == null)
{
link.Url = string.Empty;
}
else
{
global::Sitecore.Data.Items.MediaItem media =
new global::Sitecore.Data.Items.MediaItem(linkField.TargetItem);
link.Url = global::Sitecore.Resources.Media.MediaManager.GetMediaUrl(media);
}
link.Type = LinkType.Media;
link.TargetId = linkField.TargetID.Guid;
break;
case "internal":
if (linkField.TargetItem == null)
{
link.Url = string.Empty;
}
else
{
link.Url = LinkManager.GetItemUrl(linkField.TargetItem);
}
link.Type = LinkType.Internal;
link.TargetId = linkField.TargetID.Guid;
break;
default:
return(null);
}
link.Anchor = linkField.Anchor;
link.Class = linkField.Class;
link.Text = linkField.Text;
link.Title = linkField.Title;
link.Target = linkField.Target;
link.Query = linkField.QueryString;
return(link);
}
private void GenerateSiteMap()
{
try
{
SiteMapConfig siteMapConfig = new SiteMapConfig();
if (siteMapConfig.definedSites == null || !siteMapConfig.definedSites.Any())
{
return;
}
if (siteMapConfig.targetDatabaseName == string.Empty)
{
return;
}
foreach (var site in siteMapConfig.definedSites)
{
if (site.Fields[SiteItemFields.SiteName] == null || string.IsNullOrEmpty(site.Fields[SiteItemFields.SiteName].Value))
{
continue;
}
Sitecore.Sites.SiteContext _site = Factory.GetSite(site.Fields[SiteItemFields.SiteName].Value);
if (_site == null)
{
continue;
}
Item _root = GetTargetDatabase().GetItem(_site.StartPath);
if (_root == null)
{
continue;
}
string siteHostName;
if (string.IsNullOrEmpty(_site.TargetHostName))
{
var hostArray = _site.HostName.Split('|');
siteHostName = hostArray.FirstOrDefault();
}
else
{
siteHostName = _site.TargetHostName;
}
bool useServerUrlOverride = site.Fields[SiteItemFields.ServerURL] != null && !string.IsNullOrEmpty(site.Fields[SiteItemFields.ServerURL].Value);
string serverUrlOverrideUrl = site.Fields[SiteItemFields.ServerURL].Value;
StringBuilder sbSiteMap = new StringBuilder();
sbSiteMap.Append("<urlset xmlns='http://www.sitemaps.org/schemas/sitemap/0.9' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' xsi:schemaLocation='http://www.sitemaps.org/schemas/sitemap/0.9 http://www.sitemaps.org/schemas/sitemap/0.9/sitemap.xsd'>");
List <Item> siteMapItems = _root.Axes.GetDescendants().Where(P => P.Fields["Show In XML SiteMap"] != null && P.Fields["Show In XML SiteMap"].Value == "1").ToList();
if (siteMapItems != null && siteMapItems.Any())
{
if (_root.Fields["Show In XML SiteMap"].Value == "1")
{
siteMapItems.Add(_root);
}
var options = global::Sitecore.Links.LinkManager.GetDefaultUrlOptions();
options.LanguageEmbedding = LanguageEmbedding.Always;
options.SiteResolving = true;
// get langauges
List <Language> _availbleLangauges = null;
if (siteMapConfig.multilingualSiteMapXML)
{
Item _languagesRoot = GetTargetDatabase().GetItem(Guids.Items.LangaugesRootItem);
_availbleLangauges = _languagesRoot.Axes.GetDescendants().Where(P => P.Fields["Iso"].Value != string.Empty).Select(P => Language.Parse(P.Fields["Iso"].Value)).ToList();
}
else
{
_availbleLangauges = new List <Language>()
{
Language.Parse("en")
};
}
XmlDocument doc = new XmlDocument();
foreach (var langauge in _availbleLangauges)
{
options.Language = langauge;
options.EmbedLanguage(langauge);
options.Site = _site;
foreach (var item in siteMapItems)
{
options.AlwaysIncludeServerUrl = !useServerUrlOverride;
//to resolve issues with multisite link resolution here, set the rootPath="#" on the publisher site in web.config
//and also add scheme="http" to the Site Definition for your site
string url = LinkManager.GetItemUrl(item, options);
// Add URL override to url
if (useServerUrlOverride)
{
url = string.Format("{0}{1}", serverUrlOverrideUrl, url);
}
//handle where scheme="http" has not been added to Site Definitions
if (url.StartsWith("://"))
{
url = url.Replace("://", "");
}
if (!url.StartsWith("http://") || !url.StartsWith("https://"))
{
url = "http://" + url;
}
string lastUpdated = DateUtil.IsoDateToDateTime(item.Fields[Sitecore.FieldIDs.Updated].Value).ToString("yyyy-MM-ddTHH:mm:sszzz");
string FrequencyChange = "yearly";
if (item.Fields[SiteMapFields.FrequencyChange] != null)
{
if (!string.IsNullOrEmpty(item.Fields[SiteMapFields.FrequencyChange].Value))
{
Item _FrequencyChange = GetTargetDatabase().GetItem(item.Fields[SiteMapFields.FrequencyChange].Value);
if (_FrequencyChange != null)
{
FrequencyChange = _FrequencyChange.Name;
}
}
}
string Priority = "0.0";
if (item.Fields[SiteMapFields.Priority] != null)
{
if (!string.IsNullOrEmpty(item.Fields[SiteMapFields.Priority].Value))
{
Item _priority = GetTargetDatabase().GetItem(item.Fields[SiteMapFields.Priority].Value);
if (_priority != null && _priority.Fields["Value"] != null && !string.IsNullOrEmpty(_priority.Fields["Value"].Value))
{
Priority = _priority.Fields["Value"].Value;
}
}
}
sbSiteMap.Append("<url>");
sbSiteMap.Append("<loc>");
sbSiteMap.Append(url);
sbSiteMap.Append("</loc>");
sbSiteMap.Append("<lastmod>");
sbSiteMap.Append(lastUpdated);
sbSiteMap.Append("</lastmod>");
sbSiteMap.Append("<changefreq>");
sbSiteMap.Append(FrequencyChange);
sbSiteMap.Append("</changefreq>");
sbSiteMap.Append("<priority>");
sbSiteMap.Append(Priority);
sbSiteMap.Append("</priority>");
sbSiteMap.Append("</url>");
}
}
sbSiteMap.Append("</urlset>");
string fileName = "SiteMap.xml";
if (site.Fields[SiteItemFields.SitemMapXMLFilename] != null &&
!string.IsNullOrEmpty(site.Fields[SiteItemFields.SitemMapXMLFilename].Value))
{
fileName = site.Fields[SiteItemFields.SitemMapXMLFilename].Value;
}
doc.LoadXml(sbSiteMap.ToString());
string xmlFilePath = MainUtil.MapPath("/" + fileName);
doc.Save(xmlFilePath);
if (site.Fields[SiteItemFields.AddToRobotFile] != null)
{
// Base URL
var serverUrl = serverUrlOverrideUrl;
if (!useServerUrlOverride)
{
// handles multi site, single site with hostname defined and single site with no hostname defined
var item = siteMapItems.FirstOrDefault();
Uri mySite = new Uri(LinkManager.GetItemUrl(item, new UrlOptions {
LanguageEmbedding = LanguageEmbedding.Never, AlwaysIncludeServerUrl = true
}));
serverUrl = mySite.Scheme + Uri.SchemeDelimiter + mySite.Host;
}
serverUrl = serverUrl.EndsWith("/") ? serverUrl : serverUrl + "/"; // Ensure URL is built correctly
Sitecore.Data.Fields.CheckboxField _AddToRobotFile = site.Fields[SiteItemFields.AddToRobotFile];
if (_AddToRobotFile != null)
{
if (_AddToRobotFile.Checked)
{
AddSitemapToRobots(string.Format("{0}{1}", serverUrl, fileName));
}
}
}
Sitecore.Web.UI.Sheer.SheerResponse.Alert("SiteMap has been generated successfully");
}
}
}
catch (Exception exception)
{
Log.Error(exception.Message, "SiteMapBuilder - GenerateSiteMap method");
}
}
public static string GetUrl(this Item item)
{
return(!IsMedia(item) ? LinkManager.GetItemUrl(item) : MediaManager.GetMediaUrl(item));
}
public void GetItem_Test1()
{
//Assign
GeneralFluentFixtureNS.BasicTemplate test = null;
//Act
using (new SecurityDisabler())
{
test = _sitecore.GetItem <GeneralFluentFixtureNS.BasicTemplate>("/sitecore/content/Configuration/Fluent/GeneralFluent/GetItemTest1");
}
var getTestItem1 = _db.GetItem("/sitecore/content/Configuration/Fluent/GeneralFluent/GetItemTest1");
//Assert
#region SitecoreId
Assert.AreEqual(getTestItem1.ID.Guid, test.Id);
#endregion
#region Fields
#region SimpleTypes
Assert.IsTrue(test.Checkbox);
Assert.AreEqual(new DateTime(2011, 05, 01), test.Date);
Assert.AreEqual(new DateTime(2011, 06, 01, 06, 30, 00), test.DateTime);
var file = new File()
{
Id = new Guid("{368A358E-5835-458B-AFE6-BA5F80334F5A}"),
Src = "~/media/Files/SimpleTextFile.ashx"
};
Assert.AreEqual(file.Id, test.File.Id);
Assert.AreEqual(file.Src, test.File.Src);
var image = new Image()
{
Alt = "Alternate Text Test",
Border = "",
Class = "",
Height = 540,
HSpace = 50,
MediaId = new Guid("{223EEAE5-DF4C-4E30-95AC-17BE2F00E2CD}"),
Src = "~/media/Files/Kitten1.ashx",
VSpace = 60,
Width = 720,
};
Assert.AreEqual(image.Alt, test.Image.Alt);
Assert.AreEqual(image.Border, test.Image.Border);
Assert.AreEqual(image.Class, test.Image.Class);
Assert.AreEqual(image.Height, test.Image.Height);
Assert.AreEqual(image.HSpace, test.Image.HSpace);
Assert.AreEqual(image.MediaId, test.Image.MediaId);
Assert.AreEqual(image.Src, test.Image.Src);
Assert.AreEqual(image.VSpace, test.Image.VSpace);
Assert.AreEqual(image.Width, test.Image.Width);
Assert.AreEqual(456, test.Integer);
Assert.AreEqual(456f, test.Float);
Assert.AreEqual(456d, test.Double);
Assert.AreEqual(456m, test.Decimal);
Assert.AreEqual("Multi Line Text Test", test.MultiLineText);
Assert.AreEqual(789, test.Number);
Assert.AreEqual("Password Test", test.Password);
Assert.AreEqual("<p>Rich Text Test</p>", test.RichText.Trim());
Assert.AreEqual("Single Line Text Test", test.SingleLineText);
#endregion
#region List Types
Assert.AreEqual(2, test.CheckList.Count());
Assert.AreEqual(_check1.ID.Guid, test.CheckList.First().Id);
Assert.AreEqual(_check2.ID.Guid, test.CheckList.Last().Id);
Assert.AreEqual(TestEnum.Test1, test.DropList);
Assert.AreEqual(_test3.ID.Guid, test.GroupedDropLink.Id);
Assert.AreEqual(TestEnum.Test3, test.GroupedDropList);
Assert.AreEqual(_multiList1.ID.Guid, test.MultiList.First().Id);
Assert.AreEqual(_treeList1.ID.Guid, test.Treelist.First().Id);
Assert.AreEqual(_treeList2.ID.Guid, test.TreeListEx.First().Id);
#endregion
#region Link Types
Assert.AreEqual(_link1.ID.Guid, test.DropLink.Id);
Assert.AreEqual(_link2.ID.Guid, test.DropTree.Id);
var link = new Link()
{
Anchor = "",
Class = "Style Class Test",
Target = "_blank",
TargetId = Guid.Empty,
Text = "Link Description Test",
Title = "Alternate Text Test",
Url = "http://www.google.com"
};
Assert.AreEqual(link.Anchor, test.GeneralLink.Anchor);
Assert.AreEqual(link.Class, test.GeneralLink.Class);
Assert.AreEqual(link.Target, test.GeneralLink.Target);
Assert.AreEqual(link.TargetId, test.GeneralLink.TargetId);
Assert.AreEqual(link.Text, test.GeneralLink.Text);
Assert.AreEqual(link.Title, test.GeneralLink.Title);
Assert.AreEqual(link.Url, test.GeneralLink.Url);
#endregion
#region Developer Types
Assert.AreEqual("/sitecore/shell/Themes/Standard/Applications/48x48/about.png", test.Icon);
Assert.AreEqual(TriState.No, test.TriState);
#endregion
#region System Types
Console.WriteLine("Attachment not tested");
#endregion
#endregion
#region SitecoreInfo
Assert.AreEqual(getTestItem1.Paths.ContentPath, test.ContentPath);
Assert.AreEqual(getTestItem1.DisplayName, test.DisplayName);
Assert.AreEqual(getTestItem1.Paths.FullPath, test.FullPath);
Assert.AreEqual(getTestItem1.Key, test.Key);
Console.WriteLine("Not test media URL");
Assert.AreEqual(getTestItem1.Paths.Path, test.Path);
Assert.AreEqual(getTestItem1.TemplateID.Guid, test.TemplateId);
Assert.AreEqual(getTestItem1.TemplateName, test.TemplateName);
Assert.AreEqual(LinkManager.GetItemUrl(getTestItem1), test.Url);
Assert.AreEqual(getTestItem1.Version.Number, test.Version);
#endregion
#region SitecoreChildren
Assert.AreEqual(getTestItem1.Children.Count, test.Children.Count());
Assert.AreEqual(getTestItem1.Children.First().ID.Guid, test.Children.First().Id);
#endregion
#region SitecoreParent
Assert.AreEqual(getTestItem1.ParentID.Guid, test.Parent.Id);
#endregion
#region SitecoreQuery
//we have to use the security disabler because we are outside of an ASP.NET context
//if you do this without the disabler the role manager throws an exception
using (new SecurityDisabler())
{
Assert.AreEqual(3, test.Query.Count());
Assert.AreEqual(_query1.ID.Guid, test.Query.First().Id);
Assert.AreEqual(_query2.ID.Guid, test.Query.Skip(1).First().Id);
}
#endregion
}
/// <summary>
/// used to getting the link
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void frmOnline_Load(object sender, EventArgs e)
{
string sLinkID = string.Empty;
try
{
txtServerIp.Text = ConfigurationManager.AppSettings["ipconfig"].ToString();
m_sPort = ConfigurationManager.AppSettings["port"].ToString();
m_sLinkType = ConfigurationManager.AppSettings["linktype"].ToString();
m_objLinkManager = new LinkManager();
if (!Equals(m_objLinkManager, null))
{
if (string.Compare(m_sLinkType, "TCP", StringComparison.OrdinalIgnoreCase) == 0)
m_objLink = m_objLinkManager.GetLink(LINKTYPE.TCP, out sLinkID);
if (string.Compare(m_sLinkType, "NAMEDPIPE", StringComparison.OrdinalIgnoreCase) == 0)
m_objLink = m_objLinkManager.GetLink(LINKTYPE.NAMEDPIPE, out sLinkID);
}//end (if)
if (!Equals(m_objLink, null))
{
m_objLink.OnEngineConnected += new EventHandler<EngineArgs>(objLink_OnEngineConnected);
}//end (if)
this.FormClosing += new FormClosingEventHandler(frmOnline_FormClosing);
}//end (try)
catch (Exception ex)
{
LogWriter.WriteLog(MODULENAME, ex);
}//end (catch)
}
private void AddItemToQueue(params Item[] items)
{
//For now links are always added from one site as an array
if (!items.Any())
{
return;
}
var websiteItem = items.First();
var fullItemPath = websiteItem.Paths.FullPath.ToLower();
var site = GetSiteContext(fullItemPath);
if (site == null)
{
Log.Debug($"Cludo.Push.Url can't find website for item {fullItemPath}", this);
return;
}
//If there is no match for site ignore links
using (new SiteContextSwitcher(site))
{
var options = LinkManager.GetDefaultUrlOptions();
options.AlwaysIncludeServerUrl = true;
options.ShortenUrls = true;
options.SiteResolving = true;
if (options.LanguageEmbedding != LanguageEmbedding.Always &&
options.LanguageEmbedding != LanguageEmbedding.Never)
{
Log.Warn($"Cludo.Push.Url supports only linkManager with languageEmbedding as always or never https://sdn.sitecore.net/upload/sitecore6/sc62keywords/dynamic_links_sc62_a4.pdf", this);
return;
}
foreach (var urlGroup in items.GroupBy(i => i.Language.Name))
{
var contentId = ContentSourceId(urlGroup.Key);
if (contentId <= 0)
{
continue;
}
using (var client = GetClient())
{
var serilizer = new JavaScriptSerializer();
var result = client.PostAsync($"/api/v3/{CustomerId}/content/{contentId}/pushurls",
new StringContent(
serilizer.Serialize(
urlGroup.Select(item => LinkManager.GetItemUrl(item, options)).ToList()),
Encoding.UTF8, "application/json")).Result;
if (result.IsSuccessStatusCode)
{
return;
}
var message = result.Content.ReadAsStringAsync().Result;
Log.Error(
$"Invalid request to Cludo {result.RequestMessage.RequestUri}: Status: {result.StatusCode}, Message: {message}",
this);
}
}
}
}
