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();
}
