github/Ombi
1
0
Fork 0
mirror of https://github.com/Ombi-app/Ombi.git synced 2025-07-12 08:16:05 -07:00
Code Issues Projects Releases Packages Wiki Activity Actions

WIP on notification resolver

Browse source
This commit is contained in:
tidusjar 2016-07-05 17:29:42 +01:00
parent ecf025d95b
commit d7f01dcbb5
6 changed files with 276 additions and 216 deletions
Download patch file Download diff file Expand all files Collapse all files

5
PlexRequests.Core.Tests/AuthenticationSettingsTests.cs
View file

@ -38,12 +38,13 @@ namespace PlexRequests.Core.Tests
public class NotificationMessageResolverTests public class NotificationMessageResolverTests
{ {
[TestCaseSource(nameof(MessageResolver))] [TestCaseSource(nameof(MessageResolver))]
public string Resolve(Dictionary<NotificationType, string> message, Dictionary<string,string> param) [Ignore("WIP")]
public NotificationMessageResolution Resolve(Dictionary<NotificationType, string> body, Dictionary<string,string> param)
{ {
var n = new NotificationMessageResolver(); var n = new NotificationMessageResolver();
var s = new NotificationSettings var s = new NotificationSettings
{ {
Message = message, Message = body,
CustomParamaters = param CustomParamaters = param
}; };

34
PlexRequests.Core/NotificationMessageResolution.cs Normal file
View file

@ -0,0 +1,34 @@
#region Copyright
// /************************************************************************
// Copyright (c) 2016 Jamie Rees
// File: NotificationMessageResolution.cs
// Created By: Jamie Rees
//
// Permission is hereby granted, free of charge, to any person obtaining
// a copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to
// permit persons to whom the Software is furnished to do so, subject to
// the following conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
// ************************************************************************/
#endregion
namespace PlexRequests.Core
{
public class NotificationMessageResolution
{
public string Subject { get; set; }
public string Body { get; set; }
}
}

33
PlexRequests.Core/NotificationMessageResolver.cs
View file

@ -36,30 +36,41 @@ namespace PlexRequests.Core
{ {
private const char StartChar = (char)123; private const char StartChar = (char)123;
private const char EndChar = (char)125; private const char EndChar = (char)125;
public string ParseMessage<T>(T notification, NotificationType type) where T : NotificationSettings public NotificationMessageResolution ParseMessage<T>(T notification, NotificationType type) where T : NotificationSettings
{ {
var notificationToParse = notification.Message.FirstOrDefault(x => x.Key == type).Value; var bodyToParse = notification.Message.FirstOrDefault(x => x.Key == type).Value;
if (string.IsNullOrEmpty(notificationToParse)) var subjectToParse = notification.Subject.FirstOrDefault(x => x.Key == type).Value;
return string.Empty; //if (string.IsNullOrEmpty(notificationToParse))
// return string.Empty;
return Resolve(notificationToParse, notification.CustomParamaters); return Resolve(bodyToParse, subjectToParse, notification.CustomParamaters);
} }
private string Resolve(string message, Dictionary<string,string> paramaters) private NotificationMessageResolution Resolve(string body, string subject, Dictionary<string, string> paramaters)
{ {
var fields = FindCurlyFields(message);
foreach (var f in fields) var bodyFields = FindCurlyFields(body);
var subjectFields = FindCurlyFields(subject);
foreach (var f in bodyFields)
{ {
string outString; string outString;
if (paramaters.TryGetValue(f, out outString)) if (paramaters.TryGetValue(f, out outString))
{ {
message = message.Replace($"{{{f}}}", outString); body = body.Replace($"{{{f}}}", outString);
} }
} }
return message; foreach (var s in subjectFields)
{
string outString;
if (paramaters.TryGetValue(s, out outString))
{
subject = subject.Replace($"{{{s}}}", outString);
}
}
return new NotificationMessageResolution { Body = body, Subject = subject };
} }
private IEnumerable<string> FindCurlyFields(string message) private IEnumerable<string> FindCurlyFields(string message)

1
PlexRequests.Core/PlexRequests.Core.csproj
View file

@ -71,6 +71,7 @@
</ItemGroup> </ItemGroup>
<ItemGroup> <ItemGroup>
<Compile Include="CacheKeys.cs" /> <Compile Include="CacheKeys.cs" />
<Compile Include="NotificationMessageResolution.cs" />
<Compile Include="NotificationMessageResolver.cs" /> <Compile Include="NotificationMessageResolver.cs" />
<Compile Include="IIssueService.cs" /> <Compile Include="IIssueService.cs" />
<Compile Include="IRequestService.cs" /> <Compile Include="IRequestService.cs" />

13
PlexRequests.Core/SettingModels/NotificationSettings.cs
View file

@ -32,7 +32,20 @@ namespace PlexRequests.Core.SettingModels
{ {
public class NotificationSettings : Settings public class NotificationSettings : Settings
{ {
public NotificationSettings()
{
CustomParamaters = new Dictionary<string, string>
{
{"Username", string.Empty },
{"Date", string.Empty },
{"Title", string.Empty },
{"RequestType", string.Empty },
{"Issue", string.Empty },
};
}
public Dictionary<NotificationType, string> Message { get; set; } public Dictionary<NotificationType, string> Message { get; set; }
public Dictionary<NotificationType, string> Subject { get; set; }
public Dictionary<string,string> CustomParamaters { get; set; } public Dictionary<string,string> CustomParamaters { get; set; }
} }
} }

406
PlexRequests.UI/Program.cs
View file

@ -1,203 +1,203 @@
#region Copyright #region Copyright
// /************************************************************************ // /************************************************************************
// Copyright (c) 2016 Jamie Rees // Copyright (c) 2016 Jamie Rees
// File: Program.cs // File: Program.cs
// Created By: Jamie Rees // Created By: Jamie Rees
// //
// Permission is hereby granted, free of charge, to any person obtaining // Permission is hereby granted, free of charge, to any person obtaining
// a copy of this software and associated documentation files (the // a copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including // "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish, // without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to // distribute, sublicense, and/or sell copies of the Software, and to
// permit persons to whom the Software is furnished to do so, subject to // permit persons to whom the Software is furnished to do so, subject to
// the following conditions: // the following conditions:
// //
// The above copyright notice and this permission notice shall be // The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software. // included in all copies or substantial portions of the Software.
// //
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
// ************************************************************************/ // ************************************************************************/
#endregion #endregion
using System; using System;
using Microsoft.Owin.Hosting; using Microsoft.Owin.Hosting;
using Mono.Data.Sqlite; using Mono.Data.Sqlite;
using Mono.Unix; using Mono.Unix;
using Mono.Unix.Native; using Mono.Unix.Native;
using NLog; using NLog;
using PlexRequests.Core; using PlexRequests.Core;
using PlexRequests.Core.SettingModels; using PlexRequests.Core.SettingModels;
using PlexRequests.Helpers; using PlexRequests.Helpers;
using PlexRequests.Store; using PlexRequests.Store;
using PlexRequests.Store.Repository; using PlexRequests.Store.Repository;
using System.Diagnostics; using System.Diagnostics;
using System.IO; using System.IO;
using System.Linq; using System.Linq;
using System.Windows.Forms; using System.Windows.Forms;
using CommandLine; using CommandLine;
using PlexRequests.UI.Start; using PlexRequests.UI.Start;
namespace PlexRequests.UI namespace PlexRequests.UI
{ {
class Program class Program
{ {
private static Logger Log = LogManager.GetCurrentClassLogger(); private static Logger Log = LogManager.GetCurrentClassLogger();
static void Main(string[] args) static void Main(string[] args)
{ {
var result = Parser.Default.ParseArguments<StartupOptions>(args); var result = Parser.Default.ParseArguments<StartupOptions>(args);
var baseUrl = result.MapResult( var baseUrl = result.MapResult(
o => o.BaseUrl, o => o.BaseUrl,
e => string.Empty); e => string.Empty);
var port = result.MapResult( var port = result.MapResult(
x => x.Port, x => x.Port,
e => -1); e => -1);
var updated = result.MapResult(x => x.Updated, e => UpdateValue.None); var updated = result.MapResult(x => x.Updated, e => UpdateValue.None);
CheckUpdate(updated); CheckUpdate(updated);
PrintToConsole("Starting Up! Please wait, this can usually take a few seconds.", ConsoleColor.Yellow); PrintToConsole("Starting Up! Please wait, this can usually take a few seconds.", ConsoleColor.Yellow);
Log.Trace("Getting product version"); Log.Trace("Getting product version");
WriteOutVersion(); WriteOutVersion();
var s = new Setup(); var s = new Setup();
var cn = s.SetupDb(baseUrl); var cn = s.SetupDb(baseUrl);
s.CacheQualityProfiles(); s.CacheQualityProfiles();
ConfigureTargets(cn); ConfigureTargets(cn);
SetupLogging(); SetupLogging();
if (port == -1 || port == 3579) if (port == -1 || port == 3579)
port = GetStartupPort(); port = GetStartupPort();
var options = new StartOptions(Debugger.IsAttached ? $"http://localhost:{port}" : $"http://+:{port}") var options = new StartOptions(Debugger.IsAttached ? $"http://localhost:{port}" : $"http://+:{port}")
{ {
ServerFactory = "Microsoft.Owin.Host.HttpListener" ServerFactory = "Microsoft.Owin.Host.HttpListener"
}; };
try try
{ {
using (WebApp.Start<Startup>(options)) using (WebApp.Start<Startup>(options))
{ {
Console.WriteLine($"Plex Requests is running on the following: http://+:{port}/{baseUrl}"); Console.WriteLine($"Plex Requests is running on the following: http://+:{port}/{baseUrl}");
PrintToConsole("All setup, Plex Requests is now ready!", ConsoleColor.Yellow); PrintToConsole("All setup, Plex Requests is now ready!", ConsoleColor.Yellow);
if (Type.GetType("Mono.Runtime") != null) if (Type.GetType("Mono.Runtime") != null)
{ {
Log.Info("We are on Mono!"); Log.Info("We are on Mono!");
// on mono, processes will usually run as daemons - this allows you to listen // on mono, processes will usually run as daemons - this allows you to listen
// for termination signals (ctrl+c, shutdown, etc) and finalize correctly // for termination signals (ctrl+c, shutdown, etc) and finalize correctly
UnixSignal.WaitAny( UnixSignal.WaitAny(
new[] { new UnixSignal(Signum.SIGINT), new UnixSignal(Signum.SIGTERM), new UnixSignal(Signum.SIGQUIT) }); new[] { new UnixSignal(Signum.SIGINT), new UnixSignal(Signum.SIGTERM), new UnixSignal(Signum.SIGQUIT) });
} }
else else
{ {
Log.Info("This is not Mono"); Log.Info("This is not Mono");
Console.WriteLine("Press any key to exit"); Console.WriteLine("Press any key to exit");
Console.ReadLine(); Console.ReadLine();
} }
} }
} }
catch (Exception e) catch (Exception e)
{ {
Log.Fatal(e); Log.Fatal(e);
Console.WriteLine(e); Console.WriteLine(e);
throw; throw;
} }
} }
private static void WriteOutVersion() private static void WriteOutVersion()
{ {
var assemblyVer = AssemblyHelper.GetProductVersion(); var assemblyVer = AssemblyHelper.GetProductVersion();
Log.Info($"Version: {assemblyVer}"); Log.Info($"Version: {assemblyVer}");
Console.WriteLine($"Version: {assemblyVer}"); Console.WriteLine($"Version: {assemblyVer}");
} }
private static int GetStartupPort() private static int GetStartupPort()
{ {
Log.Trace("Getting startup Port"); Log.Trace("Getting startup Port");
var port = 3579; var port = 3579;
var service = new SettingsServiceV2<PlexRequestSettings>(new SettingsJsonRepository(new DbConfiguration(new SqliteFactory()), new MemoryCacheProvider())); var service = new SettingsServiceV2<PlexRequestSettings>(new SettingsJsonRepository(new DbConfiguration(new SqliteFactory()), new MemoryCacheProvider()));
var settings = service.GetSettings(); var settings = service.GetSettings();
Log.Trace("Port: {0}", settings.Port); Log.Trace("Port: {0}", settings.Port);
if (settings.Port != 0) if (settings.Port != 0)
{ {
port = settings.Port; port = settings.Port;
} }
return port; return port;
} }
private static void ConfigureTargets(string connectionString) private static void ConfigureTargets(string connectionString)
{ {
LoggingHelper.ConfigureLogging(connectionString); LoggingHelper.ConfigureLogging(connectionString);
} }
private static void SetupLogging() private static void SetupLogging()
{ {
var settingsService = new SettingsServiceV2<LogSettings>(new SettingsJsonRepository(new DbConfiguration(new SqliteFactory()), new MemoryCacheProvider())); var settingsService = new SettingsServiceV2<LogSettings>(new SettingsJsonRepository(new DbConfiguration(new SqliteFactory()), new MemoryCacheProvider()));
var logSettings = settingsService.GetSettings(); var logSettings = settingsService.GetSettings();
if (logSettings != null) if (logSettings != null)
{ {
LoggingHelper.ReconfigureLogLevel(LogLevel.FromOrdinal(logSettings.Level)); LoggingHelper.ReconfigureLogLevel(LogLevel.FromOrdinal(logSettings.Level));
} }
} }
private static void PrintToConsole(string message, ConsoleColor colour = ConsoleColor.Gray) private static void PrintToConsole(string message, ConsoleColor colour = ConsoleColor.Gray)
{ {
Console.ForegroundColor = colour; Console.ForegroundColor = colour;
Console.WriteLine(message); Console.WriteLine(message);
Console.ForegroundColor = ConsoleColor.Gray; Console.ForegroundColor = ConsoleColor.Gray;
} }
private static void CheckUpdate(UpdateValue val) private static void CheckUpdate(UpdateValue val)
{ {
if (val == UpdateValue.Failed) if (val == UpdateValue.Failed)
{ {
PrintToConsole("Update Failed", ConsoleColor.Red); PrintToConsole("Update Failed", ConsoleColor.Red);
} }
if (val == UpdateValue.Updated) if (val == UpdateValue.Updated)
{ {
PrintToConsole("Finishing Update", ConsoleColor.Yellow); PrintToConsole("Finishing Update", ConsoleColor.Yellow);
var applicationPath = Path.Combine(Path.GetDirectoryName(Application.ExecutablePath)); var applicationPath = Path.Combine(Path.GetDirectoryName(Application.ExecutablePath));
var files = Directory.GetFiles(applicationPath, "PlexRequests.*", SearchOption.TopDirectoryOnly); var files = Directory.GetFiles(applicationPath, "PlexRequests.*", SearchOption.TopDirectoryOnly);
var oldUpdater = files.FirstOrDefault(x => x == $"{applicationPath}\\PlexRequests.Updater.exe"); var oldUpdater = files.FirstOrDefault(x => x == $"{applicationPath}\\PlexRequests.Updater.exe");
var newUpdater = files.FirstOrDefault(x => x == $"{applicationPath}\\PlexRequests.Updater.exe_Updated"); var newUpdater = files.FirstOrDefault(x => x == $"{applicationPath}\\PlexRequests.Updater.exe_Updated");
if (oldUpdater == null || newUpdater == null) if (oldUpdater == null || newUpdater == null)
{ {
PrintToConsole("Looks like there was nothing to update.", ConsoleColor.Yellow); PrintToConsole("Looks like there was nothing to update.", ConsoleColor.Yellow);
return; return;
} }
try try
{ {
File.Copy(oldUpdater, "PlexRequests.Updater.exe_Old", true); File.Copy(oldUpdater, "PlexRequests.Updater.exe_Old", true);
File.Delete(oldUpdater); File.Delete(oldUpdater);
File.Copy(newUpdater, "PlexRequests.Updater.exe", true); File.Copy(newUpdater, "PlexRequests.Updater.exe", true);
File.Delete(newUpdater); File.Delete(newUpdater);
File.Delete("PlexRequests.Updater.exe_Old"); // Cleanup File.Delete("PlexRequests.Updater.exe_Old"); // Cleanup
} }
catch (Exception e) catch (Exception e)
{ {
Console.WriteLine(e.Message); Console.WriteLine(e.Message);
} }
PrintToConsole("Finished Update!", ConsoleColor.Yellow); PrintToConsole("Finished Update!", ConsoleColor.Yellow);
} }
} }
} }
} }