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
{
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)
{
if (timeSpan == null)
{
timeSpan = DefaultTime;
timeSpan = DefaultRetryTime;
}
var policy = RetryAndWaitPolicy(timeSpan);
@ -50,7 +50,7 @@ namespace PlexRequests.Api
{
if (timeSpan == null)
{
timeSpan = DefaultTime;
timeSpan = DefaultRetryTime;
}
var policy = RetryAndWaitPolicy(action, timeSpan);
@ -61,7 +61,7 @@ namespace PlexRequests.Api
{
if (timeSpan == null)
{
timeSpan = DefaultTime;
timeSpan = DefaultRetryTime;
}
var policy = Policy.Handle<Exception>().WaitAndRetry(timeSpan, (e, ts) => action());
@ -72,7 +72,7 @@ namespace PlexRequests.Api
{
if (timeSpan == null)
{
timeSpan = DefaultTime;
timeSpan = DefaultRetryTime;
}
var policy = Policy.Handle<Exception>().WaitAndRetry(timeSpan);
@ -83,7 +83,7 @@ namespace PlexRequests.Api
{
if (timeSpan == null)
{
timeSpan = DefaultTime;
timeSpan = DefaultRetryTime;
}
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 PlexRequests.Core.Models;
using PlexRequests.Core.Notification;
using PlexRequests.Core.SettingModels;
namespace PlexRequests.Core.Tests
@ -43,7 +44,7 @@ namespace PlexRequests.Core.Tests
var n = new NotificationMessageResolver();
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);
@ -56,7 +57,7 @@ namespace PlexRequests.Core.Tests
var n = new NotificationMessageResolver();
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);

10
PlexRequests.Core/JsonIssuesModelRequestService.cs
View file

@ -53,7 +53,7 @@ namespace PlexRequests.Core
model.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;
}
@ -61,21 +61,21 @@ namespace PlexRequests.Core
public async Task<bool> UpdateIssueAsync(IssuesModel model)
{
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)
{
var entity = await Repo.GetAsync(id);
await Repo.DeleteAsync(entity);
await Repo.DeleteAsync(entity).ConfigureAwait(false);
}
public async Task DeleteIssueAsync(IssuesModel model)
{
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>
@ -101,7 +101,7 @@ namespace PlexRequests.Core
/// <returns></returns>
public async Task<IEnumerable<IssuesModel>> GetAllAsync()
{
var blobs = await Repo.GetAllAsync();
var blobs = await Repo.GetAllAsync().ConfigureAwait(false);
if (blobs == null)
{

22
PlexRequests.Core/JsonRequestModelRequestService.cs
View file

@ -61,12 +61,12 @@ namespace PlexRequests.Core
public async Task<int> AddRequestAsync(RequestedModel model)
{
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;
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;
}
@ -80,7 +80,7 @@ namespace PlexRequests.Core
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);
return blob != null ? ByteConverterHelper.ReturnObject<RequestedModel>(blob.Content) : null;
}
@ -94,7 +94,7 @@ namespace PlexRequests.Core
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);
return blob != null ? ByteConverterHelper.ReturnObject<RequestedModel>(blob.Content) : null;
}
@ -107,8 +107,8 @@ namespace PlexRequests.Core
public async Task DeleteRequestAsync(RequestedModel request)
{
var blob = await Repo.GetAsync(request.Id);
await Repo.DeleteAsync(blob);
var blob = await Repo.GetAsync(request.Id).ConfigureAwait(false);
await Repo.DeleteAsync(blob).ConfigureAwait(false);
}
public bool UpdateRequest(RequestedModel model)
@ -120,7 +120,7 @@ namespace PlexRequests.Core
public async Task<bool> UpdateRequestAsync(RequestedModel model)
{
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)
@ -136,7 +136,7 @@ namespace PlexRequests.Core
public async Task<RequestedModel> GetAsync(int id)
{
var blob = await Repo.GetAsync(id);
var blob = await Repo.GetAsync(id).ConfigureAwait(false);
if (blob == null)
{
return new RequestedModel();
@ -155,7 +155,7 @@ namespace PlexRequests.Core
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))
.Select(JsonConvert.DeserializeObject<RequestedModel>)
.ToList();
@ -169,7 +169,7 @@ namespace PlexRequests.Core
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();
return await Repo.UpdateAllAsync(entities);
return await Repo.UpdateAllAsync(entities).ConfigureAwait(false);
}
public bool BatchDelete(IEnumerable<RequestedModel> model)
{
@ -180,7 +180,7 @@ namespace PlexRequests.Core
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();
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
using PlexRequests.Core.Models;
namespace PlexRequests.Core
namespace PlexRequests.Core.Notification
{
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.
// ************************************************************************/
#endregion
namespace PlexRequests.Core
namespace PlexRequests.Core.Notification
{
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.
// ************************************************************************/
#endregion
using System;
using System.Collections.Generic;
namespace PlexRequests.Core
namespace PlexRequests.Core.Notification
{
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.SettingModels;
namespace PlexRequests.Core
namespace PlexRequests.Core.Notification
{
public class NotificationMessageResolver
{
/// <summary>
/// The start character '{'
/// </summary>
private const char StartChar = (char)123;
/// <summary>
/// The end character '}'
/// </summary>
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
{
var content = notification.Message.FirstOrDefault(x => x.NotificationType == type);
@ -47,33 +62,30 @@ namespace PlexRequests.Core
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 subjectFields = FindCurlyFields(subject);
foreach (var f in bodyFields)
{
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);
}
}
body = ReplaceFields(bodyFields, parameters, body);
subject = ReplaceFields(subjectFields, parameters, subject);
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)
{
if (string.IsNullOrEmpty(message))
@ -116,5 +128,25 @@ namespace PlexRequests.Core
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>
<Compile Include="CacheKeys.cs" />
<Compile Include="NotificationMessage.cs" />
<Compile Include="NotificationMessageContent.cs" />
<Compile Include="NotificationMessageCurlys.cs" />
<Compile Include="NotificationMessageResolver.cs" />
<Compile Include="Notification\NotificationMessage.cs" />
<Compile Include="Notification\NotificationMessageContent.cs" />
<Compile Include="Notification\NotificationMessageCurlys.cs" />
<Compile Include="Notification\NotificationMessageResolver.cs" />
<Compile Include="IIssueService.cs" />
<Compile Include="IRequestService.cs" />
<Compile Include="ISettingsService.cs" />
@ -130,6 +130,7 @@
<Name>PlexRequests.Store</Name>
</ProjectReference>
</ItemGroup>
<ItemGroup />
<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
<!-- 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.

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

@ -1,37 +1,37 @@
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
// General Information about an assembly is controlled through the following
// set of attributes. Change these attribute values to modify the information
// associated with an assembly.
[assembly: AssemblyTitle("PlexRequests.Core")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("PlexRequests.Core")]
[assembly: AssemblyCopyright("Copyright © 2016")]
[assembly: AssemblyTrademark("")]
[assembly: AssemblyCulture("")]
// 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
// COM, set the ComVisible attribute to true on that type.
[assembly: ComVisible(false)]
// The following GUID is for the ID of the typelib if this project is exposed to COM
[assembly: Guid("dd7dc444-d3bf-4027-8ab9-efc71f5ec581")]
// Version information for an assembly consists of the following four values:
//
// Major Version
// Minor Version
// Build Number
// Revision
//
// You can specify all the values or you can default the Build and Revision Numbers
// by using the '*' as shown below:
// [assembly: AssemblyVersion("1.0.*")]
[assembly: AssemblyVersion("1.0.0.0")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersionAttribute("1.0.0.0")]
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
// General Information about an assembly is controlled through the following
// set of attributes. Change these attribute values to modify the information
// associated with an assembly.
[assembly: AssemblyTitle("PlexRequests.Core")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("PlexRequests.Core")]
[assembly: AssemblyCopyright("Copyright © 2016")]
[assembly: AssemblyTrademark("")]
[assembly: AssemblyCulture("")]
// 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
// COM, set the ComVisible attribute to true on that type.
[assembly: ComVisible(false)]
// The following GUID is for the ID of the typelib if this project is exposed to COM
[assembly: Guid("dd7dc444-d3bf-4027-8ab9-efc71f5ec581")]
// Version information for an assembly consists of the following four values:
//
// Major Version
// Minor Version
// Build Number
// Revision
//
// You can specify all the values or you can default the Build and Revision Numbers
// by using the '*' as shown below:
// [assembly: AssemblyVersion("1.0.*")]
[assembly: AssemblyVersion("1.0.0.0")]
[assembly: AssemblyFileVersion("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 PlexRequests.Core.Models;
using PlexRequests.Core.Notification;
namespace PlexRequests.Core.SettingModels
{
@ -40,21 +41,15 @@ namespace PlexRequests.Core.SettingModels
new NotificationMessage { NotificationType = NotificationType.Issue },
new NotificationMessage { NotificationType = NotificationType.AdminNote },
new NotificationMessage { NotificationType = NotificationType.RequestApproved },
new NotificationMessage { NotificationType = NotificationType.RequestAvailable },
new NotificationMessage { NotificationType = NotificationType.RequestAvailable }
};
}
public List<NotificationMessage> Message { get; set; }
}
public static class NotificationCurly
{
public static readonly List<string> Curlys = new List<string>
{
"Username",
"Title",
"Date",
"Issue",
"Type"
};
public static readonly List<string> Curlys = new List<string> { "Username", "Title", "Date", "Issue", "Type" };
}
}

6
PlexRequests.Core/SettingsServiceV2.cs
View file

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

164
PlexRequests.Core/StatusChecker.cs
View file

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

2
PlexRequests.Helpers/CookieHelper.cs
View file

@ -41,7 +41,7 @@ namespace PlexRequests.Helpers
/// <returns></returns>
public static string GetAnalyticClientId(IDictionary<string, string> cookies)
{
var outString = string.Empty;
string 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())
{
db.Open();
await db.DeleteAsync(entity);
await db.DeleteAsync(entity).ConfigureAwait(false);
}
}
catch (SqliteException e) when (e.ErrorCode == SQLiteErrorCode.Corrupt)
@ -134,7 +134,7 @@ namespace PlexRequests.Store.Repository
using (var db = Config.DbConnection())
{
db.Open();
return await db.UpdateAsync(entity);
return await db.UpdateAsync(entity).ConfigureAwait(false);
}
}
catch (SqliteException e) when (e.ErrorCode == SQLiteErrorCode.Corrupt)
@ -173,16 +173,17 @@ namespace PlexRequests.Store.Repository
try
{
ResetCache();
var result = new HashSet<bool>();
var tasks = new List<Task<bool>>();
using (var db = Config.DbConnection())
{
db.Open();
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);
}
catch (SqliteException e) when (e.ErrorCode == SQLiteErrorCode.Corrupt)
@ -200,7 +201,7 @@ namespace PlexRequests.Store.Repository
using (var cnn = Config.DbConnection())
{
cnn.Open();
return await cnn.InsertAsync(entity);
return await cnn.InsertAsync(entity).ConfigureAwait(false);
}
}
catch (SqliteException e) when (e.ErrorCode == SQLiteErrorCode.Corrupt)
@ -240,7 +241,7 @@ namespace PlexRequests.Store.Repository
using (var db = Config.DbConnection())
{
db.Open();
var result = await db.GetAllAsync<T>();
var result = await db.GetAllAsync<T>().ConfigureAwait(false);
return result;
}
}

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

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

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

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

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

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

158
PlexRequests.Store/UserRepository.cs
View file

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