Lots of different UI enhancements and fixes #865

src/Ombi.Api.Sonarr/ISonarrApi.cs

@@ -19,6 +19,6 @@ namespace Ombi.Api.Sonarr
         Task<bool> EpisodeSearch(int[] episodeIds, string apiKey, string baseUrl);
         Task<bool> SeasonSearch(int seriesId, int seasonNumber, string apiKey, string baseUrl);
         Task<bool> SeriesSearch(int seriesId, string apiKey, string baseUrl);
-
+        Task<SystemStatus> SystemStatus(string apiKey, string baseUrl);
     }
 }

src/Ombi.Api.Sonarr/Models/SystemStatus.cs

@@ -0,0 +1,25 @@
+namespace Ombi.Api.Sonarr
+{
+    public class SystemStatus
+    {
+        public string version { get; set; }
+        public string buildTime { get; set; }
+        public bool isDebug { get; set; }
+        public bool isProduction { get; set; }
+        public bool isAdmin { get; set; }
+        public bool isUserInteractive { get; set; }
+        public string startupPath { get; set; }
+        public string appData { get; set; }
+        public string osVersion { get; set; }
+        public bool isMonoRuntime { get; set; }
+        public bool isMono { get; set; }
+        public bool isLinux { get; set; }
+        public bool isOsx { get; set; }
+        public bool isWindows { get; set; }
+        public string branch { get; set; }
+        public string authentication { get; set; }
+        public string sqliteVersion { get; set; }
+        public string urlBase { get; set; }
+        public string runtimeVersion { get; set; }
+    }
+}

src/Ombi.Api.Sonarr/SonarrApi.cs

@@ -188,5 +188,13 @@ namespace Ombi.Api.Sonarr
             request.AddJsonBody(body);
             return await Api.Request<CommandResult>(request);
         }
+
+        public async Task<SystemStatus> SystemStatus(string apiKey, string baseUrl)
+        {
+            var request = new Request("/api/system/status", baseUrl, HttpMethod.Get);
+            request.AddHeader("X-Api-Key", apiKey);
+
+            return await Api.Request<SystemStatus>(request);
+        }
     }
 }

src/Ombi.Core/Engine/TvRequestEngine.cs

@@ -149,8 +149,19 @@ namespace Ombi.Core.Engine
         public async Task RemoveTvChild(int requestId)
         {
             var request = await TvRepository.GetChild().FirstOrDefaultAsync(x => x.Id == requestId);
+            var all = TvRepository.Db.TvRequests.Include(x => x.ChildRequests);
+            var parent = all.FirstOrDefault(x => x.Id == request.ParentRequestId);
+           
+            // Is this the only child? If so delete the parent
+            if (parent.ChildRequests.Count <= 1)
+            {
+                // Delete the parent
+                TvRepository.Db.TvRequests.Remove(parent);
+            }
             await Audit.Record(AuditType.Deleted, AuditArea.TvRequest, $"Deleting Request {request.Title}", Username);
-            await TvRepository.DeleteChild(request);
+
+            TvRepository.Db.ChildRequests.Remove(request);
+            await TvRepository.Db.SaveChangesAsync();
         }
 
         public async Task RemoveTvRequest(int requestId)

src/Ombi.Schedule/Jobs/Emby/EmbyContentCacher.cs

@@ -37,7 +37,7 @@ namespace Ombi.Schedule.Jobs.Emby
 
         public async Task Start()
         {
-            var embySettings = await _settings.GetSettingsAsync();
+           var embySettings = await _settings.GetSettingsAsync();
             if (!embySettings.Enable)
                 return;
 

src/Ombi.Store/Repository/Requests/ITvRequestRepository.cs

@@ -1,11 +1,13 @@
 using System.Linq;
 using System.Threading.Tasks;
+using Ombi.Store.Context;
 using Ombi.Store.Entities.Requests;
 
 namespace Ombi.Store.Repository.Requests
 {
     public interface ITvRequestRepository
     {
+        IOmbiContext Db { get; }
         Task<TvRequests> Add(TvRequests request);
         Task<ChildRequests> AddChild(ChildRequests request);
         Task Delete(TvRequests request);

src/Ombi.Store/Repository/Requests/TvRequestRepository.cs

@@ -13,7 +13,7 @@ namespace Ombi.Store.Repository.Requests
             Db = ctx;
         }
 
-        private IOmbiContext Db { get; }
+        public IOmbiContext Db { get; }
 
         public async Task<TvRequests> GetRequestAsync(int tvDbId)
         {

src/Ombi/ClientApp/app/auth/auth.service.ts

@@ -51,7 +51,7 @@ export class AuthService extends ServiceHelpers {
 
 
     hasRole(role: string): boolean {
-        return this.claims().roles.some(r => r === role);
+        return this.claims().roles.some(r => r.toUpperCase() === role.toUpperCase());
     }
 
     logout() {

src/Ombi/ClientApp/app/requests/tvrequests.component.html

@@ -68,6 +68,7 @@
                                     <span *ngIf="child.available" class="label label-success">Available</span>
                                     <span *ngIf="child.denied" class="label label-danger">Denied</span>
                                     <span *ngIf="child.approved && !child.available && !child.denied" class="label label-info">Processing Request</span>
+                                    <span *ngIf="!child.approved && !child.available" class="label label-info">Pending Approval</span>
                                 </div>
 
 
@@ -95,7 +96,7 @@
                                                 <table class="table table-striped table-hover table-responsive table-condensed">
                                                     <thead>
                                                         <tr>
-                                                            <th>
+                                                            <th style="left">
                                                                 <a>#</a>
                                                             </th>
                                                             <th>
@@ -125,7 +126,7 @@
                                                                 <span *ngIf="ep.approved && !ep.available" class="label label-info">Processing Request</span>
                                                                 <div *ngIf="ep.requested && !ep.available; then requested else notRequested"></div>
                                                                 <ng-template #requested>
-                                                                    <span *ngIf="!ep.available" class="label label-warning">Pending Approval</span>
+                                                                    <span *ngIf="!ep.available" class="label label-info">Pending Approval</span>
                                                                 </ng-template>
 
                                                                 <ng-template #notRequested>

src/Ombi/ClientApp/app/requests/tvrequests.component.scss

@@ -11,4 +11,8 @@
 .ui-treetable-toggler.fa.fa-fw.ui-c.fa-caret-right,
 .ui-treetable-toggler.fa.fa-fw.ui-c.fa-caret-down {
     display: none;
+}
+
+th {
+    text-align: left !important;
 }

src/Ombi/ClientApp/app/requests/tvrequests.component.ts

@@ -11,7 +11,6 @@ import 'rxjs/add/operator/map';
 
 import { RequestService } from '../services/request.service';
 import { AuthService } from '../auth/auth.service';
-import { IdentityService } from '../services/identity.service';
 
 import { ITvRequests, IChildRequests, INewSeasonRequests, IEpisodesRequests } from '../interfaces/IRequestModel';
 import { TreeNode, } from "primeng/primeng";
@@ -27,7 +26,9 @@ import { TreeNode, } from "primeng/primeng";
 })
 export class TvRequestsComponent implements OnInit, OnDestroy {
     constructor(private requestService: RequestService,
-        private identityService: IdentityService, private authService : AuthService) {
+        private authService: AuthService) {
+
+        this.admin = this.authService.hasRole("admin");
         this.searchChanged
             .debounceTime(600) // Wait Xms afterthe last event before emitting last event
             .distinctUntilChanged() // only emit if value is different from previous value
@@ -49,7 +50,6 @@ export class TvRequestsComponent implements OnInit, OnDestroy {
         this.currentlyLoaded = 5;
         this.tvRequests = [];
         this.loadInit();
-        this.admin = this.authService.hasRole("admin");
     }
 
     public admin = false;
@@ -157,14 +157,27 @@ export class TvRequestsComponent implements OnInit, OnDestroy {
     public approve(request: IChildRequests) {
         request.approved = true;
         request.denied = false;
+
+        // Mark all the episodes as approved now
+        request.seasonRequests.forEach((val) => {
+            val.episodes.forEach((ep) => {
+                ep.approved = true;
+            });
+        });
         this.requestService.updateChild(request)
             .subscribe();
     }
 
     public deny(request: IChildRequests) {
-        debugger;
         request.approved = false;
         request.denied = true;
+
+        // Mark all the episodes as not approved now
+        request.seasonRequests.forEach((val) => {
+            val.episodes.forEach((ep) => {
+                ep.approved = false;
+            });
+        });
         this.requestService.updateChild(request)
             .subscribe();
     }
@@ -214,10 +227,8 @@ export class TvRequestsComponent implements OnInit, OnDestroy {
         this.requestService.getTvRequests(this.amountToLoad, 0)
             .takeUntil(this.subscriptions)
             .subscribe(x => {
-                debugger;
                 this.tvRequests = this.transformData(x);
             });
-        this.isAdmin = this.identityService.hasRole("Admin");
     }
 
     private resetSearch() {
@@ -236,7 +247,12 @@ export class TvRequestsComponent implements OnInit, OnDestroy {
             var data = (<any>val).data;
             var index = data.childRequests.indexOf(key, 0);
             if (index > -1) {
-                data.childRequests.splice(index, 1);
+                // Check if we need to remove the parent (if this is the only child)
+                if (data.childRequests.length <= 1) {
+                    this.removeRequestFromUi(val);
+                } else {
+                    data.childRequests.splice(index, 1);
+                }
             }
         });
     }

src/Ombi/ClientApp/app/search/seriesinformation.component.ts

@@ -65,6 +65,10 @@ export class SeriesInformationComponent implements OnInit, OnDestroy {
         episode.requested = true;
     }
 
+    public removeRequest(episode: IEpisodesRequests) {
+        episode.requested = false;
+    }
+
 
     ngOnDestroy(): void {
         this.subscriptions.next();

src/Ombi/ClientApp/app/services/applications/tester.service.ts

@@ -13,6 +13,12 @@ import {
     IMattermostNotifcationSettings
 } from '../../interfaces/INotifcationSettings'
 
+import {
+    IEmbyServer,
+    IPlexServer,
+    IRadarrSettings,
+    ISonarrSettings
+} from '../../interfaces/ISettings';
 
 @Injectable()
 export class TesterService extends ServiceAuthHelpers {
@@ -41,5 +47,17 @@ export class TesterService extends ServiceAuthHelpers {
 
     emailTest(settings: IEmailNotificationSettings): Observable<boolean> {
         return this.http.post(`${this.url}email`, JSON.stringify(settings), { headers: this.headers }).map(this.extractData);
+    }
+    plexTest(settings: IPlexServer): Observable<boolean> {
+        return this.http.post(`${this.url}plex`, JSON.stringify(settings), { headers: this.headers }).map(this.extractData);
+    }
+    embyTest(settings: IEmbyServer): Observable<boolean> {
+        return this.http.post(`${this.url}emby`, JSON.stringify(settings), { headers: this.headers }).map(this.extractData);
+    }
+    radarrTest(settings: IRadarrSettings): Observable<boolean> {
+        return this.http.post(`${this.url}radarr`, JSON.stringify(settings), { headers: this.headers }).map(this.extractData);
+    }
+    sonarrTest(settings: ISonarrSettings): Observable<boolean> {
+        return this.http.post(`${this.url}sonarr`, JSON.stringify(settings), { headers: this.headers }).map(this.extractData);
     }   
 }

src/Ombi/ClientApp/app/settings/emby/emby.component.ts

@@ -3,14 +3,16 @@
 import { IEmbySettings, IEmbyServer } from '../../interfaces/ISettings'
 import { SettingsService } from '../../services/settings.service';
 import { NotificationService } from "../../services/notification.service";
+import { TesterService } from '../../services/applications/tester.service';
 
 @Component({
-  
+    templateUrl: './emby.component.html'
-    templateUrl: './emby.component.html',
 })
 export class EmbyComponent implements OnInit {
 
-    constructor(private settingsService: SettingsService, private notificationService: NotificationService) {  }
+    constructor(private settingsService: SettingsService,
+        private notificationService: NotificationService,
+    private testerService : TesterService) { }
 
     settings: IEmbySettings;
 
@@ -22,13 +24,37 @@ export class EmbyComponent implements OnInit {
         if (this.settings.servers == null) {
             this.settings.servers = [];
         } 
-        this.settings.servers.push(<IEmbyServer>{ name: "New*", id: Math.floor(Math.random() * (99999 - 0 + 1) + 1), apiKey: "", administratorId: "", enableEpisodeSearching: false, ip: "", port: 0, ssl: false, subDir: "" });
+        this.settings.servers.push({
+            name: "New*",
+            id: Math.floor(Math.random() * (99999 - 0 + 1) + 1),
+            apiKey: "",
+            administratorId: "",
+            enableEpisodeSearching: false,
+            ip: "",
+            port: 0,
+            ssl: false,
+            subDir: ""
+        } as IEmbyServer);
     }
 
-    test() {
+    test(server: IEmbyServer) {
-        // TODO Emby Service
+        this.testerService.embyTest(server).subscribe(x => {
+            if (x) {
+                this.notificationService.success("Connected", `Successfully connected to the Emby server ${server.name}!`);
+            } else {
+                this.notificationService.error("Connected", `We could not connect to the Emby server  ${server.name}!`);
+            }
+        });
     }
 
+    removeServer(server: IEmbyServer) {
+        var index = this.settings.servers.indexOf(server, 0);
+        if (index > -1) {
+            this.settings.servers.splice(index, 1);
+        }
+    }
+
+
     save() {
         this.settingsService.saveEmby(this.settings).subscribe(x => {
             if (x) {

src/Ombi/ClientApp/app/settings/ombi/ombi.component.html

@@ -4,12 +4,12 @@
     <legend>Ombi Configuration</legend>
     <form novalidate [formGroup]="form" (ngSubmit)="onSubmit(form)">
 
-        <div class="form-group">
+        <!--<div class="form-group">
             <label for="portNumber" class="control-label">Port</label>
             <div>
                 <input type="text" class="form-control form-control-custom " id="portNumber" name="Port" placeholder="Port Number" formControlName="port" pTooltip="You will have to restart after changing the port.">
             </div>
-        </div>
+        </div>-->
 
         <!--<div *ngIf="form.invalid && form.dirty" class="alert alert-danger">
             <div>The External URL is incorrect</div>

src/Ombi/ClientApp/app/settings/ombi/ombi.component.ts

@@ -30,9 +30,7 @@ export class OmbiComponent implements OnInit {
 
     refreshApiKey() {
         this.settingsService.resetOmbiApi().subscribe(x => {
-            this.form.patchValue({
+            this.form.controls["apiKey"].patchValue(x);
-                apiKey: x
-            });
         });
     }
 
@@ -41,6 +39,8 @@ export class OmbiComponent implements OnInit {
             this.notificationService.error("Validation", "Please check your entered values");
             return;
         }
+
+        
         this.settingsService.saveOmbi(form.value).subscribe(x => {
             if (x) {
                 this.notificationService.success("Settings Saved", "Successfully saved Ombi settings");

src/Ombi/ClientApp/app/settings/plex/plex.component.html

@@ -145,7 +145,7 @@
 
                         <div class="form-group">
                             <div>
-                                <button id="testPlex" type="submit" (click)="testPlex()" class="btn btn-primary-outline">
+                                <button id="testPlex" type="submit" (click)="testPlex(server)" class="btn btn-primary-outline">
                                     Test Connectivity
                                     <div id="spinner"></div>
                                 </button>

src/Ombi/ClientApp/app/settings/plex/plex.component.ts

@@ -6,6 +6,7 @@ import { IPlexSettings, IPlexLibraries, IPlexServer } from '../../interfaces/ISe
 import { IPlexServerResponse, IPlexServerViewModel } from '../../interfaces/IPlex'
 
 import { SettingsService } from '../../services/settings.service';
+import { TesterService } from '../../services/applications/tester.service';
 import { PlexService } from '../../services/applications/plex.service';
 import { NotificationService } from "../../services/notification.service";
 
@@ -13,7 +14,10 @@ import { NotificationService } from "../../services/notification.service";
     templateUrl: './plex.component.html',
 })
 export class PlexComponent implements OnInit, OnDestroy {
-    constructor(private settingsService: SettingsService, private notificationService: NotificationService, private plexService: PlexService) { }
+    constructor(private settingsService: SettingsService,
+        private notificationService: NotificationService,
+        private plexService: PlexService,
+        private testerService : TesterService) { }
 
     settings: IPlexSettings;
     loadedServers: IPlexServerViewModel; // This comes from the api call for the user to select a server
@@ -26,8 +30,7 @@ export class PlexComponent implements OnInit, OnDestroy {
     ngOnInit(): void {
         this.settingsService.getPlex().subscribe(x => {
             this.settings = x;
-        }
+        });
-        );
     }
 
     requestServers(server: IPlexServer): void {
@@ -55,8 +58,14 @@ export class PlexComponent implements OnInit, OnDestroy {
         this.notificationService.success("Success", `Selected ${server.name}!`)
     }
 
-    testPlex() {
+    testPlex(server: IPlexServer) {
-        // TODO Plex Service
+        this.testerService.plexTest(server).subscribe(x => {
+            if (x) {
+                this.notificationService.success("Connected", `Successfully connected to the Plex server ${server.name}!`);
+            } else {
+                this.notificationService.error("Connected", `We could not connect to the Plex server  ${server.name}!`);
+            }
+        });
     }
 
     addTab() {
@@ -68,11 +77,10 @@ export class PlexComponent implements OnInit, OnDestroy {
     }
 
     removeServer(server: IPlexServer) {
-        this.notificationService.warning("Disabled", "This feature is currently disabled");
+        var index = this.settings.servers.indexOf(server, 0);
-        //var index = this.settings.servers.indexOf(server, 0);
+        if (index > -1) {
-        //if (index > -1) {
+            this.settings.servers.splice(index, 1);
-        //    this.settings.servers.splice(index, 1);
+        }
-        //}
     }
 
     loadLibraries(server: IPlexServer) {

src/Ombi/ClientApp/app/settings/radarr/radarr.component.html

@@ -112,7 +112,7 @@
             </div>
             <div class="form-group">
                 <div>
-                    <button [disabled]="form.invalid" (click)="test()" class="btn btn-primary-outline">Test Connectivity <span id="spinner"></span></button>
+                    <button [disabled]="form.invalid" (click)="test(form)" class="btn btn-primary-outline">Test Connectivity <span id="spinner"></span></button>
                 </div>
             </div>
 

src/Ombi/ClientApp/app/settings/radarr/radarr.component.ts

@@ -7,6 +7,7 @@ import { IRadarrSettings } from '../../interfaces/ISettings';
 import { IRadarrProfile, IRadarrRootFolder, IMinimumAvailability } from '../../interfaces/IRadarr';
 import { SettingsService } from '../../services/settings.service';
 import { RadarrService } from '../../services/applications/radarr.service';
+import { TesterService } from '../../services/applications/tester.service';
 import { NotificationService } from "../../services/notification.service";
 
 @Component({
@@ -15,8 +16,11 @@ import { NotificationService } from "../../services/notification.service";
 })
 export class RadarrComponent implements OnInit {
 
-    constructor(private settingsService: SettingsService, private radarrService: RadarrService, private notificationService: NotificationService,
+    constructor(private settingsService: SettingsService,
-        private fb: FormBuilder) { }
+        private radarrService: RadarrService,
+        private notificationService: NotificationService,
+        private fb: FormBuilder,
+        private testerService : TesterService) { }
     qualities: IRadarrProfile[];
     rootFolders: IRadarrRootFolder[];
 
@@ -57,11 +61,11 @@ export class RadarrComponent implements OnInit {
             });
 
         this.minimumAvailabilityOptions = [
-            { name: "Announced", value:"Announced" },
+            { name: "Announced", value: "Announced" },
-            { name: "In Cinemas", value:"InCinemas" },
+            { name: "In Cinemas", value: "InCinemas" },
-            { name: "Physical / Web", value:"Released" },
+            { name: "Physical / Web", value: "Released" },
-            { name: "PreDb", value:"PreDb" },
+            { name: "PreDb", value: "PreDb" },
-        ]
+        ];
 
     }
 
@@ -86,14 +90,25 @@ export class RadarrComponent implements OnInit {
          });
     }
 
-    test() {
+    test(form: FormGroup) {
-        // TODO
+        if (form.invalid) {
+            this.notificationService.error("Validation", "Please check your entered values");
+            return;
+        }
+        var settings = <IRadarrSettings>form.value;
+        this.testerService.radarrTest(settings).subscribe(x => {
+            if (x) {
+                this.notificationService.success("Connected", "Successfully connected to Radarr!");
+            } else {
+                this.notificationService.error("Connected", "We could not connect to Radarr!");
+            }
+        });
     }
 
 onSubmit(form: FormGroup) {
         if (form.invalid) {
             this.notificationService.error("Validation", "Please check your entered values");
-            return
+            return;
         }
 
         var settings = <IRadarrSettings>form.value;

src/Ombi/ClientApp/app/settings/sonarr/sonarr.component.html

@@ -110,7 +110,7 @@
 
             <div class="form-group">
                 <div>
-                    <button type="button" (click)="test()" class="btn btn-primary-outline">Test Connectivity <span id="spinner"> </span></button>
+                    <button type="button" (click)="test(form)" class="btn btn-primary-outline">Test Connectivity <span id="spinner"> </span></button>
                 </div>
             </div>
 

src/Ombi/ClientApp/app/settings/sonarr/sonarr.component.ts

@@ -4,6 +4,9 @@ import "rxjs/add/operator/takeUntil";
 import { FormGroup, Validators, FormBuilder } from '@angular/forms';
 
 import { ISonarrProfile, ISonarrRootFolder } from '../../interfaces/ISonarr'
+
+import { TesterService } from '../../services/applications/tester.service';
+import { ISonarrSettings } from '../../interfaces/ISettings';
 import { SettingsService } from '../../services/settings.service';
 import { SonarrService } from '../../services/applications/sonarr.service';
 import { NotificationService } from "../../services/notification.service";
@@ -14,8 +17,11 @@ import { NotificationService } from "../../services/notification.service";
 })
 export class SonarrComponent implements OnInit, OnDestroy {
 
-    constructor(private settingsService: SettingsService, private sonarrService: SonarrService, private notificationService: NotificationService,
+    constructor(private settingsService: SettingsService,
-    private fb : FormBuilder) { }
+        private sonarrService: SonarrService,
+        private notificationService: NotificationService,
+        private testerService : TesterService,
+        private fb : FormBuilder) { }
 
     qualities: ISonarrProfile[];
     rootFolders: ISonarrRootFolder[];
@@ -84,15 +90,26 @@ export class SonarrComponent implements OnInit, OnDestroy {
             });
     }
 
-    test() {
+    test(form: FormGroup) {
-        // TODO
+        if (form.invalid) {
+            this.notificationService.error("Validation", "Please check your entered values");
+            return;
+        }
+        var settings = <ISonarrSettings>form.value;
+        this.testerService.sonarrTest(settings).subscribe(x => {
+            if (x) {
+                this.notificationService.success("Connected", "Successfully connected to Sonarr!");
+            } else {
+                this.notificationService.error("Connected", "We could not connect to Sonarr!");
+            }
+        });
     }
 
     onSubmit(form:FormGroup) {
    if (form.invalid) {
             this.notificationService.error("Validation", "Please check your entered values");
-            return
+       return;
-        }
+   }
         this.settingsService.saveSonarr(form.value)
             .takeUntil(this.subscriptions)
             .subscribe(x => {

src/Ombi/Controllers/External/TesterController.cs

@@ -1,11 +1,20 @@
 using System;
+using System.Linq;
+using System.Threading.Tasks;
 using Hangfire;
 using Microsoft.AspNetCore.Mvc;
+using Microsoft.Extensions.Logging;
+using Ombi.Api.Emby;
+using Ombi.Api.Plex;
+using Ombi.Api.Radarr;
+using Ombi.Api.Sonarr;
 using Ombi.Attributes;
 using Ombi.Core.Notifications;
+using Ombi.Core.Settings.Models.External;
 using Ombi.Helpers;
 using Ombi.Notifications.Agents;
 using Ombi.Notifications.Models;
+using Ombi.Settings.Settings.Models.External;
 using Ombi.Settings.Settings.Models.Notifications;
 
 namespace Ombi.Controllers.External
@@ -27,7 +36,8 @@ namespace Ombi.Controllers.External
         /// <param name="pushbullet">The pushbullet.</param>
         /// <param name="slack">The slack.</param>
         public TesterController(INotificationService service, IDiscordNotification notification, IEmailNotification emailN,
-            IPushbulletNotification pushbullet, ISlackNotification slack, IPushoverNotification po, IMattermostNotification mm)
+            IPushbulletNotification pushbullet, ISlackNotification slack, IPushoverNotification po, IMattermostNotification mm,
+            IPlexApi plex, IEmbyApi emby, IRadarrApi radarr, ISonarrApi sonarr, ILogger<TesterController> log)
         {
             Service = service;
             DiscordNotification = notification;
@@ -36,6 +46,11 @@ namespace Ombi.Controllers.External
             SlackNotification = slack;
             PushoverNotification = po;
             MattermostNotification = mm;
+            PlexApi = plex;
+            RadarrApi = radarr;
+            EmbyApi = emby;
+            SonarrApi = sonarr;
+            Log = log;
         }
 
         private INotificationService Service { get; }
@@ -45,6 +60,11 @@ namespace Ombi.Controllers.External
         private ISlackNotification SlackNotification { get; }
         private IPushoverNotification PushoverNotification { get; }
         private IMattermostNotification MattermostNotification { get; }
+        private IPlexApi PlexApi { get; }
+        private IRadarrApi RadarrApi { get; }
+        private IEmbyApi EmbyApi { get; }
+        private ISonarrApi SonarrApi { get; }
+        private ILogger<TesterController> Log { get; }
 
 
         /// <summary>
@@ -135,11 +155,95 @@ namespace Ombi.Controllers.External
             var notificationModel = new NotificationOptions
             {
                 NotificationType = NotificationType.Test,
-                RequestId = -1 
+                RequestId = -1
             };
             EmailNotification.NotifyAsync(notificationModel, settings);
 
             return true;
         }
+
+        /// <summary>
+        /// Checks if we can connect to Plex with the provided settings
+        /// </summary>
+        /// <param name="settings"></param>
+        /// <returns></returns>
+        [HttpPost("plex")]
+        public async Task<bool> Plex([FromBody] PlexServers settings)
+        {
+            try
+            {
+                var result = await PlexApi.GetStatus(settings.PlexAuthToken, settings.FullUri);
+                return result?.MediaContainer?.version != null;
+            }
+            catch (Exception e)
+            {
+                Log.LogError(LoggingEvents.Api, e, "Could not test Plex");
+                return false;
+            }
+        }
+
+        /// <summary>
+        /// Checks if we can connect to Emby with the provided settings
+        /// </summary>
+        /// <param name="settings"></param>
+        /// <returns></returns>
+        [HttpPost("emby")]
+        public async Task<bool> Emby([FromBody] EmbyServers settings)
+        {
+            try
+            {
+
+                var result = await EmbyApi.GetUsers(settings.FullUri, settings.ApiKey);
+                return result.Any();
+            }
+            catch (Exception e)
+            {
+                Log.LogError(LoggingEvents.Api, e, "Could not test Emby");
+                return false;
+            }
+        }
+
+        /// <summary>
+        /// Checks if we can connect to Radarr with the provided settings
+        /// </summary>
+        /// <param name="settings"></param>
+        /// <returns></returns>
+        [HttpPost("radarr")]
+        public async Task<bool> Radarr([FromBody] RadarrSettings settings)
+        {
+            try
+            {
+
+
+                var result = await RadarrApi.SystemStatus(settings.ApiKey, settings.FullUri);
+                return result.version != null;
+            }
+            catch (Exception e)
+            {
+                Log.LogError(LoggingEvents.Api, e, "Could not test Radarr");
+                return false;
+            }
+        }
+
+        /// <summary>
+        /// Checks if we can connect to Sonarr with the provided settings
+        /// </summary>
+        /// <param name="settings"></param>
+        /// <returns></returns>
+        [HttpPost("sonarr")]
+        public async Task<bool> Sonarr([FromBody] SonarrSettings settings)
+        {
+            try
+            {
+
+                var result = await SonarrApi.SystemStatus(settings.ApiKey, settings.FullUri);
+                return result.version != null;
+            }
+            catch (Exception e)
+            {
+                Log.LogError(LoggingEvents.Api, e, "Could not test Sonarr");
+                return false;
+            }
+        }
     }
 }

src/Ombi/Controllers/SettingsController.cs

@@ -3,6 +3,7 @@ using System.Collections.Generic;
 using System.Linq;
 using System.Threading.Tasks;
 using AutoMapper;
+using Hangfire;
 using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.Mvc;
 using Ombi.Api.Emby;
@@ -12,6 +13,9 @@ using Ombi.Core.Settings;
 using Ombi.Core.Settings.Models;
 using Ombi.Core.Settings.Models.External;
 using Ombi.Helpers;
+using Ombi.Schedule.Jobs;
+using Ombi.Schedule.Jobs.Emby;
+using Ombi.Schedule.Jobs.Radarr;
 using Ombi.Settings.Settings.Models;
 using Ombi.Settings.Settings.Models.External;
 using Ombi.Settings.Settings.Models.Notifications;
@@ -34,19 +38,30 @@ namespace Ombi.Controllers
         /// <param name="resolver">The resolver.</param>
         /// <param name="mapper">The mapper.</param>
         /// <param name="templateRepo">The templateRepo.</param>
-        public SettingsController(ISettingsResolver resolver, IMapper mapper, INotificationTemplatesRepository templateRepo,
+        public SettingsController(ISettingsResolver resolver, 
-            IEmbyApi embyApi)
+            IMapper mapper, 
+            INotificationTemplatesRepository templateRepo,
+            IEmbyApi embyApi,
+            IPlexContentCacher cacher,
+            IEmbyContentCacher embyCacher,
+            IRadarrCacher radarrCacher)
         {
             SettingsResolver = resolver;
             Mapper = mapper;
             TemplateRepository = templateRepo;
             _embyApi = embyApi;
+            _plexContentCacher = cacher;
+            _embyContentCacher = embyCacher;
+            _radarrCacher = radarrCacher;
         }
 
         private ISettingsResolver SettingsResolver { get; }
         private IMapper Mapper { get; }
         private INotificationTemplatesRepository TemplateRepository { get; }
         private readonly IEmbyApi _embyApi;
+        private readonly IPlexContentCacher _plexContentCacher;
+        private readonly IEmbyContentCacher _embyContentCacher;
+        private readonly IRadarrCacher _radarrCacher;
 
         /// <summary>
         /// Gets the Ombi settings.
@@ -66,6 +81,7 @@ namespace Ombi.Controllers
         [HttpPost("ombi")]
         public async Task<bool> OmbiSettings([FromBody]OmbiSettings ombi)
         {
+            ombi.Wizard = true;
             return await Save(ombi);
         }
 
@@ -97,7 +113,12 @@ namespace Ombi.Controllers
         [HttpPost("plex")]
         public async Task<bool> PlexSettings([FromBody]PlexSettings plex)
         {
-            return await Save(plex);
+            var result = await Save(plex);
+            if (result)
+            {
+                BackgroundJob.Enqueue(() => _plexContentCacher.CacheContent());
+            }
+            return result;
         }
 
         /// <summary>
@@ -124,7 +145,12 @@ namespace Ombi.Controllers
                 var admin = users.FirstOrDefault(x => x.Policy.IsAdministrator);
                 server.AdministratorId = admin?.Id;
             }
-            return await Save(emby);
+            var result = await Save(emby);
+            if (result)
+            {
+                BackgroundJob.Enqueue(() => _embyContentCacher.Start());
+            }
+            return result;
         }
 
         /// <summary>
@@ -231,7 +257,12 @@ namespace Ombi.Controllers
         [HttpPost("radarr")]
         public async Task<bool> RadarrSettings([FromBody]RadarrSettings settings)
         {
-            return await Save(settings);
+            var result = await Save(settings);
+            if (result)
+            {
+                BackgroundJob.Enqueue(() => _radarrCacher.CacheContent());
+            }
+            return result;
         }
 
         /// <summary>