diff --git a/src/Umbraco.Core/Composing/SetCollectionBuilderBase.cs b/src/Umbraco.Core/Composing/SetCollectionBuilderBase.cs new file mode 100644 index 0000000000..3698b7e801 --- /dev/null +++ b/src/Umbraco.Core/Composing/SetCollectionBuilderBase.cs @@ -0,0 +1,167 @@ +using System; +using System.Collections.Generic; + +namespace Umbraco.Core.Composing +{ + /// + /// Implements an un-ordered collection builder. + /// + /// The type of the builder. + /// The type of the collection. + /// The type of the items. + public abstract class SetCollectionBuilderBase : CollectionBuilderBase + where TBuilder : SetCollectionBuilderBase + where TCollection : class, IBuilderCollection + { + protected abstract TBuilder This { get; } + + /// + /// Clears all types in the collection. + /// + /// The builder. + public TBuilder Clear() + { + Configure(types => types.Clear()); + return This; + } + + /// + /// Adds a type to the collection. + /// + /// The type to append. + /// The builder. + public TBuilder Add() + where T : TItem + { + Configure(types => + { + var type = typeof(T); + if (types.Contains(type)) types.Remove(type); + types.Add(type); + }); + return This; + } + + /// + /// Adds a type to the collection. + /// + /// The type to append. + /// The builder. + public TBuilder Add(Type type) + { + Configure(types => + { + EnsureType(type, "register"); + if (types.Contains(type)) types.Remove(type); + types.Add(type); + }); + return This; + } + + /// + /// Adds types to the collections. + /// + /// The types to append. + /// The builder. + public TBuilder Add(IEnumerable types) + { + Configure(list => + { + foreach (var type in types) + { + // would be detected by CollectionBuilderBase when registering, anyways, but let's fail fast + EnsureType(type, "register"); + if (list.Contains(type)) list.Remove(type); + list.Add(type); + } + }); + return This; + } + + /// + /// Removes a type from the collection. + /// + /// The type to remove. + /// The builder. + public TBuilder Remove() + where T : TItem + { + Configure(types => + { + var type = typeof(T); + if (types.Contains(type)) types.Remove(type); + }); + return This; + } + + /// + /// Removes a type from the collection. + /// + /// The type to remove. + /// The builder. + public TBuilder Remove(Type type) + { + Configure(types => + { + EnsureType(type, "remove"); + if (types.Contains(type)) types.Remove(type); + }); + return This; + } + + /// + /// Replaces a type in the collection. + /// + /// The type to replace. + /// The type to insert. + /// The builder. + /// Throws if the type to replace does not already belong to the collection. + public TBuilder Replace() + where TReplaced : TItem + where T : TItem + { + Configure(types => + { + var typeReplaced = typeof(TReplaced); + var type = typeof(T); + if (typeReplaced == type) return; + + var index = types.IndexOf(typeReplaced); + if (index < 0) throw new InvalidOperationException(); + + if (types.Contains(type)) types.Remove(type); + index = types.IndexOf(typeReplaced); // in case removing type changed index + types.Insert(index, type); + types.Remove(typeReplaced); + }); + return This; + } + + /// + /// Replaces a type in the collection. + /// + /// The type to replace. + /// The type to insert. + /// The builder. + /// Throws if the type to replace does not already belong to the collection. + public TBuilder Replace(Type typeReplaced, Type type) + { + Configure(types => + { + EnsureType(typeReplaced, "find"); + EnsureType(type, "register"); + + if (typeReplaced == type) return; + + var index = types.IndexOf(typeReplaced); + if (index < 0) throw new InvalidOperationException(); + + if (types.Contains(type)) types.Remove(type); + index = types.IndexOf(typeReplaced); // in case removing type changed index + types.Insert(index, type); + types.Remove(typeReplaced); + }); + return This; + } + } +} diff --git a/src/Umbraco.Core/Persistence/Mappers/AccessMapper.cs b/src/Umbraco.Core/Persistence/Mappers/AccessMapper.cs index 0465086810..271f208585 100644 --- a/src/Umbraco.Core/Persistence/Mappers/AccessMapper.cs +++ b/src/Umbraco.Core/Persistence/Mappers/AccessMapper.cs @@ -1,4 +1,5 @@ -using System.Collections.Concurrent; +using System; +using System.Collections.Concurrent; using Umbraco.Core.Models; using Umbraco.Core.Persistence.Dtos; @@ -7,18 +8,15 @@ namespace Umbraco.Core.Persistence.Mappers [MapperFor(typeof(PublicAccessEntry))] public sealed class AccessMapper : BaseMapper { - private static readonly ConcurrentDictionary PropertyInfoCacheInstance = new ConcurrentDictionary(); - - internal override ConcurrentDictionary PropertyInfoCache => PropertyInfoCacheInstance; - - protected override void BuildMap() + public AccessMapper(ISqlContext sqlContext, ConcurrentDictionary> maps) + : base(sqlContext, maps) { - CacheMap(src => src.Key, dto => dto.Id); - CacheMap(src => src.LoginNodeId, dto => dto.LoginNodeId); - CacheMap(src => src.NoAccessNodeId, dto => dto.NoAccessNodeId); - CacheMap(src => src.ProtectedNodeId, dto => dto.NodeId); - CacheMap(src => src.CreateDate, dto => dto.CreateDate); - CacheMap(src => src.UpdateDate, dto => dto.UpdateDate); + DefineMap(nameof(PublicAccessEntry.Key), nameof(AccessDto.Id)); + DefineMap(nameof(PublicAccessEntry.LoginNodeId), nameof(AccessDto.LoginNodeId)); + DefineMap(nameof(PublicAccessEntry.NoAccessNodeId), nameof(AccessDto.NoAccessNodeId)); + DefineMap(nameof(PublicAccessEntry.ProtectedNodeId), nameof(AccessDto.NodeId)); + DefineMap(nameof(PublicAccessEntry.CreateDate), nameof(AccessDto.CreateDate)); + DefineMap(nameof(PublicAccessEntry.UpdateDate), nameof(AccessDto.UpdateDate)); } } } diff --git a/src/Umbraco.Core/Persistence/Mappers/AuditEntryMapper.cs b/src/Umbraco.Core/Persistence/Mappers/AuditEntryMapper.cs index 28c7c1eeec..5d23f8edf1 100644 --- a/src/Umbraco.Core/Persistence/Mappers/AuditEntryMapper.cs +++ b/src/Umbraco.Core/Persistence/Mappers/AuditEntryMapper.cs @@ -1,4 +1,5 @@ -using System.Collections.Concurrent; +using System; +using System.Collections.Concurrent; using Umbraco.Core.Models; using Umbraco.Core.Persistence.Dtos; @@ -11,21 +12,18 @@ namespace Umbraco.Core.Persistence.Mappers [MapperFor(typeof(AuditEntry))] public sealed class AuditEntryMapper : BaseMapper { - private static readonly ConcurrentDictionary PropertyInfoCacheInstance = new ConcurrentDictionary(); - - internal override ConcurrentDictionary PropertyInfoCache => PropertyInfoCacheInstance; - - protected override void BuildMap() + public AuditEntryMapper(ISqlContext sqlContext, ConcurrentDictionary> maps) + : base(sqlContext, maps) { - CacheMap(entity => entity.Id, dto => dto.Id); - CacheMap(entity => entity.PerformingUserId, dto => dto.PerformingUserId); - CacheMap(entity => entity.PerformingDetails, dto => dto.PerformingDetails); - CacheMap(entity => entity.PerformingIp, dto => dto.PerformingIp); - CacheMap(entity => entity.EventDateUtc, dto => dto.EventDateUtc); - CacheMap(entity => entity.AffectedUserId, dto => dto.AffectedUserId); - CacheMap(entity => entity.AffectedDetails, dto => dto.AffectedDetails); - CacheMap(entity => entity.EventType, dto => dto.EventType); - CacheMap(entity => entity.EventDetails, dto => dto.EventDetails); + DefineMap(nameof(AuditEntry.Id), nameof(AuditEntryDto.Id)); + DefineMap(nameof(AuditEntry.PerformingUserId), nameof(AuditEntryDto.PerformingUserId)); + DefineMap(nameof(AuditEntry.PerformingDetails), nameof(AuditEntryDto.PerformingDetails)); + DefineMap(nameof(AuditEntry.PerformingIp), nameof(AuditEntryDto.PerformingIp)); + DefineMap(nameof(AuditEntry.EventDateUtc), nameof(AuditEntryDto.EventDateUtc)); + DefineMap(nameof(AuditEntry.AffectedUserId), nameof(AuditEntryDto.AffectedUserId)); + DefineMap(nameof(AuditEntry.AffectedDetails), nameof(AuditEntryDto.AffectedDetails)); + DefineMap(nameof(AuditEntry.EventType), nameof(AuditEntryDto.EventType)); + DefineMap(nameof(AuditEntry.EventDetails), nameof(AuditEntryDto.EventDetails)); } } } diff --git a/src/Umbraco.Core/Persistence/Mappers/AuditItemMapper.cs b/src/Umbraco.Core/Persistence/Mappers/AuditItemMapper.cs index ad1964ee07..bada61a097 100644 --- a/src/Umbraco.Core/Persistence/Mappers/AuditItemMapper.cs +++ b/src/Umbraco.Core/Persistence/Mappers/AuditItemMapper.cs @@ -1,4 +1,5 @@ -using System.Collections.Concurrent; +using System; +using System.Collections.Concurrent; using Umbraco.Core.Models; using Umbraco.Core.Persistence.Dtos; @@ -8,17 +9,14 @@ namespace Umbraco.Core.Persistence.Mappers [MapperFor(typeof(IAuditItem))] public sealed class AuditItemMapper : BaseMapper { - private static readonly ConcurrentDictionary PropertyInfoCacheInstance = new ConcurrentDictionary(); - - internal override ConcurrentDictionary PropertyInfoCache => PropertyInfoCacheInstance; - - protected override void BuildMap() + public AuditItemMapper(ISqlContext sqlContext, ConcurrentDictionary> maps) + : base(sqlContext, maps) { - CacheMap(src => src.Id, dto => dto.NodeId); - CacheMap(src => src.CreateDate, dto => dto.Datestamp); - CacheMap(src => src.UserId, dto => dto.UserId); - CacheMap(src => src.AuditType, dto => dto.Header); - CacheMap(src => src.Comment, dto => dto.Comment); + DefineMap(nameof(AuditItem.Id), nameof(LogDto.NodeId)); + DefineMap(nameof(AuditItem.CreateDate), nameof(LogDto.Datestamp)); + DefineMap(nameof(AuditItem.UserId), nameof(LogDto.UserId)); + DefineMap(nameof(AuditItem.AuditType), nameof(LogDto.Header)); + DefineMap(nameof(AuditItem.Comment), nameof(LogDto.Comment)); } } } diff --git a/src/Umbraco.Core/Persistence/Mappers/BaseMapper.cs b/src/Umbraco.Core/Persistence/Mappers/BaseMapper.cs index 22421eca53..88b6aed923 100644 --- a/src/Umbraco.Core/Persistence/Mappers/BaseMapper.cs +++ b/src/Umbraco.Core/Persistence/Mappers/BaseMapper.cs @@ -1,7 +1,5 @@ using System; using System.Collections.Concurrent; -using System.Linq.Expressions; -using System.Reflection; using NPoco; using Umbraco.Core.Persistence.SqlSyntax; using Umbraco.Core.Composing; @@ -10,22 +8,38 @@ namespace Umbraco.Core.Persistence.Mappers { public abstract class BaseMapper : IDiscoverable { - protected BaseMapper() + private readonly ISqlSyntaxProvider _sqlSyntax; + private readonly ConcurrentDictionary> _maps; + + protected BaseMapper(ISqlContext sqlContext, ConcurrentDictionary> maps) { - Build(); + _sqlSyntax = sqlContext.SqlSyntax; + _maps = maps; } - internal abstract ConcurrentDictionary PropertyInfoCache { get; } - - private void Build() + internal string Map(string propertyName, bool throws = false) { - BuildMap(); + if (!_maps.TryGetValue(GetType(), out var mapperMaps)) + throw new InvalidOperationException($"No maps defined for mapper {GetType().FullName}."); + if (!mapperMaps.TryGetValue(propertyName, out var mappedName)) + throw new InvalidOperationException($"No map defined by mapper {GetType().FullName} for property {propertyName}."); + return mappedName; } - protected abstract void BuildMap(); - + // fixme kill + /* internal string Map(ISqlSyntaxProvider sqlSyntax, string propertyName, bool throws = false) { + // fixme mapping a string to a string - should be a dictionary! + // and then why have the other dictionary? should BuildMap(syntax) => directly build the correct string + + /-* + var propertyInfo = PropertyInfoCache[propertyName].PropertyInfo; // fixme - tryGet + var tableName = propertyInfo.DeclaringType.FirstAttribute().Value; + var columnName = propertyInfo.FirstAttribute().Name; + var mapped = sqlSyntax.GetQuotedTableName(tableName) + "." + sqlSyntax.GetQuotedColumnName(columnName); + *-/ + if (PropertyInfoCache.TryGetValue(propertyName, out var dtoTypeProperty)) return GetColumnName(sqlSyntax, dtoTypeProperty.Type, dtoTypeProperty.PropertyInfo); @@ -40,8 +54,36 @@ namespace Umbraco.Core.Persistence.Mappers var property = ResolveMapping(sourceMember, destinationMember); PropertyInfoCache.AddOrUpdate(property.SourcePropertyName, property, (x, y) => property); } + */ - internal DtoMapModel ResolveMapping(Expression> sourceMember, Expression> destinationMember) + //protected void DefineMap(string sourceName, Expression> targetMember) + protected void DefineMap(string sourceName, string targetName) + { + var sourceType = typeof(TSource); + var targetType = typeof(TTarget); + + // TODO ensure that sourceName is a valid sourceType property (but, slow?) + + var tableNameAttribute = targetType.FirstAttribute(); + if (tableNameAttribute == null) throw new InvalidOperationException($"Type {targetType.FullName} is not marked with a TableName attribute."); + var tableName = tableNameAttribute.Value; + + // TODO maybe get all properties once and then index them + var targetProperty = targetType.GetProperty(targetName); + if (targetProperty == null) throw new InvalidOperationException($"Type {targetType.FullName} does not have a property named {targetName}."); + var columnAttribute = targetProperty.FirstAttribute(); + if (columnAttribute == null) throw new InvalidOperationException($"Property {targetType.FullName}.{targetName} is not marked with a Column attribute."); + + var columnName = columnAttribute.Name; + var columnMap = _sqlSyntax.GetQuotedTableName(tableName) + "." + _sqlSyntax.GetQuotedColumnName(columnName); + + var mapperMaps = _maps.GetOrAdd(GetType(), type => new ConcurrentDictionary()); + mapperMaps[sourceName] = columnMap; + } + + // fixme kill + /* + private static DtoMapModel ResolveMapping(Expression> sourceMember, Expression> destinationMember) { var source = ExpressionHelper.FindProperty(sourceMember); var destination = (PropertyInfo) ExpressionHelper.FindProperty(destinationMember).Item1; @@ -54,7 +96,7 @@ namespace Umbraco.Core.Persistence.Mappers return new DtoMapModel(typeof(TDestination), destination, source.Item1.Name); } - internal virtual string GetColumnName(ISqlSyntaxProvider sqlSyntax, Type dtoType, PropertyInfo dtoProperty) + private static string GetColumnName(ISqlSyntaxProvider sqlSyntax, Type dtoType, PropertyInfo dtoProperty) { var tableNameAttribute = dtoType.FirstAttribute(); var tableName = tableNameAttribute.Value; @@ -65,5 +107,6 @@ namespace Umbraco.Core.Persistence.Mappers var columnMap = sqlSyntax.GetQuotedTableName(tableName) + "." + sqlSyntax.GetQuotedColumnName(columnName); return columnMap; } + */ } } diff --git a/src/Umbraco.Core/Persistence/Mappers/ConsentMapper.cs b/src/Umbraco.Core/Persistence/Mappers/ConsentMapper.cs index 063197d1a2..b8cfefae24 100644 --- a/src/Umbraco.Core/Persistence/Mappers/ConsentMapper.cs +++ b/src/Umbraco.Core/Persistence/Mappers/ConsentMapper.cs @@ -1,4 +1,5 @@ -using System.Collections.Concurrent; +using System; +using System.Collections.Concurrent; using Umbraco.Core.Models; using Umbraco.Core.Persistence.Dtos; @@ -11,20 +12,17 @@ namespace Umbraco.Core.Persistence.Mappers [MapperFor(typeof(Consent))] public sealed class ConsentMapper : BaseMapper { - private static readonly ConcurrentDictionary PropertyInfoCacheInstance = new ConcurrentDictionary(); - - internal override ConcurrentDictionary PropertyInfoCache => PropertyInfoCacheInstance; - - protected override void BuildMap() + public ConsentMapper(ISqlContext sqlContext, ConcurrentDictionary> maps) + : base(sqlContext, maps) { - CacheMap(entity => entity.Id, dto => dto.Id); - CacheMap(entity => entity.Current, dto => dto.Current); - CacheMap(entity => entity.CreateDate, dto => dto.CreateDate); - CacheMap(entity => entity.Source, dto => dto.Source); - CacheMap(entity => entity.Context, dto => dto.Context); - CacheMap(entity => entity.Action, dto => dto.Action); - CacheMap(entity => entity.State, dto => dto.State); - CacheMap(entity => entity.Comment, dto => dto.Comment); + DefineMap(nameof(Consent.Id), nameof(ConsentDto.Id)); + DefineMap(nameof(Consent.Current), nameof(ConsentDto.Current)); + DefineMap(nameof(Consent.CreateDate), nameof(ConsentDto.CreateDate)); + DefineMap(nameof(Consent.Source), nameof(ConsentDto.Source)); + DefineMap(nameof(Consent.Context), nameof(ConsentDto.Context)); + DefineMap(nameof(Consent.Action), nameof(ConsentDto.Action)); + DefineMap(nameof(Consent.State), nameof(ConsentDto.State)); + DefineMap(nameof(Consent.Comment), nameof(ConsentDto.Comment)); } } } diff --git a/src/Umbraco.Core/Persistence/Mappers/ContentMapper.cs b/src/Umbraco.Core/Persistence/Mappers/ContentMapper.cs index 2cc3a5b140..1b75db38ef 100644 --- a/src/Umbraco.Core/Persistence/Mappers/ContentMapper.cs +++ b/src/Umbraco.Core/Persistence/Mappers/ContentMapper.cs @@ -1,4 +1,5 @@ -using System.Collections.Concurrent; +using System; +using System.Collections.Concurrent; using Umbraco.Core.Models; using Umbraco.Core.Persistence.Dtos; @@ -12,36 +13,31 @@ namespace Umbraco.Core.Persistence.Mappers [MapperFor(typeof(IContent))] public sealed class ContentMapper : BaseMapper { - private static readonly ConcurrentDictionary PropertyInfoCacheInstance = new ConcurrentDictionary(); - - internal override ConcurrentDictionary PropertyInfoCache => PropertyInfoCacheInstance; - - protected override void BuildMap() + public ContentMapper(ISqlContext sqlContext, ConcurrentDictionary> maps) + : base(sqlContext, maps) { - if (PropertyInfoCache.IsEmpty == false) return; + DefineMap(nameof(Content.Id), nameof(NodeDto.NodeId)); + DefineMap(nameof(Content.Key), nameof(NodeDto.UniqueId)); - CacheMap(src => src.Id, dto => dto.NodeId); - CacheMap(src => src.Key, dto => dto.UniqueId); + DefineMap(nameof(Content.VersionId), nameof(ContentVersionDto.Id)); + DefineMap(nameof(Content.Name), nameof(ContentVersionDto.Text)); - CacheMap(src => src.VersionId, dto => dto.Id); - CacheMap(src => src.Name, dto => dto.Text); + DefineMap(nameof(Content.ParentId), nameof(NodeDto.ParentId)); + DefineMap(nameof(Content.Level), nameof(NodeDto.Level)); + DefineMap(nameof(Content.Path), nameof(NodeDto.Path)); + DefineMap(nameof(Content.SortOrder), nameof(NodeDto.SortOrder)); + DefineMap(nameof(Content.Trashed), nameof(NodeDto.Trashed)); - CacheMap(src => src.ParentId, dto => dto.ParentId); - CacheMap(src => src.Level, dto => dto.Level); - CacheMap(src => src.Path, dto => dto.Path); - CacheMap(src => src.SortOrder, dto => dto.SortOrder); - CacheMap(src => src.Trashed, dto => dto.Trashed); + DefineMap(nameof(Content.CreateDate), nameof(NodeDto.CreateDate)); + DefineMap(nameof(Content.CreatorId), nameof(NodeDto.UserId)); + DefineMap(nameof(Content.ContentTypeId), nameof(ContentDto.ContentTypeId)); - CacheMap(src => src.CreateDate, dto => dto.CreateDate); - CacheMap(src => src.CreatorId, dto => dto.UserId); - CacheMap(src => src.ContentTypeId, dto => dto.ContentTypeId); + DefineMap(nameof(Content.UpdateDate), nameof(ContentVersionDto.VersionDate)); + DefineMap(nameof(Content.Published), nameof(DocumentDto.Published)); - CacheMap(src => src.UpdateDate, dto => dto.VersionDate); - CacheMap(src => src.Published, dto => dto.Published); - - //CacheMap(src => src.Name, dto => dto.Alias); + //DefineMap(nameof(Content.Name), nameof(DocumentDto.Alias)); //CacheMap(src => src, dto => dto.Newest); - //CacheMap(src => src.Template, dto => dto.TemplateId); + //DefineMap(nameof(Content.Template), nameof(DocumentDto.TemplateId)); } } } diff --git a/src/Umbraco.Core/Persistence/Mappers/ContentTypeMapper.cs b/src/Umbraco.Core/Persistence/Mappers/ContentTypeMapper.cs index a24963bace..c87ca1a321 100644 --- a/src/Umbraco.Core/Persistence/Mappers/ContentTypeMapper.cs +++ b/src/Umbraco.Core/Persistence/Mappers/ContentTypeMapper.cs @@ -1,4 +1,5 @@ -using System.Collections.Concurrent; +using System; +using System.Collections.Concurrent; using Umbraco.Core.Models; using Umbraco.Core.Persistence.Dtos; @@ -12,31 +13,26 @@ namespace Umbraco.Core.Persistence.Mappers [MapperFor(typeof(IContentType))] public sealed class ContentTypeMapper : BaseMapper { - private static readonly ConcurrentDictionary PropertyInfoCacheInstance = new ConcurrentDictionary(); - - internal override ConcurrentDictionary PropertyInfoCache => PropertyInfoCacheInstance; - - protected override void BuildMap() + public ContentTypeMapper(ISqlContext sqlContext, ConcurrentDictionary> maps) + : base(sqlContext, maps) { - if (PropertyInfoCache.IsEmpty == false) return; - - CacheMap(src => src.Id, dto => dto.NodeId); - CacheMap(src => src.CreateDate, dto => dto.CreateDate); - CacheMap(src => src.Level, dto => dto.Level); - CacheMap(src => src.ParentId, dto => dto.ParentId); - CacheMap(src => src.Path, dto => dto.Path); - CacheMap(src => src.SortOrder, dto => dto.SortOrder); - CacheMap(src => src.Name, dto => dto.Text); - CacheMap(src => src.Trashed, dto => dto.Trashed); - CacheMap(src => src.Key, dto => dto.UniqueId); - CacheMap(src => src.CreatorId, dto => dto.UserId); - CacheMap(src => src.Alias, dto => dto.Alias); - CacheMap(src => src.AllowedAsRoot, dto => dto.AllowAtRoot); - CacheMap(src => src.Description, dto => dto.Description); - CacheMap(src => src.Icon, dto => dto.Icon); - CacheMap(src => src.IsContainer, dto => dto.IsContainer); - CacheMap(src => src.IsElement, dto => dto.IsElement); - CacheMap(src => src.Thumbnail, dto => dto.Thumbnail); + DefineMap(nameof(ContentType.Id), nameof(NodeDto.NodeId)); + DefineMap(nameof(ContentType.CreateDate), nameof(NodeDto.CreateDate)); + DefineMap(nameof(ContentType.Level), nameof(NodeDto.Level)); + DefineMap(nameof(ContentType.ParentId), nameof(NodeDto.ParentId)); + DefineMap(nameof(ContentType.Path), nameof(NodeDto.Path)); + DefineMap(nameof(ContentType.SortOrder), nameof(NodeDto.SortOrder)); + DefineMap(nameof(ContentType.Name), nameof(NodeDto.Text)); + DefineMap(nameof(ContentType.Trashed), nameof(NodeDto.Trashed)); + DefineMap(nameof(ContentType.Key), nameof(NodeDto.UniqueId)); + DefineMap(nameof(ContentType.CreatorId), nameof(NodeDto.UserId)); + DefineMap(nameof(ContentType.Alias), nameof(ContentTypeDto.Alias)); + DefineMap(nameof(ContentType.AllowedAsRoot), nameof(ContentTypeDto.AllowAtRoot)); + DefineMap(nameof(ContentType.Description), nameof(ContentTypeDto.Description)); + DefineMap(nameof(ContentType.Icon), nameof(ContentTypeDto.Icon)); + DefineMap(nameof(ContentType.IsContainer), nameof(ContentTypeDto.IsContainer)); + DefineMap(nameof(ContentType.IsElement), nameof(ContentTypeDto.IsElement)); + DefineMap(nameof(ContentType.Thumbnail), nameof(ContentTypeDto.Thumbnail)); } } } diff --git a/src/Umbraco.Core/Persistence/Mappers/DataTypeMapper.cs b/src/Umbraco.Core/Persistence/Mappers/DataTypeMapper.cs index a67f9301b2..266adb0aeb 100644 --- a/src/Umbraco.Core/Persistence/Mappers/DataTypeMapper.cs +++ b/src/Umbraco.Core/Persistence/Mappers/DataTypeMapper.cs @@ -1,4 +1,5 @@ -using System.Collections.Concurrent; +using System; +using System.Collections.Concurrent; using Umbraco.Core.Models; using Umbraco.Core.Persistence.Dtos; @@ -12,25 +13,21 @@ namespace Umbraco.Core.Persistence.Mappers [MapperFor(typeof(IDataType))] public sealed class DataTypeMapper : BaseMapper { - private static readonly ConcurrentDictionary PropertyInfoCacheInstance = new ConcurrentDictionary(); - - internal override ConcurrentDictionary PropertyInfoCache => PropertyInfoCacheInstance; - - protected override void BuildMap() + public DataTypeMapper(ISqlContext sqlContext, ConcurrentDictionary> maps) + : base(sqlContext, maps) { - CacheMap(src => src.Id, dto => dto.NodeId); - CacheMap(src => src.CreateDate, dto => dto.CreateDate); - CacheMap(src => src.Level, dto => dto.Level); - CacheMap(src => src.ParentId, dto => dto.ParentId); - CacheMap(src => src.Path, dto => dto.Path); - CacheMap(src => src.SortOrder, dto => dto.SortOrder); - CacheMap(src => src.Name, dto => dto.Text); - CacheMap(src => src.Trashed, dto => dto.Trashed); - CacheMap(src => src.Key, dto => dto.UniqueId); - CacheMap(src => src.CreatorId, dto => dto.UserId); - CacheMap(src => src.EditorAlias, dto => dto.EditorAlias); - CacheMap(src => src.DatabaseType, dto => dto.DbType); - + DefineMap(nameof(DataType.Id), nameof(NodeDto.NodeId)); + DefineMap(nameof(DataType.CreateDate), nameof(NodeDto.CreateDate)); + DefineMap(nameof(DataType.Level), nameof(NodeDto.Level)); + DefineMap(nameof(DataType.ParentId), nameof(NodeDto.ParentId)); + DefineMap(nameof(DataType.Path), nameof(NodeDto.Path)); + DefineMap(nameof(DataType.SortOrder), nameof(NodeDto.SortOrder)); + DefineMap(nameof(DataType.Name), nameof(NodeDto.Text)); + DefineMap(nameof(DataType.Trashed), nameof(NodeDto.Trashed)); + DefineMap(nameof(DataType.Key), nameof(NodeDto.UniqueId)); + DefineMap(nameof(DataType.CreatorId), nameof(NodeDto.UserId)); + DefineMap(nameof(DataType.EditorAlias), nameof(DataTypeDto.EditorAlias)); + DefineMap(nameof(DataType.DatabaseType), nameof(DataTypeDto.DbType)); } } } diff --git a/src/Umbraco.Core/Persistence/Mappers/DictionaryMapper.cs b/src/Umbraco.Core/Persistence/Mappers/DictionaryMapper.cs index 0c2773c2dd..467eb55ebe 100644 --- a/src/Umbraco.Core/Persistence/Mappers/DictionaryMapper.cs +++ b/src/Umbraco.Core/Persistence/Mappers/DictionaryMapper.cs @@ -1,4 +1,5 @@ -using System.Collections.Concurrent; +using System; +using System.Collections.Concurrent; using Umbraco.Core.Models; using Umbraco.Core.Persistence.Dtos; @@ -12,16 +13,13 @@ namespace Umbraco.Core.Persistence.Mappers [MapperFor(typeof(IDictionaryItem))] public sealed class DictionaryMapper : BaseMapper { - private static readonly ConcurrentDictionary PropertyInfoCacheInstance = new ConcurrentDictionary(); - - internal override ConcurrentDictionary PropertyInfoCache => PropertyInfoCacheInstance; - - protected override void BuildMap() + public DictionaryMapper(ISqlContext sqlContext, ConcurrentDictionary> maps) + : base(sqlContext, maps) { - CacheMap(src => src.Id, dto => dto.PrimaryKey); - CacheMap(src => src.Key, dto => dto.UniqueId); - CacheMap(src => src.ItemKey, dto => dto.Key); - CacheMap(src => src.ParentId, dto => dto.Parent); + DefineMap(nameof(DictionaryItem.Id), nameof(DictionaryDto.PrimaryKey)); + DefineMap(nameof(DictionaryItem.Key), nameof(DictionaryDto.UniqueId)); + DefineMap(nameof(DictionaryItem.ItemKey), nameof(DictionaryDto.Key)); + DefineMap(nameof(DictionaryItem.ParentId), nameof(DictionaryDto.Parent)); } } } diff --git a/src/Umbraco.Core/Persistence/Mappers/DictionaryTranslationMapper.cs b/src/Umbraco.Core/Persistence/Mappers/DictionaryTranslationMapper.cs index 3f8641b959..6383604dbe 100644 --- a/src/Umbraco.Core/Persistence/Mappers/DictionaryTranslationMapper.cs +++ b/src/Umbraco.Core/Persistence/Mappers/DictionaryTranslationMapper.cs @@ -1,4 +1,5 @@ -using System.Collections.Concurrent; +using System; +using System.Collections.Concurrent; using Umbraco.Core.Models; using Umbraco.Core.Persistence.Dtos; @@ -12,16 +13,13 @@ namespace Umbraco.Core.Persistence.Mappers [MapperFor(typeof(IDictionaryTranslation))] public sealed class DictionaryTranslationMapper : BaseMapper { - private static readonly ConcurrentDictionary PropertyInfoCacheInstance = new ConcurrentDictionary(); - - internal override ConcurrentDictionary PropertyInfoCache => PropertyInfoCacheInstance; - - protected override void BuildMap() + public DictionaryTranslationMapper(ISqlContext sqlContext, ConcurrentDictionary> maps) + : base(sqlContext, maps) { - CacheMap(src => src.Id, dto => dto.PrimaryKey); - CacheMap(src => src.Key, dto => dto.UniqueId); - CacheMap(src => src.Language, dto => dto.LanguageId); - CacheMap(src => src.Value, dto => dto.Value); + DefineMap(nameof(DictionaryTranslation.Id), nameof(LanguageTextDto.PrimaryKey)); + DefineMap(nameof(DictionaryTranslation.Key), nameof(LanguageTextDto.UniqueId)); + DefineMap(nameof(DictionaryTranslation.Language), nameof(LanguageTextDto.LanguageId)); + DefineMap(nameof(DictionaryTranslation.Value), nameof(LanguageTextDto.Value)); } } } diff --git a/src/Umbraco.Core/Persistence/Mappers/DomainMapper.cs b/src/Umbraco.Core/Persistence/Mappers/DomainMapper.cs index 0bce8d7538..4d91b54691 100644 --- a/src/Umbraco.Core/Persistence/Mappers/DomainMapper.cs +++ b/src/Umbraco.Core/Persistence/Mappers/DomainMapper.cs @@ -1,4 +1,5 @@ -using System.Collections.Concurrent; +using System; +using System.Collections.Concurrent; using Umbraco.Core.Models; using Umbraco.Core.Persistence.Dtos; @@ -8,16 +9,13 @@ namespace Umbraco.Core.Persistence.Mappers [MapperFor(typeof(UmbracoDomain))] public sealed class DomainMapper : BaseMapper { - private static readonly ConcurrentDictionary PropertyInfoCacheInstance = new ConcurrentDictionary(); - - internal override ConcurrentDictionary PropertyInfoCache => PropertyInfoCacheInstance; - - protected override void BuildMap() + public DomainMapper(ISqlContext sqlContext, ConcurrentDictionary> maps) + : base(sqlContext, maps) { - CacheMap(src => src.Id, dto => dto.Id); - CacheMap(src => src.RootContentId, dto => dto.RootStructureId); - CacheMap(src => src.LanguageId, dto => dto.DefaultLanguage); - CacheMap(src => src.DomainName, dto => dto.DomainName); + DefineMap(nameof(UmbracoDomain.Id), nameof(DomainDto.Id)); + DefineMap(nameof(UmbracoDomain.RootContentId), nameof(DomainDto.RootStructureId)); + DefineMap(nameof(UmbracoDomain.LanguageId), nameof(DomainDto.DefaultLanguage)); + DefineMap(nameof(UmbracoDomain.DomainName), nameof(DomainDto.DomainName)); } } } diff --git a/src/Umbraco.Core/Persistence/Mappers/DtoMapModel.cs b/src/Umbraco.Core/Persistence/Mappers/DtoMapModel.cs deleted file mode 100644 index ebf16a1d36..0000000000 --- a/src/Umbraco.Core/Persistence/Mappers/DtoMapModel.cs +++ /dev/null @@ -1,19 +0,0 @@ -using System; -using System.Reflection; - -namespace Umbraco.Core.Persistence.Mappers -{ - internal class DtoMapModel - { - public DtoMapModel(Type type, PropertyInfo propertyInfo, string sourcePropertyName) - { - Type = type; - PropertyInfo = propertyInfo; - SourcePropertyName = sourcePropertyName; - } - - public string SourcePropertyName { get; private set; } - public Type Type { get; private set; } - public PropertyInfo PropertyInfo { get; private set; } - } -} diff --git a/src/Umbraco.Core/Persistence/Mappers/ExternalLoginMapper.cs b/src/Umbraco.Core/Persistence/Mappers/ExternalLoginMapper.cs index d3fb24273b..3f95dbccc9 100644 --- a/src/Umbraco.Core/Persistence/Mappers/ExternalLoginMapper.cs +++ b/src/Umbraco.Core/Persistence/Mappers/ExternalLoginMapper.cs @@ -1,4 +1,5 @@ -using System.Collections.Concurrent; +using System; +using System.Collections.Concurrent; using Umbraco.Core.Models.Identity; using Umbraco.Core.Persistence.Dtos; @@ -8,25 +9,14 @@ namespace Umbraco.Core.Persistence.Mappers [MapperFor(typeof(IdentityUserLogin))] public sealed class ExternalLoginMapper : BaseMapper { - private static readonly ConcurrentDictionary PropertyInfoCacheInstance = new ConcurrentDictionary(); - public ExternalLoginMapper() + public ExternalLoginMapper(ISqlContext sqlContext, ConcurrentDictionary> maps) + : base(sqlContext, maps) { - BuildMap(); + DefineMap(nameof(IdentityUserLogin.Id), nameof(ExternalLoginDto.Id)); + DefineMap(nameof(IdentityUserLogin.CreateDate), nameof(ExternalLoginDto.CreateDate)); + DefineMap(nameof(IdentityUserLogin.LoginProvider), nameof(ExternalLoginDto.LoginProvider)); + DefineMap(nameof(IdentityUserLogin.ProviderKey), nameof(ExternalLoginDto.ProviderKey)); + DefineMap(nameof(IdentityUserLogin.UserId), nameof(ExternalLoginDto.UserId)); } - - #region Overrides of BaseMapper - - internal override ConcurrentDictionary PropertyInfoCache => PropertyInfoCacheInstance; - - protected override void BuildMap() - { - CacheMap(src => src.Id, dto => dto.Id); - CacheMap(src => src.CreateDate, dto => dto.CreateDate); - CacheMap(src => src.LoginProvider, dto => dto.LoginProvider); - CacheMap(src => src.ProviderKey, dto => dto.ProviderKey); - CacheMap(src => src.UserId, dto => dto.UserId); - } - - #endregion } } diff --git a/src/Umbraco.Core/Persistence/Mappers/LanguageMapper.cs b/src/Umbraco.Core/Persistence/Mappers/LanguageMapper.cs index ea7d4c2f09..eeb89f9e7c 100644 --- a/src/Umbraco.Core/Persistence/Mappers/LanguageMapper.cs +++ b/src/Umbraco.Core/Persistence/Mappers/LanguageMapper.cs @@ -1,4 +1,5 @@ -using System.Collections.Concurrent; +using System; +using System.Collections.Concurrent; using Umbraco.Core.Models; using Umbraco.Core.Persistence.Dtos; @@ -12,15 +13,12 @@ namespace Umbraco.Core.Persistence.Mappers [MapperFor(typeof(Language))] public sealed class LanguageMapper : BaseMapper { - private static readonly ConcurrentDictionary PropertyInfoCacheInstance = new ConcurrentDictionary(); - - internal override ConcurrentDictionary PropertyInfoCache => PropertyInfoCacheInstance; - - protected override void BuildMap() + public LanguageMapper(ISqlContext sqlContext, ConcurrentDictionary> maps) + : base(sqlContext, maps) { - CacheMap(src => src.Id, dto => dto.Id); - CacheMap(src => src.IsoCode, dto => dto.IsoCode); - CacheMap(src => src.CultureName, dto => dto.CultureName); + DefineMap(nameof(Language.Id), nameof(LanguageDto.Id)); + DefineMap(nameof(Language.IsoCode), nameof(LanguageDto.IsoCode)); + DefineMap(nameof(Language.CultureName), nameof(LanguageDto.CultureName)); } } } diff --git a/src/Umbraco.Core/Persistence/Mappers/MacroMapper.cs b/src/Umbraco.Core/Persistence/Mappers/MacroMapper.cs index b6da1dc3d8..00eb5ea02f 100644 --- a/src/Umbraco.Core/Persistence/Mappers/MacroMapper.cs +++ b/src/Umbraco.Core/Persistence/Mappers/MacroMapper.cs @@ -1,4 +1,5 @@ -using System.Collections.Concurrent; +using System; +using System.Collections.Concurrent; using Umbraco.Core.Models; using Umbraco.Core.Persistence.Dtos; @@ -8,22 +9,19 @@ namespace Umbraco.Core.Persistence.Mappers [MapperFor(typeof(IMacro))] internal sealed class MacroMapper : BaseMapper { - private static readonly ConcurrentDictionary PropertyInfoCacheInstance = new ConcurrentDictionary(); - - internal override ConcurrentDictionary PropertyInfoCache => PropertyInfoCacheInstance; - - protected override void BuildMap() + public MacroMapper(ISqlContext sqlContext, ConcurrentDictionary> maps) + : base(sqlContext, maps) { - CacheMap(src => src.Id, dto => dto.Id); - CacheMap(src => src.Alias, dto => dto.Alias); - CacheMap(src => src.CacheByPage, dto => dto.CacheByPage); - CacheMap(src => src.CacheByMember, dto => dto.CachePersonalized); - CacheMap(src => src.MacroType, dto => dto.MacroType); - CacheMap(src => src.DontRender, dto => dto.DontRender); - CacheMap(src => src.Name, dto => dto.Name); - CacheMap(src => src.CacheDuration, dto => dto.RefreshRate); - CacheMap(src => src.MacroSource, dto => dto.MacroSource); - CacheMap(src => src.UseInEditor, dto => dto.UseInEditor); + DefineMap(nameof(Macro.Id), nameof(MacroDto.Id)); + DefineMap(nameof(Macro.Alias), nameof(MacroDto.Alias)); + DefineMap(nameof(Macro.CacheByPage), nameof(MacroDto.CacheByPage)); + DefineMap(nameof(Macro.CacheByMember), nameof(MacroDto.CachePersonalized)); + DefineMap(nameof(Macro.MacroType), nameof(MacroDto.MacroType)); + DefineMap(nameof(Macro.DontRender), nameof(MacroDto.DontRender)); + DefineMap(nameof(Macro.Name), nameof(MacroDto.Name)); + DefineMap(nameof(Macro.CacheDuration), nameof(MacroDto.RefreshRate)); + DefineMap(nameof(Macro.MacroSource), nameof(MacroDto.MacroSource)); + DefineMap(nameof(Macro.UseInEditor), nameof(MacroDto.UseInEditor)); } } } diff --git a/src/Umbraco.Core/Persistence/Mappers/MapperCollectionBuilder.cs b/src/Umbraco.Core/Persistence/Mappers/MapperCollectionBuilder.cs index e20f7c1911..951b0cdf93 100644 --- a/src/Umbraco.Core/Persistence/Mappers/MapperCollectionBuilder.cs +++ b/src/Umbraco.Core/Persistence/Mappers/MapperCollectionBuilder.cs @@ -1,9 +1,14 @@ -using Umbraco.Core.Composing; +using System; +using System.Collections.Concurrent; +using Umbraco.Core.Composing; namespace Umbraco.Core.Persistence.Mappers { - public class MapperCollectionBuilder : LazyCollectionBuilderBase + public class MapperCollectionBuilder : SetCollectionBuilderBase { + private readonly ConcurrentDictionary> _maps + = new ConcurrentDictionary>(); + protected override MapperCollectionBuilder This => this; public override void RegisterWith(IRegister register) @@ -19,6 +24,11 @@ namespace Umbraco.Core.Persistence.Mappers register.Register(factory => factory.GetInstance()); } + protected override BaseMapper CreateItem(IFactory factory, Type itemType) + { + return (BaseMapper) factory.CreateInstance(itemType, _maps); + } + public MapperCollectionBuilder AddCoreMappers() { Add(); diff --git a/src/Umbraco.Core/Persistence/Mappers/MediaMapper.cs b/src/Umbraco.Core/Persistence/Mappers/MediaMapper.cs index 776f929e0d..558b5e2eba 100644 --- a/src/Umbraco.Core/Persistence/Mappers/MediaMapper.cs +++ b/src/Umbraco.Core/Persistence/Mappers/MediaMapper.cs @@ -1,4 +1,5 @@ -using System.Collections.Concurrent; +using System; +using System.Collections.Concurrent; using Umbraco.Core.Models; using Umbraco.Core.Persistence.Dtos; @@ -12,29 +13,24 @@ namespace Umbraco.Core.Persistence.Mappers [MapperFor(typeof(Umbraco.Core.Models.Media))] public sealed class MediaMapper : BaseMapper { - private static readonly ConcurrentDictionary PropertyInfoCacheInstance = new ConcurrentDictionary(); - - internal override ConcurrentDictionary PropertyInfoCache => PropertyInfoCacheInstance; - - protected override void BuildMap() + public MediaMapper(ISqlContext sqlContext, ConcurrentDictionary> maps) + : base(sqlContext, maps) { - if (PropertyInfoCache.IsEmpty == false) return; + DefineMap(nameof(Models.Media.Id), nameof(NodeDto.NodeId)); + DefineMap(nameof(Models.Media.Key), nameof(NodeDto.UniqueId)); - CacheMap(src => src.Id, dto => dto.NodeId); - CacheMap(src => src.Key, dto => dto.UniqueId); + DefineMap(nameof(Content.VersionId), nameof(ContentVersionDto.Id)); - CacheMap(src => src.VersionId, dto => dto.Id); - - CacheMap(src => src.CreateDate, dto => dto.CreateDate); - CacheMap(src => src.Level, dto => dto.Level); - CacheMap(src => src.ParentId, dto => dto.ParentId); - CacheMap(src => src.Path, dto => dto.Path); - CacheMap(src => src.SortOrder, dto => dto.SortOrder); - CacheMap(src => src.Name, dto => dto.Text); - CacheMap(src => src.Trashed, dto => dto.Trashed); - CacheMap(src => src.CreatorId, dto => dto.UserId); - CacheMap(src => src.ContentTypeId, dto => dto.ContentTypeId); - CacheMap(src => src.UpdateDate, dto => dto.VersionDate); + DefineMap(nameof(Models.Media.CreateDate), nameof(NodeDto.CreateDate)); + DefineMap(nameof(Models.Media.Level), nameof(NodeDto.Level)); + DefineMap(nameof(Models.Media.ParentId), nameof(NodeDto.ParentId)); + DefineMap(nameof(Models.Media.Path), nameof(NodeDto.Path)); + DefineMap(nameof(Models.Media.SortOrder), nameof(NodeDto.SortOrder)); + DefineMap(nameof(Models.Media.Name), nameof(NodeDto.Text)); + DefineMap(nameof(Models.Media.Trashed), nameof(NodeDto.Trashed)); + DefineMap(nameof(Models.Media.CreatorId), nameof(NodeDto.UserId)); + DefineMap(nameof(Models.Media.ContentTypeId), nameof(ContentDto.ContentTypeId)); + DefineMap(nameof(Models.Media.UpdateDate), nameof(ContentVersionDto.VersionDate)); } } } diff --git a/src/Umbraco.Core/Persistence/Mappers/MediaTypeMapper.cs b/src/Umbraco.Core/Persistence/Mappers/MediaTypeMapper.cs index 6cf83bc7aa..dabf259ec1 100644 --- a/src/Umbraco.Core/Persistence/Mappers/MediaTypeMapper.cs +++ b/src/Umbraco.Core/Persistence/Mappers/MediaTypeMapper.cs @@ -1,4 +1,5 @@ -using System.Collections.Concurrent; +using System; +using System.Collections.Concurrent; using Umbraco.Core.Models; using Umbraco.Core.Persistence.Dtos; @@ -12,31 +13,26 @@ namespace Umbraco.Core.Persistence.Mappers [MapperFor(typeof(MediaType))] public sealed class MediaTypeMapper : BaseMapper { - private static readonly ConcurrentDictionary PropertyInfoCacheInstance = new ConcurrentDictionary(); - - internal override ConcurrentDictionary PropertyInfoCache => PropertyInfoCacheInstance; - - protected override void BuildMap() + public MediaTypeMapper(ISqlContext sqlContext, ConcurrentDictionary> maps) + : base(sqlContext, maps) { - if (PropertyInfoCache.IsEmpty == false) return; - - CacheMap(src => src.Id, dto => dto.NodeId); - CacheMap(src => src.CreateDate, dto => dto.CreateDate); - CacheMap(src => src.Level, dto => dto.Level); - CacheMap(src => src.ParentId, dto => dto.ParentId); - CacheMap(src => src.Path, dto => dto.Path); - CacheMap(src => src.SortOrder, dto => dto.SortOrder); - CacheMap(src => src.Name, dto => dto.Text); - CacheMap(src => src.Trashed, dto => dto.Trashed); - CacheMap(src => src.Key, dto => dto.UniqueId); - CacheMap(src => src.CreatorId, dto => dto.UserId); - CacheMap(src => src.Alias, dto => dto.Alias); - CacheMap(src => src.AllowedAsRoot, dto => dto.AllowAtRoot); - CacheMap(src => src.Description, dto => dto.Description); - CacheMap(src => src.Icon, dto => dto.Icon); - CacheMap(src => src.IsContainer, dto => dto.IsContainer); - CacheMap(src => src.IsElement, dto => dto.IsElement); - CacheMap(src => src.Thumbnail, dto => dto.Thumbnail); + DefineMap(nameof(MediaType.Id), nameof(NodeDto.NodeId)); + DefineMap(nameof(MediaType.CreateDate), nameof(NodeDto.CreateDate)); + DefineMap(nameof(MediaType.Level), nameof(NodeDto.Level)); + DefineMap(nameof(MediaType.ParentId), nameof(NodeDto.ParentId)); + DefineMap(nameof(MediaType.Path), nameof(NodeDto.Path)); + DefineMap(nameof(MediaType.SortOrder), nameof(NodeDto.SortOrder)); + DefineMap(nameof(MediaType.Name), nameof(NodeDto.Text)); + DefineMap(nameof(MediaType.Trashed), nameof(NodeDto.Trashed)); + DefineMap(nameof(MediaType.Key), nameof(NodeDto.UniqueId)); + DefineMap(nameof(MediaType.CreatorId), nameof(NodeDto.UserId)); + DefineMap(nameof(MediaType.Alias), nameof(ContentTypeDto.Alias)); + DefineMap(nameof(MediaType.AllowedAsRoot), nameof(ContentTypeDto.AllowAtRoot)); + DefineMap(nameof(MediaType.Description), nameof(ContentTypeDto.Description)); + DefineMap(nameof(MediaType.Icon), nameof(ContentTypeDto.Icon)); + DefineMap(nameof(MediaType.IsContainer), nameof(ContentTypeDto.IsContainer)); + DefineMap(nameof(MediaType.IsElement), nameof(ContentTypeDto.IsElement)); + DefineMap(nameof(MediaType.Thumbnail), nameof(ContentTypeDto.Thumbnail)); } } } diff --git a/src/Umbraco.Core/Persistence/Mappers/MemberGroupMapper.cs b/src/Umbraco.Core/Persistence/Mappers/MemberGroupMapper.cs index 0358b9e6d2..74fce23b45 100644 --- a/src/Umbraco.Core/Persistence/Mappers/MemberGroupMapper.cs +++ b/src/Umbraco.Core/Persistence/Mappers/MemberGroupMapper.cs @@ -1,4 +1,5 @@ -using System.Collections.Concurrent; +using System; +using System.Collections.Concurrent; using Umbraco.Core.Models; using Umbraco.Core.Persistence.Dtos; @@ -8,17 +9,14 @@ namespace Umbraco.Core.Persistence.Mappers [MapperFor(typeof (MemberGroup))] public sealed class MemberGroupMapper : BaseMapper { - private static readonly ConcurrentDictionary PropertyInfoCacheInstance = new ConcurrentDictionary(); - - internal override ConcurrentDictionary PropertyInfoCache => PropertyInfoCacheInstance; - - protected override void BuildMap() + public MemberGroupMapper(ISqlContext sqlContext, ConcurrentDictionary> maps) + : base(sqlContext, maps) { - CacheMap(src => src.Id, dto => dto.NodeId); - CacheMap(src => src.CreateDate, dto => dto.CreateDate); - CacheMap(src => src.CreatorId, dto => dto.UserId); - CacheMap(src => src.Name, dto => dto.Text); - CacheMap(src => src.Key, dto => dto.UniqueId); + DefineMap(nameof(MemberGroup.Id), nameof(NodeDto.NodeId)); + DefineMap(nameof(MemberGroup.CreateDate), nameof(NodeDto.CreateDate)); + DefineMap(nameof(MemberGroup.CreatorId), nameof(NodeDto.UserId)); + DefineMap(nameof(MemberGroup.Name), nameof(NodeDto.Text)); + DefineMap(nameof(MemberGroup.Key), nameof(NodeDto.UniqueId)); } } } diff --git a/src/Umbraco.Core/Persistence/Mappers/MemberMapper.cs b/src/Umbraco.Core/Persistence/Mappers/MemberMapper.cs index a34d04fb2d..1a635fd38c 100644 --- a/src/Umbraco.Core/Persistence/Mappers/MemberMapper.cs +++ b/src/Umbraco.Core/Persistence/Mappers/MemberMapper.cs @@ -1,4 +1,5 @@ -using System.Collections.Concurrent; +using System; +using System.Collections.Concurrent; using Umbraco.Core.Models; using Umbraco.Core.Models.Entities; using Umbraco.Core.Persistence.Dtos; @@ -13,47 +14,44 @@ namespace Umbraco.Core.Persistence.Mappers [MapperFor(typeof(Member))] public sealed class MemberMapper : BaseMapper { - private static readonly ConcurrentDictionary PropertyInfoCacheInstance = new ConcurrentDictionary(); - - internal override ConcurrentDictionary PropertyInfoCache => PropertyInfoCacheInstance; - - protected override void BuildMap() + public MemberMapper(ISqlContext sqlContext, ConcurrentDictionary> maps) + : base(sqlContext, maps) { - CacheMap(src => src.Id, dto => dto.NodeId); - CacheMap(src => src.CreateDate, dto => dto.CreateDate); - CacheMap(src => ((IUmbracoEntity)src).Level, dto => dto.Level); - CacheMap(src => ((IUmbracoEntity)src).ParentId, dto => dto.ParentId); - CacheMap(src => ((IUmbracoEntity)src).Path, dto => dto.Path); - CacheMap(src => ((IUmbracoEntity)src).SortOrder, dto => dto.SortOrder); - CacheMap(src => ((IUmbracoEntity)src).CreatorId, dto => dto.UserId); - CacheMap(src => src.Name, dto => dto.Text); - CacheMap(src => src.Trashed, dto => dto.Trashed); - CacheMap(src => src.Key, dto => dto.UniqueId); - CacheMap(src => src.ContentTypeId, dto => dto.ContentTypeId); - CacheMap(src => src.ContentTypeAlias, dto => dto.Alias); - CacheMap(src => src.UpdateDate, dto => dto.VersionDate); + DefineMap(nameof(Member.Id), nameof(NodeDto.NodeId)); + DefineMap(nameof(Member.CreateDate), nameof(NodeDto.CreateDate)); + DefineMap(nameof(Member.Level), nameof(NodeDto.Level)); + DefineMap(nameof(Member.ParentId), nameof(NodeDto.ParentId)); + DefineMap(nameof(Member.Path), nameof(NodeDto.Path)); + DefineMap(nameof(Member.SortOrder), nameof(NodeDto.SortOrder)); + DefineMap(nameof(Member.CreatorId), nameof(NodeDto.UserId)); + DefineMap(nameof(Member.Name), nameof(NodeDto.Text)); + DefineMap(nameof(Member.Trashed), nameof(NodeDto.Trashed)); + DefineMap(nameof(Member.Key), nameof(NodeDto.UniqueId)); + DefineMap(nameof(Member.ContentTypeId), nameof(ContentDto.ContentTypeId)); + DefineMap(nameof(Member.ContentTypeAlias), nameof(ContentTypeDto.Alias)); + DefineMap(nameof(Member.UpdateDate), nameof(ContentVersionDto.VersionDate)); - CacheMap(src => src.Email, dto => dto.Email); - CacheMap(src => src.Username, dto => dto.LoginName); - CacheMap(src => src.RawPasswordValue, dto => dto.Password); + DefineMap(nameof(Member.Email), nameof(MemberDto.Email)); + DefineMap(nameof(Member.Username), nameof(MemberDto.LoginName)); + DefineMap(nameof(Member.RawPasswordValue), nameof(MemberDto.Password)); - CacheMap(src => src.IsApproved, dto => dto.IntegerValue); - CacheMap(src => src.IsLockedOut, dto => dto.IntegerValue); - CacheMap(src => src.Comments, dto => dto.TextValue); - CacheMap(src => src.RawPasswordAnswerValue, dto => dto.VarcharValue); - CacheMap(src => src.PasswordQuestion, dto => dto.VarcharValue); - CacheMap(src => src.FailedPasswordAttempts, dto => dto.IntegerValue); - CacheMap(src => src.LastLockoutDate, dto => dto.DateValue); - CacheMap(src => src.LastLoginDate, dto => dto.DateValue); - CacheMap(src => src.LastPasswordChangeDate, dto => dto.DateValue); + DefineMap(nameof(Member.IsApproved), nameof(PropertyDataDto.IntegerValue)); + DefineMap(nameof(Member.IsLockedOut), nameof(PropertyDataDto.IntegerValue)); + DefineMap(nameof(Member.Comments), nameof(PropertyDataDto.TextValue)); + DefineMap(nameof(Member.RawPasswordAnswerValue), nameof(PropertyDataDto.VarcharValue)); + DefineMap(nameof(Member.PasswordQuestion), nameof(PropertyDataDto.VarcharValue)); + DefineMap(nameof(Member.FailedPasswordAttempts), nameof(PropertyDataDto.IntegerValue)); + DefineMap(nameof(Member.LastLockoutDate), nameof(PropertyDataDto.DateValue)); + DefineMap(nameof(Member.LastLoginDate), nameof(PropertyDataDto.DateValue)); + DefineMap(nameof(Member.LastPasswordChangeDate), nameof(PropertyDataDto.DateValue)); /* Internal experiment */ - CacheMap(src => src.DateTimePropertyValue, dto => dto.DateValue); - CacheMap(src => src.IntegerPropertyValue, dto => dto.IntegerValue); - CacheMap(src => src.BoolPropertyValue, dto => dto.IntegerValue); - CacheMap(src => src.LongStringPropertyValue, dto => dto.TextValue); - CacheMap(src => src.ShortStringPropertyValue, dto => dto.VarcharValue); - CacheMap(src => src.PropertyTypeAlias, dto => dto.Alias); + DefineMap(nameof(Member.DateTimePropertyValue), nameof(PropertyDataDto.DateValue)); + DefineMap(nameof(Member.IntegerPropertyValue), nameof(PropertyDataDto.IntegerValue)); + DefineMap(nameof(Member.BoolPropertyValue), nameof(PropertyDataDto.IntegerValue)); + DefineMap(nameof(Member.LongStringPropertyValue), nameof(PropertyDataDto.TextValue)); + DefineMap(nameof(Member.ShortStringPropertyValue), nameof(PropertyDataDto.VarcharValue)); + DefineMap(nameof(Member.PropertyTypeAlias), nameof(PropertyTypeDto.Alias)); } } } diff --git a/src/Umbraco.Core/Persistence/Mappers/MemberTypeMapper.cs b/src/Umbraco.Core/Persistence/Mappers/MemberTypeMapper.cs index 9a4e4ec040..b25b0cc493 100644 --- a/src/Umbraco.Core/Persistence/Mappers/MemberTypeMapper.cs +++ b/src/Umbraco.Core/Persistence/Mappers/MemberTypeMapper.cs @@ -1,4 +1,5 @@ -using System.Collections.Concurrent; +using System; +using System.Collections.Concurrent; using Umbraco.Core.Models; using Umbraco.Core.Persistence.Dtos; @@ -12,31 +13,26 @@ namespace Umbraco.Core.Persistence.Mappers [MapperFor(typeof (IMemberType))] public sealed class MemberTypeMapper : BaseMapper { - private static readonly ConcurrentDictionary PropertyInfoCacheInstance = new ConcurrentDictionary(); - - internal override ConcurrentDictionary PropertyInfoCache => PropertyInfoCacheInstance; - - protected override void BuildMap() + public MemberTypeMapper(ISqlContext sqlContext, ConcurrentDictionary> maps) + : base(sqlContext, maps) { - if (PropertyInfoCache.IsEmpty == false) return; - - CacheMap(src => src.Id, dto => dto.NodeId); - CacheMap(src => src.CreateDate, dto => dto.CreateDate); - CacheMap(src => src.Level, dto => dto.Level); - CacheMap(src => src.ParentId, dto => dto.ParentId); - CacheMap(src => src.Path, dto => dto.Path); - CacheMap(src => src.SortOrder, dto => dto.SortOrder); - CacheMap(src => src.Name, dto => dto.Text); - CacheMap(src => src.Trashed, dto => dto.Trashed); - CacheMap(src => src.Key, dto => dto.UniqueId); - CacheMap(src => src.CreatorId, dto => dto.UserId); - CacheMap(src => src.Alias, dto => dto.Alias); - CacheMap(src => src.AllowedAsRoot, dto => dto.AllowAtRoot); - CacheMap(src => src.Description, dto => dto.Description); - CacheMap(src => src.Icon, dto => dto.Icon); - CacheMap(src => src.IsContainer, dto => dto.IsContainer); - CacheMap(src => src.IsElement, dto => dto.IsElement); - CacheMap(src => src.Thumbnail, dto => dto.Thumbnail); + DefineMap(nameof(MemberType.Id), nameof(NodeDto.NodeId)); + DefineMap(nameof(MemberType.CreateDate), nameof(NodeDto.CreateDate)); + DefineMap(nameof(MemberType.Level), nameof(NodeDto.Level)); + DefineMap(nameof(MemberType.ParentId), nameof(NodeDto.ParentId)); + DefineMap(nameof(MemberType.Path), nameof(NodeDto.Path)); + DefineMap(nameof(MemberType.SortOrder), nameof(NodeDto.SortOrder)); + DefineMap(nameof(MemberType.Name), nameof(NodeDto.Text)); + DefineMap(nameof(MemberType.Trashed), nameof(NodeDto.Trashed)); + DefineMap(nameof(MemberType.Key), nameof(NodeDto.UniqueId)); + DefineMap(nameof(MemberType.CreatorId), nameof(NodeDto.UserId)); + DefineMap(nameof(MemberType.Alias), nameof(ContentTypeDto.Alias)); + DefineMap(nameof(MemberType.AllowedAsRoot), nameof(ContentTypeDto.AllowAtRoot)); + DefineMap(nameof(MemberType.Description), nameof(ContentTypeDto.Description)); + DefineMap(nameof(MemberType.Icon), nameof(ContentTypeDto.Icon)); + DefineMap(nameof(MemberType.IsContainer), nameof(ContentTypeDto.IsContainer)); + DefineMap(nameof(MemberType.IsElement), nameof(ContentTypeDto.IsElement)); + DefineMap(nameof(MemberType.Thumbnail), nameof(ContentTypeDto.Thumbnail)); } } } diff --git a/src/Umbraco.Core/Persistence/Mappers/PropertyGroupMapper.cs b/src/Umbraco.Core/Persistence/Mappers/PropertyGroupMapper.cs index b485a2d420..02a4790b13 100644 --- a/src/Umbraco.Core/Persistence/Mappers/PropertyGroupMapper.cs +++ b/src/Umbraco.Core/Persistence/Mappers/PropertyGroupMapper.cs @@ -1,4 +1,5 @@ -using System.Collections.Concurrent; +using System; +using System.Collections.Concurrent; using Umbraco.Core.Models; using Umbraco.Core.Persistence.Dtos; @@ -11,16 +12,13 @@ namespace Umbraco.Core.Persistence.Mappers [MapperFor(typeof(PropertyGroup))] public sealed class PropertyGroupMapper : BaseMapper { - private static readonly ConcurrentDictionary PropertyInfoCacheInstance = new ConcurrentDictionary(); - - internal override ConcurrentDictionary PropertyInfoCache => PropertyInfoCacheInstance; - - protected override void BuildMap() + public PropertyGroupMapper(ISqlContext sqlContext, ConcurrentDictionary> maps) + : base(sqlContext, maps) { - CacheMap(src => src.Id, dto => dto.Id); - CacheMap(src => src.Key, dto => dto.UniqueId); - CacheMap(src => src.SortOrder, dto => dto.SortOrder); - CacheMap(src => src.Name, dto => dto.Text); + DefineMap(nameof(PropertyGroup.Id), nameof(PropertyTypeGroupDto.Id)); + DefineMap(nameof(PropertyGroup.Key), nameof(PropertyTypeGroupDto.UniqueId)); + DefineMap(nameof(PropertyGroup.SortOrder), nameof(PropertyTypeGroupDto.SortOrder)); + DefineMap(nameof(PropertyGroup.Name), nameof(PropertyTypeGroupDto.Text)); } } } diff --git a/src/Umbraco.Core/Persistence/Mappers/PropertyMapper.cs b/src/Umbraco.Core/Persistence/Mappers/PropertyMapper.cs index 2df9bf9af5..1c00060652 100644 --- a/src/Umbraco.Core/Persistence/Mappers/PropertyMapper.cs +++ b/src/Umbraco.Core/Persistence/Mappers/PropertyMapper.cs @@ -1,4 +1,5 @@ -using System.Collections.Concurrent; +using System; +using System.Collections.Concurrent; using Umbraco.Core.Models; using Umbraco.Core.Persistence.Dtos; @@ -7,14 +8,11 @@ namespace Umbraco.Core.Persistence.Mappers [MapperFor(typeof(Property))] public sealed class PropertyMapper : BaseMapper { - private static readonly ConcurrentDictionary PropertyInfoCacheInstance = new ConcurrentDictionary(); - - internal override ConcurrentDictionary PropertyInfoCache => PropertyInfoCacheInstance; - - protected override void BuildMap() + public PropertyMapper(ISqlContext sqlContext, ConcurrentDictionary> maps) + : base(sqlContext, maps) { - CacheMap(src => src.Id, dto => dto.Id); - CacheMap(src => src.PropertyTypeId, dto => dto.PropertyTypeId); + DefineMap(nameof(Property.Id), nameof(PropertyDataDto.Id)); + DefineMap(nameof(Property.PropertyTypeId), nameof(PropertyDataDto.PropertyTypeId)); } } } diff --git a/src/Umbraco.Core/Persistence/Mappers/PropertyTypeMapper.cs b/src/Umbraco.Core/Persistence/Mappers/PropertyTypeMapper.cs index 66c1d75165..a095a661a8 100644 --- a/src/Umbraco.Core/Persistence/Mappers/PropertyTypeMapper.cs +++ b/src/Umbraco.Core/Persistence/Mappers/PropertyTypeMapper.cs @@ -1,4 +1,5 @@ -using System.Collections.Concurrent; +using System; +using System.Collections.Concurrent; using Umbraco.Core.Models; using Umbraco.Core.Persistence.Dtos; @@ -11,25 +12,20 @@ namespace Umbraco.Core.Persistence.Mappers [MapperFor(typeof(PropertyType))] public sealed class PropertyTypeMapper : BaseMapper { - private static readonly ConcurrentDictionary PropertyInfoCacheInstance = new ConcurrentDictionary(); - - internal override ConcurrentDictionary PropertyInfoCache => PropertyInfoCacheInstance; - - protected override void BuildMap() + public PropertyTypeMapper(ISqlContext sqlContext, ConcurrentDictionary> maps) + : base(sqlContext, maps) { - if (PropertyInfoCache.IsEmpty == false) return; - - CacheMap(src => src.Key, dto => dto.UniqueId); - CacheMap(src => src.Id, dto => dto.Id); - CacheMap(src => src.Alias, dto => dto.Alias); - CacheMap(src => src.DataTypeId, dto => dto.DataTypeId); - CacheMap(src => src.Description, dto => dto.Description); - CacheMap(src => src.Mandatory, dto => dto.Mandatory); - CacheMap(src => src.Name, dto => dto.Name); - CacheMap(src => src.SortOrder, dto => dto.SortOrder); - CacheMap(src => src.ValidationRegExp, dto => dto.ValidationRegExp); - CacheMap(src => src.PropertyEditorAlias, dto => dto.EditorAlias); - CacheMap(src => src.ValueStorageType, dto => dto.DbType); + DefineMap(nameof(PropertyType.Key), nameof(PropertyTypeDto.UniqueId)); + DefineMap(nameof(PropertyType.Id), nameof(PropertyTypeDto.Id)); + DefineMap(nameof(PropertyType.Alias), nameof(PropertyTypeDto.Alias)); + DefineMap(nameof(PropertyType.DataTypeId), nameof(PropertyTypeDto.DataTypeId)); + DefineMap(nameof(PropertyType.Description), nameof(PropertyTypeDto.Description)); + DefineMap(nameof(PropertyType.Mandatory), nameof(PropertyTypeDto.Mandatory)); + DefineMap(nameof(PropertyType.Name), nameof(PropertyTypeDto.Name)); + DefineMap(nameof(PropertyType.SortOrder), nameof(PropertyTypeDto.SortOrder)); + DefineMap(nameof(PropertyType.ValidationRegExp), nameof(PropertyTypeDto.ValidationRegExp)); + DefineMap(nameof(PropertyType.PropertyEditorAlias), nameof(DataTypeDto.EditorAlias)); + DefineMap(nameof(PropertyType.ValueStorageType), nameof(DataTypeDto.DbType)); } } } diff --git a/src/Umbraco.Core/Persistence/Mappers/RelationMapper.cs b/src/Umbraco.Core/Persistence/Mappers/RelationMapper.cs index 83d9eb4220..ab9317d987 100644 --- a/src/Umbraco.Core/Persistence/Mappers/RelationMapper.cs +++ b/src/Umbraco.Core/Persistence/Mappers/RelationMapper.cs @@ -1,4 +1,5 @@ -using System.Collections.Concurrent; +using System; +using System.Collections.Concurrent; using Umbraco.Core.Models; using Umbraco.Core.Persistence.Dtos; @@ -12,18 +13,15 @@ namespace Umbraco.Core.Persistence.Mappers [MapperFor(typeof(Relation))] public sealed class RelationMapper : BaseMapper { - private static readonly ConcurrentDictionary PropertyInfoCacheInstance = new ConcurrentDictionary(); - - internal override ConcurrentDictionary PropertyInfoCache => PropertyInfoCacheInstance; - - protected override void BuildMap() + public RelationMapper(ISqlContext sqlContext, ConcurrentDictionary> maps) + : base(sqlContext, maps) { - CacheMap(src => src.Id, dto => dto.Id); - CacheMap(src => src.ChildId, dto => dto.ChildId); - CacheMap(src => src.Comment, dto => dto.Comment); - CacheMap(src => src.CreateDate, dto => dto.Datetime); - CacheMap(src => src.ParentId, dto => dto.ParentId); - CacheMap(src => src.RelationTypeId, dto => dto.RelationType); + DefineMap(nameof(Relation.Id), nameof(RelationDto.Id)); + DefineMap(nameof(Relation.ChildId), nameof(RelationDto.ChildId)); + DefineMap(nameof(Relation.Comment), nameof(RelationDto.Comment)); + DefineMap(nameof(Relation.CreateDate), nameof(RelationDto.Datetime)); + DefineMap(nameof(Relation.ParentId), nameof(RelationDto.ParentId)); + DefineMap(nameof(Relation.RelationTypeId), nameof(RelationDto.RelationType)); } } } diff --git a/src/Umbraco.Core/Persistence/Mappers/RelationTypeMapper.cs b/src/Umbraco.Core/Persistence/Mappers/RelationTypeMapper.cs index b9bd3d0e89..e3da443ddf 100644 --- a/src/Umbraco.Core/Persistence/Mappers/RelationTypeMapper.cs +++ b/src/Umbraco.Core/Persistence/Mappers/RelationTypeMapper.cs @@ -1,4 +1,5 @@ -using System.Collections.Concurrent; +using System; +using System.Collections.Concurrent; using Umbraco.Core.Models; using Umbraco.Core.Persistence.Dtos; @@ -12,18 +13,15 @@ namespace Umbraco.Core.Persistence.Mappers [MapperFor(typeof(IRelationType))] public sealed class RelationTypeMapper : BaseMapper { - private static readonly ConcurrentDictionary PropertyInfoCacheInstance = new ConcurrentDictionary(); - - internal override ConcurrentDictionary PropertyInfoCache => PropertyInfoCacheInstance; - - protected override void BuildMap() + public RelationTypeMapper(ISqlContext sqlContext, ConcurrentDictionary> maps) + : base(sqlContext, maps) { - CacheMap(src => src.Id, dto => dto.Id); - CacheMap(src => src.Alias, dto => dto.Alias); - CacheMap(src => src.ChildObjectType, dto => dto.ChildObjectType); - CacheMap(src => src.IsBidirectional, dto => dto.Dual); - CacheMap(src => src.Name, dto => dto.Name); - CacheMap(src => src.ParentObjectType, dto => dto.ParentObjectType); + DefineMap(nameof(RelationType.Id), nameof(RelationTypeDto.Id)); + DefineMap(nameof(RelationType.Alias), nameof(RelationTypeDto.Alias)); + DefineMap(nameof(RelationType.ChildObjectType), nameof(RelationTypeDto.ChildObjectType)); + DefineMap(nameof(RelationType.IsBidirectional), nameof(RelationTypeDto.Dual)); + DefineMap(nameof(RelationType.Name), nameof(RelationTypeDto.Name)); + DefineMap(nameof(RelationType.ParentObjectType), nameof(RelationTypeDto.ParentObjectType)); } } } diff --git a/src/Umbraco.Core/Persistence/Mappers/ServerRegistrationMapper.cs b/src/Umbraco.Core/Persistence/Mappers/ServerRegistrationMapper.cs index 0c723fced6..eb61499f95 100644 --- a/src/Umbraco.Core/Persistence/Mappers/ServerRegistrationMapper.cs +++ b/src/Umbraco.Core/Persistence/Mappers/ServerRegistrationMapper.cs @@ -1,4 +1,5 @@ -using System.Collections.Concurrent; +using System; +using System.Collections.Concurrent; using Umbraco.Core.Models; using Umbraco.Core.Persistence.Dtos; @@ -8,19 +9,16 @@ namespace Umbraco.Core.Persistence.Mappers [MapperFor(typeof(IServerRegistration))] internal sealed class ServerRegistrationMapper : BaseMapper { - private static readonly ConcurrentDictionary PropertyInfoCacheInstance = new ConcurrentDictionary(); - - internal override ConcurrentDictionary PropertyInfoCache => PropertyInfoCacheInstance; - - protected override void BuildMap() + public ServerRegistrationMapper(ISqlContext sqlContext, ConcurrentDictionary> maps) + : base(sqlContext, maps) { - CacheMap(src => src.Id, dto => dto.Id); - CacheMap(src => src.IsActive, dto => dto.IsActive); - CacheMap(src => src.IsMaster, dto => dto.IsMaster); - CacheMap(src => src.ServerAddress, dto => dto.ServerAddress); - CacheMap(src => src.CreateDate, dto => dto.DateRegistered); - CacheMap(src => src.UpdateDate, dto => dto.DateAccessed); - CacheMap(src => src.ServerIdentity, dto => dto.ServerIdentity); + DefineMap(nameof(ServerRegistration.Id), nameof(ServerRegistrationDto.Id)); + DefineMap(nameof(ServerRegistration.IsActive), nameof(ServerRegistrationDto.IsActive)); + DefineMap(nameof(ServerRegistration.IsMaster), nameof(ServerRegistrationDto.IsMaster)); + DefineMap(nameof(ServerRegistration.ServerAddress), nameof(ServerRegistrationDto.ServerAddress)); + DefineMap(nameof(ServerRegistration.CreateDate), nameof(ServerRegistrationDto.DateRegistered)); + DefineMap(nameof(ServerRegistration.UpdateDate), nameof(ServerRegistrationDto.DateAccessed)); + DefineMap(nameof(ServerRegistration.ServerIdentity), nameof(ServerRegistrationDto.ServerIdentity)); } } } diff --git a/src/Umbraco.Core/Persistence/Mappers/SimpleContentTypeMapper.cs b/src/Umbraco.Core/Persistence/Mappers/SimpleContentTypeMapper.cs index 3ad975defb..f4272dc25e 100644 --- a/src/Umbraco.Core/Persistence/Mappers/SimpleContentTypeMapper.cs +++ b/src/Umbraco.Core/Persistence/Mappers/SimpleContentTypeMapper.cs @@ -1,4 +1,5 @@ -using System.Collections.Concurrent; +using System; +using System.Collections.Concurrent; using Umbraco.Core.Models; using Umbraco.Core.Persistence.Dtos; @@ -8,31 +9,26 @@ namespace Umbraco.Core.Persistence.Mappers [MapperFor(typeof(SimpleContentType))] public sealed class SimpleContentTypeMapper : BaseMapper { - private static readonly ConcurrentDictionary PropertyInfoCacheInstance = new ConcurrentDictionary(); - - internal override ConcurrentDictionary PropertyInfoCache => PropertyInfoCacheInstance; - - protected override void BuildMap() + public SimpleContentTypeMapper(ISqlContext sqlContext, ConcurrentDictionary> maps) + : base(sqlContext, maps) { - if (PropertyInfoCache.IsEmpty == false) return; - - CacheMap(src => src.Id, dto => dto.NodeId); - CacheMap(src => src.CreateDate, dto => dto.CreateDate); - CacheMap(src => src.Level, dto => dto.Level); - CacheMap(src => src.ParentId, dto => dto.ParentId); - CacheMap(src => src.Path, dto => dto.Path); - CacheMap(src => src.SortOrder, dto => dto.SortOrder); - CacheMap(src => src.Name, dto => dto.Text); - CacheMap(src => src.Trashed, dto => dto.Trashed); - CacheMap(src => src.Key, dto => dto.UniqueId); - CacheMap(src => src.CreatorId, dto => dto.UserId); - CacheMap(src => src.Alias, dto => dto.Alias); - CacheMap(src => src.AllowedAsRoot, dto => dto.AllowAtRoot); - CacheMap(src => src.Description, dto => dto.Description); - CacheMap(src => src.Icon, dto => dto.Icon); - CacheMap(src => src.IsContainer, dto => dto.IsContainer); - CacheMap(src => src.IsElement, dto => dto.IsElement); - CacheMap(src => src.Thumbnail, dto => dto.Thumbnail); + DefineMap(nameof(ContentType.Id), nameof(NodeDto.NodeId)); + DefineMap(nameof(ContentType.CreateDate), nameof(NodeDto.CreateDate)); + DefineMap(nameof(ContentType.Level), nameof(NodeDto.Level)); + DefineMap(nameof(ContentType.ParentId), nameof(NodeDto.ParentId)); + DefineMap(nameof(ContentType.Path), nameof(NodeDto.Path)); + DefineMap(nameof(ContentType.SortOrder), nameof(NodeDto.SortOrder)); + DefineMap(nameof(ContentType.Name), nameof(NodeDto.Text)); + DefineMap(nameof(ContentType.Trashed), nameof(NodeDto.Trashed)); + DefineMap(nameof(ContentType.Key), nameof(NodeDto.UniqueId)); + DefineMap(nameof(ContentType.CreatorId), nameof(NodeDto.UserId)); + DefineMap(nameof(ContentType.Alias), nameof(ContentTypeDto.Alias)); + DefineMap(nameof(ContentType.AllowedAsRoot), nameof(ContentTypeDto.AllowAtRoot)); + DefineMap(nameof(ContentType.Description), nameof(ContentTypeDto.Description)); + DefineMap(nameof(ContentType.Icon), nameof(ContentTypeDto.Icon)); + DefineMap(nameof(ContentType.IsContainer), nameof(ContentTypeDto.IsContainer)); + DefineMap(nameof(ContentType.IsElement), nameof(ContentTypeDto.IsElement)); + DefineMap(nameof(ContentType.Thumbnail), nameof(ContentTypeDto.Thumbnail)); } } -} \ No newline at end of file +} diff --git a/src/Umbraco.Core/Persistence/Mappers/TagMapper.cs b/src/Umbraco.Core/Persistence/Mappers/TagMapper.cs index 63f73d060a..3074377b8f 100644 --- a/src/Umbraco.Core/Persistence/Mappers/TagMapper.cs +++ b/src/Umbraco.Core/Persistence/Mappers/TagMapper.cs @@ -1,4 +1,5 @@ -using System.Collections.Concurrent; +using System; +using System.Collections.Concurrent; using Umbraco.Core.Models; using Umbraco.Core.Persistence.Dtos; @@ -12,18 +13,13 @@ namespace Umbraco.Core.Persistence.Mappers [MapperFor(typeof(ITag))] public sealed class TagMapper : BaseMapper { - private static readonly ConcurrentDictionary PropertyInfoCacheInstance = new ConcurrentDictionary(); - - internal override ConcurrentDictionary PropertyInfoCache => PropertyInfoCacheInstance; - - protected override void BuildMap() + public TagMapper(ISqlContext sqlContext, ConcurrentDictionary> maps) + : base(sqlContext, maps) { - if (PropertyInfoCache.IsEmpty == false) return; - - CacheMap(src => src.Id, dto => dto.Id); - CacheMap(src => src.Text, dto => dto.Text); - CacheMap(src => src.Group, dto => dto.Group); - CacheMap(src => src.LanguageId, dto => dto.LanguageId); + DefineMap(nameof(Tag.Id), nameof(TagDto.Id)); + DefineMap(nameof(Tag.Text), nameof(TagDto.Text)); + DefineMap(nameof(Tag.Group), nameof(TagDto.Group)); + DefineMap(nameof(Tag.LanguageId), nameof(TagDto.LanguageId)); } } } diff --git a/src/Umbraco.Core/Persistence/Mappers/TemplateMapper.cs b/src/Umbraco.Core/Persistence/Mappers/TemplateMapper.cs index ca5faab134..46ced0bba0 100644 --- a/src/Umbraco.Core/Persistence/Mappers/TemplateMapper.cs +++ b/src/Umbraco.Core/Persistence/Mappers/TemplateMapper.cs @@ -1,4 +1,5 @@ -using System.Collections.Concurrent; +using System; +using System.Collections.Concurrent; using Umbraco.Core.Models; using Umbraco.Core.Persistence.Dtos; @@ -12,18 +13,13 @@ namespace Umbraco.Core.Persistence.Mappers [MapperFor(typeof(ITemplate))] public sealed class TemplateMapper : BaseMapper { - private static readonly ConcurrentDictionary PropertyInfoCacheInstance = new ConcurrentDictionary(); - - internal override ConcurrentDictionary PropertyInfoCache => PropertyInfoCacheInstance; - - protected override void BuildMap() + public TemplateMapper(ISqlContext sqlContext, ConcurrentDictionary> maps) + : base(sqlContext, maps) { - if (PropertyInfoCache.IsEmpty == false) return; - - CacheMap(src => src.Id, dto => dto.NodeId); - CacheMap(src => src.MasterTemplateId, dto => dto.ParentId); - CacheMap(src => src.Key, dto => dto.UniqueId); - CacheMap(src => src.Alias, dto => dto.Alias); + DefineMap(nameof(Template.Id), nameof(TemplateDto.NodeId)); + DefineMap(nameof(Template.MasterTemplateId), nameof(NodeDto.ParentId)); + DefineMap(nameof(Template.Key), nameof(NodeDto.UniqueId)); + DefineMap(nameof(Template.Alias), nameof(TemplateDto.Alias)); } } } diff --git a/src/Umbraco.Core/Persistence/Mappers/UmbracoEntityMapper.cs b/src/Umbraco.Core/Persistence/Mappers/UmbracoEntityMapper.cs index 556af9b88a..a442a52fb3 100644 --- a/src/Umbraco.Core/Persistence/Mappers/UmbracoEntityMapper.cs +++ b/src/Umbraco.Core/Persistence/Mappers/UmbracoEntityMapper.cs @@ -1,4 +1,5 @@ -using System.Collections.Concurrent; +using System; +using System.Collections.Concurrent; using Umbraco.Core.Models.Entities; using Umbraco.Core.Persistence.Dtos; @@ -7,22 +8,19 @@ namespace Umbraco.Core.Persistence.Mappers [MapperFor(typeof (IUmbracoEntity))] public sealed class UmbracoEntityMapper : BaseMapper { - private static readonly ConcurrentDictionary PropertyInfoCacheInstance = new ConcurrentDictionary(); - - internal override ConcurrentDictionary PropertyInfoCache => PropertyInfoCacheInstance; - - protected override void BuildMap() + public UmbracoEntityMapper(ISqlContext sqlContext, ConcurrentDictionary> maps) + : base(sqlContext, maps) { - CacheMap(src => src.Id, dto => dto.NodeId); - CacheMap(src => src.CreateDate, dto => dto.CreateDate); - CacheMap(src => src.Level, dto => dto.Level); - CacheMap(src => src.ParentId, dto => dto.ParentId); - CacheMap(src => src.Path, dto => dto.Path); - CacheMap(src => src.SortOrder, dto => dto.SortOrder); - CacheMap(src => src.Name, dto => dto.Text); - CacheMap(src => src.Trashed, dto => dto.Trashed); - CacheMap(src => src.Key, dto => dto.UniqueId); - CacheMap(src => src.CreatorId, dto => dto.UserId); + DefineMap(nameof(IUmbracoEntity.Id), nameof(NodeDto.NodeId)); + DefineMap(nameof(IUmbracoEntity.CreateDate), nameof(NodeDto.CreateDate)); + DefineMap(nameof(IUmbracoEntity.Level), nameof(NodeDto.Level)); + DefineMap(nameof(IUmbracoEntity.ParentId), nameof(NodeDto.ParentId)); + DefineMap(nameof(IUmbracoEntity.Path), nameof(NodeDto.Path)); + DefineMap(nameof(IUmbracoEntity.SortOrder), nameof(NodeDto.SortOrder)); + DefineMap(nameof(IUmbracoEntity.Name), nameof(NodeDto.Text)); + DefineMap(nameof(IUmbracoEntity.Trashed), nameof(NodeDto.Trashed)); + DefineMap(nameof(IUmbracoEntity.Key), nameof(NodeDto.UniqueId)); + DefineMap(nameof(IUmbracoEntity.CreatorId), nameof(NodeDto.UserId)); } } } diff --git a/src/Umbraco.Core/Persistence/Mappers/UserGroupMapper.cs b/src/Umbraco.Core/Persistence/Mappers/UserGroupMapper.cs index 92e2abd03e..ad0938b911 100644 --- a/src/Umbraco.Core/Persistence/Mappers/UserGroupMapper.cs +++ b/src/Umbraco.Core/Persistence/Mappers/UserGroupMapper.cs @@ -1,4 +1,5 @@ -using System.Collections.Concurrent; +using System; +using System.Collections.Concurrent; using Umbraco.Core.Models.Membership; using Umbraco.Core.Persistence.Dtos; @@ -12,29 +13,15 @@ namespace Umbraco.Core.Persistence.Mappers [MapperFor(typeof(UserGroup))] public sealed class UserGroupMapper : BaseMapper { - private static readonly ConcurrentDictionary PropertyInfoCacheInstance = new ConcurrentDictionary(); - - //NOTE: its an internal class but the ctor must be public since we're using Activator.CreateInstance to create it - // otherwise that would fail because there is no public constructor. - public UserGroupMapper() + public UserGroupMapper(ISqlContext sqlContext, ConcurrentDictionary> maps) + : base(sqlContext, maps) { - BuildMap(); + DefineMap(nameof(UserGroup.Id), nameof(UserGroupDto.Id)); + DefineMap(nameof(UserGroup.Alias), nameof(UserGroupDto.Alias)); + DefineMap(nameof(UserGroup.Name), nameof(UserGroupDto.Name)); + DefineMap(nameof(UserGroup.Icon), nameof(UserGroupDto.Icon)); + DefineMap(nameof(UserGroup.StartContentId), nameof(UserGroupDto.StartContentId)); + DefineMap(nameof(UserGroup.StartMediaId), nameof(UserGroupDto.StartMediaId)); } - - #region Overrides of BaseMapper - - internal override ConcurrentDictionary PropertyInfoCache => PropertyInfoCacheInstance; - - protected override void BuildMap() - { - CacheMap(src => src.Id, dto => dto.Id); - CacheMap(src => src.Alias, dto => dto.Alias); - CacheMap(src => src.Name, dto => dto.Name); - CacheMap(src => src.Icon, dto => dto.Icon); - CacheMap(src => src.StartContentId, dto => dto.StartContentId); - CacheMap(src => src.StartMediaId, dto => dto.StartMediaId); - } - - #endregion } } diff --git a/src/Umbraco.Core/Persistence/Mappers/UserMapper.cs b/src/Umbraco.Core/Persistence/Mappers/UserMapper.cs index d32f48910d..47b95eb17a 100644 --- a/src/Umbraco.Core/Persistence/Mappers/UserMapper.cs +++ b/src/Umbraco.Core/Persistence/Mappers/UserMapper.cs @@ -1,4 +1,5 @@ -using System.Collections.Concurrent; +using System; +using System.Collections.Concurrent; using Umbraco.Core.Models.Membership; using Umbraco.Core.Persistence.Dtos; @@ -8,28 +9,25 @@ namespace Umbraco.Core.Persistence.Mappers [MapperFor(typeof(User))] public sealed class UserMapper : BaseMapper { - private static readonly ConcurrentDictionary PropertyInfoCacheInstance = new ConcurrentDictionary(); - - internal override ConcurrentDictionary PropertyInfoCache => PropertyInfoCacheInstance; - - protected override void BuildMap() + public UserMapper(ISqlContext sqlContext, ConcurrentDictionary> maps) + : base(sqlContext, maps) { - CacheMap(src => src.Id, dto => dto.Id); - CacheMap(src => src.Email, dto => dto.Email); - CacheMap(src => src.Username, dto => dto.Login); - CacheMap(src => src.RawPasswordValue, dto => dto.Password); - CacheMap(src => src.Name, dto => dto.UserName); + DefineMap(nameof(User.Id), nameof(UserDto.Id)); + DefineMap(nameof(User.Email), nameof(UserDto.Email)); + DefineMap(nameof(User.Username), nameof(UserDto.Login)); + DefineMap(nameof(User.RawPasswordValue), nameof(UserDto.Password)); + DefineMap(nameof(User.Name), nameof(UserDto.UserName)); //NOTE: This column in the db is *not* used! - //CacheMap(src => src.DefaultPermissions, dto => dto.DefaultPermissions); - CacheMap(src => src.IsApproved, dto => dto.Disabled); - CacheMap(src => src.IsLockedOut, dto => dto.NoConsole); - CacheMap(src => src.Language, dto => dto.UserLanguage); - CacheMap(src => src.CreateDate, dto => dto.CreateDate); - CacheMap(src => src.UpdateDate, dto => dto.UpdateDate); - CacheMap(src => src.LastLockoutDate, dto => dto.LastLockoutDate); - CacheMap(src => src.LastLoginDate, dto => dto.LastLoginDate); - CacheMap(src => src.LastPasswordChangeDate, dto => dto.LastPasswordChangeDate); - CacheMap(src => src.SecurityStamp, dto => dto.SecurityStampToken); + //DefineMap(nameof(User.DefaultPermissions), nameof(UserDto.DefaultPermissions)); + DefineMap(nameof(User.IsApproved), nameof(UserDto.Disabled)); + DefineMap(nameof(User.IsLockedOut), nameof(UserDto.NoConsole)); + DefineMap(nameof(User.Language), nameof(UserDto.UserLanguage)); + DefineMap(nameof(User.CreateDate), nameof(UserDto.CreateDate)); + DefineMap(nameof(User.UpdateDate), nameof(UserDto.UpdateDate)); + DefineMap(nameof(User.LastLockoutDate), nameof(UserDto.LastLockoutDate)); + DefineMap(nameof(User.LastLoginDate), nameof(UserDto.LastLoginDate)); + DefineMap(nameof(User.LastPasswordChangeDate), nameof(UserDto.LastPasswordChangeDate)); + DefineMap(nameof(User.SecurityStamp), nameof(UserDto.SecurityStampToken)); } } } diff --git a/src/Umbraco.Core/Persistence/Querying/ModelToSqlExpressionVisitor.cs b/src/Umbraco.Core/Persistence/Querying/ModelToSqlExpressionVisitor.cs index bf26523d9e..0c835c9b63 100644 --- a/src/Umbraco.Core/Persistence/Querying/ModelToSqlExpressionVisitor.cs +++ b/src/Umbraco.Core/Persistence/Querying/ModelToSqlExpressionVisitor.cs @@ -33,7 +33,7 @@ namespace Umbraco.Core.Persistence.Querying //don't execute if compiled if (Visited == false) { - var field = _mapper.Map(SqlSyntax, m.Member.Name, true); + var field = _mapper.Map(m.Member.Name, true); if (field.IsNullOrWhiteSpace()) throw new InvalidOperationException($"The mapper returned an empty field for the member name: {m.Member.Name} for type: {m.Expression.Type}."); return field; @@ -48,7 +48,7 @@ namespace Umbraco.Core.Persistence.Querying //don't execute if compiled if (Visited == false) { - var field = _mapper.Map(SqlSyntax, m.Member.Name, true); + var field = _mapper.Map(m.Member.Name, true); if (field.IsNullOrWhiteSpace()) throw new InvalidOperationException($"The mapper returned an empty field for the member name: {m.Member.Name} for type: {m.Expression.Type}."); return field; @@ -70,7 +70,7 @@ namespace Umbraco.Core.Persistence.Querying if (Visited == false) { var subMapper = _mappers[m.Expression.Type]; // throws if not found - var field = subMapper.Map(SqlSyntax, m.Member.Name, true); + var field = subMapper.Map(m.Member.Name, true); if (field.IsNullOrWhiteSpace()) throw new InvalidOperationException($"The mapper returned an empty field for the member name: {m.Member.Name} for type: {m.Expression.Type}"); return field; diff --git a/src/Umbraco.Core/Persistence/Repositories/Implement/UserRepository.cs b/src/Umbraco.Core/Persistence/Repositories/Implement/UserRepository.cs index 9e0999e38f..9027e9269c 100644 --- a/src/Umbraco.Core/Persistence/Repositories/Implement/UserRepository.cs +++ b/src/Umbraco.Core/Persistence/Repositories/Implement/UserRepository.cs @@ -822,7 +822,7 @@ ORDER BY colName"; var expressionMember = ExpressionHelper.GetMemberInfo(orderBy); var mapper = _mapperCollection[typeof(IUser)]; - var mappedField = mapper.Map(SqlContext.SqlSyntax, expressionMember.Name); + var mappedField = mapper.Map(expressionMember.Name); if (mappedField.IsNullOrWhiteSpace()) throw new ArgumentException("Could not find a mapping for the column specified in the orderBy clause"); diff --git a/src/Umbraco.Core/TypeLoaderExtensions.cs b/src/Umbraco.Core/TypeLoaderExtensions.cs index 96028daca6..974bd3e805 100644 --- a/src/Umbraco.Core/TypeLoaderExtensions.cs +++ b/src/Umbraco.Core/TypeLoaderExtensions.cs @@ -33,13 +33,5 @@ namespace Umbraco.Core { return mgr.GetTypes(); } - - /// - /// Gets all classes inheriting from BaseMapper and marked with the MapperForAttribute. - /// - public static IEnumerable GetAssignedMapperTypes(this TypeLoader mgr) - { - return mgr.GetTypesWithAttribute(); - } } } diff --git a/src/Umbraco.Core/Umbraco.Core.csproj b/src/Umbraco.Core/Umbraco.Core.csproj index fa046acd63..c4f5df9d5a 100755 --- a/src/Umbraco.Core/Umbraco.Core.csproj +++ b/src/Umbraco.Core/Umbraco.Core.csproj @@ -161,6 +161,7 @@ + @@ -984,7 +985,6 @@ - diff --git a/src/Umbraco.Tests.Benchmarks/ModelToSqlExpressionHelperBenchmarks.cs b/src/Umbraco.Tests.Benchmarks/ModelToSqlExpressionHelperBenchmarks.cs index 3532eba6b2..4cd7c964b0 100644 --- a/src/Umbraco.Tests.Benchmarks/ModelToSqlExpressionHelperBenchmarks.cs +++ b/src/Umbraco.Tests.Benchmarks/ModelToSqlExpressionHelperBenchmarks.cs @@ -1,9 +1,11 @@ using System; +using System.Collections.Concurrent; using System.Linq.Expressions; using BenchmarkDotNet.Attributes; using BenchmarkDotNet.Diagnosers; using Moq; using Umbraco.Core.Models; +using Umbraco.Core.Persistence; using Umbraco.Core.Persistence.Mappers; using Umbraco.Core.Persistence.Querying; using Umbraco.Core.Persistence.SqlSyntax; @@ -13,9 +15,20 @@ namespace Umbraco.Tests.Benchmarks [MemoryDiagnoser] public class ModelToSqlExpressionHelperBenchmarks { + protected ISqlContext MockSqlContext() + { + var sqlContext = Mock.Of(); + var syntax = new SqlCeSyntaxProvider(); + Mock.Get(sqlContext).Setup(x => x.SqlSyntax).Returns(syntax); + return sqlContext; + } + + protected ConcurrentDictionary> CreateMaps() + => new ConcurrentDictionary>(); + public ModelToSqlExpressionHelperBenchmarks() { - var contentMapper = new ContentMapper(); + var contentMapper = new ContentMapper(MockSqlContext(), CreateMaps()); _cachedExpression = new CachedExpression(); var mapperCollection = new Mock(); mapperCollection.Setup(x => x[It.IsAny()]).Returns(contentMapper); diff --git a/src/Umbraco.Tests/Composing/TypeLoaderTests.cs b/src/Umbraco.Tests/Composing/TypeLoaderTests.cs index b3237dd4ba..7b7574ce47 100644 --- a/src/Umbraco.Tests/Composing/TypeLoaderTests.cs +++ b/src/Umbraco.Tests/Composing/TypeLoaderTests.cs @@ -260,13 +260,6 @@ AnotherContentFinder Assert.AreEqual(1, _typeLoader.TypeLists.Count(x => x.BaseType == typeof(IFindMe) && x.AttributeType == null)); } - [Test] - public void Resolves_Assigned_Mappers() - { - var foundTypes1 = _typeLoader.GetAssignedMapperTypes(); - Assert.AreEqual(30, foundTypes1.Count()); - } - [Test] public void Resolves_Types() { diff --git a/src/Umbraco.Tests/Persistence/Mappers/ContentMapperTest.cs b/src/Umbraco.Tests/Persistence/Mappers/ContentMapperTest.cs index a87aca1ad7..9ad77c0246 100644 --- a/src/Umbraco.Tests/Persistence/Mappers/ContentMapperTest.cs +++ b/src/Umbraco.Tests/Persistence/Mappers/ContentMapperTest.cs @@ -2,38 +2,37 @@ using Umbraco.Core; using Umbraco.Core.Models; using Umbraco.Core.Persistence.Mappers; -using Umbraco.Core.Persistence.SqlSyntax; namespace Umbraco.Tests.Persistence.Mappers { [TestFixture] - public class ContentMapperTest + public class ContentMapperTest : MapperTestBase { [Test] public void Can_Map_Id_Property() { - var column = new ContentMapper().Map(new SqlCeSyntaxProvider(), nameof(Content.Id)); + var column = new ContentMapper(MockSqlContext(), CreateMaps()).Map(nameof(Content.Id)); Assert.That(column, Is.EqualTo($"[{Constants.DatabaseSchema.Tables.Node}].[id]")); } [Test] public void Can_Map_Trashed_Property() { - var column = new ContentMapper().Map(new SqlCeSyntaxProvider(), nameof(Content.Trashed)); + var column = new ContentMapper(MockSqlContext(), CreateMaps()).Map(nameof(Content.Trashed)); Assert.That(column, Is.EqualTo($"[{Constants.DatabaseSchema.Tables.Node}].[trashed]")); } [Test] public void Can_Map_Published_Property() { - var column = new ContentMapper().Map(new SqlCeSyntaxProvider(), nameof(Content.Published)); + var column = new ContentMapper(MockSqlContext(), CreateMaps()).Map(nameof(Content.Published)); Assert.That(column, Is.EqualTo($"[{Constants.DatabaseSchema.Tables.Document}].[published]")); } [Test] public void Can_Map_Version_Property() { - var column = new ContentMapper().Map(new SqlCeSyntaxProvider(), nameof(Content.VersionId)); + var column = new ContentMapper(MockSqlContext(), CreateMaps()).Map(nameof(Content.VersionId)); Assert.That(column, Is.EqualTo($"[{Constants.DatabaseSchema.Tables.ContentVersion}].[id]")); } } diff --git a/src/Umbraco.Tests/Persistence/Mappers/ContentTypeMapperTest.cs b/src/Umbraco.Tests/Persistence/Mappers/ContentTypeMapperTest.cs index 35efce6dbe..dcd064e862 100644 --- a/src/Umbraco.Tests/Persistence/Mappers/ContentTypeMapperTest.cs +++ b/src/Umbraco.Tests/Persistence/Mappers/ContentTypeMapperTest.cs @@ -1,18 +1,17 @@ using NUnit.Framework; using Umbraco.Core.Persistence.Mappers; -using Umbraco.Core.Persistence.SqlSyntax; namespace Umbraco.Tests.Persistence.Mappers { [TestFixture] - public class ContentTypeMapperTest + public class ContentTypeMapperTest : MapperTestBase { [Test] public void Can_Map_Id_Property() { // Act - string column = new ContentTypeMapper().Map(new SqlCeSyntaxProvider(), "Id"); + string column = new ContentTypeMapper(MockSqlContext(), CreateMaps()).Map("Id"); // Assert Assert.That(column, Is.EqualTo("[umbracoNode].[id]")); @@ -23,7 +22,7 @@ namespace Umbraco.Tests.Persistence.Mappers { // Act - string column = new ContentTypeMapper().Map(new SqlCeSyntaxProvider(), "Name"); + string column = new ContentTypeMapper(MockSqlContext(), CreateMaps()).Map("Name"); // Assert Assert.That(column, Is.EqualTo("[umbracoNode].[text]")); @@ -34,7 +33,7 @@ namespace Umbraco.Tests.Persistence.Mappers { // Act - string column = new ContentTypeMapper().Map(new SqlCeSyntaxProvider(), "Thumbnail"); + string column = new ContentTypeMapper(MockSqlContext(), CreateMaps()).Map("Thumbnail"); // Assert Assert.That(column, Is.EqualTo("[cmsContentType].[thumbnail]")); @@ -45,7 +44,7 @@ namespace Umbraco.Tests.Persistence.Mappers { // Act - string column = new ContentTypeMapper().Map(new SqlCeSyntaxProvider(), "Description"); + string column = new ContentTypeMapper(MockSqlContext(), CreateMaps()).Map("Description"); // Assert Assert.That(column, Is.EqualTo("[cmsContentType].[description]")); diff --git a/src/Umbraco.Tests/Persistence/Mappers/DataTypeMapperTest.cs b/src/Umbraco.Tests/Persistence/Mappers/DataTypeMapperTest.cs index a65464a629..2ae8f755a2 100644 --- a/src/Umbraco.Tests/Persistence/Mappers/DataTypeMapperTest.cs +++ b/src/Umbraco.Tests/Persistence/Mappers/DataTypeMapperTest.cs @@ -6,14 +6,14 @@ using Umbraco.Core.Persistence.SqlSyntax; namespace Umbraco.Tests.Persistence.Mappers { [TestFixture] - public class DataTypeMapperTest + public class DataTypeMapperTest : MapperTestBase { [Test] public void Can_Map_Id_Property() { // Act - string column = new DataTypeMapper().Map(new SqlCeSyntaxProvider(), "Id"); + string column = new DataTypeMapper(MockSqlContext(), CreateMaps()).Map("Id"); // Assert Assert.That(column, Is.EqualTo("[umbracoNode].[id]")); @@ -24,7 +24,7 @@ namespace Umbraco.Tests.Persistence.Mappers { // Act - string column = new DataTypeMapper().Map(new SqlCeSyntaxProvider(), "Key"); + string column = new DataTypeMapper(MockSqlContext(), CreateMaps()).Map("Key"); // Assert Assert.That(column, Is.EqualTo("[umbracoNode].[uniqueId]")); @@ -35,7 +35,7 @@ namespace Umbraco.Tests.Persistence.Mappers { // Act - string column = new DataTypeMapper().Map(new SqlCeSyntaxProvider(), "DatabaseType"); + string column = new DataTypeMapper(MockSqlContext(), CreateMaps()).Map("DatabaseType"); // Assert Assert.That(column, Is.EqualTo($"[{Constants.DatabaseSchema.Tables.DataType}].[dbType]")); @@ -46,7 +46,7 @@ namespace Umbraco.Tests.Persistence.Mappers { // Act - string column = new DataTypeMapper().Map(new SqlCeSyntaxProvider(), "EditorAlias"); + string column = new DataTypeMapper(MockSqlContext(), CreateMaps()).Map("EditorAlias"); // Assert Assert.That(column, Is.EqualTo($"[{Constants.DatabaseSchema.Tables.DataType}].[propertyEditorAlias]")); diff --git a/src/Umbraco.Tests/Persistence/Mappers/DictionaryMapperTest.cs b/src/Umbraco.Tests/Persistence/Mappers/DictionaryMapperTest.cs index bd4a1ee969..cb4e8dc534 100644 --- a/src/Umbraco.Tests/Persistence/Mappers/DictionaryMapperTest.cs +++ b/src/Umbraco.Tests/Persistence/Mappers/DictionaryMapperTest.cs @@ -5,14 +5,14 @@ using Umbraco.Core.Persistence.SqlSyntax; namespace Umbraco.Tests.Persistence.Mappers { [TestFixture] - public class DictionaryMapperTest + public class DictionaryMapperTest : MapperTestBase { [Test] public void Can_Map_Id_Property() { // Act - string column = new DictionaryMapper().Map(new SqlCeSyntaxProvider(), "Id"); + string column = new DictionaryMapper(MockSqlContext(), CreateMaps()).Map("Id"); // Assert Assert.That(column, Is.EqualTo("[cmsDictionary].[pk]")); @@ -23,7 +23,7 @@ namespace Umbraco.Tests.Persistence.Mappers { // Act - string column = new DictionaryMapper().Map(new SqlCeSyntaxProvider(), "Key"); + string column = new DictionaryMapper(MockSqlContext(), CreateMaps()).Map("Key"); // Assert Assert.That(column, Is.EqualTo("[cmsDictionary].[id]")); @@ -34,7 +34,7 @@ namespace Umbraco.Tests.Persistence.Mappers { // Act - string column = new DictionaryMapper().Map(new SqlCeSyntaxProvider(), "ItemKey"); + string column = new DictionaryMapper(MockSqlContext(), CreateMaps()).Map("ItemKey"); // Assert Assert.That(column, Is.EqualTo("[cmsDictionary].[key]")); diff --git a/src/Umbraco.Tests/Persistence/Mappers/DictionaryTranslationMapperTest.cs b/src/Umbraco.Tests/Persistence/Mappers/DictionaryTranslationMapperTest.cs index c3e02105d6..c40ddb0cdf 100644 --- a/src/Umbraco.Tests/Persistence/Mappers/DictionaryTranslationMapperTest.cs +++ b/src/Umbraco.Tests/Persistence/Mappers/DictionaryTranslationMapperTest.cs @@ -1,18 +1,17 @@ using NUnit.Framework; using Umbraco.Core.Persistence.Mappers; -using Umbraco.Core.Persistence.SqlSyntax; namespace Umbraco.Tests.Persistence.Mappers { [TestFixture] - public class DictionaryTranslationMapperTest + public class DictionaryTranslationMapperTest : MapperTestBase { [Test] public void Can_Map_Key_Property() { // Act - string column = new DictionaryTranslationMapper().Map(new SqlCeSyntaxProvider(), "Key"); + string column = new DictionaryTranslationMapper(MockSqlContext(), CreateMaps()).Map("Key"); // Assert Assert.That(column, Is.EqualTo("[cmsLanguageText].[UniqueId]")); @@ -23,7 +22,7 @@ namespace Umbraco.Tests.Persistence.Mappers { // Act - string column = new DictionaryTranslationMapper().Map(new SqlCeSyntaxProvider(), "Language"); + string column = new DictionaryTranslationMapper(MockSqlContext(), CreateMaps()).Map("Language"); // Assert Assert.That(column, Is.EqualTo("[cmsLanguageText].[languageId]")); @@ -34,7 +33,7 @@ namespace Umbraco.Tests.Persistence.Mappers { // Act - string column = new DictionaryTranslationMapper().Map(new SqlCeSyntaxProvider(), "Value"); + string column = new DictionaryTranslationMapper(MockSqlContext(), CreateMaps()).Map("Value"); // Assert Assert.That(column, Is.EqualTo("[cmsLanguageText].[value]")); diff --git a/src/Umbraco.Tests/Persistence/Mappers/LanguageMapperTest.cs b/src/Umbraco.Tests/Persistence/Mappers/LanguageMapperTest.cs index 39d731c72d..5db8a991d6 100644 --- a/src/Umbraco.Tests/Persistence/Mappers/LanguageMapperTest.cs +++ b/src/Umbraco.Tests/Persistence/Mappers/LanguageMapperTest.cs @@ -5,14 +5,14 @@ using Umbraco.Core.Persistence.SqlSyntax; namespace Umbraco.Tests.Persistence.Mappers { [TestFixture] - public class LanguageMapperTest + public class LanguageMapperTest : MapperTestBase { [Test] public void Can_Map_Id_Property() { // Act - string column = new LanguageMapper().Map(new SqlCeSyntaxProvider(), "Id"); + string column = new LanguageMapper(MockSqlContext(), CreateMaps()).Map("Id"); // Assert Assert.That(column, Is.EqualTo("[umbracoLanguage].[id]")); @@ -23,7 +23,7 @@ namespace Umbraco.Tests.Persistence.Mappers { // Act - string column = new LanguageMapper().Map(new SqlCeSyntaxProvider(), "IsoCode"); + string column = new LanguageMapper(MockSqlContext(), CreateMaps()).Map("IsoCode"); // Assert Assert.That(column, Is.EqualTo("[umbracoLanguage].[languageISOCode]")); @@ -33,7 +33,7 @@ namespace Umbraco.Tests.Persistence.Mappers public void Can_Map_CultureName_Property() { // Act - string column = new LanguageMapper().Map(new SqlCeSyntaxProvider(), "CultureName"); + string column = new LanguageMapper(MockSqlContext(), CreateMaps()).Map("CultureName"); // Assert Assert.That(column, Is.EqualTo("[umbracoLanguage].[languageCultureName]")); diff --git a/src/Umbraco.Tests/Persistence/Mappers/MapperTestBase.cs b/src/Umbraco.Tests/Persistence/Mappers/MapperTestBase.cs new file mode 100644 index 0000000000..f4d3eb3cdc --- /dev/null +++ b/src/Umbraco.Tests/Persistence/Mappers/MapperTestBase.cs @@ -0,0 +1,22 @@ +using System; +using System.Collections.Concurrent; +using Moq; +using Umbraco.Core.Persistence; +using Umbraco.Core.Persistence.SqlSyntax; + +namespace Umbraco.Tests.Persistence.Mappers +{ + public class MapperTestBase + { + protected ISqlContext MockSqlContext() + { + var sqlContext = Mock.Of(); + var syntax = new SqlCeSyntaxProvider(); + Mock.Get(sqlContext).Setup(x => x.SqlSyntax).Returns(syntax); + return sqlContext; + } + + protected ConcurrentDictionary> CreateMaps() + => new ConcurrentDictionary>(); + } +} \ No newline at end of file diff --git a/src/Umbraco.Tests/Persistence/Mappers/MediaMapperTest.cs b/src/Umbraco.Tests/Persistence/Mappers/MediaMapperTest.cs index 0d6cc12d7c..9c7b0729b6 100644 --- a/src/Umbraco.Tests/Persistence/Mappers/MediaMapperTest.cs +++ b/src/Umbraco.Tests/Persistence/Mappers/MediaMapperTest.cs @@ -7,33 +7,33 @@ using Umbraco.Core.Persistence.SqlSyntax; namespace Umbraco.Tests.Persistence.Mappers { [TestFixture] - public class MediaMapperTest + public class MediaMapperTest : MapperTestBase { [Test] public void Can_Map_Id_Property() { - var column = new MediaMapper().Map(new SqlCeSyntaxProvider(), nameof(Media.Id)); + var column = new MediaMapper(MockSqlContext(), CreateMaps()).Map(nameof(Media.Id)); Assert.That(column, Is.EqualTo($"[{Constants.DatabaseSchema.Tables.Node}].[id]")); } [Test] public void Can_Map_Trashed_Property() { - var column = new MediaMapper().Map(new SqlCeSyntaxProvider(), nameof(Media.Trashed)); + var column = new MediaMapper(MockSqlContext(), CreateMaps()).Map(nameof(Media.Trashed)); Assert.That(column, Is.EqualTo($"[{Constants.DatabaseSchema.Tables.Node}].[trashed]")); } [Test] public void Can_Map_UpdateDate_Property() { - var column = new MediaMapper().Map(new SqlCeSyntaxProvider(), nameof(Media.UpdateDate)); + var column = new MediaMapper(MockSqlContext(), CreateMaps()).Map(nameof(Media.UpdateDate)); Assert.That(column, Is.EqualTo($"[{Constants.DatabaseSchema.Tables.ContentVersion}].[versionDate]")); } [Test] public void Can_Map_Version_Property() { - var column = new MediaMapper().Map(new SqlCeSyntaxProvider(), nameof(Media.VersionId)); + var column = new MediaMapper(MockSqlContext(), CreateMaps()).Map(nameof(Media.VersionId)); Assert.That(column, Is.EqualTo($"[{Constants.DatabaseSchema.Tables.ContentVersion}].[id]")); } } diff --git a/src/Umbraco.Tests/Persistence/Mappers/PropertyGroupMapperTest.cs b/src/Umbraco.Tests/Persistence/Mappers/PropertyGroupMapperTest.cs index 84ad2e85dc..780ae482cb 100644 --- a/src/Umbraco.Tests/Persistence/Mappers/PropertyGroupMapperTest.cs +++ b/src/Umbraco.Tests/Persistence/Mappers/PropertyGroupMapperTest.cs @@ -1,20 +1,16 @@ using NUnit.Framework; using Umbraco.Core.Persistence.Mappers; -using Umbraco.Core.Persistence.SqlSyntax; namespace Umbraco.Tests.Persistence.Mappers { [TestFixture] - public class PropertyGroupMapperTest + public class PropertyGroupMapperTest : MapperTestBase { [Test] public void Can_Map_Id_Property() { - // Arrange - var sqlSyntaxProvider = new SqlCeSyntaxProvider(); - // Act - string column = new PropertyGroupMapper().Map(sqlSyntaxProvider, "Id"); + string column = new PropertyGroupMapper(MockSqlContext(), CreateMaps()).Map("Id"); // Assert Assert.That(column, Is.EqualTo("[cmsPropertyTypeGroup].[id]")); @@ -23,11 +19,8 @@ namespace Umbraco.Tests.Persistence.Mappers [Test] public void Can_Map_SortOrder_Property() { - // Arrange - var sqlSyntaxProvider = new SqlCeSyntaxProvider(); - // Act - string column = new PropertyGroupMapper().Map(sqlSyntaxProvider, "SortOrder"); + string column = new PropertyGroupMapper(MockSqlContext(), CreateMaps()).Map("SortOrder"); // Assert Assert.That(column, Is.EqualTo("[cmsPropertyTypeGroup].[sortorder]")); @@ -36,11 +29,8 @@ namespace Umbraco.Tests.Persistence.Mappers [Test] public void Can_Map_Name_Property() { - // Arrange - var sqlSyntaxProvider = new SqlCeSyntaxProvider(); - // Act - string column = new PropertyGroupMapper().Map(sqlSyntaxProvider, "Name"); + string column = new PropertyGroupMapper(MockSqlContext(), CreateMaps()).Map("Name"); // Assert Assert.That(column, Is.EqualTo("[cmsPropertyTypeGroup].[text]")); diff --git a/src/Umbraco.Tests/Persistence/Mappers/PropertyTypeMapperTest.cs b/src/Umbraco.Tests/Persistence/Mappers/PropertyTypeMapperTest.cs index 3fa8af510e..ab76fa211b 100644 --- a/src/Umbraco.Tests/Persistence/Mappers/PropertyTypeMapperTest.cs +++ b/src/Umbraco.Tests/Persistence/Mappers/PropertyTypeMapperTest.cs @@ -6,13 +6,13 @@ using Umbraco.Core.Persistence.SqlSyntax; namespace Umbraco.Tests.Persistence.Mappers { [TestFixture] - public class PropertyTypeMapperTest + public class PropertyTypeMapperTest : MapperTestBase { [Test] public void Can_Map_Id_Property() { // Act - string column = new PropertyTypeMapper().Map(new SqlCeSyntaxProvider(), "Id"); + string column = new PropertyTypeMapper(MockSqlContext(), CreateMaps()).Map("Id"); // Assert Assert.That(column, Is.EqualTo("[cmsPropertyType].[id]")); @@ -22,7 +22,7 @@ namespace Umbraco.Tests.Persistence.Mappers public void Can_Map_Alias_Property() { // Act - string column = new PropertyTypeMapper().Map(new SqlCeSyntaxProvider(), "Alias"); + string column = new PropertyTypeMapper(MockSqlContext(), CreateMaps()).Map("Alias"); // Assert Assert.That(column, Is.EqualTo("[cmsPropertyType].[Alias]")); @@ -32,7 +32,7 @@ namespace Umbraco.Tests.Persistence.Mappers public void Can_Map_DataTypeDefinitionId_Property() { // Act - string column = new PropertyTypeMapper().Map(new SqlCeSyntaxProvider(), "DataTypeId"); + string column = new PropertyTypeMapper(MockSqlContext(), CreateMaps()).Map("DataTypeId"); // Assert Assert.That(column, Is.EqualTo("[cmsPropertyType].[dataTypeId]")); @@ -42,7 +42,7 @@ namespace Umbraco.Tests.Persistence.Mappers public void Can_Map_SortOrder_Property() { // Act - string column = new PropertyTypeMapper().Map(new SqlCeSyntaxProvider(), "SortOrder"); + string column = new PropertyTypeMapper(MockSqlContext(), CreateMaps()).Map("SortOrder"); // Assert Assert.That(column, Is.EqualTo("[cmsPropertyType].[sortOrder]")); @@ -52,7 +52,7 @@ namespace Umbraco.Tests.Persistence.Mappers public void Can_Map_PropertyEditorAlias_Property() { // Act - string column = new PropertyTypeMapper().Map(new SqlCeSyntaxProvider(), "PropertyEditorAlias"); + string column = new PropertyTypeMapper(MockSqlContext(), CreateMaps()).Map("PropertyEditorAlias"); // Assert Assert.That(column, Is.EqualTo($"[{Constants.DatabaseSchema.Tables.DataType}].[propertyEditorAlias]")); @@ -62,7 +62,7 @@ namespace Umbraco.Tests.Persistence.Mappers public void Can_Map_DataTypeDatabaseType_Property() { // Act - string column = new PropertyTypeMapper().Map(new SqlCeSyntaxProvider(), "ValueStorageType"); + string column = new PropertyTypeMapper(MockSqlContext(), CreateMaps()).Map("ValueStorageType"); // Assert Assert.That(column, Is.EqualTo($"[{Constants.DatabaseSchema.Tables.DataType}].[dbType]")); diff --git a/src/Umbraco.Tests/Persistence/Mappers/RelationMapperTest.cs b/src/Umbraco.Tests/Persistence/Mappers/RelationMapperTest.cs index 7a4a924a76..630c263924 100644 --- a/src/Umbraco.Tests/Persistence/Mappers/RelationMapperTest.cs +++ b/src/Umbraco.Tests/Persistence/Mappers/RelationMapperTest.cs @@ -5,13 +5,13 @@ using Umbraco.Core.Persistence.SqlSyntax; namespace Umbraco.Tests.Persistence.Mappers { [TestFixture] - public class RelationMapperTest + public class RelationMapperTest : MapperTestBase { [Test] public void Can_Map_Id_Property() { // Act - string column = new RelationMapper().Map(new SqlCeSyntaxProvider(), "Id"); + string column = new RelationMapper(MockSqlContext(), CreateMaps()).Map("Id"); // Assert Assert.That(column, Is.EqualTo("[umbracoRelation].[id]")); @@ -21,7 +21,7 @@ namespace Umbraco.Tests.Persistence.Mappers public void Can_Map_ChildId_Property() { // Act - string column = new RelationMapper().Map(new SqlCeSyntaxProvider(), "ChildId"); + string column = new RelationMapper(MockSqlContext(), CreateMaps()).Map("ChildId"); // Assert Assert.That(column, Is.EqualTo("[umbracoRelation].[childId]")); @@ -31,7 +31,7 @@ namespace Umbraco.Tests.Persistence.Mappers public void Can_Map_Datetime_Property() { // Act - string column = new RelationMapper().Map(new SqlCeSyntaxProvider(), "CreateDate"); + string column = new RelationMapper(MockSqlContext(), CreateMaps()).Map("CreateDate"); // Assert Assert.That(column, Is.EqualTo("[umbracoRelation].[datetime]")); @@ -41,7 +41,7 @@ namespace Umbraco.Tests.Persistence.Mappers public void Can_Map_Comment_Property() { // Act - string column = new RelationMapper().Map(new SqlCeSyntaxProvider(), "Comment"); + string column = new RelationMapper(MockSqlContext(), CreateMaps()).Map("Comment"); // Assert Assert.That(column, Is.EqualTo("[umbracoRelation].[comment]")); @@ -51,7 +51,7 @@ namespace Umbraco.Tests.Persistence.Mappers public void Can_Map_RelationType_Property() { // Act - string column = new RelationMapper().Map(new SqlCeSyntaxProvider(), "RelationTypeId"); + string column = new RelationMapper(MockSqlContext(), CreateMaps()).Map("RelationTypeId"); // Assert Assert.That(column, Is.EqualTo("[umbracoRelation].[relType]")); diff --git a/src/Umbraco.Tests/Persistence/Mappers/RelationTypeMapperTest.cs b/src/Umbraco.Tests/Persistence/Mappers/RelationTypeMapperTest.cs index 920cb06668..32e4f307c9 100644 --- a/src/Umbraco.Tests/Persistence/Mappers/RelationTypeMapperTest.cs +++ b/src/Umbraco.Tests/Persistence/Mappers/RelationTypeMapperTest.cs @@ -5,13 +5,13 @@ using Umbraco.Core.Persistence.SqlSyntax; namespace Umbraco.Tests.Persistence.Mappers { [TestFixture] - public class RelationTypeMapperTest + public class RelationTypeMapperTest : MapperTestBase { [Test] public void Can_Map_Id_Property() { // Act - string column = new RelationTypeMapper().Map(new SqlCeSyntaxProvider(), "Id"); + string column = new RelationTypeMapper(MockSqlContext(), CreateMaps()).Map("Id"); // Assert Assert.That(column, Is.EqualTo("[umbracoRelationType].[id]")); @@ -21,7 +21,7 @@ namespace Umbraco.Tests.Persistence.Mappers public void Can_Map_Alias_Property() { // Act - string column = new RelationTypeMapper().Map(new SqlCeSyntaxProvider(), "Alias"); + string column = new RelationTypeMapper(MockSqlContext(), CreateMaps()).Map("Alias"); // Assert Assert.That(column, Is.EqualTo("[umbracoRelationType].[alias]")); @@ -32,7 +32,7 @@ namespace Umbraco.Tests.Persistence.Mappers { // Act - string column = new RelationTypeMapper().Map(new SqlCeSyntaxProvider(), "ChildObjectType"); + string column = new RelationTypeMapper(MockSqlContext(), CreateMaps()).Map("ChildObjectType"); // Assert Assert.That(column, Is.EqualTo("[umbracoRelationType].[childObjectType]")); @@ -43,7 +43,7 @@ namespace Umbraco.Tests.Persistence.Mappers { // Act - string column = new RelationTypeMapper().Map(new SqlCeSyntaxProvider(), "IsBidirectional"); + string column = new RelationTypeMapper(MockSqlContext(), CreateMaps()).Map("IsBidirectional"); // Assert Assert.That(column, Is.EqualTo("[umbracoRelationType].[dual]")); diff --git a/src/Umbraco.Tests/TestHelpers/BaseUsingSqlCeSyntax.cs b/src/Umbraco.Tests/TestHelpers/BaseUsingSqlCeSyntax.cs index ca32e71e5b..f62effcb62 100644 --- a/src/Umbraco.Tests/TestHelpers/BaseUsingSqlCeSyntax.cs +++ b/src/Umbraco.Tests/TestHelpers/BaseUsingSqlCeSyntax.cs @@ -1,4 +1,5 @@ -using Moq; +using System; +using Moq; using NPoco; using NUnit.Framework; using Umbraco.Core; @@ -33,8 +34,6 @@ namespace Umbraco.Tests.TestHelpers { Current.Reset(); - var sqlSyntax = new SqlCeSyntaxProvider(); - var container = RegisterFactory.Create(); var logger = new ProfilingLogger(Mock.Of(), Mock.Of()); @@ -51,15 +50,17 @@ namespace Umbraco.Tests.TestHelpers composition.RegisterUnique(typeLoader); composition.WithCollectionBuilder() - .Add(() => composition.TypeLoader.GetAssignedMapperTypes()); + .AddCoreMappers(); + + composition.RegisterUnique(_ => SqlContext); var factory = Current.Factory = composition.CreateFactory(); - Mappers = factory.GetInstance(); - var pocoMappers = new NPoco.MapperCollection { new PocoMapper() }; var pocoDataFactory = new FluentPocoDataFactory((type, iPocoDataFactory) => new PocoDataBuilder(type, pocoMappers).Init()); - SqlContext = new SqlContext(sqlSyntax, DatabaseType.SQLCe, pocoDataFactory, Mappers); + var sqlSyntax = new SqlCeSyntaxProvider(); + SqlContext = new SqlContext(sqlSyntax, DatabaseType.SQLCe, pocoDataFactory, new Lazy(() => factory.GetInstance())); + Mappers = factory.GetInstance(); SetUp(); } diff --git a/src/Umbraco.Tests/TestHelpers/TestObjects-Mocks.cs b/src/Umbraco.Tests/TestHelpers/TestObjects-Mocks.cs index 29fdc27840..75e9cd60cb 100644 --- a/src/Umbraco.Tests/TestHelpers/TestObjects-Mocks.cs +++ b/src/Umbraco.Tests/TestHelpers/TestObjects-Mocks.cs @@ -14,6 +14,7 @@ using Umbraco.Core.IO; using Umbraco.Core.Logging; using Umbraco.Core.Models; using Umbraco.Core.Persistence; +using Umbraco.Core.Persistence.SqlSyntax; using Umbraco.Core.Services; using Umbraco.Tests.Testing.Objects.Accessors; using Umbraco.Web; @@ -37,10 +38,14 @@ namespace Umbraco.Tests.TestHelpers /// This is just a void factory that has no actual database. public IUmbracoDatabaseFactory GetDatabaseFactoryMock(bool configured = true, bool canConnect = true) { + var sqlSyntax = new SqlCeSyntaxProvider(); + var sqlContext = Mock.Of(); + Mock.Get(sqlContext).Setup(x => x.SqlSyntax).Returns(sqlSyntax); + var databaseFactoryMock = new Mock(); databaseFactoryMock.Setup(x => x.Configured).Returns(configured); databaseFactoryMock.Setup(x => x.CanConnect).Returns(canConnect); - databaseFactoryMock.Setup(x => x.SqlContext).Returns(Mock.Of()); + databaseFactoryMock.Setup(x => x.SqlContext).Returns(sqlContext); // can create a database - but don't try to use it! if (configured && canConnect) diff --git a/src/Umbraco.Tests/TestHelpers/TestWithDatabaseBase.cs b/src/Umbraco.Tests/TestHelpers/TestWithDatabaseBase.cs index 643deab304..7f3c855593 100644 --- a/src/Umbraco.Tests/TestHelpers/TestWithDatabaseBase.cs +++ b/src/Umbraco.Tests/TestHelpers/TestWithDatabaseBase.cs @@ -85,9 +85,8 @@ namespace Umbraco.Tests.TestHelpers if (Options.Database == UmbracoTestOptions.Database.None) return TestObjects.GetDatabaseFactoryMock(); - var logger = f.GetInstance(); - var mappers = f.GetInstance(); - var factory = new UmbracoDatabaseFactory(GetDbConnectionString(), GetDbProviderName(), logger, new Lazy(() => mappers)); + var lazyMappers = new Lazy(f.GetInstance); + var factory = new UmbracoDatabaseFactory(GetDbConnectionString(), GetDbProviderName(), f.GetInstance(), lazyMappers); factory.ResetForTests(); return factory; }); diff --git a/src/Umbraco.Tests/Testing/UmbracoTestBase.cs b/src/Umbraco.Tests/Testing/UmbracoTestBase.cs index fedc94d45b..589d4b3df5 100644 --- a/src/Umbraco.Tests/Testing/UmbracoTestBase.cs +++ b/src/Umbraco.Tests/Testing/UmbracoTestBase.cs @@ -342,7 +342,7 @@ namespace Umbraco.Tests.Testing Composition.RegisterUnique(f => new UmbracoDatabaseFactory( Constants.System.UmbracoConnectionName, Logger, - new Lazy(Mock.Of))); + new Lazy(f.GetInstance))); Composition.RegisterUnique(f => f.TryGetInstance().SqlContext); Composition.WithCollectionBuilder(); // empty diff --git a/src/Umbraco.Tests/Umbraco.Tests.csproj b/src/Umbraco.Tests/Umbraco.Tests.csproj index e0622f0c27..85f4b8d5e0 100644 --- a/src/Umbraco.Tests/Umbraco.Tests.csproj +++ b/src/Umbraco.Tests/Umbraco.Tests.csproj @@ -136,6 +136,7 @@ + diff --git a/src/Umbraco.Tests/Web/Controllers/UsersControllerTests.cs b/src/Umbraco.Tests/Web/Controllers/UsersControllerTests.cs index c48aa2717c..efb6c5ac7a 100644 --- a/src/Umbraco.Tests/Web/Controllers/UsersControllerTests.cs +++ b/src/Umbraco.Tests/Web/Controllers/UsersControllerTests.cs @@ -1,4 +1,6 @@ -using System.Collections.Generic; +using System; +using System.Collections.Concurrent; +using System.Collections.Generic; using System.Linq; using System.Net.Http; using System.Net.Http.Formatting; @@ -123,7 +125,7 @@ namespace Umbraco.Tests.Web.Controllers var mappers = new MapperCollection(new [] { - new UserMapper() + new UserMapper(Current.SqlContext, new ConcurrentDictionary>()) }); Mock.Get(Current.SqlContext)