static void Main() { IBDRepository bdRepository = new BDRepository(); Application.EnableVisualStyles(); Application.SetCompatibleTextRenderingDefault(false); bool appliOuverte = true; while (appliOuverte) { IPersonneRepository personneRepository = new PersonneRepository(); IRelationRepository relationRepository = new RelationRepository(); LoginForm loginForm = new LoginForm(personneRepository, bdRepository); if (loginForm.ShowDialog() == DialogResult.OK) { int idUtilisateur = personneRepository.GetIdUtilisateur(loginForm.Login, loginForm.Password); MainForm mainForm = new MainForm(bdRepository, relationRepository, personneRepository, idUtilisateur); Application.Run(mainForm); } DeconnexionForm deconnexionForm = new DeconnexionForm(); if (deconnexionForm.ShowDialog() == DialogResult.No) { appliOuverte = false; } } }
public TreeContextExtension(TaxonomyTree tree, RelationRepository relationRepo, NHibernateBoxTransformation<RelationBoxMap, RelationEntity> relationTransformer) { _tree = tree; _relationRepo = relationRepo; this.relationTransformer = relationTransformer; }
private async Task GetMovieGenres(Movie movie) { var relationRepository = new RelationRepository(Configuration, MemoryCache); var isExist = MemoryCache.TryGetValue("CACHEMOVIERELATIONS" + movie.GetId(), out List <Relation> movieRelations); if (!isExist) { movieRelations = await relationRepository.GetRelationsByParent( movie.GetEntityCategoryId(), movie.GetId()); MemoryCache.Set("CACHEMOVIERELATIONS" + movie.GetId(), movieRelations); TrakkerCache.SaveCacheEntry("CACHEMOVIERELATIONS" + movie.GetId()); } var movieGenreRepository = new MovieGenreRepository(Configuration, MemoryCache); foreach (var relation in movieRelations) { if (relation.CategoryTo == MovieGenre.ENTITY_CATEGORY_ID) { movie.AddGenre(await movieGenreRepository.GetById(relation.EntityTo)); } } }
private RelationRepository CreateRepository(IDatabaseUnitOfWork unitOfWork, out RelationTypeRepository relationTypeRepository) { relationTypeRepository = new RelationTypeRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of <ILogger>(), SqlSyntax); var repository = new RelationRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of <ILogger>(), SqlSyntax, relationTypeRepository); return(repository); }
public TreeContextExtension(TaxonomyTree tree, RelationRepository relationRepo, NHibernateBoxTransformation <RelationBoxMap, RelationEntity> relationTransformer) { _tree = tree; _relationRepo = relationRepo; this.relationTransformer = relationTransformer; }
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); } }
private RelationRepository CreateRepository(IDatabaseUnitOfWork unitOfWork, out RelationTypeRepository relationTypeRepository) { relationTypeRepository = new RelationTypeRepository(unitOfWork, NullCacheProvider.Current); var repository = new RelationRepository(unitOfWork, NullCacheProvider.Current, relationTypeRepository); return(repository); }
public void CreateTestData() { _relateContent = new RelationType( "Relate Content on Copy", "relateContentOnCopy", true, Constants.ObjectTypes.Document, new Guid("C66BA18E-EAF3-4CFF-8A22-41B16D66A972")); _relateContentType = new RelationType( "Relate ContentType on Copy", "relateContentTypeOnCopy", true, Constants.ObjectTypes.DocumentType, new Guid("A2CB7800-F571-4787-9638-BC48539A0EFB")); using (IScope scope = ScopeProvider.CreateScope()) { var accessor = (IScopeAccessor)ScopeProvider; var relationTypeRepository = new RelationTypeRepository(accessor, AppCaches.Disabled, Mock.Of <ILogger <RelationTypeRepository> >()); var entityRepository = new EntityRepository(accessor, AppCaches.Disabled); var relationRepository = new RelationRepository(accessor, Mock.Of <ILogger <RelationRepository> >(), relationTypeRepository, entityRepository); relationTypeRepository.Save(_relateContent); relationTypeRepository.Save(_relateContentType); Template template = TemplateBuilder.CreateTextPageTemplate(); FileService.SaveTemplate(template); // Create and Save ContentType "umbTextpage" -> (NodeDto.NodeIdSeed) _contentType = ContentTypeBuilder.CreateSimpleContentType("umbTextpage", "Textpage", defaultTemplateId: template.Id); ContentTypeService.Save(_contentType); // Create and Save Content "Homepage" based on "umbTextpage" -> (NodeDto.NodeIdSeed + 1) _textpage = ContentBuilder.CreateSimpleContent(_contentType); ContentService.Save(_textpage, 0); // Create and Save Content "Text Page 1" based on "umbTextpage" -> (NodeDto.NodeIdSeed + 2) _subpage = ContentBuilder.CreateSimpleContent(_contentType, "Text Page 1", _textpage.Id); ContentService.Save(_subpage, 0); // Create and Save Content "Text Page 1" based on "umbTextpage" -> (NodeDto.NodeIdSeed + 3) _subpage2 = ContentBuilder.CreateSimpleContent(_contentType, "Text Page 2", _textpage.Id); ContentService.Save(_subpage2, 0); _relation = new Relation(_textpage.Id, _subpage.Id, _relateContent) { Comment = string.Empty }; _relation2 = new Relation(_textpage.Id, _subpage2.Id, _relateContent) { Comment = string.Empty }; relationRepository.Save(_relation); relationRepository.Save(_relation2); scope.Complete(); } }
public void Initialize() { RepositoryTest.InitDB(); relationRepository = new RelationRepository(); bdRepository = new BDRepository(); personneRepository = new PersonneRepository(); }
private RelationRepository CreateRepository(IScopeProvider provider, out RelationTypeRepository relationTypeRepository) { var accessor = (IScopeAccessor)provider; relationTypeRepository = new RelationTypeRepository(accessor, CacheHelper.Disabled, Mock.Of <ILogger>()); var repository = new RelationRepository(accessor, Mock.Of <ILogger>(), relationTypeRepository); return(repository); }
public MediaListPopulating(IConfiguration configuration, IMemoryCache cache) { _configuration = configuration; _cache = cache; _movieRepository = new MovieRepository(configuration, cache); _relationRepository = new RelationRepository(configuration, _cache); _mediaListRepository = new MediaListRepository(configuration, _cache); _tvShowRepository = new TVShowRepository(configuration, _cache); }
public CommonsService(ILog log, IComponentContext context, TaxonomyTree tree, RelationRepository relRepo) { this.context = context; this.log = log; _tree = tree; _relRepo = relRepo; SetupTimer(); }
public void CreateTestData() { var relateContent = new RelationType( "Relate Content on Copy", "relateContentOnCopy", true, Constants.ObjectTypes.Document, new Guid("C66BA18E-EAF3-4CFF-8A22-41B16D66A972")); var relateContentType = new RelationType("Relate ContentType on Copy", "relateContentTypeOnCopy", true, Constants.ObjectTypes.DocumentType, new Guid("A2CB7800-F571-4787-9638-BC48539A0EFB")); var provider = TestObjects.GetScopeProvider(Logger); using (var scope = provider.CreateScope()) { var accessor = (IScopeAccessor)provider; var relationTypeRepository = new RelationTypeRepository(accessor, AppCaches.Disabled, Mock.Of <ILogger>()); var entityRepository = new EntityRepository(accessor); var relationRepository = new RelationRepository(accessor, Mock.Of <ILogger>(), relationTypeRepository, entityRepository); relationTypeRepository.Save(relateContent); relationTypeRepository.Save(relateContentType); //Create and Save ContentType "umbTextpage" -> (NodeDto.NodeIdSeed) ContentType contentType = MockedContentTypes.CreateSimpleContentType("umbTextpage", "Textpage"); ServiceContext.FileService.SaveTemplate(contentType.DefaultTemplate); // else, FK violation on contentType! ServiceContext.ContentTypeService.Save(contentType); //Create and Save Content "Homepage" based on "umbTextpage" -> (NodeDto.NodeIdSeed + 1) Content textpage = MockedContent.CreateSimpleContent(contentType); ServiceContext.ContentService.Save(textpage, 0); //Create and Save Content "Text Page 1" based on "umbTextpage" -> (NodeDto.NodeIdSeed + 2) Content subpage = MockedContent.CreateSimpleContent(contentType, "Text Page 1", textpage.Id); ServiceContext.ContentService.Save(subpage, 0); //Create and Save Content "Text Page 1" based on "umbTextpage" -> (NodeDto.NodeIdSeed + 3) Content subpage2 = MockedContent.CreateSimpleContent(contentType, "Text Page 2", textpage.Id); ServiceContext.ContentService.Save(subpage2, 0); var relation = new Relation(textpage.Id, subpage.Id, relateContent) { Comment = string.Empty }; var relation2 = new Relation(textpage.Id, subpage2.Id, relateContent) { Comment = string.Empty }; relationRepository.Save(relation); relationRepository.Save(relation2); scope.Complete(); } }
public RelationType(RelationRepository repository) { Name = "Relation"; Field(x => x.Id); Field(x => x.Dashboard); Field(x => x.Date); Field(x => x.Time); Field(x => x.IsActive); Field(x => x.userId); Field(x => x.projectId); }
public void CreateTestData() { var relateContent = new RelationType(new Guid(Constants.ObjectTypes.Document), new Guid("C66BA18E-EAF3-4CFF-8A22-41B16D66A972"), "relateContentOnCopy") { IsBidirectional = true, Name = "Relate Content on Copy" }; var relateContentType = new RelationType(new Guid(Constants.ObjectTypes.DocumentType), new Guid("A2CB7800-F571-4787-9638-BC48539A0EFB"), "relateContentTypeOnCopy") { IsBidirectional = true, Name = "Relate ContentType on Copy" }; var provider = new PetaPocoUnitOfWorkProvider(); var unitOfWork = provider.GetUnitOfWork(); var relationTypeRepository = new RelationTypeRepository(unitOfWork); var relationRepository = new RelationRepository(unitOfWork, NullCacheProvider.Current, relationTypeRepository); relationTypeRepository.AddOrUpdate(relateContent); relationTypeRepository.AddOrUpdate(relateContentType); unitOfWork.Commit(); //Create and Save ContentType "umbTextpage" -> 1045 ContentType contentType = MockedContentTypes.CreateSimpleContentType("umbTextpage", "Textpage"); ServiceContext.ContentTypeService.Save(contentType); //Create and Save Content "Homepage" based on "umbTextpage" -> 1046 Content textpage = MockedContent.CreateSimpleContent(contentType); ServiceContext.ContentService.Save(textpage, 0); //Create and Save Content "Text Page 1" based on "umbTextpage" -> 1047 Content subpage = MockedContent.CreateSimpleContent(contentType, "Text Page 1", textpage.Id); ServiceContext.ContentService.Save(subpage, 0); //Create and Save Content "Text Page 1" based on "umbTextpage" -> 1048 Content subpage2 = MockedContent.CreateSimpleContent(contentType, "Text Page 2", textpage.Id); ServiceContext.ContentService.Save(subpage2, 0); var relation = new Relation(textpage.Id, subpage.Id, relateContent) { Comment = string.Empty }; var relation2 = new Relation(textpage.Id, subpage2.Id, relateContent) { Comment = string.Empty }; relationRepository.AddOrUpdate(relation); relationRepository.AddOrUpdate(relation2); unitOfWork.Commit(); }
public void Can_Instantiate_Repository() { // Arrange var provider = new PetaPocoUnitOfWorkProvider(); var unitOfWork = provider.GetUnitOfWork(); // Act var repositoryType = new RelationTypeRepository(unitOfWork); var repository = new RelationRepository(unitOfWork, NullCacheProvider.Current, repositoryType); // Assert Assert.That(repository, Is.Not.Null); }
public void Can_Instantiate_Repository() { // Arrange var provider = new PetaPocoUnitOfWorkProvider(); var unitOfWork = provider.GetUnitOfWork(); // Act var repositoryType = new RelationTypeRepository(unitOfWork); var repository = new RelationRepository(unitOfWork, NullCacheProvider.Current, repositoryType); // Assert Assert.That(repository, Is.Not.Null); }
public void Get_Paged_Child_Entities_By_Parent_Id() { CreateTestDataForPagingTests(out List <IContent> createdContent, out List <IMember> createdMembers, out _); using (IScope scope = ScopeProvider.CreateScope()) { RelationRepository repository = CreateRepository(ScopeProvider, out _); // Get parent entities for child id var parents = repository.GetPagedChildEntitiesByParentId(createdContent[0].Id, 0, 6, out long totalRecords).ToList(); Assert.AreEqual(6, totalRecords); Assert.AreEqual(6, parents.Count); // Add the next page parents.AddRange(repository.GetPagedChildEntitiesByParentId(createdContent[0].Id, 1, 6, out totalRecords)); Assert.AreEqual(6, totalRecords); Assert.AreEqual(6, parents.Count); var contentEntities = parents.OfType <IDocumentEntitySlim>().ToList(); var mediaEntities = parents.OfType <IMediaEntitySlim>().ToList(); var memberEntities = parents.OfType <IMemberEntitySlim>().ToList(); Assert.AreEqual(3, contentEntities.Count); Assert.AreEqual(3, mediaEntities.Count); Assert.AreEqual(0, memberEntities.Count); // only of a certain type parents.AddRange(repository.GetPagedChildEntitiesByParentId(createdContent[0].Id, 0, 100, out totalRecords, UmbracoObjectTypes.Media.GetGuid())); Assert.AreEqual(3, totalRecords); parents.AddRange(repository.GetPagedChildEntitiesByParentId(createdMembers[0].Id, 0, 100, out totalRecords, UmbracoObjectTypes.Media.GetGuid())); Assert.AreEqual(3, totalRecords); parents.AddRange(repository.GetPagedChildEntitiesByParentId(createdContent[0].Id, 0, 100, out totalRecords, UmbracoObjectTypes.Member.GetGuid())); Assert.AreEqual(0, totalRecords); // Test getting relations of specified relation types IRelationType relatedMediaRelType = RelationService.GetRelationTypeByAlias(Constants.Conventions.RelationTypes.RelatedMediaAlias); IRelationType relatedContentRelType = RelationService.GetRelationTypeByAlias(Constants.Conventions.RelationTypes.RelatedDocumentAlias); parents = repository.GetPagedChildEntitiesByParentId(createdContent[0].Id, 0, 6, out totalRecords, new int[] { relatedContentRelType.Id, relatedMediaRelType.Id }).ToList(); Assert.AreEqual(3, totalRecords); Assert.AreEqual(3, parents.Count); parents = repository.GetPagedChildEntitiesByParentId(createdContent[0].Id, 1, 6, out totalRecords, new int[] { relatedContentRelType.Id, relatedMediaRelType.Id }).ToList(); Assert.AreEqual(3, totalRecords); Assert.AreEqual(0, parents.Count); } }
public void Can_Perform_Count_On_RelationRepository() { // Arrange using (IScope scope = ScopeProvider.CreateScope()) { RelationRepository repository = CreateRepository(ScopeProvider, out RelationTypeRepository repositoryType); // Act IQuery <IRelation> query = ScopeProvider.CreateQuery <IRelation>().Where(x => x.ParentId == _textpage.Id); int count = repository.Count(query); // Assert Assert.That(count, Is.EqualTo(2)); } }
public void Can_Perform_Exists_On_RelationRepository() { // Arrange using (IScope scope = ScopeProvider.CreateScope()) { RelationRepository repository = CreateRepository(ScopeProvider, out RelationTypeRepository repositoryType); // Act bool exists = repository.Exists(2); bool doesntExist = repository.Exists(5); // Assert Assert.That(exists, Is.True); Assert.That(doesntExist, Is.False); } }
public void Can_Perform_Exists_On_RelationRepository() { // Arrange var provider = new PetaPocoUnitOfWorkProvider(); var unitOfWork = provider.GetUnitOfWork(); var repositoryType = new RelationTypeRepository(unitOfWork); var repository = new RelationRepository(unitOfWork, NullCacheProvider.Current, repositoryType); // Act var exists = repository.Exists(2); var doesntExist = repository.Exists(5); // Assert Assert.That(exists, Is.True); Assert.That(doesntExist, Is.False); }
public void Can_Perform_Count_On_RelationRepository() { // Arrange var provider = new PetaPocoUnitOfWorkProvider(); var unitOfWork = provider.GetUnitOfWork(); var repositoryType = new RelationTypeRepository(unitOfWork); var repository = new RelationRepository(unitOfWork, NullCacheProvider.Current, repositoryType); // Act var query = Query <Relation> .Builder.Where(x => x.ParentId == 1046); int count = repository.Count(query); // Assert Assert.That(count, Is.EqualTo(2)); }
public void Can_Perform_GetAll_With_Params_On_RelationRepository() { // Arrange using (IScope scope = ScopeProvider.CreateScope()) { RelationRepository repository = CreateRepository(ScopeProvider, out RelationTypeRepository repositoryType); // Act IEnumerable <IRelation> relations = repository.GetMany(1, 2); // Assert Assert.That(relations, Is.Not.Null); Assert.That(relations.Any(), Is.True); Assert.That(relations.Any(x => x == null), Is.False); Assert.That(relations.Count(), Is.EqualTo(2)); } }
private DocumentRepository CreateDocumentRepository(IScopeProvider provider) { var accessor = (IScopeAccessor)provider; var tRepository = new TemplateRepository(accessor, AppCaches.Disabled, Logger, TestObjects.GetFileSystemsMock()); var tagRepo = new TagRepository(accessor, AppCaches.Disabled, Logger); var commonRepository = new ContentTypeCommonRepository(accessor, tRepository, AppCaches); var languageRepository = new LanguageRepository(accessor, AppCaches.Disabled, Logger); var ctRepository = new ContentTypeRepository(accessor, AppCaches.Disabled, Logger, commonRepository, languageRepository); var relationTypeRepository = new RelationTypeRepository(accessor, AppCaches.Disabled, Logger); var entityRepository = new EntityRepository(accessor); var relationRepository = new RelationRepository(accessor, Logger, relationTypeRepository, entityRepository); var propertyEditors = new Lazy <PropertyEditorCollection>(() => new PropertyEditorCollection(new DataEditorCollection(Enumerable.Empty <IDataEditor>()))); var dataValueReferences = new DataValueReferenceFactoryCollection(Enumerable.Empty <IDataValueReferenceFactory>()); var repository = new DocumentRepository(accessor, AppCaches.Disabled, Logger, ctRepository, tRepository, tagRepo, languageRepository, relationRepository, relationTypeRepository, propertyEditors, dataValueReferences); return(repository); }
public void Can_Perform_Add_On_RelationRepository() { // Arrange using (IScope scope = ScopeProvider.CreateScope()) { RelationRepository repository = CreateRepository(ScopeProvider, out RelationTypeRepository repositoryType); // Act IRelationType relationType = repositoryType.Get(1); var relation = new Relation(_textpage.Id, _subpage.Id, relationType); repository.Save(relation); // Assert Assert.That(relation, Is.Not.Null); Assert.That(relation.HasIdentity, Is.True); } }
public void Can_Perform_Delete_On_RelationRepository() { // Arrange using (IScope scope = ScopeProvider.CreateScope()) { RelationRepository repository = CreateRepository(ScopeProvider, out RelationTypeRepository repositoryType); // Act IRelation relation = repository.Get(2); repository.Delete(relation); bool exists = repository.Exists(2); // Assert Assert.That(exists, Is.False); } }
public void Can_Perform_GetAll_With_Params_On_RelationRepository() { // Arrange var provider = new PetaPocoUnitOfWorkProvider(); var unitOfWork = provider.GetUnitOfWork(); var repositoryType = new RelationTypeRepository(unitOfWork); var repository = new RelationRepository(unitOfWork, NullCacheProvider.Current, repositoryType); // Act var relations = repository.GetAll(1, 2); // Assert Assert.That(relations, Is.Not.Null); Assert.That(relations.Any(), Is.True); Assert.That(relations.Any(x => x == null), Is.False); Assert.That(relations.Count(), Is.EqualTo(2)); }
public void Can_Perform_Get_On_RelationRepository() { // Arrange using (IScope scope = ScopeProvider.CreateScope()) { RelationRepository repository = CreateRepository(ScopeProvider, out RelationTypeRepository repositoryType); // Act IRelation relation = repository.Get(1); // Assert Assert.That(relation, Is.Not.Null); Assert.That(relation.HasIdentity, Is.True); Assert.That(relation.ChildId, Is.EqualTo(_subpage.Id)); Assert.That(relation.ParentId, Is.EqualTo(_textpage.Id)); Assert.That(relation.RelationType.Alias, Is.EqualTo("relateContentOnCopy")); } }
public void Can_Perform_GetByQuery_On_RelationRepository() { // Arrange using (IScope scope = ScopeProvider.CreateScope()) { RelationRepository repository = CreateRepository(ScopeProvider, out RelationTypeRepository repositoryType); // Act IQuery <IRelation> query = ScopeProvider.CreateQuery <IRelation>().Where(x => x.RelationTypeId == _relateContent.Id); IEnumerable <IRelation> relations = repository.Get(query); // Assert Assert.That(relations, Is.Not.Null); Assert.That(relations.Any(), Is.True); Assert.That(relations.Any(x => x == null), Is.False); Assert.That(relations.Count(), Is.EqualTo(2)); } }
public void Can_Perform_Add_On_RelationRepository() { // Arrange var provider = new PetaPocoUnitOfWorkProvider(); var unitOfWork = provider.GetUnitOfWork(); var repositoryType = new RelationTypeRepository(unitOfWork); var repository = new RelationRepository(unitOfWork, NullCacheProvider.Current, repositoryType); // Act var relationType = repositoryType.Get(1); var relation = new Relation(1047, 1048, relationType); repository.AddOrUpdate(relation); unitOfWork.Commit(); // Assert Assert.That(relation, Is.Not.Null); Assert.That(relation.HasIdentity, Is.True); }
public void Can_Perform_Get_On_RelationRepository() { // Arrange var provider = new PetaPocoUnitOfWorkProvider(); var unitOfWork = provider.GetUnitOfWork(); var repositoryType = new RelationTypeRepository(unitOfWork); var repository = new RelationRepository(unitOfWork, NullCacheProvider.Current, repositoryType); // Act var relation = repository.Get(1); // Assert Assert.That(relation, Is.Not.Null); Assert.That(relation.HasIdentity, Is.True); Assert.That(relation.ChildId, Is.EqualTo(1047)); Assert.That(relation.ParentId, Is.EqualTo(1046)); Assert.That(relation.RelationType.Alias, Is.EqualTo("relateContentOnCopy")); }
public void Can_Perform_Delete_When_Assigned_To_Doc() { // Arrange IScopeProvider provider = ScopeProvider; var scopeAccessor = (IScopeAccessor)provider; IDataTypeService dataTypeService = GetRequiredService <IDataTypeService>(); IFileService fileService = GetRequiredService <IFileService>(); using (provider.CreateScope()) { ITemplateRepository templateRepository = CreateRepository(provider); var globalSettings = new GlobalSettings(); var serializer = new JsonNetSerializer(); var tagRepository = new TagRepository(scopeAccessor, AppCaches.Disabled, LoggerFactory.CreateLogger <TagRepository>()); var commonRepository = new ContentTypeCommonRepository(scopeAccessor, templateRepository, AppCaches, ShortStringHelper); var languageRepository = new LanguageRepository(scopeAccessor, AppCaches.Disabled, LoggerFactory.CreateLogger <LanguageRepository>(), Microsoft.Extensions.Options.Options.Create(globalSettings)); var contentTypeRepository = new ContentTypeRepository(scopeAccessor, AppCaches.Disabled, LoggerFactory.CreateLogger <ContentTypeRepository>(), commonRepository, languageRepository, ShortStringHelper); var relationTypeRepository = new RelationTypeRepository(scopeAccessor, AppCaches.Disabled, LoggerFactory.CreateLogger <RelationTypeRepository>()); var entityRepository = new EntityRepository(scopeAccessor, AppCaches.Disabled); var relationRepository = new RelationRepository(scopeAccessor, LoggerFactory.CreateLogger <RelationRepository>(), relationTypeRepository, entityRepository); var propertyEditors = new PropertyEditorCollection(new DataEditorCollection(() => Enumerable.Empty <IDataEditor>())); var dataValueReferences = new DataValueReferenceFactoryCollection(() => Enumerable.Empty <IDataValueReferenceFactory>()); var contentRepo = new DocumentRepository(scopeAccessor, AppCaches.Disabled, LoggerFactory.CreateLogger <DocumentRepository>(), LoggerFactory, contentTypeRepository, templateRepository, tagRepository, languageRepository, relationRepository, relationTypeRepository, propertyEditors, dataValueReferences, dataTypeService, serializer, Mock.Of <IEventAggregator>()); Template template = TemplateBuilder.CreateTextPageTemplate(); fileService.SaveTemplate(template); // else, FK violation on contentType! ContentType contentType = ContentTypeBuilder.CreateSimpleContentType("umbTextpage2", "Textpage", defaultTemplateId: template.Id); contentTypeRepository.Save(contentType); Content textpage = ContentBuilder.CreateSimpleContent(contentType); contentRepo.Save(textpage); textpage.TemplateId = template.Id; contentRepo.Save(textpage); // Act ITemplate templates = templateRepository.Get("textPage"); templateRepository.Delete(templates); // Assert Assert.IsNull(templateRepository.Get("textPage")); } }
public void Can_Perform_Delete_On_RelationRepository() { // Arrange var provider = new PetaPocoUnitOfWorkProvider(); var unitOfWork = provider.GetUnitOfWork(); var repositoryType = new RelationTypeRepository(unitOfWork); var repository = new RelationRepository(unitOfWork, NullCacheProvider.Current, repositoryType); // Act var relation = repository.Get(2); repository.Delete(relation); unitOfWork.Commit(); var exists = repository.Exists(2); // Assert Assert.That(exists, Is.False); }
public void Can_Perform_Update_On_RelationRepository() { // Arrange var provider = new PetaPocoUnitOfWorkProvider(); var unitOfWork = provider.GetUnitOfWork(); var repositoryType = new RelationTypeRepository(unitOfWork); var repository = new RelationRepository(unitOfWork, NullCacheProvider.Current, repositoryType); // Act var relation = repository.Get(1); relation.Comment = "This relation has been updated"; repository.AddOrUpdate(relation); unitOfWork.Commit(); var relationUpdated = repository.Get(1); // Assert Assert.That(relationUpdated, Is.Not.Null); Assert.That(relationUpdated.Comment, Is.EqualTo("This relation has been updated")); Assert.AreNotEqual(relationUpdated.UpdateDate, relation.UpdateDate); }
public void Can_Perform_Exists_On_RelationRepository() { // Arrange var provider = new PetaPocoUnitOfWorkProvider(); var unitOfWork = provider.GetUnitOfWork(); var repositoryType = new RelationTypeRepository(unitOfWork); var repository = new RelationRepository(unitOfWork, NullCacheProvider.Current, repositoryType); // Act var exists = repository.Exists(2); var doesntExist = repository.Exists(5); // Assert Assert.That(exists, Is.True); Assert.That(doesntExist, Is.False); }
public void Can_Perform_Delete_On_RelationRepository() { // Arrange var provider = new PetaPocoUnitOfWorkProvider(); var unitOfWork = provider.GetUnitOfWork(); var repositoryType = new RelationTypeRepository(unitOfWork); var repository = new RelationRepository(unitOfWork, NullCacheProvider.Current, repositoryType); // Act var relation = repository.Get(2); repository.Delete(relation); unitOfWork.Commit(); var exists = repository.Exists(2); // Assert Assert.That(exists, Is.False); }
public void Can_Perform_Get_On_RelationRepository() { // Arrange var provider = new PetaPocoUnitOfWorkProvider(); var unitOfWork = provider.GetUnitOfWork(); var repositoryType = new RelationTypeRepository(unitOfWork); var repository = new RelationRepository(unitOfWork, NullCacheProvider.Current, repositoryType); // Act var relation = repository.Get(1); // Assert Assert.That(relation, Is.Not.Null); Assert.That(relation.HasIdentity, Is.True); Assert.That(relation.ChildId, Is.EqualTo(1047)); Assert.That(relation.ParentId, Is.EqualTo(1046)); Assert.That(relation.RelationType.Alias, Is.EqualTo("relateContentOnCopy")); }
private RelationRepository CreateRepository(IDatabaseUnitOfWork unitOfWork, out RelationTypeRepository relationTypeRepository) { relationTypeRepository = new RelationTypeRepository(unitOfWork, NullCacheProvider.Current); var repository = new RelationRepository(unitOfWork, NullCacheProvider.Current, relationTypeRepository); return repository; }
public void CreateTestData() { var relateContent = new RelationType(new Guid(Constants.ObjectTypes.Document), new Guid("C66BA18E-EAF3-4CFF-8A22-41B16D66A972"), "relateContentOnCopy") { IsBidirectional = true, Name = "Relate Content on Copy" }; var relateContentType = new RelationType(new Guid(Constants.ObjectTypes.DocumentType), new Guid("A2CB7800-F571-4787-9638-BC48539A0EFB"), "relateContentTypeOnCopy") { IsBidirectional = true, Name = "Relate ContentType on Copy" }; var provider = new PetaPocoUnitOfWorkProvider(); var unitOfWork = provider.GetUnitOfWork(); var relationTypeRepository = new RelationTypeRepository(unitOfWork); var relationRepository = new RelationRepository(unitOfWork, NullCacheProvider.Current, relationTypeRepository); relationTypeRepository.AddOrUpdate(relateContent); relationTypeRepository.AddOrUpdate(relateContentType); unitOfWork.Commit(); //Create and Save ContentType "umbTextpage" -> 1045 ContentType contentType = MockedContentTypes.CreateSimpleContentType("umbTextpage", "Textpage"); ServiceContext.ContentTypeService.Save(contentType); //Create and Save Content "Homepage" based on "umbTextpage" -> 1046 Content textpage = MockedContent.CreateSimpleContent(contentType); ServiceContext.ContentService.Save(textpage, 0); //Create and Save Content "Text Page 1" based on "umbTextpage" -> 1047 Content subpage = MockedContent.CreateSimpleContent(contentType, "Text Page 1", textpage.Id); ServiceContext.ContentService.Save(subpage, 0); //Create and Save Content "Text Page 1" based on "umbTextpage" -> 1048 Content subpage2 = MockedContent.CreateSimpleContent(contentType, "Text Page 2", textpage.Id); ServiceContext.ContentService.Save(subpage2, 0); var relation = new Relation(textpage.Id, subpage.Id, relateContent) { Comment = string.Empty }; var relation2 = new Relation(textpage.Id, subpage2.Id, relateContent) { Comment = string.Empty }; relationRepository.AddOrUpdate(relation); relationRepository.AddOrUpdate(relation2); unitOfWork.Commit(); }
public void Can_Delete_Content_And_Verify_Relation_Is_Removed() { // Arrange var provider = new PetaPocoUnitOfWorkProvider(); var unitOfWork = provider.GetUnitOfWork(); var repositoryType = new RelationTypeRepository(unitOfWork); var repository = new RelationRepository(unitOfWork, NullCacheProvider.Current, repositoryType); var content = ServiceContext.ContentService.GetById(1047); ServiceContext.ContentService.Delete(content, 0); // Act var shouldntExist = repository.Exists(1); var shouldExist = repository.Exists(2); // Assert Assert.That(shouldntExist, Is.False); Assert.That(shouldExist, Is.True); }
public void Can_Perform_GetByQuery_On_RelationRepository() { // Arrange var provider = new PetaPocoUnitOfWorkProvider(); var unitOfWork = provider.GetUnitOfWork(); var repositoryType = new RelationTypeRepository(unitOfWork); var repository = new RelationRepository(unitOfWork, NullCacheProvider.Current, repositoryType); // Act var query = Query<Relation>.Builder.Where(x => x.RelationTypeId == 2); var relations = repository.GetByQuery(query); // Assert Assert.That(relations, Is.Not.Null); Assert.That(relations.Any(), Is.True); Assert.That(relations.Any(x => x == null), Is.False); Assert.That(relations.Count(), Is.EqualTo(2)); }
public void Can_Perform_Count_On_RelationRepository() { // Arrange var provider = new PetaPocoUnitOfWorkProvider(); var unitOfWork = provider.GetUnitOfWork(); var repositoryType = new RelationTypeRepository(unitOfWork); var repository = new RelationRepository(unitOfWork, NullCacheProvider.Current, repositoryType); // Act var query = Query<Relation>.Builder.Where(x => x.ParentId == 1046); int count = repository.Count(query); // Assert Assert.That(count, Is.EqualTo(2)); }
public void Can_Perform_GetAll_With_Params_On_RelationRepository() { // Arrange var provider = new PetaPocoUnitOfWorkProvider(); var unitOfWork = provider.GetUnitOfWork(); var repositoryType = new RelationTypeRepository(unitOfWork); var repository = new RelationRepository(unitOfWork, NullCacheProvider.Current, repositoryType); // Act var relations = repository.GetAll(1, 2); // Assert Assert.That(relations, Is.Not.Null); Assert.That(relations.Any(), Is.True); Assert.That(relations.Any(x => x == null), Is.False); Assert.That(relations.Count(), Is.EqualTo(2)); }