public void CreateVersions()
{
var provider = TestObjects.GetScopeProvider(Logger);
using (var scope = provider.CreateScope())
{
var repository = CreateRepository((IScopeAccessor)provider, out var contentTypeRepository, out DataTypeRepository _);
var versions = new List <int>();
var hasPropertiesContentType = MockedContentTypes.CreateSimpleContentType("umbTextpage1", "Textpage");
ServiceContext.FileService.SaveTemplate(hasPropertiesContentType.DefaultTemplate); // else, FK violation on contentType!
contentTypeRepository.Save(hasPropertiesContentType);
IContent content1 = MockedContent.CreateSimpleContent(hasPropertiesContentType);
// save = create the initial version
repository.Save(content1);
versions.Add(content1.VersionId); // the first version
// publish = new edit version
content1.SetValue("title", "title");
content1.PublishCulture(CultureImpact.Invariant);
content1.PublishedState = PublishedState.Publishing;
repository.Save(content1);
versions.Add(content1.VersionId); // NEW VERSION
// new edit version has been created
Assert.AreNotEqual(versions[versions.Count - 2], versions[versions.Count - 1]);
Assert.IsTrue(content1.Published);
Assert.AreEqual(PublishedState.Published, ((Content)content1).PublishedState);
Assert.AreEqual(versions[versions.Count - 1], repository.Get(content1.Id).VersionId);
// misc checks
Assert.AreEqual(true, scope.Database.ExecuteScalar <bool>($"SELECT published FROM {Constants.DatabaseSchema.Tables.Document} WHERE nodeId=@id", new { id = content1.Id }));
// change something
// save = update the current (draft) version
content1.Name = "name-1";
content1.SetValue("title", "title-1");
repository.Save(content1);
versions.Add(content1.VersionId); // the same version
// no new version has been created
Assert.AreEqual(versions[versions.Count - 2], versions[versions.Count - 1]);
Assert.IsTrue(content1.Published);
Assert.AreEqual(versions[versions.Count - 1], repository.Get(content1.Id).VersionId);
// misc checks
Assert.AreEqual(true, scope.Database.ExecuteScalar <bool>($"SELECT published FROM {Constants.DatabaseSchema.Tables.Document} WHERE nodeId=@id", new { id = content1.Id }));
// unpublish = no impact on versions
((Content)content1).PublishedState = PublishedState.Unpublishing;
repository.Save(content1);
versions.Add(content1.VersionId); // the same version
// no new version has been created
Assert.AreEqual(versions[versions.Count - 2], versions[versions.Count - 1]);
Assert.IsFalse(content1.Published);
Assert.AreEqual(PublishedState.Unpublished, ((Content)content1).PublishedState);
Assert.AreEqual(versions[versions.Count - 1], repository.Get(content1.Id).VersionId);
// misc checks
Assert.AreEqual(false, scope.Database.ExecuteScalar <bool>($"SELECT published FROM {Constants.DatabaseSchema.Tables.Document} WHERE nodeId=@id", new { id = content1.Id }));
// change something
// save = update the current (draft) version
content1.Name = "name-2";
content1.SetValue("title", "title-2");
repository.Save(content1);
versions.Add(content1.VersionId); // the same version
// no new version has been created
Assert.AreEqual(versions[versions.Count - 2], versions[versions.Count - 1]);
Assert.AreEqual(versions[versions.Count - 1], repository.Get(content1.Id).VersionId);
// misc checks
Assert.AreEqual(false, scope.Database.ExecuteScalar <bool>($"SELECT published FROM {Constants.DatabaseSchema.Tables.Document} WHERE nodeId=@id", new { id = content1.Id }));
// publish = version
content1.PublishCulture(CultureImpact.Invariant);
content1.PublishedState = PublishedState.Publishing;
repository.Save(content1);
versions.Add(content1.VersionId); // NEW VERSION
// new version has been created
Assert.AreNotEqual(versions[versions.Count - 2], versions[versions.Count - 1]);
Assert.IsTrue(content1.Published);
Assert.AreEqual(PublishedState.Published, ((Content)content1).PublishedState);
Assert.AreEqual(versions[versions.Count - 1], repository.Get(content1.Id).VersionId);
// misc checks
Assert.AreEqual(true, scope.Database.ExecuteScalar <bool>($"SELECT published FROM {Constants.DatabaseSchema.Tables.Document} WHERE nodeId=@id", new { id = content1.Id }));
// change something
// save = update the current (draft) version
content1.Name = "name-3";
content1.SetValue("title", "title-3");
//Thread.Sleep(2000); // force date change
repository.Save(content1);
versions.Add(content1.VersionId); // the same version
// no new version has been created
Assert.AreEqual(versions[versions.Count - 2], versions[versions.Count - 1]);
Assert.AreEqual(versions[versions.Count - 1], repository.Get(content1.Id).VersionId);
// misc checks
Assert.AreEqual(true, scope.Database.ExecuteScalar <bool>($"SELECT published FROM {Constants.DatabaseSchema.Tables.Document} WHERE nodeId=@id", new { id = content1.Id }));
// publish = new version
content1.Name = "name-4";
content1.SetValue("title", "title-4");
content1.PublishCulture(CultureImpact.Invariant);
content1.PublishedState = PublishedState.Publishing;
repository.Save(content1);
versions.Add(content1.VersionId); // NEW VERSION
// a new version has been created
Assert.AreNotEqual(versions[versions.Count - 2], versions[versions.Count - 1]);
Assert.IsTrue(content1.Published);
Assert.AreEqual(PublishedState.Published, ((Content)content1).PublishedState);
Assert.AreEqual(versions[versions.Count - 1], repository.Get(content1.Id).VersionId);
// misc checks
Assert.AreEqual(true, scope.Database.ExecuteScalar <bool>($"SELECT published FROM {Constants.DatabaseSchema.Tables.Document} WHERE nodeId=@id", new { id = content1.Id }));
// all versions
var allVersions = repository.GetAllVersions(content1.Id).ToArray();
Console.WriteLine();
foreach (var v in versions)
{
Console.WriteLine(v);
}
Console.WriteLine();
foreach (var v in allVersions)
{
var c = (Content)v;
Console.WriteLine($"{c.Id} {c.VersionId} {(c.Published ? "+" : "-")}pub pk={c.VersionId} ppk={c.PublishedVersionId} name=\"{c.Name}\" pname=\"{c.PublishName}\"");
}
// get older version
var content = repository.GetVersion(versions[versions.Count - 4]);
Assert.AreNotEqual(0, content.VersionId);
Assert.AreEqual(versions[versions.Count - 4], content.VersionId);
Assert.AreEqual("name-4", content1.Name);
Assert.AreEqual("title-4", content1.GetValue("title"));
Assert.AreEqual("name-2", content.Name);
Assert.AreEqual("title-2", content.GetValue("title"));
// get all versions - most recent first
allVersions = repository.GetAllVersions(content1.Id).ToArray();
var expVersions = versions.Distinct().Reverse().ToArray();
Assert.AreEqual(expVersions.Length, allVersions.Length);
for (var i = 0; i < expVersions.Length; i++)
{
Assert.AreEqual(expVersions[i], allVersions[i].VersionId);
}
}
}
public void To_Display_Model_With_Non_Grouped_Properties()
{
var idSeed = 1;
var contentType = MockedContentTypes.CreateSimpleContentType();
//add non-grouped properties
contentType.AddPropertyType(new PropertyType(Constants.PropertyEditors.Aliases.TextBox, ValueStorageType.Ntext, "nonGrouped1")
{
Name = "Non Grouped 1", Description = "", Mandatory = false, SortOrder = 1, DataTypeId = -88
});
contentType.AddPropertyType(new PropertyType(Constants.PropertyEditors.Aliases.TextBox, ValueStorageType.Ntext, "nonGrouped2")
{
Name = "Non Grouped 2", Description = "", Mandatory = false, SortOrder = 1, DataTypeId = -88
});
//set ids or it wont work
contentType.Id = idSeed;
foreach (var p in contentType.PropertyTypes)
{
p.Id = idSeed;
idSeed++;
}
Mock.Get(_contentTypeService).As <IContentTypeBaseService>().Setup(x => x.Get(It.IsAny <int>())).Returns(contentType);
Mock.Get(_contentTypeService).Setup(x => x.Get(It.IsAny <int>())).Returns(contentType);
var content = MockedContent.CreateSimpleContent(contentType);
FixUsers(content);
foreach (var p in content.Properties)
{
p.Id = idSeed;
idSeed++;
}
//need ids for tabs
var id = 1;
foreach (var g in contentType.CompositionPropertyGroups)
{
g.Id = id;
id++;
}
//ensure that nothing is marked as dirty
contentType.ResetDirtyProperties(false);
//ensure that nothing is marked as dirty
content.ResetDirtyProperties(false);
var result = Mapper.Map <IContent, ContentItemDisplay>(content);
AssertBasics(result, content);
var invariantContent = result.Variants.First();
foreach (var p in content.Properties)
{
AssertBasicProperty(invariantContent, p);
AssertDisplayProperty(invariantContent, p);
}
Assert.AreEqual(contentType.CompositionPropertyGroups.Count(), invariantContent.Tabs.Count() - 1);
Assert.IsTrue(invariantContent.Tabs.Any(x => x.Label == Current.Services.TextService.Localize("general", "properties")));
Assert.AreEqual(2, invariantContent.Tabs.Where(x => x.Label == Current.Services.TextService.Localize("general", "properties")).SelectMany(x => x.Properties.Where(p => p.Alias.StartsWith("_umb_") == false)).Count());
}
public void Get_All_User_Permissions_For_All_Nodes_With_Explicit_Permission()
{
// Arrange
var userService = ServiceContext.UserService;
var userGroup1 = CreateTestUserGroup();
var userGroup2 = CreateTestUserGroup("test2", "Test 2");
var userGroup3 = CreateTestUserGroup("test3", "Test 3");
var user = userService.CreateUserWithIdentity("John Doe", "*****@*****.**");
var defaultPermissionCount = userGroup3.Permissions.Count();
user.AddGroup(userGroup1);
user.AddGroup(userGroup2);
user.AddGroup(userGroup3);
userService.Save(user);
var contentType = MockedContentTypes.CreateSimpleContentType();
ServiceContext.ContentTypeService.Save(contentType);
var content = new[]
{
MockedContent.CreateSimpleContent(contentType),
MockedContent.CreateSimpleContent(contentType),
MockedContent.CreateSimpleContent(contentType)
};
ServiceContext.ContentService.Save(content);
//assign permissions - we aren't assigning anything explicit for group3 and nothing explicit for content[2] /w group2
ServiceContext.ContentService.SetPermission(content[0], ActionBrowse.ActionLetter, new int[] { userGroup1.Id });
ServiceContext.ContentService.SetPermission(content[0], ActionDelete.ActionLetter, new int[] { userGroup1.Id });
ServiceContext.ContentService.SetPermission(content[0], ActionMove.ActionLetter, new int[] { userGroup2.Id });
ServiceContext.ContentService.SetPermission(content[1], ActionBrowse.ActionLetter, new int[] { userGroup1.Id });
ServiceContext.ContentService.SetPermission(content[1], ActionDelete.ActionLetter, new int[] { userGroup2.Id });
ServiceContext.ContentService.SetPermission(content[2], ActionDelete.ActionLetter, new int[] { userGroup1.Id });
// Act
//we don't pass in any nodes so it will return all of them
var result = userService.GetPermissions(user).ToArray();
var permissions = result
.GroupBy(x => x.EntityId)
.ToDictionary(x => x.Key, x => x.GroupBy(a => a.UserGroupId).ToDictionary(a => a.Key, a => a.ToArray()));
//assert
//there will be 3 since that is how many content items there are
Assert.AreEqual(3, permissions.Count);
//test permissions contains content[0]
Assert.IsTrue(permissions.ContainsKey(content[0].Id));
//test that this permissions set contains permissions for all groups
Assert.IsTrue(permissions[content[0].Id].ContainsKey(userGroup1.Id));
Assert.IsTrue(permissions[content[0].Id].ContainsKey(userGroup2.Id));
Assert.IsTrue(permissions[content[0].Id].ContainsKey(userGroup3.Id));
//test that the correct number of permissions are returned for each group
Assert.AreEqual(2, permissions[content[0].Id][userGroup1.Id].SelectMany(x => x.AssignedPermissions).Count());
Assert.AreEqual(1, permissions[content[0].Id][userGroup2.Id].SelectMany(x => x.AssignedPermissions).Count());
Assert.AreEqual(defaultPermissionCount, permissions[content[0].Id][userGroup3.Id].SelectMany(x => x.AssignedPermissions).Count());
//test permissions contains content[1]
Assert.IsTrue(permissions.ContainsKey(content[1].Id));
//test that this permissions set contains permissions for all groups
Assert.IsTrue(permissions[content[1].Id].ContainsKey(userGroup1.Id));
Assert.IsTrue(permissions[content[1].Id].ContainsKey(userGroup2.Id));
Assert.IsTrue(permissions[content[1].Id].ContainsKey(userGroup3.Id));
//test that the correct number of permissions are returned for each group
Assert.AreEqual(1, permissions[content[1].Id][userGroup1.Id].SelectMany(x => x.AssignedPermissions).Count());
Assert.AreEqual(1, permissions[content[1].Id][userGroup2.Id].SelectMany(x => x.AssignedPermissions).Count());
Assert.AreEqual(defaultPermissionCount, permissions[content[1].Id][userGroup3.Id].SelectMany(x => x.AssignedPermissions).Count());
//test permissions contains content[2]
Assert.IsTrue(permissions.ContainsKey(content[2].Id));
//test that this permissions set contains permissions for all groups
Assert.IsTrue(permissions[content[2].Id].ContainsKey(userGroup1.Id));
Assert.IsTrue(permissions[content[2].Id].ContainsKey(userGroup2.Id));
Assert.IsTrue(permissions[content[2].Id].ContainsKey(userGroup3.Id));
//test that the correct number of permissions are returned for each group
Assert.AreEqual(1, permissions[content[2].Id][userGroup1.Id].SelectMany(x => x.AssignedPermissions).Count());
Assert.AreEqual(defaultPermissionCount, permissions[content[2].Id][userGroup2.Id].SelectMany(x => x.AssignedPermissions).Count());
Assert.AreEqual(defaultPermissionCount, permissions[content[2].Id][userGroup3.Id].SelectMany(x => x.AssignedPermissions).Count());
}
public void Can_Get_Tags_For_Entity_Type_For_Group()
{
var provider = TestObjects.GetScopeProvider(Logger);
using (ScopeProvider.CreateScope())
{
var contentRepository = CreateDocumentRepository(provider, out var contentTypeRepository);
var mediaRepository = CreateMediaRepository(provider, out var mediaTypeRepository);
//create data to relate to
var contentType = MockedContentTypes.CreateSimpleContentType("test", "Test");
ServiceContext.FileService.SaveTemplate(contentType.DefaultTemplate); // else, FK violation on contentType!
contentTypeRepository.Save(contentType);
var content1 = MockedContent.CreateSimpleContent(contentType);
contentRepository.Save(content1);
var mediaType = MockedContentTypes.CreateImageMediaType("image2");
mediaTypeRepository.Save(mediaType);
var media1 = MockedMedia.CreateMediaImage(mediaType, -1);
mediaRepository.Save(media1);
var repository = CreateRepository(provider);
repository.Assign(
content1.Id,
contentType.PropertyTypes.First().Id,
new[]
{
new Tag {
Text = "tag1", Group = "test"
},
new Tag {
Text = "tag2", Group = "test1"
},
new Tag {
Text = "tag3", Group = "test"
},
new Tag {
Text = "tag4", Group = "test1"
}
}, false);
repository.Assign(
media1.Id,
mediaType.PropertyTypes.Last().Id,
new[]
{
new Tag {
Text = "tag1", Group = "test"
},
new Tag {
Text = "tag2", Group = "test1"
}
}, false);
var result1 = repository.GetTagsForEntityType(TaggableObjectTypes.Content, "test1").ToArray();
var result2 = repository.GetTagsForEntityType(TaggableObjectTypes.Media, "test1").ToArray();
Assert.AreEqual(2, result1.Length);
Assert.AreEqual(1, result2.Length);
}
}
public void Can_Get_Tagged_Entities_For_Tag_Group()
{
var provider = TestObjects.GetScopeProvider(Logger);
using (ScopeProvider.CreateScope())
{
var contentRepository = CreateDocumentRepository(provider, out var contentTypeRepository);
var mediaRepository = CreateMediaRepository(provider, out var mediaTypeRepository);
//create data to relate to
var contentType = MockedContentTypes.CreateSimpleContentType("test", "Test");
ServiceContext.FileService.SaveTemplate(contentType.DefaultTemplate); // else, FK violation on contentType!
contentTypeRepository.Save(contentType);
var content1 = MockedContent.CreateSimpleContent(contentType);
contentRepository.Save(content1);
var content2 = MockedContent.CreateSimpleContent(contentType);
contentRepository.Save(content2);
var mediaType = MockedContentTypes.CreateImageMediaType("image2");
mediaTypeRepository.Save(mediaType);
var media1 = MockedMedia.CreateMediaImage(mediaType, -1);
mediaRepository.Save(media1);
var repository = CreateRepository(provider);
repository.Assign(
content1.Id,
contentType.PropertyTypes.First().Id,
new[]
{
new Tag {
Text = "tag1", Group = "test"
},
new Tag {
Text = "tag2", Group = "test1"
},
new Tag {
Text = "tag3", Group = "test"
}
}, false);
repository.Assign(
content2.Id,
contentType.PropertyTypes.Last().Id,
new[]
{
new Tag {
Text = "tag1", Group = "test"
},
new Tag {
Text = "tag2", Group = "test1"
},
new Tag {
Text = "tag3", Group = "test"
}
}, false);
repository.Assign(
media1.Id,
mediaType.PropertyTypes.Last().Id,
new[]
{
new Tag {
Text = "tag1", Group = "test"
},
new Tag {
Text = "tag2", Group = "test1"
}
}, false);
var contentTestIds = repository.GetTaggedEntitiesByTagGroup(TaggableObjectTypes.Content, "test").ToArray();
//there are two content items tagged against the 'test' group
Assert.AreEqual(2, contentTestIds.Length);
//there are a total of two property types tagged against the 'test' group
Assert.AreEqual(2, contentTestIds.SelectMany(x => x.TaggedProperties).Count());
//there are a total of 2 tags tagged against the 'test' group
Assert.AreEqual(2, contentTestIds.SelectMany(x => x.TaggedProperties).SelectMany(x => x.Tags).Select(x => x.Id).Distinct().Count());
var contentTest1Ids = repository.GetTaggedEntitiesByTagGroup(TaggableObjectTypes.Content, "test1").ToArray();
//there are two content items tagged against the 'test1' group
Assert.AreEqual(2, contentTest1Ids.Length);
//there are a total of two property types tagged against the 'test1' group
Assert.AreEqual(2, contentTest1Ids.SelectMany(x => x.TaggedProperties).Count());
//there are a total of 1 tags tagged against the 'test1' group
Assert.AreEqual(1, contentTest1Ids.SelectMany(x => x.TaggedProperties).SelectMany(x => x.Tags).Select(x => x.Id).Distinct().Count());
var mediaTestIds = repository.GetTaggedEntitiesByTagGroup(TaggableObjectTypes.Media, "test");
Assert.AreEqual(1, mediaTestIds.Count());
var mediaTest1Ids = repository.GetTaggedEntitiesByTagGroup(TaggableObjectTypes.Media, "test1");
Assert.AreEqual(1, mediaTest1Ids.Count());
}
}
public void TagsCanBeVariant()
{
var languageService = ServiceContext.LocalizationService;
languageService.Save(new Language("fr-FR")); // en-US is already there
var contentService = ServiceContext.ContentService;
var contentTypeService = ServiceContext.ContentTypeService;
var tagService = ServiceContext.TagService;
var contentType = MockedContentTypes.CreateSimpleContentType("umbMandatory", "Mandatory Doc Type", true);
contentType.PropertyGroups.First().PropertyTypes.Add(
new PropertyType("test", ValueStorageType.Ntext, "tags")
{
DataTypeId = 1041,
Variations = ContentVariation.Culture
});
contentType.Variations = ContentVariation.Culture;
contentTypeService.Save(contentType);
IContent content1 = MockedContent.CreateSimpleContent(contentType, "Tagged content 1", -1);
content1.SetCultureName("name-fr", "fr-FR");
content1.SetCultureName("name-en", "en-US");
content1.AssignTags("tags", new[] { "hello", "world", "some", "tags", "plus" }, culture: "fr-FR");
content1.AssignTags("tags", new[] { "hello", "world", "another", "one" }, culture: "en-US");
contentService.SaveAndPublish(content1);
content1 = contentService.GetById(content1.Id);
var frTags = content1.Properties["tags"].GetTagsValue("fr-FR").ToArray();
Assert.AreEqual(5, frTags.Length);
Assert.Contains("plus", frTags);
Assert.AreEqual(-1, frTags.IndexOf("one"));
var enTags = content1.Properties["tags"].GetTagsValue("en-US").ToArray();
Assert.AreEqual(4, enTags.Length);
Assert.Contains("one", enTags);
Assert.AreEqual(-1, enTags.IndexOf("plus"));
var tagGroups = tagService.GetAllTags(culture: "*").GroupBy(x => x.LanguageId);
foreach (var tag in tagService.GetAllTags())
{
Console.WriteLine($"{tag.Group}:{tag.Text} {tag.LanguageId}");
}
Assert.AreEqual(2, tagGroups.Count());
var frTagGroup = tagGroups.FirstOrDefault(x => x.Key == 2);
Assert.IsNotNull(frTagGroup);
Assert.AreEqual(5, frTagGroup.Count());
Assert.IsTrue(frTagGroup.Any(x => x.Text == "plus"));
Assert.IsFalse(frTagGroup.Any(x => x.Text == "one"));
var enTagGroup = tagGroups.FirstOrDefault(x => x.Key == 1);
Assert.IsNotNull(enTagGroup);
Assert.AreEqual(4, enTagGroup.Count());
Assert.IsTrue(enTagGroup.Any(x => x.Text == "one"));
Assert.IsFalse(enTagGroup.Any(x => x.Text == "plus"));
}
public void GetPagedResultsByQuery_With_Variant_Names()
{
// one invariant content type named "umbInvariantTextPage"
//
var invariantCt = MockedContentTypes.CreateSimpleContentType("umbInvariantTextpage", "Invariant Textpage");
invariantCt.Variations = ContentVariation.Nothing;
foreach (var p in invariantCt.PropertyTypes)
{
p.Variations = ContentVariation.Nothing;
}
ServiceContext.FileService.SaveTemplate(invariantCt.DefaultTemplate); // else, FK violation on contentType!
ServiceContext.ContentTypeService.Save(invariantCt);
// one variant (by culture) content type named "umbVariantTextPage"
// with properties, every 2nd one being variant (by culture), the other being invariant
//
var variantCt = MockedContentTypes.CreateSimpleContentType("umbVariantTextpage", "Variant Textpage");
variantCt.Variations = ContentVariation.Culture;
var propTypes = variantCt.PropertyTypes.ToList();
for (var i = 0; i < propTypes.Count; i++)
{
var p = propTypes[i];
p.Variations = i % 2 == 0 ? ContentVariation.Culture : ContentVariation.Nothing;
}
ServiceContext.FileService.SaveTemplate(variantCt.DefaultTemplate); // else, FK violation on contentType!
ServiceContext.ContentTypeService.Save(variantCt);
invariantCt.AllowedContentTypes = new[] { new ContentTypeSort(invariantCt.Id, 0), new ContentTypeSort(variantCt.Id, 1) };
ServiceContext.ContentTypeService.Save(invariantCt);
//create content
var root = MockedContent.CreateSimpleContent(invariantCt);
ServiceContext.ContentService.Save(root);
var children = new List <IContent>();
for (var i = 0; i < 25; i++)
{
var isInvariant = i % 2 == 0;
var name = (isInvariant ? "INV" : "VAR") + "_" + Guid.NewGuid();
var culture = isInvariant ? null : "en-US";
var child = MockedContent.CreateSimpleContent(
isInvariant ? invariantCt : variantCt,
name, root,
culture,
setPropertyValues: isInvariant);
if (!isInvariant)
{
//manually set the property values since we have mixed variant/invariant property types
child.SetValue("title", name + " Subpage", culture: culture);
child.SetValue("bodyText", "This is a subpage", culture: null); //this one is invariant
child.SetValue("author", "John Doe", culture: culture);
}
ServiceContext.ContentService.Save(child);
children.Add(child);
}
var child1 = children[1];
Assert.IsTrue(child1.ContentType.VariesByCulture());
Assert.IsTrue(child1.Name.StartsWith("VAR"));
Assert.IsTrue(child1.GetCultureName("en-US").StartsWith("VAR"));
var provider = TestObjects.GetScopeProvider(Logger);
using (var scope = provider.CreateScope())
{
var repository = CreateRepository((IScopeAccessor)provider, out _);
var child = repository.Get(children[1].Id); // 1 is variant
Assert.IsTrue(child.ContentType.VariesByCulture());
Assert.IsTrue(child.Name.StartsWith("VAR"));
Assert.IsTrue(child.GetCultureName("en-US").StartsWith("VAR"));
try
{
scope.Database.AsUmbracoDatabase().EnableSqlTrace = true;
scope.Database.AsUmbracoDatabase().EnableSqlCount = true;
var query = scope.SqlContext.Query <IContent>().Where(x => x.ParentId == root.Id);
var result = repository.GetPage(query, 0, 20, out var totalRecords, null, Ordering.By("UpdateDate"));
Assert.AreEqual(25, totalRecords);
foreach (var r in result)
{
var isInvariant = r.ContentType.Alias == "umbInvariantTextpage";
var name = isInvariant ? r.Name : r.CultureInfos["en-US"].Name;
var namePrefix = isInvariant ? "INV" : "VAR";
//ensure the correct name (invariant vs variant) is in the result
Assert.IsTrue(name.StartsWith(namePrefix));
foreach (var p in r.Properties)
{
//ensure there is a value for the correct variant/invariant property
var value = p.GetValue(p.PropertyType.Variations.VariesByNothing() ? null : "en-US");
Assert.IsNotNull(value);
}
}
}
finally
{
scope.Database.AsUmbracoDatabase().EnableSqlTrace = false;
scope.Database.AsUmbracoDatabase().EnableSqlCount = false;
}
}
}
public void Create_Tag_Data_Bulk_Publish_Operation()
{
//Arrange
var contentService = ServiceContext.ContentService;
var contentTypeService = ServiceContext.ContentTypeService;
var dataTypeService = ServiceContext.DataTypeService;
//set configuration
var dataType = dataTypeService.GetDataType(1041);
dataType.Configuration = new TagConfiguration
{
Group = "test",
StorageType = TagsStorageType.Csv
};
var contentType = MockedContentTypes.CreateSimpleContentType("umbMandatory", "Mandatory Doc Type", true);
contentType.PropertyGroups.First().PropertyTypes.Add(
new PropertyType("test", ValueStorageType.Ntext, "tags")
{
DataTypeId = 1041
});
contentTypeService.Save(contentType);
contentType.AllowedContentTypes = new[] { new ContentTypeSort(new Lazy <int>(() => contentType.Id), 0, contentType.Alias) };
var content = MockedContent.CreateSimpleContent(contentType, "Tagged content", -1);
content.AssignTags("tags", new[] { "hello", "world", "some", "tags" });
contentService.Save(content);
var child1 = MockedContent.CreateSimpleContent(contentType, "child 1 content", content.Id);
child1.AssignTags("tags", new[] { "hello1", "world1", "some1" });
contentService.Save(child1);
var child2 = MockedContent.CreateSimpleContent(contentType, "child 2 content", content.Id);
child2.AssignTags("tags", new[] { "hello2", "world2" });
contentService.Save(child2);
// Act
contentService.SaveAndPublishBranch(content, true);
// Assert
var propertyTypeId = contentType.PropertyTypes.Single(x => x.Alias == "tags").Id;
using (var scope = ScopeProvider.CreateScope())
{
Assert.AreEqual(4, scope.Database.ExecuteScalar <int>(
"SELECT COUNT(*) FROM cmsTagRelationship WHERE nodeId=@nodeId AND propertyTypeId=@propTypeId",
new { nodeId = content.Id, propTypeId = propertyTypeId }));
Assert.AreEqual(3, scope.Database.ExecuteScalar <int>(
"SELECT COUNT(*) FROM cmsTagRelationship WHERE nodeId=@nodeId AND propertyTypeId=@propTypeId",
new { nodeId = child1.Id, propTypeId = propertyTypeId }));
Assert.AreEqual(2, scope.Database.ExecuteScalar <int>(
"SELECT COUNT(*) FROM cmsTagRelationship WHERE nodeId=@nodeId AND propertyTypeId=@propTypeId",
new { nodeId = child2.Id, propTypeId = propertyTypeId }));
scope.Complete();
}
}
public void TagsAreUpdatedWhenContentIsTrashedAndUnTrashed_Tree()
{
var contentService = ServiceContext.ContentService;
var contentTypeService = ServiceContext.ContentTypeService;
var tagService = ServiceContext.TagService;
var contentType = MockedContentTypes.CreateSimpleContentType("umbMandatory", "Mandatory Doc Type", true);
contentType.PropertyGroups.First().PropertyTypes.Add(
new PropertyType("test", ValueStorageType.Ntext, "tags")
{
DataTypeId = 1041
});
contentTypeService.Save(contentType);
var content1 = MockedContent.CreateSimpleContent(contentType, "Tagged content 1", -1);
content1.AssignTags("tags", new[] { "hello", "world", "some", "tags", "plus" });
contentService.SaveAndPublish(content1);
var content2 = MockedContent.CreateSimpleContent(contentType, "Tagged content 2", content1.Id);
content2.AssignTags("tags", new[] { "hello", "world", "some", "tags" });
contentService.SaveAndPublish(content2);
// verify
var tags = tagService.GetTagsForEntity(content1.Id);
Assert.AreEqual(5, tags.Count());
var allTags = tagService.GetAllContentTags();
Assert.AreEqual(5, allTags.Count());
contentService.MoveToRecycleBin(content1);
// no more tags
tags = tagService.GetTagsForEntity(content1.Id);
Assert.AreEqual(0, tags.Count());
tags = tagService.GetTagsForEntity(content2.Id);
Assert.AreEqual(0, tags.Count());
// no more tags
allTags = tagService.GetAllContentTags();
Assert.AreEqual(0, allTags.Count());
contentService.Move(content1, -1);
Assert.IsFalse(content1.Published);
// no more tags
tags = tagService.GetTagsForEntity(content1.Id);
Assert.AreEqual(0, tags.Count());
tags = tagService.GetTagsForEntity(content2.Id);
Assert.AreEqual(0, tags.Count());
// no more tags
allTags = tagService.GetAllContentTags();
Assert.AreEqual(0, allTags.Count());
content1.PublishCulture();
contentService.SaveAndPublish(content1);
Assert.IsTrue(content1.Published);
// tags are back
tags = tagService.GetTagsForEntity(content1.Id);
Assert.AreEqual(5, tags.Count());
// fixme tag & tree issue
// when we publish, we 'just' publish the top one and not the ones below = fails
// what we should do is... NOT clear tags when unpublishing or trashing or...
// and just update the tag service to NOT return anything related to trashed or
// unpublished entities (since trashed is set on ALL entities in the trashed branch)
tags = tagService.GetTagsForEntity(content2.Id); // including that one!
Assert.AreEqual(4, tags.Count());
// tags are back
allTags = tagService.GetAllContentTags();
Assert.AreEqual(5, allTags.Count());
}
public void TagsCanBecomeVariant()
{
var enId = ServiceContext.LocalizationService.GetLanguageIdByIsoCode("en-US").Value;
var contentService = ServiceContext.ContentService;
var contentTypeService = ServiceContext.ContentTypeService;
var tagService = ServiceContext.TagService;
var contentType = MockedContentTypes.CreateSimpleContentType("umbMandatory", "Mandatory Doc Type", true);
PropertyType propertyType;
contentType.PropertyGroups.First().PropertyTypes.Add(
propertyType = new PropertyType("test", ValueStorageType.Ntext, "tags")
{
DataTypeId = 1041
});
contentTypeService.Save(contentType);
IContent content1 = MockedContent.CreateSimpleContent(contentType, "Tagged content 1", -1);
content1.AssignTags("tags", new[] { "hello", "world", "another", "one" });
contentService.SaveAndPublish(content1);
contentType.Variations = ContentVariation.Culture;
contentTypeService.Save(contentType);
// no changes
content1 = contentService.GetById(content1.Id);
var tags = content1.Properties["tags"].GetTagsValue().ToArray();
Assert.AreEqual(4, tags.Length);
Assert.Contains("one", tags);
Assert.AreEqual(-1, tags.IndexOf("plus"));
var tagGroups = tagService.GetAllTags().GroupBy(x => x.LanguageId);
foreach (var tag in tagService.GetAllTags())
{
Console.WriteLine($"{tag.Group}:{tag.Text} {tag.LanguageId}");
}
Assert.AreEqual(1, tagGroups.Count());
var enTagGroup = tagGroups.FirstOrDefault(x => x.Key == null);
Assert.IsNotNull(enTagGroup);
Assert.AreEqual(4, enTagGroup.Count());
Assert.IsTrue(enTagGroup.Any(x => x.Text == "one"));
Assert.IsFalse(enTagGroup.Any(x => x.Text == "plus"));
propertyType.Variations = ContentVariation.Culture;
contentTypeService.Save(contentType);
// changes
content1 = contentService.GetById(content1.Id);
// property value has been moved from invariant to en-US
tags = content1.Properties["tags"].GetTagsValue().ToArray();
Assert.IsEmpty(tags);
tags = content1.Properties["tags"].GetTagsValue("en-US").ToArray();
Assert.AreEqual(4, tags.Length);
Assert.Contains("one", tags);
Assert.AreEqual(-1, tags.IndexOf("plus"));
// tags have been copied from invariant to en-US
tagGroups = tagService.GetAllTags(culture: "*").GroupBy(x => x.LanguageId);
foreach (var tag in tagService.GetAllTags("*"))
{
Console.WriteLine($"{tag.Group}:{tag.Text} {tag.LanguageId}");
}
Assert.AreEqual(1, tagGroups.Count());
enTagGroup = tagGroups.FirstOrDefault(x => x.Key == enId);
Assert.IsNotNull(enTagGroup);
Assert.AreEqual(4, enTagGroup.Count());
Assert.IsTrue(enTagGroup.Any(x => x.Text == "one"));
Assert.IsFalse(enTagGroup.Any(x => x.Text == "plus"));
}
public void Deal_With_Corrupt_Duplicate_Newest_Published_Flags_Full_Model()
{
// Arrange
var provider = new PetaPocoUnitOfWorkProvider(Logger);
var unitOfWork = provider.GetUnitOfWork();
ContentTypeRepository contentTypeRepository;
IContent content1;
using (var repository = CreateContentRepository(unitOfWork, out contentTypeRepository))
{
var hasPropertiesContentType = MockedContentTypes.CreateSimpleContentType("umbTextpage1", "Textpage");
content1 = MockedContent.CreateSimpleContent(hasPropertiesContentType);
contentTypeRepository.AddOrUpdate(hasPropertiesContentType);
repository.AddOrUpdate(content1);
unitOfWork.Commit();
}
var versionDtos = new List <ContentVersionDto>();
//Now manually corrupt the data
var versions = new[] { Guid.NewGuid(), Guid.NewGuid() };
for (var index = 0; index < versions.Length; index++)
{
var version = versions[index];
var versionDate = DateTime.Now.AddMinutes(index);
var versionDto = new ContentVersionDto
{
NodeId = content1.Id,
VersionDate = versionDate,
VersionId = version
};
this.DatabaseContext.Database.Insert(versionDto);
versionDtos.Add(versionDto);
this.DatabaseContext.Database.Insert(new DocumentDto
{
Newest = true,
NodeId = content1.Id,
Published = true,
Text = content1.Name,
VersionId = version,
WriterUserId = 0,
UpdateDate = versionDate,
TemplateId = content1.Template == null || content1.Template.Id <= 0 ? null : (int?)content1.Template.Id
});
}
// Assert
using (var repository = new EntityRepository(unitOfWork))
{
var content = repository.GetByQuery(new Query <IUmbracoEntity>().Where(c => c.Id == content1.Id), Constants.ObjectTypes.DocumentGuid).ToArray();
Assert.AreEqual(1, content.Length);
Assert.AreEqual(versionDtos.Max(x => x.Id), content[0].AdditionalData["VersionId"]);
content = repository.GetAll(Constants.ObjectTypes.DocumentGuid, content[0].Key).ToArray();
Assert.AreEqual(1, content.Length);
Assert.AreEqual(versionDtos.Max(x => x.Id), content[0].AdditionalData["VersionId"]);
content = repository.GetAll(Constants.ObjectTypes.DocumentGuid, content[0].Id).ToArray();
Assert.AreEqual(1, content.Length);
Assert.AreEqual(versionDtos.Max(x => x.Id), content[0].AdditionalData["VersionId"]);
var contentItem = repository.Get(content[0].Id, Constants.ObjectTypes.DocumentGuid);
Assert.AreEqual(versionDtos.Max(x => x.Id), contentItem.AdditionalData["VersionId"]);
contentItem = repository.GetByKey(content[0].Key, Constants.ObjectTypes.DocumentGuid);
Assert.AreEqual(versionDtos.Max(x => x.Id), contentItem.AdditionalData["VersionId"]);
}
}
public void Rebuild_All_Xml_Structures_For_Content_Type()
{
var provider = new PetaPocoUnitOfWorkProvider(Logger);
var unitOfWork = provider.GetUnitOfWork();
ContentTypeRepository contentTypeRepository;
using (var repository = CreateRepository(unitOfWork, out contentTypeRepository))
{
var contentType1 = MockedContentTypes.CreateSimpleContentType("Textpage1", "Textpage1");
var contentType2 = MockedContentTypes.CreateSimpleContentType("Textpage2", "Textpage2");
var contentType3 = MockedContentTypes.CreateSimpleContentType("Textpage3", "Textpage3");
contentTypeRepository.AddOrUpdate(contentType1);
contentTypeRepository.AddOrUpdate(contentType2);
contentTypeRepository.AddOrUpdate(contentType3);
var allCreated = new List <IContent>();
for (var i = 0; i < 30; i++)
{
//These will be non-published so shouldn't show up
var c1 = MockedContent.CreateSimpleContent(contentType1);
repository.AddOrUpdate(c1);
allCreated.Add(c1);
}
for (var i = 0; i < 30; i++)
{
var c1 = MockedContent.CreateSimpleContent(contentType1);
c1.ChangePublishedState(PublishedState.Published);
repository.AddOrUpdate(c1);
allCreated.Add(c1);
}
for (var i = 0; i < 30; i++)
{
var c1 = MockedContent.CreateSimpleContent(contentType2);
c1.ChangePublishedState(PublishedState.Published);
repository.AddOrUpdate(c1);
allCreated.Add(c1);
}
for (var i = 0; i < 30; i++)
{
var c1 = MockedContent.CreateSimpleContent(contentType3);
c1.ChangePublishedState(PublishedState.Published);
repository.AddOrUpdate(c1);
allCreated.Add(c1);
}
unitOfWork.Commit();
//now create some versions of this content - this shouldn't affect the xml structures saved
for (int i = 0; i < allCreated.Count; i++)
{
allCreated[i].Name = "blah" + i;
repository.AddOrUpdate(allCreated[i]);
}
unitOfWork.Commit();
//delete all xml
unitOfWork.Database.Execute("DELETE FROM cmsContentXml");
Assert.AreEqual(0, unitOfWork.Database.ExecuteScalar <int>("SELECT COUNT(*) FROM cmsContentXml"));
repository.RebuildXmlStructures(media => new XElement("test"), 10, contentTypeIds: new[] { contentType1.Id, contentType2.Id });
Assert.AreEqual(60, unitOfWork.Database.ExecuteScalar <int>("SELECT COUNT(*) FROM cmsContentXml"));
}
}
