github/Ombi
1
0
Fork 0
mirror of https://github.com/Ombi-app/Ombi.git synced 2025-07-14 01:02:57 -07:00
Code Issues Projects Releases Packages Wiki Activity Actions

Made a generic repository to use !minor

Browse source
This commit is contained in:
Jamie.Rees 2017-10-17 15:03:00 +01:00
parent ba04a9d1b1
commit 894945f652
8 changed files with 99 additions and 149 deletions
Download patch file Download diff file Expand all files Collapse all files

113
src/Ombi.Core.Tests/Rule/Search/RadarrCacheRuleTests.cs
View file

@ -1,16 +1,12 @@
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.EntityFrameworkCore;
using Microsoft.EntityFrameworkCore.Query.Internal;
using Moq;
using NUnit.Framework;
using Ombi.Core.Models.Search;
using Ombi.Core.Rule.Rules.Search;
using Ombi.Store.Context;
using Ombi.Store.Entities;
using Ombi.Store.Repository;
namespace Ombi.Core.Tests.Rule.Search
{
@ -19,38 +15,23 @@ namespace Ombi.Core.Tests.Rule.Search
[SetUp]
public void Setup()
{
ContextMock = new Mock<IOmbiContext>();
ContextMock = new Mock<IRepository<RadarrCache>>();
Rule = new RadarrCacheRule(ContextMock.Object);
}
private RadarrCacheRule Rule { get; set; }
private Mock<IOmbiContext> ContextMock { get; set; }
private Mock<IRepository<RadarrCache>> ContextMock { get; set; }
[Test]
[Ignore("EF IAsyncQueryProvider")]
public async Task Should_ReturnApproved_WhenMovieIsInRadarr()
{
var list = new List<RadarrCache>(){new RadarrCache
{
TheMovieDbId = 123
}}.AsQueryable();
var radarrMock = new Mock<DbSet<RadarrCache>>();
radarrMock.As<IAsyncEnumerable<RadarrCache>>()
.Setup(m => m.GetEnumerator())
.Returns(new TestAsyncEnumerator<RadarrCache>(list.GetEnumerator()));
radarrMock.As<IQueryable<RadarrCache>>()
.Setup(m => m.Provider)
.Returns(new TestAsyncQueryProvider<RadarrCache>(list.Provider));
radarrMock.As<IQueryable<RadarrCache>>().Setup(m => m.Expression).Returns(list.Expression);
radarrMock.As<IQueryable<RadarrCache>>().Setup(m => m.ElementType).Returns(list.ElementType);
radarrMock.As<IQueryable<RadarrCache>>().Setup(m => m.GetEnumerator()).Returns(() => list.GetEnumerator());
ContextMock.Setup(c => c.Set<RadarrCache>()).Returns(radarrMock.Object);
ContextMock.Setup(x => x.GetAll()).Returns(list);
var request = new SearchMovieViewModel { Id = 123 };
var result =await Rule.Execute(request);
@ -61,7 +42,6 @@ namespace Ombi.Core.Tests.Rule.Search
[Test]
[Ignore("EF IAsyncQueryProvider")]
public async Task Should_ReturnNotApproved_WhenMovieIsNotInRadarr()
{
var list = DbHelper.GetQueryableMockDbSet(new RadarrCache
@ -69,7 +49,7 @@ namespace Ombi.Core.Tests.Rule.Search
TheMovieDbId = 000012
});
ContextMock.Setup(x => x.RadarrCache).Returns(list);
ContextMock.Setup(x => x.GetAll()).Returns(list);
var request = new SearchMovieViewModel { Id = 123 };
var result = await Rule.Execute(request);
@ -78,87 +58,4 @@ namespace Ombi.Core.Tests.Rule.Search
Assert.False(request.Approved);
}
}
internal class TestAsyncQueryProvider<TEntity> : IAsyncQueryProvider
{
private readonly IQueryProvider _inner;
internal TestAsyncQueryProvider(IQueryProvider inner)
{
_inner = inner;
}
public IQueryable CreateQuery(Expression expression)
{
return new TestAsyncEnumerable<TEntity>(expression);
}
public IQueryable<TElement> CreateQuery<TElement>(Expression expression)
{
return new TestAsyncEnumerable<TElement>(expression);
}
public object Execute(Expression expression)
{
return _inner.Execute(expression);
}
public TResult Execute<TResult>(Expression expression)
{
return _inner.Execute<TResult>(expression);
}
public IAsyncEnumerable<TResult> ExecuteAsync<TResult>(Expression expression)
{
return new TestAsyncEnumerable<TResult>(expression);
}
public Task<TResult> ExecuteAsync<TResult>(Expression expression, CancellationToken cancellationToken)
{
return Task.FromResult(Execute<TResult>(expression));
}
}
internal class TestAsyncEnumerable<T> : EnumerableQuery<T>, IAsyncEnumerable<T>, IQueryable<T>
{
public TestAsyncEnumerable(IEnumerable<T> enumerable)
: base(enumerable)
{ }
public TestAsyncEnumerable(Expression expression)
: base(expression)
{ }
public IAsyncEnumerator<T> GetEnumerator()
{
return new TestAsyncEnumerator<T>(this.AsEnumerable().GetEnumerator());
}
IQueryProvider IQueryable.Provider
{
get { return new TestAsyncQueryProvider<T>(this); }
}
}
internal class TestAsyncEnumerator<T> : IAsyncEnumerator<T>
{
private readonly IEnumerator<T> _inner;
public TestAsyncEnumerator(IEnumerator<T> inner)
{
_inner = inner;
}
public void Dispose()
{
_inner.Dispose();
}
public T Current => _inner.Current;
public Task<bool> MoveNext(CancellationToken cancellationToken)
{
return Task.FromResult(_inner.MoveNext());
}
}
}

18
src/Ombi.Core/Rule/Rules/Search/RadarrCacheRule.cs
View file

@ -1,35 +1,33 @@
using System.Linq;
using System.Threading.Tasks;
using Microsoft.EntityFrameworkCore;
using Ombi.Core.Models.Search;
using Ombi.Core.Rule.Interfaces;
using Ombi.Store.Context;
using Ombi.Store.Entities;
using Ombi.Store.Repository;
namespace Ombi.Core.Rule.Rules.Search
{
public class RadarrCacheRule : BaseSearchRule, IRules<SearchViewModel>
{
public RadarrCacheRule(IOmbiContext ctx)
public RadarrCacheRule(IRepository<RadarrCache> db)
{
_ctx = ctx;
_db = db;
}
private readonly IOmbiContext _ctx;
private readonly IRepository<RadarrCache> _db;
public async Task<RuleResult> Execute(SearchViewModel obj)
public Task<RuleResult> Execute(SearchViewModel obj)
{
if (obj.Type == RequestType.Movie)
{
// Check if it's in Radarr
var result = await _ctx.RadarrCache.FirstOrDefaultAsync(x => x.TheMovieDbId == obj.Id);
var result = _db.GetAll().FirstOrDefault(x => x.TheMovieDbId == obj.Id);
if (result != null)
{
obj.Approved =
true; // It's in radarr so it's approved... Maybe have a new property called "Processing" or something?
obj.Approved = true; // It's in radarr so it's approved... Maybe have a new property called "Processing" or something?
}
}
return Success();
return Task.FromResult(Success());
}
}
}

1
src/Ombi.DependencyInjection/IocExtensions.cs
View file

@ -115,6 +115,7 @@ namespace Ombi.DependencyInjection
services.AddTransient<IApplicationConfigRepository, ApplicationConfigRepository>();
services.AddTransient<ITokenRepository, TokenRepository>();
services.AddTransient(typeof(ISettingsService<>), typeof(SettingsService<>));
services.AddTransient(typeof(IRepository<>), typeof(Repository<>));
}
public static void RegisterServices(this IServiceCollection services)
{

1
src/Ombi.Store/Context/OmbiContext.cs
View file

@ -67,7 +67,6 @@ namespace Ombi.Store.Context
.HasPrincipalKey(x => x.EmbyId)
.HasForeignKey(p => p.ParentId);
builder.Ignore<Logs>();
base.OnModelCreating(builder);
}

5
src/Ombi.Store/Repository/IPlexContentRepository.cs
View file

@ -5,12 +5,10 @@ using Ombi.Store.Entities;
namespace Ombi.Store.Repository
{
public interface IPlexContentRepository
public interface IPlexContentRepository : IRepository<PlexContent>
{
Task<PlexContent> Add(PlexContent content);
Task AddRange(IEnumerable<PlexContent> content);
Task<bool> ContentExists(string providerId);
Task<IEnumerable<PlexContent>> GetAll();
Task<PlexContent> Get(string providerId);
Task<PlexContent> GetByKey(int key);
Task Update(PlexContent existingContent);
@ -18,6 +16,5 @@ namespace Ombi.Store.Repository
Task<PlexEpisode> Add(PlexEpisode content);
Task<PlexEpisode> GetEpisodeByKey(int key);
Task AddRange(IEnumerable<PlexEpisode> content);
IQueryable<PlexContent> Get();
}
}

22
src/Ombi.Store/Repository/IRepository.cs Normal file
View file

@ -0,0 +1,22 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;
using System.Threading.Tasks;
using Microsoft.EntityFrameworkCore.Query;
using Ombi.Store.Entities;
namespace Ombi.Store.Repository
{
public interface IRepository<T> where T : Entity
{
Task<T> Find(object key);
IQueryable<T> GetAll();
Task<T> FirstOrDefaultAsync(Expression<Func<T, bool>> predicate);
Task AddRange(IEnumerable<T> content);
IIncludableQueryable<TEntity, TProperty> Include<TEntity, TProperty>(
IQueryable<TEntity> source, Expression<Func<TEntity, TProperty>> navigationPropertyPath)
where TEntity : class;
}
}

26
src/Ombi.Store/Repository/PlexContentRepository.cs
View file

@ -34,49 +34,27 @@ using Ombi.Store.Entities;
namespace Ombi.Store.Repository
{
public class PlexContentRepository : IPlexContentRepository
public class PlexContentRepository : Repository<PlexContent>, IPlexContentRepository
{
public PlexContentRepository(IOmbiContext db)
public PlexContentRepository(IOmbiContext db) : base(db)
{
Db = db;
}
private IOmbiContext Db { get; }
public async Task<IEnumerable<PlexContent>> GetAll()
{
return await Db.PlexContent.ToListAsync();
}
public async Task AddRange(IEnumerable<PlexContent> content)
{
Db.PlexContent.AddRange(content);
await Db.SaveChangesAsync();
}
public async Task<bool> ContentExists(string providerId)
{
return await Db.PlexContent.AnyAsync(x => x.ProviderId == providerId);
}
public async Task<PlexContent> Add(PlexContent content)
{
await Db.PlexContent.AddAsync(content);
await Db.SaveChangesAsync();
return content;
}
public async Task<PlexContent> Get(string providerId)
{
return await Db.PlexContent.FirstOrDefaultAsync(x => x.ProviderId == providerId);
}
public IQueryable<PlexContent> Get()
{
return Db.PlexContent.AsQueryable();
}
public async Task<PlexContent> GetByKey(int key)
{
return await Db.PlexContent.Include(x => x.Seasons).FirstOrDefaultAsync(x => x.Key == key);

58
src/Ombi.Store/Repository/Repository.cs Normal file
View file

@ -0,0 +1,58 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;
using System.Threading.Tasks;
using Microsoft.EntityFrameworkCore;
using Microsoft.EntityFrameworkCore.Query;
using Ombi.Store.Context;
using Ombi.Store.Entities;
namespace Ombi.Store.Repository
{
public class Repository<T> : IRepository<T> where T : Entity
{
public Repository(IOmbiContext ctx)
{
_ctx = ctx;
_db = _ctx.Set<T>();
}
private readonly DbSet<T> _db;
private readonly IOmbiContext _ctx;
public async Task<T> Find(object key)
{
return await _db.FindAsync(key);
}
public IQueryable<T> GetAll()
{
return _db.AsQueryable();
}
public async Task<T> FirstOrDefaultAsync(Expression<Func<T,bool>> predicate)
{
return await _db.FirstOrDefaultAsync(predicate);
}
public async Task AddRange(IEnumerable<T> content)
{
_db.AddRange(content);
await _ctx.SaveChangesAsync();
}
public async Task<T> Add(T content)
{
await _db.AddAsync(content);
await _ctx.SaveChangesAsync();
return content;
}
public IIncludableQueryable<TEntity, TProperty> Include<TEntity, TProperty>(
IQueryable<TEntity> source, Expression<Func<TEntity, TProperty>> navigationPropertyPath)
where TEntity : class
{
return source.Include(navigationPropertyPath);
}
}
}