public RequestResult GetAlbumPaginated(AlbumModel albumModel)
{
var result = new RequestResult(StatusResult.Success);
try
{
using (var unitOfWork = UnitOfWorkFactory.CreateUnitOfWork())
{
var albumQuantidade = unitOfWork.Repository.Count <Album>(x => x.GeneroId == albumModel.GeneroId).Result;
var albumList = unitOfWork.Repository.Get <Album>(x => x.GeneroId == albumModel.GeneroId).OrderBy(x => x.Nome)
.Skip(albumModel.Skip)
.Take(albumModel.Take).ToList();
var resultPaginated = new AlbumResponse {
Albuns = albumList, Quantidade = albumQuantidade
};
result.Data = resultPaginated;
}
}
catch (Exception ex)
{
result.Status = StatusResult.Danger;
result.Messages.Add(new Message(string.Format(_localizer["UnexpectedError"], ex.Message)));
}
return(result);
}
public static async Task <List <AlbumListItem> > GetTopAlbums()
{
HttpWebRequest request = HttpWebRequest.Create(Constants.URLs.TopAlbums) as HttpWebRequest;
HttpWebResponse response = await request.GetResponseAsync() as HttpWebResponse;
return(AlbumResponse.GetTopAlbums(response));
}
/// <summary>
/// Attach Get Album Commands
/// </summary>
/// <param name="client">Spotify Sdk Client</param>
/// <param name="response">Album Response</param>
/// <param name="overrideIsAttach">Override Is Attach?</param>
public static void AttachGetAlbumCommands(
this ISpotifySdkClient client,
AlbumResponse response,
bool?overrideIsAttach = null)
{
var isAttach = GetConfig(client.Config.IsAttachGetAlbumCommands, overrideIsAttach);
if (isAttach && response != null)
{
// Album Command
if (client.CommandActions.Album != null)
{
response.Command = new GenericCommand <AlbumResponse>(
client.CommandActions.Album);
}
// Add User Playback Command
response.AddUserPlaybackCommand = new GenericCommand <IPlaybackResponse>(
client.AddUserPlaybackHandler);
// Artist Commands
if (response?.Artists != null)
{
response.Artists.ForEach(item => client.AttachGetArtistCommands(item, isAttach));
}
if (response?.Artist != null)
{
client.AttachGetArtistCommands(response?.Artist, isAttach);
}
// Track Commands
if (response?.Tracks?.Items != null)
{
response.Tracks.Items.ForEach(item => client.AttachGetTrackCommands(item, isAttach));
}
}
}
public async Task <ActionResult <AlbumResponse> > Put(int id, [FromBody] AlbumResponse input,
CancellationToken ct = default)
{
try
{
if (input == null)
{
return(BadRequest());
}
if (await _chinookSupervisor.GetAlbumByIdAsync(id, ct) == null)
{
return(NotFound());
}
var errors = JsonConvert.SerializeObject(ModelState.Values
.SelectMany(state => state.Errors)
.Select(error => error.ErrorMessage));
Debug.WriteLine(errors);
if (await _chinookSupervisor.UpdateAlbumAsync(input, ct))
{
return(Ok(input));
}
return(StatusCode(500));
}
catch (Exception ex)
{
return(StatusCode(500, ex));
}
}
public AlbumResponse GetAlbumByArtist(Guid artistId)
{
//Initialising response to be returned by the Service Layer
var albumResponse = new AlbumResponse {
Releases = new List <ReleaseResponse>()
};
//External call to MusicBrainz API with the help of a NuGet package library
var release = MusicBrainz.Search.Release(arid: artistId.ToString());
//Build object to be returned
foreach (var s in release.Data)
{
albumResponse.Releases.Add(new ReleaseResponse
{
Label = s.Labelinfolist.Any() ? s.Labelinfolist.FirstOrDefault().Label.Name : "",
ReleaseId = s.Id,
Status = s.Status,
Title = s.Title,
NumberOfTracks = s.Mediumlist.Trackcount.ToString(),
OtherArtists = new List <OtherArtistResponse>(s.Artistcredit.Any() ? s.Artistcredit.Select(a => new OtherArtistResponse {
Id = a.Artist.Id, Name = a.Artist.Name
}) : null)
});
}
return(albumResponse);
}
public static async Task <List <SongListItem> > GetSongs(int id)
{
string url = string.Format(Constants.URLs.AlbumSongs, id);
HttpWebRequest request = HttpWebRequest.Create(url) as HttpWebRequest;
HttpWebResponse response = await request.GetResponseAsync() as HttpWebResponse;
return(AlbumResponse.GetSongs(response));
}
public static async Task <Album> GetDetails(int id)
{
string url = string.Format(Constants.URLs.AlbumDetails, id);
HttpWebRequest request = HttpWebRequest.Create(url) as HttpWebRequest;
HttpWebResponse response = await request.GetResponseAsync() as HttpWebResponse;
return(AlbumResponse.GetDetails(response));
}
public async Task <AlbumResponse> Get(int id)
{
var album = await _albumCollection.GetAlbumByIdAsync(id);
if (album == null)
{
throw new HttpException(HttpStatusCode.NotFound);
}
return(await AlbumResponse.CreateFromAlbumAsync(album));
}
public async Task <AlbumResponse> Create([FromBody] CreateAlbumRequest request)
{
var artist = await _authenticatedUser.GetArtistAsync();
var album = await artist.CreateAlbumAsync(request.Name);
if (album == null)
{
throw new HttpException(HttpStatusCode.InternalServerError);
}
return(await AlbumResponse.CreateFromAlbumAsync(album));
}
public async Task <AlbumResponse> AddAlbumAsync(AlbumResponse newAlbumViewModel,
CancellationToken ct = default)
{
var album = new Album
{
Title = newAlbumViewModel.Title,
ArtistId = newAlbumViewModel.ArtistId
};
album = await _albumRepository.AddAsync(album, ct);
newAlbumViewModel.AlbumId = album.AlbumId;
return(newAlbumViewModel);
}
public async Task <bool> UpdateAlbumAsync(AlbumResponse albumViewModel,
CancellationToken ct = default)
{
var album = await _albumRepository.GetByIdAsync(albumViewModel.AlbumId, ct);
if (album is null)
{
return(false);
}
album.AlbumId = albumViewModel.AlbumId;
album.Title = albumViewModel.Title;
album.ArtistId = albumViewModel.ArtistId;
return(await _albumRepository.UpdateAsync(album, ct));
}
/// <summary>
/// Attach Get Album Toggles
/// </summary>
/// <param name="client">Spotify Sdk Client</param>
/// <param name="response">Album Response</param>
public static async Task AttachGetAlbumToggles(
this ISpotifySdkClient client,
AlbumResponse response)
{
if (client.Config.IsAttachGetAlbumToggles && response != null)
{
// Toggle Favourites
response.ToggleFavourite = await client.GetToggleAsync(
ToggleType.Favourites, response.Id, (byte)FavouriteType.Album);
// Toggle Saved
response.ToggleSaved = await client.GetToggleAsync(
ToggleType.Saved, response.Id, (byte)SavedType.Album);
}
}
public async Task <ActionResult <AlbumResponse> > Post([FromBody] AlbumResponse input,
CancellationToken ct = default)
{
try
{
if (input == null)
{
return(BadRequest());
}
return(StatusCode(201, await _chinookSupervisor.AddAlbumAsync(input, ct)));
}
catch (Exception ex)
{
return(StatusCode(500, ex));
}
}
internal static List <AlbumResponse> ConvertToAlbumResponses(List <Album> albums)
{
var albumResponses = new List <AlbumResponse>();
albums.ForEach((album) =>
{
var albumResponse = new AlbumResponse
{
Id = album.Id,
Title = album.Title,
UserId = album.UserId
};
albumResponses.Add(albumResponse);
});
return(albumResponses);
}
// TODO
private async Task <SearchAlbumViewModel> MapIntoAlbumVm(AlbumResponse a, LidarrSettings settings)
{
var vm = new SearchAlbumViewModel
{
ForeignAlbumId = a.foreignAlbumId,
Monitored = a.monitored,
Rating = a.ratings?.value ?? 0m,
ReleaseDate = a.releaseDate,
Title = a.title,
Disk = a.images?.FirstOrDefault(x => x.coverType.Equals("disc"))?.url?.Replace("http", "https"),
Genres = a.genres
};
if (a.artistId > 0)
{
//TODO THEY HAVE FIXED THIS IN DEV
// The JSON is different for some stupid reason
// Need to lookup the artist now and all the images -.-"
var artist = await _lidarrApi.GetArtist(a.artistId, settings.ApiKey, settings.FullUri);
vm.ArtistName = artist.artistName;
vm.ForeignArtistId = artist.foreignArtistId;
}
else
{
//vm.ForeignArtistId = a.artistId?.foreignArtistId;
//vm.ArtistName = a.artist?.artistName;
}
vm.Cover = a.images?.FirstOrDefault(x => x.coverType.Equals("cover"))?.url?.Replace("http", "https");
if (vm.Cover.IsNullOrEmpty())
{
//vm.Cover = a.remoteCover;
}
await Rules.StartSpecificRules(vm, SpecificRules.LidarrAlbum);
await RunSearchRules(vm);
return(vm);
}
private async Task DownloadCompositions(AlbumResponse composition, String path)
{
try
{
if (path[path.Length - 1] != '\\')
{
path = path + "\\";
}
var fileName = composition.title;
if (fileName.Length > 40)
{
fileName = fileName.Substring(0, 40);
}
fileName = fileName.Replace(":", "").Replace("\\", "").Replace("/", "").Replace("*", "").Replace("?", "").Replace("\"", "");
using (var client = new WebClient())
{
client.DownloadProgressChanged += (o, args) =>
{
progressBar.Value = args.ProgressPercentage;
};
client.DownloadFileCompleted += (o, args) =>
{
progressBar.Value = 0;
compositionName.Text = "";
};
compositionName.Text = composition.title;
await client.DownloadFileTaskAsync(new Uri(composition.url), path + fileName + ".mp3");
}
}
catch (Exception)
{
// ignored
}
}
