github/Ombi
1
0
Fork 0
mirror of https://github.com/Ombi-app/Ombi.git synced 2025-07-10 15:32:37 -07:00
Code Issues Projects Releases Packages Wiki Activity Actions

Async async async improvements.

Browse source
This commit is contained in:
tidusjar 2016-07-29 16:50:35 +01:00
parent 236024e4ae
commit b3e90c7a7f
19 changed files with 785 additions and 755 deletions
Download patch file Download diff file Expand all files Collapse all files

12
PlexRequests.Api/RetryHandler.cs
View file

@ -33,13 +33,13 @@ namespace PlexRequests.Api
{ {
public static class RetryHandler public static class RetryHandler
{ {
private static readonly TimeSpan[] DefaultTime = { TimeSpan.FromSeconds(2), TimeSpan.FromSeconds(5), TimeSpan.FromSeconds(10) }; private static readonly TimeSpan[] DefaultRetryTime = { TimeSpan.FromSeconds(2), TimeSpan.FromSeconds(5), TimeSpan.FromSeconds(10) };
public static T Execute<T>(Func<T> action, TimeSpan[] timeSpan = null) public static T Execute<T>(Func<T> action, TimeSpan[] timeSpan = null)
{ {
if (timeSpan == null) if (timeSpan == null)
{ {
timeSpan = DefaultTime; timeSpan = DefaultRetryTime;
} }
var policy = RetryAndWaitPolicy(timeSpan); var policy = RetryAndWaitPolicy(timeSpan);
@ -50,7 +50,7 @@ namespace PlexRequests.Api
{ {
if (timeSpan == null) if (timeSpan == null)
{ {
timeSpan = DefaultTime; timeSpan = DefaultRetryTime;
} }
var policy = RetryAndWaitPolicy(action, timeSpan); var policy = RetryAndWaitPolicy(action, timeSpan);
@ -61,7 +61,7 @@ namespace PlexRequests.Api
{ {
if (timeSpan == null) if (timeSpan == null)
{ {
timeSpan = DefaultTime; timeSpan = DefaultRetryTime;
} }
var policy = Policy.Handle<Exception>().WaitAndRetry(timeSpan, (e, ts) => action()); var policy = Policy.Handle<Exception>().WaitAndRetry(timeSpan, (e, ts) => action());
@ -72,7 +72,7 @@ namespace PlexRequests.Api
{ {
if (timeSpan == null) if (timeSpan == null)
{ {
timeSpan = DefaultTime; timeSpan = DefaultRetryTime;
} }
var policy = Policy.Handle<Exception>().WaitAndRetry(timeSpan); var policy = Policy.Handle<Exception>().WaitAndRetry(timeSpan);
@ -83,7 +83,7 @@ namespace PlexRequests.Api
{ {
if (timeSpan == null) if (timeSpan == null)
{ {
timeSpan = DefaultTime; timeSpan = DefaultRetryTime;
} }
var policy = Policy.Handle<Exception>().WaitAndRetry(timeSpan, action); var policy = Policy.Handle<Exception>().WaitAndRetry(timeSpan, action);

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

@ -30,6 +30,7 @@ using System.Collections.Generic;
using NUnit.Framework; using NUnit.Framework;
using PlexRequests.Core.Models; using PlexRequests.Core.Models;
using PlexRequests.Core.Notification;
using PlexRequests.Core.SettingModels; using PlexRequests.Core.SettingModels;
namespace PlexRequests.Core.Tests namespace PlexRequests.Core.Tests
@ -43,7 +44,7 @@ namespace PlexRequests.Core.Tests
var n = new NotificationMessageResolver(); var n = new NotificationMessageResolver();
var s = new NotificationSettings var s = new NotificationSettings
{ {
Message = new List<NotificationMessage> { new NotificationMessage { NotificationType = NotificationType.NewRequest, Body = body } } Message = new List<Notification.NotificationMessage> { new Notification.NotificationMessage { NotificationType = NotificationType.NewRequest, Body = body } }
}; };
var result = n.ParseMessage(s, NotificationType.NewRequest, param); var result = n.ParseMessage(s, NotificationType.NewRequest, param);
@ -56,7 +57,7 @@ namespace PlexRequests.Core.Tests
var n = new NotificationMessageResolver(); var n = new NotificationMessageResolver();
var s = new NotificationSettings var s = new NotificationSettings
{ {
Message = new List<NotificationMessage> { new NotificationMessage { NotificationType = NotificationType.NewRequest, Subject = subject }} Message = new List<Notification.NotificationMessage> { new Notification.NotificationMessage { NotificationType = NotificationType.NewRequest, Subject = subject }}
}; };
var result = n.ParseMessage(s, NotificationType.NewRequest, param); var result = n.ParseMessage(s, NotificationType.NewRequest, param);

10
PlexRequests.Core/JsonIssuesModelRequestService.cs
View file

@ -53,7 +53,7 @@ namespace PlexRequests.Core
model.Id = id; model.Id = id;
entity = new IssueBlobs { Type = model.Type, Content = ByteConverterHelper.ReturnBytes(model), RequestId = model.RequestId, Id = id }; entity = new IssueBlobs { Type = model.Type, Content = ByteConverterHelper.ReturnBytes(model), RequestId = model.RequestId, Id = id };
var result = await Repo.UpdateAsync(entity); var result = await Repo.UpdateAsync(entity).ConfigureAwait(false);
return result ? id : -1; return result ? id : -1;
} }
@ -61,21 +61,21 @@ namespace PlexRequests.Core
public async Task<bool> UpdateIssueAsync(IssuesModel model) public async Task<bool> UpdateIssueAsync(IssuesModel model)
{ {
var entity = new IssueBlobs { Type = model.Type, Content = ByteConverterHelper.ReturnBytes(model), RequestId = model.RequestId, Id = model.Id }; var entity = new IssueBlobs { Type = model.Type, Content = ByteConverterHelper.ReturnBytes(model), RequestId = model.RequestId, Id = model.Id };
return await Repo.UpdateAsync(entity); return await Repo.UpdateAsync(entity).ConfigureAwait(false);
} }
public async Task DeleteIssueAsync(int id) public async Task DeleteIssueAsync(int id)
{ {
var entity = await Repo.GetAsync(id); var entity = await Repo.GetAsync(id);
await Repo.DeleteAsync(entity); await Repo.DeleteAsync(entity).ConfigureAwait(false);
} }
public async Task DeleteIssueAsync(IssuesModel model) public async Task DeleteIssueAsync(IssuesModel model)
{ {
var entity = new IssueBlobs { Type = model.Type, Content = ByteConverterHelper.ReturnBytes(model), RequestId = model.RequestId, Id = model.Id }; var entity = new IssueBlobs { Type = model.Type, Content = ByteConverterHelper.ReturnBytes(model), RequestId = model.RequestId, Id = model.Id };
await Repo.DeleteAsync(entity); await Repo.DeleteAsync(entity).ConfigureAwait(false);
} }
/// <summary> /// <summary>
@ -101,7 +101,7 @@ namespace PlexRequests.Core
/// <returns></returns> /// <returns></returns>
public async Task<IEnumerable<IssuesModel>> GetAllAsync() public async Task<IEnumerable<IssuesModel>> GetAllAsync()
{ {
var blobs = await Repo.GetAllAsync(); var blobs = await Repo.GetAllAsync().ConfigureAwait(false);
if (blobs == null) if (blobs == null)
{ {

22
PlexRequests.Core/JsonRequestModelRequestService.cs
View file

@ -61,12 +61,12 @@ namespace PlexRequests.Core
public async Task<int> AddRequestAsync(RequestedModel model) public async Task<int> AddRequestAsync(RequestedModel model)
{ {
var entity = new RequestBlobs { Type = model.Type, Content = ByteConverterHelper.ReturnBytes(model), ProviderId = model.ProviderId }; var entity = new RequestBlobs { Type = model.Type, Content = ByteConverterHelper.ReturnBytes(model), ProviderId = model.ProviderId };
var id = await Repo.InsertAsync(entity); var id = await Repo.InsertAsync(entity).ConfigureAwait(false);
model.Id = id; model.Id = id;
entity = new RequestBlobs { Type = model.Type, Content = ByteConverterHelper.ReturnBytes(model), ProviderId = model.ProviderId, Id = id, MusicId = model.MusicBrainzId }; entity = new RequestBlobs { Type = model.Type, Content = ByteConverterHelper.ReturnBytes(model), ProviderId = model.ProviderId, Id = id, MusicId = model.MusicBrainzId };
var result = await Repo.UpdateAsync(entity); var result = await Repo.UpdateAsync(entity).ConfigureAwait(false);
return result ? id : -1; return result ? id : -1;
} }
@ -80,7 +80,7 @@ namespace PlexRequests.Core
public async Task<RequestedModel> CheckRequestAsync(int providerId) public async Task<RequestedModel> CheckRequestAsync(int providerId)
{ {
var blobs = await Repo.GetAllAsync(); var blobs = await Repo.GetAllAsync().ConfigureAwait(false);
var blob = blobs.FirstOrDefault(x => x.ProviderId == providerId); var blob = blobs.FirstOrDefault(x => x.ProviderId == providerId);
return blob != null ? ByteConverterHelper.ReturnObject<RequestedModel>(blob.Content) : null; return blob != null ? ByteConverterHelper.ReturnObject<RequestedModel>(blob.Content) : null;
} }
@ -94,7 +94,7 @@ namespace PlexRequests.Core
public async Task<RequestedModel> CheckRequestAsync(string musicId) public async Task<RequestedModel> CheckRequestAsync(string musicId)
{ {
var blobs = await Repo.GetAllAsync(); var blobs = await Repo.GetAllAsync().ConfigureAwait(false);
var blob = blobs.FirstOrDefault(x => x.MusicId == musicId); var blob = blobs.FirstOrDefault(x => x.MusicId == musicId);
return blob != null ? ByteConverterHelper.ReturnObject<RequestedModel>(blob.Content) : null; return blob != null ? ByteConverterHelper.ReturnObject<RequestedModel>(blob.Content) : null;
} }
@ -107,8 +107,8 @@ namespace PlexRequests.Core
public async Task DeleteRequestAsync(RequestedModel request) public async Task DeleteRequestAsync(RequestedModel request)
{ {
var blob = await Repo.GetAsync(request.Id); var blob = await Repo.GetAsync(request.Id).ConfigureAwait(false);
await Repo.DeleteAsync(blob); await Repo.DeleteAsync(blob).ConfigureAwait(false);
} }
public bool UpdateRequest(RequestedModel model) public bool UpdateRequest(RequestedModel model)
@ -120,7 +120,7 @@ namespace PlexRequests.Core
public async Task<bool> UpdateRequestAsync(RequestedModel model) public async Task<bool> UpdateRequestAsync(RequestedModel model)
{ {
var entity = new RequestBlobs { Type = model.Type, Content = ByteConverterHelper.ReturnBytes(model), ProviderId = model.ProviderId, Id = model.Id }; var entity = new RequestBlobs { Type = model.Type, Content = ByteConverterHelper.ReturnBytes(model), ProviderId = model.ProviderId, Id = model.Id };
return await Repo.UpdateAsync(entity); return await Repo.UpdateAsync(entity).ConfigureAwait(false);
} }
public RequestedModel Get(int id) public RequestedModel Get(int id)
@ -136,7 +136,7 @@ namespace PlexRequests.Core
public async Task<RequestedModel> GetAsync(int id) public async Task<RequestedModel> GetAsync(int id)
{ {
var blob = await Repo.GetAsync(id); var blob = await Repo.GetAsync(id).ConfigureAwait(false);
if (blob == null) if (blob == null)
{ {
return new RequestedModel(); return new RequestedModel();
@ -155,7 +155,7 @@ namespace PlexRequests.Core
public async Task<IEnumerable<RequestedModel>> GetAllAsync() public async Task<IEnumerable<RequestedModel>> GetAllAsync()
{ {
var blobs = await Repo.GetAllAsync(); var blobs = await Repo.GetAllAsync().ConfigureAwait(false);
return blobs.Select(b => Encoding.UTF8.GetString(b.Content)) return blobs.Select(b => Encoding.UTF8.GetString(b.Content))
.Select(JsonConvert.DeserializeObject<RequestedModel>) .Select(JsonConvert.DeserializeObject<RequestedModel>)
.ToList(); .ToList();
@ -169,7 +169,7 @@ namespace PlexRequests.Core
public async Task<bool> BatchUpdateAsync(IEnumerable<RequestedModel> model) public async Task<bool> BatchUpdateAsync(IEnumerable<RequestedModel> model)
{ {
var entities = model.Select(m => new RequestBlobs { Type = m.Type, Content = ByteConverterHelper.ReturnBytes(m), ProviderId = m.ProviderId, Id = m.Id }).ToList(); var entities = model.Select(m => new RequestBlobs { Type = m.Type, Content = ByteConverterHelper.ReturnBytes(m), ProviderId = m.ProviderId, Id = m.Id }).ToList();
return await Repo.UpdateAllAsync(entities); return await Repo.UpdateAllAsync(entities).ConfigureAwait(false);
} }
public bool BatchDelete(IEnumerable<RequestedModel> model) public bool BatchDelete(IEnumerable<RequestedModel> model)
{ {
@ -180,7 +180,7 @@ namespace PlexRequests.Core
public async Task<bool> BatchDeleteAsync(IEnumerable<RequestedModel> model) public async Task<bool> BatchDeleteAsync(IEnumerable<RequestedModel> model)
{ {
var entities = model.Select(m => new RequestBlobs { Type = m.Type, Content = ByteConverterHelper.ReturnBytes(m), ProviderId = m.ProviderId, Id = m.Id }).ToList(); var entities = model.Select(m => new RequestBlobs { Type = m.Type, Content = ByteConverterHelper.ReturnBytes(m), ProviderId = m.ProviderId, Id = m.Id }).ToList();
return await Repo.DeleteAllAsync(entities); return await Repo.DeleteAllAsync(entities).ConfigureAwait(false);
} }
} }
} }

2
PlexRequests.Core/NotificationMessage.cs → PlexRequests.Core/Notification/NotificationMessage.cs
View file

@ -26,7 +26,7 @@
#endregion #endregion
using PlexRequests.Core.Models; using PlexRequests.Core.Models;
namespace PlexRequests.Core namespace PlexRequests.Core.Notification
{ {
public class NotificationMessage public class NotificationMessage
{ {

2
PlexRequests.Core/NotificationMessageContent.cs → PlexRequests.Core/Notification/NotificationMessageContent.cs
View file

@ -24,7 +24,7 @@
// 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
namespace PlexRequests.Core namespace PlexRequests.Core.Notification
{ {
public class NotificationMessageContent public class NotificationMessageContent
{ {

3
PlexRequests.Core/NotificationMessageCurlys.cs → PlexRequests.Core/Notification/NotificationMessageCurlys.cs
View file

@ -24,10 +24,9 @@
// 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.Collections.Generic; using System.Collections.Generic;
namespace PlexRequests.Core namespace PlexRequests.Core.Notification
{ {
public class NotificationMessageCurlys public class NotificationMessageCurlys
{ {

72
PlexRequests.Core/NotificationMessageResolver.cs → PlexRequests.Core/Notification/NotificationMessageResolver.cs
View file

@ -30,12 +30,27 @@ using System.Linq;
using PlexRequests.Core.Models; using PlexRequests.Core.Models;
using PlexRequests.Core.SettingModels; using PlexRequests.Core.SettingModels;
namespace PlexRequests.Core namespace PlexRequests.Core.Notification
{ {
public class NotificationMessageResolver public class NotificationMessageResolver
{ {
/// <summary>
/// The start character '{'
/// </summary>
private const char StartChar = (char)123; private const char StartChar = (char)123;
/// <summary>
/// The end character '}'
/// </summary>
private const char EndChar = (char)125; private const char EndChar = (char)125;
/// <summary>
/// Parses the message.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="notification">The notification.</param>
/// <param name="type">The type.</param>
/// <param name="c">The c.</param>
/// <returns></returns>
public NotificationMessageContent ParseMessage<T>(T notification, NotificationType type, NotificationMessageCurlys c) where T : NotificationSettings public NotificationMessageContent ParseMessage<T>(T notification, NotificationType type, NotificationMessageCurlys c) where T : NotificationSettings
{ {
var content = notification.Message.FirstOrDefault(x => x.NotificationType == type); var content = notification.Message.FirstOrDefault(x => x.NotificationType == type);
@ -47,33 +62,30 @@ namespace PlexRequests.Core
return Resolve(content.Body, content.Subject, c.Curlys); return Resolve(content.Body, content.Subject, c.Curlys);
} }
private NotificationMessageContent Resolve(string body, string subject, Dictionary<string, string> paramaters) /// <summary>
/// Resolves the specified message curly fields.
/// </summary>
/// <param name="body">The body.</param>
/// <param name="subject">The subject.</param>
/// <param name="parameters">The parameters.</param>
/// <returns></returns>
private NotificationMessageContent Resolve(string body, string subject, IReadOnlyDictionary<string, string> parameters)
{ {
// Find the fields
var bodyFields = FindCurlyFields(body); var bodyFields = FindCurlyFields(body);
var subjectFields = FindCurlyFields(subject); var subjectFields = FindCurlyFields(subject);
foreach (var f in bodyFields) body = ReplaceFields(bodyFields, parameters, body);
{ subject = ReplaceFields(subjectFields, parameters, subject);
string outString;
if (paramaters.TryGetValue(f, out outString))
{
body = body.Replace($"{{{f}}}", outString);
}
}
foreach (var s in subjectFields)
{
string outString;
if (paramaters.TryGetValue(s, out outString))
{
subject = subject.Replace($"{{{s}}}", outString);
}
}
return new NotificationMessageContent { Body = body ?? string.Empty, Subject = subject ?? string.Empty }; return new NotificationMessageContent { Body = body ?? string.Empty, Subject = subject ?? string.Empty };
} }
/// <summary>
/// Finds the curly fields.
/// </summary>
/// <param name="message">The message.</param>
/// <returns></returns>
private IEnumerable<string> FindCurlyFields(string message) private IEnumerable<string> FindCurlyFields(string message)
{ {
if (string.IsNullOrEmpty(message)) if (string.IsNullOrEmpty(message))
@ -116,5 +128,25 @@ namespace PlexRequests.Core
return fields; return fields;
} }
/// <summary>
/// Replaces the fields.
/// </summary>
/// <param name="fields">The fields.</param>
/// <param name="parameters">The parameters.</param>
/// <param name="mainText">The main text.</param>
/// <returns></returns>
private string ReplaceFields(IEnumerable<string> fields, IReadOnlyDictionary<string, string> parameters, string mainText)
{
foreach (var field in fields)
{
string outString;
if (parameters.TryGetValue(field, out outString))
{
mainText = mainText.Replace($"{{{field}}}", outString);
}
}
return mainText;
}
} }
} }

9
PlexRequests.Core/PlexRequests.Core.csproj
View file

@ -67,10 +67,10 @@
</ItemGroup> </ItemGroup>
<ItemGroup> <ItemGroup>
<Compile Include="CacheKeys.cs" /> <Compile Include="CacheKeys.cs" />
<Compile Include="NotificationMessage.cs" /> <Compile Include="Notification\NotificationMessage.cs" />
<Compile Include="NotificationMessageContent.cs" /> <Compile Include="Notification\NotificationMessageContent.cs" />
<Compile Include="NotificationMessageCurlys.cs" /> <Compile Include="Notification\NotificationMessageCurlys.cs" />
<Compile Include="NotificationMessageResolver.cs" /> <Compile Include="Notification\NotificationMessageResolver.cs" />
<Compile Include="IIssueService.cs" /> <Compile Include="IIssueService.cs" />
<Compile Include="IRequestService.cs" /> <Compile Include="IRequestService.cs" />
<Compile Include="ISettingsService.cs" /> <Compile Include="ISettingsService.cs" />
@ -130,6 +130,7 @@
<Name>PlexRequests.Store</Name> <Name>PlexRequests.Store</Name>
</ProjectReference> </ProjectReference>
</ItemGroup> </ItemGroup>
<ItemGroup />
<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" /> <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
<!-- To modify your build process, add your task inside one of the targets below and uncomment it. <!-- To modify your build process, add your task inside one of the targets below and uncomment it.
Other similar extension points exist, see Microsoft.Common.targets. Other similar extension points exist, see Microsoft.Common.targets.

74
PlexRequests.Core/Properties/AssemblyInfo.cs
View file

@ -1,37 +1,37 @@
using System.Reflection; using System.Reflection;
using System.Runtime.CompilerServices; using System.Runtime.CompilerServices;
using System.Runtime.InteropServices; using System.Runtime.InteropServices;
// General Information about an assembly is controlled through the following // General Information about an assembly is controlled through the following
// set of attributes. Change these attribute values to modify the information // set of attributes. Change these attribute values to modify the information
// associated with an assembly. // associated with an assembly.
[assembly: AssemblyTitle("PlexRequests.Core")] [assembly: AssemblyTitle("PlexRequests.Core")]
[assembly: AssemblyDescription("")] [assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")] [assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")] [assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("PlexRequests.Core")] [assembly: AssemblyProduct("PlexRequests.Core")]
[assembly: AssemblyCopyright("Copyright © 2016")] [assembly: AssemblyCopyright("Copyright © 2016")]
[assembly: AssemblyTrademark("")] [assembly: AssemblyTrademark("")]
[assembly: AssemblyCulture("")] [assembly: AssemblyCulture("")]
// Setting ComVisible to false makes the types in this assembly not visible // Setting ComVisible to false makes the types in this assembly not visible
// to COM components. If you need to access a type in this assembly from // to COM components. If you need to access a type in this assembly from
// COM, set the ComVisible attribute to true on that type. // COM, set the ComVisible attribute to true on that type.
[assembly: ComVisible(false)] [assembly: ComVisible(false)]
// The following GUID is for the ID of the typelib if this project is exposed to COM // The following GUID is for the ID of the typelib if this project is exposed to COM
[assembly: Guid("dd7dc444-d3bf-4027-8ab9-efc71f5ec581")] [assembly: Guid("dd7dc444-d3bf-4027-8ab9-efc71f5ec581")]
// Version information for an assembly consists of the following four values: // Version information for an assembly consists of the following four values:
// //
// Major Version // Major Version
// Minor Version // Minor Version
// Build Number // Build Number
// Revision // Revision
// //
// You can specify all the values or you can default the Build and Revision Numbers // You can specify all the values or you can default the Build and Revision Numbers
// by using the '*' as shown below: // by using the '*' as shown below:
// [assembly: AssemblyVersion("1.0.*")] // [assembly: AssemblyVersion("1.0.*")]
[assembly: AssemblyVersion("1.0.0.0")] [assembly: AssemblyVersion("1.0.0.0")]
[assembly: AssemblyFileVersion("1.0.0.0")] [assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersionAttribute("1.0.0.0")] [assembly: AssemblyInformationalVersionAttribute("1.0.0.0")]

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

@ -27,6 +27,7 @@
using System.Collections.Generic; using System.Collections.Generic;
using PlexRequests.Core.Models; using PlexRequests.Core.Models;
using PlexRequests.Core.Notification;
namespace PlexRequests.Core.SettingModels namespace PlexRequests.Core.SettingModels
{ {
@ -40,21 +41,15 @@ namespace PlexRequests.Core.SettingModels
new NotificationMessage { NotificationType = NotificationType.Issue }, new NotificationMessage { NotificationType = NotificationType.Issue },
new NotificationMessage { NotificationType = NotificationType.AdminNote }, new NotificationMessage { NotificationType = NotificationType.AdminNote },
new NotificationMessage { NotificationType = NotificationType.RequestApproved }, new NotificationMessage { NotificationType = NotificationType.RequestApproved },
new NotificationMessage { NotificationType = NotificationType.RequestAvailable }, new NotificationMessage { NotificationType = NotificationType.RequestAvailable }
}; };
} }
public List<NotificationMessage> Message { get; set; } public List<NotificationMessage> Message { get; set; }
} }
public static class NotificationCurly public static class NotificationCurly
{ {
public static readonly List<string> Curlys = new List<string> public static readonly List<string> Curlys = new List<string> { "Username", "Title", "Date", "Issue", "Type" };
{
"Username",
"Title",
"Date",
"Issue",
"Type"
};
} }
} }

6
PlexRequests.Core/SettingsServiceV2.cs
View file

@ -65,7 +65,7 @@ namespace PlexRequests.Core
public async Task<T> GetSettingsAsync() public async Task<T> GetSettingsAsync()
{ {
var result = await Repo.GetAsync(EntityName); var result = await Repo.GetAsync(EntityName).ConfigureAwait(false);
if (result == null) if (result == null)
{ {
return new T(); return new T();
@ -110,7 +110,7 @@ namespace PlexRequests.Core
var settings = new GlobalSettings { SettingsName = EntityName, Content = JsonConvert.SerializeObject(newEntity, SerializerSettings.Settings) }; var settings = new GlobalSettings { SettingsName = EntityName, Content = JsonConvert.SerializeObject(newEntity, SerializerSettings.Settings) };
settings.Content = EncryptSettings(settings); settings.Content = EncryptSettings(settings);
var insertResult = await Repo.InsertAsync(settings); var insertResult = await Repo.InsertAsync(settings).ConfigureAwait(false);
return insertResult != int.MinValue; return insertResult != int.MinValue;
} }
@ -120,7 +120,7 @@ namespace PlexRequests.Core
var globalSettings = new GlobalSettings { SettingsName = EntityName, Content = JsonConvert.SerializeObject(modified, SerializerSettings.Settings), Id = entity.Id }; var globalSettings = new GlobalSettings { SettingsName = EntityName, Content = JsonConvert.SerializeObject(modified, SerializerSettings.Settings), Id = entity.Id };
globalSettings.Content = EncryptSettings(globalSettings); globalSettings.Content = EncryptSettings(globalSettings);
var result = await Repo.UpdateAsync(globalSettings); var result = await Repo.UpdateAsync(globalSettings).ConfigureAwait(false);
return result; return result;
} }

164
PlexRequests.Core/StatusChecker.cs
View file

@ -1,83 +1,83 @@
#region Copyright #region Copyright
// /************************************************************************ // /************************************************************************
// Copyright (c) 2016 Jamie Rees // Copyright (c) 2016 Jamie Rees
// File: StatusChecker.cs // File: StatusChecker.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 System.Linq; using System.Linq;
using System.Threading.Tasks; using System.Threading.Tasks;
using Octokit; using Octokit;
using PlexRequests.Core.Models; using PlexRequests.Core.Models;
using PlexRequests.Helpers; using PlexRequests.Helpers;
namespace PlexRequests.Core namespace PlexRequests.Core
{ {
public class StatusChecker public class StatusChecker
{ {
public StatusChecker() public StatusChecker()
{ {
Git = new GitHubClient(new ProductHeaderValue("PlexRequests-StatusChecker")); Git = new GitHubClient(new ProductHeaderValue("PlexRequests-StatusChecker"));
} }
private IGitHubClient Git { get; } private IGitHubClient Git { get; }
private const string Owner = "tidusjar"; private const string Owner = "tidusjar";
private const string RepoName = "PlexRequests.Net"; private const string RepoName = "PlexRequests.Net";
public async Task<Release> GetLatestRelease() public async Task<Release> GetLatestRelease()
{ {
var releases = await Git.Repository.Release.GetAll(Owner, RepoName); var releases = await Git.Repository.Release.GetAll(Owner, RepoName);
return releases.FirstOrDefault(); return releases.FirstOrDefault();
} }
public async Task<StatusModel> GetStatus() public async Task<StatusModel> GetStatus()
{ {
var assemblyVersion = AssemblyHelper.GetProductVersion(); var assemblyVersion = AssemblyHelper.GetProductVersion();
var model = new StatusModel var model = new StatusModel
{ {
Version = assemblyVersion, Version = assemblyVersion,
}; };
var latestRelease = await GetLatestRelease(); var latestRelease = await GetLatestRelease();
if (latestRelease == null) if (latestRelease == null)
{ {
return new StatusModel { Version = "Unknown" }; return new StatusModel { Version = "Unknown" };
} }
var latestVersionArray = latestRelease.Name.Split(new[] { 'v' }, StringSplitOptions.RemoveEmptyEntries); var latestVersionArray = latestRelease.Name.Split(new[] { 'v' }, StringSplitOptions.RemoveEmptyEntries);
var latestVersion = latestVersionArray.Length > 1 ? latestVersionArray[1] : string.Empty; var latestVersion = latestVersionArray.Length > 1 ? latestVersionArray[1] : string.Empty;
if (!latestVersion.Equals(assemblyVersion, StringComparison.InvariantCultureIgnoreCase)) if (!latestVersion.Equals(assemblyVersion, StringComparison.InvariantCultureIgnoreCase))
{ {
model.UpdateAvailable = true; model.UpdateAvailable = true;
model.UpdateUri = latestRelease.HtmlUrl; model.UpdateUri = latestRelease.HtmlUrl;
} }
model.ReleaseNotes = latestRelease.Body; model.ReleaseNotes = latestRelease.Body;
model.DownloadUri = latestRelease.Assets[0].BrowserDownloadUrl; model.DownloadUri = latestRelease.Assets[0].BrowserDownloadUrl;
model.ReleaseTitle = latestRelease.Name; model.ReleaseTitle = latestRelease.Name;
return model; return model;
} }
} }
} }

2
PlexRequests.Helpers/CookieHelper.cs
View file

@ -41,7 +41,7 @@ namespace PlexRequests.Helpers
/// <returns></returns> /// <returns></returns>
public static string GetAnalyticClientId(IDictionary<string, string> cookies) public static string GetAnalyticClientId(IDictionary<string, string> cookies)
{ {
var outString = string.Empty; string outString;
if (cookies.TryGetValue(GaCookie, out outString)) if (cookies.TryGetValue(GaCookie, out outString))
{ {

13
PlexRequests.Store/Repository/BaseGenericRepository.cs
View file

@ -98,7 +98,7 @@ namespace PlexRequests.Store.Repository
using (var db = Config.DbConnection()) using (var db = Config.DbConnection())
{ {
db.Open(); db.Open();
await db.DeleteAsync(entity); await db.DeleteAsync(entity).ConfigureAwait(false);
} }
} }
catch (SqliteException e) when (e.ErrorCode == SQLiteErrorCode.Corrupt) catch (SqliteException e) when (e.ErrorCode == SQLiteErrorCode.Corrupt)
@ -134,7 +134,7 @@ namespace PlexRequests.Store.Repository
using (var db = Config.DbConnection()) using (var db = Config.DbConnection())
{ {
db.Open(); db.Open();
return await db.UpdateAsync(entity); return await db.UpdateAsync(entity).ConfigureAwait(false);
} }
} }
catch (SqliteException e) when (e.ErrorCode == SQLiteErrorCode.Corrupt) catch (SqliteException e) when (e.ErrorCode == SQLiteErrorCode.Corrupt)
@ -173,16 +173,17 @@ namespace PlexRequests.Store.Repository
try try
{ {
ResetCache(); ResetCache();
var result = new HashSet<bool>(); var tasks = new List<Task<bool>>();
using (var db = Config.DbConnection()) using (var db = Config.DbConnection())
{ {
db.Open(); db.Open();
foreach (var e in entity) foreach (var e in entity)
{ {
result.Add(await db.UpdateAsync(e)); tasks.Add(db.UpdateAsync(e));
} }
} }
var result = await Task.WhenAll(tasks).ConfigureAwait(false);
return result.All(x => true); return result.All(x => true);
} }
catch (SqliteException e) when (e.ErrorCode == SQLiteErrorCode.Corrupt) catch (SqliteException e) when (e.ErrorCode == SQLiteErrorCode.Corrupt)
@ -200,7 +201,7 @@ namespace PlexRequests.Store.Repository
using (var cnn = Config.DbConnection()) using (var cnn = Config.DbConnection())
{ {
cnn.Open(); cnn.Open();
return await cnn.InsertAsync(entity); return await cnn.InsertAsync(entity).ConfigureAwait(false);
} }
} }
catch (SqliteException e) when (e.ErrorCode == SQLiteErrorCode.Corrupt) catch (SqliteException e) when (e.ErrorCode == SQLiteErrorCode.Corrupt)
@ -240,7 +241,7 @@ namespace PlexRequests.Store.Repository
using (var db = Config.DbConnection()) using (var db = Config.DbConnection())
{ {
db.Open(); db.Open();
var result = await db.GetAllAsync<T>(); var result = await db.GetAllAsync<T>().ConfigureAwait(false);
return result; return result;
} }
} }

180
PlexRequests.Store/Repository/GenericRepository.cs
View file

@ -1,92 +1,90 @@
#region Copyright #region Copyright
// /************************************************************************ // /************************************************************************
// Copyright (c) 2016 Jamie Rees // Copyright (c) 2016 Jamie Rees
// File: GenericRepository.cs // File: GenericRepository.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 System.Collections.Generic; using System.Threading.Tasks;
using System.Linq; using Dapper.Contrib.Extensions;
using System.Threading.Tasks;
using Dapper.Contrib.Extensions; using PlexRequests.Helpers;
using NLog;
using PlexRequests.Helpers; namespace PlexRequests.Store.Repository
{
namespace PlexRequests.Store.Repository public class GenericRepository<T> : BaseGenericRepository<T>, IRepository<T> where T : Entity
{ {
public class GenericRepository<T> : BaseGenericRepository<T>, IRepository<T> where T : Entity
{ public GenericRepository(ISqliteConfiguration config, ICacheProvider cache) : base(config, cache)
{
public GenericRepository(ISqliteConfiguration config, ICacheProvider cache) : base(config, cache)
{ }
} public override T Get(string id)
{
public override T Get(string id) throw new NotSupportedException("Get(string) is not supported. Use Get(int)");
{ }
throw new NotSupportedException("Get(string) is not supported. Use Get(int)");
} public override Task<T> GetAsync(string id)
{
public override Task<T> GetAsync(string id) throw new NotSupportedException("GetAsync(string) is not supported. Use GetAsync(int)");
{ }
throw new NotSupportedException("GetAsync(string) is not supported. Use GetAsync(int)");
} public override T Get(int id)
{
public override T Get(int id) var key = "Get" + id;
{ var item = Cache.GetOrSet(
var key = "Get" + id; key,
var item = Cache.GetOrSet( () =>
key, {
() => using (var db = Config.DbConnection())
{ {
using (var db = Config.DbConnection()) db.Open();
{ return db.Get<T>(id);
db.Open(); }
return db.Get<T>(id); });
} return item;
}); }
return item;
} public override async Task<T> GetAsync(int id)
{
public override async Task<T> GetAsync(int id) var key = "Get" + id;
{ var item = await Cache.GetOrSetAsync(
var key = "Get" + id; key,
var item = await Cache.GetOrSetAsync( async () =>
key, {
async () => using (var db = Config.DbConnection())
{ {
using (var db = Config.DbConnection()) db.Open();
{ return await db.GetAsync<T>(id).ConfigureAwait(false);
db.Open(); }
return await db.GetAsync<T>(id); });
} return item;
}); }
return item;
}
}
}
} }

459
PlexRequests.Store/Repository/RequestJsonRepository.cs
View file

@ -1,228 +1,231 @@
#region Copyright #region Copyright
// /************************************************************************ // /************************************************************************
// Copyright (c) 2016 Jamie Rees // Copyright (c) 2016 Jamie Rees
// File: SettingsJsonRepository.cs // File: SettingsJsonRepository.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.Collections.Generic; using System.Collections.Generic;
using System.Linq; using System.Linq;
using System.Threading.Tasks; using System.Threading.Tasks;
using Dapper.Contrib.Extensions; using Dapper.Contrib.Extensions;
using PlexRequests.Helpers; using PlexRequests.Helpers;
using PlexRequests.Store.Models; using PlexRequests.Store.Models;
namespace PlexRequests.Store.Repository namespace PlexRequests.Store.Repository
{ {
public class RequestJsonRepository : IRequestRepository public class RequestJsonRepository : IRequestRepository
{ {
private ICacheProvider Cache { get; } private ICacheProvider Cache { get; }
public RequestJsonRepository(ISqliteConfiguration config, ICacheProvider cacheProvider) public RequestJsonRepository(ISqliteConfiguration config, ICacheProvider cacheProvider)
{ {
Db = config; Db = config;
Cache = cacheProvider; Cache = cacheProvider;
} }
private ISqliteConfiguration Db { get; } private ISqliteConfiguration Db { get; }
public long Insert(RequestBlobs entity) public long Insert(RequestBlobs entity)
{ {
ResetCache(); ResetCache();
using (var con = Db.DbConnection()) using (var con = Db.DbConnection())
{ {
var id = con.Insert(entity); var id = con.Insert(entity);
return id; return id;
} }
} }
public async Task<int> InsertAsync(RequestBlobs entity) public async Task<int> InsertAsync(RequestBlobs entity)
{ {
ResetCache(); ResetCache();
using (var con = Db.DbConnection()) using (var con = Db.DbConnection())
{ {
var id = await con.InsertAsync(entity); var id = await con.InsertAsync(entity).ConfigureAwait(false);
return id; return id;
} }
} }
public IEnumerable<RequestBlobs> GetAll() public IEnumerable<RequestBlobs> GetAll()
{ {
var key = "GetAll"; var key = "GetAll";
var item = Cache.GetOrSet(key, () => var item = Cache.GetOrSet(key, () =>
{ {
using (var con = Db.DbConnection()) using (var con = Db.DbConnection())
{ {
var page = con.GetAll<RequestBlobs>(); var page = con.GetAll<RequestBlobs>();
return page; return page;
} }
}, 5); }, 5);
return item; return item;
} }
public async Task<IEnumerable<RequestBlobs>> GetAllAsync() public async Task<IEnumerable<RequestBlobs>> GetAllAsync()
{ {
var key = "GetAll"; var key = "GetAll";
var item = await Cache.GetOrSetAsync(key, async() => var item = await Cache.GetOrSetAsync(key, async() =>
{ {
using (var con = Db.DbConnection()) using (var con = Db.DbConnection())
{ {
var page = await con.GetAllAsync<RequestBlobs>(); var page = await con.GetAllAsync<RequestBlobs>().ConfigureAwait(false);
return page; return page;
} }
}, 5); }, 5);
return item; return item;
} }
public RequestBlobs Get(int id) public RequestBlobs Get(int id)
{ {
var key = "Get" + id; var key = "Get" + id;
var item = Cache.GetOrSet(key, () => var item = Cache.GetOrSet(key, () =>
{ {
using (var con = Db.DbConnection()) using (var con = Db.DbConnection())
{ {
var page = con.Get<RequestBlobs>(id); var page = con.Get<RequestBlobs>(id);
return page; return page;
} }
}, 5); }, 5);
return item; return item;
} }
public async Task<RequestBlobs> GetAsync(int id) public async Task<RequestBlobs> GetAsync(int id)
{ {
var key = "Get" + id; var key = "Get" + id;
var item = await Cache.GetOrSetAsync(key, async () => var item = await Cache.GetOrSetAsync(key, async () =>
{ {
using (var con = Db.DbConnection()) using (var con = Db.DbConnection())
{ {
var page = await con.GetAsync<RequestBlobs>(id); var page = await con.GetAsync<RequestBlobs>(id).ConfigureAwait(false);
return page; return page;
} }
}, 5); }, 5);
return item; return item;
} }
public bool Delete(RequestBlobs entity) public bool Delete(RequestBlobs entity)
{ {
ResetCache(); ResetCache();
using (var con = Db.DbConnection()) using (var con = Db.DbConnection())
{ {
return con.Delete(entity); return con.Delete(entity);
} }
} }
public async Task<bool> DeleteAsync(RequestBlobs entity) public async Task<bool> DeleteAsync(RequestBlobs entity)
{ {
ResetCache(); ResetCache();
using (var con = Db.DbConnection()) using (var con = Db.DbConnection())
{ {
return await con.DeleteAsync(entity); return await con.DeleteAsync(entity).ConfigureAwait(false);
} }
} }
public async Task<bool> DeleteAllAsync(IEnumerable<RequestBlobs> entity) public async Task<bool> DeleteAllAsync(IEnumerable<RequestBlobs> entity)
{ {
ResetCache(); ResetCache();
var result = new HashSet<bool>(); var tasks = new List<Task<bool>>();
using (var db = Db.DbConnection()) using (var db = Db.DbConnection())
{ {
db.Open(); db.Open();
foreach (var e in entity) foreach (var e in entity)
{ {
result.Add(await db.DeleteAsync(e)); tasks.Add(db.DeleteAsync(e));
} }
} }
return result.All(x => true); var result = await Task.WhenAll(tasks).ConfigureAwait(false);
}
return result.All(x => true);
public bool Update(RequestBlobs entity) }
{
ResetCache(); public bool Update(RequestBlobs entity)
using (var con = Db.DbConnection()) {
{ ResetCache();
return con.Update(entity); using (var con = Db.DbConnection())
} {
} return con.Update(entity);
}
public async Task<bool> UpdateAsync(RequestBlobs entity) }
{
ResetCache(); public async Task<bool> UpdateAsync(RequestBlobs entity)
using (var con = Db.DbConnection()) {
{ ResetCache();
return await con.UpdateAsync(entity); using (var con = Db.DbConnection())
} {
} return await con.UpdateAsync(entity).ConfigureAwait(false);
}
private void ResetCache() }
{
Cache.Remove("Get"); private void ResetCache()
Cache.Remove("GetAll"); {
} Cache.Remove("Get");
Cache.Remove("GetAll");
public bool UpdateAll(IEnumerable<RequestBlobs> entity) }
{
ResetCache(); public bool UpdateAll(IEnumerable<RequestBlobs> entity)
var result = new HashSet<bool>(); {
using (var db = Db.DbConnection()) ResetCache();
{ var result = new HashSet<bool>();
db.Open(); using (var db = Db.DbConnection())
foreach (var e in entity) {
{ db.Open();
result.Add(db.Update(e)); foreach (var e in entity)
} {
} result.Add(db.Update(e));
return result.All(x => true); }
} }
return result.All(x => true);
public async Task<bool> UpdateAllAsync(IEnumerable<RequestBlobs> entity) }
{
ResetCache(); public async Task<bool> UpdateAllAsync(IEnumerable<RequestBlobs> entity)
var result = new HashSet<bool>(); {
using (var db = Db.DbConnection()) ResetCache();
{ var tasks = new List<Task<bool>>();
db.Open(); using (var db = Db.DbConnection())
foreach (var e in entity) {
{ db.Open();
result.Add(await db.UpdateAsync(e)); foreach (var e in entity)
} {
} tasks.Add(db.UpdateAsync(e));
return result.All(x => true); }
} }
var result = await Task.WhenAll(tasks).ConfigureAwait(false);
public bool DeleteAll(IEnumerable<RequestBlobs> entity) return result.All(x => true);
{ }
ResetCache();
var result = new HashSet<bool>(); public bool DeleteAll(IEnumerable<RequestBlobs> entity)
using (var db = Db.DbConnection()) {
{ ResetCache();
db.Open(); var result = new HashSet<bool>();
foreach (var e in entity) using (var db = Db.DbConnection())
{ {
result.Add(db.Delete(e)); db.Open();
} foreach (var e in entity)
} {
return result.All(x => true); result.Add(db.Delete(e));
} }
} }
} return result.All(x => true);
}
}
}

334
PlexRequests.Store/Repository/SettingsJsonRepository.cs
View file

@ -1,167 +1,167 @@
#region Copyright #region Copyright
// /************************************************************************ // /************************************************************************
// Copyright (c) 2016 Jamie Rees // Copyright (c) 2016 Jamie Rees
// File: SettingsJsonRepository.cs // File: SettingsJsonRepository.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.Collections.Generic; using System.Collections.Generic;
using System.Linq; using System.Linq;
using System.Threading.Tasks; using System.Threading.Tasks;
using Dapper.Contrib.Extensions; using Dapper.Contrib.Extensions;
using PlexRequests.Helpers; using PlexRequests.Helpers;
using PlexRequests.Store.Models; using PlexRequests.Store.Models;
namespace PlexRequests.Store.Repository namespace PlexRequests.Store.Repository
{ {
public class SettingsJsonRepository : ISettingsRepository public class SettingsJsonRepository : ISettingsRepository
{ {
private ICacheProvider Cache { get; set; } private ICacheProvider Cache { get; }
private string TypeName { get; set; } private string TypeName { get; }
public SettingsJsonRepository(ISqliteConfiguration config, ICacheProvider cacheProvider) public SettingsJsonRepository(ISqliteConfiguration config, ICacheProvider cacheProvider)
{ {
Db = config; Db = config;
Cache = cacheProvider; Cache = cacheProvider;
TypeName = typeof(SettingsJsonRepository).Name; TypeName = typeof(SettingsJsonRepository).Name;
} }
private ISqliteConfiguration Db { get; set; } private ISqliteConfiguration Db { get; }
public long Insert(GlobalSettings entity) public long Insert(GlobalSettings entity)
{ {
ResetCache(); ResetCache();
using (var con = Db.DbConnection()) using (var con = Db.DbConnection())
{ {
return con.Insert(entity); return con.Insert(entity);
} }
} }
public async Task<int> InsertAsync(GlobalSettings entity) public async Task<int> InsertAsync(GlobalSettings entity)
{ {
ResetCache(); ResetCache();
using (var con = Db.DbConnection()) using (var con = Db.DbConnection())
{ {
return await con.InsertAsync(entity); return await con.InsertAsync(entity).ConfigureAwait(false);
} }
} }
public IEnumerable<GlobalSettings> GetAll() public IEnumerable<GlobalSettings> GetAll()
{ {
var key = TypeName + "GetAll"; var key = TypeName + "GetAll";
var item = Cache.GetOrSet(key, () => var item = Cache.GetOrSet(key, () =>
{ {
using (var con = Db.DbConnection()) using (var con = Db.DbConnection())
{ {
var page = con.GetAll<GlobalSettings>(); var page = con.GetAll<GlobalSettings>();
return page; return page;
} }
}, 5); }, 5);
return item; return item;
} }
public async Task<IEnumerable<GlobalSettings>> GetAllAsync() public async Task<IEnumerable<GlobalSettings>> GetAllAsync()
{ {
var key = TypeName + "GetAll"; var key = TypeName + "GetAll";
var item = await Cache.GetOrSetAsync(key, async() => var item = await Cache.GetOrSetAsync(key, async() =>
{ {
using (var con = Db.DbConnection()) using (var con = Db.DbConnection())
{ {
var page = await con.GetAllAsync<GlobalSettings>(); var page = await con.GetAllAsync<GlobalSettings>().ConfigureAwait(false);
return page; return page;
} }
}, 5); }, 5);
return item; return item;
} }
public GlobalSettings Get(string pageName) public GlobalSettings Get(string pageName)
{ {
var key = pageName + "Get"; var key = pageName + "Get";
var item = Cache.GetOrSet(key, () => var item = Cache.GetOrSet(key, () =>
{ {
using (var con = Db.DbConnection()) using (var con = Db.DbConnection())
{ {
var page = con.GetAll<GlobalSettings>().SingleOrDefault(x => x.SettingsName == pageName); var page = con.GetAll<GlobalSettings>().SingleOrDefault(x => x.SettingsName == pageName);
return page; return page;
} }
}, 5); }, 5);
return item; return item;
} }
public async Task<GlobalSettings> GetAsync(string settingsName) public async Task<GlobalSettings> GetAsync(string settingsName)
{ {
var key = settingsName + "Get"; var key = settingsName + "Get";
var item = await Cache.GetOrSetAsync(key, async() => var item = await Cache.GetOrSetAsync(key, async() =>
{ {
using (var con = Db.DbConnection()) using (var con = Db.DbConnection())
{ {
var page = await con.GetAllAsync<GlobalSettings>(); var page = await con.GetAllAsync<GlobalSettings>().ConfigureAwait(false);
return page.SingleOrDefault(x => x.SettingsName == settingsName); return page.SingleOrDefault(x => x.SettingsName == settingsName);
} }
}, 5); }, 5);
return item; return item;
} }
public async Task<bool> DeleteAsync(GlobalSettings entity) public async Task<bool> DeleteAsync(GlobalSettings entity)
{ {
ResetCache(); ResetCache();
using (var con = Db.DbConnection()) using (var con = Db.DbConnection())
{ {
return await con.DeleteAsync(entity); return await con.DeleteAsync(entity).ConfigureAwait(false);
} }
} }
public async Task<bool> UpdateAsync(GlobalSettings entity) public async Task<bool> UpdateAsync(GlobalSettings entity)
{ {
ResetCache(); ResetCache();
using (var con = Db.DbConnection()) using (var con = Db.DbConnection())
{ {
return await con.UpdateAsync(entity); return await con.UpdateAsync(entity).ConfigureAwait(false);
} }
} }
public bool Delete(GlobalSettings entity) public bool Delete(GlobalSettings entity)
{ {
ResetCache(); ResetCache();
using (var con = Db.DbConnection()) using (var con = Db.DbConnection())
{ {
return con.Delete(entity); return con.Delete(entity);
} }
} }
public bool Update(GlobalSettings entity) public bool Update(GlobalSettings entity)
{ {
ResetCache(); ResetCache();
using (var con = Db.DbConnection()) using (var con = Db.DbConnection())
{ {
return con.Update(entity); return con.Update(entity);
} }
} }
private void ResetCache() private void ResetCache()
{ {
Cache.Remove("Get"); Cache.Remove("Get");
Cache.Remove(TypeName + "GetAll"); Cache.Remove(TypeName + "GetAll");
} }
} }
} }

158
PlexRequests.Store/UserRepository.cs
View file

@ -1,79 +1,79 @@
#region Copyright #region Copyright
// /************************************************************************ // /************************************************************************
// Copyright (c) 2016 Jamie Rees // Copyright (c) 2016 Jamie Rees
// File: UserRepository.cs // File: UserRepository.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 System.Collections.Generic; using System.Collections.Generic;
using System.Linq; using System.Linq;
using System.Threading.Tasks; using System.Threading.Tasks;
using Dapper.Contrib.Extensions; using Dapper.Contrib.Extensions;
using PlexRequests.Helpers; using PlexRequests.Helpers;
using PlexRequests.Store.Repository; using PlexRequests.Store.Repository;
namespace PlexRequests.Store namespace PlexRequests.Store
{ {
public class UserRepository<T> : BaseGenericRepository<T>, IRepository<T> where T : UserEntity public class UserRepository<T> : BaseGenericRepository<T>, IRepository<T> where T : UserEntity
{ {
public UserRepository(ISqliteConfiguration config, ICacheProvider cache) : base(config, cache) public UserRepository(ISqliteConfiguration config, ICacheProvider cache) : base(config, cache)
{ {
} }
public override T Get(int id) public override T Get(int id)
{ {
throw new NotSupportedException("Get(int) is not supported. Use Get(string)"); throw new NotSupportedException("Get(int) is not supported. Use Get(string)");
} }
public override Task<T> GetAsync(int id) public override Task<T> GetAsync(int id)
{ {
throw new NotSupportedException("GetAsync(int) is not supported. Use GetAsync(string)"); throw new NotSupportedException("GetAsync(int) is not supported. Use GetAsync(string)");
} }
public override T Get(string id) public override T Get(string id)
{ {
using (var db = Config.DbConnection()) using (var db = Config.DbConnection())
{ {
db.Open(); db.Open();
var result = db.GetAll<T>(); var result = db.GetAll<T>();
var selected = result.FirstOrDefault(x => x.UserGuid == id); var selected = result.FirstOrDefault(x => x.UserGuid == id);
return selected; return selected;
} }
} }
public override async Task<T> GetAsync(string id) public override async Task<T> GetAsync(string id)
{ {
using (var db = Config.DbConnection()) using (var db = Config.DbConnection())
{ {
db.Open(); db.Open();
var result = await db.GetAllAsync<T>(); var result = await db.GetAllAsync<T>().ConfigureAwait(false);
var selected = result.FirstOrDefault(x => x.UserGuid == id); var selected = result.FirstOrDefault(x => x.UserGuid == id);
return selected; return selected;
} }
} }
} }
} }