/// <inheritdoc />
public async Task <PagedResult <RoomEntity> > GetRoomsAsync(PagingModel paging)
{
var rooms = await _linqProvider.Query <RoomEntity>()
.AsPagedAsync(paging.Page, paging.Size);
return(rooms);
}
/// <inheritdoc />
public async Task <PagedResult <BookingEntity> > GetBookingsAsync(int page, int size)
{
var bookings = await _linqProvider.Query <BookingEntity>()
.AsPagedAsync(page, size);
return(bookings);
}
public Task <DeliveryInterval> AskAsync(DeliveryIntervalWithTemplateByIdCriterion criterion)
{
return(_linqProvider.Query <DeliveryInterval>()
.Include(x => x.DeliveryIntervalTemplate)
.Where(x => x.Id == criterion.DeliveryIntervalId)
.FirstOrDefaultAsync());
}
public Task <SubscriptionDate> AskAsync(LastSubscriptionDateForSubscriptionRepositoryCriterion criterion)
{
return(_linqProvider.Query <SubscriptionDate>()
.Where(x => x.SubscriptionId == criterion.SubscriptionId)
.OrderByDescending(x => x.Date)
.FirstOrDefaultAsync());
}
/// <summary>
/// Initializes a new instance of the <see cref="AddBookingFilterValidator" /> class.
/// </summary>
public AddBookingFilterValidator(ILinqProvider linqProvider)
{
RuleFor(x => x.StartDate)
.LessThanOrEqualTo(x => x.EndDate)
.WithMessage("'startdDate' cannot be greater that 'endDate'");
RuleFor(x => x.EndDate)
.GreaterThanOrEqualTo(x => x.StartDate)
.WithMessage("'endDate' cannot be less that 'startDate'");
RuleFor(x => x)
.Must(y =>
{
var bookingsDates = linqProvider.Query <BookingEntity>()
.Where(x => x.RoomId == y.RoomId)
.Select(x => new { x.StartDate, x.EndDate })
.ToList();
foreach (var booking in bookingsDates)
{
if (y.StartDate < booking.EndDate.AddDays(1) && y.EndDate > booking.StartDate)
{
return(false);
}
}
return(true);
})
.WithMessage("There is overlapping with existing bookings, please re-check yours request dates");
}
private IQueryable <TEntity> PreQuery(ILinqProvider linqProvider, TParam qrit)
{
var res = linqProvider.Query <TEntity>()
.Apply(Spec, qrit);
return(res);
}
public async Task EFQueryAsyncTest()
{
int cntBook = 0;
using (ILinqProvider linq = serviceLocator.GetInstance <ILinqProviderFactory>().Create())
{
var books = linq.Query <Book>().ToList();
Assert.IsNotNull(books);
cntBook = books.Count();
Assert.IsTrue(cntBook > 0);
}
var allBooks = await handlerLocator
.For <IEnumerable <BookDto> >()
.AskAsync(new BookOrAuthorQriteria());
var idQrit = new IdQriteria {
Id = 2
};
var book = await handlerLocator
.For <BookDto>()
.AskAsync(idQrit);
Assert.IsNotNull(allBooks);
Assert.IsInstanceOfType(allBooks, typeof(IEnumerable <BookDto>));
Assert.IsTrue(allBooks.Count() > 0);
Assert.IsTrue(allBooks.Count() == cntBook);
Assert.IsNotNull(book);
Assert.IsInstanceOfType(book, typeof(BookDto));
Assert.AreEqual(idQrit.Id, book.Id);
}
public Task <IQueryable <TResult> > AskAsync(GetCriterion criterion)
{
return(Task.FromResult(
linqProvider.Query <TEntity>()
.ProjectTo <TResult>(mapper.ConfigurationProvider)
.DecompileAsync()
));
}
public void InMemoryStoreTest()
{
using (var store = new InMemoryStore())
{
store.Register <Author>();
IUnitOfWork uow = store as IUnitOfWork;
const int authorCount = 100;
Parallel.For(0, authorCount, i =>
{
uow.Add(new Author(i, $"Author {i}"));
});
ILinqProvider linq = store as ILinqProvider;
Assert.AreEqual(authorCount, linq.Query <Author>().Count());
int id = 3;
Assert.AreEqual(1, linq.Query <Author>().Where(a => a.Id == id).Count());
Assert.AreEqual(id, linq.Query <Author>().Where(a => a.Id == id).FirstOrDefault().Id);
Assert.AreEqual($"Author {id}", linq.Query <Author>().Where(a => a.Id == id).FirstOrDefault().Name);
var author = new Author(id, $"Author#{id}");
uow.Update(author);
uow.Commit();
Assert.AreEqual(1, linq.Query <Author>().Where(a => a.Id == id).Count());
Assert.AreEqual(author.Id, linq.Query <Author>().Where(a => a.Id == id).FirstOrDefault().Id);
Assert.AreEqual(author.Name, linq.Query <Author>().Where(a => a.Id == id).FirstOrDefault().Name);
Parallel.For(0, 100, i =>
{
var updAuthor = new Author(id, $"Author#{i}");
uow.Update(updAuthor);
});
}
}
protected virtual IQueryable <TDest> GetQueryable(TSpecification spec)
{
return(LinqProvider
.Query <TSource>()
.MaybeWhere(spec)
.MaybeSort(spec)
.Project <TSource, TDest>(Projector)
.MaybeWhere(spec)
.MaybeSort(spec));
}
public override Result Request(ILinqProvider linq, CreateBookCmd qrit)
{
var query = linq.Query <Book>()
.Where(b => b.Name == qrit.Name)
.AsNoTracking();
if (!query.Any())
{
return(Result.Ok());
}
return(new Failure(Messages.BookNameUnique, query.ToList()));
}
public IQueryable Query(ILinqProvider linqProvider, IPageQriteria <TParam> qrit)
{
var filterExpr = qrit.Subject != null ?
ConventionBuilder <TEntity> .FilterExpression(qrit.Subject)
: (x) => true;
var query = linqProvider
.Query <TEntity>()
.Where(filterExpr)
.OrderByConventions(qrit);
return(query);
}
private IQueryable <Expert> FetchQuery(ExpertFetch expertFetch)
{
var query = _linqProvider.Query <Expert>();
if ((expertFetch & ExpertFetch.Associations) == ExpertFetch.Associations)
{
query.FetchMany(x => x.Associations);
}
if ((expertFetch & ExpertFetch.Relations) == ExpertFetch.Relations)
{
query.FetchMany(x => x.Relations);
}
return(query);
}
public override IEnumerable <Object> Request(ILinqProvider linqProvider, BookInGenreQrit qrit)
{
// некая сложная выборка, для которой недостаточно Expression
var q1 = from b in linqProvider.Query <Book>()
where b.BookGenres.Any(bg => bg.Genre.Name.StartsWith(qrit.Name))
select new { b.Id, BookName = b.Name, b.BookGenres };
var d1 = q1.ToArray();
var q2 = from b in d1
select new
{
b.BookName,
Genre = b.BookGenres.AsQueryable().Aggregate("Genre(s): ", (g, next) => g + ", " + next.Genre.Name)
};
return(q2);
}
public IReadOnlyCollection <NodeCandidate> GetNodeCandidatesBySession(SessionOfExperts session)
{
var totalExpectCount = new GetExpertCountQuery(_linqProvider).Execute(
new GetExpertCountSpecification(session));
return(_linqProvider.Query <Association>()
.Where(x => x.Expert.SessionOfExperts == session)
.GroupBy(x => new { x.Notion, TypeName = x.Type.Name, TypeId = x.Type.Id })
.Select(
gr => new NodeCandidate
{
Notion = gr.Key.Notion,
TypeId = gr.Key.TypeId,
TypeName = gr.Key.TypeName,
ExpertCount = gr.Count(),
TotalExpert = totalExpectCount
})
.ToList());
}
public IReadOnlyCollection <GroupedRelation> GetGroupedRelations(SessionOfExperts sessionOfExperts)
{
var totalExpectCount = new GetExpertCountQuery(_linqProvider).Execute(
new GetExpertCountSpecification(sessionOfExperts));
var relations = _linqProvider.Query <Relation>()
.SelectMany(x => x.Types, (relation, type) => new { relation.Source, relation.Destination, Type = type })
.ToList();
return(relations
.GroupBy(x => new { x.Source, x.Destination, x.Type })
.Select(
gr => new GroupedRelation
{
Source = gr.Key.Source,
Destination = gr.Key.Destination,
Type = gr.Key.Type,
ExpertCount = gr.Count(),
TotalExpectCount = totalExpectCount
})
.ToList());
}
public Task <Subscription> AskAsync(SubscriptionWithProductsCriterion criterion)
{
return(_linqProvider.Query <Subscription>().Include(x => x.Products).FirstOrDefaultAsync());
}
public virtual TResult Ask(TKey specification) =>
Projector.Project <TEntity, TResult>(LinqProvider
.Query <TEntity>()
.Where(x => specification.Equals(x.Id)))
.SingleOrDefault();
private IQueryable <TEntity> Query(TKey specification) => LinqProvider .Query <TEntity>() .Where(x => specification.Equals(x.Id));
public Task <DeliveryIntervalTemplate> AskAsync(DeliveryIntervalTemplateByIdCriterion criterion)
{
return(_linqProvider.Query <DeliveryIntervalTemplate>()
.FirstOrDefaultAsync(x => x.Id == criterion.DeliveryIntervalTemplateId));
}
/// <summary>
/// Initializes a new instance of the <see cref="GetAvailableRoomDatesFilterValidator" /> class.
/// </summary>
public GetAvailableRoomDatesFilterValidator(ILinqProvider linqProvider)
{
RuleFor(x => x.Id)
.Must(x => linqProvider.Query <RoomEntity>().Any(y => y.Id == x))
.WithMessage("There is not such room with provided id");
}
public static TEntity ById <TEntity>(this ILinqProvider linqProvider, int id)
where TEntity : class, IHasId <int>
=> linqProvider.Query <TEntity>().ById(id);
public virtual IQueryable <TEntity> Query <TEntity>()
where TEntity : class, IEntity, new()
{
return(_linq.Query <TEntity>());
}
public Task <List <Product> > AskAsync(AllProductsCriterion criterion)
{
return(_linqProvider.Query <Product>()
.ToListAsync());
}
protected IQueryable <T> Query <T>()
{
return(linqProvider.Query <T>());
}
public IQueryable Query(ILinqProvider linqProvider, IHasId qrit) => linqProvider.Query <TEntity>() .Where(ConventionBuilder <TEntity> .IdFilterExpression(qrit));
public Task <long> AskAsync(SubscriptionIdCriterion criterion)
{
return(_linqProvider.Query <Subscription>().Select(x => x.Id).FirstOrDefaultAsync());
}
public Task <List <DeliveryIntervalTemplate> > AskAsync(AllDeliveryIntervalTemplatesCriterion criterion)
{
return(_linqProvider.Query <DeliveryIntervalTemplate>().ToListAsync());
}
public Node GetByNotionAndType(string notion, NotionType type)
{
return(_linqProvider.Query <Node>().SingleOrDefault(x => x.Notion == notion && x.Type == type));
}
public Verge GetByNodesAndTypes(Node source, Node destination, RelationType type)
{
return(_linqProvider.Query <Verge>()
.SingleOrDefault(x => x.SourceNode == source && x.DestinationNode == destination && x.Type == type));
}