public string GetReference(ReferenceField field)
{
return(referenceTrackingList[
field.ReferenceType.NameSpace + "." +
field.ReferenceType.Name +
field.TableName]);
}
/// <summary>Serializes a reference type into a <see cref="DbEntry"/> instance
/// using the default <see cref="Field{T, F}"/> instance registered for that type.</summary>
/// <typeparam name="T">Reference type to serialize.</typeparam>
/// <param name="obj">Object to serialize.</param>
/// <returns>A properly initialized <see cref="DbEntry"/> instance containing
/// the serialized object graph.</returns>
public DbEntry ToDbEntry <T>(T obj)
where T : class
{
ReferenceField <T, Formatter> field = (ReferenceField <T, Formatter>)GetField <T>();
return(ToDbEntry(obj, field));
}
public void ClearReference(ReferenceField field, string value)
{
referenceTrackingList.Remove(
field.ReferenceType.NameSpace + "." +
field.ReferenceType.Name +
field.TableName);
}
public bool ReferenceUsed(ReferenceField field)
{
return(referenceTrackingList.ContainsKey(
field.ReferenceType.NameSpace + "." +
field.ReferenceType.Name +
field.TableName));
}
public virtual void CreateControlField(CodeWriter output,
ReferenceField f, bool instantiate)
{
if (f.IsClientEditEnabled)
{
if (!f.HasChildrenTables)
{
output.WriteLine("private DropDownList dd{0}" +
(instantiate ? " = new DropDownList();" : ";"),
f.Name);
}
else
{
output.WriteLine("private CheckBoxList cbl{0}" +
(instantiate ? " = new CheckBoxList();" : ";"),
f.Name);
}
}
else if (f.IsClientViewEnabled)
{
output.WriteLine("private Literal lt{0}" +
(instantiate ? " = new Literal();" : ";"),
f.Name);
}
}
public void SaveReference(ReferenceField field, string value)
{
referenceTrackingList.Add(
field.ReferenceType.NameSpace + "." +
field.ReferenceType.Name +
field.TableName, value);
}
public virtual void CreateClassField(CodeWriter output,
ReferenceField f, bool isInternal, bool instantiate)
{
if (f.IsArray)
{
output.WriteLine(
(isInternal ? "internal" : "private") + " {0}[] {1}" +
(instantiate ? " = new {0}[];" : ";"),
f.ReferenceType.Name,
f.PrivateName);
}
else if (f.IsCollection)
{
output.WriteLine(
(isInternal ? "internal" : "private") + " {0}Collection {1}" +
(instantiate ? " = new {0}Collection;" : ";"),
f.ReferenceType.Name,
f.PrivateName);
}
else
{
output.WriteLine(
(isInternal ? "internal" : "private") + "{0} {1}" +
(instantiate ? " = new {0};" : ";"),
f.ReferenceType.Name,
f.PrivateName);
}
}
public static Country GetCountry(Item item)
{
ReferenceField field = item?.Fields["Country"];
if (field == null)
{
return(new Country());
}
var countryItem = Sitecore.Context.Database.GetItem($"/sitecore/{field.InnerField.Source}/{field.Path}");
// var countryItem = Sitecore.Context.Database.GetItem(field.TargetItem.ID); // Target Item is null ???
if (countryItem == null)
{
return(new Country());
}
var country = new Country
{
CountryCode = countryItem.Fields["CountryCode"].Value,
CountryName = countryItem.Fields["CountryName"].Value,
CountryLatitude = double.Parse(countryItem.Fields["CountryLatitude"].Value),
CountryLongitude = double.Parse(countryItem.Fields["CountryLongitude"].Value),
CountryInfo = countryItem.Fields["CountryInfo"].Value,
};
return(country);
}
public void Execute(Item[] items, Sitecore.Tasks.CommandItem command, Sitecore.Tasks.ScheduleItem schedule)
{
Assert.IsNotNull(command, "command is null");
Assert.IsNotNull(schedule, "schedule is null");
Sitecore.Diagnostics.Log.Info("Task: Started Purging Publishing Activity Log data.", this);
// Get the module settings item.
Item settings = Sitecore.Configuration.Factory.GetDatabase("master").GetItem(Resources.Constants.SettingsItem);
if (settings == null)
{
Sitecore.Diagnostics.Log.Error("Task: Failed to get settings item.", this);
}
// Get the specified retention policy time.
ReferenceField retention = settings.Fields[Resources.Fields.scFieldRetentionPeriod];
int days = (retention == null || String.IsNullOrEmpty(retention?.TargetItem?.Fields["Value"]?.Value)) ? 7 : Int32.Parse(retention?.TargetItem?.Fields["Value"]?.Value);
// Filter expired items based on retention period.
List <Item> expiredLogItems = items.Where(x => (Sitecore.DateUtil.IsoDateToDateTime(((DateField)x.Fields[Resources.Fields.scFieldPublishDate]).Value) - DateTime.Now).TotalDays > days).ToList();
// Delete old items.
expiredLogItems.ForEach(x => x.Delete());
// Sync bucket to cleanup empty folders.
BucketManager.Sync(Sitecore.Configuration.Factory.GetDatabase("master").GetItem(Resources.Constants.PublishedItemsSaveLocation));
Sitecore.Diagnostics.Log.Info("Task: Finished Purging Publishing Activity Log data.", this);
}
/// <summary>Serializes reference type sequences accessible through <see cref="IEnumerable{T}"/>
/// using the default <see cref="Field{T, F}"/> instance registered for that type.</summary>
/// <typeparam name="T">Type of sequence elements - must be reference type.</typeparam>
/// <param name="value"><see cref="IEnumerable{T}"/> sequence to serialize.</param>
/// <returns>A properly initialized <see cref="DbEntry"/> instance containing
/// the serialized collection.</returns>
public DbEntry ObjectsToDbEntry <T>(IEnumerable <T> value)
where T : class
{
ReferenceField <T, Formatter> field = (ReferenceField <T, Formatter>)GetField <T>();
return(ObjectsToDbEntry(value, field));
}
public void BrokenLinkShouldNotFail()
{
//Arrange
using (var db = new Db {
new ItemBuilder()
.WithReference(new List <ID> {
ID.NewID
}).Build()
})
{
var item = db.GetItem("/sitecore/content/source");
var indexable = new SitecoreIndexableItem(item);
var sut = new ReferenceField
{
FieldName = "Reference",
};
//Act
var actual = (IEnumerable <string>)sut.ComputeFieldValue(indexable);
//Assert
actual.Should().BeEquivalentTo();
}
}
public virtual IEnumerable <string> GetInterests()
{
var item = GetSettingsItem(null);
ReferenceField interestsFolder = item.Fields[Templates.ProfileSettigs.Fields.InterestsFolder];
return(interestsFolder?.TargetItem?.Children.Where(i => i.IsDerived(Templates.Interest.ID))?.Select(i => i.Fields[Templates.Interest.Fields.Title].Value) ?? Enumerable.Empty <string>());
}
/// <summary>Deserializes any kind of reference type collection through call-backs
/// using the default <see cref="Field{T, F}"/> instance registered for that type.</summary>
/// <typeparam name="T">Type of sequence elements - must be reference type.</typeparam>
/// <param name="initSequence">Call-back delegate to instantiate/initialize collection.
/// Returns another delegate to add sequence elements to the collection.</param>
/// <param name="entry"><see cref="DbEntry"/> instance containing the serialized data.</param>
public void ObjectsFromDbEntry <T>(InitSequence <T> initSequence, ref DbEntry entry)
where T : class
{
ReferenceField <T, Formatter> field = (ReferenceField <T, Formatter>)GetField <T>();
ObjectsFromDbEntry(initSequence, ref entry, field);
}
public MapPluginViewModel GetModel()
{
// Instantiate Map Model.
MapPluginViewModel model = new MapPluginViewModel();
// Current Rendering Item.
var contentItem = RenderingContext.Current?.Rendering?.Item ?? null;
model.Item = contentItem;
if (contentItem == null)
{
return(model);
}
// Get Bing Maps API Key.
model.ApiKey = GetBingMapsApiKey();
// Set Property Values.
CheckboxField disableZoomField = contentItem.Fields[Resources.Resource.scFieldDisableZooming];
model.DisableZooming = disableZoomField == null ? false : disableZoomField.Value == "1";
CheckboxField disableSearchField = contentItem.Fields[Resources.Resource.scFieldDisableSearch];
model.DisableSearch = disableSearchField == null ? false : disableSearchField.Value == "1";
ReferenceField mapTypeField = contentItem.Fields[Resources.Resource.scFieldType];
model.MapTypeId = (mapTypeField == null || String.IsNullOrEmpty(mapTypeField?.TargetItem?.Fields["Value"]?.Value)) ? "Microsoft.Maps.MapTypeId.road" : mapTypeField?.TargetItem?.Fields["Value"]?.Value;
model.Guid = contentItem.ID.Guid.ToString();
return(model);
}
protected void Page_Load(object sender, EventArgs e)
{
var item = Sitecore.Context.Item;
if (item.TemplateID == TemplateReferences.Holiday)
{
var json = new JSONHoliday();
json.PageHeading = FieldRenderer.Render(item, "Page Heading");
json.PageContent = FieldRenderer.Render(item, "Page Content");
ReferenceField difficulty = item.Fields["Difficulty"];
json.DifficultyLabel = Sitecore.Globalization.Translate.Text("Difficulty");
json.Difficulty = FieldRenderer.Render(difficulty.TargetItem, "Text");
ReferenceField type = item.Fields["Type"];
json.TypeLabel = Sitecore.Globalization.Translate.Text("Type");
json.Type = FieldRenderer.Render(type.TargetItem, "Text");
MultilistField terrain = item.Fields["Terrain"];
json.TerrainLabel = Sitecore.Globalization.Translate.Text("Terrain");
json.Terrain = string.Join(",", terrain.GetItems().Select(x => FieldRenderer.Render(x, "Text")));
JavaScriptSerializer serializer = new JavaScriptSerializer();
Response.Write(serializer.Serialize(json));
}
}
//This method is used to create Team item in the database
public virtual void OnUpdateCommentRemote(object sender, EventArgs e)
{
if (e is CreateTeamEventArgs)
{
var args = e as CreateTeamEventArgs;
var master = Sitecore.Configuration.Factory.GetDatabase("master");
using (new SecurityDisabler())
{
TemplateItem templateItem = master.GetTemplate(ID.Parse(Templates.Team.TemplateId));
var parentItem = master.GetItem(Sitecore.Context.Site.StartPath);
ReferenceField droplink = parentItem.Fields[ID.Parse(Templates.HackathonSettings.Fields.ActualContest)];
if (droplink == null)
{
//Field does not exist
}
else if (droplink.TargetItem == null)
{
// No item selected
}
else if (droplink.TargetItem.HasChildren && templateItem != null)
{
var childItem = droplink.TargetItem.Children.InnerChildren.Find(f => f.TemplateID.ToString() == Templates.TeamFolder.TemplateId);
if (childItem != null)
{
EditItem(templateItem, childItem, args);
}
}
}
}
}
public override void Create(VisualElement root)
{
var field = new ReferenceField("Reference", typeof(ISampleItem), new SampleItemDrawer());
field.RegisterValueChangedCallback(evt => Debug.Log($"Reference type changed from {evt.previousValue?.GetType().Name ?? "null"} to {evt.newValue?.GetType().Name ?? "null"}"));
root.Add(field);
}
/// <summary>Deserializes reference type arrays from a <see cref="DbEntry"/> instance
/// using the default <see cref="Field{T, F}"/> instance registered for that type.</summary>
/// <typeparam name="T">Type of sequence elements - must be reference type.</typeparam>
/// <param name="obj">Reference type array to deserialize.</param>
/// <param name="entry"><see cref="DbEntry"/> instance containing the serialized data.</param>
public void ObjectsFromDbEntry <T>(ref T[] obj, ref DbEntry entry)
where T : class
{
ReferenceField <T, Formatter> field = (ReferenceField <T, Formatter>)GetField <T>();
ObjectsFromDbEntry(ref obj, ref entry, field);
}
private Item GetErrorItem(string fieldId)
{
var settingsItem = GetContextSiteSettingsItem();
ReferenceField errorItemField = settingsItem?.Fields[fieldId];
return(errorItemField?.TargetItem);
}
public override void CreateControlField(CodeWriter output,
ReferenceField c, bool instantiate)
{
output.WriteLine("private ComponentArt.Web.UI.ComboBox combo{0}" +
(instantiate ? " = new ComponentArt.Web.UI.ComboBox();" : ";"),
c.Name);
}
public override void CreateControlBinding(CodeWriter output, ReferenceField c)
{
WebEditorReferenceFieldExtension extension = (WebEditorReferenceFieldExtension)
c.GetExtension(typeof(WebEditorReferenceFieldExtension));
if (c.IsClientEditEnabled)
{
if (c.ReferenceType.IsTableCoded)
{
if (!output.ReferenceUsed(c))
{
output.WriteLine("{0}Manager {1}Manager = new {0}Manager();",
c.ReferenceType.Name,
c.ReferenceType.ParentClassEntry.PrivateName,
c.Name);
output.WriteLine("{0}Collection {1}Collection = " +
"{1}Manager.GetCollection(string.Empty, string.Empty);",
c.ReferenceType.Name,
c.ReferenceType.ParentClassEntry.PrivateName);
// Save Reference For Later :)~ Take that!
output.SaveReference(c,
c.ReferenceType.ParentClassEntry.PrivateName +
"Collection");
}
}
else
{
if (!output.ReferenceUsed(c))
{
// BLECH! A Custom Manager, Blah BLAH!
output.WriteLine("{0}Manager {1}Manager = new {0}Manager(\"{2}\");",
c.ReferenceType.Name, c.PrivateName, c.TableName);
output.WriteLine("{0}Collection {1}Collection = " +
"{1}Manager.GetCollection(string.Empty, string.Empty);",
c.ReferenceType.Name, c.PrivateName);
// Save another pesky reference for later!
// Don't worry so much bud, it keeps track of tables!
output.SaveReference(c, c.PrivateName + "Collection");
}
}
output.WriteLine("foreach({0} itemObject in {1})",
c.ReferenceType.Name, output.GetReference(c));
output.WriteLine("{");
output.Indent++;
output.WriteLine("ComponentArt.Web.UI.ComboBoxItem item = " +
"new ComponentArt.Web.UI.ComboBoxItem();");
output.WriteLine("item.Text = itemObject." +
extension.ListText + ";");
output.WriteLine("item.Value = itemObject.ID.ToString();");
output.WriteLine("combo{0}.Items.Add(item);", c.Name);
output.Indent--;
output.WriteLine("}");
output.WriteLine();
}
}
public virtual void CreateControlProperties(CodeWriter output,
ClassFolder folder, bool instantiate, bool enableViewState,
string addControlFormat)
{
foreach (object item in folder.Items)
{
if (item is ValueField)
{
ValueField f = (ValueField)item;
f.Builder.CreateControlProperties(output, f, instantiate,
enableViewState, addControlFormat);
output.WriteLine();
}
else if (item is ReferenceField)
{
ReferenceField f = (ReferenceField)item;
f.Builder.CreateControlProperties(output, f, instantiate,
enableViewState, addControlFormat);
output.WriteLine();
}
else if (item is EnumField)
{
EnumField f = (EnumField)item;
f.Builder.CreateControlProperties(output, f, instantiate,
enableViewState, addControlFormat);
output.WriteLine();
}
}
}
public void ShouldReturnCustomTitle()
{
//Arrange
using (var db = new Db {
new ItemBuilder().AddSubItemWithField("titleField", "titleValue")
.WithReference("droplink").Build()
})
{
var item = db.GetItem("/sitecore/content/source");
var indexable = new SitecoreIndexableItem(item);
var xmlDoc = new XmlDocument();
xmlDoc.LoadXml(@"<field><target referenceFieldName=""titleField""/></field>");
var xmlNode = xmlDoc.FirstChild;
var sut = new ReferenceField(xmlNode)
{
FieldName = "Reference"
};
//Act
var actual = (IEnumerable <string>)sut.ComputeFieldValue(indexable);
//Assert
actual.Should().BeEquivalentTo("titleValue");
}
}
public virtual ActionResult Index()
{
Item actionItem;
string explicitDatasource = RenderingContext.Current.Rendering.DataSource;
if (string.IsNullOrEmpty(explicitDatasource))
{
var siteRoot = GetSiteRoot(Sitecore.Context.Item);
ReferenceField rf = siteRoot.Fields["Site Root Global Navigation"];
if (rf?.TargetItem != null)
{
actionItem = rf.TargetItem;
}
else
{
actionItem = GetActionItem();
}
}
else
{
actionItem = GetActionItem();
}
if (actionItem != null && actionItem.Versions.Count > 0)
{
var model = _navigationRepository.GetModel(actionItem);
return(View(GetViewName("Top Navigation"), SetComponentProperties(model)));
}
return(DatasourceMissingResult());
}
public ActionResult FeaturedRecipes()
{
if (Sitecore.Context.Item == null)
{
return(null);
}
var dataSourceId = Sitecore.Context.Item.ID.ToString();
Assert.IsNotNullOrEmpty(dataSourceId, "dataSourceId is null or empty");
var item = Sitecore.Context.Database.GetItem(dataSourceId);
if (item == null)
{
return(null);
}
FeaturedRecipes featuredRecipes = new FeaturedRecipes();
//Featured Recipe - DropTree Field
ReferenceField featuredRecipeField = item.Fields[Templates.FeaturedRecipe.Fields.FeaturedRecipe];
Item featuredRecipeItem = Sitecore.Context.Database.GetItem(featuredRecipeField.TargetID);
if (featuredRecipeItem != null)
{
Recipe featuredRecipe = new Recipe();
featuredRecipe.RecipeName = featuredRecipeItem.Fields[Templates.Recipe.Fields.RecipeName.ToString()].Value;
featuredRecipe.RecipeDescription = featuredRecipeItem.Fields[Templates.Recipe.Fields.RecipeDescription.ToString()].Value;
featuredRecipes.FeaturedRecipe = featuredRecipe;
ImageField featuredRecipeImage = featuredRecipeItem.Fields[Templates.Recipe.Fields.RecipeImage];
featuredRecipe.RecipeImageUrl = Sitecore.Resources.Media.MediaManager.GetMediaUrl(featuredRecipeImage.MediaItem);
featuredRecipe.RecipeImageAlt = featuredRecipeImage.Alt;
}
//Featured Recipes List - TreeList Field
MultilistField featuredRecipesListField = item.Fields[Templates.FeaturedRecipe.Fields.FeaturedRecipesList];
Item[] featuredRecipeItems = featuredRecipesListField.GetItems();
List <Recipe> featuredRecipesList = new List <Recipe>();
if (featuredRecipeItems != null && featuredRecipeItems.Count() > 0)
{
foreach (Item i in featuredRecipeItems)
{
Recipe recipe = new Recipe();
Item recipeItem = Sitecore.Context.Database.GetItem(i.ID);
recipe.RecipeName = recipeItem.Fields[Templates.Recipe.Fields.RecipeName.ToString()].Value;
recipe.RecipeDescription = recipeItem.Fields[Templates.Recipe.Fields.RecipeDescription.ToString()].Value;
ImageField recipeImage = recipeItem.Fields[Templates.Recipe.Fields.RecipeImage];
recipe.RecipeImageUrl = Sitecore.Resources.Media.MediaManager.GetMediaUrl(recipeImage.MediaItem);
recipe.RecipeImageAlt = recipeImage.Alt;
featuredRecipesList.Add(recipe);
}
}
featuredRecipes.FeaturedRecipesList = featuredRecipesList;
return(View(featuredRecipes));
}
/// <summary>
/// Get the referenced target item from the named reference field (Droplink, Droptree, Grouped Droplink). If the field not found or the reference null, it will return null.
/// </summary>
/// <returns>The the referenced target item from the named reference field. If the field not found or the reference null, it will return null</returns>
public static Item GetReferenceTarget(this Item item, string referenceFieldName)
{
Assert.ArgumentNotNullOrEmpty(referenceFieldName, "referenceFieldName");
ReferenceField referenceField = item.Fields[referenceFieldName];
return((referenceField == null) ? null : referenceField.TargetItem);
}
/// <summary>
/// Gets player ID.
/// </summary>
/// <param name="asset">
/// The asset.
/// </param>
/// <returns>
/// The <see cref="string"/>.
/// </returns>
protected virtual string GetPlayerId(Item asset)
{
ReferenceField field = asset.Fields[FieldIDs.MediaElement.Player];
Item targetItem = field.TargetItem;
return(targetItem != null ? targetItem[FieldIDs.Player.Id] : string.Empty);
}
/// <overloads>Deserializes reference type sequences (arrays, collections) from
/// a <see cref="DbEntry"/> instance.</overloads>
/// <summary>Deserializes reference type arrays from a <see cref="DbEntry"/>
/// instance using a specific <see cref="Field{T, F}"/> instance.</summary>
/// <typeparam name="T">Type of sequence elements - must be reference type.</typeparam>
/// <param name="obj">Reference type array to deserialize.</param>
/// <param name="entry"><see cref="DbEntry"/> instance containing the serialized data.</param>
/// <param name="field"><see cref="ReferenceField{T, Formatter}"/> instance that
/// deserializes the <c>entry</c>argument.</param>
public void ObjectsFromDbEntry <T>(ref T[] obj, ref DbEntry entry, ReferenceField <T, Formatter> field)
where T : class
{
int index = entry.Start;
InitDeserialization(entry.Buffer, index);
DeserializeObjects(ref obj, field);
index = FinishDeserialization();
}
public WildcardSetting(Item setting)
{
ReferenceField itemReference = setting.Fields[AppConstants.WildcardSettingItemField];
ItemID = itemReference?.TargetItem?.ID;
ReferenceField datasourceReference = setting.Fields[AppConstants.WildcardSettingItemField];
DatasourceTemplateID = datasourceReference?.TargetItem?.ID;
}
public override Item GetDefaultPlayer(MediaGenerateMarkupArgs args)
{
ID fieldId = args.MediaItem.TemplateID == TemplateIDs.Video
? FieldIDs.AccountSettings.DefaultVideoPlayer
: FieldIDs.AccountSettings.DefaultPlaylistPlayer;
ReferenceField settingsField = AccountManager.GetSettingsField(args.AccountItem, fieldId);
return(settingsField != null ? settingsField.TargetItem : null);
}
/// <summary>
/// Returns lookup field value as an item display name instead of item ID.
/// </summary>
/// <returns></returns>
public override string GetValue()
{
var value = String.Empty;
if (FieldTypeManager.GetField(_field) is LookupField)
{
var lookupField = new LookupField(_field);
value = IdHelper.NormalizeGuid(lookupField.TargetID);
}
if (FieldTypeManager.GetField(_field) is ReferenceField)
{
var referenceField = new ReferenceField(_field);
value = IdHelper.NormalizeGuid(referenceField.TargetID);
}
return value;
}
/// <summary>
/// Initializes a new instance of the <see cref="ReferenceProperty"/> class.
/// </summary>
/// <param name="field">The field to wrap.</param>
public ReferenceProperty(Field field)
: base(field)
{
this.referenceField = field;
}
