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;
 }
Example #3
0
        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));
                }
            }
        }
Example #4
0
        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);
        }
Example #5
0
 public TreeContextExtension(TaxonomyTree tree, RelationRepository relationRepo,
                             NHibernateBoxTransformation <RelationBoxMap, RelationEntity> relationTransformer)
 {
     _tree                    = tree;
     _relationRepo            = relationRepo;
     this.relationTransformer = relationTransformer;
 }
Example #6
0
        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);
            }
        }
Example #7
0
        private RelationRepository CreateRepository(IDatabaseUnitOfWork unitOfWork, out RelationTypeRepository relationTypeRepository)
        {
            relationTypeRepository = new RelationTypeRepository(unitOfWork, NullCacheProvider.Current);
            var repository = new RelationRepository(unitOfWork, NullCacheProvider.Current, relationTypeRepository);

            return(repository);
        }
Example #8
0
        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);
        }
Example #11
0
 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();
            }
        }
Example #14
0
 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);
 }
Example #15
0
        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);
        }
Example #18
0
        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);
            }
        }
Example #19
0
        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));
            }
        }
Example #20
0
        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));
        }
Example #23
0
        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);
        }
Example #25
0
        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);
            }
        }
Example #26
0
        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));
        }
Example #28
0
        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"));
            }
        }
Example #29
0
        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));
        }