public void Init()
{
FluentMappings mappings = new FluentMappings();
mappings
.Entity <RootClass>()
.Columns.AutoMapSimpleTypeProperties()
.For(r => r.ID).SetPrimaryKey()
.Relationships.MapProperties()
.For(r => r.Dupe1)
.EagerLoad((db, r) => db.Query <DupedClass>().Where(d => d.ID == r.Dupe1ID).FirstOrDefault())
.For(r => r.Dupe2)
.EagerLoad((db, r) => db.Query <DupedClass>().Where(d => d.ID == r.Dupe2ID).FirstOrDefault())
.Entity <DupedClass>()
.Columns.AutoMapSimpleTypeProperties()
.For(d => d.ID).SetPrimaryKey()
.Relationships.MapProperties()
.For(d => d.Child)
.JoinOne(d => d.Child, (d, dcc) => d.ChildID == dcc.ID)
.Entity <DupedClassChild>()
.Columns.AutoMapSimpleTypeProperties()
.PrefixAltNames("dcc")
.For(d => d.ID).SetPrimaryKey();
}
public void Init()
{
FluentMappings mappings = new FluentMappings();
mappings
.Entity<RootClass>()
.Columns.AutoMapSimpleTypeProperties()
.For(r => r.ID).SetPrimaryKey()
.Relationships.MapProperties()
.For(r => r.Dupe1)
.EagerLoad((db, r) => db.Query<DupedClass>().Where(d => d.ID == r.Dupe1ID).FirstOrDefault())
.For(r => r.Dupe2)
.EagerLoad((db, r) => db.Query<DupedClass>().Where(d => d.ID == r.Dupe2ID).FirstOrDefault())
.Entity<DupedClass>()
.Columns.AutoMapSimpleTypeProperties()
.For(d => d.ID).SetPrimaryKey()
.Relationships.MapProperties()
.For(d => d.Child)
.JoinOne(d => d.Child, (d, dcc) => d.ChildID == dcc.ID)
.Entity<DupedClassChild>()
.Columns.AutoMapSimpleTypeProperties()
.PrefixAltNames("dcc")
.For(d => d.ID).SetPrimaryKey();
}
private void CreateMappings()
{
var mappings = new FluentMappings();
mappings
.Entity <FluentMappedOrder>()
.Table.MapTable("Order")
.Columns.AutoMapSimpleTypeProperties()
.PrefixAltNames("o")
.For(e => e.ID).SetPrimaryKey().SetAutoIncrement().SetReturnValue()
.Relationships.MapProperties()
.For(e => e.OrderItems).JoinMany <FluentMappedOrderItem>(o => o.OrderItems, (o, oi) => o.ID == oi.OrderID)
.Entity <FluentMappedOrderItem>()
.Table.MapTable("OrderItem")
.Columns.AutoMapSimpleTypeProperties()
.PrefixAltNames("oi")
.For(oi => oi.ID).SetPrimaryKey().SetAutoIncrement().SetReturnValue()
.Relationships.MapProperties()
.For(oi => oi.ItemReceipt).JoinOne <FluentMappedReceipt>(oi => oi.ItemReceipt, (oi, r) => oi.ID == r.OrderItemID)
.Entity <FluentMappedReceipt>()
.Table.MapTable("Receipt")
.Columns.AutoMapSimpleTypeProperties()
.PrefixAltNames("r");
}
private void CreateMappings()
{
var mappings = new FluentMappings();
mappings
.Entity<FluentMappedOrder>()
.Table.MapTable("Order")
.Columns.AutoMapSimpleTypeProperties()
.PrefixAltNames("o")
.For(e => e.ID).SetPrimaryKey().SetAutoIncrement().SetReturnValue()
.Relationships.MapProperties()
.For(e => e.OrderItems)
.EagerLoad((db, o) => db.Query<FluentMappedOrderItem>().Where(oi => oi.OrderID == o.ID).ToList())
//.JoinMany<FluentMappedOrderItem>(o => o.OrderItems, (o, oi) => o.ID == oi.OrderID)
.Entity<FluentMappedOrderItem>()
.Table.MapTable("OrderItem")
.Columns.AutoMapSimpleTypeProperties()
.PrefixAltNames("oi")
.For(oi => oi.ID).SetPrimaryKey().SetAutoIncrement().SetReturnValue()
.Relationships.MapProperties()
.For(oi => oi.ItemReceipt)
.JoinOne<FluentMappedReceipt>(oi => oi.ItemReceipt, (oi, r) => oi.ID == r.OrderItemID)
.Entity<FluentMappedReceipt>()
.Table.MapTable("Receipt")
.Columns.AutoMapSimpleTypeProperties()
.PrefixAltNames("r");
}
private void CreateMappings()
{
var mappings = new FluentMappings();
mappings
.Entity<Entities.FluentMappedOrder>()
.Table.MapTable("Order")
.Columns.AutoMapSimpleTypeProperties()
.For(e => e.ID)
.SetPrimaryKey().SetAutoIncrement().SetReturnValue()
.For(e => e.OrderName)
.ToDB(o => (o as string) + "[ToDB]")
.FromDB(o => (o as string) + "[FromDB]");
}
private void CreateMappings()
{
var mappings = new FluentMappings();
mappings
.Entity <Entities.FluentMappedOrder>()
.Table.MapTable("Order")
.Columns.AutoMapSimpleTypeProperties()
.For(e => e.ID)
.SetPrimaryKey().SetAutoIncrement().SetReturnValue()
.For(e => e.OrderName)
.ToDB(o => (o as string) + "[ToDB]")
.FromDB(o => (o as string) + "[FromDB]");
}
public void Setup()
{
FluentMappings mappings = new FluentMappings();
mappings
.Entity<Building>()
.Columns.AutoMapSimpleTypeProperties()
.Relationships.AutoMapICollectionOrComplexProperties()
.Ignore(b => b.Offices)
.Ignore(b => b.OfficesDynamic)
.For("_offices")
.LazyLoad((db, building) => db.Query<Office>().Where(o => o.BuildingName == building.Name).ToList())
.For("_officesDynamic")
.LazyLoad((db, building) => db.Query<Office>().Where(o => o.BuildingName == building.Name).ToList())
.Entity<Office>()
.Columns.AutoMapSimpleTypeProperties();
}
public void Setup()
{
FluentMappings mappings = new FluentMappings();
mappings
.Entity <Building>()
.Columns.AutoMapSimpleTypeProperties()
.For(b => b.Name).SetPrimaryKey()
.Relationships.AutoMapICollectionOrComplexProperties()
.Ignore(b => b.Offices)
.Ignore(b => b.OfficesDynamic)
.For <Office>("_offices")
.LazyLoad((db, building) => db.Query <Office>().Where(o => o.BuildingName == building.Name))
.For <Office>("_officesDynamic")
.LazyLoad((db, building) => db.Query <Office>().Where(o => o.BuildingName == building.Name))
.Entity <Office>()
.Columns.AutoMapSimpleTypeProperties()
.For(o => o.BuildingName).SetPrimaryKey()
.For(o => o.Number).SetPrimaryKey();
}
protected void InitMappings()
{
FluentMappings mappings = new FluentMappings();
mappings
.Entity<Person>()
.Table.MapTable("PersonTable")
.Columns.AutoMapSimpleTypeProperties()
.For(p => p.ID)
.SetPrimaryKey()
.SetReturnValue()
.SetAutoIncrement()
.Relationships.AutoMapICollectionOrComplexProperties()
.Entity<Pet>()
.Columns.AutoMapSimpleTypeProperties()
.For(p => p.ID)
.SetPrimaryKey()
.SetAltName("Pet_ID")
.For(p => p.Name)
.SetAltName("Pet_Name");
}
protected void InitMappings()
{
FluentMappings mappings = new FluentMappings();
mappings
.Entity <Person>()
.Table.MapTable("PersonTable")
.Columns.AutoMapSimpleTypeProperties()
.For(p => p.ID)
.SetPrimaryKey()
.SetReturnValue()
.SetAutoIncrement()
.Relationships.AutoMapICollectionOrComplexProperties()
.Entity <Pet>()
.Columns.AutoMapSimpleTypeProperties()
.For(p => p.ID)
.SetPrimaryKey()
.SetAltName("Pet_ID")
.For(p => p.Name)
.SetAltName("Pet_Name");
}
public void Setup()
{
MapRepository.Instance.EnableTraceLogging = true;
FluentMappings mappings = new FluentMappings();
mappings
.Entity<Series>()
.Columns.AutoMapSimpleTypeProperties()
.For(s => s.Id)
.SetPrimaryKey()
.Relationships.AutoMapICollectionOrComplexProperties()
.Entity<Episode>()
.Columns.AutoMapSimpleTypeProperties()
.For(e => e.Id)
.SetPrimaryKey()
.SetAltName("EpisodeId")
.For(e => e.Title)
.SetAltName("EpisodeTitle")
.Relationships.AutoMapICollectionOrComplexProperties();
}
public void Setup()
{
MapRepository.Instance.EnableTraceLogging = true;
FluentMappings mappings = new FluentMappings();
mappings
.Entity <Series>()
.Columns.AutoMapSimpleTypeProperties()
.For(s => s.Id)
.SetPrimaryKey()
.Relationships.AutoMapICollectionOrComplexProperties()
.Entity <Episode>()
.Columns.AutoMapSimpleTypeProperties()
.For(e => e.Id)
.SetPrimaryKey()
.SetAltName("EpisodeId")
.For(e => e.Title)
.SetAltName("EpisodeTitle")
.Relationships.AutoMapICollectionOrComplexProperties();
}
private void CreateMappings()
{
var mappings = new FluentMappings();
mappings
.Entity<Entities.FluentMappedOrder>()
.Table.MapTable("Order")
.Columns.AutoMapSimpleTypeProperties()
.For(e => e.ID).SetPrimaryKey().SetAutoIncrement().SetReturnValue()
.Relationships.MapProperties()
.For(e => e.OrderItems).EagerLoad((db, order) => db.Query<Entities.FluentMappedOrderItem>()
.Where(oi => oi.OrderID == order.ID))
.Entity<Entities.FluentMappedOrderItem>()
.Table.MapTable("OrderItem")
.Columns.AutoMapSimpleTypeProperties()
.For(oi => oi.ID).SetPrimaryKey().SetAutoIncrement().SetReturnValue()
.Relationships.MapProperties()
.For(oi => oi.ItemReceipt).EagerLoad((db, orderItem) => db.Query<Entities.FluentMappedReceipt>()
.Where(r => r.OrderItemID == orderItem.ID))
.Entity<Entities.FluentMappedReceipt>()
.Table.MapTable("Receipt")
.Columns.AutoMapSimpleTypeProperties()
.For(r => r.OrderItemID).SetPrimaryKey(); // Not really a PK, but works as a grouping key since this is a 1-1 relationship wtih order item
}
private void CreateMappings()
{
var mappings = new FluentMappings();
mappings
.Entity <Entities.FluentMappedOrder>()
.Table.MapTable("Order")
.Columns.AutoMapSimpleTypeProperties()
.For(e => e.ID).SetPrimaryKey().SetAutoIncrement().SetReturnValue()
.Relationships.MapProperties()
.For(e => e.OrderItems).EagerLoad((db, order) => db.Query <Entities.FluentMappedOrderItem>()
.Where(oi => oi.OrderID == order.ID))
.Entity <Entities.FluentMappedOrderItem>()
.Table.MapTable("OrderItem")
.Columns.AutoMapSimpleTypeProperties()
.For(oi => oi.ID).SetPrimaryKey().SetAutoIncrement().SetReturnValue()
.Relationships.MapProperties()
.For(oi => oi.ItemReceipt).EagerLoad((db, orderItem) => db.Query <Entities.FluentMappedReceipt>()
.Where(r => r.OrderItemID == orderItem.ID))
.Entity <Entities.FluentMappedReceipt>()
.Table.MapTable("Receipt")
.Columns.AutoMapSimpleTypeProperties()
.For(r => r.OrderItemID).SetPrimaryKey(); // Not really a PK, but works as a grouping key since this is a 1-1 relationship wtih order item
}
public static void Map()
{
RegisterMappers();
Mapper.Entity <Config>().RegisterModel("Config");
Mapper.Entity <RootFolder>().RegisterModel("RootFolders")
.Ignore(r => r.Accessible)
.Ignore(r => r.FreeSpace)
.Ignore(r => r.TotalSpace);
Mapper.Entity <ScheduledTask>().RegisterModel("ScheduledTasks");
Mapper.Entity <IndexerDefinition>().RegisterDefinition("Indexers")
.Ignore(i => i.Enable)
.Ignore(i => i.Protocol)
.Ignore(i => i.SupportsRss)
.Ignore(i => i.SupportsSearch)
.Ignore(d => d.Tags);
Mapper.Entity <NotificationDefinition>().RegisterDefinition("Notifications")
.Ignore(i => i.SupportsOnGrab)
.Ignore(i => i.SupportsOnDownload)
.Ignore(i => i.SupportsOnUpgrade)
.Ignore(i => i.SupportsOnRename)
.Ignore(i => i.SupportsOnHealthIssue);
Mapper.Entity <MetadataDefinition>().RegisterDefinition("Metadata")
.Ignore(d => d.Tags);
Mapper.Entity <DownloadClientDefinition>().RegisterDefinition("DownloadClients")
.Ignore(d => d.Protocol)
.Ignore(d => d.Tags);
Mapper.Entity <ImportListDefinition>().RegisterDefinition("ImportLists")
.Ignore(i => i.ListType)
.Ignore(i => i.Enable);
Mapper.Entity <SceneMapping>().RegisterModel("SceneMappings");
Mapper.Entity <EpisodeHistory>().RegisterModel("History")
.AutoMapChildModels();
Mapper.Entity <Series>().RegisterModel("Series")
.Ignore(s => s.RootFolderPath)
.Relationship()
.HasOne(s => s.QualityProfile, s => s.QualityProfileId)
.HasOne(s => s.LanguageProfile, s => s.LanguageProfileId);
Mapper.Entity <EpisodeFile>().RegisterModel("EpisodeFiles")
.Ignore(f => f.Path)
.Relationships.AutoMapICollectionOrComplexProperties()
.For("Episodes")
.LazyLoad(condition: parent => parent.Id > 0,
query: (db, parent) => db.Query <Episode>().Where(c => c.EpisodeFileId == parent.Id).ToList())
.HasOne(file => file.Series, file => file.SeriesId);
Mapper.Entity <Episode>().RegisterModel("Episodes")
.Ignore(e => e.SeriesTitle)
.Ignore(e => e.Series)
.Ignore(e => e.HasFile)
.Relationship()
.HasOne(episode => episode.EpisodeFile, episode => episode.EpisodeFileId);
Mapper.Entity <QualityDefinition>().RegisterModel("QualityDefinitions")
.Ignore(d => d.GroupName)
.Ignore(d => d.Weight);
Mapper.Entity <QualityProfile>().RegisterModel("QualityProfiles");
Mapper.Entity <LanguageProfile>().RegisterModel("LanguageProfiles");
Mapper.Entity <Log>().RegisterModel("Logs");
Mapper.Entity <NamingConfig>().RegisterModel("NamingConfig");
Mapper.Entity <SeasonStatistics>().MapResultSet();
Mapper.Entity <Blacklist>().RegisterModel("Blacklist");
Mapper.Entity <MetadataFile>().RegisterModel("MetadataFiles");
Mapper.Entity <SubtitleFile>().RegisterModel("SubtitleFiles");
Mapper.Entity <OtherExtraFile>().RegisterModel("ExtraFiles");
Mapper.Entity <PendingRelease>().RegisterModel("PendingReleases")
.Ignore(e => e.RemoteEpisode);
Mapper.Entity <RemotePathMapping>().RegisterModel("RemotePathMappings");
Mapper.Entity <Tag>().RegisterModel("Tags");
Mapper.Entity <ReleaseProfile>().RegisterModel("ReleaseProfiles");
Mapper.Entity <DelayProfile>().RegisterModel("DelayProfiles");
Mapper.Entity <User>().RegisterModel("Users");
Mapper.Entity <CommandModel>().RegisterModel("Commands")
.Ignore(c => c.Message);
Mapper.Entity <IndexerStatus>().RegisterModel("IndexerStatus");
Mapper.Entity <DownloadClientStatus>().RegisterModel("DownloadClientStatus");
Mapper.Entity <ImportListStatus>().RegisterModel("ImportListStatus");
Mapper.Entity <CustomFilter>().RegisterModel("CustomFilters");
Mapper.Entity <DownloadHistory>().RegisterModel("DownloadHistory")
.AutoMapChildModels();
Mapper.Entity <UpdateHistory>().RegisterModel("UpdateHistory");
Mapper.Entity <ImportListExclusion>().RegisterModel("ImportListExclusions");
}
public static void Map()
{
RegisterMappers();
Mapper.Entity<Config>().RegisterModel("Config");
Mapper.Entity<RootFolder>().RegisterModel("RootFolders")
.Ignore(r => r.FreeSpace)
.Ignore(r => r.TotalSpace);
Mapper.Entity<ScheduledTask>().RegisterModel("ScheduledTasks");
Mapper.Entity<IndexerDefinition>().RegisterDefinition("Indexers")
.Ignore(i => i.Enable)
.Ignore(i => i.Protocol)
.Ignore(i => i.SupportsRss)
.Ignore(i => i.SupportsSearch);
Mapper.Entity<NetImportDefinition>().RegisterDefinition("NetImport")
.Ignore(i => i.Enable)
.Relationship()
.HasOne(n => n.Profile, n => n.ProfileId);
Mapper.Entity<NotificationDefinition>().RegisterDefinition("Notifications")
.Ignore(i => i.SupportsOnGrab)
.Ignore(i => i.SupportsOnDownload)
.Ignore(i => i.SupportsOnUpgrade)
.Ignore(i => i.SupportsOnRename);
Mapper.Entity<MetadataDefinition>().RegisterDefinition("Metadata");
Mapper.Entity<DownloadClientDefinition>().RegisterDefinition("DownloadClients")
.Ignore(d => d.Protocol);
Mapper.Entity<History.History>().RegisterModel("History")
.AutoMapChildModels();
Mapper.Entity<MovieFile>().RegisterModel("MovieFiles")
.Ignore(f => f.Path)
.Relationships.AutoMapICollectionOrComplexProperties()
.For("Movie")
.LazyLoad(condition: parent => parent.Id > 0,
query: (db, parent) => db.Query<Movie>().Where(c => c.MovieFileId == parent.Id).ToList())
.HasOne(file => file.Movie, file => file.MovieId);
Mapper.Entity<Movie>().RegisterModel("Movies")
.Ignore(s => s.RootFolderPath)
.Ignore(m => m.Actors)
.Ignore(m => m.Genres)
// .Ignore(m => m.Tags)
.Relationship()
.HasOne(s => s.Profile, s => s.ProfileId);
//.HasOne(m => m.MovieFile, m => m.MovieFileId);
Mapper.Entity<AlternativeTitle>().RegisterModel("AlternativeTitles")
.For(t => t.Id)
.SetAltName("AltTitle_Id")
.Relationship()
.HasOne(t => t.Movie, t => t.MovieId);
Mapper.Entity<ImportExclusion>().RegisterModel("ImportExclusions");
Mapper.Entity<QualityDefinition>().RegisterModel("QualityDefinitions")
.Ignore(d => d.Weight)
.Relationship();
Mapper.Entity<CustomFormat>().RegisterModel("CustomFormats")
.Relationship();
Mapper.Entity<Profile>().RegisterModel("Profiles");
Mapper.Entity<Log>().RegisterModel("Logs");
Mapper.Entity<NamingConfig>().RegisterModel("NamingConfig");
Mapper.Entity<Blacklist>().RegisterModel("Blacklist");
Mapper.Entity<MetadataFile>().RegisterModel("MetadataFiles");
Mapper.Entity<SubtitleFile>().RegisterModel("SubtitleFiles");
Mapper.Entity<OtherExtraFile>().RegisterModel("ExtraFiles");
Mapper.Entity<PendingRelease>().RegisterModel("PendingReleases")
.Ignore(e => e.RemoteMovie);
Mapper.Entity<RemotePathMapping>().RegisterModel("RemotePathMappings");
Mapper.Entity<Tag>().RegisterModel("Tags");
Mapper.Entity<Restriction>().RegisterModel("Restrictions");
Mapper.Entity<DelayProfile>().RegisterModel("DelayProfiles");
Mapper.Entity<User>().RegisterModel("Users");
Mapper.Entity<CommandModel>().RegisterModel("Commands")
.Ignore(c => c.Message);
Mapper.Entity<IndexerStatus>().RegisterModel("IndexerStatus");
}
public static void Map()
{
RegisterMappers();
Mapper.Entity <Config>().RegisterModel("Config");
Mapper.Entity <RootFolder>().RegisterModel("RootFolders")
.Ignore(r => r.FreeSpace)
.Ignore(r => r.TotalSpace);
Mapper.Entity <ScheduledTask>().RegisterModel("ScheduledTasks");
Mapper.Entity <IndexerDefinition>().RegisterDefinition("Indexers")
.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")
.Ignore(i => i.Enable)
.Ignore(i => i.ListType);
Mapper.Entity <NotificationDefinition>().RegisterDefinition("Notifications")
.Ignore(i => i.SupportsOnGrab)
.Ignore(i => i.SupportsOnReleaseImport)
.Ignore(i => i.SupportsOnUpgrade)
.Ignore(i => i.SupportsOnRename)
.Ignore(i => i.SupportsOnHealthIssue)
.Ignore(i => i.SupportsOnDownloadFailure)
.Ignore(i => i.SupportsOnImportFailure)
.Ignore(i => i.SupportsOnTrackRetag);
Mapper.Entity <MetadataDefinition>().RegisterDefinition("Metadata")
.Ignore(d => d.Tags);
Mapper.Entity <DownloadClientDefinition>().RegisterDefinition("DownloadClients")
.Ignore(d => d.Protocol)
.Ignore(d => d.Tags);
Mapper.Entity <History.History>().RegisterModel("History")
.AutoMapChildModels();
Mapper.Entity <Artist>().RegisterModel("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());
Mapper.Entity <ArtistMetadata>().RegisterModel("ArtistMetadata");
Mapper.Entity <Album>().RegisterModel("Albums")
.Ignore(r => r.ArtistId)
.Relationship()
.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());
Mapper.Entity <AlbumRelease>().RegisterModel("AlbumReleases")
.Relationship()
.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());
Mapper.Entity <Track>().RegisterModel("Tracks")
.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());
Mapper.Entity <TrackFile>().RegisterModel("TrackFiles")
.Relationship()
.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());
Mapper.Entity <QualityDefinition>().RegisterModel("QualityDefinitions")
.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 <PendingRelease>().RegisterModel("PendingReleases")
.Ignore(e => e.RemoteAlbum);
Mapper.Entity <RemotePathMapping>().RegisterModel("RemotePathMappings");
Mapper.Entity <Tag>().RegisterModel("Tags");
Mapper.Entity <ReleaseProfile>().RegisterModel("ReleaseProfiles");
Mapper.Entity <DelayProfile>().RegisterModel("DelayProfiles");
Mapper.Entity <User>().RegisterModel("Users");
Mapper.Entity <CommandModel>().RegisterModel("Commands")
.Ignore(c => c.Message);
Mapper.Entity <IndexerStatus>().RegisterModel("IndexerStatus");
Mapper.Entity <DownloadClientStatus>().RegisterModel("DownloadClientStatus");
Mapper.Entity <ImportListStatus>().RegisterModel("ImportListStatus");
Mapper.Entity <CustomFilter>().RegisterModel("CustomFilters");
Mapper.Entity <ImportListExclusion>().RegisterModel("ImportListExclusions");
}
public static void Map()
{
RegisterMappers();
Mapper.Entity <Config>().RegisterModel("Config");
Mapper.Entity <RootFolder>().RegisterModel("RootFolders").Ignore(r => r.FreeSpace);
Mapper.Entity <IndexerDefinition>().RegisterModel("Indexers");
Mapper.Entity <ScheduledTask>().RegisterModel("ScheduledTasks");
Mapper.Entity <NotificationDefinition>().RegisterModel("Notifications");
Mapper.Entity <MetadataDefinition>().RegisterModel("Metadata");
Mapper.Entity <DownloadClientDefinition>().RegisterModel("DownloadClients");
Mapper.Entity <SceneMapping>().RegisterModel("SceneMappings");
Mapper.Entity <History.History>().RegisterModel("History")
.AutoMapChildModels();
Mapper.Entity <Series>().RegisterModel("Series")
.Ignore(s => s.RootFolderPath)
.Relationship()
.HasOne(s => s.QualityProfile, s => s.QualityProfileId);
Mapper.Entity <Episode>().RegisterModel("Episodes")
.Ignore(e => e.SeriesTitle)
.Ignore(e => e.Series)
.Ignore(e => e.HasFile)
.Relationship()
.HasOne(episode => episode.EpisodeFile, episode => episode.EpisodeFileId);
Mapper.Entity <EpisodeFile>().RegisterModel("EpisodeFiles")
.Relationships.AutoMapICollectionOrComplexProperties();
Mapper.Entity <QualityProfile>().RegisterModel("QualityProfiles");
Mapper.Entity <QualityDefinition>().RegisterModel("QualityDefinitions");
Mapper.Entity <Log>().RegisterModel("Logs");
Mapper.Entity <NamingConfig>().RegisterModel("NamingConfig");
Mapper.Entity <SeriesStatistics>().MapResultSet();
Mapper.Entity <Blacklist>().RegisterModel("Blacklist");
Mapper.Entity <MetadataFile>().RegisterModel("MetadataFiles");
}
public static void Map()
{
RegisterMappers();
Mapper.Entity <Config>().RegisterModel("Config");
Mapper.Entity <RootFolder>().RegisterModel("RootFolders").Ignore(r => r.FreeSpace);
Mapper.Entity <IndexerDefinition>().RegisterModel("Indexers")
.Ignore(i => i.Enable)
.Ignore(i => i.Protocol)
.Ignore(i => i.SupportsRss)
.Ignore(i => i.SupportsSearch);
Mapper.Entity <ScheduledTask>().RegisterModel("ScheduledTasks");
Mapper.Entity <NotificationDefinition>().RegisterModel("Notifications");
Mapper.Entity <MetadataDefinition>().RegisterModel("Metadata");
Mapper.Entity <DownloadClientDefinition>().RegisterModel("DownloadClients")
.Ignore(d => d.Protocol);
Mapper.Entity <SceneMapping>().RegisterModel("SceneMappings");
Mapper.Entity <History.History>().RegisterModel("History")
.AutoMapChildModels();
Mapper.Entity <Series>().RegisterModel("Series")
.Ignore(s => s.RootFolderPath)
.Relationship()
.HasOne(s => s.Profile, s => s.ProfileId);
Mapper.Entity <EpisodeFile>().RegisterModel("EpisodeFiles")
.Ignore(f => f.Path)
.Relationships.AutoMapICollectionOrComplexProperties()
.For("Episodes")
.LazyLoad(condition: parent => parent.Id > 0,
query: (db, parent) => db.Query <Episode>().Where(c => c.EpisodeFileId == parent.Id).ToList())
.HasOne(file => file.Series, file => file.SeriesId);
Mapper.Entity <Episode>().RegisterModel("Episodes")
.Ignore(e => e.SeriesTitle)
.Ignore(e => e.Series)
.Ignore(e => e.HasFile)
.Relationship()
.HasOne(episode => episode.EpisodeFile, episode => episode.EpisodeFileId);
Mapper.Entity <Profile>().RegisterModel("Profiles");
Mapper.Entity <QualityDefinition>().RegisterModel("QualityDefinitions");
Mapper.Entity <Log>().RegisterModel("Logs");
Mapper.Entity <NamingConfig>().RegisterModel("NamingConfig");
Mapper.Entity <SeriesStatistics>().MapResultSet();
Mapper.Entity <Blacklist>().RegisterModel("Blacklist");
Mapper.Entity <MetadataFile>().RegisterModel("MetadataFiles");
Mapper.Entity <PendingRelease>().RegisterModel("PendingReleases")
.Ignore(e => e.RemoteEpisode);
Mapper.Entity <RemotePathMapping>().RegisterModel("RemotePathMappings");
Mapper.Entity <Tag>().RegisterModel("Tags");
}
