public void ResetFieldById(DbFieldCollection sut, [Frozen] ID id, DbField originalField, DbField newField)
{
sut[id] = originalField;
sut[id] = newField;
sut[id].Should().BeSameAs(newField);
}
public void ShouldCreateTemplateFieldItemBasedOnDbField(ID templateId, DbField field)
{
using (var db = new Db { new DbTemplate(templateId) { field } })
{
db.GetItem(field.ID).Should().NotBeNull();
}
}
public void ShouldCreateTemplateFieldItemWithTypeField(ID templateId, DbField field)
{
using (var db = new Db { new DbTemplate(templateId) { field } })
{
var templateFieldItem = (TemplateFieldItem)db.GetItem(field.ID);
templateFieldItem.Type.Should().Be(field.Type);
}
}
private static void SetFieldValue(DbField field, string lang, string value)
{
var valueSet = !string.IsNullOrEmpty(
field.GetValue(lang, Version.Latest.Number));
if (!valueSet)
{
field.SetValue(lang, value);
}
}
public void ShouldAddTemplateFieldItemsToDefaultSection(TemplateTreeBuilder sut, DbTemplate template, DbField field1, DbField field2)
{
template.Add(field1);
template.Add(field2);
sut.Build(template);
var section = template.Children.Single();
section.Children.Should().HaveCount(2);
}
public void ShouldGetFieldById()
{
// arrange
var id = ID.NewID;
var field = new DbField("Title") { ID = id };
var collection = new DbFieldCollection { field };
// act & assert
collection[id].ShouldBeEquivalentTo(field);
}
public void ShouldCreateTemplateFieldItemWithSharedField(bool shared, ID templateId, DbField field)
{
field.Shared = shared;
using (var db = new Db { new DbTemplate(templateId) { field } })
{
var templateFieldItem = (TemplateFieldItem)db.GetItem(field.ID);
templateFieldItem.Shared.Should().Be(shared);
}
}
public void ShouldSaveFieldSource(TemplateTreeBuilder sut, DbTemplate template, DbField field)
{
field.Source = "/sitecore/content";
template.Add(field);
sut.Build(template);
var section = template.Children.Single();
var fieldItem = section.Children.Single();
fieldItem.Fields[TemplateFieldIDs.Source].Value.Should().Be("/sitecore/content");
}
public void ShouldSaveFieldType(TemplateTreeBuilder sut, DbTemplate template, DbField field)
{
field.Type = "General Link";
template.Add(field);
sut.Build(template);
var section = template.Children.Single();
var fieldItem = section.Children.Single();
fieldItem.Fields[TemplateFieldIDs.Type].Value.Should().Be("General Link");
}
public void ShouldAddFieldCopyToStandardValues(DbTemplate template, DbField field, string standardValue)
{
template.Add(field, standardValue);
template.StandardValues.Should().Contain(
f => f.Name == field.Name &&
f.ID == field.ID &&
f.Shared == field.Shared &&
f.Source == field.Source &&
f.Type == field.Type &&
f.Value == standardValue);
}
public void ShouldSetTemplateFieldItemData(TemplateTreeBuilder sut, DbTemplate template, DbField field)
{
template.Add(field);
sut.Build(template);
var section = template.Children.Single();
var fieldItem = section.Children.Single();
fieldItem.ID.Should().Be(field.ID);
fieldItem.Name.Should().Be(field.Name);
fieldItem.TemplateID.Should().Be(TemplateIDs.TemplateField);
}
public void ShouldSetFieldById()
{
// arrange
var id = ID.NewID;
var originalField = new DbField("Title") { ID = id };
var newField = new DbField("Title") { ID = id };
var collection = new DbFieldCollection { originalField };
// act
collection[id] = newField;
// assert
collection[id].ShouldBeEquivalentTo(newField);
}
public void ProcessSetsValidRevision(
SetStatistics sut,
[Frozen] DbItem item,
AddDbItemArgs args,
ID id,
string value)
{
var field = new DbField(id) { { "en", value } };
item.Fields.Add(field);
sut.Process(args);
var actual = item.Fields[FieldIDs.Revision].GetValue("en", 0);
Assert.True(ID.IsID(actual));
}
public virtual void Process(AddDbItemArgs args)
{
var item = args.DbItem;
var dataStorage = args.DataStorage;
var isResolved = this.ResolveTemplate(item, dataStorage);
if (isResolved)
{
new TemplateTreeBuilder().Build(item);
return;
}
if (!ID.IsNullOrEmpty(item.TemplateID) && dataStorage.GetFakeTemplate(item.TemplateID) != null)
{
return;
}
if (item.TemplateID == ID.Null)
{
item.TemplateID = ID.NewID;
}
var template = new DbTemplate(item.Name, item.TemplateID)
{
Generated = true
};
foreach (var itemField in item.Fields)
{
var templatefield = new DbField(itemField.Name, itemField.ID)
{
Shared = itemField.Shared,
Type = itemField.Type,
Source = itemField.Source
};
template.Add(templatefield);
}
new TemplateTreeBuilder().Build(item);
dataStorage.AddFakeItem(template);
}
public void ProcessSetsSameCreateAndUpdateInfoForAllLanguages(
string statisticField,
SetStatistics sut,
[Frozen] DbItem item,
AddDbItemArgs args,
ID id1,
ID id2,
string value1,
string value2)
{
var statisticFieldId = ID.Parse(statisticField);
var fieldEn = new DbField(id1) { { "en", value1 } };
var fieldDa = new DbField(id2) { { "da", value2 } };
item.Fields.Add(fieldEn);
item.Fields.Add(fieldDa);
sut.Process(args);
var valueEn = item.Fields[statisticFieldId].GetValue("en", 0);
var valueDa = item.Fields[statisticFieldId].GetValue("da", 0);
valueEn.Should().Be(valueDa);
}
public void ProcessSetsUniqueRevisionsForAllLanguages(
SetStatistics sut,
[Frozen] DbItem item,
AddDbItemArgs args,
ID id1,
ID id2,
string value1,
string value2)
{
var fieldEn = new DbField(id1) { { "en", value1 } };
var fieldDa = new DbField(id2) { { "da", value2 } };
item.Fields.Add(fieldEn);
item.Fields.Add(fieldDa);
sut.Process(args);
var revisionEn = item.Fields[FieldIDs.Revision].GetValue("en", 0);
var revisionDa = item.Fields[FieldIDs.Revision].GetValue("da", 0);
revisionEn.Should().NotBeNullOrEmpty();
revisionDa.Should().NotBeNullOrEmpty();
revisionEn.Should().NotBe(revisionDa);
}
protected virtual void CopyField(DbField field, DbItem copy)
{
copy.Fields.Add(new DbField(field.Name, field.ID)
{
Shared = field.Shared,
Type = field.Type
});
if (field.Shared)
{
copy.Fields[field.ID].Value = field.Value;
}
else
{
foreach (var fieldValue in field.Values)
{
var language = fieldValue.Key;
var versions = fieldValue.Value.ToDictionary(v => v.Key, v => v.Value);
copy.Fields[field.ID].Values.Add(language, versions);
}
}
}
public void ShouldGetSomeValueForInvariantLanguageIfShared(DbField sut)
{
sut.Shared = true;
sut.GetValue(Language.Invariant.Name, 0).Should().NotBeEmpty();
}
public void ShouldGetSomeValueForInvariantLanguageIfShared(DbField field)
{
// arrange
field.Shared = true;
// act & assert
field.GetValue(Language.Invariant.Name, 0).Should().NotBeEmpty();
}
public void Write(DbField value)
{
this.outputStream.Write(value);
}
public void ShouldMapDefaultFieldIdByName(string fieldName, string expectedId)
{
// act
var dbfield = new DbField(fieldName);
// assert
dbfield.ID.ToString().Should().Be(expectedId);
}
public void ShouldGetEmptyValueForInvariantLanguageIfNotShared(DbField field)
{
// arrange
field.Shared = false;
// act & assert
field.GetValue(Language.Invariant.Name, 0).Should().BeEmpty();
}
public void ShouldMarkStandardFieldsSharedByDefault(string fieldName, bool shared)
{
// arrange & act
var dbfield = new DbField(fieldName);
// assert
dbfield.Shared.Should().Be(shared);
}
public void ShouldMapDefaultFieldNameById(string fieldId, string expectedName)
{
// arrange
var id = new ID(fieldId);
// act
var dbfield = new DbField(id);
// assert
dbfield.Name.Should().Be(expectedName);
}
public DbFieldTest()
{
this.field = new DbField("Title");
}
public void ShouldGetFieldListByTemplateId()
{
// arrange
var templateId = ID.NewID;
var field1 = new DbField("Title");
var field2 = new DbField("Title");
var template = new DbTemplate { ID = templateId, Fields = { field1, field2 } };
this.dataStorage.FakeTemplates.Add(templateId, template);
// act
var fieldList = this.dataStorage.GetFieldList(template.ID);
// assert
fieldList.Count.Should().Be(2);
fieldList[field1.ID].Should().BeEmpty();
fieldList[field2.ID].Should().BeEmpty();
}
public void ShouldReturnFalseIfNoValueFoundForLanguage(DbItem sut, DbField field, string language)
{
field.Values[language] = new Dictionary<int, string>();
sut.Add(field);
sut.RemoveVersion(language).Should().BeFalse();
}
protected void FillDefaultFakeItems()
{
var field = new DbField("__Security") { Value = "ar|Everyone|p*|+*|" };
this.FakeItems.Add(ItemIDs.RootID, new DbItem(ItemNames.Sitecore, ItemIDs.RootID, TemplateIdSitecore) { ParentID = ID.Null, FullPath = "/sitecore", Fields = { field } });
this.FakeItems.Add(ItemIDs.ContentRoot, new DbItem(ItemNames.Content, ItemIDs.ContentRoot, TemplateIDs.MainSection) { ParentID = ItemIDs.RootID, FullPath = "/sitecore/content" });
this.FakeItems.Add(ItemIDs.TemplateRoot, new DbItem(ItemNames.Templates, ItemIDs.TemplateRoot, TemplateIDs.MainSection) { ParentID = ItemIDs.RootID, FullPath = "/sitecore/templates" });
this.FakeItems.Add(ItemIDs.BranchesRoot, new DbItem(ItemNames.Branches, ItemIDs.BranchesRoot, TemplateIDs.BranchTemplateFolder) { ParentID = ItemIDs.TemplateRoot, FullPath = "/sitecore/templates/Branches" });
this.FakeItems.Add(ItemIDs.SystemRoot, new DbItem(ItemNames.System, ItemIDs.SystemRoot, TemplateIDs.MainSection) { ParentID = ItemIDs.RootID, FullPath = "/sitecore/system" });
this.FakeItems.Add(ItemIDs.MediaLibraryRoot, new DbItem(ItemNames.MediaLibrary, ItemIDs.MediaLibraryRoot, TemplateIDs.MainSection) { ParentID = ItemIDs.RootID, FullPath = "/sitecore/media library" });
this.FakeItems[ItemIDs.RootID].Add(this.FakeItems[ItemIDs.ContentRoot]);
this.FakeItems[ItemIDs.RootID].Add(this.FakeItems[ItemIDs.TemplateRoot]);
this.FakeItems[ItemIDs.RootID].Add(this.FakeItems[ItemIDs.SystemRoot]);
this.FakeItems[ItemIDs.RootID].Add(this.FakeItems[ItemIDs.MediaLibraryRoot]);
// TODO: Move 'Template' item to proper directory to correspond Sitecore structure.
this.FakeItems.Add(TemplateIDs.TemplateSection, new DbTemplate(ItemNames.TemplateSection, TemplateIDs.TemplateSection, TemplateIDs.TemplateSection) { ParentID = ItemIDs.TemplateRoot, FullPath = "/sitecore/templates/template section" });
this.FakeItems.Add(TemplateIDs.BranchTemplate, new DbItem(ItemNames.Branch, TemplateIDs.BranchTemplate, TemplateIDs.Template) { ParentID = ItemIDs.TemplateRoot, FullPath = "/sitecore/templates/branch" });
this.AddFakeItem(new DbItem(ItemNames.DefinitionsRoot, ItemIDs.Analytics.MarketingCenterItem, TemplateIDs.Folder) { ParentID = ItemIDs.SystemRoot, FullPath = "/sitecore/system/Marketing Control Panel" });
this.AddFakeItem(new DbItem(ItemNames.Profiles, ItemIDs.Analytics.Profiles, TemplateIDs.Folder) { ParentID = ItemIDs.Analytics.MarketingCenterItem, FullPath = "/sitecore/system/Marketing Control Panel/Profiles" });
if (this.Database.Name == "core")
{
this.AddFakeItem(
new DbItem(ItemNames.FieldTypes, new ID("{76E6D8C7-1F93-4712-872B-DA3C96B808F2}"), TemplateIDs.Node)
{
ParentID = ItemIDs.SystemRoot,
Children = { new DbItem("text") { { "Control", "Text" } } }
});
}
}
/// <summary>
/// Creates a SQL Statement for merge-all operation.
/// </summary>
/// <param name="queryBuilder">The query builder to be used.</param>
/// <param name="tableName">The name of the target table.</param>
/// <param name="fields">The list of fields to be merged.</param>
/// <param name="qualifiers">The list of the qualifier <see cref="Field"/> objects.</param>
/// <param name="batchSize">The batch size of the operation.</param>
/// <param name="primaryField">The primary field from the database.</param>
/// <param name="identityField">The identity field from the database.</param>
/// <param name="hints">The table hints to be used.</param>
/// <returns>A sql statement for merge operation.</returns>
public override string CreateMergeAll(QueryBuilder queryBuilder,
string tableName,
IEnumerable <Field> fields,
IEnumerable <Field> qualifiers = null,
int batchSize = Constant.DefaultBatchOperationSize,
DbField primaryField = null,
DbField identityField = null,
string hints = null)
{
// Ensure with guards
GuardTableName(tableName);
GuardHints(hints);
GuardPrimary(primaryField);
GuardIdentity(identityField);
// Verify the fields
if (fields?.Any() != true)
{
throw new MissingFieldsException($"The list of fields cannot be null or empty.");
}
// Check the qualifiers
if (qualifiers?.Any() == true)
{
// Check if the qualifiers are present in the given fields
var unmatchesQualifiers = qualifiers.Where(field =>
fields.FirstOrDefault(f =>
string.Equals(field.Name, f.Name, StringComparison.OrdinalIgnoreCase)) == null);
// Throw an error we found any unmatches
if (unmatchesQualifiers.Any() == true)
{
throw new InvalidQualifiersException($"The qualifiers '{unmatchesQualifiers.Select(field => field.Name).Join(", ")}' are not " +
$"present at the given fields '{fields.Select(field => field.Name).Join(", ")}'.");
}
}
else
{
if (primaryField != null)
{
// Make sure that primary is present in the list of fields before qualifying to become a qualifier
var isPresent = fields.FirstOrDefault(f => string.Equals(f.Name, primaryField.Name, StringComparison.OrdinalIgnoreCase)) != null;
// Throw if not present
if (isPresent == false)
{
throw new InvalidQualifiersException($"There are no qualifier field objects found for '{tableName}'. Ensure that the " +
$"primary field is present at the given fields '{fields.Select(field => field.Name).Join(", ")}'.");
}
// The primary is present, use it as a default if there are no qualifiers given
qualifiers = primaryField.AsField().AsEnumerable();
}
else
{
// Throw exception, qualifiers are not defined
throw new MissingQualifierFieldsException($"There are no qualifier fields found for '{tableName}'.");
}
}
// Get the insertable and updateable fields
var insertableFields = fields
.Where(field => !string.Equals(field.Name, identityField?.Name, StringComparison.OrdinalIgnoreCase));
var updateableFields = fields
.Where(field => !string.Equals(field.Name, primaryField?.Name, StringComparison.OrdinalIgnoreCase) &&
!string.Equals(field.Name, identityField?.Name, StringComparison.OrdinalIgnoreCase));
// Variables needed
var databaseType = (string)null;
// Check for the identity
if (identityField != null)
{
var dbType = new ClientTypeToDbTypeResolver().Resolve(identityField.Type);
if (dbType != null)
{
databaseType = new DbTypeToSqlServerStringNameResolver().Resolve(dbType.Value);
}
}
else if (primaryField != null)
{
var dbType = new ClientTypeToDbTypeResolver().Resolve(primaryField.Type);
if (dbType != null)
{
databaseType = new DbTypeToSqlServerStringNameResolver().Resolve(dbType.Value);
}
}
// Initialize the builder
var builder = queryBuilder ?? new QueryBuilder();
// Build the query
builder.Clear();
// Iterate the indexes
for (var index = 0; index < batchSize; index++)
{
// MERGE T USING S
builder.Merge()
.TableNameFrom(tableName, DbSetting)
.HintsFrom(hints)
.As("T")
.Using()
.OpenParen()
.Select()
.ParametersAsFieldsFrom(fields, index, DbSetting)
.CloseParen()
.As("S")
// QUALIFIERS
.On()
.OpenParen()
.WriteText(qualifiers?
.Select(
field => field.AsJoinQualifier("S", "T", true, DbSetting))
.Join(" AND "))
.CloseParen()
// WHEN NOT MATCHED THEN INSERT VALUES
.When()
.Not()
.Matched()
.Then()
.Insert()
.OpenParen()
.FieldsFrom(insertableFields, DbSetting)
.CloseParen()
.Values()
.OpenParen()
.AsAliasFieldsFrom(insertableFields, "S", DbSetting)
.CloseParen()
// WHEN MATCHED THEN UPDATE SET
.When()
.Matched()
.Then()
.Update()
.Set()
.FieldsAndAliasFieldsFrom(updateableFields, "T", "S", DbSetting);
// Set the output
var outputField = identityField ?? primaryField;
if (outputField != null)
{
builder
.WriteText(string.Concat("OUTPUT INSERTED.", outputField.Name.AsField(DbSetting)))
.As("[Id],")
.WriteText($"{DbSetting.ParameterPrefix}__RepoDb_OrderColumn_{index}")
.As("[OrderColumn]");
}
// End the builder
builder.End();
}
// Return the query
return(builder.GetString());
}
protected DbField FindItemDbField(DbItem fakeItem, DbField templateField)
{
Assert.IsNotNull(fakeItem, "fakeItem");
Assert.IsNotNull(templateField, "templateField");
// The item has fields with the IDs matching the fields in the template it directly inherits from
if (fakeItem.Fields.ContainsKey(templateField.ID))
{
return fakeItem.Fields[templateField.ID];
}
return fakeItem.Fields.SingleOrDefault(f => string.Equals(f.Name, templateField.Name));
}
public void SetValueTwiceResetsExistingValue(bool shared, DbField sut, string oldValue, string newValue)
{
sut.Shared = shared;
sut.SetValue("en", oldValue);
sut.SetValue("en", newValue);
sut.Value.Should().Be(newValue);
}
public void ShouldGetItemFields([Greedy] FakeDataProvider sut, DbTemplate template, DbItem item, DbField field, Language language, Version version,
CallContext context)
{
template.Fields.Add(field);
item.Fields.Add(field); // ?
item.TemplateID = template.ID;
sut.DataStorage.GetFakeTemplate(template.ID).Returns(template);
sut.DataStorage.GetFakeItem(item.ID).Returns(item);
var def = new ItemDefinition(item.ID, item.Name, item.TemplateID, item.BranchId);
var versionUri = new VersionUri(language, version);
sut.GetItemFields(def, versionUri, context).Should().HaveCount(1);
}
private DbBaseFieldControl ItemRow(DbField fld, List <DbBaseFieldControl> subcontrols = null)
{
var fldRow = new TableRow();
if (fld.Hidden)
{
fldRow.Style.Add("display", "none");
}
var titleCell = new TableCell {
CssClass = "ms-formlabel",
VerticalAlign = VerticalAlign.Top,
Width = Unit.Pixel(113)
};
var displayName = fld.DisplayName;
var lookup = fld as DbFieldLookup;
if (lookup != null)
{
if (lookup.ListSource == (int)LookupSourceType.SpList)
{
var list = SPContext.Current.SPList(lookup.ListId.ToGuid());
if (list != null)
{
if (lookup.LookupFields.Count() > 1)
{
displayName = string.Format("{0} : {1}", fld.DisplayName,
list.FieldTitle(lookup.LookupFields[0].ToGuid()));
}
}
}
}
var fldLabel = new Label {
ID = fld.InternalName + "_label",
Text = displayName
};
titleCell.Controls.Add(fldLabel);
var bodyCell = new TableCell {
CssClass = "ms-formbody",
VerticalAlign = VerticalAlign.Top,
Width = Unit.Pixel(350)
};
bodyCell.Attributes.Add("fieldname", fld.InternalName);
var baseCtrl = fld.BaseControl;
baseCtrl.ID = fld.InternalNameOriginal.ToNormalize();
baseCtrl.ControlMode = ControlMode;
if (subcontrols != null)
{
baseCtrl.Subcontrols.AddRange(subcontrols);
}
bodyCell.Controls.Add(baseCtrl);
fldRow.Cells.Add(titleCell);
fldRow.Cells.Add(bodyCell);
FormTable.Rows.AddAt(0, fldRow);
FieldControls.Add(new Tuple <Label, DbBaseFieldControl, DbField>(fldLabel, baseCtrl, fld));
return(baseCtrl);
}
