public async Task Content_Not_Published()
{
var contentType = ContentTypeBuilder.CreateBasicContentType();
var content = ContentBuilder.CreateBasicContent(contentType);
content.Id = 1046; // FIXME: we are using this ID only because it's built into the test XML published cache
content.Path = "-1,1046";
var umbracoContextAccessor = GetUmbracoContextAccessor("http://localhost:8000");
var publishedRouter = CreatePublishedRouter(
umbracoContextAccessor,
new[] { new ContentFinderByUrl(Mock.Of <ILogger <ContentFinderByUrl> >(), umbracoContextAccessor) });
var umbracoContext = umbracoContextAccessor.GetRequiredUmbracoContext();
var urlProvider = GetUrlProvider(umbracoContextAccessor, _requestHandlerSettings, _webRoutingSettings, out var uriUtility);
var urls = (await content.GetContentUrlsAsync(
publishedRouter,
umbracoContext,
GetLangService("en-US", "fr-FR"),
GetTextService(),
Mock.Of <IContentService>(),
VariationContextAccessor,
Mock.Of <ILogger <IContent> >(),
uriUtility,
urlProvider)).ToList();
Assert.AreEqual(1, urls.Count);
Assert.AreEqual("content/itemNotPublished", urls[0].Text);
Assert.IsFalse(urls[0].IsUrl);
}
public void GivenIndexingDocument_WhenRichTextPropertyData_CanStoreImmenseFields()
{
using (GetSynchronousContentIndex(false, out UmbracoContentIndex index, out _, out ContentValueSetBuilder contentValueSetBuilder, null))
{
index.CreateIndex();
ContentType contentType = ContentTypeBuilder.CreateBasicContentType();
contentType.AddPropertyType(new PropertyType(TestHelper.ShortStringHelper, "test", ValueStorageType.Ntext)
{
Alias = "rte",
Name = "RichText",
PropertyEditorAlias = Cms.Core.Constants.PropertyEditors.Aliases.TinyMce
});
Content content = ContentBuilder.CreateBasicContent(contentType);
content.Id = 555;
content.Path = "-1,555";
var luceneStringFieldMaxLength = ByteBlockPool.BYTE_BLOCK_SIZE - 2;
var faker = new Faker();
var immenseText = faker.Random.String(length: luceneStringFieldMaxLength + 10);
content.Properties["rte"].SetValue(immenseText);
IEnumerable <ValueSet> valueSet = contentValueSetBuilder.GetValueSets(content);
index.IndexItems(valueSet);
ISearchResults results = index.Searcher.CreateQuery().Id(555).Execute();
ISearchResult result = results.First();
var key = $"{UmbracoExamineFieldNames.RawFieldPrefix}rte";
Assert.IsTrue(result.Values.ContainsKey(key));
Assert.Greater(result.Values[key].Length, luceneStringFieldMaxLength);
}
}
public void LastIn()
{
DoSaveForContent += OnDoThingFail;
var now = DateTime.Now;
var contentType = ContentTypeBuilder.CreateBasicContentType();
var content1 = ContentBuilder.CreateBasicContent(contentType);
content1.Id = 123;
content1.UpdateDate = now.AddMinutes(1);
var content2 = ContentBuilder.CreateBasicContent(contentType);
content2.Id = 123;
content2.UpdateDate = now.AddMinutes(2);
var content3 = ContentBuilder.CreateBasicContent(contentType);
content3.Id = 123;
content3.UpdateDate = now.AddMinutes(3);
var scopeProvider = GetScopeProvider(NullLoggerFactory.Instance);
using (var scope = scopeProvider.CreateScope(eventDispatcher: new PassiveEventDispatcher()))
{
scope.Events.Dispatch(DoSaveForContent, this, new SaveEventArgs <IContent>(content1));
scope.Events.Dispatch(DoSaveForContent, this, new SaveEventArgs <IContent>(content2));
scope.Events.Dispatch(DoSaveForContent, this, new SaveEventArgs <IContent>(content3));
// events have been queued
var events = scope.Events.GetEvents(EventDefinitionFilter.LastIn).ToArray();
Assert.AreEqual(1, events.Length);
Assert.AreEqual(content3, ((SaveEventArgs <IContent>)events[0].Args).SavedEntities.First());
Assert.IsTrue(object.ReferenceEquals(content3, ((SaveEventArgs <IContent>)events[0].Args).SavedEntities.First()));
Assert.AreEqual(content3.UpdateDate, ((SaveEventArgs <IContent>)events[0].Args).SavedEntities.First().UpdateDate);
}
}
public void GetAvailableCompositeContentTypes_Include_Indirect_Composed_Types()
{
ContentType ct1 = ContentTypeBuilder.CreateBasicContentType("ct1", "CT1");
ContentType ct2 = ContentTypeBuilder.CreateBasicContentType("ct2", "CT2");
ContentType ct3 = ContentTypeBuilder.CreateBasicContentType("ct3", "CT3");
ContentType ct4 = ContentTypeBuilder.CreateBasicContentType("ct4", "CT4");
ct1.Id = 1;
ct2.Id = 2;
ct3.Id = 3;
ct4.Id = 4;
ct1.AddContentType(ct3); // ct3 is direct to ct1
ct3.AddContentType(ct4); // ct4 is indirect to ct1
var service = new Mock <IContentTypeService>();
IContentTypeComposition[] availableTypes = service.Object.GetAvailableCompositeContentTypes(
ct1,
new[] { ct1, ct2, ct3 })
.Results.Where(x => x.Allowed).Select(x => x.Composition).ToArray();
Assert.AreEqual(3, availableTypes.Count());
Assert.AreEqual(ct2.Id, availableTypes.ElementAt(0).Id);
Assert.AreEqual(ct3.Id, availableTypes.ElementAt(1).Id);
Assert.AreEqual(ct4.Id, availableTypes.ElementAt(2).Id);
}
public void Replacing_History_Cleanup_Registers_As_Dirty()
{
var contentType = ContentTypeBuilder.CreateBasicContentType();
Assert.IsFalse(contentType.IsDirty());
contentType.HistoryCleanup = new HistoryCleanup();
Assert.IsTrue(contentType.IsDirty());
Assert.IsTrue(contentType.IsPropertyDirty(nameof(contentType.HistoryCleanup)));
}
public void Changing_Keep_latest_Makes_ContentType_Dirty()
{
var contentType = ContentTypeBuilder.CreateBasicContentType();
Assert.IsFalse(contentType.IsDirty());
var newValue = 2;
contentType.HistoryCleanup.KeepLatestVersionPerDayForDays = newValue;
Assert.IsTrue(contentType.IsDirty());
Assert.AreEqual(newValue, contentType.HistoryCleanup.KeepLatestVersionPerDayForDays);
}
public void Changing_Prevent_Cleanup_Makes_ContentType_Dirty()
{
var contentType = ContentTypeBuilder.CreateBasicContentType();
Assert.IsFalse(contentType.IsDirty());
var newValue = true;
contentType.HistoryCleanup.PreventCleanup = newValue;
Assert.IsTrue(contentType.IsDirty());
Assert.AreEqual(newValue, contentType.HistoryCleanup.PreventCleanup);
}
public void GivenScope_WhenNotificationsSuppressed_ThenNotificationsDoNotExecute()
{
using IScope scope = ScopeProvider.CreateScope(autoComplete: true);
using IDisposable _ = scope.Notifications.Suppress();
ContentType contentType = ContentTypeBuilder.CreateBasicContentType();
ContentTypeService.Save(contentType);
Content content = ContentBuilder.CreateBasicContent(contentType);
ContentService.Save(content);
}
public void GetAvailableCompositeContentTypes_No_Overlap_By_Content_Type_And_Property_Type_Alias()
{
void AddPropType(string alias, IContentType ct)
{
var contentCollection = new PropertyTypeCollection(true)
{
new PropertyType(ShortStringHelper, Constants.PropertyEditors.Aliases.TextBox, ValueStorageType.Ntext)
{
Alias = alias,
Name = "Title",
Description = string.Empty,
Mandatory = false,
SortOrder = 1,
DataTypeId = -88,
},
};
var pg = new PropertyGroup(contentCollection)
{
Alias = "test", Name = "test", SortOrder = 1
};
ct.PropertyGroups.Add(pg);
}
var ct1 = ContentTypeBuilder.CreateBasicContentType("ct1", "CT1");
var ct2 = ContentTypeBuilder.CreateBasicContentType("ct2", "CT2");
AddPropType("title", ct2);
var ct3 = ContentTypeBuilder.CreateBasicContentType("ct3", "CT3");
AddPropType("title", ct3);
var ct4 = ContentTypeBuilder.CreateBasicContentType("ct4", "CT4");
var ct5 = ContentTypeBuilder.CreateBasicContentType("ct5", "CT5");
AddPropType("blah", ct5);
ct1.Id = 1;
ct2.Id = 2;
ct3.Id = 3;
ct4.Id = 4;
ct5.Id = 4;
var service = new Mock <IContentTypeService>();
var availableTypes = service.Object.GetAvailableCompositeContentTypes(
ct1,
new[] { ct1, ct2, ct3, ct4, ct5 },
new[] { ct2.Alias },
new[] { "blah" })
.Results.Where(x => x.Allowed).Select(x => x.Composition).ToArray();
Assert.AreEqual(1, availableTypes.Count());
Assert.AreEqual(ct4.Id, availableTypes.ElementAt(0).Id);
}
private void CreateTestDataForPagingTests(out List <IContent> createdContent, out List <IMember> createdMembers, out List <IMedia> createdMedia)
{
// Create content
createdContent = new List <IContent>();
ContentType contentType = ContentTypeBuilder.CreateBasicContentType("blah");
ContentTypeService.Save(contentType);
for (int i = 0; i < 3; i++)
{
Content c1 = ContentBuilder.CreateBasicContent(contentType);
ContentService.Save(c1);
createdContent.Add(c1);
}
// Create media
createdMedia = new List <IMedia>();
MediaType imageType = MediaTypeBuilder.CreateImageMediaType("myImage");
MediaTypeService.Save(imageType);
for (int i = 0; i < 3; i++)
{
Media c1 = MediaBuilder.CreateMediaImage(imageType, -1);
MediaService.Save(c1);
createdMedia.Add(c1);
}
// Create members
MemberType memberType = MemberTypeBuilder.CreateSimpleMemberType("simple");
MemberTypeService.Save(memberType);
createdMembers = MemberBuilder.CreateSimpleMembers(memberType, 3).ToList();
GetMemberService().Save(createdMembers);
IRelationType relType = RelationService.GetRelationTypeByAlias(Constants.Conventions.RelationTypes.RelatedMediaAlias);
// Relate content to media
foreach (IContent content in createdContent)
{
foreach (IMedia media in createdMedia)
{
RelationService.Relate(content.Id, media.Id, relType);
}
}
// Relate members to media
foreach (IMember member in createdMembers)
{
foreach (IMedia media in createdMedia)
{
RelationService.Relate(member.Id, media.Id, relType);
}
}
}
public void Get_Paged_Relations_By_Relation_Type()
{
// Create content
var createdContent = new List <IContent>();
var contentType = ContentTypeBuilder.CreateBasicContentType("blah");
ContentTypeService.Save(contentType);
for (var i = 0; i < 3; i++)
{
var c1 = ContentBuilder.CreateBasicContent(contentType);
ContentService.Save(c1);
createdContent.Add(c1);
}
// Create media
var createdMedia = new List <IMedia>();
var imageType = MediaTypeBuilder.CreateImageMediaType("myImage");
MediaTypeService.Save(imageType);
for (var i = 0; i < 3; i++)
{
var c1 = MediaBuilder.CreateMediaImage(imageType, -1);
MediaService.Save(c1);
createdMedia.Add(c1);
}
var relType = RelationService.GetRelationTypeByAlias(Constants.Conventions.RelationTypes.RelatedMediaAlias);
// Relate content to media
foreach (var content in createdContent)
{
foreach (var media in createdMedia)
{
RelationService.Relate(content.Id, media.Id, relType);
}
}
var paged = RelationService.GetPagedByRelationTypeId(relType.Id, 0, 4, out var totalRecs).ToList();
Assert.AreEqual(9, totalRecs);
Assert.AreEqual(4, paged.Count);
// next page
paged.AddRange(RelationService.GetPagedByRelationTypeId(relType.Id, 1, 4, out totalRecs));
Assert.AreEqual(9, totalRecs);
Assert.AreEqual(8, paged.Count);
Assert.IsTrue(createdContent.Select(x => x.Id).ContainsAll(paged.Select(x => x.ParentId)));
Assert.IsTrue(createdMedia.Select(x => x.Id).ContainsAll(paged.Select(x => x.ChildId)));
}
public void Old_History_Cleanup_Reference_Doesnt_Make_Content_Type_Dirty()
{
var contentType = ContentTypeBuilder.CreateBasicContentType();
var oldHistoryCleanup = contentType.HistoryCleanup;
contentType.HistoryCleanup = new HistoryCleanup();
contentType.ResetDirtyProperties();
contentType.ResetWereDirtyProperties();
oldHistoryCleanup.KeepAllVersionsNewerThanDays = 2;
Assert.IsFalse(contentType.IsDirty());
Assert.IsFalse(contentType.WasDirty());
}
public void SupersededEvents()
{
DoSaveForContent += OnDoThingFail;
DoDeleteForContent += OnDoThingFail;
DoForTestArgs += OnDoThingFail;
DoForTestArgs2 += OnDoThingFail;
var contentType = ContentTypeBuilder.CreateBasicContentType();
var content1 = ContentBuilder.CreateBasicContent(contentType);
content1.Id = 123;
var content2 = ContentBuilder.CreateBasicContent(contentType);
content2.Id = 456;
var content3 = ContentBuilder.CreateBasicContent(contentType);
content3.Id = 789;
var scopeProvider = GetScopeProvider(NullLoggerFactory.Instance);
using (var scope = scopeProvider.CreateScope(eventDispatcher: new PassiveEventDispatcher()))
{
//content1 will be filtered from the args
scope.Events.Dispatch(DoSaveForContent, this, new SaveEventArgs <IContent>(new[] { content1, content3 }));
scope.Events.Dispatch(DoDeleteForContent, this, new DeleteEventArgs <IContent>(content1), "DoDeleteForContent");
scope.Events.Dispatch(DoSaveForContent, this, new SaveEventArgs <IContent>(content2));
//this entire event will be filtered
scope.Events.Dispatch(DoForTestArgs, this, new TestEventArgs(content1));
scope.Events.Dispatch(DoForTestArgs2, this, new TestEventArgs2(content1));
// events have been queued
var events = scope.Events.GetEvents(EventDefinitionFilter.All).ToArray();
Assert.AreEqual(4, events.Length);
Assert.AreEqual(typeof(SaveEventArgs <IContent>), events[0].Args.GetType());
Assert.AreEqual(1, ((SaveEventArgs <IContent>)events[0].Args).SavedEntities.Count());
Assert.AreEqual(content3.Id, ((SaveEventArgs <IContent>)events[0].Args).SavedEntities.First().Id);
Assert.AreEqual(typeof(DeleteEventArgs <IContent>), events[1].Args.GetType());
Assert.AreEqual(content1.Id, ((DeleteEventArgs <IContent>)events[1].Args).DeletedEntities.First().Id);
Assert.AreEqual(typeof(SaveEventArgs <IContent>), events[2].Args.GetType());
Assert.AreEqual(content2.Id, ((SaveEventArgs <IContent>)events[2].Args).SavedEntities.First().Id);
Assert.AreEqual(typeof(TestEventArgs2), events[3].Args.GetType());
}
}
public void GivenNestedScope_WhenOuterNotificationsSuppressed_ThenNotificationsDoNotExecute()
{
using (var parentScope = ScopeProvider.CreateScope(autoComplete: true))
{
using var _ = parentScope.Notifications.Suppress();
using (var childScope = ScopeProvider.CreateScope(autoComplete: true))
{
var contentType = ContentTypeBuilder.CreateBasicContentType();
ContentTypeService.Save(contentType);
var content = ContentBuilder.CreateBasicContent(contentType);
ContentService.Save(content);
}
}
}
public async Task Invariant_Child_Content_Published_No_Domains()
{
var contentType = ContentTypeBuilder.CreateBasicContentType();
var parent = ContentBuilder.CreateBasicContent(contentType);
parent.Id = 1046; // FIXME: we are using this ID only because it's built into the test XML published cache
parent.Name = "home";
parent.Path = "-1,1046";
parent.Published = true;
var child = ContentBuilder.CreateBasicContent(contentType);
child.Name = "sub1";
child.Id = 1173; // FIXME: we are using this ID only because it's built into the test XML published cache
child.Path = "-1,1046,1173";
child.Published = true;
var umbracoContextAccessor = GetUmbracoContextAccessor("http://localhost:8000");
var publishedRouter = CreatePublishedRouter(
umbracoContextAccessor,
new[] { new ContentFinderByUrl(Mock.Of <ILogger <ContentFinderByUrl> >(), umbracoContextAccessor) });
var umbracoContext = umbracoContextAccessor.GetRequiredUmbracoContext();
var localizationService = GetLangService("en-US", "fr-FR");
var urlProvider = GetUrlProvider(umbracoContextAccessor, _requestHandlerSettings, _webRoutingSettings, out var uriUtility);
var urls = (await child.GetContentUrlsAsync(
publishedRouter,
umbracoContext,
localizationService,
GetTextService(),
Mock.Of <IContentService>(),
VariationContextAccessor,
Mock.Of <ILogger <IContent> >(),
uriUtility,
urlProvider)).ToList();
Assert.AreEqual(2, urls.Count);
var enUrl = urls.First(x => x.Culture == "en-US");
Assert.AreEqual("/home/sub1/", enUrl.Text);
Assert.AreEqual("en-US", enUrl.Culture);
Assert.IsTrue(enUrl.IsUrl);
var frUrl = urls.First(x => x.Culture == "fr-FR");
Assert.IsFalse(frUrl.IsUrl);
}
public void Can_Move()
{
IScopeProvider provider = ScopeProvider;
using (IScope scope = provider.CreateScope())
{
ContentTypeRepository repository = ContentTypeRepository;
var container1 = new EntityContainer(Constants.ObjectTypes.DocumentType)
{
Name = "blah1"
};
DocumentTypeContainerRepository.Save(container1);
var container2 = new EntityContainer(Constants.ObjectTypes.DocumentType)
{
Name = "blah2", ParentId = container1.Id
};
DocumentTypeContainerRepository.Save(container2);
var contentType = (IContentType)ContentTypeBuilder.CreateBasicContentType("asdfasdf");
contentType.ParentId = container2.Id;
repository.Save(contentType);
// create a
var contentType2 = (IContentType) new ContentType(ShortStringHelper, contentType, "hello")
{
Name = "Blahasdfsadf"
};
contentType.ParentId = contentType.Id;
repository.Save(contentType2);
global::Umbraco.Cms.Core.Events.MoveEventInfo <IContentType>[] result = repository.Move(contentType, container1).ToArray();
Assert.AreEqual(2, result.Count());
// re-get
contentType = repository.Get(contentType.Id);
contentType2 = repository.Get(contentType2.Id);
Assert.AreEqual(container1.Id, contentType.ParentId);
Assert.AreNotEqual(result.Single(x => x.Entity.Id == contentType.Id).OriginalPath, contentType.Path);
Assert.AreNotEqual(result.Single(x => x.Entity.Id == contentType2.Id).OriginalPath, contentType2.Path);
}
}
private int CreateTestData(string isoName, out ContentType ct)
{
var provider = ScopeProvider;
using (var scope = provider.CreateScope())
{
var lang = new Language(isoName, isoName);
LanguageRepository.Save(lang);
ct = ContentTypeBuilder.CreateBasicContentType("test", "Test");
ContentTypeRepository.Save(ct);
var content = new Content("test", -1, ct)
{
CreatorId = 0, WriterId = 0
};
DocumentRepository.Save(content);
scope.Complete();
return(content.Id);
}
}
public void GetAvailableCompositeContentTypes_No_Results_If_Already_A_Composition()
{
ContentType ct1 = ContentTypeBuilder.CreateBasicContentType("ct1", "CT1");
ContentType ct2 = ContentTypeBuilder.CreateBasicContentType("ct2", "CT2");
ContentType ct3 = ContentTypeBuilder.CreateBasicContentType("ct3", "CT3");
ct1.Id = 1;
ct2.Id = 2;
ct3.Id = 3;
ct2.AddContentType(ct1);
var service = new Mock <IContentTypeService>();
System.Collections.Generic.IEnumerable <ContentTypeAvailableCompositionsResult> availableTypes = service.Object.GetAvailableCompositeContentTypes(
ct1,
new[] { ct1, ct2, ct3 }).Results;
Assert.AreEqual(0, availableTypes.Count());
}
public void GetAvailableCompositeContentTypes_No_Results_If_Already_A_Composition_By_Parent()
{
var ct1 = ContentTypeBuilder.CreateBasicContentType("ct1", "CT1");
ct1.Id = 1;
var ct2 = ContentTypeBuilder.CreateBasicContentType("ct2", "CT2", ct1);
ct2.Id = 2;
var ct3 = ContentTypeBuilder.CreateBasicContentType("ct3", "CT3");
ct3.Id = 3;
var service = new Mock <IContentTypeService>();
var availableTypes = service.Object.GetAvailableCompositeContentTypes(
ct1,
new[] { ct1, ct2, ct3 }).Results;
Assert.AreEqual(0, availableTypes.Count());
}
public void GetAvailableCompositeContentTypes_Not_Itself()
{
ContentType ct1 = ContentTypeBuilder.CreateBasicContentType("ct1", "CT1", null);
ContentType ct2 = ContentTypeBuilder.CreateBasicContentType("ct2", "CT2", null);
ContentType ct3 = ContentTypeBuilder.CreateBasicContentType("ct3", "CT3", null);
ct1.Id = 1;
ct2.Id = 2;
ct3.Id = 3;
var service = new Mock <IContentTypeService>();
IContentTypeComposition[] availableTypes = service.Object.GetAvailableCompositeContentTypes(
ct1,
new[] { ct1, ct2, ct3 })
.Results.Where(x => x.Allowed).Select(x => x.Composition).ToArray();
Assert.AreEqual(2, availableTypes.Count());
Assert.AreEqual(ct2.Id, availableTypes.ElementAt(0).Id);
Assert.AreEqual(ct3.Id, availableTypes.ElementAt(1).Id);
}
private IEnumerable <IContent> CreateTestData(int count)
{
var provider = ScopeProvider;
using (var scope = provider.CreateScope())
{
var ct = ContentTypeBuilder.CreateBasicContentType("testing");
ContentTypeRepository.Save(ct);
var result = new List <IContent>();
for (var i = 0; i < count; i++)
{
var c = new Content("test" + i, -1, ct);
DocumentRepository.Save(c);
result.Add(c);
}
scope.Complete();
return(result);
}
}
public void GetAvailableCompositeContentTypes_Do_Not_Include_Other_Composed_Types()
{
ContentType ct1 = ContentTypeBuilder.CreateBasicContentType("ct1", "CT1");
ContentType ct2 = ContentTypeBuilder.CreateBasicContentType("ct2", "CT2");
ContentType ct3 = ContentTypeBuilder.CreateBasicContentType("ct3", "CT3");
ct1.Id = 1;
ct2.Id = 2;
ct3.Id = 3;
ct2.AddContentType(ct3);
var service = new Mock <IContentTypeService>();
IContentTypeComposition[] availableTypes = service.Object.GetAvailableCompositeContentTypes(
ct1,
new[] { ct1, ct2, ct3 })
.Results.Where(x => x.Allowed).Select(x => x.Composition).ToArray();
Assert.AreEqual(1, availableTypes.Count());
Assert.AreEqual(ct3.Id, availableTypes.Single().Id);
}
private void CreateTestDataForPagingTests(out List <IContent> createdContent, out List <IMember> createdMembers, out List <IMedia> createdMedia)
{
// Create content
createdContent = new List <IContent>();
ContentType contentType = ContentTypeBuilder.CreateBasicContentType("blah");
ContentTypeService.Save(contentType);
for (int i = 0; i < 3; i++)
{
Content c1 = ContentBuilder.CreateBasicContent(contentType);
ContentService.Save(c1);
createdContent.Add(c1);
}
// Create related content
var relatedContent = new List <IContent>();
for (int i = 0; i < 3; i++)
{
Content c1 = ContentBuilder.CreateBasicContent(contentType);
ContentService.Save(c1);
relatedContent.Add(c1);
}
// Create media
createdMedia = new List <IMedia>();
MediaType imageType = MediaTypeBuilder.CreateImageMediaType("myImage");
MediaTypeService.Save(imageType);
for (int i = 0; i < 3; i++)
{
Media c1 = MediaBuilder.CreateMediaImage(imageType, -1);
MediaService.Save(c1);
createdMedia.Add(c1);
}
// Create members
MemberType memberType = MemberTypeBuilder.CreateSimpleMemberType("simple");
MemberTypeService.Save(memberType);
createdMembers = MemberBuilder.CreateSimpleMembers(memberType, 3).ToList();
GetMemberService().Save(createdMembers);
IRelationType relatedMediaRelType = RelationService.GetRelationTypeByAlias(Constants.Conventions.RelationTypes.RelatedMediaAlias);
IRelationType relatedContentRelType = RelationService.GetRelationTypeByAlias(Constants.Conventions.RelationTypes.RelatedDocumentAlias);
// Relate content to media
foreach (IContent content in createdContent)
{
foreach (IMedia media in createdMedia)
{
RelationService.Relate(content.Id, media.Id, relatedMediaRelType);
}
}
// Relate content to content
foreach (IContent relContent in relatedContent)
{
foreach (IContent content in createdContent)
{
RelationService.Relate(relContent.Id, content.Id, relatedContentRelType);
}
}
// Relate members to media
foreach (IMember member in createdMembers)
{
foreach (IMedia media in createdMedia)
{
RelationService.Relate(member.Id, media.Id, relatedMediaRelType);
}
}
// Create copied content
var copiedContent = new List <IContent>();
for (int i = 0; i < 3; i++)
{
Content c1 = ContentBuilder.CreateBasicContent(contentType);
ContentService.Save(c1);
copiedContent.Add(c1);
}
IRelationType copiedContentRelType = RelationService.GetRelationTypeByAlias(Constants.Conventions.RelationTypes.RelateDocumentOnCopyAlias);
// Relate content to content (mimics copy)
foreach (IContent content in createdContent)
{
foreach (IContent cpContent in copiedContent)
{
RelationService.Relate(content.Id, cpContent.Id, copiedContentRelType);
}
}
// Create trashed content
var trashedContent = new List <IContent>();
for (int i = 0; i < 3; i++)
{
Content c1 = ContentBuilder.CreateBasicContent(contentType);
ContentService.Save(c1);
trashedContent.Add(c1);
}
IRelationType trashedRelType = RelationService.GetRelationTypeByAlias(Constants.Conventions.RelationTypes.RelateParentDocumentOnDeleteAlias);
// Relate to trashed content
foreach (IContent trContent in trashedContent)
{
foreach (IContent content in createdContent)
{
RelationService.Relate(trContent.Id, content.Id, trashedRelType);
}
}
// Create trashed media
var trashedMedia = new List <IMedia>();
for (int i = 0; i < 3; i++)
{
Media m1 = MediaBuilder.CreateMediaImage(imageType, -1);
MediaService.Save(m1);
trashedMedia.Add(m1);
}
IRelationType trashedMediaRelType = RelationService.GetRelationTypeByAlias(Constants.Conventions.RelationTypes.RelateParentMediaFolderOnDeleteAlias);
// Relate to trashed media
foreach (IMedia trMedia in trashedMedia)
{
foreach (IMedia media in createdMedia)
{
RelationService.Relate(trMedia.Id, media.Id, trashedMediaRelType);
}
}
}
public void Can_Perform_Update_On_UserRepository()
{
var ct = ContentTypeBuilder.CreateBasicContentType("test");
var mt = MediaTypeBuilder.CreateSimpleMediaType("testmedia", "TestMedia");
// Arrange
ICoreScopeProvider provider = ScopeProvider;
using (var scope = provider.CreateCoreScope(autoComplete: true))
{
var userRepository = CreateRepository(provider);
var userGroupRepository = CreateUserGroupRepository(provider);
ContentTypeRepository.Save(ct);
MediaTypeRepository.Save(mt);
var content = ContentBuilder.CreateBasicContent(ct);
var media = MediaBuilder.CreateSimpleMedia(mt, "asdf", -1);
DocumentRepository.Save(content);
MediaRepository.Save(media);
var user = CreateAndCommitUserWithGroup(userRepository, userGroupRepository);
// Act
var resolved = (User)userRepository.Get(user.Id);
resolved.Name = "New Name";
// the db column is not used, default permissions are taken from the user type's permissions, this is a getter only
//// resolved.DefaultPermissions = "ZYX";
resolved.Language = "fr";
resolved.IsApproved = false;
resolved.RawPasswordValue = "new";
resolved.IsLockedOut = true;
resolved.StartContentIds = new[] { content.Id };
resolved.StartMediaIds = new[] { media.Id };
resolved.Email = "*****@*****.**";
resolved.Username = "******";
userRepository.Save(resolved);
var updatedItem = (User)userRepository.Get(user.Id);
// Assert
Assert.That(updatedItem.Id, Is.EqualTo(resolved.Id));
Assert.That(updatedItem.Name, Is.EqualTo(resolved.Name));
Assert.That(updatedItem.Language, Is.EqualTo(resolved.Language));
Assert.That(updatedItem.IsApproved, Is.EqualTo(resolved.IsApproved));
Assert.That(updatedItem.RawPasswordValue, Is.EqualTo(resolved.RawPasswordValue));
Assert.That(updatedItem.IsLockedOut, Is.EqualTo(resolved.IsLockedOut));
Assert.IsTrue(updatedItem.StartContentIds.UnsortedSequenceEqual(resolved.StartContentIds));
Assert.IsTrue(updatedItem.StartMediaIds.UnsortedSequenceEqual(resolved.StartMediaIds));
Assert.That(updatedItem.Email, Is.EqualTo(resolved.Email));
Assert.That(updatedItem.Username, Is.EqualTo(resolved.Username));
Assert.That(updatedItem.AllowedSections.Count(), Is.EqualTo(resolved.AllowedSections.Count()));
foreach (var allowedSection in resolved.AllowedSections)
{
Assert.IsTrue(updatedItem.AllowedSections.Contains(allowedSection));
}
}
}
public void GivenIndexingDocument_WhenGridPropertyData_ThenDataIndexedInSegregatedFields()
{
using (GetSynchronousContentIndex(false, out var index, out _, out var contentValueSetBuilder))
{
index.CreateIndex();
var contentType = ContentTypeBuilder.CreateBasicContentType();
contentType.AddPropertyType(new PropertyType(TestHelper.ShortStringHelper, "test", ValueStorageType.Ntext)
{
Alias = "grid",
Name = "Grid",
PropertyEditorAlias = Constants.PropertyEditors.Aliases.Grid
});
var content = ContentBuilder.CreateBasicContent(contentType);
content.Id = 555;
content.Path = "-1,555";
var gridVal = new GridValue
{
Name = "n1",
Sections = new List <GridValue.GridSection>
{
new()
{
Grid = "g1",
Rows = new List <GridValue.GridRow>
{
new()
{
Id = Guid.NewGuid(),
Name = "row1",
Areas = new List <GridValue.GridArea>
{
new()
{
Grid = "g2",
Controls = new List <GridValue.GridControl>
{
new()
{
Editor = new GridValue.GridEditor
{
Alias = "editor1",
View = "view1"
},
Value = "value1"
},
new()
{
Editor = new GridValue.GridEditor
{
Alias = "editor1",
View = "view1"
},
Value = "value2"
}
}
}
}
}
}
}
}
};
var json = JsonConvert.SerializeObject(gridVal);
content.Properties["grid"].SetValue(json);
var valueSet = contentValueSetBuilder.GetValueSets(content);
index.IndexItems(valueSet);
var results = index.Searcher.CreateQuery().Id(555).Execute();
Assert.AreEqual(1, results.TotalItemCount);
var result = results.First();
Assert.IsTrue(result.Values.ContainsKey("grid.row1"));
Assert.AreEqual("value1", result.AllValues["grid.row1"][0]);
Assert.AreEqual("value2", result.AllValues["grid.row1"][1]);
Assert.IsTrue(result.Values.ContainsKey("grid"));
Assert.AreEqual("value1 value2 ", result["grid"]);
Assert.IsTrue(result.Values.ContainsKey($"{UmbracoExamineFieldNames.RawFieldPrefix}grid"));
Assert.AreEqual(json, result[$"{UmbracoExamineFieldNames.RawFieldPrefix}grid"]);
}
}
public void Get_Paged_Mixed_Entities_By_Ids()
{
// Create content
IContentService contentService = GetRequiredService <IContentService>();
IContentTypeService contentTypeService = GetRequiredService <IContentTypeService>();
var createdContent = new List <IContent>();
ContentType contentType = ContentTypeBuilder.CreateBasicContentType("blah");
contentTypeService.Save(contentType);
for (int i = 0; i < 10; i++)
{
Content c1 = ContentBuilder.CreateBasicContent(contentType);
contentService.Save(c1);
createdContent.Add(c1);
}
// Create media
IMediaService mediaService = GetRequiredService <IMediaService>();
IMediaTypeService mediaTypeService = GetRequiredService <IMediaTypeService>();
var createdMedia = new List <IMedia>();
MediaType imageType = MediaTypeBuilder.CreateImageMediaType("myImage");
mediaTypeService.Save(imageType);
for (int i = 0; i < 10; i++)
{
Media c1 = MediaBuilder.CreateMediaImage(imageType, -1);
mediaService.Save(c1);
createdMedia.Add(c1);
}
// Create members
IMemberService memberService = GetRequiredService <IMemberService>();
IMemberTypeService memberTypeService = GetRequiredService <IMemberTypeService>();
MemberType memberType = MemberTypeBuilder.CreateSimpleMemberType("simple");
memberTypeService.Save(memberType);
var createdMembers = MemberBuilder.CreateMultipleSimpleMembers(memberType, 10).ToList();
memberService.Save(createdMembers);
IScopeProvider provider = ScopeProvider;
using (provider.CreateScope())
{
EntityRepository repo = CreateRepository((IScopeAccessor)provider);
IEnumerable <int> ids = createdContent.Select(x => x.Id).Concat(createdMedia.Select(x => x.Id)).Concat(createdMembers.Select(x => x.Id));
System.Guid[] objectTypes = new[] { Constants.ObjectTypes.Document, Constants.ObjectTypes.Media, Constants.ObjectTypes.Member };
IQuery <IUmbracoEntity> query = provider.CreateQuery <IUmbracoEntity>()
.WhereIn(e => e.Id, ids);
var entities = repo.GetPagedResultsByQuery(query, objectTypes, 0, 20, out long totalRecords, null, null).ToList();
Assert.AreEqual(20, entities.Count);
Assert.AreEqual(30, totalRecords);
// add the next page
entities.AddRange(repo.GetPagedResultsByQuery(query, objectTypes, 1, 20, out totalRecords, null, null));
Assert.AreEqual(30, entities.Count);
Assert.AreEqual(30, totalRecords);
var contentEntities = entities.OfType <IDocumentEntitySlim>().ToList();
var mediaEntities = entities.OfType <IMediaEntitySlim>().ToList();
var memberEntities = entities.OfType <IMemberEntitySlim>().ToList();
Assert.AreEqual(10, contentEntities.Count);
Assert.AreEqual(10, mediaEntities.Count);
Assert.AreEqual(10, memberEntities.Count);
}
}
private static IContent CreateContent(int nodeId)
{
ContentType contentType = ContentTypeBuilder.CreateBasicContentType();
return(ContentBuilder.CreateBasicContent(contentType, nodeId));
}
