github/Ombi
1
0
Fork 0
mirror of https://github.com/Ombi-app/Ombi.git synced 2025-07-14 17:22:54 -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
{
[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 s = new NotificationSettings
{
Message = message,
Message = body,
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 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;
if (string.IsNullOrEmpty(notificationToParse))
return string.Empty;
var bodyToParse = notification.Message.FirstOrDefault(x => x.Key == type).Value;
var subjectToParse = notification.Subject.FirstOrDefault(x => x.Key == type).Value;
//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;
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)

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

@ -71,6 +71,7 @@
</ItemGroup>
<ItemGroup>
<Compile Include="CacheKeys.cs" />
<Compile Include="NotificationMessageResolution.cs" />
<Compile Include="NotificationMessageResolver.cs" />
<Compile Include="IIssueService.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 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> Subject { get; set; }
public Dictionary<string,string> CustomParamaters { get; set; }
}
}

406
PlexRequests.UI/Program.cs
View file

@ -1,203 +1,203 @@
#region Copyright
// /************************************************************************
// Copyright (c) 2016 Jamie Rees
// File: Program.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
using System;
using Microsoft.Owin.Hosting;
using Mono.Data.Sqlite;
using Mono.Unix;
using Mono.Unix.Native;
using NLog;
using PlexRequests.Core;
using PlexRequests.Core.SettingModels;
using PlexRequests.Helpers;
using PlexRequests.Store;
using PlexRequests.Store.Repository;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Windows.Forms;
using CommandLine;
using PlexRequests.UI.Start;
namespace PlexRequests.UI
{
class Program
{
private static Logger Log = LogManager.GetCurrentClassLogger();
static void Main(string[] args)
{
var result = Parser.Default.ParseArguments<StartupOptions>(args);
var baseUrl = result.MapResult(
o => o.BaseUrl,
e => string.Empty);
var port = result.MapResult(
x => x.Port,
e => -1);
var updated = result.MapResult(x => x.Updated, e => UpdateValue.None);
CheckUpdate(updated);
PrintToConsole("Starting Up! Please wait, this can usually take a few seconds.", ConsoleColor.Yellow);
Log.Trace("Getting product version");
WriteOutVersion();
var s = new Setup();
var cn = s.SetupDb(baseUrl);
s.CacheQualityProfiles();
ConfigureTargets(cn);
SetupLogging();
if (port == -1 || port == 3579)
port = GetStartupPort();
var options = new StartOptions(Debugger.IsAttached ? $"http://localhost:{port}" : $"http://+:{port}")
{
ServerFactory = "Microsoft.Owin.Host.HttpListener"
};
try
{
using (WebApp.Start<Startup>(options))
{
Console.WriteLine($"Plex Requests is running on the following: http://+:{port}/{baseUrl}");
PrintToConsole("All setup, Plex Requests is now ready!", ConsoleColor.Yellow);
if (Type.GetType("Mono.Runtime") != null)
{
Log.Info("We are on Mono!");
// on mono, processes will usually run as daemons - this allows you to listen
// for termination signals (ctrl+c, shutdown, etc) and finalize correctly
UnixSignal.WaitAny(
new[] { new UnixSignal(Signum.SIGINT), new UnixSignal(Signum.SIGTERM), new UnixSignal(Signum.SIGQUIT) });
}
else
{
Log.Info("This is not Mono");
Console.WriteLine("Press any key to exit");
Console.ReadLine();
}
}
}
catch (Exception e)
{
Log.Fatal(e);
Console.WriteLine(e);
throw;
}
}
private static void WriteOutVersion()
{
var assemblyVer = AssemblyHelper.GetProductVersion();
Log.Info($"Version: {assemblyVer}");
Console.WriteLine($"Version: {assemblyVer}");
}
private static int GetStartupPort()
{
Log.Trace("Getting startup Port");
var port = 3579;
var service = new SettingsServiceV2<PlexRequestSettings>(new SettingsJsonRepository(new DbConfiguration(new SqliteFactory()), new MemoryCacheProvider()));
var settings = service.GetSettings();
Log.Trace("Port: {0}", settings.Port);
if (settings.Port != 0)
{
port = settings.Port;
}
return port;
}
private static void ConfigureTargets(string connectionString)
{
LoggingHelper.ConfigureLogging(connectionString);
}
private static void SetupLogging()
{
var settingsService = new SettingsServiceV2<LogSettings>(new SettingsJsonRepository(new DbConfiguration(new SqliteFactory()), new MemoryCacheProvider()));
var logSettings = settingsService.GetSettings();
if (logSettings != null)
{
LoggingHelper.ReconfigureLogLevel(LogLevel.FromOrdinal(logSettings.Level));
}
}
private static void PrintToConsole(string message, ConsoleColor colour = ConsoleColor.Gray)
{
Console.ForegroundColor = colour;
Console.WriteLine(message);
Console.ForegroundColor = ConsoleColor.Gray;
}
private static void CheckUpdate(UpdateValue val)
{
if (val == UpdateValue.Failed)
{
PrintToConsole("Update Failed", ConsoleColor.Red);
}
if (val == UpdateValue.Updated)
{
PrintToConsole("Finishing Update", ConsoleColor.Yellow);
var applicationPath = Path.Combine(Path.GetDirectoryName(Application.ExecutablePath));
var files = Directory.GetFiles(applicationPath, "PlexRequests.*", SearchOption.TopDirectoryOnly);
var oldUpdater = files.FirstOrDefault(x => x == $"{applicationPath}\\PlexRequests.Updater.exe");
var newUpdater = files.FirstOrDefault(x => x == $"{applicationPath}\\PlexRequests.Updater.exe_Updated");
if (oldUpdater == null || newUpdater == null)
{
PrintToConsole("Looks like there was nothing to update.", ConsoleColor.Yellow);
return;
}
try
{
File.Copy(oldUpdater, "PlexRequests.Updater.exe_Old", true);
File.Delete(oldUpdater);
File.Copy(newUpdater, "PlexRequests.Updater.exe", true);
File.Delete(newUpdater);
File.Delete("PlexRequests.Updater.exe_Old"); // Cleanup
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
PrintToConsole("Finished Update!", ConsoleColor.Yellow);
}
}
}
}
#region Copyright
// /************************************************************************
// Copyright (c) 2016 Jamie Rees
// File: Program.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
using System;
using Microsoft.Owin.Hosting;
using Mono.Data.Sqlite;
using Mono.Unix;
using Mono.Unix.Native;
using NLog;
using PlexRequests.Core;
using PlexRequests.Core.SettingModels;
using PlexRequests.Helpers;
using PlexRequests.Store;
using PlexRequests.Store.Repository;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Windows.Forms;
using CommandLine;
using PlexRequests.UI.Start;
namespace PlexRequests.UI
{
class Program
{
private static Logger Log = LogManager.GetCurrentClassLogger();
static void Main(string[] args)
{
var result = Parser.Default.ParseArguments<StartupOptions>(args);
var baseUrl = result.MapResult(
o => o.BaseUrl,
e => string.Empty);
var port = result.MapResult(
x => x.Port,
e => -1);
var updated = result.MapResult(x => x.Updated, e => UpdateValue.None);
CheckUpdate(updated);
PrintToConsole("Starting Up! Please wait, this can usually take a few seconds.", ConsoleColor.Yellow);
Log.Trace("Getting product version");
WriteOutVersion();
var s = new Setup();
var cn = s.SetupDb(baseUrl);
s.CacheQualityProfiles();
ConfigureTargets(cn);
SetupLogging();
if (port == -1 || port == 3579)
port = GetStartupPort();
var options = new StartOptions(Debugger.IsAttached ? $"http://localhost:{port}" : $"http://+:{port}")
{
ServerFactory = "Microsoft.Owin.Host.HttpListener"
};
try
{
using (WebApp.Start<Startup>(options))
{
Console.WriteLine($"Plex Requests is running on the following: http://+:{port}/{baseUrl}");
PrintToConsole("All setup, Plex Requests is now ready!", ConsoleColor.Yellow);
if (Type.GetType("Mono.Runtime") != null)
{
Log.Info("We are on Mono!");
// on mono, processes will usually run as daemons - this allows you to listen
// for termination signals (ctrl+c, shutdown, etc) and finalize correctly
UnixSignal.WaitAny(
new[] { new UnixSignal(Signum.SIGINT), new UnixSignal(Signum.SIGTERM), new UnixSignal(Signum.SIGQUIT) });
}
else
{
Log.Info("This is not Mono");
Console.WriteLine("Press any key to exit");
Console.ReadLine();
}
}
}
catch (Exception e)
{
Log.Fatal(e);
Console.WriteLine(e);
throw;
}
}
private static void WriteOutVersion()
{
var assemblyVer = AssemblyHelper.GetProductVersion();
Log.Info($"Version: {assemblyVer}");
Console.WriteLine($"Version: {assemblyVer}");
}
private static int GetStartupPort()
{
Log.Trace("Getting startup Port");
var port = 3579;
var service = new SettingsServiceV2<PlexRequestSettings>(new SettingsJsonRepository(new DbConfiguration(new SqliteFactory()), new MemoryCacheProvider()));
var settings = service.GetSettings();
Log.Trace("Port: {0}", settings.Port);
if (settings.Port != 0)
{
port = settings.Port;
}
return port;
}
private static void ConfigureTargets(string connectionString)
{
LoggingHelper.ConfigureLogging(connectionString);
}
private static void SetupLogging()
{
var settingsService = new SettingsServiceV2<LogSettings>(new SettingsJsonRepository(new DbConfiguration(new SqliteFactory()), new MemoryCacheProvider()));
var logSettings = settingsService.GetSettings();
if (logSettings != null)
{
LoggingHelper.ReconfigureLogLevel(LogLevel.FromOrdinal(logSettings.Level));
}
}
private static void PrintToConsole(string message, ConsoleColor colour = ConsoleColor.Gray)
{
Console.ForegroundColor = colour;
Console.WriteLine(message);
Console.ForegroundColor = ConsoleColor.Gray;
}
private static void CheckUpdate(UpdateValue val)
{
if (val == UpdateValue.Failed)
{
PrintToConsole("Update Failed", ConsoleColor.Red);
}
if (val == UpdateValue.Updated)
{
PrintToConsole("Finishing Update", ConsoleColor.Yellow);
var applicationPath = Path.Combine(Path.GetDirectoryName(Application.ExecutablePath));
var files = Directory.GetFiles(applicationPath, "PlexRequests.*", SearchOption.TopDirectoryOnly);
var oldUpdater = files.FirstOrDefault(x => x == $"{applicationPath}\\PlexRequests.Updater.exe");
var newUpdater = files.FirstOrDefault(x => x == $"{applicationPath}\\PlexRequests.Updater.exe_Updated");
if (oldUpdater == null || newUpdater == null)
{
PrintToConsole("Looks like there was nothing to update.", ConsoleColor.Yellow);
return;
}
try
{
File.Copy(oldUpdater, "PlexRequests.Updater.exe_Old", true);
File.Delete(oldUpdater);
File.Copy(newUpdater, "PlexRequests.Updater.exe", true);
File.Delete(newUpdater);
File.Delete("PlexRequests.Updater.exe_Old"); // Cleanup
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
PrintToConsole("Finished Update!", ConsoleColor.Yellow);
}
}
}
}