public void Get_Paged_Parent_Child_Entities_With_Same_Entity_Relation() { // Create a media item and create a relationship between itself (parent -> child) MediaType imageType = MediaTypeBuilder.CreateImageMediaType("myImage"); MediaTypeService.Save(imageType); Media media = MediaBuilder.CreateMediaImage(imageType, -1); MediaService.Save(media); IRelationType relType = RelationService.GetRelationTypeByAlias(Constants.Conventions.RelationTypes.RelatedMediaAlias); RelationService.Relate(media.Id, media.Id, relType); using (IScope scope = ScopeProvider.CreateScope()) { RelationRepository repository = CreateRepository(ScopeProvider, out RelationTypeRepository relationTypeRepository); // Get parent entities for child id var parents = repository.GetPagedParentEntitiesByChildId(media.Id, 0, 10, out long totalRecords).ToList(); Assert.AreEqual(1, totalRecords); Assert.AreEqual(1, parents.Count); // Get child entities for parent id var children = repository.GetPagedChildEntitiesByParentId(media.Id, 0, 10, out totalRecords).ToList(); Assert.AreEqual(1, totalRecords); Assert.AreEqual(1, children.Count); } }
public void Can_Copy_MediaType_By_Performing_Clone() { // Arrange var mediaType = MediaTypeBuilder.CreateImageMediaType("Image2") as IMediaType; MediaTypeService.Save(mediaType); // Act var sut = mediaType.DeepCloneWithResetIdentities("Image2_2"); Assert.IsNotNull(sut); MediaTypeService.Save(sut); // Assert Assert.That(sut.HasIdentity, Is.True); Assert.AreEqual(mediaType.ParentId, sut.ParentId); Assert.AreEqual(mediaType.Level, sut.Level); Assert.AreEqual(mediaType.PropertyTypes.Count(), sut.PropertyTypes.Count()); Assert.AreNotEqual(mediaType.Id, sut.Id); Assert.AreNotEqual(mediaType.Key, sut.Key); Assert.AreNotEqual(mediaType.Path, sut.Path); Assert.AreNotEqual(mediaType.SortOrder, sut.SortOrder); Assert.AreNotEqual(mediaType.PropertyTypes.First(x => x.Alias.Equals("umbracoFile")).Id, sut.PropertyTypes.First(x => x.Alias.Equals("umbracoFile")).Id); Assert.AreNotEqual(mediaType.PropertyGroups.First(x => x.Name.Equals("Media")).Id, sut.PropertyGroups.First(x => x.Name.Equals("Media")).Id); }
public void Export_Zip() { var mt = MediaTypeBuilder.CreateImageMediaType("testImage"); MediaTypeService.Save(mt); var m1 = MediaBuilder.CreateMediaFile(mt, -1); MediaService.Save(m1); //Ensure a file exist var fullPath = HostingEnvironment.MapPathWebRoot(m1.Properties[Constants.Conventions.Media.File].GetValue().ToString()); using (StreamWriter file1 = File.CreateText(fullPath)) { file1.WriteLine("hello"); } var def = new PackageDefinition { Name = "test", MediaUdis = new List <GuidUdi>() { m1.GetUdi() } }; bool result = PackageBuilder.SavePackage(def); Assert.IsTrue(result); Assert.IsTrue(def.PackagePath.IsNullOrWhiteSpace()); string packageXmlPath = PackageBuilder.ExportPackage(def); def = PackageBuilder.GetById(def.Id); // re-get Assert.IsNotNull(def.PackagePath); using (FileStream packageZipStream = File.OpenRead(packageXmlPath)) using (ZipArchive zipArchive = PackageMigrationResource.GetPackageDataManifest(packageZipStream, out XDocument packageXml)) { string test = "test-file.txt"; Assert.Multiple(() => { var mediaEntry = zipArchive.GetEntry("media/media/test-file.txt"); Assert.AreEqual("umbPackage", packageXml.Root.Name.ToString()); Assert.IsNotNull(mediaEntry); Assert.AreEqual(test, mediaEntry.Name); Assert.IsNotNull(zipArchive.GetEntry("package.xml")); Assert.AreEqual( $"<MediaItems><MediaSet><testImage id=\"{m1.Id}\" key=\"{m1.Key}\" parentID=\"-1\" level=\"1\" creatorID=\"-1\" sortOrder=\"0\" createDate=\"{m1.CreateDate.ToString("s")}\" updateDate=\"{m1.UpdateDate.ToString("s")}\" nodeName=\"Test File\" urlName=\"test-file\" path=\"{m1.Path}\" isDoc=\"\" nodeType=\"{mt.Id}\" nodeTypeAlias=\"testImage\" writerName=\"\" writerID=\"0\" udi=\"{m1.GetUdi()}\" mediaFilePath=\"/media/test-file.txt\"><umbracoFile><![CDATA[/media/test-file.txt]]></umbracoFile><umbracoBytes><![CDATA[100]]></umbracoBytes><umbracoExtension><![CDATA[png]]></umbracoExtension></testImage></MediaSet></MediaItems>", packageXml.Element("umbPackage").Element("MediaItems").ToString(SaveOptions.DisableFormatting)); Assert.AreEqual(2, zipArchive.Entries.Count()); Assert.AreEqual(ZipArchiveMode.Read, zipArchive.Mode); Assert.IsNull(packageXml.DocumentType); Assert.IsNull(packageXml.NextNode); Assert.IsNull(packageXml.Parent); Assert.IsNull(packageXml.PreviousNode); }); } }
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 GivenMimeType_WhenDeriving_ThenNameIsRequired() { var builder = new MediaTypeBuilder(this.DatabaseSession); var mediaType = builder.Build(); Assert.IsTrue(this.DatabaseSession.Derive().HasErrors); this.DatabaseSession.Rollback(); builder.WithName("image/gif"); mediaType = builder.Build(); Assert.IsFalse(this.DatabaseSession.Derive().HasErrors); }
public void Can_Move() { var provider = ScopeProvider; using (var scope = provider.CreateScope()) { var containerRepository = CreateContainerRepository(provider); var repository = CreateRepository(provider); var container1 = new EntityContainer(Constants.ObjectTypes.MediaType) { Name = "blah1" }; containerRepository.Save(container1); var container2 = new EntityContainer(Constants.ObjectTypes.MediaType) { Name = "blah2", ParentId = container1.Id }; containerRepository.Save(container2); IMediaType contentType = MediaTypeBuilder.CreateNewMediaType(); contentType.ParentId = container2.Id; repository.Save(contentType); // create a var contentType2 = (IMediaType) new MediaType(ShortStringHelper, contentType, "hello") { Name = "Blahasdfsadf" }; contentType.ParentId = contentType.Id; repository.Save(contentType2); var result = repository.Move(contentType, container1).ToArray(); Assert.AreEqual(2, result.Length); // 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); } }
public void Empty_Description_Is_Always_Null_After_Saving_Media_Type() { var mediaType = MediaTypeBuilder.CreateSimpleMediaType("mediaType", "Media Type"); mediaType.Description = null; MediaTypeService.Save(mediaType); var mediaType2 = MediaTypeBuilder.CreateSimpleMediaType("mediaType2", "Media Type 2"); mediaType2.Description = string.Empty; MediaTypeService.Save(mediaType2); Assert.IsNull(mediaType.Description); Assert.IsNull(mediaType2.Description); }
public void Automatically_Track_Relations() { var mt = MediaTypeBuilder.CreateSimpleMediaType("testMediaType", "Test Media Type"); MediaTypeService.Save(mt); var m1 = MediaBuilder.CreateSimpleMedia(mt, "hello 1", -1); var m2 = MediaBuilder.CreateSimpleMedia(mt, "hello 1", -1); MediaService.Save(m1); MediaService.Save(m2); var template = TemplateBuilder.CreateTextPageTemplate(); FileService.SaveTemplate(template); var ct = ContentTypeBuilder.CreateTextPageContentType("richTextTest", defaultTemplateId: template.Id); ct.AllowedTemplates = Enumerable.Empty <ITemplate>(); ContentTypeService.Save(ct); var c1 = ContentBuilder.CreateTextpageContent(ct, "my content 1", -1); ContentService.Save(c1); var c2 = ContentBuilder.CreateTextpageContent(ct, "my content 2", -1); // 'bodyText' is a property with a RTE property editor which we knows tracks relations c2.Properties["bodyText"].SetValue(@"<p> <img src='/media/12312.jpg' data-udi='umb://media/" + m1.Key.ToString("N") + @"' /> </p><p><img src='/media/234234.jpg' data-udi=""umb://media/" + m2.Key.ToString("N") + @""" /> </p> <p> <a href=""{locallink:umb://document/" + c1.Key.ToString("N") + @"}"">hello</a> </p>"); ContentService.Save(c2); var relations = RelationService.GetByParentId(c2.Id).ToList(); Assert.AreEqual(3, relations.Count); Assert.AreEqual(Constants.Conventions.RelationTypes.RelatedMediaAlias, relations[0].RelationType.Alias); Assert.AreEqual(m1.Id, relations[0].ChildId); Assert.AreEqual(Constants.Conventions.RelationTypes.RelatedMediaAlias, relations[1].RelationType.Alias); Assert.AreEqual(m2.Id, relations[1].ChildId); Assert.AreEqual(Constants.Conventions.RelationTypes.RelatedDocumentAlias, relations[2].RelationType.Alias); Assert.AreEqual(c1.Id, relations[2].ChildId); }
public void CacheActiveForIntsAndGuids() { var realCache = new AppCaches( new ObjectCacheAppCache(), new DictionaryAppCache(), new IsolatedCaches(t => new ObjectCacheAppCache())); IScopeProvider provider = ScopeProvider; using (IScope scope = provider.CreateScope()) { MediaRepository repository = CreateRepository(provider, out MediaTypeRepository mediaTypeRepository, appCaches: realCache); IUmbracoDatabase udb = ScopeAccessor.AmbientScope.Database; udb.EnableSqlCount = false; MediaType mediaType = MediaTypeBuilder.CreateSimpleMediaType("umbTextpage1", "Textpage"); mediaTypeRepository.Save(mediaType); Media media = MediaBuilder.CreateSimpleMedia(mediaType, "hello", -1); repository.Save(media); udb.EnableSqlCount = true; // go get it, this should already be cached since the default repository key is the INT IMedia found = repository.Get(media.Id); Assert.AreEqual(0, udb.SqlCount); // retrieve again, this should use cache found = repository.Get(media.Id); Assert.AreEqual(0, udb.SqlCount); // reset counter udb.EnableSqlCount = false; udb.EnableSqlCount = true; // now get by GUID, this won't be cached yet because the default repo key is not a GUID found = repository.Get(media.Key); int sqlCount = udb.SqlCount; Assert.Greater(sqlCount, 0); // retrieve again, this should use cache now found = repository.Get(media.Key); Assert.AreEqual(sqlCount, udb.SqlCount); } }
public void Can_Copy_MediaType_To_New_Parent_By_Performing_Clone() { // Arrange var parentMediaType1 = MediaTypeBuilder.CreateSimpleMediaType("parent1", "Parent1"); MediaTypeService.Save(parentMediaType1); var parentMediaType2 = MediaTypeBuilder.CreateSimpleMediaType("parent2", "Parent2", null, true); MediaTypeService.Save(parentMediaType2); var mediaType = MediaTypeBuilder.CreateImageMediaType("Image2") as IMediaType; MediaTypeService.Save(mediaType); // Act var clone = mediaType.DeepCloneWithResetIdentities("newcategory"); Assert.IsNotNull(clone); clone.RemoveContentType("parent1"); clone.AddContentType(parentMediaType2); clone.ParentId = parentMediaType2.Id; MediaTypeService.Save(clone); // Assert Assert.That(clone.HasIdentity, Is.True); var clonedMediaType = MediaTypeService.Get(clone.Id); var originalMediaType = MediaTypeService.Get(mediaType.Id); Assert.That(clonedMediaType.CompositionAliases().Any(x => x.Equals("parent2")), Is.True); Assert.That(clonedMediaType.CompositionAliases().Any(x => x.Equals("parent1")), Is.False); Assert.AreEqual(clonedMediaType.Path, "-1," + parentMediaType2.Id + "," + clonedMediaType.Id); Assert.AreEqual(clonedMediaType.PropertyTypes.Count(), originalMediaType.PropertyTypes.Count()); Assert.AreNotEqual(clonedMediaType.ParentId, originalMediaType.ParentId); Assert.AreEqual(clonedMediaType.ParentId, parentMediaType2.Id); Assert.AreNotEqual(clonedMediaType.Id, originalMediaType.Id); Assert.AreNotEqual(clonedMediaType.Key, originalMediaType.Key); Assert.AreNotEqual(clonedMediaType.Path, originalMediaType.Path); Assert.AreNotEqual(clonedMediaType.PropertyTypes.First(x => x.Alias.StartsWith("umbracoFile")).Id, originalMediaType.PropertyTypes.First(x => x.Alias.StartsWith("umbracoFile")).Id); Assert.AreNotEqual(clonedMediaType.PropertyGroups.First(x => x.Name.StartsWith("Media")).Id, originalMediaType.PropertyGroups.First(x => x.Name.StartsWith("Media")).Id); }
public void IMediaType_To_MediaTypeDisplay() { // Arrange var mediaType = MediaTypeBuilder.CreateImageMediaType(); MediaTypeBuilder.EnsureAllIds(mediaType, 8888); // Act var result = _sut.Map <MediaTypeDisplay>(mediaType); // Assert Assert.AreEqual(mediaType.Alias, result.Alias); Assert.AreEqual(mediaType.Description, result.Description); Assert.AreEqual(mediaType.Icon, result.Icon); Assert.AreEqual(mediaType.Id, result.Id); Assert.AreEqual(mediaType.Name, result.Name); Assert.AreEqual(mediaType.ParentId, result.ParentId); Assert.AreEqual(mediaType.Path, result.Path); Assert.AreEqual(mediaType.Thumbnail, result.Thumbnail); Assert.AreEqual(mediaType.IsContainer, result.IsContainer); Assert.AreEqual(mediaType.CreateDate, result.CreateDate); Assert.AreEqual(mediaType.UpdateDate, result.UpdateDate); Assert.AreEqual(mediaType.PropertyGroups.Count(), result.Groups.Count()); for (var i = 0; i < mediaType.PropertyGroups.Count(); i++) { Assert.AreEqual(mediaType.PropertyGroups.ElementAt(i).Id, result.Groups.ElementAt(i).Id); Assert.AreEqual(mediaType.PropertyGroups.ElementAt(i).Name, result.Groups.ElementAt(i).Name); var propTypes = mediaType.PropertyGroups.ElementAt(i).PropertyTypes; Assert.AreEqual(propTypes.Count(), result.Groups.ElementAt(i).Properties.Count()); for (var j = 0; j < propTypes.Count(); j++) { Assert.AreEqual(propTypes.ElementAt(j).Id, result.Groups.ElementAt(i).Properties.ElementAt(j).Id); Assert.AreEqual(propTypes.ElementAt(j).DataTypeId, result.Groups.ElementAt(i).Properties.ElementAt(j).DataTypeId); } } Assert.AreEqual(mediaType.AllowedContentTypes.Count(), result.AllowedContentTypes.Count()); for (var i = 0; i < mediaType.AllowedContentTypes.Count(); i++) { Assert.AreEqual(mediaType.AllowedContentTypes.ElementAt(i).Id.Value, result.AllowedContentTypes.ElementAt(i)); } }
public void Deleting_Media_Types_With_Hierarchy_Of_Media_Items_Doesnt_Raise_Trashed_Event_For_Deleted_Items() { ContentNotificationHandler.MovedMediaToRecycleBin = MovedMediaToRecycleBin; try { IMediaType contentType1 = MediaTypeBuilder.CreateSimpleMediaType("test1", "Test1"); MediaTypeService.Save(contentType1); IMediaType contentType2 = MediaTypeBuilder.CreateSimpleMediaType("test2", "Test2"); MediaTypeService.Save(contentType2); IMediaType contentType3 = MediaTypeBuilder.CreateSimpleMediaType("test3", "Test3"); MediaTypeService.Save(contentType3); IMediaType[] contentTypes = { contentType1, contentType2, contentType3 }; var parentId = -1; var ids = new List <int>(); for (var i = 0; i < 2; i++) { for (var index = 0; index < contentTypes.Length; index++) { var contentType = contentTypes[index]; var contentItem = MediaBuilder.CreateSimpleMedia(contentType, "MyName_" + index + "_" + i, parentId); MediaService.Save(contentItem); parentId = contentItem.Id; ids.Add(contentItem.Id); } } foreach (var contentType in contentTypes.Reverse()) { MediaTypeService.Delete(contentType); } } finally { ContentNotificationHandler.MovedMediaToRecycleBin = null; } }
public void Deleting_Media_Type_With_Hierarchy_Of_Media_Items_Moves_Orphaned_Media_To_Recycle_Bin() { IMediaType contentType1 = MediaTypeBuilder.CreateSimpleMediaType("test1", "Test1"); MediaTypeService.Save(contentType1); IMediaType contentType2 = MediaTypeBuilder.CreateSimpleMediaType("test2", "Test2"); MediaTypeService.Save(contentType2); IMediaType contentType3 = MediaTypeBuilder.CreateSimpleMediaType("test3", "Test3"); MediaTypeService.Save(contentType3); IMediaType[] contentTypes = { contentType1, contentType2, contentType3 }; var parentId = -1; var ids = new List <int>(); for (var i = 0; i < 2; i++) { for (var index = 0; index < contentTypes.Length; index++) { var contentType = contentTypes[index]; var contentItem = MediaBuilder.CreateSimpleMedia(contentType, "MyName_" + index + "_" + i, parentId); MediaService.Save(contentItem); parentId = contentItem.Id; ids.Add(contentItem.Id); } } // delete the first content type, all other content of different content types should be in the recycle bin MediaTypeService.Delete(contentTypes[0]); var found = MediaService.GetByIds(ids); Assert.AreEqual(4, found.Count()); foreach (var content in found) { Assert.IsTrue(content.Trashed); } }