mirror of
https://github.com/Readarr/Readarr.git
synced 2026-04-25 22:36:59 -04:00
Swap to dapper with lazyload
This commit is contained in:
ta264
@@ -1,18 +1,13 @@
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Linq;
|
||||
using Marr.Data;
|
||||
using Marr.Data.Mapping;
|
||||
using Marr.Data.QGen;
|
||||
using NzbDrone.Common.Disk;
|
||||
using Dapper;
|
||||
using NzbDrone.Common.Reflection;
|
||||
using NzbDrone.Core.ArtistStats;
|
||||
using NzbDrone.Core.Authentication;
|
||||
using NzbDrone.Core.Blacklisting;
|
||||
using NzbDrone.Core.Configuration;
|
||||
using NzbDrone.Core.CustomFilters;
|
||||
using NzbDrone.Core.Datastore.Converters;
|
||||
using NzbDrone.Core.Datastore.Extensions;
|
||||
using NzbDrone.Core.Download;
|
||||
using NzbDrone.Core.Download.Pending;
|
||||
using NzbDrone.Core.Extras.Lyrics;
|
||||
@@ -39,38 +34,47 @@ using NzbDrone.Core.RemotePathMappings;
|
||||
using NzbDrone.Core.RootFolders;
|
||||
using NzbDrone.Core.Tags;
|
||||
using NzbDrone.Core.ThingiProvider;
|
||||
using static Dapper.SqlMapper;
|
||||
|
||||
namespace NzbDrone.Core.Datastore
|
||||
{
|
||||
public static class TableMapping
|
||||
{
|
||||
private static readonly FluentMappings Mapper = new FluentMappings(true);
|
||||
static TableMapping()
|
||||
{
|
||||
Mapper = new TableMapper();
|
||||
}
|
||||
|
||||
public static TableMapper Mapper { get; private set; }
|
||||
|
||||
public static void Map()
|
||||
{
|
||||
RegisterMappers();
|
||||
|
||||
Mapper.Entity<Config>().RegisterModel("Config");
|
||||
Mapper.Entity<Config>("Config").RegisterModel();
|
||||
|
||||
Mapper.Entity<RootFolder>().RegisterModel("RootFolders")
|
||||
Mapper.Entity<RootFolder>("RootFolders").RegisterModel()
|
||||
.Ignore(r => r.Accessible)
|
||||
.Ignore(r => r.FreeSpace)
|
||||
.Ignore(r => r.TotalSpace);
|
||||
|
||||
Mapper.Entity<ScheduledTask>().RegisterModel("ScheduledTasks");
|
||||
Mapper.Entity<ScheduledTask>("ScheduledTasks").RegisterModel();
|
||||
|
||||
Mapper.Entity<IndexerDefinition>().RegisterDefinition("Indexers")
|
||||
Mapper.Entity<IndexerDefinition>("Indexers").RegisterModel()
|
||||
.Ignore(x => x.ImplementationName)
|
||||
.Ignore(i => i.Enable)
|
||||
.Ignore(i => i.Protocol)
|
||||
.Ignore(i => i.SupportsRss)
|
||||
.Ignore(i => i.SupportsSearch)
|
||||
.Ignore(d => d.Tags);
|
||||
|
||||
Mapper.Entity<ImportListDefinition>().RegisterDefinition("ImportLists")
|
||||
Mapper.Entity<ImportListDefinition>("ImportLists").RegisterModel()
|
||||
.Ignore(x => x.ImplementationName)
|
||||
.Ignore(i => i.Enable)
|
||||
.Ignore(i => i.ListType);
|
||||
|
||||
Mapper.Entity<NotificationDefinition>().RegisterDefinition("Notifications")
|
||||
Mapper.Entity<NotificationDefinition>("Notifications").RegisterModel()
|
||||
.Ignore(x => x.ImplementationName)
|
||||
.Ignore(i => i.SupportsOnGrab)
|
||||
.Ignore(i => i.SupportsOnReleaseImport)
|
||||
.Ignore(i => i.SupportsOnUpgrade)
|
||||
@@ -80,118 +84,110 @@ namespace NzbDrone.Core.Datastore
|
||||
.Ignore(i => i.SupportsOnImportFailure)
|
||||
.Ignore(i => i.SupportsOnTrackRetag);
|
||||
|
||||
Mapper.Entity<MetadataDefinition>().RegisterDefinition("Metadata")
|
||||
Mapper.Entity<MetadataDefinition>("Metadata").RegisterModel()
|
||||
.Ignore(x => x.ImplementationName)
|
||||
.Ignore(d => d.Tags);
|
||||
|
||||
Mapper.Entity<DownloadClientDefinition>().RegisterDefinition("DownloadClients")
|
||||
Mapper.Entity<DownloadClientDefinition>("DownloadClients").RegisterModel()
|
||||
.Ignore(x => x.ImplementationName)
|
||||
.Ignore(d => d.Protocol)
|
||||
.Ignore(d => d.Tags);
|
||||
|
||||
Mapper.Entity<History.History>().RegisterModel("History")
|
||||
.AutoMapChildModels();
|
||||
Mapper.Entity<History.History>("History").RegisterModel();
|
||||
|
||||
Mapper.Entity<Artist>().RegisterModel("Artists")
|
||||
Mapper.Entity<Artist>("Artists")
|
||||
.Ignore(s => s.RootFolderPath)
|
||||
.Ignore(s => s.Name)
|
||||
.Ignore(s => s.ForeignArtistId)
|
||||
.Relationship()
|
||||
.HasOne(a => a.Metadata, a => a.ArtistMetadataId)
|
||||
.HasOne(a => a.QualityProfile, a => a.QualityProfileId)
|
||||
.HasOne(s => s.MetadataProfile, s => s.MetadataProfileId)
|
||||
.For(a => a.Albums)
|
||||
.LazyLoad(condition: a => a.Id > 0, query: (db, a) => db.Query<Album>().Where(rg => rg.ArtistMetadataId == a.Id).ToList());
|
||||
.LazyLoad(a => a.Albums, (db, a) => db.Query<Album>(new SqlBuilder().Where<Album>(rg => rg.ArtistMetadataId == a.Id)).ToList(), a => a.Id > 0);
|
||||
|
||||
Mapper.Entity<ArtistMetadata>().RegisterModel("ArtistMetadata");
|
||||
Mapper.Entity<ArtistMetadata>("ArtistMetadata").RegisterModel();
|
||||
|
||||
Mapper.Entity<Album>().RegisterModel("Albums")
|
||||
.Ignore(r => r.ArtistId)
|
||||
.Relationship()
|
||||
Mapper.Entity<Album>("Albums").RegisterModel()
|
||||
.Ignore(x => x.ArtistId)
|
||||
.HasOne(r => r.ArtistMetadata, r => r.ArtistMetadataId)
|
||||
.For(rg => rg.AlbumReleases)
|
||||
.LazyLoad(condition: rg => rg.Id > 0, query: (db, rg) => db.Query<AlbumRelease>().Where(r => r.AlbumId == rg.Id).ToList())
|
||||
.For(rg => rg.Artist)
|
||||
.LazyLoad(condition: rg => rg.ArtistMetadataId > 0,
|
||||
query: (db, rg) => db.Query<Artist>()
|
||||
.Join<Artist, ArtistMetadata>(JoinType.Inner, a => a.Metadata, (a, m) => a.ArtistMetadataId == m.Id)
|
||||
.Where(a => a.ArtistMetadataId == rg.ArtistMetadataId).SingleOrDefault());
|
||||
.LazyLoad(a => a.AlbumReleases, (db, album) => db.Query<AlbumRelease>(new SqlBuilder().Where<AlbumRelease>(r => r.AlbumId == album.Id)).ToList(), a => a.Id > 0)
|
||||
.LazyLoad(a => a.Artist,
|
||||
(db, album) => ArtistRepository.Query(db,
|
||||
new SqlBuilder()
|
||||
.Join<Artist, ArtistMetadata>((a, m) => a.ArtistMetadataId == m.Id)
|
||||
.Where<Artist>(a => a.ArtistMetadataId == album.ArtistMetadataId)).SingleOrDefault(),
|
||||
a => a.ArtistMetadataId > 0);
|
||||
|
||||
Mapper.Entity<AlbumRelease>().RegisterModel("AlbumReleases")
|
||||
.Relationship()
|
||||
Mapper.Entity<AlbumRelease>("AlbumReleases").RegisterModel()
|
||||
.HasOne(r => r.Album, r => r.AlbumId)
|
||||
.For(r => r.Tracks)
|
||||
.LazyLoad(condition: r => r.Id > 0, query: (db, r) => db.Query<Track>().Where(t => t.AlbumReleaseId == r.Id).ToList());
|
||||
.LazyLoad(x => x.Tracks, (db, release) => db.Query<Track>(new SqlBuilder().Where<Track>(t => t.AlbumReleaseId == release.Id)).ToList(), r => r.Id > 0);
|
||||
|
||||
Mapper.Entity<Track>().RegisterModel("Tracks")
|
||||
Mapper.Entity<Track>("Tracks").RegisterModel()
|
||||
.Ignore(t => t.HasFile)
|
||||
.Ignore(t => t.AlbumId)
|
||||
.Ignore(t => t.Album)
|
||||
.Relationship()
|
||||
.HasOne(track => track.AlbumRelease, track => track.AlbumReleaseId)
|
||||
.HasOne(track => track.ArtistMetadata, track => track.ArtistMetadataId)
|
||||
.For(track => track.TrackFile)
|
||||
.LazyLoad(condition: track => track.TrackFileId > 0,
|
||||
query: (db, track) => db.Query<TrackFile>()
|
||||
.Join<TrackFile, Track>(JoinType.Inner, t => t.Tracks, (t, x) => t.Id == x.TrackFileId)
|
||||
.Join<TrackFile, Album>(JoinType.Inner, t => t.Album, (t, a) => t.AlbumId == a.Id)
|
||||
.Join<TrackFile, Artist>(JoinType.Inner, t => t.Artist, (t, a) => t.Album.Value.ArtistMetadataId == a.ArtistMetadataId)
|
||||
.Join<Artist, ArtistMetadata>(JoinType.Inner, a => a.Metadata, (a, m) => a.ArtistMetadataId == m.Id)
|
||||
.Where(t => t.Id == track.TrackFileId)
|
||||
.SingleOrDefault())
|
||||
.For(t => t.Artist)
|
||||
.LazyLoad(condition: t => t.AlbumReleaseId > 0, query: (db, t) => db.Query<Artist>()
|
||||
.Join<Artist, ArtistMetadata>(JoinType.Inner, a => a.Metadata, (a, m) => a.ArtistMetadataId == m.Id)
|
||||
.Join<Artist, Album>(JoinType.Inner, a => a.Albums, (l, r) => l.ArtistMetadataId == r.ArtistMetadataId)
|
||||
.Join<Album, AlbumRelease>(JoinType.Inner, a => a.AlbumReleases, (l, r) => l.Id == r.AlbumId)
|
||||
.Where<AlbumRelease>(r => r.Id == t.AlbumReleaseId)
|
||||
.SingleOrDefault());
|
||||
.LazyLoad(t => t.TrackFile,
|
||||
(db, track) => MediaFileRepository.Query(db,
|
||||
new SqlBuilder()
|
||||
.Join<TrackFile, Track>((l, r) => l.Id == r.TrackFileId)
|
||||
.Join<TrackFile, Album>((l, r) => l.AlbumId == r.Id)
|
||||
.Join<Album, Artist>((l, r) => l.ArtistMetadataId == r.ArtistMetadataId)
|
||||
.Join<Artist, ArtistMetadata>((l, r) => l.ArtistMetadataId == r.Id)
|
||||
.Where<TrackFile>(t => t.Id == track.TrackFileId)).SingleOrDefault(),
|
||||
t => t.TrackFileId > 0)
|
||||
.LazyLoad(x => x.Artist,
|
||||
(db, t) => ArtistRepository.Query(db,
|
||||
new SqlBuilder()
|
||||
.Join<Artist, ArtistMetadata>((a, m) => a.ArtistMetadataId == m.Id)
|
||||
.Join<Artist, Album>((l, r) => l.ArtistMetadataId == r.ArtistMetadataId)
|
||||
.Join<Album, AlbumRelease>((l, r) => l.Id == r.AlbumId)
|
||||
.Where<AlbumRelease>(r => r.Id == t.AlbumReleaseId)).SingleOrDefault(),
|
||||
t => t.Id > 0);
|
||||
|
||||
Mapper.Entity<TrackFile>().RegisterModel("TrackFiles")
|
||||
.Relationship()
|
||||
Mapper.Entity<TrackFile>("TrackFiles").RegisterModel()
|
||||
.HasOne(f => f.Album, f => f.AlbumId)
|
||||
.For(f => f.Tracks)
|
||||
.LazyLoad(condition: f => f.Id > 0, query: (db, f) => db.Query<Track>()
|
||||
.Where(x => x.TrackFileId == f.Id)
|
||||
.ToList())
|
||||
.For(t => t.Artist)
|
||||
.LazyLoad(condition: f => f.Id > 0, query: (db, f) => db.Query<Artist>()
|
||||
.Join<Artist, ArtistMetadata>(JoinType.Inner, a => a.Metadata, (a, m) => a.ArtistMetadataId == m.Id)
|
||||
.Join<Artist, Album>(JoinType.Inner, a => a.Albums, (l, r) => l.ArtistMetadataId == r.ArtistMetadataId)
|
||||
.Where<Album>(r => r.Id == f.AlbumId)
|
||||
.SingleOrDefault());
|
||||
.LazyLoad(x => x.Tracks, (db, file) => db.Query<Track>(new SqlBuilder().Where<Track>(t => t.TrackFileId == file.Id)).ToList(), x => x.Id > 0)
|
||||
.LazyLoad(x => x.Artist,
|
||||
(db, f) => ArtistRepository.Query(db,
|
||||
new SqlBuilder()
|
||||
.Join<Artist, ArtistMetadata>((a, m) => a.ArtistMetadataId == m.Id)
|
||||
.Join<Artist, Album>((l, r) => l.ArtistMetadataId == r.ArtistMetadataId)
|
||||
.Where<Album>(a => a.Id == f.AlbumId)).SingleOrDefault(),
|
||||
t => t.Id > 0);
|
||||
|
||||
Mapper.Entity<QualityDefinition>().RegisterModel("QualityDefinitions")
|
||||
Mapper.Entity<QualityDefinition>("QualityDefinitions").RegisterModel()
|
||||
.Ignore(d => d.GroupName)
|
||||
.Ignore(d => d.GroupWeight)
|
||||
.Ignore(d => d.Weight);
|
||||
|
||||
Mapper.Entity<QualityProfile>().RegisterModel("QualityProfiles");
|
||||
Mapper.Entity<MetadataProfile>().RegisterModel("MetadataProfiles");
|
||||
Mapper.Entity<Log>().RegisterModel("Logs");
|
||||
Mapper.Entity<NamingConfig>().RegisterModel("NamingConfig");
|
||||
Mapper.Entity<AlbumStatistics>().MapResultSet();
|
||||
Mapper.Entity<Blacklist>().RegisterModel("Blacklist");
|
||||
Mapper.Entity<MetadataFile>().RegisterModel("MetadataFiles");
|
||||
Mapper.Entity<LyricFile>().RegisterModel("LyricFiles");
|
||||
Mapper.Entity<OtherExtraFile>().RegisterModel("ExtraFiles");
|
||||
Mapper.Entity<QualityProfile>("QualityProfiles").RegisterModel();
|
||||
Mapper.Entity<MetadataProfile>("MetadataProfiles").RegisterModel();
|
||||
Mapper.Entity<Log>("Logs").RegisterModel();
|
||||
Mapper.Entity<NamingConfig>("NamingConfig").RegisterModel();
|
||||
|
||||
Mapper.Entity<PendingRelease>().RegisterModel("PendingReleases")
|
||||
Mapper.Entity<Blacklist>("Blacklist").RegisterModel();
|
||||
Mapper.Entity<MetadataFile>("MetadataFiles").RegisterModel();
|
||||
Mapper.Entity<LyricFile>("LyricFiles").RegisterModel();
|
||||
Mapper.Entity<OtherExtraFile>("ExtraFiles").RegisterModel();
|
||||
|
||||
Mapper.Entity<PendingRelease>("PendingReleases").RegisterModel()
|
||||
.Ignore(e => e.RemoteAlbum);
|
||||
|
||||
Mapper.Entity<RemotePathMapping>().RegisterModel("RemotePathMappings");
|
||||
Mapper.Entity<Tag>().RegisterModel("Tags");
|
||||
Mapper.Entity<ReleaseProfile>().RegisterModel("ReleaseProfiles");
|
||||
Mapper.Entity<RemotePathMapping>("RemotePathMappings").RegisterModel();
|
||||
Mapper.Entity<Tag>("Tags").RegisterModel();
|
||||
Mapper.Entity<ReleaseProfile>("ReleaseProfiles").RegisterModel();
|
||||
|
||||
Mapper.Entity<DelayProfile>().RegisterModel("DelayProfiles");
|
||||
Mapper.Entity<User>().RegisterModel("Users");
|
||||
Mapper.Entity<CommandModel>().RegisterModel("Commands")
|
||||
.Ignore(c => c.Message);
|
||||
Mapper.Entity<DelayProfile>("DelayProfiles").RegisterModel();
|
||||
Mapper.Entity<User>("Users").RegisterModel();
|
||||
Mapper.Entity<CommandModel>("Commands").RegisterModel()
|
||||
.Ignore(c => c.Message);
|
||||
|
||||
Mapper.Entity<IndexerStatus>().RegisterModel("IndexerStatus");
|
||||
Mapper.Entity<DownloadClientStatus>().RegisterModel("DownloadClientStatus");
|
||||
Mapper.Entity<ImportListStatus>().RegisterModel("ImportListStatus");
|
||||
Mapper.Entity<IndexerStatus>("IndexerStatus").RegisterModel();
|
||||
Mapper.Entity<DownloadClientStatus>("DownloadClientStatus").RegisterModel();
|
||||
Mapper.Entity<ImportListStatus>("ImportListStatus").RegisterModel();
|
||||
|
||||
Mapper.Entity<CustomFilter>().RegisterModel("CustomFilters");
|
||||
Mapper.Entity<ImportListExclusion>().RegisterModel("ImportListExclusions");
|
||||
Mapper.Entity<CustomFilter>("CustomFilters").RegisterModel();
|
||||
Mapper.Entity<ImportListExclusion>("ImportListExclusions").RegisterModel();
|
||||
}
|
||||
|
||||
private static void RegisterMappers()
|
||||
@@ -199,40 +195,40 @@ namespace NzbDrone.Core.Datastore
|
||||
RegisterEmbeddedConverter();
|
||||
RegisterProviderSettingConverter();
|
||||
|
||||
MapRepository.Instance.RegisterTypeConverter(typeof(int), new Int32Converter());
|
||||
MapRepository.Instance.RegisterTypeConverter(typeof(double), new DoubleConverter());
|
||||
MapRepository.Instance.RegisterTypeConverter(typeof(DateTime), new UtcConverter());
|
||||
MapRepository.Instance.RegisterTypeConverter(typeof(bool), new BooleanIntConverter());
|
||||
MapRepository.Instance.RegisterTypeConverter(typeof(Enum), new EnumIntConverter());
|
||||
MapRepository.Instance.RegisterTypeConverter(typeof(Quality), new QualityIntConverter());
|
||||
MapRepository.Instance.RegisterTypeConverter(typeof(List<QualityProfileQualityItem>), new EmbeddedDocumentConverter(new QualityIntConverter()));
|
||||
MapRepository.Instance.RegisterTypeConverter(typeof(QualityModel), new EmbeddedDocumentConverter(new QualityIntConverter()));
|
||||
MapRepository.Instance.RegisterTypeConverter(typeof(Dictionary<string, string>), new EmbeddedDocumentConverter());
|
||||
MapRepository.Instance.RegisterTypeConverter(typeof(List<int>), new EmbeddedDocumentConverter());
|
||||
MapRepository.Instance.RegisterTypeConverter(typeof(List<KeyValuePair<string, int>>), new EmbeddedDocumentConverter());
|
||||
MapRepository.Instance.RegisterTypeConverter(typeof(List<string>), new EmbeddedDocumentConverter());
|
||||
MapRepository.Instance.RegisterTypeConverter(typeof(List<ProfilePrimaryAlbumTypeItem>), new EmbeddedDocumentConverter(new PrimaryAlbumTypeIntConverter()));
|
||||
MapRepository.Instance.RegisterTypeConverter(typeof(List<ProfileSecondaryAlbumTypeItem>), new EmbeddedDocumentConverter(new SecondaryAlbumTypeIntConverter()));
|
||||
MapRepository.Instance.RegisterTypeConverter(typeof(List<ProfileReleaseStatusItem>), new EmbeddedDocumentConverter(new ReleaseStatusIntConverter()));
|
||||
MapRepository.Instance.RegisterTypeConverter(typeof(ParsedAlbumInfo), new EmbeddedDocumentConverter());
|
||||
MapRepository.Instance.RegisterTypeConverter(typeof(ParsedTrackInfo), new EmbeddedDocumentConverter());
|
||||
MapRepository.Instance.RegisterTypeConverter(typeof(ReleaseInfo), new EmbeddedDocumentConverter());
|
||||
MapRepository.Instance.RegisterTypeConverter(typeof(HashSet<int>), new EmbeddedDocumentConverter());
|
||||
MapRepository.Instance.RegisterTypeConverter(typeof(OsPath), new OsPathConverter());
|
||||
MapRepository.Instance.RegisterTypeConverter(typeof(Guid), new GuidConverter());
|
||||
MapRepository.Instance.RegisterTypeConverter(typeof(Command), new CommandConverter());
|
||||
MapRepository.Instance.RegisterTypeConverter(typeof(TimeSpan), new TimeSpanConverter());
|
||||
MapRepository.Instance.RegisterTypeConverter(typeof(TimeSpan?), new TimeSpanConverter());
|
||||
SqlMapper.RemoveTypeMap(typeof(DateTime));
|
||||
SqlMapper.AddTypeHandler(new DapperUtcConverter());
|
||||
SqlMapper.AddTypeHandler(new DapperQualityIntConverter());
|
||||
SqlMapper.AddTypeHandler(new EmbeddedDocumentConverter<List<QualityProfileQualityItem>>(new QualityIntConverter()));
|
||||
SqlMapper.AddTypeHandler(new EmbeddedDocumentConverter<QualityModel>(new QualityIntConverter()));
|
||||
SqlMapper.AddTypeHandler(new EmbeddedDocumentConverter<Dictionary<string, string>>());
|
||||
SqlMapper.AddTypeHandler(new EmbeddedDocumentConverter<IDictionary<string, string>>());
|
||||
SqlMapper.AddTypeHandler(new EmbeddedDocumentConverter<List<int>>());
|
||||
SqlMapper.AddTypeHandler(new EmbeddedDocumentConverter<List<KeyValuePair<string, int>>>());
|
||||
SqlMapper.AddTypeHandler(new EmbeddedDocumentConverter<KeyValuePair<string, int>>());
|
||||
SqlMapper.AddTypeHandler(new EmbeddedDocumentConverter<List<string>>());
|
||||
SqlMapper.AddTypeHandler(new EmbeddedDocumentConverter<List<ProfilePrimaryAlbumTypeItem>>(new PrimaryAlbumTypeIntConverter()));
|
||||
SqlMapper.AddTypeHandler(new EmbeddedDocumentConverter<List<ProfileSecondaryAlbumTypeItem>>(new SecondaryAlbumTypeIntConverter()));
|
||||
SqlMapper.AddTypeHandler(new EmbeddedDocumentConverter<List<ProfileReleaseStatusItem>>(new ReleaseStatusIntConverter()));
|
||||
SqlMapper.AddTypeHandler(new EmbeddedDocumentConverter<ParsedAlbumInfo>());
|
||||
SqlMapper.AddTypeHandler(new EmbeddedDocumentConverter<ParsedTrackInfo>());
|
||||
SqlMapper.AddTypeHandler(new EmbeddedDocumentConverter<ReleaseInfo>());
|
||||
SqlMapper.AddTypeHandler(new EmbeddedDocumentConverter<HashSet<int>>());
|
||||
SqlMapper.AddTypeHandler(new OsPathConverter());
|
||||
SqlMapper.RemoveTypeMap(typeof(Guid));
|
||||
SqlMapper.RemoveTypeMap(typeof(Guid?));
|
||||
SqlMapper.AddTypeHandler(new GuidConverter());
|
||||
SqlMapper.AddTypeHandler(new CommandConverter());
|
||||
}
|
||||
|
||||
private static void RegisterProviderSettingConverter()
|
||||
{
|
||||
var settingTypes = typeof(IProviderConfig).Assembly.ImplementationsOf<IProviderConfig>();
|
||||
var settingTypes = typeof(IProviderConfig).Assembly.ImplementationsOf<IProviderConfig>()
|
||||
.Where(x => !x.ContainsGenericParameters);
|
||||
|
||||
var providerSettingConverter = new ProviderSettingConverter();
|
||||
foreach (var embeddedType in settingTypes)
|
||||
{
|
||||
MapRepository.Instance.RegisterTypeConverter(embeddedType, providerSettingConverter);
|
||||
SqlMapper.AddTypeHandler(embeddedType, providerSettingConverter);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -240,16 +236,24 @@ namespace NzbDrone.Core.Datastore
|
||||
{
|
||||
var embeddedTypes = typeof(IEmbeddedDocument).Assembly.ImplementationsOf<IEmbeddedDocument>();
|
||||
|
||||
var embeddedConvertor = new EmbeddedDocumentConverter();
|
||||
var embeddedConverterDefinition = typeof(EmbeddedDocumentConverter<>).GetGenericTypeDefinition();
|
||||
var genericListDefinition = typeof(List<>).GetGenericTypeDefinition();
|
||||
|
||||
foreach (var embeddedType in embeddedTypes)
|
||||
{
|
||||
var embeddedListType = genericListDefinition.MakeGenericType(embeddedType);
|
||||
|
||||
MapRepository.Instance.RegisterTypeConverter(embeddedType, embeddedConvertor);
|
||||
MapRepository.Instance.RegisterTypeConverter(embeddedListType, embeddedConvertor);
|
||||
RegisterEmbeddedConverter(embeddedType, embeddedConverterDefinition);
|
||||
RegisterEmbeddedConverter(embeddedListType, embeddedConverterDefinition);
|
||||
}
|
||||
}
|
||||
|
||||
private static void RegisterEmbeddedConverter(Type embeddedType, Type embeddedConverterDefinition)
|
||||
{
|
||||
var embeddedConverterType = embeddedConverterDefinition.MakeGenericType(embeddedType);
|
||||
var converter = (ITypeHandler)Activator.CreateInstance(embeddedConverterType);
|
||||
|
||||
SqlMapper.AddTypeHandler(embeddedType, converter);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user