Added settings

Mpv.JsonIpc/Api.cs

@@ -24,5 +24,11 @@ public async Task<float> GetVolume()
             var result = await _ipc.GetProperty<float>(Property.Volume);
             return result.Data;
         }
+
+        public async Task PlayMedia(string path)
+        {
+            var request = _ipc.CreateCommand(new[] {"loadfile", path});
+            await _ipc.ExecuteCommand<string>(request);
+        }
     }
 }

Mpv.JsonIpc/IApi.cs

@@ -7,5 +7,6 @@ public interface IApi
     {
         Task        ShowText(string text, TimeSpan duration);
         Task<float> GetVolume();
+        Task PlayMedia(string path);
     }
 }

Mpv.JsonIpc/Ipc.cs

@@ -1,4 +1,3 @@
-
 using System;
 using System.Collections.Generic;
 using System.Linq;
@@ -15,45 +14,45 @@ public Ipc(IManager manager)
             _manager = manager;
         }
 
-        public async Task<Response<T>> ExecuteCommand<T>(Request request)
-        {
-            return await _manager.Execute<T>(request);
-        }
-
         public async Task<Response<T>> GetProperty<T>(Property property, params string[] args)
         {
             var request = CreateCommand(new[] {"get_property", property.GetStringValue()}, args);
-            return await _manager.Execute<T>(request);
+            return await ExecuteCommand<T>(request);
         }
 
         public async Task<Response<T>> SetProperty<T>(Property property, params object[] args)
         {
             var request = CreateCommand(new[] {"set_property", property.GetStringValue()}, args);
-            return await _manager.Execute<T>(request);
+            return await ExecuteCommand<T>(request);
         }
 
         public async Task<Response<T>> SetPropertyString<T>(Property property, params string[] args)
         {
             var request = CreateCommand(new[] {"set_property_string", property.GetStringValue()}, args);
-            return await _manager.Execute<T>(request);
+            return await ExecuteCommand<T>(request);
         }
 
         public async Task<Response<T>> CycleProperty<T>(Property property)
         {
             var request = CreateCommand(new[] {"cycle", property.GetStringValue()});
-            return await _manager.Execute<T>(request);
+            return await ExecuteCommand<T>(request);
         }
 
         public Request CreateCommand(IEnumerable<object> command)
         {
             return CreateCommand(command, Array.Empty<object>());
         }
-        
+
         public Request CreateCommand(IEnumerable<object> command, object arg)
         {
             return CreateCommand(command, new[] {arg});
         }
 
+        public async Task<Response<T>> ExecuteCommand<T>(Request request)
+        {
+            return await _manager.Execute<T>(request);
+        }
+
         public Request CreateCommand(IEnumerable<object> command, IEnumerable<object> args)
         {
             return new Request

Mpv.JsonIpc/Manager.cs

@@ -10,21 +10,24 @@ namespace Mpv.JsonIpc
     public sealed class Manager : IDisposable, IManager
     {
         private readonly NamedPipeClientStream _pipe;
-        private readonly StreamReader          _pipeIn;
 
-        private readonly StreamWriter _pipeOut;
+        private StreamReader _pipeIn;
+        private StreamWriter _pipeOut;
 
         public Manager(INamedPipeFactory pipeFactory)
         {
             _pipe = pipeFactory.CreateNamedPipe();
-            _pipe.Connect();
-
-            _pipeIn = new StreamReader(_pipe);
-            _pipeOut = new StreamWriter(_pipe) {AutoFlush = true};
         }
 
         public async Task<Response<T>> Execute<T>(Request message)
         {
+            if (!_pipe.IsConnected)
+            {
+                _pipe.Connect();
+                _pipeIn = new StreamReader(_pipe);
+                _pipeOut = new StreamWriter(_pipe) {AutoFlush = true};
+            }
+
             var messageToSend = JsonConvert.SerializeObject(message);
             Console.WriteLine(messageToSend);
             _pipeOut.WriteLine(messageToSend);

Mpv.JsonIpc/NamedPipeFactory.cs

@@ -12,7 +12,7 @@ public NamedPipeClientStream CreateNamedPipe()
             return new NamedPipeClientStream(".", pipeName, PipeDirection.InOut, PipeOptions.Asynchronous, TokenImpersonationLevel.Anonymous);
         }
 
-        private static string GetPipeNameForCurrentOs()
+        public static string GetPipeNameForCurrentOs()
         {
             const string linuxOrMacPipeName = "/tmp/mpvsocket";
             const string windowsPipeName = "mpvpipe";

SnackTime.Core/Database/DatabaseFactory.cs

@@ -0,0 +1,14 @@
+using LiteDB;
+
+namespace SnackTime.Core.Database
+{
+    public class DatabaseFactory
+    {
+        private const string ConnectionString = "MediaDb";
+
+        public LiteDatabase CreateDatabase()
+        {
+            return new LiteDatabase(ConnectionString);
+        }
+    }
+}

SnackTime.Core/DependencyModule.cs

@@ -1,4 +1,7 @@
 using Autofac;
+using SnackTime.Core.Database;
+using SnackTime.Core.Process;
+using SnackTime.Core.Settings;
 using SonarrSharp;
 
 namespace SnackTime.Core
@@ -16,6 +19,13 @@ protected override void Load(ContainerBuilder builder)
         {
             var sonarrClient = new SonarrClient(_sonarrConfig.Host, _sonarrConfig.Port, _sonarrConfig.ApiKey);
             builder.RegisterInstance(sonarrClient).As<SonarrClient>();
+
+            builder.RegisterType<DatabaseFactory>().AsSelf();
+
+            builder.RegisterType<SettingsService>().AsSelf();
+            builder.RegisterType<SettingsRepo>().AsSelf();
+
+            builder.RegisterType<ProcessManager>().As<IProcessManager>().SingleInstance();
         }
 
         public class SonarrConfig

SnackTime.Core/Process/IProcessManager.cs

@@ -0,0 +1,9 @@
+namespace SnackTime.Core.Process
+{
+    public interface IProcessManager
+    {
+        void StartProcess(string path, string[] args = null);
+        bool IsProcessRunning(string path);
+        void StopProcess(string path);
+    }
+}

SnackTime.Core/Process/ProcessManager.cs

@@ -0,0 +1,40 @@
+using System.Collections.Generic;
+
+namespace SnackTime.Core.Process
+{
+    public class ProcessManager : IProcessManager
+    {
+        private readonly Dictionary<string, System.Diagnostics.Process> _process;
+
+        public ProcessManager()
+        {
+            _process = new Dictionary<string, System.Diagnostics.Process>();
+        }
+
+
+        public void StartProcess(string path, string[] args = null)
+        {
+            if (IsProcessRunning(path)) return;
+
+            var process = System.Diagnostics.Process.Start(path, string.Join(" ", args));
+            _process.Add(path, process);
+        }
+
+        public bool IsProcessRunning(string path)
+        {
+            if (!_process.ContainsKey(path))
+                return false;
+
+            if (!_process[path].HasExited) return true;
+
+            _process.Remove(path);
+            return false;
+        }
+
+        public void StopProcess(string path)
+        {
+            if (IsProcessRunning(path))
+                _process[path].Kill();
+        }
+    }
+}

SnackTime.Core/Settings/SettingsService.cs

@@ -0,0 +1,71 @@
+using System.Linq;
+using SnackTime.Core.Database;
+
+namespace SnackTime.Core.Settings
+{
+    public class SettingsService
+    {
+        private readonly SettingsRepo _settingsRepo;
+
+        public SettingsService(SettingsRepo settingsRepo)
+        {
+            _settingsRepo = settingsRepo;
+        }
+
+        public void Save(Settings settings)
+        {
+            _settingsRepo.Save(settings);
+        }
+
+        public Settings Get()
+        {
+            return _settingsRepo.Get() ?? new Settings();
+        }
+    }
+
+    public class SettingsRepo
+    {
+        private const string CollectionName = "settxigns";
+
+        private readonly DatabaseFactory _databaseFactory;
+
+        public SettingsRepo(DatabaseFactory databaseFactory)
+        {
+            _databaseFactory = databaseFactory;
+        }
+
+        public void Save(Settings settings)
+        {
+            settings.Id = 1;
+            using (var db = _databaseFactory.CreateDatabase())
+            {
+                var collection = db.GetCollection<Settings>(CollectionName);
+                collection.Upsert(settings);
+            }
+        }
+
+        public Settings Get()
+        {
+            using (var db = _databaseFactory.CreateDatabase())
+            {
+                var collection = db.GetCollection<Settings>(CollectionName);
+                return collection.FindAll().FirstOrDefault();
+            }
+        }
+    }
+
+
+    public class Settings : DbEntity
+    {
+        public string MpvPath { get; set; }
+        public string SvpPath { get; set; }
+
+        public string SonarrAddress { get; set; }
+        public string RadarrAddress { get; set; }
+    }
+
+    public abstract class DbEntity
+    {
+        public int Id { get; set; }
+    }
+}

SnackTime.Core/SnackTime.Core.csproj

@@ -11,6 +11,7 @@
         <PackageReference Include="Autofac">
             <Version>4.9.1</Version>
         </PackageReference>
+        <PackageReference Include="LiteDB" Version="4.1.4" />
         <PackageReference Include="SonarrSharp">
             <Version>1.2.1</Version>
         </PackageReference>

SnackTime.WebApi/Controllers/EpisodeController.cs

@@ -1,6 +1,7 @@
 using System.Threading.Tasks;
 using Microsoft.AspNetCore.Mvc;
 using SnackTime.Core.Episodes;
+using SnackTime.WebApi.Helpers;
 using SonarrSharp;
 
 namespace SnackTime.WebApi.Controllers

SnackTime.WebApi/Controllers/RemoteController.cs

@@ -1,18 +1,21 @@
 using System;
 using Microsoft.AspNetCore.Mvc;
 using Mpv.JsonIpc;
+using SnackTime.Core.Process;
 
 namespace SnackTime.WebApi.Controllers
 {
     [Route("api/[controller]/v1")]
     [ApiController]
     public class Remote : ControllerBase
     {
-        private readonly IApi _api;
+        private readonly IApi            _api;
+        private readonly IProcessManager _processManager;
 
-        public Remote(IApi api)
+        public Remote(IApi api, IProcessManager processManager)
         {
             _api = api;
+            _processManager = processManager;
         }
 
         [HttpPost("toggle")]
@@ -22,5 +25,25 @@ public ActionResult Post()
 
             return Ok();
         }
+
+        [HttpGet("play")]
+        public ActionResult PlayMedia()
+        {
+            var path = "C:\\Program Files (x86)\\SVP 4\\mpv64\\mpv.exe";
+            var arguments = new[] {$"--input-ipc-server={NamedPipeFactory.GetPipeNameForCurrentOs()}"};
+
+            if (_processManager.IsProcessRunning(path))
+            {
+                return BadRequest($"Process {path} already running");
+            }
+
+            _processManager.StartProcess(path, arguments);
+
+            _api.ShowText("Started", TimeSpan.FromSeconds(2));
+
+            _api.PlayMedia(@"D:\Downloads\TorrentDay\Blue Planet II\Season 1\Blue Planet II - S01E04 - Big Blue WEBDL-1080p.mkv");
+
+            return Ok();
+        }
     }
 }