private void UpdateAttachments(string directoryName, DbAlbum album)
{
_logger.Debug("Updating attachments");
string imagePath = _fileSystem.Path.Combine(directoryName, "folder.jpg");
if (_fileSystem.File.Exists(imagePath))
{
album.AlbumArtPath = imagePath;
}
string markdownPath = _fileSystem.Directory.EnumerateFiles(directoryName, "*.md").FirstOrDefault();
if (markdownPath != null)
{
string markdownText = _fileSystem.File.ReadAllText(markdownPath);
album.Description = new Markdown().Transform(markdownText);
}
album.AttachmentPaths = _fileSystem.Directory.GetFiles(directoryName).Where(f =>
!f.EndsWith(".mp3", StringComparison.OrdinalIgnoreCase) &&
!f.EndsWith(".flac", StringComparison.OrdinalIgnoreCase) &&
!f.EndsWith("folder.jpg", StringComparison.OrdinalIgnoreCase) &&
!f.EndsWith(".md", StringComparison.OrdinalIgnoreCase))
.ToList();
}
/// <summary>
/// Share an album.
/// </summary>
/// <param name="album">The album to be shared.</param>
public static async Task ShareAsync(this DbAlbum album)
{
if (album != null)
{
var files = new List <StorageFile>();
// Prep files.
foreach (var et in album.MediaFiles)
{
try
{
files.Add(await StorageFile.GetFileFromPathAsync(et.Path));
}
catch (COMException)
{
// WinRT error: ignore
}
catch (UnauthorizedAccessException)
{
// WinRT error: ignore
}
catch (FileNotFoundException)
{
// File not found: ignore
}
}
var shareService = ShareServices.GetForCurrentView();
shareService.PrecleanForSession();
shareService.Title = album.Title;
shareService.Description = album.Intro ?? string.Empty;
shareService.AddFiles(files);
shareService.ShowShareUI();
}
}
public void RefreshAlbum()
{
LinkStatus = LinkStatus.Unknown;
try
{
DbAlbum albumMetaData = _dbReader.GetAlbum(MediaId);
if (albumMetaData != null)
{
GetAlbumDetailsFromWebsite(albumMetaData.AlbumMediaId);
}
else
{
LinkStatus = LinkStatus.Unlinked;
}
}
catch (COMException)
{
Messenger.Default.Send(new ErrorMessage(ErrorMode.Error,
"Could not find album, you may need to refresh the database."));
}
catch (Exception ex)
{
Messenger.Default.Send(new ErrorMessage(ErrorMode.Error, ex.Message));
}
}
/// <summary>
/// Load album entity.
/// </summary>
/// <param name="album">Instance of <see cref="DbAlbum"/>.</param>
private void LoadAlbum(DbAlbum album)
{
if (album == null)
{
throw new ArgumentNullException(nameof(album));
}
Type = CommonItemType.Album;
InternalDbEntityId = album.Id;
Title = album.Title ?? "Album";
var name = album.Artist ?? "Artist";
ExtendedArtistName = name;
var songsCount = album.FileCount;
if (songsCount > 0)
{
Content = string.Format(CommonSharedStrings.AlbumSubtitleFormat, songsCount, name);
}
else
{
Content = string.Format(CommonSharedStrings.AlbumSubtitleFallbackFormat, name);
}
Genre = album.Genre ?? "Genre";
ReleaseDate = album.Date ?? "";
ImagePath = ImageHash = album.CoverPath;
ExtendedFilePath = album.FirstFileInAlbum;
DatabaseItemAddedDate = album.DatabaseItemAddedDate;
}
public Album Insert(CreateAlbum value)
{
using (var tran = db.Database.BeginTransaction(System.Data.IsolationLevel.RepeatableRead))
{
if (db.Albums.Any(t => EF.Functions.Like(t.Title, value.Title)))
{
throw new ArgumentException("name must be unique");
}
DbGenre genre;
if (db.Genres.Any(s => EF.Functions.Like(s.Name, value.Genre)))
{
genre = db.Genres.FirstOrDefault(s => EF.Functions.Like(s.Name, value.Genre));
}
else
{
var toInsert2 = new DbGenre()
{
Name = value.Genre
};
db.Genres.Add(toInsert2);
db.SaveChanges();
genre = toInsert2;
}
DbArtist artist;
if (db.Artists.Any(s => EF.Functions.Like(s.Name, value.Artist)))
{
artist = db.Artists.FirstOrDefault(s => EF.Functions.Like(s.Name, value.Artist));
}
else
{
var toInsert2 = new DbArtist()
{
Name = value.Artist
};
db.Artists.Add(toInsert2);
db.SaveChanges();
artist = toInsert2;
}
var toInsert = new DbAlbum()
{
Title = value.Title, ArtistId = artist.Id, GenreId = genre.Id
};
db.Albums.Add(toInsert);
db.SaveChanges();
tran.Commit();
return(FindById(toInsert.Id));
}
}
/// <summary>
/// Cleanup method.
/// </summary>
public override void Cleanup()
{
Messenger.Default.Unregister <MessageBase>(this, CommonSharedStrings.ControlPageShareClickedEventMessageToken, OnControlPageShareClickedReceived);
_backendAlbum = null;
ViewItems = null;
base.Cleanup();
}
/// <summary>
/// Helper that verifies and creates new instance of <see cref="CommonViewItemModel"/> from album entity.
/// </summary>
/// <param name="album">Instance of <see cref="DbAlbum"/>.</param>
/// <returns>Instance of <see cref="CommonViewItemModel"/>. Will return null if given album has null or empty title.</returns>
public static CommonViewItemModel CreateFromDbAlbumAndCheck(DbAlbum album)
{
if (string.IsNullOrEmpty(album?.Title))
{
return(null);
}
else
{
return(new CommonViewItemModel(album));
}
}
public static ExpandedAlbumDetailsViewModel GetAlbumDetailsFrom(this DbAlbum album)
{
return(new ExpandedAlbumDetailsViewModel
{
Artist = album.Artist,
Title = album.Title,
ArtworkUrl = album.ArtworkUrl,
SongCount = album.TrackCount.ToString(),
Year = album.ReleaseYear
});
}
/// <summary>
/// Play an album.
/// </summary>
/// <param name="album"></param>
/// <param name="requireClear"></param>
/// <param name="isInsert"></param>
public static async void Play(this DbAlbum album, bool requireClear = false, bool isInsert = false)
{
if (album?.MediaFiles != null)
{
var sortedFiles = album.MediaFiles
.OrderBy(file => ParseWithDefaultFallback(file.DiscNumber))
.ThenBy(file => ParseWithDefaultFallback(file.TrackNumber))
.Select(file => MusicPlaybackItem.CreateFromMediaFile(file));
if (requireClear)
{
PlaybackControl.Instance.Clear();
}
await PlaybackControl.Instance.AddFile(sortedFiles.ToList(), isInsert? -2 : -1);
}
}
public SearchResultModel(DbAlbum album)
{
Entity = album;
Title = album.Title;
Subtitle = CommonSharedStrings.AlbumText;
ItemType = CommonItemType.Album;
HasThumbnail = true;
Artist = album.Artist;
Thumbnail = new ThumbnailTag
{
Fallback = "Album,AlbumPlaceholder",
ArtistName = album.Artist,
AlbumName = album.Title,
ThumbnailPath = album.FirstFileInAlbum,
};
}
public AlbumDetail MapToDetailRep(DbAlbum a)
{
PublishedStatusEnumMapper statusMapper = new PublishedStatusEnumMapper();
if (a == null)
{
throw new NullReferenceException($"A null value was passed to the mapper. Expected an object of type {nameof(DbAlbum)}");
}
List <AlbumTrack> tracks = a.Tracks
.OrderByDescending(x => x.TrackNumber)
.Select(x => new AlbumTrack()
{
Title = x.Title,
DurationInSeconds = x.DurationInSeconds,
TrackNumber = x.TrackNumber,
TrackId = x.Id
}).OrderBy(x => x.TrackNumber).ToList();
var album = new AlbumDetail
{
Id = a.Id,
Title = a.Title,
DescriptionText = a.DescriptionText,
CoverImageId = a.AlbumCoverImageId,
Price = a.Price,
Producer = a.Producer,
Label = a.Label,
ReleaseDate = a.ReleaseDate,
TotalDurationInSeconds = a.TotalDurationInSeconds,
Tracks = tracks,
 CoverImageUrl = (a.AlbumCoverImageId.HasValue ? $"/api/image/{a.AlbumCoverImageId.Value}" : null),
Genres = a.AlbumGenres.Select(g => g.Genre.Name).ToList(),
CreatedUtc = new DateTime(a.CreatedUtc.Ticks, DateTimeKind.Utc),
UpdatedUtc = new DateTime(a.UpdatedUtc.Ticks, DateTimeKind.Utc),
PublishedStatus = statusMapper.Map(a.PublishStatus),
ArtistId = a.ArtistId
};
if (a.Artist != null)
{
album.ArtistName = a.Artist.Name;
}
return(album);
}
public async Task PurchaseAsync(int albumId, string userId)
{
DbAlbum dbalbum = await _context.Albums.SingleOrDefaultAsync(x => x.Id == albumId);
DbUser user = await _context.Users.SingleOrDefaultAsync(u => u.Id == userId);
if (dbalbum != null && user != null)
{
var existingRecord = await _context.UserAlbums.SingleOrDefaultAsync(x => x.UserId == userId && x.AlbumId == albumId);
if (existingRecord == null)
{
_context.UserAlbums.Add(new DbUserPurchasedAlbum
{
CreatedUtc = DateTime.UtcNow,
AlbumId = albumId,
UserId = userId
});
await _context.SaveChangesAsync();
}
}
}
async Task <List <DbAlbum> > IndexAlbumsAsync(
Dictionary <string, MetadataCollection> albums,
Dictionary <string, DbArtist> artistsCache,
Dictionary <string, DbAlbum> albumsCache)
{
var albumsDelta = new List <DbAlbum>();
foreach (var a in albums)
{
// Empty Album: Ignore album relationship
if (string.IsNullOrEmpty(a.Key) || albumsCache.ContainsKey(a.Key))
{
continue;
}
var artist = a.Value.AlbumArtist;
var firstItem = a.Value.FirstOrDefault();
var e = new DbAlbum
{
Title = a.Key,
Artist = a.Value.AlbumArtist,
Genre = firstItem.Item1.Genre,
Date = firstItem.Item1.Date,
RelatedArtistId = artistsCache.ContainsKey(artist) ?
artistsCache[artist].Id : (int?)null,
FirstFileInAlbum = firstItem.Item2
};
m_dbContext.Albums.Add(e);
albumsCache.Add(a.Key, e);
albumsDelta.Add(e);
}
await m_dbContext.SaveChangesAsync();
return(albumsDelta);
}
private void LinkAlbum()
{
try
{
DbAlbum dbAlbum = _dbReader.GetAlbum(MediaId);
_sharedModel.DbAlbum = dbAlbum;
IEnumerable <string> filePaths = dbAlbum.Tracks.Select(x => x.FilePath);
_sharedModel.SongsFromFile = _fileRetriever.GetContainers(filePaths);
var searchVm = _locator.SwitchToView <SearchView, SearchViewModel>();
searchVm.Search(dbAlbum.Artist, dbAlbum.Title);
}
catch (COMException)
{
Messenger.Default.Send(new ErrorMessage(ErrorMode.Error,
"Could not find album, you may need to refresh the database."));
}
catch (Exception ex)
{
Messenger.Default.Send(new ErrorMessage(ErrorMode.Error, ex.Message));
}
}
private async Task <int> SetupTestAlbumInDatabase()
{
var testAlbum = new DbAlbum
{
Title = "test_album",
CreatedUtc = DateTime.UtcNow,
PublishStatus = DbPublishedStatus.PUBLISHED,
ReleaseDate = DateTime.Now,
UpdatedUtc = DateTime.UtcNow,
Artist = new DbArtist
{
Name = "test artist",
PublishStatus = DbPublishedStatus.PUBLISHED,
CreatedUtc = DateTime.UtcNow,
UpdatedUtc = DateTime.UtcNow
}
};
this.db.Albums.Add(testAlbum);
await this.db.SaveChangesAsync();
return(testAlbum.Id);
}
public async Task LoadTitleAsync()
{
_backendAlbum = await EntityRetrievalExtensions.GetAlbumByIdAsync(_itemId);
if (_backendAlbum != null)
{
CoverImageTag = new ThumbnailTag
{
Fallback = "Album,AlbumPlaceholder",
ArtistName = _backendAlbum.Artist,
AlbumName = _backendAlbum.Title,
ThumbnailPath = _backendAlbum.FirstFileInAlbum,
};
// Get album detailed information
Title = _backendAlbum.Title;
Artist = _backendAlbum.Artist;
Year = DateTimeHelper.GetItemDateYearString(_backendAlbum.Date);
Intro = _backendAlbum.Intro;
Genre = _backendAlbum.Genre;
DesktopTitleViewConfiguration.SetTitleBarText(Title);
}
}
/// <summary>
/// Load data from database.
/// </summary>
/// <returns>An awaitable task.</returns>
public async Task LoadDataAsync()
{
var elem = await EntityRetrievalExtensions.GetAlbumByIdAsync(_itemId);
if (elem != null)
{
_backendAlbum = elem;
CoverImageTag = new ThumbnailTag
{
Fallback = "Album,AlbumPlaceholder",
ArtistName = _backendAlbum.Artist,
AlbumName = _backendAlbum.Title,
ThumbnailPath = _backendAlbum.FirstFileInAlbum,
};
#region Basic Info
// Get album detailed information
Title = elem.Title;
Artist = elem.Artist;
Year = DateTimeHelper.GetItemDateYearString(elem.Date);
Intro = elem.Intro;
Genre = elem.Genre;
DesktopTitleViewConfiguration.SetTitleBarText(Title);
#endregion
#region Items
var tempOrderedItem = new List <Tuple <int, int, DbMediaFile> >();
var dbFileAsyncEnumerator = elem.MediaFiles.ToAsyncEnumerable().GetEnumerator();
if (dbFileAsyncEnumerator != null)
{
while (await dbFileAsyncEnumerator.MoveNext())
{
var item = dbFileAsyncEnumerator.Current;
int discNum = 0, trackNum = 0;
int.TryParse(item.DiscNumber, out discNum);
int.TryParse(item.TrackNumber, out trackNum);
tempOrderedItem.Add(new Tuple <int, int, DbMediaFile>(discNum, trackNum, item));
}
}
// Disk and Track
var sortedItem = tempOrderedItem.OrderBy(i => i.Item1)
.ThenBy(i => i.Item2);
// Add subitems to the ListView data entity set
foreach (var s in sortedItem)
{
if (s == null)
{
continue;
}
ViewItems.Add(s.Item3);
}
#endregion
}
// Mark complete
IsLoading = false;
}
private async Task <DbAlbum> CreateAlbum(int artistId, string title, string description, string[] genres, string producer, DateTime releaseDate, string label, double price, string coverImagePath, TrackStruct[] tracks)
{
foreach (string genre in genres)
{
await this.CreateGenre(genre);
}
var existing = await this._context.Albums.FirstOrDefaultAsync(a => a.Title == title && a.ArtistId == artistId);
if (existing != null)
{
return(existing);
}
DbAlbum album = new DbAlbum()
{
Title = title,
DescriptionText = description,
Producer = producer,
Label = label,
ReleaseDate = releaseDate,
ArtistId = artistId,
Price = price,
TotalDurationInSeconds = (tracks == null ? 0 : tracks.Select(x => x.DurationInSec).Sum()),
CreatedUtc = DateTime.UtcNow,
UpdatedUtc = DateTime.UtcNow,
PublishStatus = DbPublishedStatus.PUBLISHED
};
for (int i = 0; i < tracks.Length; i++)
{
var t = tracks[i];
album.Tracks.Add(new DbTrack
{
Title = t.Title,
CreatedUtc = DateTime.UtcNow,
DurationInSeconds = t.DurationInSec,
TrackNumber = (i + 1),
UpdatedUtc = DateTime.UtcNow
});
}
foreach (string genre in genres)
{
var dbGenre = await _context.Genres.FirstAsync(x => x.Name == genre);
if (dbGenre != null)
{
album.AlbumGenres.Add(new DbAlbumGenre()
{
Genre = dbGenre,
CreatedUtc = DateTime.UtcNow
});
}
}
foreach (var g in _context.AlbumGroups)
{
int totalItems = _context.AlbumGroupListPositions.Count(x => x.GroupId == g.Id);
_context.AlbumGroupListPositions.Add(new DbAlbumGroupAlbumPosition
{
Album = album,
CreatedUtc = DateTime.UtcNow,
Group = g,
PositionIndex = totalItems + 1
});
}
if (!string.IsNullOrWhiteSpace(coverImagePath))
{
string fullPath = Path.Combine(Directory.GetCurrentDirectory(), coverImagePath);
if (File.Exists(fullPath))
{
album.AlbumCoverImage = new DbImageResource()
{
Data = File.ReadAllBytes(fullPath),
MimeType = "image/png"
};
}
}
_context.Albums.Add(album);
await _context.SaveChangesAsync();
return(album);
}
private Album ToModel(DbAlbum value)
{
return(new Album(value.Id, value.Title, value.Genre.Name, value.Artist.Name));
}
public void ReadActualDatabase()
{
Core.ZuneDatabase.SortOrder so;
switch (Settings.Default.SortOrder)
{
case SortOrder.DateAdded:
so = Core.ZuneDatabase.SortOrder.DateAdded;
break;
case SortOrder.Album:
so = Core.ZuneDatabase.SortOrder.Album;
break;
case SortOrder.Artist:
so = Core.ZuneDatabase.SortOrder.Artist;
break;
default:
so = Core.ZuneDatabase.SortOrder.DateAdded;
break;
}
_webAlbumListViewModel.Sort();
foreach (DbAlbum newAlbum in _dbReader.ReadAlbums(so))
{
var newalbumDetails = _viewLocator.Resolve <AlbumDetailsViewModel>();
newalbumDetails.LinkStatus = newAlbum.AlbumMediaId.GetLinkStatusFromGuid();
newalbumDetails.DateAdded = newAlbum.DateAdded;
newalbumDetails.Left = new AlbumThumbDetails
{
Artist = newAlbum.Artist,
ArtworkUrl = newAlbum.ArtworkUrl,
Title = newAlbum.Title,
};
if (newalbumDetails.LinkStatus == LinkStatus.Unknown || newalbumDetails.LinkStatus == LinkStatus.Linked)
{
if (_cache != null)
{
DbAlbum album = newAlbum;
var cachedObjects = _cache.Where(x => x.AlbumMediaId == album.AlbumMediaId);
if (cachedObjects.Count() > 0)
{
var co = cachedObjects.First();
if (co.Right != null)
{
newalbumDetails.Right = co.Right;
newalbumDetails.LinkStatus = LinkStatus.Linked;
}
else
{
newalbumDetails.LinkStatus = co.LinkStatus;
}
}
}
}
newalbumDetails.Init(newAlbum.MediaId, newAlbum.AlbumMediaId);
_albums.Add(newalbumDetails);
}
}
private void RebuildFromFolder(SubscriptionInfo subscriptionInfo, string folderPath, bool restricted, int startPercent = 0, int endPercent = 100)
{
if (folderPath == null)
{
throw new ArgumentNullException(nameof(folderPath));
}
using (IDbConnection db = _dbConnectionFactory.Open())
{
DirectoryInfoBase directoryInfo = _fileSystem.DirectoryInfo.FromDirectoryName(folderPath);
FileInfoBase[] files = directoryInfo.GetFiles("*.mp3", SearchOption.AllDirectories);
int index = 0;
foreach (IGrouping <string, FileInfoBase> albumFiles in files.GroupBy(f => f.DirectoryName))
{
using (IDbTransaction transaction = db.OpenTransaction())
{
_logger.Debug("Fetching album");
DbAlbum album = db.Single <DbAlbum>(a => a.Path == albumFiles.Key);
foreach (FileInfoBase file in albumFiles)
{
int progress =
(int)Math.Round((index + 1) / (double)files.Length * (endPercent - startPercent)) +
startPercent;
PublishProgress(subscriptionInfo, progress);
_logger.DebugFormat("Processing file {0}", file.FullName);
DbRecording recording;
bool saveTagFile = false;
_logger.Debug("Reading tag file");
using (File tagFile = File.Create(_fileAbstractionFactory(file.FullName, true)))
{
string recordingId = tagFile.GetCustomField(SoundWordsRecordingIdField);
if (recordingId != null)
{
_logger.Debug("Fetching recording");
recording = db.Single <DbRecording>(r => r.Uid == recordingId) ?? new DbRecording {
Uid = recordingId
};
}
else
{
recording = new DbRecording {
Uid = Guid.NewGuid().ToString("N")
};
saveTagFile = true;
tagFile.SetCustomField(SoundWordsRecordingIdField, recording.Uid);
}
if (album == null)
{
string uid = tagFile.GetCustomField(SoundWordsAlbumIdField) ?? Guid.NewGuid().ToString("N");
album = new DbAlbum
{
Uid = uid,
Name = (tagFile.Tag.Album ?? "Ukjent").Trim(),
Path = albumFiles.Key,
Restricted = restricted
};
}
UpdateAttachments(albumFiles.Key, album);
if (album.Id != 0)
{
_logger.Debug("Saving album");
db.Update(album);
}
else
{
_logger.Debug("Creating album");
album.Id = db.Insert(album, true);
}
if (tagFile.GetCustomField(SoundWordsAlbumIdField) != album.Uid)
{
tagFile.SetCustomField(SoundWordsAlbumIdField, album.Uid);
saveTagFile = true;
}
recording.AlbumId = album.Id;
recording.Title = (tagFile.Tag.Title ?? "Ukjent").Trim();
recording.Track = (ushort)tagFile.Tag.Track;
recording.Comment = tagFile.Tag.Comment;
recording.Year = tagFile.Tag.Year != 0 ? (ushort?)tagFile.Tag.Year : null;
recording.Path = file.FullName;
recording.Restricted = restricted;
if (recording.Id == 0)
{
_logger.DebugFormat("Creating recording: {0}", recording.Dump());
recording.Id = db.Insert(recording, true);
}
else
{
_logger.DebugFormat("Saving recording: {0}", recording.Dump());
db.Update(recording);
}
db.Delete <DbRecordingSpeaker>(rs => rs.RecordingId == recording.Id);
foreach (string performer in tagFile.Tag.Performers)
{
_logger.DebugFormat($"Creating speaker {performer}");
NameInfo nameInfo = performer.ToNameInfo();
DbSpeaker speaker = db.Single <DbSpeaker>(s =>
s.FirstName == nameInfo.FirstName && s.LastName == nameInfo.LastName);
if (speaker == null)
{
speaker = new DbSpeaker
{
Uid = Guid.NewGuid().ToString("N"),
FirstName = nameInfo.FirstName,
LastName = nameInfo.LastName
};
speaker.Id = db.Insert(speaker, true);
}
if (!db.Exists <DbRecordingSpeaker>(rs =>
rs.RecordingId == recording.Id && rs.SpeakerId == speaker.Id))
{
db.Insert(new DbRecordingSpeaker
{
RecordingId = recording.Id,
SpeakerId = speaker.Id
});
}
}
if (saveTagFile)
{
_logger.Debug("Writing ID tag data");
tagFile.Save();
}
}
index++;
}
_logger.Info("Committing transaction");
transaction.Commit();
}
}
}
}
public async Task <AlbumDetail> AddAsync(Album album)
{
PublishedStatusEnumMapper statusMapper = new PublishedStatusEnumMapper();
var newEntity = new DbAlbum()
{
CreatedUtc = DateTime.Now,
UpdatedUtc = DateTime.Now,
Title = album.Title,
DescriptionText = album.DescriptionText,
PublishStatus = statusMapper.Map(album.PublishedStatus),
Label = album.Label,
Price = album.Price,
Producer = album.Producer,
ReleaseDate = album.ReleaseDate,
TotalDurationInSeconds = album.TotalDurationInSeconds,
ArtistId = album.ArtistId
};
foreach (AlbumTrack t in album.Tracks)
{
newEntity.Tracks.Add(
new DbTrack
{
CreatedUtc = DateTime.UtcNow,
DurationInSeconds = t.DurationInSeconds,
Title = t.Title,
TrackNumber = t.TrackNumber,
UpdatedUtc = DateTime.UtcNow
}
);
}
foreach (string genre in album.Genres)
{
var dbGenre = await _context.Genres.SingleOrDefaultAsync(x => x.Name == genre);
if (dbGenre != null)
{
newEntity.AlbumGenres.Add((new DbAlbumGenre()
{
Genre = dbGenre
}));
}
else
{
throw new RepositoryException($"The supplied genre '{genre}' does not exist.");
}
}
if (album.CoverImageId.HasValue)
{
var img = await this._context.ImageResources.SingleOrDefaultAsync(x => x.Id == album.CoverImageId.Value);
if (img != null)
{
newEntity.AlbumCoverImage = img;
}
else
{
throw new RepositoryException($"Invalid {nameof(album.CoverImageId)}, no image for ID");
}
}
this._context.Albums.Add(newEntity);
await this._context.SaveChangesAsync();
return(_mapper.MapToDetailRep(newEntity));
}
/// <summary>
/// Initializes new instance of <see cref="CommonViewItemModel"/> from album entity.
/// </summary>
/// <param name="album">Instance of <see cref="DbAlbum"/>.</param>
public CommonViewItemModel(DbAlbum album)
{
LoadAlbum(album);
}
public RecentlyAddedAlbumModel(DbAlbum album)
{
Album = album;
}
