private async void GetAlbums()
{
List <AlbumListItem> albums = await AlbumRequest.GetTopAlbums();
TopAlbums.DataContext = null;
TopAlbums.DataContext = albums;
}
private async void GetAlbumSongs(int id)
{
currentAlbum.Songs = await AlbumRequest.GetSongs(id);
AlbumDetails.DataContext = null;
AlbumDetails.DataContext = currentAlbum;
}
public async Task <RequestEngineResult> ApproveAlbum(AlbumRequest request)
{
if (request == null)
{
return(new RequestEngineResult
{
ErrorMessage = "Request does not exist"
});
}
request.MarkedAsApproved = DateTime.Now;
request.Approved = true;
request.Denied = false;
await MusicRepository.Update(request);
var canNotify = await RunSpecificRule(request, SpecificRules.CanSendNotification);
if (canNotify.Success)
{
NotificationHelper.Notify(request, NotificationType.RequestApproved);
}
if (request.Approved)
{
var result = await _musicSender.Send(request);
if (result.Success && result.Sent)
{
return(new RequestEngineResult
{
Result = true
});
}
if (!result.Success)
{
Logger.LogWarning("Tried auto sending album but failed. Message: {0}", result.Message);
return(new RequestEngineResult
{
Message = result.Message,
ErrorMessage = result.Message,
Result = false
});
}
// If there are no providers then it's successful but movie has not been sent
}
return(new RequestEngineResult
{
Result = true
});
}
public void Setup(NotificationOptions opts, AlbumRequest req, CustomizationSettings s,
UserNotificationPreferences pref)
{
LoadIssues(opts);
LoadCommon(req, s, pref, opts);
LoadTitle(opts, req);
ProviderId = req?.ForeignArtistId ?? string.Empty;
Year = req?.ReleaseDate.Year.ToString();
AdditionalInformation = opts?.AdditionalInformation ?? string.Empty;
PosterImage = req?.Cover.HasValue() ?? false ? req.Cover : req?.Disk ?? string.Empty;
CalculateRequestStatus(req);
}
public void NewRequest(AlbumRequest model)
{
var notificationModel = new NotificationOptions
{
RequestId = model.Id,
DateTime = DateTime.Now,
NotificationType = NotificationType.NewRequest,
RequestType = model.RequestType
};
BackgroundJob.Enqueue(() => NotificationService.Publish(notificationModel));
}
public void Notify(AlbumRequest model, NotificationType type)
{
var notificationModel = new NotificationOptions
{
RequestId = model.Id,
DateTime = DateTime.Now,
NotificationType = type,
RequestType = model.RequestType,
Recipient = model.RequestedUser?.Email ?? string.Empty
};
BackgroundJob.Enqueue(() => NotificationService.Publish(notificationModel));
}
public async Task <SenderResult> Send(AlbumRequest model)
{
var settings = await _lidarrSettings.GetSettingsAsync();
if (settings.Enabled)
{
return(await SendToLidarr(model, settings));
}
return(new SenderResult {
Success = false, Sent = false, Message = "Lidarr is not enabled"
});
}
public async Task NewRequest(AlbumRequest model)
{
var notificationModel = new NotificationOptions
{
RequestId = model.Id,
DateTime = DateTime.Now,
NotificationType = NotificationType.NewRequest,
RequestType = model.RequestType
};
await OmbiQuartz.TriggerJob(nameof(INotificationService), "Notifications", new Dictionary <string, object>
{
{ JobDataKeys.NotificationOptions, notificationModel }
});
}
private async Task <SenderResult> SetupAlbum(AlbumRequest model, ArtistResult artist, LidarrSettings settings)
{
// Get the album id
var albums = await _lidarrApi.GetAllAlbumsByArtistId(artist.id, settings.ApiKey, settings.FullUri);
var album = albums.FirstOrDefault(x =>
x.foreignAlbumId.Equals(model.ForeignAlbumId, StringComparison.InvariantCultureIgnoreCase));
var maxRetryCount = 10; // 5 seconds
var currentRetry = 0;
while (!albums.Any() || album == null)
{
if (currentRetry >= maxRetryCount)
{
break;
}
currentRetry++;
await Task.Delay(500);
albums = await _lidarrApi.GetAllAlbumsByArtistId(artist.id, settings.ApiKey, settings.FullUri);
album = albums.FirstOrDefault(x =>
x.foreignAlbumId.Equals(model.ForeignAlbumId, StringComparison.InvariantCultureIgnoreCase));
}
// Get the album we want.
if (album == null)
{
return(new SenderResult {
Message = "Could not find album in Lidarr", Sent = false, Success = false
});
}
var result = await _lidarrApi.MontiorAlbum(album.id, settings.ApiKey, settings.FullUri);
if (!settings.AddOnly)
{
await _lidarrApi.AlbumSearch(new[] { result.id }, settings.ApiKey, settings.FullUri);
}
if (result.monitored)
{
return(new SenderResult {
Message = "Album has been requested!", Sent = true, Success = true
});
}
return(new SenderResult {
Message = "Could not set album to monitored", Sent = false, Success = false
});
}
private async Task CheckForSubscription(HideResult shouldHide, AlbumRequest x)
{
if (shouldHide.UserId == x.RequestedUserId)
{
x.ShowSubscribe = false;
}
else
{
x.ShowSubscribe = true;
var sub = await _subscriptionRepository.GetAll().FirstOrDefaultAsync(s =>
s.UserId == shouldHide.UserId && s.RequestId == x.Id && s.RequestType == RequestType.Album);
x.Subscribed = sub != null;
}
}
public async Task <IActionResult> SaveAlbuns(AlbumRequest request)
{
if (ModelState.IsValid == false)
{
return(BadRequest(ModelState));
}
AlbumInputDto album = this.Mapper.Map <AlbumInputDto>(request);
var query = await this.Mediator.Send(new CreateAlbumCommand(album));
var result = this.Mapper.Map <AlbumResponse>(query.Album);
return(Created($"/{result.Id}", result));
}
public async Task Notify(AlbumRequest model, NotificationType type)
{
var notificationModel = new NotificationOptions
{
RequestId = model.Id,
DateTime = DateTime.Now,
NotificationType = type,
RequestType = model.RequestType,
Recipient = model.RequestedUser?.Email ?? string.Empty
};
await OmbiQuartz.TriggerJob(nameof(INotificationService), "Notifications", new Dictionary <string, object>
{
{ JobDataKeys.NotificationOptions, notificationModel }
});
}
public async Task <SenderResult> Send(AlbumRequest model)
{
try
{
var settings = await _lidarrSettings.GetSettingsAsync();
if (settings.Enabled)
{
return(await SendToLidarr(model, settings));
}
return(new SenderResult {
Success = false, Sent = false, Message = "Lidarr is not enabled"
});
}
catch (Exception e)
{
_log.LogError(e, "Exception thrown when sending a music to DVR app, added to the request queue");
var existingQueue = await _requestQueueRepository.FirstOrDefaultAsync(x => x.RequestId == model.Id);
if (existingQueue != null)
{
existingQueue.RetryCount++;
existingQueue.Error = e.Message;
await _requestQueueRepository.SaveChangesAsync();
}
else
{
await _requestQueueRepository.Add(new RequestQueue
{
Dts = DateTime.UtcNow,
Error = e.Message,
RequestId = model.Id,
Type = RequestType.Album,
RetryCount = 0
});
_notificationHelper.Notify(model, NotificationType.ItemAddedToFaultQueue);
}
}
return(new SenderResult {
Success = false, Sent = false, Message = "Something went wrong!"
});
}
public void Setup(NotificationOptions opts, AlbumRequest req, CustomizationSettings s, UserNotificationPreferences pref)
{
LoadIssues(opts);
RequestId = req?.Id.ToString();
string title;
if (req == null)
{
opts.Substitutes.TryGetValue("Title", out title);
}
else
{
title = req?.Title;
}
ApplicationUrl = (s?.ApplicationUrl.HasValue() ?? false) ? s.ApplicationUrl : string.Empty;
ApplicationName = string.IsNullOrEmpty(s?.ApplicationName) ? "Ombi" : s?.ApplicationName;
RequestedUser = req?.RequestedUser?.UserName;
if (UserName.IsNullOrEmpty())
{
// Can be set if it's an issue
UserName = req?.RequestedUser?.UserName;
}
AvailableDate = req?.MarkedAsAvailable?.ToString("D") ?? string.Empty;
DenyReason = req?.DeniedReason;
Alias = (req?.RequestedUser?.Alias.HasValue() ?? false) ? req?.RequestedUser?.Alias : req?.RequestedUser?.UserName;
if (pref != null)
{
UserPreference = pref.Value.HasValue() ? pref.Value : Alias;
}
Title = title;
RequestedDate = req?.RequestedDate.ToString("D");
if (Type.IsNullOrEmpty())
{
Type = req?.RequestType.Humanize();
}
Year = req?.ReleaseDate.Year.ToString();
PosterImage = (req?.Cover.HasValue() ?? false) ? req.Cover : req?.Disk ?? string.Empty;
AdditionalInformation = opts?.AdditionalInformation ?? string.Empty;
}
public void Verify_Create_Album_To_Pass()
{
AlbumRequest request = new AlbumRequest()
{
Name = "The Wall", Artist = "Pink Floyd"
};
Albums album = new Albums()
{
Id = 1, Name = "The Wall", Artist = "Pink Floyd"
};
_mockMapper.Setup(i => i.Map <AlbumRequest, Albums>(request)).Returns(album);
_mockGenericRepository.Setup(i => i.Add(album)).ReturnsAsync(album);
_mockMapper.Setup(i => i.Map <Albums, AlbumResponse>(album));
var restController = createAlbumController();
var result = restController.Create(request);
Assert.NotNull(result);
//Assert.IsType<AlbumResponse>(result.Result);
}
public AlbumDetails GetAlbumDetails(AlbumRequest request)
{
switch (request.Artist)
{
case "HZ":
_albumDetails.AlbumName = "Interstellar";
_albumDetails.Label = "WaterTower Music";
_albumDetails.Year = "2014";
break;
case "Eminem":
_albumDetails.AlbumName = "Kamikaze";
_albumDetails.Label = "Interscope Records";
_albumDetails.Year = "2018";
break;
default:
break;
}
return(_albumDetails);
}
private async Task <RequestEngineResult> AddAlbumRequest(AlbumRequest model)
{
await MusicRepository.Add(model);
var result = await RunSpecificRule(model, SpecificRules.CanSendNotification);
if (result.Success)
{
NotificationHelper.NewRequest(model);
}
await _requestLog.Add(new RequestLog
{
UserId = (await GetUser()).Id,
RequestDate = DateTime.UtcNow,
RequestId = model.Id,
RequestType = RequestType.Album,
});
return(new RequestEngineResult {
Result = true, Message = $"{model.Title} has been successfully added!", RequestId = model.Id
});
}
/// <summary>
/// Requests the Album.
/// </summary>
/// <param name="model">The model.</param>
/// <returns></returns>
public async Task <RequestEngineResult> RequestAlbum(MusicAlbumRequestViewModel model)
{
var s = await _lidarrSettings.GetSettingsAsync();
var album = await _lidarrApi.GetAlbumByForeignId(model.ForeignAlbumId, s.ApiKey, s.FullUri);
if (album == null)
{
return(new RequestEngineResult
{
Result = false,
Message = "There was an issue adding this album!",
ErrorMessage = "Please try again later"
});
}
var userDetails = await GetUser();
var requestModel = new AlbumRequest
{
ForeignAlbumId = model.ForeignAlbumId,
ArtistName = album.artist?.artistName,
ReleaseDate = album.releaseDate,
RequestedDate = DateTime.Now,
RequestType = RequestType.Album,
Rating = album.ratings?.value ?? 0m,
RequestedUserId = userDetails.Id,
Title = album.title,
Disk = album.images?.FirstOrDefault(x => x.coverType.Equals("disc"))?.url,
Cover = album.images?.FirstOrDefault(x => x.coverType.Equals("cover"))?.url,
ForeignArtistId = album?.artist?.foreignArtistId ?? string.Empty,
RequestedByAlias = model.RequestedByAlias
};
if (requestModel.Cover.IsNullOrEmpty())
{
requestModel.Cover = album.remoteCover;
}
var ruleResults = (await RunRequestRules(requestModel)).ToList();
if (ruleResults.Any(x => !x.Success))
{
return(new RequestEngineResult
{
ErrorMessage = ruleResults.FirstOrDefault(x => x.Message.HasValue()).Message
});
}
if (requestModel.Approved) // The rules have auto approved this
{
var requestEngineResult = await AddAlbumRequest(requestModel);
if (requestEngineResult.Result)
{
var result = await ApproveAlbum(requestModel);
if (result.IsError)
{
Logger.LogWarning("Tried auto sending Album but failed. Message: {0}", result.Message);
return(new RequestEngineResult
{
Message = result.Message,
ErrorMessage = result.Message,
Result = false
});
}
return(requestEngineResult);
}
// If there are no providers then it's successful but album has not been sent
}
return(await AddAlbumRequest(requestModel));
}
private async Task <SenderResult> SendToLidarr(AlbumRequest model, LidarrSettings settings)
{
var qualityToUse = int.Parse(settings.DefaultQualityProfile);
//if (model.QualityOverride > 0)
//{
// qualityToUse = model.QualityOverride;
//}
var rootFolderPath = /*model.RootPathOverride <= 0 ?*/ settings.DefaultRootPath /*: await RadarrRootPath(model.RootPathOverride, settings)*/;
// Need to get the artist
var artist = await _lidarrApi.GetArtistByForeignId(model.ForeignArtistId, settings.ApiKey, settings.FullUri);
if (artist == null || artist.id <= 0)
{
// Create artist
var newArtist = new ArtistAdd
{
foreignArtistId = model.ForeignArtistId,
addOptions = new Addoptions
{
monitored = true,
searchForMissingAlbums = false,
selectedOption = 6, // None
AlbumsToMonitor = new[] { model.ForeignAlbumId }
},
added = DateTime.Now,
monitored = true,
albumFolder = settings.AlbumFolder,
artistName = model.ArtistName,
cleanName = model.ArtistName.ToLowerInvariant().RemoveSpaces(),
images = new Image[] { },
languageProfileId = settings.LanguageProfileId,
links = new Link[] {},
metadataProfileId = settings.MetadataProfileId,
qualityProfileId = qualityToUse,
rootFolderPath = rootFolderPath,
};
var result = await _lidarrApi.AddArtist(newArtist, settings.ApiKey, settings.FullUri);
if (result != null && result.id > 0)
{
// Search for it
if (!settings.AddOnly)
{
// get the album
var album = await _lidarrApi.GetAllAlbumsByArtistId(result.id, settings.ApiKey, settings.FullUri);
var albumToSearch = album.FirstOrDefault(x =>
x.foreignAlbumId.Equals(model.ForeignAlbumId, StringComparison.InvariantCultureIgnoreCase));
var maxRetryCount = 10; // 5 seconds
var currentRetry = 0;
while (albumToSearch != null)
{
if (currentRetry >= maxRetryCount)
{
break;
}
currentRetry++;
await Task.Delay(500);
album = await _lidarrApi.GetAllAlbumsByArtistId(result.id, settings.ApiKey, settings.FullUri);
albumToSearch = album.FirstOrDefault(x =>
x.foreignAlbumId.Equals(model.ForeignAlbumId, StringComparison.InvariantCultureIgnoreCase));
}
if (albumToSearch != null)
{
await _lidarrApi.AlbumSearch(new[] { albumToSearch.id }, settings.ApiKey, settings.FullUri);
}
}
return(new SenderResult {
Message = "Album has been requested!", Sent = true, Success = true
});
}
}
else
{
SenderResult result = await SetupAlbum(model, artist, settings);
return(result);
}
return(new SenderResult {
Success = false, Sent = false, Message = "Album is already monitored"
});
}
