From aa8b8c77366e10415ee4e191e5ef484ebb1a2693 Mon Sep 17 00:00:00 2001 From: Stephan Date: Wed, 17 Aug 2016 11:50:38 +0200 Subject: [PATCH] Resvolution - MappingResolver --- src/Umbraco.Core/CoreBootManager.cs | 7 -- .../RepositoryCompositionRoot.cs | 20 +++-- .../Persistence/DefaultDatabaseFactory.cs | 28 +++---- .../Persistence/Mappers/IMapperCollection.cs | 9 ++ .../Persistence/Mappers/IMappingResolver.cs | 14 ---- .../Persistence/Mappers/MapperCollection.cs | 36 ++++++++ .../Mappers/MapperCollectionBuilder.cs | 27 ++++++ .../Persistence/Mappers/MappingResolver.cs | 82 ------------------- .../Persistence/Querying/IQueryFactory.cs | 2 +- .../Querying/ModelToSqlExpressionHelper.cs | 9 +- .../Persistence/Querying/Query.cs | 10 +-- .../Persistence/Querying/QueryFactory.cs | 8 +- .../Repositories/AuditRepository.cs | 4 +- .../Repositories/ContentRepository.cs | 4 +- .../Repositories/ContentTypeRepository.cs | 4 +- .../Repositories/ContentTypeRepositoryBase.cs | 4 +- .../DataTypeDefinitionRepository.cs | 10 +-- .../Repositories/DictionaryRepository.cs | 20 ++--- .../Repositories/DomainRepository.cs | 4 +- .../Repositories/EntityContainerRepository.cs | 4 +- .../Repositories/EntityRepository.cs | 4 +- .../Repositories/ExternalLoginRepository.cs | 4 +- .../Interfaces/DataTypeContainerRepository.cs | 4 +- .../DocumentTypeContainerRepository.cs | 4 +- .../MediaTypeContainerRepository.cs | 4 +- .../Repositories/LanguageRepository.cs | 4 +- .../Repositories/MacroRepository.cs | 4 +- .../Repositories/MediaRepository.cs | 4 +- .../Repositories/MediaTypeRepository.cs | 4 +- .../Repositories/MemberGroupRepository.cs | 4 +- .../Repositories/MemberRepository.cs | 4 +- .../Repositories/MemberTypeRepository.cs | 4 +- .../Repositories/MigrationEntryRepository.cs | 4 +- .../Repositories/NPocoRepositoryBase.cs | 6 +- .../Repositories/PublicAccessRepository.cs | 4 +- .../Repositories/RecycleBinRepository.cs | 4 +- .../Repositories/RedirectUrlRepository.cs | 4 +- .../Repositories/RelationRepository.cs | 4 +- .../Repositories/RelationTypeRepository.cs | 4 +- .../ServerRegistrationRepository.cs | 4 +- .../Repositories/SimpleGetRepository.cs | 4 +- .../Persistence/Repositories/TagRepository.cs | 4 +- .../Repositories/TaskRepository.cs | 4 +- .../Repositories/TaskTypeRepository.cs | 4 +- .../Repositories/TemplateRepository.cs | 4 +- .../Repositories/UserRepository.cs | 6 +- .../Repositories/UserTypeRepository.cs | 4 +- .../Repositories/VersionableRepositoryBase.cs | 4 +- src/Umbraco.Core/Umbraco.Core.csproj | 5 +- .../Persistence/DatabaseContextTests.cs | 4 +- .../FaultHandling/ConnectionRetryTest.cs | 4 +- .../Persistence/Querying/QueryBuilderTests.cs | 8 +- .../Repositories/AuditRepositoryTest.cs | 2 +- .../Repositories/ContentRepositoryTest.cs | 14 ++-- .../Repositories/ContentTypeRepositoryTest.cs | 18 ++-- .../DataTypeDefinitionRepositoryTest.cs | 6 +- .../Repositories/DictionaryRepositoryTest.cs | 4 +- .../Repositories/DomainRepositoryTest.cs | 12 +-- .../Repositories/LanguageRepositoryTest.cs | 6 +- .../Repositories/MacroRepositoryTest.cs | 40 ++++----- .../Repositories/MediaRepositoryTest.cs | 28 +++---- .../Repositories/MediaTypeRepositoryTest.cs | 4 +- .../Repositories/MemberRepositoryTest.cs | 12 +-- .../Repositories/MemberTypeRepositoryTest.cs | 2 +- .../PublicAccessRepositoryTest.cs | 22 ++--- .../RedirectUrlRepositoryTests.cs | 2 +- .../Repositories/RelationRepositoryTest.cs | 12 +-- .../RelationTypeRepositoryTest.cs | 8 +- .../ServerRegistrationRepositoryTest.cs | 2 +- .../Repositories/TagRepositoryTest.cs | 16 ++-- .../Repositories/TaskRepositoryTest.cs | 18 ++-- .../Repositories/TaskTypeRepositoryTest.cs | 4 +- .../Repositories/TemplateRepositoryTest.cs | 8 +- .../Repositories/UserRepositoryTest.cs | 18 ++-- .../Repositories/UserTypeRepositoryTest.cs | 8 +- .../Services/ContentServicePerformanceTest.cs | 32 ++++---- .../Services/ContentServiceTests.cs | 18 ++-- .../Services/MacroServiceTests.cs | 2 +- .../Services/ThreadSafetyServiceTest.cs | 10 +-- .../Templates/TemplateRepositoryTests.cs | 2 +- .../TestHelpers/BaseDatabaseFactoryTest.cs | 2 +- .../TestHelpers/BaseUmbracoApplicationTest.cs | 7 +- .../TestHelpers/BaseUsingSqlCeSyntax.cs | 13 ++- src/Umbraco.Tests/TestHelpers/TestObjects.cs | 4 +- 84 files changed, 382 insertions(+), 417 deletions(-) create mode 100644 src/Umbraco.Core/Persistence/Mappers/IMapperCollection.cs delete mode 100644 src/Umbraco.Core/Persistence/Mappers/IMappingResolver.cs create mode 100644 src/Umbraco.Core/Persistence/Mappers/MapperCollection.cs create mode 100644 src/Umbraco.Core/Persistence/Mappers/MapperCollectionBuilder.cs delete mode 100644 src/Umbraco.Core/Persistence/Mappers/MappingResolver.cs diff --git a/src/Umbraco.Core/CoreBootManager.cs b/src/Umbraco.Core/CoreBootManager.cs index d04a15500e..a7439eb88b 100644 --- a/src/Umbraco.Core/CoreBootManager.cs +++ b/src/Umbraco.Core/CoreBootManager.cs @@ -15,7 +15,6 @@ using Umbraco.Core.Manifest; using Umbraco.Core.Models.Mapping; using Umbraco.Core.Models.PublishedContent; using Umbraco.Core.ObjectResolution; -using Umbraco.Core.Persistence.Mappers; using Umbraco.Core.Persistence.Migrations; using Umbraco.Core.Plugins; using Umbraco.Core.PropertyEditors; @@ -181,7 +180,6 @@ namespace Umbraco.Core container.RegisterSingleton(); container.Register(factory => FileSystemProviderManager.Current.GetFileSystemProvider()); - } /// @@ -443,11 +441,6 @@ namespace Umbraco.Core Container, factory => new DatabaseServerMessenger(ApplicationContext, true, new DatabaseServerMessengerOptions())); - MappingResolver.Current = new MappingResolver( - Container, ProfilingLogger.Logger, - () => PluginManager.ResolveAssignedMapperTypes()); - - //RepositoryResolver.Current = new RepositoryResolver( // new RepositoryFactory(ApplicationCache)); diff --git a/src/Umbraco.Core/DependencyInjection/RepositoryCompositionRoot.cs b/src/Umbraco.Core/DependencyInjection/RepositoryCompositionRoot.cs index c2088bdda9..71f9968dc5 100644 --- a/src/Umbraco.Core/DependencyInjection/RepositoryCompositionRoot.cs +++ b/src/Umbraco.Core/DependencyInjection/RepositoryCompositionRoot.cs @@ -1,7 +1,7 @@ +using System; using LightInject; using Umbraco.Core.Cache; using Umbraco.Core.IO; -using Umbraco.Core.Logging; using Umbraco.Core.Persistence; using Umbraco.Core.Persistence.Mappers; using Umbraco.Core.Persistence.Repositories; @@ -41,13 +41,6 @@ namespace Umbraco.Core.DependencyInjection container.RegisterSingleton(); container.RegisterSingleton(); - // register mapping resover - // using a factory because... no time to clean it up at the moment - container.RegisterSingleton(factory => new MappingResolver( - factory.GetInstance(), - factory.GetInstance(), - () => factory.GetInstance().ResolveAssignedMapperTypes())); - // register repository factory container.RegisterSingleton(); @@ -116,6 +109,17 @@ namespace Umbraco.Core.DependencyInjection container.Register(); container.Register(); container.Register(); + + // collection builders require a full IServiceContainer because they need to + // be able to both register stuff, and get stuff - but ICompositionRoot gives + // us an IServiceRegistry - which *is* a full container - so, casting - bit + // awkward but it works + var serviceContainer = container as IServiceContainer; + if (serviceContainer == null) throw new Exception("Container is not IServiceContainer."); + + // register persistence mappers + MapperCollectionBuilder.Register(serviceContainer) + .AddProducer(f => f.GetInstance().ResolveAssignedMapperTypes()); } } } \ No newline at end of file diff --git a/src/Umbraco.Core/Persistence/DefaultDatabaseFactory.cs b/src/Umbraco.Core/Persistence/DefaultDatabaseFactory.cs index fe37df3949..a9e2777514 100644 --- a/src/Umbraco.Core/Persistence/DefaultDatabaseFactory.cs +++ b/src/Umbraco.Core/Persistence/DefaultDatabaseFactory.cs @@ -27,7 +27,7 @@ namespace Umbraco.Core.Persistence /// internal class DefaultDatabaseFactory : DisposableObject, IDatabaseFactory { - private readonly IMappingResolver _mappingResolver; + private readonly IMapperCollection _mappers; private readonly IUmbracoDatabaseAccessor _umbracoDatabaseAccessor; private readonly ISqlSyntaxProvider[] _sqlSyntaxProviders; private readonly ILogger _logger; @@ -59,7 +59,7 @@ namespace Umbraco.Core.Persistence get { EnsureConfigured(); - return _queryFactory ?? (_queryFactory = new QueryFactory(SqlSyntax, _mappingResolver)); + return _queryFactory ?? (_queryFactory = new QueryFactory(SqlSyntax, _mappers)); } } @@ -69,10 +69,10 @@ namespace Umbraco.Core.Persistence /// The collection of available sql syntax providers. /// A logger. /// - /// + /// /// Used by LightInject. - public DefaultDatabaseFactory(IEnumerable sqlSyntaxProviders, ILogger logger, IUmbracoDatabaseAccessor umbracoDatabaseAccessor, IMappingResolver mappingResolver) - : this(GlobalSettings.UmbracoConnectionName, sqlSyntaxProviders, logger, umbracoDatabaseAccessor, mappingResolver) + public DefaultDatabaseFactory(IEnumerable sqlSyntaxProviders, ILogger logger, IUmbracoDatabaseAccessor umbracoDatabaseAccessor, IMapperCollection mappers) + : this(GlobalSettings.UmbracoConnectionName, sqlSyntaxProviders, logger, umbracoDatabaseAccessor, mappers) { if (Configured == false) DatabaseContext.GiveLegacyAChance(this, logger); @@ -85,17 +85,17 @@ namespace Umbraco.Core.Persistence /// The collection of available sql syntax providers. /// A logger /// - /// + /// /// Used by the other ctor and in tests. - public DefaultDatabaseFactory(string connectionStringName, IEnumerable sqlSyntaxProviders, ILogger logger, IUmbracoDatabaseAccessor umbracoDatabaseAccessor, IMappingResolver mappingResolver) + public DefaultDatabaseFactory(string connectionStringName, IEnumerable sqlSyntaxProviders, ILogger logger, IUmbracoDatabaseAccessor umbracoDatabaseAccessor, IMapperCollection mappers) { if (sqlSyntaxProviders == null) throw new ArgumentNullException(nameof(sqlSyntaxProviders)); if (logger == null) throw new ArgumentNullException(nameof(logger)); if (umbracoDatabaseAccessor == null) throw new ArgumentNullException(nameof(umbracoDatabaseAccessor)); if (string.IsNullOrWhiteSpace(connectionStringName)) throw new ArgumentException("Value cannot be null nor empty.", nameof(connectionStringName)); - if (mappingResolver == null) throw new ArgumentNullException(nameof(mappingResolver)); + if (mappers == null) throw new ArgumentNullException(nameof(mappers)); - _mappingResolver = mappingResolver; + _mappers = mappers; _sqlSyntaxProviders = sqlSyntaxProviders.ToArray(); _logger = logger; _umbracoDatabaseAccessor = umbracoDatabaseAccessor; @@ -124,16 +124,16 @@ namespace Umbraco.Core.Persistence /// The collection of available sql syntax providers. /// A logger. /// - /// + /// /// Used in tests. - public DefaultDatabaseFactory(string connectionString, string providerName, IEnumerable sqlSyntaxProviders, ILogger logger, IUmbracoDatabaseAccessor umbracoDatabaseAccessor, IMappingResolver mappingResolver) + public DefaultDatabaseFactory(string connectionString, string providerName, IEnumerable sqlSyntaxProviders, ILogger logger, IUmbracoDatabaseAccessor umbracoDatabaseAccessor, IMapperCollection mappers) { if (sqlSyntaxProviders == null) throw new ArgumentNullException(nameof(sqlSyntaxProviders)); if (logger == null) throw new ArgumentNullException(nameof(logger)); if (umbracoDatabaseAccessor == null) throw new ArgumentNullException(nameof(umbracoDatabaseAccessor)); - if (mappingResolver == null) throw new ArgumentNullException(nameof(mappingResolver)); + if (mappers == null) throw new ArgumentNullException(nameof(mappers)); - _mappingResolver = mappingResolver; + _mappers = mappers; _sqlSyntaxProviders = sqlSyntaxProviders.ToArray(); _logger = logger; _umbracoDatabaseAccessor = umbracoDatabaseAccessor; @@ -176,7 +176,7 @@ namespace Umbraco.Core.Persistence // ensure we have only 1 set of mappers, and 1 PocoDataFactory, for all database // so that everything NPoco is properly cached for the lifetime of the application - var mappers = new MapperCollection { new PocoMapper() }; + var mappers = new NPoco.MapperCollection { new PocoMapper() }; var factory = new FluentPocoDataFactory((type, iPocoDataFactory) => new PocoDataBuilder(type, mappers).Init()); _pocoDataFactory = factory; var config = new FluentConfig(xmappers => factory); diff --git a/src/Umbraco.Core/Persistence/Mappers/IMapperCollection.cs b/src/Umbraco.Core/Persistence/Mappers/IMapperCollection.cs new file mode 100644 index 0000000000..313c5a5bd3 --- /dev/null +++ b/src/Umbraco.Core/Persistence/Mappers/IMapperCollection.cs @@ -0,0 +1,9 @@ +using System; + +namespace Umbraco.Core.Persistence.Mappers +{ + public interface IMapperCollection + { + BaseMapper this[Type type] { get; } + } +} diff --git a/src/Umbraco.Core/Persistence/Mappers/IMappingResolver.cs b/src/Umbraco.Core/Persistence/Mappers/IMappingResolver.cs deleted file mode 100644 index a5e3ffffb0..0000000000 --- a/src/Umbraco.Core/Persistence/Mappers/IMappingResolver.cs +++ /dev/null @@ -1,14 +0,0 @@ -using System; - -namespace Umbraco.Core.Persistence.Mappers -{ - public interface IMappingResolver - { - /// - /// Return a mapper by type - /// - /// - /// - BaseMapper ResolveMapperByType(Type type); - } -} \ No newline at end of file diff --git a/src/Umbraco.Core/Persistence/Mappers/MapperCollection.cs b/src/Umbraco.Core/Persistence/Mappers/MapperCollection.cs new file mode 100644 index 0000000000..7718849562 --- /dev/null +++ b/src/Umbraco.Core/Persistence/Mappers/MapperCollection.cs @@ -0,0 +1,36 @@ +using System; +using System.Collections.Concurrent; +using System.Collections.Generic; +using System.Linq; +using Umbraco.Core.DependencyInjection; + +namespace Umbraco.Core.Persistence.Mappers +{ + public class MapperCollection : BuilderCollectionBase, IMapperCollection + { + public MapperCollection(IEnumerable items) + : base(items) + { } + + // maintain our own index for faster lookup + private readonly ConcurrentDictionary _index = new ConcurrentDictionary(); + + public BaseMapper this[Type type] + { + get + { + return _index.GetOrAdd(type, t => + { + // check if any of the mappers are assigned to this type + var mapper = this.FirstOrDefault(x => x.GetType() + .GetCustomAttributes(false) + .Any(m => m.EntityType == type)); + + if (mapper != null) return mapper; + + throw new Exception($"Could not find a mapper matching type {type.FullName}."); + }); + } + } + } +} diff --git a/src/Umbraco.Core/Persistence/Mappers/MapperCollectionBuilder.cs b/src/Umbraco.Core/Persistence/Mappers/MapperCollectionBuilder.cs new file mode 100644 index 0000000000..f7f3b72781 --- /dev/null +++ b/src/Umbraco.Core/Persistence/Mappers/MapperCollectionBuilder.cs @@ -0,0 +1,27 @@ +using LightInject; +using Umbraco.Core.DependencyInjection; + +namespace Umbraco.Core.Persistence.Mappers +{ + public class MapperCollectionBuilder : LazyCollectionBuilderBase + { + public MapperCollectionBuilder(IServiceContainer container) + : base(container) + { } + + protected override MapperCollectionBuilder This => this; + + protected override void Initialize() + { + base.Initialize(); + + // default initializer registers + // - service MapperCollectionBuilder, returns MapperCollectionBuilder + // - service MapperCollection, returns MapperCollectionBuilder's collection + // we want to register extra + // - service IMapperCollection, returns MappersCollectionBuilder's collection + + Container.Register(factory => factory.GetInstance()); + } + } +} diff --git a/src/Umbraco.Core/Persistence/Mappers/MappingResolver.cs b/src/Umbraco.Core/Persistence/Mappers/MappingResolver.cs deleted file mode 100644 index 6933c221d7..0000000000 --- a/src/Umbraco.Core/Persistence/Mappers/MappingResolver.cs +++ /dev/null @@ -1,82 +0,0 @@ -using System; -using System.Collections.Concurrent; -using System.Collections.Generic; -using System.Linq; -using LightInject; -using Umbraco.Core.Logging; -using Umbraco.Core.ObjectResolution; - -namespace Umbraco.Core.Persistence.Mappers -{ - internal class MappingResolver : ContainerLazyManyObjectsResolver, IMappingResolver - { - /// - /// Constructor accepting a list of BaseMapper types that are attributed with the MapperFor attribute - /// - /// - /// - /// - public MappingResolver(IServiceContainer container, ILogger logger, Func> assignedMapperTypes) - : base(container, logger, assignedMapperTypes) - { } - - /// - /// Caches the type -> mapper so that we don't have to type check each time we want one or lookup the attribute - /// - private readonly ConcurrentDictionary _mapperCache = new ConcurrentDictionary(); - - /// - /// Return a mapper by type - /// - /// - /// - public BaseMapper ResolveMapperByType(Type type) - { - return _mapperCache.GetOrAdd(type, type1 => - { - - //first check if we can resolve it by attribute - - var byAttribute = TryGetMapperByAttribute(type); - if (byAttribute.Success) - { - return byAttribute.Result; - } - throw new Exception("Invalid Type: A Mapper could not be resolved based on the passed in Type"); - }); - } - - /// - /// Check the entity type to see if it has a mapper attribute assigned and try to instantiate it - /// - /// - /// - private Attempt TryGetMapperByAttribute(Type entityType) - { - //check if any of the mappers are assigned to this type - var mapper = Values.FirstOrDefault( - x => x.GetType().GetCustomAttributes(false) - .Any(m => m.EntityType == entityType)); - - if (mapper == null) - { - return Attempt.Fail(); - } - - return Attempt.Succeed(mapper); - } - - /* - internal string GetMapping(Type type, string propertyName) - { - var mapper = ResolveMapperByType(type); - var result = mapper.Map(propertyName); - if(string.IsNullOrEmpty(result)) - throw new Exception("Invalid mapping: The passed in property name could not be mapped using the passed in type"); - - return result; - } - */ - } - -} \ No newline at end of file diff --git a/src/Umbraco.Core/Persistence/Querying/IQueryFactory.cs b/src/Umbraco.Core/Persistence/Querying/IQueryFactory.cs index 782d5a68c5..e044425e57 100644 --- a/src/Umbraco.Core/Persistence/Querying/IQueryFactory.cs +++ b/src/Umbraco.Core/Persistence/Querying/IQueryFactory.cs @@ -5,7 +5,7 @@ namespace Umbraco.Core.Persistence.Querying { public interface IQueryFactory { - IMappingResolver MappingResolver { get; } + IMapperCollection Mappers { get; } ISqlSyntaxProvider SqlSyntax { get; } IQuery Create(); } diff --git a/src/Umbraco.Core/Persistence/Querying/ModelToSqlExpressionHelper.cs b/src/Umbraco.Core/Persistence/Querying/ModelToSqlExpressionHelper.cs index b2859615a2..d3c3067ab7 100644 --- a/src/Umbraco.Core/Persistence/Querying/ModelToSqlExpressionHelper.cs +++ b/src/Umbraco.Core/Persistence/Querying/ModelToSqlExpressionHelper.cs @@ -22,15 +22,10 @@ namespace Umbraco.Core.Persistence.Querying _mapper = mapper; } - public ModelToSqlExpressionHelper(ISqlSyntaxProvider sqlSyntax, IMappingResolver mappingResolver) + public ModelToSqlExpressionHelper(ISqlSyntaxProvider sqlSyntax, IMapperCollection mappers) : base(sqlSyntax) { - _mapper = mappingResolver.ResolveMapperByType(typeof(T)); - - if (_mapper == null) - { - throw new InvalidOperationException("Could not resolve a mapper for type " + typeof (T)); - } + _mapper = mappers[typeof(T)]; // throws if not found } protected override string VisitMemberAccess(MemberExpression m) diff --git a/src/Umbraco.Core/Persistence/Querying/Query.cs b/src/Umbraco.Core/Persistence/Querying/Query.cs index 4c58e9e122..c69efe4a5f 100644 --- a/src/Umbraco.Core/Persistence/Querying/Query.cs +++ b/src/Umbraco.Core/Persistence/Querying/Query.cs @@ -16,13 +16,13 @@ namespace Umbraco.Core.Persistence.Querying public class Query : IQuery { private readonly ISqlSyntaxProvider _sqlSyntax; - private readonly IMappingResolver _mappingResolver; + private readonly IMapperCollection _mappers; private readonly List> _wheres = new List>(); - public Query(ISqlSyntaxProvider sqlSyntax, IMappingResolver mappingResolver) + public Query(ISqlSyntaxProvider sqlSyntax, IMapperCollection mappers) { _sqlSyntax = sqlSyntax; - _mappingResolver = mappingResolver; + _mappers = mappers; } /// @@ -34,7 +34,7 @@ namespace Umbraco.Core.Persistence.Querying { if (predicate != null) { - var expressionHelper = new ModelToSqlExpressionHelper(_sqlSyntax, _mappingResolver); + var expressionHelper = new ModelToSqlExpressionHelper(_sqlSyntax, _mappers); string whereExpression = expressionHelper.Visit(predicate); _wheres.Add(new Tuple(whereExpression, expressionHelper.GetSqlParameters())); @@ -46,7 +46,7 @@ namespace Umbraco.Core.Persistence.Querying { if (fieldSelector != null) { - var expressionHelper = new ModelToSqlExpressionHelper(_sqlSyntax, _mappingResolver); + var expressionHelper = new ModelToSqlExpressionHelper(_sqlSyntax, _mappers); string whereExpression = expressionHelper.Visit(fieldSelector); _wheres.Add(new Tuple(whereExpression + " IN (@values)", new object[] { new { @values = values } })); diff --git a/src/Umbraco.Core/Persistence/Querying/QueryFactory.cs b/src/Umbraco.Core/Persistence/Querying/QueryFactory.cs index d9e0ab4121..a16355f9d7 100644 --- a/src/Umbraco.Core/Persistence/Querying/QueryFactory.cs +++ b/src/Umbraco.Core/Persistence/Querying/QueryFactory.cs @@ -6,17 +6,17 @@ namespace Umbraco.Core.Persistence.Querying public class QueryFactory : IQueryFactory { public ISqlSyntaxProvider SqlSyntax { get; } - public IMappingResolver MappingResolver { get; } + public IMapperCollection Mappers { get; } - public QueryFactory(ISqlSyntaxProvider sqlSyntax, IMappingResolver mappingResolver) + public QueryFactory(ISqlSyntaxProvider sqlSyntax, IMapperCollection mappers) { SqlSyntax = sqlSyntax; - MappingResolver = mappingResolver; + Mappers = mappers; } public IQuery Create() { - return new Query(SqlSyntax, MappingResolver); + return new Query(SqlSyntax, Mappers); } } } \ No newline at end of file diff --git a/src/Umbraco.Core/Persistence/Repositories/AuditRepository.cs b/src/Umbraco.Core/Persistence/Repositories/AuditRepository.cs index 4ef27371b5..0c6d61c68e 100644 --- a/src/Umbraco.Core/Persistence/Repositories/AuditRepository.cs +++ b/src/Umbraco.Core/Persistence/Repositories/AuditRepository.cs @@ -17,8 +17,8 @@ namespace Umbraco.Core.Persistence.Repositories { internal class AuditRepository : NPocoRepositoryBase, IAuditRepository { - public AuditRepository(IDatabaseUnitOfWork work, [Inject(RepositoryCompositionRoot.DisabledCache)] CacheHelper cache, ILogger logger, IMappingResolver mappingResolver) - : base(work, cache, logger, mappingResolver) + public AuditRepository(IDatabaseUnitOfWork work, [Inject(RepositoryCompositionRoot.DisabledCache)] CacheHelper cache, ILogger logger, IMapperCollection mappers) + : base(work, cache, logger, mappers) { } diff --git a/src/Umbraco.Core/Persistence/Repositories/ContentRepository.cs b/src/Umbraco.Core/Persistence/Repositories/ContentRepository.cs index 6d334fe426..55299c3914 100644 --- a/src/Umbraco.Core/Persistence/Repositories/ContentRepository.cs +++ b/src/Umbraco.Core/Persistence/Repositories/ContentRepository.cs @@ -31,8 +31,8 @@ namespace Umbraco.Core.Persistence.Repositories private readonly CacheHelper _cacheHelper; private PermissionRepository _permissionRepository; - public ContentRepository(IDatabaseUnitOfWork work, CacheHelper cacheHelper, ILogger logger, IContentTypeRepository contentTypeRepository, ITemplateRepository templateRepository, ITagRepository tagRepository, IContentSection contentSection, IMappingResolver mappingResolver) - : base(work, cacheHelper, logger, contentSection, mappingResolver) + public ContentRepository(IDatabaseUnitOfWork work, CacheHelper cacheHelper, ILogger logger, IContentTypeRepository contentTypeRepository, ITemplateRepository templateRepository, ITagRepository tagRepository, IContentSection contentSection, IMapperCollection mappers) + : base(work, cacheHelper, logger, contentSection, mappers) { if (contentTypeRepository == null) throw new ArgumentNullException(nameof(contentTypeRepository)); if (templateRepository == null) throw new ArgumentNullException(nameof(templateRepository)); diff --git a/src/Umbraco.Core/Persistence/Repositories/ContentTypeRepository.cs b/src/Umbraco.Core/Persistence/Repositories/ContentTypeRepository.cs index c4814a3647..0e1ddc5490 100644 --- a/src/Umbraco.Core/Persistence/Repositories/ContentTypeRepository.cs +++ b/src/Umbraco.Core/Persistence/Repositories/ContentTypeRepository.cs @@ -22,8 +22,8 @@ namespace Umbraco.Core.Persistence.Repositories private readonly ITemplateRepository _templateRepository; private IRepositoryCachePolicy _cachePolicy; - public ContentTypeRepository(IDatabaseUnitOfWork work, CacheHelper cache, ILogger logger, ITemplateRepository templateRepository, IMappingResolver mappingResolver) - : base(work, cache, logger, mappingResolver) + public ContentTypeRepository(IDatabaseUnitOfWork work, CacheHelper cache, ILogger logger, ITemplateRepository templateRepository, IMapperCollection mappers) + : base(work, cache, logger, mappers) { _templateRepository = templateRepository; } diff --git a/src/Umbraco.Core/Persistence/Repositories/ContentTypeRepositoryBase.cs b/src/Umbraco.Core/Persistence/Repositories/ContentTypeRepositoryBase.cs index 4d9b32f1e8..34134ae3c6 100644 --- a/src/Umbraco.Core/Persistence/Repositories/ContentTypeRepositoryBase.cs +++ b/src/Umbraco.Core/Persistence/Repositories/ContentTypeRepositoryBase.cs @@ -31,8 +31,8 @@ namespace Umbraco.Core.Persistence.Repositories internal abstract class ContentTypeRepositoryBase : NPocoRepositoryBase, IReadRepository where TEntity : class, IContentTypeComposition { - protected ContentTypeRepositoryBase(IDatabaseUnitOfWork work, CacheHelper cache, ILogger logger, IMappingResolver mappingResolver) - : base(work, cache, logger, mappingResolver) + protected ContentTypeRepositoryBase(IDatabaseUnitOfWork work, CacheHelper cache, ILogger logger, IMapperCollection mappers) + : base(work, cache, logger, mappers) { } diff --git a/src/Umbraco.Core/Persistence/Repositories/DataTypeDefinitionRepository.cs b/src/Umbraco.Core/Persistence/Repositories/DataTypeDefinitionRepository.cs index 691d579401..4c581a1729 100644 --- a/src/Umbraco.Core/Persistence/Repositories/DataTypeDefinitionRepository.cs +++ b/src/Umbraco.Core/Persistence/Repositories/DataTypeDefinitionRepository.cs @@ -32,11 +32,11 @@ namespace Umbraco.Core.Persistence.Repositories private readonly DataTypePreValueRepository _preValRepository; public DataTypeDefinitionRepository(IDatabaseUnitOfWork work, CacheHelper cache, ILogger logger, - IContentTypeRepository contentTypeRepository, IMappingResolver mappingResolver) - : base(work, cache, logger, mappingResolver) + IContentTypeRepository contentTypeRepository, IMapperCollection mappers) + : base(work, cache, logger, mappers) { _contentTypeRepository = contentTypeRepository; - _preValRepository = new DataTypePreValueRepository(work, CacheHelper.CreateDisabledCacheHelper(), logger, mappingResolver); + _preValRepository = new DataTypePreValueRepository(work, CacheHelper.CreateDisabledCacheHelper(), logger, mappers); } #region Overrides of RepositoryBase @@ -534,8 +534,8 @@ AND umbracoNode.id <> @id", /// private class DataTypePreValueRepository : NPocoRepositoryBase { - public DataTypePreValueRepository(IDatabaseUnitOfWork work, CacheHelper cache, ILogger logger, IMappingResolver mappingResolver) - : base(work, cache, logger, mappingResolver) + public DataTypePreValueRepository(IDatabaseUnitOfWork work, CacheHelper cache, ILogger logger, IMapperCollection mappers) + : base(work, cache, logger, mappers) { } diff --git a/src/Umbraco.Core/Persistence/Repositories/DictionaryRepository.cs b/src/Umbraco.Core/Persistence/Repositories/DictionaryRepository.cs index c0966ff95c..95574fe05e 100644 --- a/src/Umbraco.Core/Persistence/Repositories/DictionaryRepository.cs +++ b/src/Umbraco.Core/Persistence/Repositories/DictionaryRepository.cs @@ -21,12 +21,12 @@ namespace Umbraco.Core.Persistence.Repositories internal class DictionaryRepository : NPocoRepositoryBase, IDictionaryRepository { private IRepositoryCachePolicy _cachePolicy; - private readonly IMappingResolver _mappingResolver; + private readonly IMapperCollection _mappers; - public DictionaryRepository(IDatabaseUnitOfWork work, CacheHelper cache, ILogger logger, IMappingResolver mappingResolver) - : base(work, cache, logger, mappingResolver) + public DictionaryRepository(IDatabaseUnitOfWork work, CacheHelper cache, ILogger logger, IMapperCollection mappers) + : base(work, cache, logger, mappers) { - _mappingResolver = mappingResolver; + _mappers = mappers; } protected override IRepositoryCachePolicy CachePolicy @@ -243,13 +243,13 @@ namespace Umbraco.Core.Persistence.Repositories public IDictionaryItem Get(Guid uniqueId) { - var uniqueIdRepo = new DictionaryByUniqueIdRepository(this, UnitOfWork, RepositoryCache, Logger, _mappingResolver); + var uniqueIdRepo = new DictionaryByUniqueIdRepository(this, UnitOfWork, RepositoryCache, Logger, _mappers); return uniqueIdRepo.Get(uniqueId); } public IDictionaryItem Get(string key) { - var keyRepo = new DictionaryByKeyRepository(this, UnitOfWork, RepositoryCache, Logger, _mappingResolver); + var keyRepo = new DictionaryByKeyRepository(this, UnitOfWork, RepositoryCache, Logger, _mappers); return keyRepo.Get(key); } @@ -297,8 +297,8 @@ namespace Umbraco.Core.Persistence.Repositories private IRepositoryCachePolicy _cachePolicy; private readonly DictionaryRepository _dictionaryRepository; - public DictionaryByUniqueIdRepository(DictionaryRepository dictionaryRepository, IDatabaseUnitOfWork work, CacheHelper cache, ILogger logger, IMappingResolver mappingResolver) - : base(work, cache, logger, mappingResolver) + public DictionaryByUniqueIdRepository(DictionaryRepository dictionaryRepository, IDatabaseUnitOfWork work, CacheHelper cache, ILogger logger, IMapperCollection mappers) + : base(work, cache, logger, mappers) { _dictionaryRepository = dictionaryRepository; } @@ -358,8 +358,8 @@ namespace Umbraco.Core.Persistence.Repositories private IRepositoryCachePolicy _cachePolicy; private readonly DictionaryRepository _dictionaryRepository; - public DictionaryByKeyRepository(DictionaryRepository dictionaryRepository, IDatabaseUnitOfWork work, CacheHelper cache, ILogger logger, IMappingResolver mappingResolver) - : base(work, cache, logger, mappingResolver) + public DictionaryByKeyRepository(DictionaryRepository dictionaryRepository, IDatabaseUnitOfWork work, CacheHelper cache, ILogger logger, IMapperCollection mappers) + : base(work, cache, logger, mappers) { _dictionaryRepository = dictionaryRepository; } diff --git a/src/Umbraco.Core/Persistence/Repositories/DomainRepository.cs b/src/Umbraco.Core/Persistence/Repositories/DomainRepository.cs index 2bcba58cb1..a5231b8ea6 100644 --- a/src/Umbraco.Core/Persistence/Repositories/DomainRepository.cs +++ b/src/Umbraco.Core/Persistence/Repositories/DomainRepository.cs @@ -22,8 +22,8 @@ namespace Umbraco.Core.Persistence.Repositories { private IRepositoryCachePolicy _cachePolicy; - public DomainRepository(IDatabaseUnitOfWork work, CacheHelper cache, ILogger logger, IMappingResolver mappingResolver) - : base(work, cache, logger, mappingResolver) + public DomainRepository(IDatabaseUnitOfWork work, CacheHelper cache, ILogger logger, IMapperCollection mappers) + : base(work, cache, logger, mappers) { } diff --git a/src/Umbraco.Core/Persistence/Repositories/EntityContainerRepository.cs b/src/Umbraco.Core/Persistence/Repositories/EntityContainerRepository.cs index 9ff81061a4..ca48911429 100644 --- a/src/Umbraco.Core/Persistence/Repositories/EntityContainerRepository.cs +++ b/src/Umbraco.Core/Persistence/Repositories/EntityContainerRepository.cs @@ -22,8 +22,8 @@ namespace Umbraco.Core.Persistence.Repositories { private readonly Guid _containerObjectType; - public EntityContainerRepository(IDatabaseUnitOfWork work, CacheHelper cache, ILogger logger, IMappingResolver mappingResolver, Guid containerObjectType) - : base(work, cache, logger, mappingResolver) + public EntityContainerRepository(IDatabaseUnitOfWork work, CacheHelper cache, ILogger logger, IMapperCollection mappers, Guid containerObjectType) + : base(work, cache, logger, mappers) { var allowedContainers = new[] {Constants.ObjectTypes.DocumentTypeContainerGuid, Constants.ObjectTypes.MediaTypeContainerGuid, Constants.ObjectTypes.DataTypeContainerGuid}; _containerObjectType = containerObjectType; diff --git a/src/Umbraco.Core/Persistence/Repositories/EntityRepository.cs b/src/Umbraco.Core/Persistence/Repositories/EntityRepository.cs index 3f2fc05cd5..c2f1c503eb 100644 --- a/src/Umbraco.Core/Persistence/Repositories/EntityRepository.cs +++ b/src/Umbraco.Core/Persistence/Repositories/EntityRepository.cs @@ -23,10 +23,10 @@ namespace Umbraco.Core.Persistence.Repositories { private readonly QueryFactory _queryFactory; - public EntityRepository(IDatabaseUnitOfWork work, IMappingResolver mappingResolver) + public EntityRepository(IDatabaseUnitOfWork work, IMapperCollection mappers) { UnitOfWork = work; - _queryFactory = new QueryFactory(work.Database.SqlSyntax, mappingResolver); + _queryFactory = new QueryFactory(work.Database.SqlSyntax, mappers); } /// diff --git a/src/Umbraco.Core/Persistence/Repositories/ExternalLoginRepository.cs b/src/Umbraco.Core/Persistence/Repositories/ExternalLoginRepository.cs index 5868216062..2fa0c18ef0 100644 --- a/src/Umbraco.Core/Persistence/Repositories/ExternalLoginRepository.cs +++ b/src/Umbraco.Core/Persistence/Repositories/ExternalLoginRepository.cs @@ -18,8 +18,8 @@ namespace Umbraco.Core.Persistence.Repositories { internal class ExternalLoginRepository : NPocoRepositoryBase, IExternalLoginRepository { - public ExternalLoginRepository(IDatabaseUnitOfWork work, CacheHelper cache, ILogger logger, IMappingResolver mappingResolver) - : base(work, cache, logger, mappingResolver) + public ExternalLoginRepository(IDatabaseUnitOfWork work, CacheHelper cache, ILogger logger, IMapperCollection mappers) + : base(work, cache, logger, mappers) { } diff --git a/src/Umbraco.Core/Persistence/Repositories/Interfaces/DataTypeContainerRepository.cs b/src/Umbraco.Core/Persistence/Repositories/Interfaces/DataTypeContainerRepository.cs index 5eb8e44fbb..0be6f8fde9 100644 --- a/src/Umbraco.Core/Persistence/Repositories/Interfaces/DataTypeContainerRepository.cs +++ b/src/Umbraco.Core/Persistence/Repositories/Interfaces/DataTypeContainerRepository.cs @@ -7,8 +7,8 @@ namespace Umbraco.Core.Persistence.Repositories { class DataTypeContainerRepository : EntityContainerRepository, IDataTypeContainerRepository { - public DataTypeContainerRepository(IDatabaseUnitOfWork uow, CacheHelper cache, ILogger logger, IMappingResolver mappingResolver) - : base(uow, cache, logger, mappingResolver, Constants.ObjectTypes.DataTypeContainerGuid) + public DataTypeContainerRepository(IDatabaseUnitOfWork uow, CacheHelper cache, ILogger logger, IMapperCollection mappers) + : base(uow, cache, logger, mappers, Constants.ObjectTypes.DataTypeContainerGuid) { } } } \ No newline at end of file diff --git a/src/Umbraco.Core/Persistence/Repositories/Interfaces/DocumentTypeContainerRepository.cs b/src/Umbraco.Core/Persistence/Repositories/Interfaces/DocumentTypeContainerRepository.cs index 64b2bb685b..8eaa210a97 100644 --- a/src/Umbraco.Core/Persistence/Repositories/Interfaces/DocumentTypeContainerRepository.cs +++ b/src/Umbraco.Core/Persistence/Repositories/Interfaces/DocumentTypeContainerRepository.cs @@ -7,8 +7,8 @@ namespace Umbraco.Core.Persistence.Repositories { class DocumentTypeContainerRepository : EntityContainerRepository, IDocumentTypeContainerRepository { - public DocumentTypeContainerRepository(IDatabaseUnitOfWork uow, CacheHelper cache, ILogger logger, IMappingResolver mappingResolver) - : base(uow, cache, logger, mappingResolver, Constants.ObjectTypes.DocumentTypeContainerGuid) + public DocumentTypeContainerRepository(IDatabaseUnitOfWork uow, CacheHelper cache, ILogger logger, IMapperCollection mappers) + : base(uow, cache, logger, mappers, Constants.ObjectTypes.DocumentTypeContainerGuid) { } } } \ No newline at end of file diff --git a/src/Umbraco.Core/Persistence/Repositories/Interfaces/MediaTypeContainerRepository.cs b/src/Umbraco.Core/Persistence/Repositories/Interfaces/MediaTypeContainerRepository.cs index 38429f2996..b11d241040 100644 --- a/src/Umbraco.Core/Persistence/Repositories/Interfaces/MediaTypeContainerRepository.cs +++ b/src/Umbraco.Core/Persistence/Repositories/Interfaces/MediaTypeContainerRepository.cs @@ -7,8 +7,8 @@ namespace Umbraco.Core.Persistence.Repositories { class MediaTypeContainerRepository : EntityContainerRepository, IMediaTypeContainerRepository { - public MediaTypeContainerRepository(IDatabaseUnitOfWork uow, CacheHelper cache, ILogger logger, IMappingResolver mappingResolver) - : base(uow, cache, logger, mappingResolver, Constants.ObjectTypes.MediaTypeContainerGuid) + public MediaTypeContainerRepository(IDatabaseUnitOfWork uow, CacheHelper cache, ILogger logger, IMapperCollection mappers) + : base(uow, cache, logger, mappers, Constants.ObjectTypes.MediaTypeContainerGuid) { } } } \ No newline at end of file diff --git a/src/Umbraco.Core/Persistence/Repositories/LanguageRepository.cs b/src/Umbraco.Core/Persistence/Repositories/LanguageRepository.cs index 143eb92055..b97576b5a6 100644 --- a/src/Umbraco.Core/Persistence/Repositories/LanguageRepository.cs +++ b/src/Umbraco.Core/Persistence/Repositories/LanguageRepository.cs @@ -23,8 +23,8 @@ namespace Umbraco.Core.Persistence.Repositories { private IRepositoryCachePolicy _cachePolicy; - public LanguageRepository(IDatabaseUnitOfWork work, CacheHelper cache, ILogger logger, IMappingResolver mappingResolver) - : base(work, cache, logger, mappingResolver) + public LanguageRepository(IDatabaseUnitOfWork work, CacheHelper cache, ILogger logger, IMapperCollection mappers) + : base(work, cache, logger, mappers) { } diff --git a/src/Umbraco.Core/Persistence/Repositories/MacroRepository.cs b/src/Umbraco.Core/Persistence/Repositories/MacroRepository.cs index 29d8c73943..d49ab92efd 100644 --- a/src/Umbraco.Core/Persistence/Repositories/MacroRepository.cs +++ b/src/Umbraco.Core/Persistence/Repositories/MacroRepository.cs @@ -19,8 +19,8 @@ namespace Umbraco.Core.Persistence.Repositories internal class MacroRepository : NPocoRepositoryBase, IMacroRepository { - public MacroRepository(IDatabaseUnitOfWork work, CacheHelper cache, ILogger logger, IMappingResolver mappingResolver) - : base(work, cache, logger, mappingResolver) + public MacroRepository(IDatabaseUnitOfWork work, CacheHelper cache, ILogger logger, IMapperCollection mappers) + : base(work, cache, logger, mappers) { } diff --git a/src/Umbraco.Core/Persistence/Repositories/MediaRepository.cs b/src/Umbraco.Core/Persistence/Repositories/MediaRepository.cs index e0fdfb40a6..b78c636fff 100644 --- a/src/Umbraco.Core/Persistence/Repositories/MediaRepository.cs +++ b/src/Umbraco.Core/Persistence/Repositories/MediaRepository.cs @@ -29,8 +29,8 @@ namespace Umbraco.Core.Persistence.Repositories private readonly IMediaTypeRepository _mediaTypeRepository; private readonly ITagRepository _tagRepository; - public MediaRepository(IDatabaseUnitOfWork work, CacheHelper cache, ILogger logger, IMediaTypeRepository mediaTypeRepository, ITagRepository tagRepository, IContentSection contentSection, IMappingResolver mappingResolver) - : base(work, cache, logger, contentSection, mappingResolver) + public MediaRepository(IDatabaseUnitOfWork work, CacheHelper cache, ILogger logger, IMediaTypeRepository mediaTypeRepository, ITagRepository tagRepository, IContentSection contentSection, IMapperCollection mappers) + : base(work, cache, logger, contentSection, mappers) { if (mediaTypeRepository == null) throw new ArgumentNullException(nameof(mediaTypeRepository)); if (tagRepository == null) throw new ArgumentNullException(nameof(tagRepository)); diff --git a/src/Umbraco.Core/Persistence/Repositories/MediaTypeRepository.cs b/src/Umbraco.Core/Persistence/Repositories/MediaTypeRepository.cs index f79fcac57a..b07ea0c5bc 100644 --- a/src/Umbraco.Core/Persistence/Repositories/MediaTypeRepository.cs +++ b/src/Umbraco.Core/Persistence/Repositories/MediaTypeRepository.cs @@ -19,8 +19,8 @@ namespace Umbraco.Core.Persistence.Repositories { private IRepositoryCachePolicy _cachePolicy; - public MediaTypeRepository(IDatabaseUnitOfWork work, CacheHelper cache, ILogger logger, IMappingResolver mappingResolver) - : base(work, cache, logger, mappingResolver) + public MediaTypeRepository(IDatabaseUnitOfWork work, CacheHelper cache, ILogger logger, IMapperCollection mappers) + : base(work, cache, logger, mappers) { } protected override IRepositoryCachePolicy CachePolicy diff --git a/src/Umbraco.Core/Persistence/Repositories/MemberGroupRepository.cs b/src/Umbraco.Core/Persistence/Repositories/MemberGroupRepository.cs index c15cd73619..2210c981c4 100644 --- a/src/Umbraco.Core/Persistence/Repositories/MemberGroupRepository.cs +++ b/src/Umbraco.Core/Persistence/Repositories/MemberGroupRepository.cs @@ -18,8 +18,8 @@ namespace Umbraco.Core.Persistence.Repositories internal class MemberGroupRepository : NPocoRepositoryBase, IMemberGroupRepository { - public MemberGroupRepository(IDatabaseUnitOfWork work, CacheHelper cache, ILogger logger, IMappingResolver mappingResolver) - : base(work, cache, logger, mappingResolver) + public MemberGroupRepository(IDatabaseUnitOfWork work, CacheHelper cache, ILogger logger, IMapperCollection mappers) + : base(work, cache, logger, mappers) { } private readonly MemberGroupFactory _modelFactory = new MemberGroupFactory(); diff --git a/src/Umbraco.Core/Persistence/Repositories/MemberRepository.cs b/src/Umbraco.Core/Persistence/Repositories/MemberRepository.cs index d643f90c62..139f3b7d6a 100644 --- a/src/Umbraco.Core/Persistence/Repositories/MemberRepository.cs +++ b/src/Umbraco.Core/Persistence/Repositories/MemberRepository.cs @@ -29,8 +29,8 @@ namespace Umbraco.Core.Persistence.Repositories private readonly ITagRepository _tagRepository; private readonly IMemberGroupRepository _memberGroupRepository; - public MemberRepository(IDatabaseUnitOfWork work, CacheHelper cache, ILogger logger, IMemberTypeRepository memberTypeRepository, IMemberGroupRepository memberGroupRepository, ITagRepository tagRepository, IContentSection contentSection, IMappingResolver mappingResolver) - : base(work, cache, logger, contentSection, mappingResolver) + public MemberRepository(IDatabaseUnitOfWork work, CacheHelper cache, ILogger logger, IMemberTypeRepository memberTypeRepository, IMemberGroupRepository memberGroupRepository, ITagRepository tagRepository, IContentSection contentSection, IMapperCollection mappers) + : base(work, cache, logger, contentSection, mappers) { if (memberTypeRepository == null) throw new ArgumentNullException(nameof(memberTypeRepository)); if (tagRepository == null) throw new ArgumentNullException(nameof(tagRepository)); diff --git a/src/Umbraco.Core/Persistence/Repositories/MemberTypeRepository.cs b/src/Umbraco.Core/Persistence/Repositories/MemberTypeRepository.cs index eb18989230..983fc6ca5a 100644 --- a/src/Umbraco.Core/Persistence/Repositories/MemberTypeRepository.cs +++ b/src/Umbraco.Core/Persistence/Repositories/MemberTypeRepository.cs @@ -21,8 +21,8 @@ namespace Umbraco.Core.Persistence.Repositories { private IRepositoryCachePolicy _cachePolicy; - public MemberTypeRepository(IDatabaseUnitOfWork work, CacheHelper cache, ILogger logger, IMappingResolver mappingResolver) - : base(work, cache, logger, mappingResolver) + public MemberTypeRepository(IDatabaseUnitOfWork work, CacheHelper cache, ILogger logger, IMapperCollection mappers) + : base(work, cache, logger, mappers) { } protected override IRepositoryCachePolicy CachePolicy diff --git a/src/Umbraco.Core/Persistence/Repositories/MigrationEntryRepository.cs b/src/Umbraco.Core/Persistence/Repositories/MigrationEntryRepository.cs index 86e2c61e9d..281c752732 100644 --- a/src/Umbraco.Core/Persistence/Repositories/MigrationEntryRepository.cs +++ b/src/Umbraco.Core/Persistence/Repositories/MigrationEntryRepository.cs @@ -19,8 +19,8 @@ namespace Umbraco.Core.Persistence.Repositories { internal class MigrationEntryRepository : NPocoRepositoryBase, IMigrationEntryRepository { - public MigrationEntryRepository(IDatabaseUnitOfWork work, [Inject(RepositoryCompositionRoot.DisabledCache)] CacheHelper cache, ILogger logger, IMappingResolver mappingResolver) - : base(work, cache, logger, mappingResolver) + public MigrationEntryRepository(IDatabaseUnitOfWork work, [Inject(RepositoryCompositionRoot.DisabledCache)] CacheHelper cache, ILogger logger, IMapperCollection mappers) + : base(work, cache, logger, mappers) { } diff --git a/src/Umbraco.Core/Persistence/Repositories/NPocoRepositoryBase.cs b/src/Umbraco.Core/Persistence/Repositories/NPocoRepositoryBase.cs index 44be94df21..80a85c8b00 100644 --- a/src/Umbraco.Core/Persistence/Repositories/NPocoRepositoryBase.cs +++ b/src/Umbraco.Core/Persistence/Repositories/NPocoRepositoryBase.cs @@ -25,11 +25,11 @@ namespace Umbraco.Core.Persistence.Repositories /// A database unit of work. /// A cache helper. /// A logger. - /// A mapping resolver. - protected NPocoRepositoryBase(IDatabaseUnitOfWork work, CacheHelper cache, ILogger logger, IMappingResolver mappingResolver) + /// A mappers collection. + protected NPocoRepositoryBase(IDatabaseUnitOfWork work, CacheHelper cache, ILogger logger, IMapperCollection mappers) : base(work, cache, logger) { - QueryFactory = new QueryFactory(SqlSyntax, mappingResolver); + QueryFactory = new QueryFactory(SqlSyntax, mappers); } /// diff --git a/src/Umbraco.Core/Persistence/Repositories/PublicAccessRepository.cs b/src/Umbraco.Core/Persistence/Repositories/PublicAccessRepository.cs index 84079ca932..b956c42136 100644 --- a/src/Umbraco.Core/Persistence/Repositories/PublicAccessRepository.cs +++ b/src/Umbraco.Core/Persistence/Repositories/PublicAccessRepository.cs @@ -18,8 +18,8 @@ namespace Umbraco.Core.Persistence.Repositories { private IRepositoryCachePolicy _cachePolicy; - public PublicAccessRepository(IDatabaseUnitOfWork work, CacheHelper cache, ILogger logger, IMappingResolver mappingResolver) - : base(work, cache, logger, mappingResolver) + public PublicAccessRepository(IDatabaseUnitOfWork work, CacheHelper cache, ILogger logger, IMapperCollection mappers) + : base(work, cache, logger, mappers) { } diff --git a/src/Umbraco.Core/Persistence/Repositories/RecycleBinRepository.cs b/src/Umbraco.Core/Persistence/Repositories/RecycleBinRepository.cs index 298fa915d6..8df1496d2f 100644 --- a/src/Umbraco.Core/Persistence/Repositories/RecycleBinRepository.cs +++ b/src/Umbraco.Core/Persistence/Repositories/RecycleBinRepository.cs @@ -14,8 +14,8 @@ namespace Umbraco.Core.Persistence.Repositories where TEntity : class, IUmbracoEntity where TRepository : class, IRepository { - protected RecycleBinRepository(IDatabaseUnitOfWork work, CacheHelper cache, ILogger logger, IContentSection contentSection, IMappingResolver mappingResolver) - : base(work, cache, logger, contentSection, mappingResolver) + protected RecycleBinRepository(IDatabaseUnitOfWork work, CacheHelper cache, ILogger logger, IContentSection contentSection, IMapperCollection mappers) + : base(work, cache, logger, contentSection, mappers) { } diff --git a/src/Umbraco.Core/Persistence/Repositories/RedirectUrlRepository.cs b/src/Umbraco.Core/Persistence/Repositories/RedirectUrlRepository.cs index d8cad7b230..ffed648b7a 100644 --- a/src/Umbraco.Core/Persistence/Repositories/RedirectUrlRepository.cs +++ b/src/Umbraco.Core/Persistence/Repositories/RedirectUrlRepository.cs @@ -16,8 +16,8 @@ namespace Umbraco.Core.Persistence.Repositories { internal class RedirectUrlRepository : NPocoRepositoryBase, IRedirectUrlRepository { - public RedirectUrlRepository(IDatabaseUnitOfWork work, CacheHelper cache, ILogger logger, IMappingResolver mappingResolver) - : base(work, cache, logger, mappingResolver) + public RedirectUrlRepository(IDatabaseUnitOfWork work, CacheHelper cache, ILogger logger, IMapperCollection mappers) + : base(work, cache, logger, mappers) { } protected override int PerformCount(IQuery query) diff --git a/src/Umbraco.Core/Persistence/Repositories/RelationRepository.cs b/src/Umbraco.Core/Persistence/Repositories/RelationRepository.cs index 6c58cd3b79..f0ef4e5f0e 100644 --- a/src/Umbraco.Core/Persistence/Repositories/RelationRepository.cs +++ b/src/Umbraco.Core/Persistence/Repositories/RelationRepository.cs @@ -25,8 +25,8 @@ namespace Umbraco.Core.Persistence.Repositories { private readonly IRelationTypeRepository _relationTypeRepository; - public RelationRepository(IDatabaseUnitOfWork work, [Inject(RepositoryCompositionRoot.DisabledCache)] CacheHelper cache, ILogger logger, IRelationTypeRepository relationTypeRepository, IMappingResolver mappingResolver) - : base(work, cache, logger, mappingResolver) + public RelationRepository(IDatabaseUnitOfWork work, [Inject(RepositoryCompositionRoot.DisabledCache)] CacheHelper cache, ILogger logger, IRelationTypeRepository relationTypeRepository, IMapperCollection mappers) + : base(work, cache, logger, mappers) { _relationTypeRepository = relationTypeRepository; } diff --git a/src/Umbraco.Core/Persistence/Repositories/RelationTypeRepository.cs b/src/Umbraco.Core/Persistence/Repositories/RelationTypeRepository.cs index 989f8aee58..d328853509 100644 --- a/src/Umbraco.Core/Persistence/Repositories/RelationTypeRepository.cs +++ b/src/Umbraco.Core/Persistence/Repositories/RelationTypeRepository.cs @@ -24,8 +24,8 @@ namespace Umbraco.Core.Persistence.Repositories internal class RelationTypeRepository : NPocoRepositoryBase, IRelationTypeRepository { - public RelationTypeRepository(IDatabaseUnitOfWork work, [Inject(RepositoryCompositionRoot.DisabledCache)] CacheHelper cache, ILogger logger, IMappingResolver mappingResolver) - : base(work, cache, logger, mappingResolver) + public RelationTypeRepository(IDatabaseUnitOfWork work, [Inject(RepositoryCompositionRoot.DisabledCache)] CacheHelper cache, ILogger logger, IMapperCollection mappers) + : base(work, cache, logger, mappers) { } diff --git a/src/Umbraco.Core/Persistence/Repositories/ServerRegistrationRepository.cs b/src/Umbraco.Core/Persistence/Repositories/ServerRegistrationRepository.cs index 8c3bfdfb83..4132d9de6a 100644 --- a/src/Umbraco.Core/Persistence/Repositories/ServerRegistrationRepository.cs +++ b/src/Umbraco.Core/Persistence/Repositories/ServerRegistrationRepository.cs @@ -18,8 +18,8 @@ namespace Umbraco.Core.Persistence.Repositories { private IRepositoryCachePolicy _cachePolicy; - public ServerRegistrationRepository(IDatabaseUnitOfWork work, CacheHelper cacheHelper, ILogger logger, IMappingResolver mappingResolver) - : base(work, CacheHelper.CreateDisabledCacheHelper(), logger, mappingResolver) + public ServerRegistrationRepository(IDatabaseUnitOfWork work, CacheHelper cacheHelper, ILogger logger, IMapperCollection mappers) + : base(work, CacheHelper.CreateDisabledCacheHelper(), logger, mappers) { } protected override IRepositoryCachePolicy CachePolicy => _cachePolicy diff --git a/src/Umbraco.Core/Persistence/Repositories/SimpleGetRepository.cs b/src/Umbraco.Core/Persistence/Repositories/SimpleGetRepository.cs index 2947fb1724..9c471a98e0 100644 --- a/src/Umbraco.Core/Persistence/Repositories/SimpleGetRepository.cs +++ b/src/Umbraco.Core/Persistence/Repositories/SimpleGetRepository.cs @@ -20,8 +20,8 @@ namespace Umbraco.Core.Persistence.Repositories where TDto: class { - protected SimpleGetRepository(IDatabaseUnitOfWork work, CacheHelper cache, ILogger logger, IMappingResolver mappingResolver) - : base(work, cache, logger, mappingResolver) + protected SimpleGetRepository(IDatabaseUnitOfWork work, CacheHelper cache, ILogger logger, IMapperCollection mappers) + : base(work, cache, logger, mappers) { } diff --git a/src/Umbraco.Core/Persistence/Repositories/TagRepository.cs b/src/Umbraco.Core/Persistence/Repositories/TagRepository.cs index c9bef38b79..9c789d1626 100644 --- a/src/Umbraco.Core/Persistence/Repositories/TagRepository.cs +++ b/src/Umbraco.Core/Persistence/Repositories/TagRepository.cs @@ -19,8 +19,8 @@ namespace Umbraco.Core.Persistence.Repositories { internal class TagRepository : NPocoRepositoryBase, ITagRepository { - public TagRepository(IDatabaseUnitOfWork work, CacheHelper cache, ILogger logger, IMappingResolver mappingResolver) - : base(work, cache, logger, mappingResolver) + public TagRepository(IDatabaseUnitOfWork work, CacheHelper cache, ILogger logger, IMapperCollection mappers) + : base(work, cache, logger, mappers) { } diff --git a/src/Umbraco.Core/Persistence/Repositories/TaskRepository.cs b/src/Umbraco.Core/Persistence/Repositories/TaskRepository.cs index 4765b72060..10df863bff 100644 --- a/src/Umbraco.Core/Persistence/Repositories/TaskRepository.cs +++ b/src/Umbraco.Core/Persistence/Repositories/TaskRepository.cs @@ -20,8 +20,8 @@ namespace Umbraco.Core.Persistence.Repositories { internal class TaskRepository : NPocoRepositoryBase, ITaskRepository { - public TaskRepository(IDatabaseUnitOfWork work, [Inject(RepositoryCompositionRoot.DisabledCache)] CacheHelper cache, ILogger logger, IMappingResolver mappingResolver) - : base(work, cache, logger, mappingResolver) + public TaskRepository(IDatabaseUnitOfWork work, [Inject(RepositoryCompositionRoot.DisabledCache)] CacheHelper cache, ILogger logger, IMapperCollection mappers) + : base(work, cache, logger, mappers) { } diff --git a/src/Umbraco.Core/Persistence/Repositories/TaskTypeRepository.cs b/src/Umbraco.Core/Persistence/Repositories/TaskTypeRepository.cs index d94475c280..1542c3f3c7 100644 --- a/src/Umbraco.Core/Persistence/Repositories/TaskTypeRepository.cs +++ b/src/Umbraco.Core/Persistence/Repositories/TaskTypeRepository.cs @@ -18,8 +18,8 @@ namespace Umbraco.Core.Persistence.Repositories { internal class TaskTypeRepository : NPocoRepositoryBase, ITaskTypeRepository { - public TaskTypeRepository(IDatabaseUnitOfWork work, [Inject(RepositoryCompositionRoot.DisabledCache)] CacheHelper cache, ILogger logger, IMappingResolver mappingResolver) - : base(work, cache, logger, mappingResolver) + public TaskTypeRepository(IDatabaseUnitOfWork work, [Inject(RepositoryCompositionRoot.DisabledCache)] CacheHelper cache, ILogger logger, IMapperCollection mappers) + : base(work, cache, logger, mappers) { } diff --git a/src/Umbraco.Core/Persistence/Repositories/TemplateRepository.cs b/src/Umbraco.Core/Persistence/Repositories/TemplateRepository.cs index 18a58dcac2..3a9fdca352 100644 --- a/src/Umbraco.Core/Persistence/Repositories/TemplateRepository.cs +++ b/src/Umbraco.Core/Persistence/Repositories/TemplateRepository.cs @@ -37,8 +37,8 @@ namespace Umbraco.Core.Persistence.Repositories private readonly MasterPageHelper _masterPageHelper; private IRepositoryCachePolicy _cachePolicy; - public TemplateRepository(IDatabaseUnitOfWork work, CacheHelper cache, ILogger logger, IFileSystem masterpageFileSystem, IFileSystem viewFileSystem, ITemplatesSection templateConfig, IMappingResolver mappingResolver) - : base(work, cache, logger, mappingResolver) + public TemplateRepository(IDatabaseUnitOfWork work, CacheHelper cache, ILogger logger, IFileSystem masterpageFileSystem, IFileSystem viewFileSystem, ITemplatesSection templateConfig, IMapperCollection mappers) + : base(work, cache, logger, mappers) { _masterpagesFileSystem = masterpageFileSystem; _viewsFileSystem = viewFileSystem; diff --git a/src/Umbraco.Core/Persistence/Repositories/UserRepository.cs b/src/Umbraco.Core/Persistence/Repositories/UserRepository.cs index c966693b62..6140b06489 100644 --- a/src/Umbraco.Core/Persistence/Repositories/UserRepository.cs +++ b/src/Umbraco.Core/Persistence/Repositories/UserRepository.cs @@ -28,8 +28,8 @@ namespace Umbraco.Core.Persistence.Repositories private readonly CacheHelper _cacheHelper; private PermissionRepository _permissionRepository; - public UserRepository(IDatabaseUnitOfWork work, CacheHelper cacheHelper, ILogger logger, IUserTypeRepository userTypeRepository, IMappingResolver mappingResolver) - : base(work, cacheHelper, logger, mappingResolver) + public UserRepository(IDatabaseUnitOfWork work, CacheHelper cacheHelper, ILogger logger, IUserTypeRepository userTypeRepository, IMapperCollection mappers) + : base(work, cacheHelper, logger, mappers) { _userTypeRepository = userTypeRepository; _cacheHelper = cacheHelper; @@ -349,7 +349,7 @@ namespace Umbraco.Core.Persistence.Repositories //get the referenced column name var expressionMember = ExpressionHelper.GetMemberInfo(orderBy); //now find the mapped column name - var mapper = QueryFactory.MappingResolver.ResolveMapperByType(typeof(IUser)); + var mapper = QueryFactory.Mappers[typeof(IUser)]; var mappedField = mapper.Map(SqlSyntax, expressionMember.Name); if (mappedField.IsNullOrWhiteSpace()) { diff --git a/src/Umbraco.Core/Persistence/Repositories/UserTypeRepository.cs b/src/Umbraco.Core/Persistence/Repositories/UserTypeRepository.cs index d2ee75dbf0..c1aabb4fe3 100644 --- a/src/Umbraco.Core/Persistence/Repositories/UserTypeRepository.cs +++ b/src/Umbraco.Core/Persistence/Repositories/UserTypeRepository.cs @@ -20,8 +20,8 @@ namespace Umbraco.Core.Persistence.Repositories /// internal class UserTypeRepository : NPocoRepositoryBase, IUserTypeRepository { - public UserTypeRepository(IDatabaseUnitOfWork work, CacheHelper cache, ILogger logger, IMappingResolver mappingResolver) - : base(work, cache, logger, mappingResolver) + public UserTypeRepository(IDatabaseUnitOfWork work, CacheHelper cache, ILogger logger, IMapperCollection mappers) + : base(work, cache, logger, mappers) { } diff --git a/src/Umbraco.Core/Persistence/Repositories/VersionableRepositoryBase.cs b/src/Umbraco.Core/Persistence/Repositories/VersionableRepositoryBase.cs index ad804bad84..46f9cc4b0b 100644 --- a/src/Umbraco.Core/Persistence/Repositories/VersionableRepositoryBase.cs +++ b/src/Umbraco.Core/Persistence/Repositories/VersionableRepositoryBase.cs @@ -52,8 +52,8 @@ namespace Umbraco.Core.Persistence.Repositories { private readonly IContentSection _contentSection; - protected VersionableRepositoryBase(IDatabaseUnitOfWork work, CacheHelper cache, ILogger logger, IContentSection contentSection, IMappingResolver mappingResolver) - : base(work, cache, logger, mappingResolver) + protected VersionableRepositoryBase(IDatabaseUnitOfWork work, CacheHelper cache, ILogger logger, IContentSection contentSection, IMapperCollection mappers) + : base(work, cache, logger, mappers) { _contentSection = contentSection; } diff --git a/src/Umbraco.Core/Umbraco.Core.csproj b/src/Umbraco.Core/Umbraco.Core.csproj index a42d9637b9..ab6faed426 100644 --- a/src/Umbraco.Core/Umbraco.Core.csproj +++ b/src/Umbraco.Core/Umbraco.Core.csproj @@ -271,6 +271,9 @@ + + + @@ -329,7 +332,6 @@ - @@ -804,7 +806,6 @@ - diff --git a/src/Umbraco.Tests/Persistence/DatabaseContextTests.cs b/src/Umbraco.Tests/Persistence/DatabaseContextTests.cs index 516ce55f2e..ef9c59b3c8 100644 --- a/src/Umbraco.Tests/Persistence/DatabaseContextTests.cs +++ b/src/Umbraco.Tests/Persistence/DatabaseContextTests.cs @@ -33,7 +33,7 @@ namespace Umbraco.Tests.Persistence _sqlCeSyntaxProvider = new SqlCeSyntaxProvider(); _sqlSyntaxProviders = new[] { (ISqlSyntaxProvider) _sqlCeSyntaxProvider }; _logger = Mock.Of(); - var dbFactory = new DefaultDatabaseFactory(Core.Configuration.GlobalSettings.UmbracoConnectionName, _sqlSyntaxProviders, _logger, new TestUmbracoDatabaseAccessor(), Mock.Of()); + var dbFactory = new DefaultDatabaseFactory(Core.Configuration.GlobalSettings.UmbracoConnectionName, _sqlSyntaxProviders, _logger, new TestUmbracoDatabaseAccessor(), Mock.Of()); _dbContext = new DatabaseContext(dbFactory, _logger); } @@ -84,7 +84,7 @@ namespace Umbraco.Tests.Persistence } // re-create the database factory and database context with proper connection string - var dbFactory = new DefaultDatabaseFactory(connString, Constants.DbProviderNames.SqlCe, _sqlSyntaxProviders, _logger, new TestUmbracoDatabaseAccessor(), Mock.Of()); + var dbFactory = new DefaultDatabaseFactory(connString, Constants.DbProviderNames.SqlCe, _sqlSyntaxProviders, _logger, new TestUmbracoDatabaseAccessor(), Mock.Of()); _dbContext = new DatabaseContext(dbFactory, _logger); // create application context diff --git a/src/Umbraco.Tests/Persistence/FaultHandling/ConnectionRetryTest.cs b/src/Umbraco.Tests/Persistence/FaultHandling/ConnectionRetryTest.cs index 86da14036c..97c23004ae 100644 --- a/src/Umbraco.Tests/Persistence/FaultHandling/ConnectionRetryTest.cs +++ b/src/Umbraco.Tests/Persistence/FaultHandling/ConnectionRetryTest.cs @@ -21,7 +21,7 @@ namespace Umbraco.Tests.Persistence.FaultHandling const string connectionString = @"server=.\SQLEXPRESS;database=EmptyForTest;user id=x;password=umbraco"; const string providerName = Constants.DbProviderNames.SqlServer; var sqlSyntax = new[] { new SqlServerSyntaxProvider(new Lazy(() => null)) }; - var factory = new DefaultDatabaseFactory(connectionString, providerName, sqlSyntax, Mock.Of(), new TestUmbracoDatabaseAccessor(), Mock.Of()); + var factory = new DefaultDatabaseFactory(connectionString, providerName, sqlSyntax, Mock.Of(), new TestUmbracoDatabaseAccessor(), Mock.Of()); var database = factory.GetDatabase(); //Act @@ -36,7 +36,7 @@ namespace Umbraco.Tests.Persistence.FaultHandling const string connectionString = @"server=.\SQLEXPRESS;database=EmptyForTest;user id=umbraco;password=umbraco"; const string providerName = Constants.DbProviderNames.SqlServer; var sqlSyntax = new[] { new SqlServerSyntaxProvider(new Lazy(() => null)) }; - var factory = new DefaultDatabaseFactory(connectionString, providerName, sqlSyntax, Mock.Of(), new TestUmbracoDatabaseAccessor(), Mock.Of()); + var factory = new DefaultDatabaseFactory(connectionString, providerName, sqlSyntax, Mock.Of(), new TestUmbracoDatabaseAccessor(), Mock.Of()); var database = factory.GetDatabase(); //Act diff --git a/src/Umbraco.Tests/Persistence/Querying/QueryBuilderTests.cs b/src/Umbraco.Tests/Persistence/Querying/QueryBuilderTests.cs index 489c13fcf9..9d55241d04 100644 --- a/src/Umbraco.Tests/Persistence/Querying/QueryBuilderTests.cs +++ b/src/Umbraco.Tests/Persistence/Querying/QueryBuilderTests.cs @@ -24,7 +24,7 @@ namespace Umbraco.Tests.Persistence.Querying sql.SelectAll(); sql.From("umbracoNode"); - var query = new Query(SqlContext.SqlSyntax, MappingResolver).Where(x => x.Path.StartsWith("-1")); + var query = new Query(SqlContext.SqlSyntax, Mappers).Where(x => x.Path.StartsWith("-1")); // Act var translator = new SqlTranslator(sql, query); @@ -51,7 +51,7 @@ namespace Umbraco.Tests.Persistence.Querying sql.SelectAll(); sql.From("umbracoNode"); - var query = new Query(SqlContext.SqlSyntax, MappingResolver).Where(x => x.ParentId == -1); + var query = new Query(SqlContext.SqlSyntax, Mappers).Where(x => x.ParentId == -1); // Act var translator = new SqlTranslator(sql, query); @@ -78,7 +78,7 @@ namespace Umbraco.Tests.Persistence.Querying sql.SelectAll(); sql.From("umbracoNode"); - var query = new Query(SqlContext.SqlSyntax, MappingResolver).Where(x => x.Alias == "umbTextpage"); + var query = new Query(SqlContext.SqlSyntax, Mappers).Where(x => x.Alias == "umbTextpage"); // Act var translator = new SqlTranslator(sql, query); @@ -115,7 +115,7 @@ namespace Umbraco.Tests.Persistence.Querying .On(left => left.NodeId, right => right.NodeId) .Where(x => x.NodeObjectType == nodeObjectTypeId); - var query = new Query(SqlContext.SqlSyntax, MappingResolver).Where(x => x.Path.StartsWith(path) && x.Id != id && x.Published == true && x.Trashed == false); + var query = new Query(SqlContext.SqlSyntax, Mappers).Where(x => x.Path.StartsWith(path) && x.Id != id && x.Published == true && x.Trashed == false); // Act var translator = new SqlTranslator(sql, query); diff --git a/src/Umbraco.Tests/Persistence/Repositories/AuditRepositoryTest.cs b/src/Umbraco.Tests/Persistence/Repositories/AuditRepositoryTest.cs index a5ba3bec72..872de57ce1 100644 --- a/src/Umbraco.Tests/Persistence/Repositories/AuditRepositoryTest.cs +++ b/src/Umbraco.Tests/Persistence/Repositories/AuditRepositoryTest.cs @@ -18,7 +18,7 @@ namespace Umbraco.Tests.Persistence.Repositories var provider = TestObjects.GetDatabaseUnitOfWorkProvider(Logger); using (var unitOfWork = provider.CreateUnitOfWork()) { - var repo = new AuditRepository(unitOfWork, CacheHelper, Logger, MappingResolver); + var repo = new AuditRepository(unitOfWork, CacheHelper, Logger, Mappers); repo.AddOrUpdate(new AuditItem(-1, "This is a System audit trail", AuditType.System, 0)); unitOfWork.Complete(); } diff --git a/src/Umbraco.Tests/Persistence/Repositories/ContentRepositoryTest.cs b/src/Umbraco.Tests/Persistence/Repositories/ContentRepositoryTest.cs index cf42f4a739..bb22406cf8 100644 --- a/src/Umbraco.Tests/Persistence/Repositories/ContentRepositoryTest.cs +++ b/src/Umbraco.Tests/Persistence/Repositories/ContentRepositoryTest.cs @@ -47,7 +47,7 @@ namespace Umbraco.Tests.Persistence.Repositories { TemplateRepository tr; var ctRepository = CreateRepository(unitOfWork, out contentTypeRepository, out tr); - dtdRepository = new DataTypeDefinitionRepository(unitOfWork, CacheHelper, Logger, contentTypeRepository, MappingResolver); + dtdRepository = new DataTypeDefinitionRepository(unitOfWork, CacheHelper, Logger, contentTypeRepository, Mappers); return ctRepository; } @@ -59,10 +59,10 @@ namespace Umbraco.Tests.Persistence.Repositories private ContentRepository CreateRepository(IDatabaseUnitOfWork unitOfWork, out ContentTypeRepository contentTypeRepository, out TemplateRepository templateRepository) { - templateRepository = new TemplateRepository(unitOfWork, CacheHelper, Logger, Mock.Of(), Mock.Of(), Mock.Of(), MappingResolver); - var tagRepository = new TagRepository(unitOfWork, CacheHelper, Logger, MappingResolver); - contentTypeRepository = new ContentTypeRepository(unitOfWork, CacheHelper, Logger, templateRepository, MappingResolver); - var repository = new ContentRepository(unitOfWork, CacheHelper, Logger, contentTypeRepository, templateRepository, tagRepository, Mock.Of(), MappingResolver); + templateRepository = new TemplateRepository(unitOfWork, CacheHelper, Logger, Mock.Of(), Mock.Of(), Mock.Of(), Mappers); + var tagRepository = new TagRepository(unitOfWork, CacheHelper, Logger, Mappers); + contentTypeRepository = new ContentTypeRepository(unitOfWork, CacheHelper, Logger, templateRepository, Mappers); + var repository = new ContentRepository(unitOfWork, CacheHelper, Logger, contentTypeRepository, templateRepository, tagRepository, Mock.Of(), Mappers); return repository; } @@ -618,7 +618,7 @@ namespace Umbraco.Tests.Persistence.Repositories long totalRecords; - var filterQuery = new Query(SqlSyntax, MappingResolver).Where(x => x.Name.Contains("Page 2")); + var filterQuery = new Query(SqlSyntax, Mappers).Where(x => x.Name.Contains("Page 2")); var result = repository.GetPagedResultsByQuery(query, 0, 1, out totalRecords, "Name", Direction.Ascending, true, filterQuery); // Assert @@ -642,7 +642,7 @@ namespace Umbraco.Tests.Persistence.Repositories long totalRecords; - var filterQuery = new Query(SqlSyntax, MappingResolver).Where(x => x.Name.Contains("text")); + var filterQuery = new Query(SqlSyntax, Mappers).Where(x => x.Name.Contains("text")); var result = repository.GetPagedResultsByQuery(query, 0, 1, out totalRecords, "Name", Direction.Ascending, true, filterQuery); // Assert diff --git a/src/Umbraco.Tests/Persistence/Repositories/ContentTypeRepositoryTest.cs b/src/Umbraco.Tests/Persistence/Repositories/ContentTypeRepositoryTest.cs index e6ca809f1c..c06c9ab5db 100644 --- a/src/Umbraco.Tests/Persistence/Repositories/ContentTypeRepositoryTest.cs +++ b/src/Umbraco.Tests/Persistence/Repositories/ContentTypeRepositoryTest.cs @@ -44,29 +44,29 @@ namespace Umbraco.Tests.Persistence.Repositories private ContentRepository CreateRepository(IDatabaseUnitOfWork unitOfWork, out ContentTypeRepository contentTypeRepository) { - var templateRepository = new TemplateRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Logger, Mock.Of(), Mock.Of(), Mock.Of(), MappingResolver); - var tagRepository = new TagRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Logger, MappingResolver); - contentTypeRepository = new ContentTypeRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Logger, templateRepository, MappingResolver); - var repository = new ContentRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Logger, contentTypeRepository, templateRepository, tagRepository, Mock.Of(), MappingResolver); + var templateRepository = new TemplateRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Logger, Mock.Of(), Mock.Of(), Mock.Of(), Mappers); + var tagRepository = new TagRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Logger, Mappers); + contentTypeRepository = new ContentTypeRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Logger, templateRepository, Mappers); + var repository = new ContentRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Logger, contentTypeRepository, templateRepository, tagRepository, Mock.Of(), Mappers); return repository; } private ContentTypeRepository CreateRepository(IDatabaseUnitOfWork unitOfWork) { - var templateRepository = new TemplateRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Logger, Mock.Of(), Mock.Of(), Mock.Of(), MappingResolver); - var contentTypeRepository = new ContentTypeRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Logger, templateRepository, MappingResolver); + var templateRepository = new TemplateRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Logger, Mock.Of(), Mock.Of(), Mock.Of(), Mappers); + var contentTypeRepository = new ContentTypeRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Logger, templateRepository, Mappers); return contentTypeRepository; } private MediaTypeRepository CreateMediaTypeRepository(IDatabaseUnitOfWork unitOfWork) { - var contentTypeRepository = new MediaTypeRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Logger, MappingResolver); + var contentTypeRepository = new MediaTypeRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Logger, Mappers); return contentTypeRepository; } private EntityContainerRepository CreateContainerRepository(IDatabaseUnitOfWork unitOfWork, Guid containerEntityType) { - return new EntityContainerRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Logger, MappingResolver, containerEntityType); + return new EntityContainerRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Logger, Mappers, containerEntityType); } //TODO Add test to verify SetDefaultTemplates updates both AllowedTemplates and DefaultTemplate(id). @@ -79,7 +79,7 @@ namespace Umbraco.Tests.Persistence.Repositories var provider = TestObjects.GetDatabaseUnitOfWorkProvider(Logger); using (var unitOfWork = provider.CreateUnitOfWork()) { - var templateRepo = new TemplateRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Logger, Mock.Of(), Mock.Of(), Mock.Of(), MappingResolver); + var templateRepo = new TemplateRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Logger, Mock.Of(), Mock.Of(), Mock.Of(), Mappers); var repository = CreateRepository(unitOfWork); var templates = new[] { diff --git a/src/Umbraco.Tests/Persistence/Repositories/DataTypeDefinitionRepositoryTest.cs b/src/Umbraco.Tests/Persistence/Repositories/DataTypeDefinitionRepositoryTest.cs index 679d5b5bd9..19f8ea504a 100644 --- a/src/Umbraco.Tests/Persistence/Repositories/DataTypeDefinitionRepositoryTest.cs +++ b/src/Umbraco.Tests/Persistence/Repositories/DataTypeDefinitionRepositoryTest.cs @@ -59,7 +59,7 @@ namespace Umbraco.Tests.Persistence.Repositories private EntityContainerRepository CreateContainerRepository(IDatabaseUnitOfWork unitOfWork) { - return new EntityContainerRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Logger, MappingResolver, Constants.ObjectTypes.DataTypeContainerGuid); + return new EntityContainerRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Logger, Mappers, Constants.ObjectTypes.DataTypeContainerGuid); } [TestCase("UmbracoPreVal87-21,3,48", 3, true)] @@ -305,7 +305,7 @@ namespace Umbraco.Tests.Persistence.Repositories var repository = CreateRepository(unitOfWork); // Act - var query = new Query(SqlSyntax, MappingResolver).Where(x => x.PropertyEditorAlias == Constants.PropertyEditors.RadioButtonListAlias); + var query = new Query(SqlSyntax, Mappers).Where(x => x.PropertyEditorAlias == Constants.PropertyEditors.RadioButtonListAlias); var result = repository.GetByQuery(query); // Assert @@ -325,7 +325,7 @@ namespace Umbraco.Tests.Persistence.Repositories var repository = CreateRepository(unitOfWork); // Act - var query = new Query(SqlSyntax, MappingResolver).Where(x => x.Name.StartsWith("D")); + var query = new Query(SqlSyntax, Mappers).Where(x => x.Name.StartsWith("D")); int count = repository.Count(query); // Assert diff --git a/src/Umbraco.Tests/Persistence/Repositories/DictionaryRepositoryTest.cs b/src/Umbraco.Tests/Persistence/Repositories/DictionaryRepositoryTest.cs index c7812137f1..573a895518 100644 --- a/src/Umbraco.Tests/Persistence/Repositories/DictionaryRepositoryTest.cs +++ b/src/Umbraco.Tests/Persistence/Repositories/DictionaryRepositoryTest.cs @@ -206,7 +206,7 @@ namespace Umbraco.Tests.Persistence.Repositories var repository = CreateRepository(unitOfWork); // Act - var query = new Query(SqlSyntax, MappingResolver).Where(x => x.ItemKey == "Article"); + var query = new Query(SqlSyntax, Mappers).Where(x => x.ItemKey == "Article"); var result = repository.GetByQuery(query); // Assert @@ -226,7 +226,7 @@ namespace Umbraco.Tests.Persistence.Repositories var repository = CreateRepository(unitOfWork); // Act - var query = new Query(SqlSyntax, MappingResolver).Where(x => x.ItemKey.StartsWith("Read")); + var query = new Query(SqlSyntax, Mappers).Where(x => x.ItemKey.StartsWith("Read")); var result = repository.Count(query); // Assert diff --git a/src/Umbraco.Tests/Persistence/Repositories/DomainRepositoryTest.cs b/src/Umbraco.Tests/Persistence/Repositories/DomainRepositoryTest.cs index 1bf49453e1..a4da78ce80 100644 --- a/src/Umbraco.Tests/Persistence/Repositories/DomainRepositoryTest.cs +++ b/src/Umbraco.Tests/Persistence/Repositories/DomainRepositoryTest.cs @@ -19,12 +19,12 @@ namespace Umbraco.Tests.Persistence.Repositories { private DomainRepository CreateRepository(IDatabaseUnitOfWork unitOfWork, out ContentTypeRepository contentTypeRepository, out ContentRepository contentRepository, out LanguageRepository languageRepository) { - var templateRepository = new TemplateRepository(unitOfWork, DisabledCache, Logger, Mock.Of(), Mock.Of(), Mock.Of(), MappingResolver); - var tagRepository = new TagRepository(unitOfWork, DisabledCache, Logger, MappingResolver); - contentTypeRepository = new ContentTypeRepository(unitOfWork, DisabledCache, Logger, templateRepository, MappingResolver); - contentRepository = new ContentRepository(unitOfWork, DisabledCache, Logger, contentTypeRepository, templateRepository, tagRepository, Mock.Of(), MappingResolver); - languageRepository = new LanguageRepository(unitOfWork, DisabledCache, Logger, MappingResolver); - var domainRepository = new DomainRepository(unitOfWork, DisabledCache, Logger, MappingResolver); + var templateRepository = new TemplateRepository(unitOfWork, DisabledCache, Logger, Mock.Of(), Mock.Of(), Mock.Of(), Mappers); + var tagRepository = new TagRepository(unitOfWork, DisabledCache, Logger, Mappers); + contentTypeRepository = new ContentTypeRepository(unitOfWork, DisabledCache, Logger, templateRepository, Mappers); + contentRepository = new ContentRepository(unitOfWork, DisabledCache, Logger, contentTypeRepository, templateRepository, tagRepository, Mock.Of(), Mappers); + languageRepository = new LanguageRepository(unitOfWork, DisabledCache, Logger, Mappers); + var domainRepository = new DomainRepository(unitOfWork, DisabledCache, Logger, Mappers); return domainRepository; } diff --git a/src/Umbraco.Tests/Persistence/Repositories/LanguageRepositoryTest.cs b/src/Umbraco.Tests/Persistence/Repositories/LanguageRepositoryTest.cs index 1cc3f42abd..0f0ffedf51 100644 --- a/src/Umbraco.Tests/Persistence/Repositories/LanguageRepositoryTest.cs +++ b/src/Umbraco.Tests/Persistence/Repositories/LanguageRepositoryTest.cs @@ -29,7 +29,7 @@ namespace Umbraco.Tests.Persistence.Repositories private LanguageRepository CreateRepository(IDatabaseUnitOfWork unitOfWork) { - return new LanguageRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of(), MappingResolver); + return new LanguageRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of(), Mappers); } @@ -176,7 +176,7 @@ namespace Umbraco.Tests.Persistence.Repositories var repository = CreateRepository(unitOfWork); // Act - var query = new Query(SqlSyntax, MappingResolver).Where(x => x.IsoCode == "da-DK"); + var query = new Query(SqlSyntax, Mappers).Where(x => x.IsoCode == "da-DK"); var result = repository.GetByQuery(query); // Assert @@ -196,7 +196,7 @@ namespace Umbraco.Tests.Persistence.Repositories var repository = CreateRepository(unitOfWork); // Act - var query = new Query(SqlSyntax, MappingResolver).Where(x => x.IsoCode.StartsWith("D")); + var query = new Query(SqlSyntax, Mappers).Where(x => x.IsoCode.StartsWith("D")); int count = repository.Count(query); // Assert diff --git a/src/Umbraco.Tests/Persistence/Repositories/MacroRepositoryTest.cs b/src/Umbraco.Tests/Persistence/Repositories/MacroRepositoryTest.cs index 8ed839e950..8a7068c9eb 100644 --- a/src/Umbraco.Tests/Persistence/Repositories/MacroRepositoryTest.cs +++ b/src/Umbraco.Tests/Persistence/Repositories/MacroRepositoryTest.cs @@ -34,7 +34,7 @@ namespace Umbraco.Tests.Persistence.Repositories var provider = TestObjects.GetDatabaseUnitOfWorkProvider(Logger); using (var unitOfWork = provider.CreateUnitOfWork()) { - var repository = new MacroRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of(), MappingResolver); + var repository = new MacroRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of(), Mappers); var macro = new Macro("test1", "Test", "~/usercontrol/blah.ascx", "MyAssembly", "test.xslt", "~/views/macropartials/test.cshtml"); repository.AddOrUpdate(macro); @@ -51,7 +51,7 @@ namespace Umbraco.Tests.Persistence.Repositories var provider = TestObjects.GetDatabaseUnitOfWorkProvider(Logger); using (var unitOfWork = provider.CreateUnitOfWork()) { - var repository = new MacroRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of(), MappingResolver); + var repository = new MacroRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of(), Mappers); var macro = repository.Get(1); macro.Alias = "test2"; @@ -68,7 +68,7 @@ namespace Umbraco.Tests.Persistence.Repositories var provider = TestObjects.GetDatabaseUnitOfWorkProvider(Logger); using (var unitOfWork = provider.CreateUnitOfWork()) { - var repository = new MacroRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of(), MappingResolver); + var repository = new MacroRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of(), Mappers); // Assert Assert.That(repository, Is.Not.Null); @@ -82,7 +82,7 @@ namespace Umbraco.Tests.Persistence.Repositories var provider = TestObjects.GetDatabaseUnitOfWorkProvider(Logger); using (var unitOfWork = provider.CreateUnitOfWork()) { - var repository = new MacroRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of(), MappingResolver); + var repository = new MacroRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of(), Mappers); // Act var macro = repository.Get(1); @@ -113,7 +113,7 @@ namespace Umbraco.Tests.Persistence.Repositories var provider = TestObjects.GetDatabaseUnitOfWorkProvider(Logger); using (var unitOfWork = provider.CreateUnitOfWork()) { - var repository = new MacroRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of(), MappingResolver); + var repository = new MacroRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of(), Mappers); // Act var macros = repository.GetAll(); @@ -131,10 +131,10 @@ namespace Umbraco.Tests.Persistence.Repositories var provider = TestObjects.GetDatabaseUnitOfWorkProvider(Logger); using (var unitOfWork = provider.CreateUnitOfWork()) { - var repository = new MacroRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of(), MappingResolver); + var repository = new MacroRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of(), Mappers); // Act - var query = new Query(SqlSyntax, MappingResolver).Where(x => x.Alias.ToUpper() == "TEST1"); + var query = new Query(SqlSyntax, Mappers).Where(x => x.Alias.ToUpper() == "TEST1"); var result = repository.GetByQuery(query); // Assert @@ -149,10 +149,10 @@ namespace Umbraco.Tests.Persistence.Repositories var provider = TestObjects.GetDatabaseUnitOfWorkProvider(Logger); using (var unitOfWork = provider.CreateUnitOfWork()) { - var repository = new MacroRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of(), MappingResolver); + var repository = new MacroRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of(), Mappers); // Act - var query = new Query(SqlSyntax, MappingResolver).Where(x => x.Name.StartsWith("Test")); + var query = new Query(SqlSyntax, Mappers).Where(x => x.Name.StartsWith("Test")); int count = repository.Count(query); // Assert @@ -167,7 +167,7 @@ namespace Umbraco.Tests.Persistence.Repositories var provider = TestObjects.GetDatabaseUnitOfWorkProvider(Logger); using (var unitOfWork = provider.CreateUnitOfWork()) { - var repository = new MacroRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of(), MappingResolver); + var repository = new MacroRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of(), Mappers); // Act var macro = new Macro("test", "Test", "~/usercontrol/blah.ascx", "MyAssembly", "test.xslt", "~/views/macropartials/test.cshtml"); @@ -189,7 +189,7 @@ namespace Umbraco.Tests.Persistence.Repositories var provider = TestObjects.GetDatabaseUnitOfWorkProvider(Logger); using (var unitOfWork = provider.CreateUnitOfWork()) { - var repository = new MacroRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of(), MappingResolver); + var repository = new MacroRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of(), Mappers); // Act var macro = repository.Get(2); @@ -231,7 +231,7 @@ namespace Umbraco.Tests.Persistence.Repositories var provider = TestObjects.GetDatabaseUnitOfWorkProvider(Logger); using (var unitOfWork = provider.CreateUnitOfWork()) { - var repository = new MacroRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of(), MappingResolver); + var repository = new MacroRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of(), Mappers); // Act var macro = repository.Get(3); @@ -253,7 +253,7 @@ namespace Umbraco.Tests.Persistence.Repositories var provider = TestObjects.GetDatabaseUnitOfWorkProvider(Logger); using (var unitOfWork = provider.CreateUnitOfWork()) { - var repository = new MacroRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of(), MappingResolver); + var repository = new MacroRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of(), Mappers); // Act var exists = repository.Exists(3); @@ -272,7 +272,7 @@ namespace Umbraco.Tests.Persistence.Repositories var provider = TestObjects.GetDatabaseUnitOfWorkProvider(Logger); using (var unitOfWork = provider.CreateUnitOfWork()) { - var repository = new MacroRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of(), MappingResolver); + var repository = new MacroRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of(), Mappers); var macro = repository.Get(1); macro.Properties.Add(new MacroProperty("new1", "New1", 3, "test")); @@ -300,7 +300,7 @@ namespace Umbraco.Tests.Persistence.Repositories var provider = TestObjects.GetDatabaseUnitOfWorkProvider(Logger); using (var unitOfWork = provider.CreateUnitOfWork()) { - var repository = new MacroRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of(), MappingResolver); + var repository = new MacroRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of(), Mappers); var macro = new Macro("newmacro", "A new macro", "~/usercontrol/test1.ascx", "MyAssembly1", "test1.xslt", "~/views/macropartials/test1.cshtml"); macro.Properties.Add(new MacroProperty("blah1", "New1", 4, "test.editor")); @@ -326,7 +326,7 @@ namespace Umbraco.Tests.Persistence.Repositories var provider = TestObjects.GetDatabaseUnitOfWorkProvider(Logger); using (var unitOfWork = provider.CreateUnitOfWork()) { - var repository = new MacroRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of(), MappingResolver); + var repository = new MacroRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of(), Mappers); var macro = new Macro("newmacro", "A new macro", "~/usercontrol/test1.ascx", "MyAssembly1", "test1.xslt", "~/views/macropartials/test1.cshtml"); macro.Properties.Add(new MacroProperty("blah1", "New1", 4, "test.editor")); @@ -352,7 +352,7 @@ namespace Umbraco.Tests.Persistence.Repositories var provider = TestObjects.GetDatabaseUnitOfWorkProvider(Logger); using (var unitOfWork = provider.CreateUnitOfWork()) { - var repository = new MacroRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of(), MappingResolver); + var repository = new MacroRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of(), Mappers); var macro = new Macro("newmacro", "A new macro", "~/usercontrol/test1.ascx", "MyAssembly1", "test1.xslt", "~/views/macropartials/test1.cshtml"); var prop1 = new MacroProperty("blah1", "New1", 4, "test.editor"); @@ -384,7 +384,7 @@ namespace Umbraco.Tests.Persistence.Repositories var provider = TestObjects.GetDatabaseUnitOfWorkProvider(Logger); using (var unitOfWork = provider.CreateUnitOfWork()) { - var repository = new MacroRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of(), MappingResolver); + var repository = new MacroRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of(), Mappers); var macro = repository.Get(1); macro.Properties.Add(new MacroProperty("new1", "New1", 3, "test")); @@ -413,7 +413,7 @@ namespace Umbraco.Tests.Persistence.Repositories var provider = TestObjects.GetDatabaseUnitOfWorkProvider(Logger); using (var unitOfWork = provider.CreateUnitOfWork()) { - var repository = new MacroRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of(), MappingResolver); + var repository = new MacroRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of(), Mappers); var macro = repository.Get(1); macro.Properties.Add(new MacroProperty("new1", "New1", 3, "test")); @@ -443,7 +443,7 @@ namespace Umbraco.Tests.Persistence.Repositories var provider = TestObjects.GetDatabaseUnitOfWorkProvider(Logger); using (var unitOfWork = provider.CreateUnitOfWork()) { - var repository = new MacroRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of(), MappingResolver); + var repository = new MacroRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of(), Mappers); repository.AddOrUpdate(new Macro("test1", "Test1", "~/usercontrol/test1.ascx", "MyAssembly1", "test1.xslt", "~/views/macropartials/test1.cshtml")); repository.AddOrUpdate(new Macro("test2", "Test2", "~/usercontrol/test2.ascx", "MyAssembly2", "test2.xslt", "~/views/macropartials/test2.cshtml")); diff --git a/src/Umbraco.Tests/Persistence/Repositories/MediaRepositoryTest.cs b/src/Umbraco.Tests/Persistence/Repositories/MediaRepositoryTest.cs index 6ca383ff1c..a78db388a5 100644 --- a/src/Umbraco.Tests/Persistence/Repositories/MediaRepositoryTest.cs +++ b/src/Umbraco.Tests/Persistence/Repositories/MediaRepositoryTest.cs @@ -35,9 +35,9 @@ namespace Umbraco.Tests.Persistence.Repositories private MediaRepository CreateRepository(IDatabaseUnitOfWork unitOfWork, out MediaTypeRepository mediaTypeRepository) { - mediaTypeRepository = new MediaTypeRepository(unitOfWork, CacheHelper, Logger, MappingResolver); - var tagRepository = new TagRepository(unitOfWork, CacheHelper, Logger, MappingResolver); - var repository = new MediaRepository(unitOfWork, CacheHelper, Logger, mediaTypeRepository, tagRepository, Mock.Of(), MappingResolver); + mediaTypeRepository = new MediaTypeRepository(unitOfWork, CacheHelper, Logger, Mappers); + var tagRepository = new TagRepository(unitOfWork, CacheHelper, Logger, Mappers); + var repository = new MediaRepository(unitOfWork, CacheHelper, Logger, mediaTypeRepository, tagRepository, Mock.Of(), Mappers); return repository; } @@ -236,7 +236,7 @@ namespace Umbraco.Tests.Persistence.Repositories var repository = CreateRepository(unitOfWork, out mediaTypeRepository); // Act - var query = new Query(SqlSyntax, MappingResolver).Where(x => x.Level == 2); + var query = new Query(SqlSyntax, Mappers).Where(x => x.Level == 2); var result = repository.GetByQuery(query); // Assert @@ -255,7 +255,7 @@ namespace Umbraco.Tests.Persistence.Repositories var repository = CreateRepository(unitOfWork, out mediaTypeRepository); // Act - var query = new Query(SqlSyntax, MappingResolver).Where(x => x.Level == 2); + var query = new Query(SqlSyntax, Mappers).Where(x => x.Level == 2); long totalRecords; var result = repository.GetPagedResultsByQuery(query, 0, 1, out totalRecords, "SortOrder", Direction.Ascending, true); @@ -277,7 +277,7 @@ namespace Umbraco.Tests.Persistence.Repositories var repository = CreateRepository(unitOfWork, out mediaTypeRepository); // Act - var query = new Query(SqlSyntax, MappingResolver).Where(x => x.Level == 2); + var query = new Query(SqlSyntax, Mappers).Where(x => x.Level == 2); long totalRecords; var result = repository.GetPagedResultsByQuery(query, 1, 1, out totalRecords, "SortOrder", Direction.Ascending, true); @@ -299,7 +299,7 @@ namespace Umbraco.Tests.Persistence.Repositories var repository = CreateRepository(unitOfWork, out mediaTypeRepository); // Act - var query = new Query(SqlSyntax, MappingResolver).Where(x => x.Level == 2); + var query = new Query(SqlSyntax, Mappers).Where(x => x.Level == 2); long totalRecords; var result = repository.GetPagedResultsByQuery(query, 0, 2, out totalRecords, "SortOrder", Direction.Ascending, true); @@ -321,7 +321,7 @@ namespace Umbraco.Tests.Persistence.Repositories var repository = CreateRepository(unitOfWork, out mediaTypeRepository); // Act - var query = new Query(SqlSyntax, MappingResolver).Where(x => x.Level == 2); + var query = new Query(SqlSyntax, Mappers).Where(x => x.Level == 2); long totalRecords; var result = repository.GetPagedResultsByQuery(query, 0, 1, out totalRecords, "SortOrder", Direction.Descending, true); @@ -343,7 +343,7 @@ namespace Umbraco.Tests.Persistence.Repositories var repository = CreateRepository(unitOfWork, out mediaTypeRepository); // Act - var query = new Query(SqlSyntax, MappingResolver).Where(x => x.Level == 2); + var query = new Query(SqlSyntax, Mappers).Where(x => x.Level == 2); long totalRecords; var result = repository.GetPagedResultsByQuery(query, 0, 1, out totalRecords, "Name", Direction.Ascending, true); @@ -365,10 +365,10 @@ namespace Umbraco.Tests.Persistence.Repositories var repository = CreateRepository(unitOfWork, out mediaTypeRepository); // Act - var query = new Query(SqlSyntax, MappingResolver).Where(x => x.Level == 2); + var query = new Query(SqlSyntax, Mappers).Where(x => x.Level == 2); long totalRecords; - var filter = new Query(SqlSyntax, MappingResolver).Where(x => x.Name.Contains("File")); + var filter = new Query(SqlSyntax, Mappers).Where(x => x.Name.Contains("File")); var result = repository.GetPagedResultsByQuery(query, 0, 1, out totalRecords, "SortOrder", Direction.Ascending, true, filter); @@ -390,10 +390,10 @@ namespace Umbraco.Tests.Persistence.Repositories var repository = CreateRepository(unitOfWork, out mediaTypeRepository); // Act - var query = new Query(SqlSyntax, MappingResolver).Where(x => x.Level == 2); + var query = new Query(SqlSyntax, Mappers).Where(x => x.Level == 2); long totalRecords; - var filter = new Query(SqlSyntax, MappingResolver).Where(x => x.Name.Contains("Test")); + var filter = new Query(SqlSyntax, Mappers).Where(x => x.Name.Contains("Test")); var result = repository.GetPagedResultsByQuery(query, 0, 1, out totalRecords, "SortOrder", Direction.Ascending, true, filter); @@ -478,7 +478,7 @@ namespace Umbraco.Tests.Persistence.Repositories // Act int level = 2; - var query = new Query(SqlSyntax, MappingResolver).Where(x => x.Level == level); + var query = new Query(SqlSyntax, Mappers).Where(x => x.Level == level); var result = repository.Count(query); // Assert diff --git a/src/Umbraco.Tests/Persistence/Repositories/MediaTypeRepositoryTest.cs b/src/Umbraco.Tests/Persistence/Repositories/MediaTypeRepositoryTest.cs index 542e991392..d632fc3185 100644 --- a/src/Umbraco.Tests/Persistence/Repositories/MediaTypeRepositoryTest.cs +++ b/src/Umbraco.Tests/Persistence/Repositories/MediaTypeRepositoryTest.cs @@ -28,12 +28,12 @@ namespace Umbraco.Tests.Persistence.Repositories private MediaTypeRepository CreateRepository(IDatabaseUnitOfWork unitOfWork) { - return new MediaTypeRepository(unitOfWork, DisabledCache, Logger, MappingResolver); + return new MediaTypeRepository(unitOfWork, DisabledCache, Logger, Mappers); } private EntityContainerRepository CreateContainerRepository(IDatabaseUnitOfWork unitOfWork) { - return new EntityContainerRepository(unitOfWork, DisabledCache, Logger, MappingResolver, Constants.ObjectTypes.MediaTypeContainerGuid); + return new EntityContainerRepository(unitOfWork, DisabledCache, Logger, Mappers, Constants.ObjectTypes.MediaTypeContainerGuid); } diff --git a/src/Umbraco.Tests/Persistence/Repositories/MemberRepositoryTest.cs b/src/Umbraco.Tests/Persistence/Repositories/MemberRepositoryTest.cs index 3c079d9ed6..a909170b6c 100644 --- a/src/Umbraco.Tests/Persistence/Repositories/MemberRepositoryTest.cs +++ b/src/Umbraco.Tests/Persistence/Repositories/MemberRepositoryTest.cs @@ -38,10 +38,10 @@ namespace Umbraco.Tests.Persistence.Repositories private MemberRepository CreateRepository(IDatabaseUnitOfWork unitOfWork, out MemberTypeRepository memberTypeRepository, out MemberGroupRepository memberGroupRepository) { - memberTypeRepository = new MemberTypeRepository(unitOfWork, DisabledCache, Logger, MappingResolver); - memberGroupRepository = new MemberGroupRepository(unitOfWork, DisabledCache, Logger, MappingResolver); - var tagRepo = new TagRepository(unitOfWork, DisabledCache, Logger, MappingResolver); - var repository = new MemberRepository(unitOfWork, DisabledCache, Logger, memberTypeRepository, memberGroupRepository, tagRepo, Mock.Of(), MappingResolver); + memberTypeRepository = new MemberTypeRepository(unitOfWork, DisabledCache, Logger, Mappers); + memberGroupRepository = new MemberGroupRepository(unitOfWork, DisabledCache, Logger, Mappers); + var tagRepo = new TagRepository(unitOfWork, DisabledCache, Logger, Mappers); + var repository = new MemberRepository(unitOfWork, DisabledCache, Logger, memberTypeRepository, memberGroupRepository, tagRepo, Mock.Of(), Mappers); return repository; } @@ -127,7 +127,7 @@ namespace Umbraco.Tests.Persistence.Repositories var member = CreateTestMember(key: key); // Act - var query = new Query(SqlSyntax, MappingResolver).Where(x => x.Key == key); + var query = new Query(SqlSyntax, Mappers).Where(x => x.Key == key); var result = repository.GetByQuery(query); // Assert @@ -260,7 +260,7 @@ namespace Umbraco.Tests.Persistence.Repositories [Test] public void Can_Create_Correct_Subquery() { - var query = new Query(SqlSyntax, MappingResolver).Where(x => + var query = new Query(SqlSyntax, Mappers).Where(x => ((Member) x).LongStringPropertyValue.Contains("1095") && ((Member) x).PropertyTypeAlias == "headshot"); diff --git a/src/Umbraco.Tests/Persistence/Repositories/MemberTypeRepositoryTest.cs b/src/Umbraco.Tests/Persistence/Repositories/MemberTypeRepositoryTest.cs index da24f24075..93ca645f70 100644 --- a/src/Umbraco.Tests/Persistence/Repositories/MemberTypeRepositoryTest.cs +++ b/src/Umbraco.Tests/Persistence/Repositories/MemberTypeRepositoryTest.cs @@ -33,7 +33,7 @@ namespace Umbraco.Tests.Persistence.Repositories private MemberTypeRepository CreateRepository(IDatabaseUnitOfWork unitOfWork) { - return new MemberTypeRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of(), MappingResolver); + return new MemberTypeRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of(), Mappers); } [Test] diff --git a/src/Umbraco.Tests/Persistence/Repositories/PublicAccessRepositoryTest.cs b/src/Umbraco.Tests/Persistence/Repositories/PublicAccessRepositoryTest.cs index 17aa1d8729..7b102b5858 100644 --- a/src/Umbraco.Tests/Persistence/Repositories/PublicAccessRepositoryTest.cs +++ b/src/Umbraco.Tests/Persistence/Repositories/PublicAccessRepositoryTest.cs @@ -28,7 +28,7 @@ namespace Umbraco.Tests.Persistence.Repositories var provider = TestObjects.GetDatabaseUnitOfWorkProvider(Logger); using (var unitOfWork = provider.CreateUnitOfWork()) { - var repo = new PublicAccessRepository(unitOfWork, CacheHelper, Logger, MappingResolver); + var repo = new PublicAccessRepository(unitOfWork, CacheHelper, Logger, Mappers); var entry = new PublicAccessEntry(content[0], content[1], content[2], new[] { @@ -58,7 +58,7 @@ namespace Umbraco.Tests.Persistence.Repositories using (var unitOfWork = provider.CreateUnitOfWork()) { unitOfWork.Database.EnableSqlTrace = true; - var repo = new PublicAccessRepository(unitOfWork, CacheHelper, Logger, MappingResolver); + var repo = new PublicAccessRepository(unitOfWork, CacheHelper, Logger, Mappers); var entry = new PublicAccessEntry(content[0], content[1], content[2], new[] { @@ -98,7 +98,7 @@ namespace Umbraco.Tests.Persistence.Repositories using (var unitOfWork = provider.CreateUnitOfWork()) { unitOfWork.Database.EnableSqlTrace = true; - var repo = new PublicAccessRepository(unitOfWork, CacheHelper, Logger, MappingResolver); + var repo = new PublicAccessRepository(unitOfWork, CacheHelper, Logger, Mappers); var entry = new PublicAccessEntry(content[0], content[1], content[2], new[] { @@ -143,7 +143,7 @@ namespace Umbraco.Tests.Persistence.Repositories var provider = TestObjects.GetDatabaseUnitOfWorkProvider(Logger); using (var unitOfWork = provider.CreateUnitOfWork()) { - var repo = new PublicAccessRepository(unitOfWork, CacheHelper, Logger, MappingResolver); + var repo = new PublicAccessRepository(unitOfWork, CacheHelper, Logger, Mappers); var entry = new PublicAccessEntry(content[0], content[1], content[2], new[] { @@ -181,7 +181,7 @@ namespace Umbraco.Tests.Persistence.Repositories var provider = TestObjects.GetDatabaseUnitOfWorkProvider(Logger); using (var unitOfWork = provider.CreateUnitOfWork()) { - var repo = new PublicAccessRepository(unitOfWork, CacheHelper, Logger, MappingResolver); + var repo = new PublicAccessRepository(unitOfWork, CacheHelper, Logger, Mappers); var entry = new PublicAccessEntry(content[0], content[1], content[2], new[] { @@ -209,7 +209,7 @@ namespace Umbraco.Tests.Persistence.Repositories var provider = TestObjects.GetDatabaseUnitOfWorkProvider(Logger); using (var unitOfWork = provider.CreateUnitOfWork()) { - var repo = new PublicAccessRepository(unitOfWork, CacheHelper, Logger, MappingResolver); + var repo = new PublicAccessRepository(unitOfWork, CacheHelper, Logger, Mappers); var entry1 = new PublicAccessEntry(content[0], content[1], content[2], new[] { @@ -247,7 +247,7 @@ namespace Umbraco.Tests.Persistence.Repositories var provider = TestObjects.GetDatabaseUnitOfWorkProvider(Logger); using (var unitOfWork = provider.CreateUnitOfWork()) { - var repo = new PublicAccessRepository(unitOfWork, CacheHelper, Logger, MappingResolver); + var repo = new PublicAccessRepository(unitOfWork, CacheHelper, Logger, Mappers); var entry1 = new PublicAccessEntry(content[0], content[1], content[2], new[] { @@ -279,10 +279,10 @@ namespace Umbraco.Tests.Persistence.Repositories private ContentRepository CreateRepository(IDatabaseUnitOfWork unitOfWork, out ContentTypeRepository contentTypeRepository) { - var templateRepository = new TemplateRepository(unitOfWork, CacheHelper, Logger, Mock.Of(), Mock.Of(), Mock.Of(), MappingResolver); - var tagRepository = new TagRepository(unitOfWork, CacheHelper, Logger, MappingResolver); - contentTypeRepository = new ContentTypeRepository(unitOfWork, CacheHelper, Logger, templateRepository, MappingResolver); - var repository = new ContentRepository(unitOfWork, CacheHelper, Logger, contentTypeRepository, templateRepository, tagRepository, Mock.Of(), MappingResolver); + var templateRepository = new TemplateRepository(unitOfWork, CacheHelper, Logger, Mock.Of(), Mock.Of(), Mock.Of(), Mappers); + var tagRepository = new TagRepository(unitOfWork, CacheHelper, Logger, Mappers); + contentTypeRepository = new ContentTypeRepository(unitOfWork, CacheHelper, Logger, templateRepository, Mappers); + var repository = new ContentRepository(unitOfWork, CacheHelper, Logger, contentTypeRepository, templateRepository, tagRepository, Mock.Of(), Mappers); return repository; } diff --git a/src/Umbraco.Tests/Persistence/Repositories/RedirectUrlRepositoryTests.cs b/src/Umbraco.Tests/Persistence/Repositories/RedirectUrlRepositoryTests.cs index 7891ce0733..d71b465b25 100644 --- a/src/Umbraco.Tests/Persistence/Repositories/RedirectUrlRepositoryTests.cs +++ b/src/Umbraco.Tests/Persistence/Repositories/RedirectUrlRepositoryTests.cs @@ -192,7 +192,7 @@ namespace Umbraco.Tests.Persistence.Repositories private IRedirectUrlRepository CreateRepository(IDatabaseUnitOfWork uow) { - return new RedirectUrlRepository(uow, CacheHelper, Logger, MappingResolver); + return new RedirectUrlRepository(uow, CacheHelper, Logger, Mappers); } private IContent _textpage, _subpage, _otherpage, _trashed; diff --git a/src/Umbraco.Tests/Persistence/Repositories/RelationRepositoryTest.cs b/src/Umbraco.Tests/Persistence/Repositories/RelationRepositoryTest.cs index c7483889e3..aa6f2c194b 100644 --- a/src/Umbraco.Tests/Persistence/Repositories/RelationRepositoryTest.cs +++ b/src/Umbraco.Tests/Persistence/Repositories/RelationRepositoryTest.cs @@ -31,8 +31,8 @@ namespace Umbraco.Tests.Persistence.Repositories private RelationRepository CreateRepository(IDatabaseUnitOfWork unitOfWork, out RelationTypeRepository relationTypeRepository) { - relationTypeRepository = new RelationTypeRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of(), MappingResolver); - var repository = new RelationRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of(), relationTypeRepository, MappingResolver); + relationTypeRepository = new RelationTypeRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of(), Mappers); + var repository = new RelationRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of(), relationTypeRepository, Mappers); return repository; } @@ -200,7 +200,7 @@ namespace Umbraco.Tests.Persistence.Repositories var repository = CreateRepository(unitOfWork, out repositoryType); // Act - var query = new Query(SqlSyntax, MappingResolver).Where(x => x.ParentId == NodeDto.NodeIdSeed + 1); + var query = new Query(SqlSyntax, Mappers).Where(x => x.ParentId == NodeDto.NodeIdSeed + 1); int count = repository.Count(query); // Assert @@ -219,7 +219,7 @@ namespace Umbraco.Tests.Persistence.Repositories var repository = CreateRepository(unitOfWork, out repositoryType); // Act - var query = new Query(SqlSyntax, MappingResolver).Where(x => x.RelationTypeId == RelationTypeDto.NodeIdSeed); + var query = new Query(SqlSyntax, Mappers).Where(x => x.RelationTypeId == RelationTypeDto.NodeIdSeed); var relations = repository.GetByQuery(query); // Assert @@ -267,8 +267,8 @@ namespace Umbraco.Tests.Persistence.Repositories var provider = TestObjects.GetDatabaseUnitOfWorkProvider(Logger); using (var unitOfWork = provider.CreateUnitOfWork()) { - var relationTypeRepository = new RelationTypeRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of(), MappingResolver); - var relationRepository = new RelationRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of(), relationTypeRepository, MappingResolver); + var relationTypeRepository = new RelationTypeRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of(), Mappers); + var relationRepository = new RelationRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of(), relationTypeRepository, Mappers); relationTypeRepository.AddOrUpdate(relateContent); relationTypeRepository.AddOrUpdate(relateContentType); diff --git a/src/Umbraco.Tests/Persistence/Repositories/RelationTypeRepositoryTest.cs b/src/Umbraco.Tests/Persistence/Repositories/RelationTypeRepositoryTest.cs index 609167c556..71258925b2 100644 --- a/src/Umbraco.Tests/Persistence/Repositories/RelationTypeRepositoryTest.cs +++ b/src/Umbraco.Tests/Persistence/Repositories/RelationTypeRepositoryTest.cs @@ -30,7 +30,7 @@ namespace Umbraco.Tests.Persistence.Repositories private RelationTypeRepository CreateRepository(IDatabaseUnitOfWork unitOfWork) { - return new RelationTypeRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of(), MappingResolver); + return new RelationTypeRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of(), Mappers); } @@ -193,7 +193,7 @@ namespace Umbraco.Tests.Persistence.Repositories var repository = CreateRepository(unitOfWork); // Act - var query = new Query(SqlSyntax, MappingResolver).Where(x => x.Alias.StartsWith("relate")); + var query = new Query(SqlSyntax, Mappers).Where(x => x.Alias.StartsWith("relate")); int count = repository.Count(query); // Assert @@ -212,7 +212,7 @@ namespace Umbraco.Tests.Persistence.Repositories // Act var childObjType = new Guid(Constants.ObjectTypes.DocumentType); - var query = new Query(SqlSyntax, MappingResolver).Where(x => x.ChildObjectType == childObjType); + var query = new Query(SqlSyntax, Mappers).Where(x => x.ChildObjectType == childObjType); var result = repository.GetByQuery(query); // Assert @@ -237,7 +237,7 @@ namespace Umbraco.Tests.Persistence.Repositories var provider = TestObjects.GetDatabaseUnitOfWorkProvider(Logger); using (var unitOfWork = provider.CreateUnitOfWork()) { - var repository = new RelationTypeRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of(), MappingResolver); + var repository = new RelationTypeRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of(), Mappers); repository.AddOrUpdate(relateContent);//Id 2 repository.AddOrUpdate(relateContentType);//Id 3 diff --git a/src/Umbraco.Tests/Persistence/Repositories/ServerRegistrationRepositoryTest.cs b/src/Umbraco.Tests/Persistence/Repositories/ServerRegistrationRepositoryTest.cs index e16f2c522b..90b362d9a0 100644 --- a/src/Umbraco.Tests/Persistence/Repositories/ServerRegistrationRepositoryTest.cs +++ b/src/Umbraco.Tests/Persistence/Repositories/ServerRegistrationRepositoryTest.cs @@ -32,7 +32,7 @@ namespace Umbraco.Tests.Persistence.Repositories private ServerRegistrationRepository CreateRepository(IDatabaseUnitOfWork unitOfWork) { - return new ServerRegistrationRepository(unitOfWork, _cacheHelper, Logger, MappingResolver); + return new ServerRegistrationRepository(unitOfWork, _cacheHelper, Logger, Mappers); } [Test] diff --git a/src/Umbraco.Tests/Persistence/Repositories/TagRepositoryTest.cs b/src/Umbraco.Tests/Persistence/Repositories/TagRepositoryTest.cs index ea1ac67633..568dd45ea6 100644 --- a/src/Umbraco.Tests/Persistence/Repositories/TagRepositoryTest.cs +++ b/src/Umbraco.Tests/Persistence/Repositories/TagRepositoryTest.cs @@ -35,7 +35,7 @@ namespace Umbraco.Tests.Persistence.Repositories private TagRepository CreateRepository(IDatabaseUnitOfWork unitOfWork) { - var tagRepository = new TagRepository(unitOfWork, DisabledCache, Logger, MappingResolver); + var tagRepository = new TagRepository(unitOfWork, DisabledCache, Logger, Mappers); return tagRepository; } @@ -1005,18 +1005,18 @@ namespace Umbraco.Tests.Persistence.Repositories private ContentRepository CreateContentRepository(IDatabaseUnitOfWork unitOfWork, out ContentTypeRepository contentTypeRepository) { - var templateRepository = new TemplateRepository(unitOfWork, DisabledCache, Logger, Mock.Of(), Mock.Of(), Mock.Of(), MappingResolver); - var tagRepository = new TagRepository(unitOfWork, DisabledCache, Logger, MappingResolver); - contentTypeRepository = new ContentTypeRepository(unitOfWork, DisabledCache, Logger, templateRepository, MappingResolver); - var repository = new ContentRepository(unitOfWork, DisabledCache, Logger, contentTypeRepository, templateRepository, tagRepository, Mock.Of(), MappingResolver); + var templateRepository = new TemplateRepository(unitOfWork, DisabledCache, Logger, Mock.Of(), Mock.Of(), Mock.Of(), Mappers); + var tagRepository = new TagRepository(unitOfWork, DisabledCache, Logger, Mappers); + contentTypeRepository = new ContentTypeRepository(unitOfWork, DisabledCache, Logger, templateRepository, Mappers); + var repository = new ContentRepository(unitOfWork, DisabledCache, Logger, contentTypeRepository, templateRepository, tagRepository, Mock.Of(), Mappers); return repository; } private MediaRepository CreateMediaRepository(IDatabaseUnitOfWork unitOfWork, out MediaTypeRepository mediaTypeRepository) { - var tagRepository = new TagRepository(unitOfWork, DisabledCache, Logger, MappingResolver); - mediaTypeRepository = new MediaTypeRepository(unitOfWork, DisabledCache, Logger, MappingResolver); - var repository = new MediaRepository(unitOfWork, DisabledCache, Logger, mediaTypeRepository, tagRepository, Mock.Of(), MappingResolver); + var tagRepository = new TagRepository(unitOfWork, DisabledCache, Logger, Mappers); + mediaTypeRepository = new MediaTypeRepository(unitOfWork, DisabledCache, Logger, Mappers); + var repository = new MediaRepository(unitOfWork, DisabledCache, Logger, mediaTypeRepository, tagRepository, Mock.Of(), Mappers); return repository; } } diff --git a/src/Umbraco.Tests/Persistence/Repositories/TaskRepositoryTest.cs b/src/Umbraco.Tests/Persistence/Repositories/TaskRepositoryTest.cs index b9a2cae414..3de328403c 100644 --- a/src/Umbraco.Tests/Persistence/Repositories/TaskRepositoryTest.cs +++ b/src/Umbraco.Tests/Persistence/Repositories/TaskRepositoryTest.cs @@ -19,7 +19,7 @@ namespace Umbraco.Tests.Persistence.Repositories var provider = TestObjects.GetDatabaseUnitOfWorkProvider(Logger); using (var unitOfWork = provider.CreateUnitOfWork()) { - var repo = new TaskRepository(unitOfWork, CacheHelper, Logger, MappingResolver); + var repo = new TaskRepository(unitOfWork, CacheHelper, Logger, Mappers); var created = DateTime.Now; var task = new Task(new TaskType("asdfasdf")) @@ -47,7 +47,7 @@ namespace Umbraco.Tests.Persistence.Repositories var provider = TestObjects.GetDatabaseUnitOfWorkProvider(Logger); using (var unitOfWork = provider.CreateUnitOfWork()) { - var repo = new TaskRepository(unitOfWork, CacheHelper, Logger, MappingResolver); + var repo = new TaskRepository(unitOfWork, CacheHelper, Logger, Mappers); var created = DateTime.Now; repo.AddOrUpdate(new Task(new TaskType("asdfasdf")) @@ -80,7 +80,7 @@ namespace Umbraco.Tests.Persistence.Repositories var provider = TestObjects.GetDatabaseUnitOfWorkProvider(Logger); using (var unitOfWork = provider.CreateUnitOfWork()) { - var repo = new TaskRepository(unitOfWork, CacheHelper, Logger, MappingResolver); + var repo = new TaskRepository(unitOfWork, CacheHelper, Logger, Mappers); var task = new Task(new TaskType("asdfasdf")) { @@ -117,7 +117,7 @@ namespace Umbraco.Tests.Persistence.Repositories var provider = TestObjects.GetDatabaseUnitOfWorkProvider(Logger); using (var unitOfWork = provider.CreateUnitOfWork()) { - var repo = new TaskRepository(unitOfWork, CacheHelper, Logger, MappingResolver); + var repo = new TaskRepository(unitOfWork, CacheHelper, Logger, Mappers); var task = new Task(new TaskType("asdfasdf")) { @@ -146,7 +146,7 @@ namespace Umbraco.Tests.Persistence.Repositories var provider = TestObjects.GetDatabaseUnitOfWorkProvider(Logger); using (var unitOfWork = provider.CreateUnitOfWork()) { - var repo = new TaskRepository(unitOfWork, CacheHelper, Logger, MappingResolver); + var repo = new TaskRepository(unitOfWork, CacheHelper, Logger, Mappers); var found = repo.GetAll().ToArray(); Assert.AreEqual(20, found.Count()); @@ -162,7 +162,7 @@ namespace Umbraco.Tests.Persistence.Repositories var provider = TestObjects.GetDatabaseUnitOfWorkProvider(Logger); using (var unitOfWork = provider.CreateUnitOfWork()) { - var repo = new TaskRepository(unitOfWork, CacheHelper, Logger, MappingResolver); + var repo = new TaskRepository(unitOfWork, CacheHelper, Logger, Mappers); var found = repo.GetTasks(includeClosed: true).ToArray(); Assert.AreEqual(15, found.Count()); @@ -178,7 +178,7 @@ namespace Umbraco.Tests.Persistence.Repositories var provider = TestObjects.GetDatabaseUnitOfWorkProvider(Logger); using (var unitOfWork = provider.CreateUnitOfWork()) { - var repo = new TaskRepository(unitOfWork, CacheHelper, Logger, MappingResolver); + var repo = new TaskRepository(unitOfWork, CacheHelper, Logger, Mappers); var found = repo.GetTasks(itemId:-20).ToArray(); Assert.AreEqual(10, found.Count()); @@ -194,7 +194,7 @@ namespace Umbraco.Tests.Persistence.Repositories var provider = TestObjects.GetDatabaseUnitOfWorkProvider(Logger); using (var unitOfWork = provider.CreateUnitOfWork()) { - var repo = new TaskRepository(unitOfWork, CacheHelper, Logger, MappingResolver); + var repo = new TaskRepository(unitOfWork, CacheHelper, Logger, Mappers); var found = repo.GetTasks(includeClosed: false); Assert.AreEqual(10, found.Count()); @@ -206,7 +206,7 @@ namespace Umbraco.Tests.Persistence.Repositories var provider = TestObjects.GetDatabaseUnitOfWorkProvider(Logger); using (var unitOfWork = provider.CreateUnitOfWork()) { - var repo = new TaskRepository(unitOfWork, CacheHelper, Logger, MappingResolver); + var repo = new TaskRepository(unitOfWork, CacheHelper, Logger, Mappers); for (int i = 0; i < count; i++) { diff --git a/src/Umbraco.Tests/Persistence/Repositories/TaskTypeRepositoryTest.cs b/src/Umbraco.Tests/Persistence/Repositories/TaskTypeRepositoryTest.cs index 0028aa3933..494b785468 100644 --- a/src/Umbraco.Tests/Persistence/Repositories/TaskTypeRepositoryTest.cs +++ b/src/Umbraco.Tests/Persistence/Repositories/TaskTypeRepositoryTest.cs @@ -19,8 +19,8 @@ namespace Umbraco.Tests.Persistence.Repositories using (var unitOfWork = provider.CreateUnitOfWork()) { var taskType = new TaskType("asdfasdf"); - var repo = new TaskRepository(unitOfWork, CacheHelper, Logger, MappingResolver); - var taskTypeRepo = new TaskTypeRepository(unitOfWork, CacheHelper, Logger, MappingResolver); + var repo = new TaskRepository(unitOfWork, CacheHelper, Logger, Mappers); + var taskTypeRepo = new TaskTypeRepository(unitOfWork, CacheHelper, Logger, Mappers); var created = DateTime.Now; var task = new Task(taskType) diff --git a/src/Umbraco.Tests/Persistence/Repositories/TemplateRepositoryTest.cs b/src/Umbraco.Tests/Persistence/Repositories/TemplateRepositoryTest.cs index c7b9e7fc6d..ab3fe272cc 100644 --- a/src/Umbraco.Tests/Persistence/Repositories/TemplateRepositoryTest.cs +++ b/src/Umbraco.Tests/Persistence/Repositories/TemplateRepositoryTest.cs @@ -31,7 +31,7 @@ namespace Umbraco.Tests.Persistence.Repositories private ITemplateRepository CreateRepository(IDatabaseUnitOfWork unitOfWork, ITemplatesSection templatesSection = null) { return new TemplateRepository(unitOfWork, DisabledCache, Logger, _masterPageFileSystem, _viewsFileSystem, - templatesSection ?? Mock.Of(t => t.DefaultRenderingEngine == RenderingEngine.Mvc), MappingResolver); + templatesSection ?? Mock.Of(t => t.DefaultRenderingEngine == RenderingEngine.Mvc), Mappers); } [SetUp] @@ -407,9 +407,9 @@ namespace Umbraco.Tests.Persistence.Repositories { var templateRepository = CreateRepository(unitOfWork); - var tagRepository = new TagRepository(unitOfWork, DisabledCache, Logger, MappingResolver); - var contentTypeRepository = new ContentTypeRepository(unitOfWork, DisabledCache, Logger, templateRepository, MappingResolver); - var contentRepo = new ContentRepository(unitOfWork, DisabledCache, Logger, contentTypeRepository, templateRepository, tagRepository, Mock.Of(), MappingResolver); + var tagRepository = new TagRepository(unitOfWork, DisabledCache, Logger, Mappers); + var contentTypeRepository = new ContentTypeRepository(unitOfWork, DisabledCache, Logger, templateRepository, Mappers); + var contentRepo = new ContentRepository(unitOfWork, DisabledCache, Logger, contentTypeRepository, templateRepository, tagRepository, Mock.Of(), Mappers); var contentType = MockedContentTypes.CreateSimpleContentType("umbTextpage2", "Textpage"); var textpage = MockedContent.CreateSimpleContent(contentType); diff --git a/src/Umbraco.Tests/Persistence/Repositories/UserRepositoryTest.cs b/src/Umbraco.Tests/Persistence/Repositories/UserRepositoryTest.cs index 37f3b5ba1a..58e69b1f18 100644 --- a/src/Umbraco.Tests/Persistence/Repositories/UserRepositoryTest.cs +++ b/src/Umbraco.Tests/Persistence/Repositories/UserRepositoryTest.cs @@ -35,8 +35,8 @@ namespace Umbraco.Tests.Persistence.Repositories private UserRepository CreateRepository(IDatabaseUnitOfWork unitOfWork, out UserTypeRepository userTypeRepository) { - userTypeRepository = new UserTypeRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of(), MappingResolver); - var repository = new UserRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of(), userTypeRepository, MappingResolver); + userTypeRepository = new UserTypeRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of(), Mappers); + var repository = new UserRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of(), userTypeRepository, Mappers); return repository; } @@ -178,8 +178,8 @@ namespace Umbraco.Tests.Persistence.Repositories unitOfWork.Flush(); var id = user.Id; - var utRepo = new UserTypeRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Logger, MappingResolver); - var repository2 = new UserRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Logger, utRepo, MappingResolver); + var utRepo = new UserTypeRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Logger, Mappers); + var repository2 = new UserRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Logger, utRepo, Mappers); repository2.Delete(user); unitOfWork.Flush(); @@ -256,7 +256,7 @@ namespace Umbraco.Tests.Persistence.Repositories CreateAndCommitMultipleUsers(repository, unitOfWork); // Act - var query = new Query(SqlSyntax, MappingResolver).Where(x => x.Username == "TestUser1"); + var query = new Query(SqlSyntax, Mappers).Where(x => x.Username == "TestUser1"); var result = repository.GetByQuery(query); // Assert @@ -341,7 +341,7 @@ namespace Umbraco.Tests.Persistence.Repositories var users = CreateAndCommitMultipleUsers(repository, unitOfWork); // Act - var query = new Query(SqlSyntax, MappingResolver).Where(x => x.Username == "TestUser1" || x.Username == "TestUser2"); + var query = new Query(SqlSyntax, Mappers).Where(x => x.Username == "TestUser1" || x.Username == "TestUser2"); var result = repository.Count(query); // Assert @@ -496,8 +496,8 @@ namespace Umbraco.Tests.Persistence.Repositories var provider = TestObjects.GetDatabaseUnitOfWorkProvider(Logger); using (var unitOfWork = provider.CreateUnitOfWork()) { - var utRepo = new UserTypeRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Logger, MappingResolver); - var repository = new UserRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Logger, utRepo, MappingResolver); + var utRepo = new UserTypeRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Logger, Mappers); + var repository = new UserRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Logger, utRepo, Mappers); // Act var user1 = MockedUser.CreateUser(CreateAndCommitUserType(), "1", "test", "media"); @@ -547,7 +547,7 @@ namespace Umbraco.Tests.Persistence.Repositories var provider = TestObjects.GetDatabaseUnitOfWorkProvider(Logger); using (var unitOfWork = provider.CreateUnitOfWork()) { - var repository = new UserTypeRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Logger, MappingResolver); + var repository = new UserTypeRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Logger, Mappers); var userType = MockedUserType.CreateUserType(); repository.AddOrUpdate(userType); unitOfWork.Complete(); diff --git a/src/Umbraco.Tests/Persistence/Repositories/UserTypeRepositoryTest.cs b/src/Umbraco.Tests/Persistence/Repositories/UserTypeRepositoryTest.cs index 1382527e51..0728ae9bb5 100644 --- a/src/Umbraco.Tests/Persistence/Repositories/UserTypeRepositoryTest.cs +++ b/src/Umbraco.Tests/Persistence/Repositories/UserTypeRepositoryTest.cs @@ -33,7 +33,7 @@ namespace Umbraco.Tests.Persistence.Repositories private UserTypeRepository CreateRepository(IDatabaseUnitOfWork unitOfWork) { - return new UserTypeRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of(), MappingResolver); + return new UserTypeRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of(), Mappers); } [Test] @@ -146,7 +146,7 @@ namespace Umbraco.Tests.Persistence.Repositories unitOfWork.Flush(); var id = userType.Id; - var repository2 = new UserTypeRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Logger, MappingResolver); + var repository2 = new UserTypeRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Logger, Mappers); repository2.Delete(userType); unitOfWork.Flush(); @@ -195,7 +195,7 @@ namespace Umbraco.Tests.Persistence.Repositories CreateAndCommitMultipleUserTypes(repository, unitOfWork); // Act - var query = new Query(SqlSyntax, MappingResolver).Where(x => x.Alias == "testUserType1"); + var query = new Query(SqlSyntax, Mappers).Where(x => x.Alias == "testUserType1"); var result = repository.GetByQuery(query); // Assert @@ -276,7 +276,7 @@ namespace Umbraco.Tests.Persistence.Repositories var userTypes = CreateAndCommitMultipleUserTypes(repository, unitOfWork); // Act - var query = new Query(SqlSyntax, MappingResolver).Where(x => x.Alias == "testUserType1" || x.Alias == "testUserType2"); + var query = new Query(SqlSyntax, Mappers).Where(x => x.Alias == "testUserType1" || x.Alias == "testUserType2"); var result = repository.Count(query); // Assert diff --git a/src/Umbraco.Tests/Services/ContentServicePerformanceTest.cs b/src/Umbraco.Tests/Services/ContentServicePerformanceTest.cs index 486cff70f5..eef43c0f10 100644 --- a/src/Umbraco.Tests/Services/ContentServicePerformanceTest.cs +++ b/src/Umbraco.Tests/Services/ContentServicePerformanceTest.cs @@ -148,10 +148,10 @@ namespace Umbraco.Tests.Services var provider = TestObjects.GetDatabaseUnitOfWorkProvider(Logger); using (var unitOfWork = provider.CreateUnitOfWork()) { - var tRepository = new TemplateRepository(unitOfWork, DisabledCache, Logger, Mock.Of(), Mock.Of(), Mock.Of(), MappingResolver); - var tagRepo = new TagRepository(unitOfWork, DisabledCache, Logger, MappingResolver); - var ctRepository = new ContentTypeRepository(unitOfWork, DisabledCache, Logger, tRepository, MappingResolver); - var repository = new ContentRepository(unitOfWork, DisabledCache, Logger, ctRepository, tRepository, tagRepo, Mock.Of(), MappingResolver); + var tRepository = new TemplateRepository(unitOfWork, DisabledCache, Logger, Mock.Of(), Mock.Of(), Mock.Of(), Mappers); + var tagRepo = new TagRepository(unitOfWork, DisabledCache, Logger, Mappers); + var ctRepository = new ContentTypeRepository(unitOfWork, DisabledCache, Logger, tRepository, Mappers); + var repository = new ContentRepository(unitOfWork, DisabledCache, Logger, ctRepository, tRepository, tagRepo, Mock.Of(), Mappers); // Act Stopwatch watch = Stopwatch.StartNew(); @@ -180,10 +180,10 @@ namespace Umbraco.Tests.Services var provider = TestObjects.GetDatabaseUnitOfWorkProvider(Logger); using (var unitOfWork = provider.CreateUnitOfWork()) { - var tRepository = new TemplateRepository(unitOfWork, DisabledCache, Logger, Mock.Of(), Mock.Of(), Mock.Of(), MappingResolver); - var tagRepo = new TagRepository(unitOfWork, DisabledCache, Logger, MappingResolver); - var ctRepository = new ContentTypeRepository(unitOfWork, DisabledCache, Logger, tRepository, MappingResolver); - var repository = new ContentRepository(unitOfWork, DisabledCache, Logger, ctRepository, tRepository, tagRepo, Mock.Of(), MappingResolver); + var tRepository = new TemplateRepository(unitOfWork, DisabledCache, Logger, Mock.Of(), Mock.Of(), Mock.Of(), Mappers); + var tagRepo = new TagRepository(unitOfWork, DisabledCache, Logger, Mappers); + var ctRepository = new ContentTypeRepository(unitOfWork, DisabledCache, Logger, tRepository, Mappers); + var repository = new ContentRepository(unitOfWork, DisabledCache, Logger, ctRepository, tRepository, tagRepo, Mock.Of(), Mappers); // Act Stopwatch watch = Stopwatch.StartNew(); @@ -210,10 +210,10 @@ namespace Umbraco.Tests.Services var provider = TestObjects.GetDatabaseUnitOfWorkProvider(Logger); using (var unitOfWork = provider.CreateUnitOfWork()) { - var tRepository = new TemplateRepository(unitOfWork, DisabledCache, Logger, Mock.Of(), Mock.Of(), Mock.Of(), MappingResolver); - var tagRepo = new TagRepository(unitOfWork, DisabledCache, Logger, MappingResolver); - var ctRepository = new ContentTypeRepository(unitOfWork, DisabledCache, Logger, tRepository, MappingResolver); - var repository = new ContentRepository(unitOfWork, DisabledCache, Logger, ctRepository, tRepository, tagRepo, Mock.Of(), MappingResolver); + var tRepository = new TemplateRepository(unitOfWork, DisabledCache, Logger, Mock.Of(), Mock.Of(), Mock.Of(), Mappers); + var tagRepo = new TagRepository(unitOfWork, DisabledCache, Logger, Mappers); + var ctRepository = new ContentTypeRepository(unitOfWork, DisabledCache, Logger, tRepository, Mappers); + var repository = new ContentRepository(unitOfWork, DisabledCache, Logger, ctRepository, tRepository, tagRepo, Mock.Of(), Mappers); // Act var contents = repository.GetAll(); @@ -243,10 +243,10 @@ namespace Umbraco.Tests.Services var provider = TestObjects.GetDatabaseUnitOfWorkProvider(Logger); using (var unitOfWork = provider.CreateUnitOfWork()) { - var tRepository = new TemplateRepository(unitOfWork, DisabledCache, Logger, Mock.Of(), Mock.Of(), Mock.Of(), MappingResolver); - var tagRepo = new TagRepository(unitOfWork, DisabledCache, Logger, MappingResolver); - var ctRepository = new ContentTypeRepository(unitOfWork, DisabledCache, Logger, tRepository, MappingResolver); - var repository = new ContentRepository(unitOfWork, DisabledCache, Logger, ctRepository, tRepository, tagRepo, Mock.Of(), MappingResolver); + var tRepository = new TemplateRepository(unitOfWork, DisabledCache, Logger, Mock.Of(), Mock.Of(), Mock.Of(), Mappers); + var tagRepo = new TagRepository(unitOfWork, DisabledCache, Logger, Mappers); + var ctRepository = new ContentTypeRepository(unitOfWork, DisabledCache, Logger, tRepository, Mappers); + var repository = new ContentRepository(unitOfWork, DisabledCache, Logger, ctRepository, tRepository, tagRepo, Mock.Of(), Mappers); // Act var contents = repository.GetAll(); diff --git a/src/Umbraco.Tests/Services/ContentServiceTests.cs b/src/Umbraco.Tests/Services/ContentServiceTests.cs index 1d9edd4d72..92a1ec7166 100644 --- a/src/Umbraco.Tests/Services/ContentServiceTests.cs +++ b/src/Umbraco.Tests/Services/ContentServiceTests.cs @@ -1385,7 +1385,7 @@ namespace Umbraco.Tests.Services TestObjects.GetDefaultSqlSyntaxProviders(Logger), Logger, new TestUmbracoDatabaseAccessor(), - MappingResolver); + Mappers); var repositoryFactory = MockRepositoryFactory(); var provider = new NPocoUnitOfWorkProvider(databaseFactory, repositoryFactory); var contentType = ServiceContext.ContentTypeService.Get("umbTextpage"); @@ -1661,10 +1661,10 @@ namespace Umbraco.Tests.Services private ContentRepository CreateRepository(IDatabaseUnitOfWork unitOfWork, out ContentTypeRepository contentTypeRepository) { - var templateRepository = new TemplateRepository(unitOfWork, DisabledCache, Logger, Mock.Of(), Mock.Of(), Mock.Of(), MappingResolver); - var tagRepository = new TagRepository(unitOfWork, DisabledCache, Logger, MappingResolver); - contentTypeRepository = new ContentTypeRepository(unitOfWork, DisabledCache, Logger, templateRepository, MappingResolver); - var repository = new ContentRepository(unitOfWork, DisabledCache, Logger, contentTypeRepository, templateRepository, tagRepository, Mock.Of(), MappingResolver); + var templateRepository = new TemplateRepository(unitOfWork, DisabledCache, Logger, Mock.Of(), Mock.Of(), Mock.Of(), Mappers); + var tagRepository = new TagRepository(unitOfWork, DisabledCache, Logger, Mappers); + contentTypeRepository = new ContentTypeRepository(unitOfWork, DisabledCache, Logger, templateRepository, Mappers); + var repository = new ContentRepository(unitOfWork, DisabledCache, Logger, contentTypeRepository, templateRepository, tagRepository, Mock.Of(), Mappers); return repository; } @@ -1676,19 +1676,19 @@ namespace Umbraco.Tests.Services mock .Setup(x => x.CreateRepository(It.IsAny(), It.IsAny())) .Returns((IDatabaseUnitOfWork uow, string name) => - new TemplateRepository(uow, DisabledCache, Logger, Mock.Of(), Mock.Of(), Mock.Of(), MappingResolver)); + new TemplateRepository(uow, DisabledCache, Logger, Mock.Of(), Mock.Of(), Mock.Of(), Mappers)); mock .Setup(x => x.CreateRepository(It.IsAny(), It.IsAny())) .Returns((IDatabaseUnitOfWork uow, string name) => - new TagRepository(uow, DisabledCache, Logger, MappingResolver)); + new TagRepository(uow, DisabledCache, Logger, Mappers)); mock .Setup(x => x.CreateRepository(It.IsAny(), It.IsAny())) .Returns((IDatabaseUnitOfWork uow, string name) => - new ContentTypeRepository(uow, DisabledCache, Logger, factory.CreateRepository(uow), MappingResolver)); + new ContentTypeRepository(uow, DisabledCache, Logger, factory.CreateRepository(uow), Mappers)); mock .Setup(x => x.CreateRepository(It.IsAny(), It.IsAny())) .Returns((IDatabaseUnitOfWork uow, string name) => - new ContentRepository(uow, DisabledCache, Logger, factory.CreateRepository(uow), factory.CreateRepository(uow), factory.CreateRepository(uow), Mock.Of(), MappingResolver)); + new ContentRepository(uow, DisabledCache, Logger, factory.CreateRepository(uow), factory.CreateRepository(uow), factory.CreateRepository(uow), Mock.Of(), Mappers)); return factory = mock.Object; } diff --git a/src/Umbraco.Tests/Services/MacroServiceTests.cs b/src/Umbraco.Tests/Services/MacroServiceTests.cs index 80eef3b666..c2c1f24352 100644 --- a/src/Umbraco.Tests/Services/MacroServiceTests.cs +++ b/src/Umbraco.Tests/Services/MacroServiceTests.cs @@ -29,7 +29,7 @@ namespace Umbraco.Tests.Services var provider = TestObjects.GetDatabaseUnitOfWorkProvider(Logger); using (var unitOfWork = provider.CreateUnitOfWork()) { - var repository = new MacroRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of(), MappingResolver); + var repository = new MacroRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of(), Mappers); repository.AddOrUpdate(new Macro("test1", "Test1", "~/usercontrol/test1.ascx", "MyAssembly1", "test1.xslt", "~/views/macropartials/test1.cshtml")); repository.AddOrUpdate(new Macro("test2", "Test2", "~/usercontrol/test2.ascx", "MyAssembly2", "test2.xslt", "~/views/macropartials/test2.cshtml")); diff --git a/src/Umbraco.Tests/Services/ThreadSafetyServiceTest.cs b/src/Umbraco.Tests/Services/ThreadSafetyServiceTest.cs index 7275c526d6..31e40228ff 100644 --- a/src/Umbraco.Tests/Services/ThreadSafetyServiceTest.cs +++ b/src/Umbraco.Tests/Services/ThreadSafetyServiceTest.cs @@ -42,7 +42,7 @@ namespace Umbraco.Tests.Services //a Database instance is created per thread, whereas the default implementation which will work in an HttpContext //threading environment, or a single apartment threading environment will not work for this test because //it is multi-threaded. - _dbFactory = new PerThreadSqlCeDatabaseFactory(Logger, Mock.Of()); + _dbFactory = new PerThreadSqlCeDatabaseFactory(Logger, Mock.Of()); var repositoryFactory = new RepositoryFactory(Container); _uowProvider = new NPocoUnitOfWorkProvider(_dbFactory, repositoryFactory); @@ -233,7 +233,7 @@ namespace Umbraco.Tests.Services // them all in one call private readonly ILogger _logger; - private readonly IMappingResolver _mappingResolver; + private readonly IMapperCollection _mappers; private IQueryFactory _queryFactory; private readonly DbProviderFactory _dbProviderFactory = @@ -249,14 +249,14 @@ namespace Umbraco.Tests.Services public ISqlSyntaxProvider SqlSyntax { get; } = new SqlCeSyntaxProvider(); - public IQueryFactory QueryFactory => _queryFactory ?? (_queryFactory = new QueryFactory(SqlSyntax, _mappingResolver)); + public IQueryFactory QueryFactory => _queryFactory ?? (_queryFactory = new QueryFactory(SqlSyntax, _mappers)); public DatabaseType DatabaseType => DatabaseType.SQLCe; - public PerThreadSqlCeDatabaseFactory(ILogger logger, IMappingResolver mappingResolver) + public PerThreadSqlCeDatabaseFactory(ILogger logger, IMapperCollection mappers) { _logger = logger; - _mappingResolver = mappingResolver; + _mappers = mappers; } private readonly ConcurrentDictionary _databases = new ConcurrentDictionary(); diff --git a/src/Umbraco.Tests/Templates/TemplateRepositoryTests.cs b/src/Umbraco.Tests/Templates/TemplateRepositoryTests.cs index 5df709bc59..2fd8c8f200 100644 --- a/src/Umbraco.Tests/Templates/TemplateRepositoryTests.cs +++ b/src/Umbraco.Tests/Templates/TemplateRepositoryTests.cs @@ -40,7 +40,7 @@ namespace Umbraco.Tests.Templates var db = TestObjects.GetUmbracoSqlCeDatabase(logger); unitOfWorkMock.Setup(x => x.Database).Returns(db); - _templateRepository = new TemplateRepository(unitOfWorkMock.Object, _cacheMock.Object, logger, _masterpageFileSystemMock.Object, _viewFileSystemMock.Object, _templateConfigMock.Object, Mock.Of()); + _templateRepository = new TemplateRepository(unitOfWorkMock.Object, _cacheMock.Object, logger, _masterpageFileSystemMock.Object, _viewFileSystemMock.Object, _templateConfigMock.Object, Mock.Of()); } diff --git a/src/Umbraco.Tests/TestHelpers/BaseDatabaseFactoryTest.cs b/src/Umbraco.Tests/TestHelpers/BaseDatabaseFactoryTest.cs index 68a8cdeb24..c7de26e141 100644 --- a/src/Umbraco.Tests/TestHelpers/BaseDatabaseFactoryTest.cs +++ b/src/Umbraco.Tests/TestHelpers/BaseDatabaseFactoryTest.cs @@ -119,7 +119,7 @@ namespace Umbraco.Tests.TestHelpers } else { - var f = new DefaultDatabaseFactory(GetDbConnectionString(), GetDbProviderName(), sqlSyntaxProviders, Logger, new TestUmbracoDatabaseAccessor(), MappingResolver); + var f = new DefaultDatabaseFactory(GetDbConnectionString(), GetDbProviderName(), sqlSyntaxProviders, Logger, new TestUmbracoDatabaseAccessor(), Mappers); f.ResetForTests(); databaseFactory = f; } diff --git a/src/Umbraco.Tests/TestHelpers/BaseUmbracoApplicationTest.cs b/src/Umbraco.Tests/TestHelpers/BaseUmbracoApplicationTest.cs index 3878e9506d..1e9461ee9e 100644 --- a/src/Umbraco.Tests/TestHelpers/BaseUmbracoApplicationTest.cs +++ b/src/Umbraco.Tests/TestHelpers/BaseUmbracoApplicationTest.cs @@ -132,10 +132,7 @@ namespace Umbraco.Tests.TestHelpers private static readonly object Locker = new object(); - protected IMappingResolver MappingResolver - { - get { return Container.GetInstance(); } - } + protected IMapperCollection Mappers => Container.GetInstance(); private static void InitializeLegacyMappingsForCoreEditors() { @@ -218,7 +215,7 @@ namespace Umbraco.Tests.TestHelpers Core.Configuration.GlobalSettings.UmbracoConnectionName, TestObjects.GetDefaultSqlSyntaxProviders(Logger), Logger, new TestUmbracoDatabaseAccessor(), - Mock.Of()); + Mock.Of()); dbFactory.ResetForTests(); var applicationContext = new ApplicationContext( // assign the db context diff --git a/src/Umbraco.Tests/TestHelpers/BaseUsingSqlCeSyntax.cs b/src/Umbraco.Tests/TestHelpers/BaseUsingSqlCeSyntax.cs index 271f0ee37b..49c7c8cf1d 100644 --- a/src/Umbraco.Tests/TestHelpers/BaseUsingSqlCeSyntax.cs +++ b/src/Umbraco.Tests/TestHelpers/BaseUsingSqlCeSyntax.cs @@ -18,9 +18,7 @@ namespace Umbraco.Tests.TestHelpers [TestFixture] public abstract class BaseUsingSqlCeSyntax { - private MappingResolver _mappingResolver; - - protected IMappingResolver MappingResolver => _mappingResolver; + protected IMapperCollection Mappers { get; private set; } protected SqlContext SqlContext { get; private set; } @@ -40,16 +38,17 @@ namespace Umbraco.Tests.TestHelpers container.RegisterSingleton(factory => Mock.Of()); container.RegisterSingleton(factory => Mock.Of()); - _mappingResolver = new MappingResolver(container, Mock.Of(), - () => PluginManager.Current.ResolveAssignedMapperTypes()); - var logger = new ProfilingLogger(Mock.Of(), Mock.Of()); var pluginManager = PluginManager.Current = new PluginManager(new NullCacheProvider(), logger, false); container.RegisterInstance(pluginManager); - var mappers = new MapperCollection { new PocoMapper() }; + MapperCollectionBuilder.Register(container) + .AddProducer(() => PluginManager.Current.ResolveAssignedMapperTypes()); + Mappers = container.GetInstance(); + + var mappers = new NPoco.MapperCollection { new PocoMapper() }; var pocoDataFactory = new FluentPocoDataFactory((type, iPocoDataFactory) => new PocoDataBuilder(type, mappers).Init()); SqlContext = new SqlContext(sqlSyntax, pocoDataFactory, DatabaseType.SQLCe); diff --git a/src/Umbraco.Tests/TestHelpers/TestObjects.cs b/src/Umbraco.Tests/TestHelpers/TestObjects.cs index dbe4c58fb3..a4b29e1191 100644 --- a/src/Umbraco.Tests/TestHelpers/TestObjects.cs +++ b/src/Umbraco.Tests/TestHelpers/TestObjects.cs @@ -203,8 +203,8 @@ namespace Umbraco.Tests.TestHelpers public static IDatabaseUnitOfWorkProvider GetDatabaseUnitOfWorkProvider(ILogger logger) { var adapter = new TestUmbracoDatabaseAccessor(); - var mappingResolver = Mock.Of(); - var databaseFactory = new DefaultDatabaseFactory(GlobalSettings.UmbracoConnectionName, GetDefaultSqlSyntaxProviders(logger), logger, adapter, mappingResolver); + var mappers = Mock.Of(); + var databaseFactory = new DefaultDatabaseFactory(GlobalSettings.UmbracoConnectionName, GetDefaultSqlSyntaxProviders(logger), logger, adapter, mappers); var repositoryFactory = new RepositoryFactory(Mock.Of()); return new NPocoUnitOfWorkProvider(databaseFactory, repositoryFactory); }