working on the requests page #1457 #865

src/Ombi.Core/Engine/BaseMediaEngine.cs

@@ -11,6 +11,8 @@ using Ombi.Core.Rule.Interfaces;
 using Ombi.Store.Entities.Requests;
 using Ombi.Store.Repository;
 using Ombi.Store.Repository.Requests;
+using Ombi.Store.Entities;
+using Microsoft.AspNetCore.Identity;
 
 namespace Ombi.Core.Engine
 {
@@ -21,7 +23,7 @@ namespace Ombi.Core.Engine
         private Dictionary<int, TvRequests> _dbTv;
 
         protected BaseMediaEngine(IPrincipal identity, IRequestServiceMain requestService,
-            IRuleEvaluator rules) : base(identity, rules)
+            IRuleEvaluator rules, UserManager<OmbiUser> um) : base(identity, um, rules)
         {
             RequestService = requestService;
         }

src/Ombi.Core/Engine/Interfaces/BaseEngine.cs

@@ -5,24 +5,44 @@ using System.Threading.Tasks;
 using Ombi.Core.Models.Search;
 using Ombi.Core.Rule.Interfaces;
 using Ombi.Store.Entities.Requests;
+using Ombi.Store.Entities;
+using Microsoft.AspNetCore.Identity;
+using System.Linq;
+using Microsoft.EntityFrameworkCore;
 
 namespace Ombi.Core.Engine.Interfaces
 {
     public abstract class BaseEngine
     {
-        protected BaseEngine(IPrincipal user, IRuleEvaluator rules)
+        protected BaseEngine(IPrincipal user, UserManager<OmbiUser> um, IRuleEvaluator rules)
         {
-            User = user;
+            UserPrinciple = user;
             Rules = rules;
+            UserManager = um;
         }
 
-        protected IPrincipal User { get; }
+        protected IPrincipal UserPrinciple { get; }
         protected IRuleEvaluator Rules { get; }
-        protected string Username => User.Identity.Name;
+        protected UserManager<OmbiUser> UserManager { get;  }
+        protected string Username => UserPrinciple.Identity.Name;
 
-        protected bool HasRole(string roleName)
+        private OmbiUser _user;
+        protected async Task<OmbiUser> User()
         {
-            return User.IsInRole(roleName);
+            if(_user == null)
+                _user = await UserManager.Users.FirstOrDefaultAsync(x => x.UserName == Username);
+
+            return _user;
+        }
+
+        protected async Task<string> UserAlias()
+        {
+            return (await User()).UserAlias;
+        }
+
+        protected async Task<bool> IsInRole(string roleName)
+        {
+            return await UserManager.IsInRoleAsync(await User(), roleName);
         }
         
         public async Task<IEnumerable<RuleResult>> RunRequestRules(BaseRequest model)

src/Ombi.Core/Engine/Interfaces/ITvRequestEngine.cs

@@ -16,5 +16,7 @@ namespace Ombi.Core.Engine.Interfaces
 
         Task<TvRequests> UpdateTvRequest(TvRequests request);
         Task<IEnumerable<ChildRequests>> GetAllChldren(int tvId);
+        Task<ChildRequests> UpdateChildRequest(ChildRequests request);
+        Task RemoveTvChild(int requestId);
     }
 }

src/Ombi.Core/Engine/MovieRequestEngine.cs

@@ -23,20 +23,19 @@ namespace Ombi.Core.Engine
     public class MovieRequestEngine : BaseMediaEngine, IMovieRequestEngine
     {
         public MovieRequestEngine(IMovieDbApi movieApi, IRequestServiceMain requestService, IPrincipal user,
-            INotificationHelper helper, IRuleEvaluator r, IMovieSender sender, ILogger<MovieRequestEngine> log, UserManager<OmbiUser> manager) : base(user, requestService, r)
+            INotificationHelper helper, IRuleEvaluator r, IMovieSender sender, ILogger<MovieRequestEngine> log, 
+            UserManager<OmbiUser> manager) : base(user, requestService, r, manager)
         {
             MovieApi = movieApi;
             NotificationHelper = helper;
             Sender = sender;
             Logger = log;
-            UserManager = manager;
         }
 
         private IMovieDbApi MovieApi { get; }
         private INotificationHelper NotificationHelper { get; }
         private IMovieSender Sender { get; }
         private ILogger<MovieRequestEngine> Logger { get; }
-        private UserManager<OmbiUser> UserManager { get; }
 
         /// <summary>
         /// Requests the movie.
@@ -58,7 +57,7 @@ namespace Ombi.Core.Engine
             var fullMovieName =
                 $"{movieInfo.Title}{(!string.IsNullOrEmpty(movieInfo.ReleaseDate) ? $" ({DateTime.Parse(movieInfo.ReleaseDate).Year})" : string.Empty)}";
 
-            var userDetails = await UserManager.GetUserAsync(new ClaimsPrincipal(User));
+            var userDetails = await User();
 
             var requestModel = new MovieRequests
             {

src/Ombi.Core/Engine/MovieSearchEngine.cs

@@ -13,14 +13,16 @@ using System.Security.Principal;
 using System.Threading.Tasks;
 using Ombi.Core.Rule.Interfaces;
 using StackExchange.Profiling;
+using Ombi.Store.Entities;
+using Microsoft.AspNetCore.Identity;
 
 namespace Ombi.Core.Engine
 {
     public class MovieSearchEngine : BaseMediaEngine, IMovieEngine
     {
         public MovieSearchEngine(IPrincipal identity, IRequestServiceMain service, IMovieDbApi movApi, IMapper mapper,
-            ILogger<MovieSearchEngine> logger, IRuleEvaluator r)
+            ILogger<MovieSearchEngine> logger, IRuleEvaluator r, UserManager<OmbiUser> um)
-            : base(identity, service, r)
+            : base(identity, service, r, um)
         {
             MovieApi = movApi;
             Mapper = mapper;

src/Ombi.Core/Engine/TvRequestEngine.cs

@@ -28,24 +28,22 @@ namespace Ombi.Core.Engine
         public TvRequestEngine(ITvMazeApi tvApi, IRequestServiceMain requestService, IPrincipal user,
             INotificationHelper helper, IMapper map,
             IRuleEvaluator rule, UserManager<OmbiUser> manager,
-            ITvSender sender) : base(user, requestService, rule)
+            ITvSender sender) : base(user, requestService, rule, manager)
         {
             TvApi = tvApi;
             NotificationHelper = helper;
             Mapper = map;
-            UserManager = manager;
             TvSender = sender;
         }
 
         private INotificationHelper NotificationHelper { get; }
         private ITvMazeApi TvApi { get; }
         private IMapper Mapper { get; }
-        private UserManager<OmbiUser> UserManager { get; }
         private ITvSender TvSender {get;}
 
         public async Task<RequestEngineResult> RequestTvShow(SearchTvShowViewModel tv)
         {
-            var user = await UserManager.GetUserAsync(new ClaimsPrincipal(User));
+            var user = await User();
 
             var tvBuilder = new TvShowRequestBuilder(TvApi);
             (await tvBuilder
@@ -132,13 +130,28 @@ namespace Ombi.Core.Engine
         {
             var allRequests = TvRepository.Get();
             var results = await allRequests.FirstOrDefaultAsync(x => x.Id == request.Id);
-            results = Mapper.Map<TvRequests>(request);
 
             // TODO need to check if we need to approve any child requests since they may have updated
             await TvRepository.Update(results);
             return results;
         }
 
+        public async Task<ChildRequests> UpdateChildRequest(ChildRequests request)
+        {
+            var allRequests = TvRepository.GetChild();
+            var results = await allRequests.FirstOrDefaultAsync(x => x.Id == request.Id);
+
+            // TODO need to check if we need to approve any child requests since they may have updated
+            await TvRepository.UpdateChild(results);
+            return results;
+        }
+
+        public async Task RemoveTvChild(int requestId)
+        {
+            var request = await TvRepository.GetChild().FirstOrDefaultAsync(x => x.Id == requestId);
+            await TvRepository.DeleteChild(request);
+        }
+
         public async Task RemoveTvRequest(int requestId)
         {
             var request = await TvRepository.Get().FirstOrDefaultAsync(x => x.Id == requestId);

src/Ombi.Core/Engine/TvSearchEngine.cs

@@ -17,14 +17,16 @@ using System.Threading.Tasks;
 using Ombi.Core.Rule.Interfaces;
 using Ombi.Store.Entities.Requests;
 using Ombi.Store.Repository.Requests;
+using Ombi.Store.Entities;
+using Microsoft.AspNetCore.Identity;
 
 namespace Ombi.Core.Engine
 {
     public class TvSearchEngine : BaseMediaEngine, ITvSearchEngine
     {
         public TvSearchEngine(IPrincipal identity, IRequestServiceMain service, ITvMazeApi tvMaze, IMapper mapper, ISettingsService<PlexSettings> plexSettings,
-            ISettingsService<EmbySettings> embySettings, IPlexContentRepository repo, ITraktApi trakt, IRuleEvaluator r)
+            ISettingsService<EmbySettings> embySettings, IPlexContentRepository repo, ITraktApi trakt, IRuleEvaluator r, UserManager<OmbiUser> um)
-            : base(identity, service, r)
+            : base(identity, service, r, um)
         {
             TvMazeApi = tvMaze;
             Mapper = mapper;

src/Ombi.Core/Senders/TvSender.cs

@@ -35,6 +35,10 @@ namespace Ombi.Core
         public async Task<NewSeries> SendToSonarr(ChildRequests model, string qualityId = null)
         {
             var s = await Settings.GetSettingsAsync();
+            if(string.IsNullOrEmpty(s.ApiKey))
+            {
+                return null;
+            }
             var qualityProfile = 0;
             if (!string.IsNullOrEmpty(qualityId)) // try to parse the passed in quality, otherwise use the settings default quality
             {

src/Ombi/ClientApp/app/requests/tvrequest-manage.component.html

@@ -2,9 +2,34 @@
     <div *ngFor="let child of childRequests">
         <div class="col-md-12">
             
-            <div class="col-md-6">
+            <div class="col-md-2">
-                <span>Requested By: {{child.requestedUser.alias}}</span>
+                <span>Requested By: {{child.requestedUser.userName}}</span>
+
+                <div *ngFor="let season of child.seasonRequests">
+                    <span>Season {{season.seasonNumber}}</span>
+                    <div>Episodes:</div>
+                    <span *ngFor="let episode of season.episodes">
+                        <span [ngStyle]="{ 'color': getColour(episode) }">{{episode.episodeNumber}}</span>
+                    </span>
+                    <br />
+                    <br />
                 </div>
             </div>
+
+            <div class="col-md-1 col-md-push-9">
+                <form>
+                    <button style="text-align: right" (click)="approve(child)" class="btn btn-sm btn-success-outline" type="submit"><i class="fa fa-plus"></i> Approve</button>
+                </form>
+                <form>
+                    <button type="button" (click)="deny(child)" class="btn btn-sm btn-danger-outline deny"><i class="fa fa-times"></i> Deny</button>
+                </form>
+                <form>
+                    <button type="button" (click)="deny(child)" class="btn btn-sm btn-danger-outline deny"><i class="fa fa-times"></i> Remove</button>
+                </form>
+            </div>
+        </div>
+        <br />
+        <br />
+        <hr />
     </div>
 </div>

src/Ombi/ClientApp/app/requests/tvrequest-manage.component.ts

@@ -4,7 +4,7 @@ import { ActivatedRoute } from '@angular/router';
 import { RequestService } from '../services/request.service';
 import { IdentityService } from '../services/identity.service';
 
-import { IChildRequests } from '../interfaces/IRequestModel';
+import { IChildRequests, IEpisodesRequests } from '../interfaces/IRequestModel';
 
 @Component({
     templateUrl: './tvrequest-manage.component.html'
@@ -29,7 +29,8 @@ export class TvRequestManageComponent {
     isAdmin: boolean;
 
     public removeRequest(request: IChildRequests) {
-        //this.requestService.removeTvRequest(request);
+        this.requestService.deleteChild(request)
+            .subscribe();
         this.removeRequestFromUi(request);
     }
 
@@ -37,31 +38,38 @@ export class TvRequestManageComponent {
         request.available = available;
     }
 
-    public approve(request: IChildRequests) {
-        request.approved = true;
-        request.denied = false;
-    }
-
     public deny(request: IChildRequests) {
         request.approved = false;
         request.denied = true;
+        this.requestService.updateChild(request)
+            .subscribe();
     }
 
-    public approveSeasonRequest(request: IChildRequests) {
+    public approve(request: IChildRequests) {
         request.approved = true;
         request.denied = false;
-        // this.requestService.updateTvRequest(this.selectedSeason)
+        this.requestService.updateChild(request)
-        //     .subscribe();
+             .subscribe();
     }
 
     public denySeasonRequest(request: IChildRequests) {
         request.approved = false;
         request.denied = true;
-        // this.requestService.updateTvRequest(this.selectedSeason)
+        this.requestService.updateChild(request)
-        //     .subscribe();
+            .subscribe();
     }
 
-
+    public getColour(ep: IEpisodesRequests): string {
+        if (ep.available)
+        {
+            return "lime";
+        }
+        if (ep.approved)
+        {
+            return "#00c0ff";
+        }
+        return "white";
+    }
 
     private removeRequestFromUi(key: IChildRequests) {
         var index = this.childRequests.indexOf(key, 0);

src/Ombi/ClientApp/app/services/request.service.ts

@@ -60,6 +60,12 @@ export class RequestService extends ServiceAuthHelpers {
     updateTvRequest(request: ITvRequests): Observable<ITvRequests> {
         return this.http.put(`${this.url}tv/`, JSON.stringify(request), { headers: this.headers }).map(this.extractData);
     }
+    updateChild(child: IChildRequests): Observable<IChildRequests> {
+        return this.http.put(`${this.url}tv/child`, JSON.stringify(child), { headers: this.headers }).map(this.extractData);
+    }
+    deleteChild(child: IChildRequests): Observable<IChildRequests> {
+        return this.http.delete(`${this.url}tv/child/${child.id}`, { headers: this.headers }).map(this.extractData);
+    }
 
     getRequestsCount(): Observable<IRequestCountModel> {
         return this.basicHttp.get(`${this.url}count`).map(this.extractData);

src/Ombi/Controllers/RequestController.cs

@@ -162,6 +162,29 @@ namespace Ombi.Controllers
             return await TvRequestEngine.UpdateTvRequest(model);
         }
 
+        /// <summary>
+        /// Updates the a specific child request
+        /// </summary>
+        /// <param name="child">The model.</param>
+        /// <returns></returns>
+        [HttpPut("tv/child")]
+        public async Task<ChildRequests> UpdateChild([FromBody] ChildRequests child)
+        {
+            return await TvRequestEngine.UpdateChildRequest(child);
+        }
+
+        /// <summary>
+        /// Deletes the a specific tv request
+        /// </summary>
+        /// <param name="requestId">The model.</param>
+        /// <returns></returns>
+        [HttpDelete("tv/child/{requestId:int}")]
+        public async Task DeleteChildRequest(int requestId)
+        {
+            await TvRequestEngine.RemoveTvChild(requestId);
+        }
+
+
         /// <summary>
         /// Retuns all children requests for the request id
         /// </summary>

src/Ombi/package.json

@@ -1,5 +1,5 @@
 {
-  "name": "Ombi",
+  "name": "ombi",
   "private": true,
   "version": "1.0.0",
   "scripts": {