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" }); }