public void Can_Perform_Delete_With_Heirarchy_On_ContentTypeRepository() { // Arrange IScopeProvider provider = ScopeProvider; using (IScope scope = provider.CreateScope()) { ContentTypeRepository repository = ContentTypeRepository; ContentType ctMain = ContentTypeBuilder.CreateSimpleContentType(defaultTemplateId: 0); ContentType ctChild1 = ContentTypeBuilder.CreateSimpleContentType("child1", "Child 1", ctMain, randomizeAliases: true, defaultTemplateId: 0); ContentType ctChild2 = ContentTypeBuilder.CreateSimpleContentType("child2", "Child 2", ctChild1, randomizeAliases: true, defaultTemplateId: 0); repository.Save(ctMain); repository.Save(ctChild1); repository.Save(ctChild2); // Act IContentType resolvedParent = repository.Get(ctMain.Id); repository.Delete(resolvedParent); // Assert Assert.That(repository.Exists(ctMain.Id), Is.False); Assert.That(repository.Exists(ctChild1.Id), Is.False); Assert.That(repository.Exists(ctChild2.Id), Is.False); } }
public void Getting_1000_Cached_Items() { // Arrange var contentType = ServiceContext.ContentTypeService.GetContentType(NodeDto.NodeIdSeed); var pages = MockedContent.CreateTextpageContent(contentType, -1, 1000); ServiceContext.ContentService.Save(pages, 0); var provider = new PetaPocoUnitOfWorkProvider(Logger); var unitOfWork = provider.GetUnitOfWork(); using (var tRepository = new TemplateRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Logger, SqlSyntax, Mock.Of <IFileSystem>(), Mock.Of <IFileSystem>(), Mock.Of <ITemplatesSection>())) using (var tagRepo = new TagRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Logger, SqlSyntax)) using (var ctRepository = new ContentTypeRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Logger, SqlSyntax, tRepository)) using (var repository = new ContentRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Logger, SqlSyntax, ctRepository, tRepository, tagRepo, Mock.Of <IContentSection>())) { // Act var contents = repository.GetAll(); Stopwatch watch = Stopwatch.StartNew(); var contentsCached = repository.GetAll(); watch.Stop(); var elapsed = watch.ElapsedMilliseconds; Debug.Print("1000 content items retrieved in {0} ms with caching", elapsed); // Assert //Assert.That(contentsCached.Any(x => x.HasIdentity == false), Is.False); //Assert.That(contentsCached.Any(x => x == null), Is.False); //Assert.That(contentsCached.Count(), Is.EqualTo(contents.Count())); } }
private ContentRepository CreateRepository(IDatabaseUnitOfWork unitOfWork, out ContentTypeRepository contentTypeRepository) { var templateRepository = new TemplateRepository(unitOfWork, NullCacheProvider.Current); contentTypeRepository = new ContentTypeRepository(unitOfWork, NullCacheProvider.Current, templateRepository); var repository = new ContentRepository(unitOfWork, NullCacheProvider.Current, contentTypeRepository, templateRepository); return repository; }
public static IList<ContentType> CreateTestContentTypes() { List<ContentType> results = new List<ContentType>(); ContentTypeRepository repo = new ContentTypeRepository(); ContentType item = new ContentType() { Text = "text" }; results.Add(item); repo.Add(item); item = new ContentType() { Text = "html" }; results.Add(item); repo.Add(item); item = new ContentType() { Text = "xhtml" }; results.Add(item); repo.Add(item); repo.Save(); return results; }
public void Can_Perform_Delete_When_Assigned_To_Doc() { // Arrange using (ScopeProvider.CreateScope()) { var templateRepository = CreateRepository(ScopeProvider); var tagRepository = new TagRepository((IScopeAccessor)ScopeProvider, AppCaches.Disabled, Logger); var contentTypeRepository = new ContentTypeRepository((IScopeAccessor)ScopeProvider, AppCaches.Disabled, Logger, templateRepository); var languageRepository = new LanguageRepository((IScopeAccessor)ScopeProvider, AppCaches.Disabled, Logger); var contentRepo = new DocumentRepository((IScopeAccessor)ScopeProvider, AppCaches.Disabled, Logger, contentTypeRepository, templateRepository, tagRepository, languageRepository); var contentType = MockedContentTypes.CreateSimpleContentType("umbTextpage2", "Textpage"); ServiceContext.FileService.SaveTemplate(contentType.DefaultTemplate); // else, FK violation on contentType! contentTypeRepository.Save(contentType); var textpage = MockedContent.CreateSimpleContent(contentType); contentRepo.Save(textpage); var template = new Template("test", "test") { Content = @"<%@ Master Language=""C#"" %>" }; templateRepository.Save(template); textpage.TemplateId = template.Id; contentRepo.Save(textpage); // Act var templates = templateRepository.Get("test"); templateRepository.Delete(templates); // Assert Assert.IsNull(templateRepository.Get("test")); } }
public void Can_Verify_AllowedChildContentTypes_On_ContentType() { // Arrange IScopeProvider provider = ScopeProvider; using (IScope scope = provider.CreateScope()) { ContentTypeRepository repository = ContentTypeRepository; ContentType subpageContentType = ContentTypeBuilder.CreateSimpleContentType("umbSubpage", "Subpage"); ContentType simpleSubpageContentType = ContentTypeBuilder.CreateSimpleContentType("umbSimpleSubpage", "Simple Subpage"); repository.Save(subpageContentType); repository.Save(simpleSubpageContentType); // Act IContentType contentType = repository.Get(_simpleContentType.Id); contentType.AllowedContentTypes = new List <ContentTypeSort> { new ContentTypeSort(new Lazy <int>(() => subpageContentType.Id), 0, subpageContentType.Alias), new ContentTypeSort(new Lazy <int>(() => simpleSubpageContentType.Id), 1, simpleSubpageContentType.Alias) }; repository.Save(contentType); // Assert IContentType updated = repository.Get(_simpleContentType.Id); Assert.That(updated.AllowedContentTypes.Any(), Is.True); Assert.That(updated.AllowedContentTypes.Any(x => x.Alias == subpageContentType.Alias), Is.True); Assert.That(updated.AllowedContentTypes.Any(x => x.Alias == simpleSubpageContentType.Alias), Is.True); } }
public void Can_Perform_Query_On_ContentTypeRepository_Sort_By_Name() { IContentType contentType; // Arrange IScopeProvider provider = ScopeProvider; using (IScope scope = provider.CreateScope()) { ContentTypeRepository repository = ContentTypeRepository; contentType = repository.Get(_textpageContentType.Id); ContentType child1 = ContentTypeBuilder.CreateSimpleContentType("abc", "abc", contentType, randomizeAliases: true, defaultTemplateId: 0); repository.Save(child1); ContentType child3 = ContentTypeBuilder.CreateSimpleContentType("zyx", "zyx", contentType, randomizeAliases: true, defaultTemplateId: 0); repository.Save(child3); ContentType child2 = ContentTypeBuilder.CreateSimpleContentType("a123", "a123", contentType, randomizeAliases: true, defaultTemplateId: 0); repository.Save(child2); scope.Complete(); } using (IScope scope = provider.CreateScope()) { ContentTypeRepository repository = ContentTypeRepository; // Act IEnumerable <IContentType> contentTypes = repository.Get(scope.SqlContext.Query <IContentType>().Where(x => x.ParentId == contentType.Id)); // Assert Assert.That(contentTypes.Count(), Is.EqualTo(3)); Assert.AreEqual("a123", contentTypes.ElementAt(0).Name); Assert.AreEqual("abc", contentTypes.ElementAt(1).Name); Assert.AreEqual("zyx", contentTypes.ElementAt(2).Name); } }
private ContentTypeRepository CreateRepository(IScopeAccessor scopeAccessor) { var templateRepository = new TemplateRepository(scopeAccessor, CacheHelper.Disabled, Logger, Mock.Of <ITemplatesSection>(), TestObjects.GetFileSystemsMock()); var contentTypeRepository = new ContentTypeRepository(scopeAccessor, CacheHelper.Disabled, Logger, templateRepository); return(contentTypeRepository); }
public void Maps_Templates_Correctly() { // Arrange IScopeProvider provider = ScopeProvider; using (IScope scope = provider.CreateScope()) { var templateRepo = new TemplateRepository((IScopeAccessor)provider, AppCaches.Disabled, LoggerFactory.CreateLogger <TemplateRepository>(), FileSystems, IOHelper, ShortStringHelper, Mock.Of <IViewHelper>()); ContentTypeRepository repository = ContentTypeRepository; Template[] templates = new[] { new Template(ShortStringHelper, "test1", "test1"), new Template(ShortStringHelper, "test2", "test2"), new Template(ShortStringHelper, "test3", "test3") }; foreach (Template template in templates) { templateRepo.Save(template); } ContentType contentType = ContentTypeBuilder.CreateSimpleContentType(); contentType.AllowedTemplates = new[] { templates[0], templates[1] }; contentType.SetDefaultTemplate(templates[0]); repository.Save(contentType); // re-get IContentType result = repository.Get(contentType.Id); Assert.AreEqual(2, result.AllowedTemplates.Count()); Assert.AreEqual(templates[0].Id, result.DefaultTemplate.Id); } }
public void Can_Perform_Update_On_ContentTypeRepository() { // Arrange IScopeProvider provider = ScopeProvider; using (IScope scope = provider.CreateScope()) { ContentTypeRepository repository = ContentTypeRepository; // Act IContentType contentType = repository.Get(_textpageContentType.Id); contentType.Thumbnail = "Doc2.png"; contentType.PropertyGroups["content"].PropertyTypes.Add(new PropertyType(ShortStringHelper, "test", ValueStorageType.Ntext, "subtitle") { Name = "Subtitle", Description = "Optional Subtitle", Mandatory = false, SortOrder = 1, DataTypeId = -88, LabelOnTop = true }); repository.Save(contentType); bool dirty = contentType.IsDirty(); // Assert Assert.That(contentType.HasIdentity, Is.True); Assert.That(dirty, Is.False); Assert.That(contentType.Thumbnail, Is.EqualTo("Doc2.png")); Assert.That(contentType.PropertyTypes.Any(x => x.Alias == "subtitle"), Is.True); Assert.That(contentType.PropertyTypes.Single(x => x.Alias == "subtitle").LabelOnTop, Is.True); } }
public void Can_Verify_Content_Type_Has_Content_Nodes() { // Arrange IScopeProvider provider = ScopeProvider; using (IScope scope = provider.CreateScope()) { ContentTypeRepository repository = ContentTypeRepository; int contentTypeId = _textpageContentType.Id; IContentType contentType = repository.Get(contentTypeId); // Act bool result = repository.HasContentNodes(contentTypeId); Content subpage = ContentBuilder.CreateTextpageContent(contentType, "Test Page 1", contentType.Id); DocumentRepository.Save(subpage); bool result2 = repository.HasContentNodes(contentTypeId); // Assert Assert.That(result, Is.False); Assert.That(result2, Is.True); } }
private ContentTypeRepository CreateRepository(IDatabaseUnitOfWork unitOfWork) { var templateRepository = new TemplateRepository(unitOfWork, NullCacheProvider.Current); var contentTypeRepository = new ContentTypeRepository(unitOfWork, NullCacheProvider.Current, templateRepository); return(contentTypeRepository); }
private ContentTypeRepository CreateRepository(IScopeAccessor scopeAccessor) { var templateRepository = new TemplateRepository(scopeAccessor, AppCaches.Disabled, Logger, TestObjects.GetFileSystemsMock()); var contentTypeRepository = new ContentTypeRepository(scopeAccessor, AppCaches.Disabled, Logger, templateRepository); return(contentTypeRepository); }
private ContentTypeRepository CreateRepository(IScopeUnitOfWork unitOfWork) { var templateRepository = new TemplateRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of <ILogger>(), SqlSyntax, Mock.Of <IFileSystem>(), Mock.Of <IFileSystem>(), Mock.Of <ITemplatesSection>()); var contentTypeRepository = new ContentTypeRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of <ILogger>(), SqlSyntax, templateRepository); return(contentTypeRepository); }
public void Can_Verify_Usage_Of_New_PropertyType_On_Content() { // Arrange IScopeProvider provider = ScopeProvider; using (IScope scope = provider.CreateScope()) { ContentTypeRepository repository = ContentTypeRepository; IContentType contentType = repository.Get(_textpageContentType.Id); Content subpage = ContentBuilder.CreateTextpageContent(contentType, "Text Page 1", contentType.Id); DocumentRepository.Save(subpage); PropertyGroup propertyGroup = contentType.PropertyGroups.First(x => x.Name == "Meta"); propertyGroup.PropertyTypes.Add(new PropertyType(ShortStringHelper, "test", ValueStorageType.Ntext, "metaAuthor") { Name = "Meta Author", Description = string.Empty, Mandatory = false, SortOrder = 1, DataTypeId = -88 }); repository.Save(contentType); // Act IContent content = DocumentRepository.Get(subpage.Id); content.SetValue("metaAuthor", "John Doe"); DocumentRepository.Save(content); // Assert IContent updated = DocumentRepository.Get(subpage.Id); Assert.That(updated.GetValue("metaAuthor").ToString(), Is.EqualTo("John Doe")); Assert.That(contentType.PropertyTypes.Count(), Is.EqualTo(5)); Assert.That(contentType.PropertyTypes.Any(x => x.Alias == "metaAuthor"), Is.True); } }
public void Getting_1000_Cached_Items() { // Arrange var contentType = ServiceContext.ContentTypeService.Get(NodeDto.NodeIdSeed); var pages = MockedContent.CreateTextpageContent(contentType, -1, 1000); ServiceContext.ContentService.Save(pages, 0); var provider = TestObjects.GetScopeProvider(Logger); using (var scope = provider.CreateScope()) { var tRepository = new TemplateRepository((IScopeAccessor)provider, AppCaches.Disabled, Logger, TestObjects.GetFileSystemsMock()); var tagRepo = new TagRepository((IScopeAccessor)provider, AppCaches.Disabled, Logger); var ctRepository = new ContentTypeRepository((IScopeAccessor)provider, AppCaches.Disabled, Logger, tRepository); var languageRepository = new LanguageRepository((IScopeAccessor)provider, AppCaches.Disabled, Logger); var repository = new DocumentRepository((IScopeAccessor)provider, AppCaches.Disabled, Logger, ctRepository, tRepository, tagRepo, languageRepository); // Act var contents = repository.GetMany(); Stopwatch watch = Stopwatch.StartNew(); var contentsCached = repository.GetMany(); watch.Stop(); var elapsed = watch.ElapsedMilliseconds; Debug.Print("1000 content items retrieved in {0} ms with caching", elapsed); // Assert //Assert.That(contentsCached.Any(x => x.HasIdentity == false), Is.False); //Assert.That(contentsCached.Any(x => x == null), Is.False); //Assert.That(contentsCached.Count(), Is.EqualTo(contents.Count())); } }
public MenuContentController() { menuRepository = new MenuRepository(DbContext); contentRepository = new ContentRepository(DbContext); pageRepository = new PageRepository(DbContext); contentTypeRepository = new ContentTypeRepository(DbContext); }
public async Task <IContent> GetAsync(string contentTypeId, string id, string language) { if (contentTypeId == null) { throw new ArgumentNullException(nameof(contentTypeId)); } if (id == null) { throw new ArgumentNullException(nameof(id)); } if (language == null) { language = DocumentLanguageConstants.Global; } var contentType = ContentTypeRepository.Get(contentTypeId); if (contentType == null) { throw new ArgumentException(nameof(contentTypeId)); } var document = await DocumentGetter.GetAsync(contentType.Container, id); if (document == null) { return(null); } return(ContentDeserializer.Deserialize(document, contentType, language)); }
public async Task <T> GetAsync <T>(string id, string language) where T : class { if (id == null) { throw new ArgumentNullException(nameof(id)); } if (language == null) { language = DocumentLanguageConstants.Global; } var contentType = ContentTypeRepository.Get(typeof(T)); if (contentType == null) { throw new TypeNotRegisteredContentTypeException(typeof(T)); } var document = await DocumentGetter.GetAsync(contentType.Container, id); if (document == null) { return(null); } return((T)ContentDeserializer.Deserialize(document, contentType, language)); }
/// <summary> /// Executes after Disqus comments add-on is installed to create default instance of Disqus comments block. /// </summary> public override void AfterInstall() { var blockType = ContentTypeRepository.Load <CommentsBlock>(); var defaultDisqusBlock = ContentRepository.GetDefault <IContent>(ContentReference.GlobalBlockFolder, blockType.ID, ContentLanguage.PreferredCulture); defaultDisqusBlock.Name = "Disqus comments"; ContentRepository.Save(defaultDisqusBlock, SaveAction.Publish, AccessLevel.NoAccess); }
public HomeController() { characterRepository = new CharacterRepository(DbContext); menuRepository = new MenuRepository(DbContext); contentRepository = new ContentRepository(DbContext); productTypeRepository = new ProductTypeRepository(DbContext); productRepository = new ProductRepository(DbContext); contentTypeRepository = new ContentTypeRepository(DbContext); }
public ContentController() { this._contentRepository = new ContentRepository(); this._contentTypeRepository = new ContentTypeRepository(); this._contentMapper = new ContentMapper(); this._contentTypeMapper = new ContentTypeMapper(); ViewData["ContentTypes"] = _contentTypeMapper.ToList(_contentTypeRepository.GetList()); }
private DocumentRepository CreateRepository(IScopeAccessor scopeAccessor, out ContentTypeRepository contentTypeRepository, out DataTypeRepository dtdRepository, AppCaches appCaches = null) { appCaches ??= AppCaches; var ctRepository = CreateRepository(scopeAccessor, out contentTypeRepository, out TemplateRepository tr); var editors = new PropertyEditorCollection(new DataEditorCollection(() => Enumerable.Empty <IDataEditor>())); dtdRepository = new DataTypeRepository(scopeAccessor, appCaches, editors, LoggerFactory.CreateLogger <DataTypeRepository>(), LoggerFactory, ConfigurationEditorJsonSerializer); return(ctRepository); }
private ContentRepository CreateRepository(IDatabaseUnitOfWork unitOfWork, out ContentTypeRepository contentTypeRepository) { var templateRepository = new TemplateRepository(unitOfWork, NullCacheProvider.Current); var tagRepository = new TagsRepository(unitOfWork, NullCacheProvider.Current); contentTypeRepository = new ContentTypeRepository(unitOfWork, NullCacheProvider.Current, templateRepository); var repository = new ContentRepository(unitOfWork, NullCacheProvider.Current, contentTypeRepository, templateRepository, tagRepository, CacheHelper.CreateDisabledCacheHelper()); return(repository); }
private ContentRepository CreateRepository(IScopeUnitOfWork unitOfWork, out ContentTypeRepository contentTypeRepository) { var templateRepository = new TemplateRepository(unitOfWork, CacheHelper, Logger, SqlSyntax, Mock.Of <IFileSystem>(), Mock.Of <IFileSystem>(), Mock.Of <ITemplatesSection>()); var tagRepository = new TagRepository(unitOfWork, CacheHelper, Logger, SqlSyntax); contentTypeRepository = new ContentTypeRepository(unitOfWork, CacheHelper, Logger, SqlSyntax, templateRepository); var repository = new ContentRepository(unitOfWork, CacheHelper, Logger, SqlSyntax, contentTypeRepository, templateRepository, tagRepository, Mock.Of <IContentSection>()); return(repository); }
private DocumentRepository CreateRepository(IScopeAccessor scopeAccessor, out ContentTypeRepository contentTypeRepository, out DataTypeRepository dtdRepository, CacheHelper cacheHelper = null) { cacheHelper = cacheHelper ?? CacheHelper; TemplateRepository tr; var ctRepository = CreateRepository(scopeAccessor, out contentTypeRepository, out tr); var editors = new PropertyEditorCollection(new DataEditorCollection(Enumerable.Empty <IDataEditor>())); dtdRepository = new DataTypeRepository(scopeAccessor, cacheHelper, new Lazy <PropertyEditorCollection>(() => editors), Logger); return(ctRepository); }
public IEnumerable <FormDescriptor> CreateAll() { var result = new List <FormDescriptor>(); foreach (var type in ContentTypeRepository.GetAll()) { result.Add(new FormDescriptor(ContentFormIdGenerator.Generate(type), type.Type)); } return(result.AsReadOnly()); }
private DomainRepository CreateRepository(IDatabaseUnitOfWork unitOfWork, out ContentTypeRepository contentTypeRepository, out ContentRepository contentRepository, out LanguageRepository languageRepository) { var templateRepository = new TemplateRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Logger, SqlSyntax, Mock.Of <IFileSystem>(), Mock.Of <IFileSystem>(), Mock.Of <ITemplatesSection>()); var tagRepository = new TagRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Logger, SqlSyntax); contentTypeRepository = new ContentTypeRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Logger, SqlSyntax, templateRepository); contentRepository = new ContentRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Logger, SqlSyntax, contentTypeRepository, templateRepository, tagRepository, Mock.Of <IContentSection>()); languageRepository = new LanguageRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Logger, SqlSyntax); var domainRepository = new DomainRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Logger, SqlSyntax); return(domainRepository); }
private DocumentRepository CreateRepository(IScopeProvider provider, out ContentTypeRepository contentTypeRepository) { var accessor = (IScopeAccessor)provider; var templateRepository = new TemplateRepository(accessor, CacheHelper, Logger, Mock.Of <ITemplatesSection>(), TestObjects.GetFileSystemsMock()); var tagRepository = new TagRepository(accessor, CacheHelper, Logger); contentTypeRepository = new ContentTypeRepository(accessor, CacheHelper, Logger, templateRepository); var languageRepository = new LanguageRepository(accessor, CacheHelper, Logger); var repository = new DocumentRepository(accessor, CacheHelper, Logger, contentTypeRepository, templateRepository, tagRepository, languageRepository, Mock.Of <IContentSection>()); return(repository); }
private DocumentRepository CreateContentRepository(IScopeProvider provider, out ContentTypeRepository contentTypeRepository) { var accessor = (IScopeAccessor)provider; var templateRepository = new TemplateRepository(accessor, AppCaches.Disabled, Logger, TestObjects.GetFileSystemsMock()); var tagRepository = new TagRepository(accessor, AppCaches.Disabled, Logger); contentTypeRepository = new ContentTypeRepository(accessor, AppCaches.Disabled, Logger, templateRepository); var languageRepository = new LanguageRepository(accessor, AppCaches.Disabled, Logger); var repository = new DocumentRepository(accessor, AppCaches.Disabled, Logger, contentTypeRepository, templateRepository, tagRepository, languageRepository); return(repository); }
/// <summary> /// Executes before Disqus comments add-on is uninstalled to remove all related data. /// </summary> public override void BeforeUninstall() { var blockType = ContentTypeRepository.Load <CommentsBlock>(); ContentModelUsage.ListContentOfContentType(blockType) .Select(usage => usage.ContentLink).Distinct().ToList() .ForEach(contentLink => ContentRepository.Delete(contentLink, true, AccessLevel.NoAccess)); ContentTypeRepository.Delete(blockType); ConfigurationProvider.Clear(); }
private DocumentRepository CreateRepository(IScopeAccessor scopeAccessor, out ContentTypeRepository contentTypeRepository) { var cacheHelper = AppCaches.Disabled; var templateRepository = new TemplateRepository(scopeAccessor, cacheHelper, Logger, TestObjects.GetFileSystemsMock()); var tagRepository = new TagRepository(scopeAccessor, cacheHelper, Logger); contentTypeRepository = new ContentTypeRepository(scopeAccessor, cacheHelper, Logger, templateRepository); var languageRepository = new LanguageRepository(scopeAccessor, cacheHelper, Logger); var repository = new DocumentRepository(scopeAccessor, cacheHelper, Logger, contentTypeRepository, templateRepository, tagRepository, languageRepository); return(repository); }
private DocumentRepository CreateRepository(IScopeAccessor scopeAccessor, out ContentTypeRepository contentTypeRepository, out TemplateRepository templateRepository, CacheHelper cacheHelper = null) { cacheHelper = cacheHelper ?? CacheHelper; templateRepository = new TemplateRepository(scopeAccessor, cacheHelper, Logger, Mock.Of <ITemplatesSection>(), TestObjects.GetFileSystemsMock()); var tagRepository = new TagRepository(scopeAccessor, cacheHelper, Logger); contentTypeRepository = new ContentTypeRepository(scopeAccessor, cacheHelper, Logger, templateRepository); var languageRepository = new LanguageRepository(scopeAccessor, cacheHelper, Logger); var repository = new DocumentRepository(scopeAccessor, cacheHelper, Logger, contentTypeRepository, templateRepository, tagRepository, languageRepository, Mock.Of <IContentSection>()); return(repository); }
public IHttpActionResult ContentWithTypes(string type, string search, string sort, int pageNumber) { try { ContentRepository contentRepo = new ContentRepository(); ContentTypeRepository typeRepo = new ContentTypeRepository(); ContentWithTypesCollectionViewModel model = new ContentWithTypesCollectionViewModel(); List<ContentViewModel> lstContents = contentRepo.GetList(type, search, sort, pageNumber); string[] contact_us = { Constants.CONTACT_US }; List<ContentTypeViewModel> lstTypes = typeRepo.GetList(contact_us); model.types = lstTypes; model.contents = lstContents; return Ok(model); } catch (Exception ex) { return BadRequest(ex.Message); } }
public IHttpActionResult SingleContentWithTypes(long id) { try { ContentRepository contentRepo = new ContentRepository(); ContentTypeRepository typeRepo = new ContentTypeRepository(); SingleContentWithTypesCollectionViewModel model = new SingleContentWithTypesCollectionViewModel(); ContentViewModel content = contentRepo.GetSingle(id); if (content.id == 0) { throw new Exception(Error.CONTENT_NOT_FOUND); } string[] contact_us = { Constants.CONTACT_US }; List<ContentTypeViewModel> lstTypes = typeRepo.GetList(contact_us); model.types = lstTypes; model.content = content; return Ok(model); } catch (Exception ex) { return BadRequest(ex.Message); } }
public ContentTypeController() { this.repo = new ContentTypeRepository(); }