IncludeAvailabilityRestrictions(this IIncludableQueryable <ContractAccommodationRelation, SeasonRange> queryable,
AvailabilityRequest availabilityRequest)
=> queryable.Include(relation => relation.Accommodation)
.ThenInclude(accommodation => accommodation.Rooms)
.ThenInclude(room => room.AvailabilityRestrictions.Where(availabilityRestrictions
=> availabilityRequest.CheckInDate <= availabilityRestrictions.ToDate &&
availabilityRestrictions.FromDate <= availabilityRequest.CheckOutDate));
public static IIncludableQueryable<User, UserBuild> ThenIncludeEverything(this IIncludableQueryable<User, ICollection<User.UserGeneratedBuildOrder>> userBuilds)
{
return userBuilds
.Include(x => x.UserGeneratedBuildOrders)
.ThenInclude(x => x.UserGeneratedBuild)
.ThenInclude(x => x.Processor)
.Include(x => x.UserGeneratedBuildOrders)
.ThenInclude(x => x.UserGeneratedBuild)
.ThenInclude(x => x.Motherboard)
.Include(x => x.UserGeneratedBuildOrders)
.ThenInclude(x => x.UserGeneratedBuild)
.ThenInclude(x => x.Memory)
.Include(x => x.UserGeneratedBuildOrders)
.ThenInclude(x => x.UserGeneratedBuild)
.ThenInclude(x => x.GraphicsCard)
.Include(x => x.UserGeneratedBuildOrders)
.ThenInclude(x => x.UserGeneratedBuild)
.ThenInclude(x => x.Storage)
.Include(x => x.UserGeneratedBuildOrders)
.ThenInclude(x => x.UserGeneratedBuild)
.ThenInclude(x => x.PowerSupply)
.Include(x => x.UserGeneratedBuildOrders)
.ThenInclude(x => x.UserGeneratedBuild)
.ThenInclude(x => x.Case)
.Include(x => x.UserGeneratedBuildOrders)
.ThenInclude(x => x.UserGeneratedBuild);
}
public static IIncludableQueryable <ContractAccommodationRelation, IEnumerable <SeasonRange> > IncludeRates(
this IIncludableQueryable <ContractAccommodationRelation, IEnumerable <SeasonRange> > queryable, AvailabilityRequest availabilityRequest,
List <RoomTypes> roomTypes)
=> queryable.Include(relation => relation.Accommodation)
.ThenInclude(accommodation => accommodation.Rooms)
.ThenInclude(room => room.RoomRates.Where(rate => roomTypes.Contains(rate.RoomType) && rate.Season.SeasonRanges.Any(seasonRange
=> availabilityRequest.CheckInDate <= seasonRange.EndDate && seasonRange.StartDate <= availabilityRequest.CheckOutDate)))
.ThenInclude(rate => rate.Season)
.ThenInclude(season => season.SeasonRanges.Where(seasonRange
=> availabilityRequest.CheckInDate <= seasonRange.EndDate && seasonRange.StartDate <= availabilityRequest.CheckOutDate));
public static IIncludableQueryable <ContractAccommodationRelation, IEnumerable <SeasonRange> > IncludeCancellationPolicies(
this IIncludableQueryable <ContractAccommodationRelation, IEnumerable <RoomAvailabilityRestriction> > queryable,
AvailabilityRequest availabilityRequest)
=> queryable.Include(accommodation => accommodation.Accommodation)
.ThenInclude(accommodation => accommodation.Rooms)
.ThenInclude(room => room.CancellationPolicies.Where(cancellationPolicy => cancellationPolicy.Season.SeasonRanges.Any(seasonRange
=> availabilityRequest.CheckInDate <= seasonRange.EndDate && seasonRange.StartDate <= availabilityRequest.CheckOutDate)))
.ThenInclude(cancellationPolicy => cancellationPolicy.Season)
.ThenInclude(season => season.SeasonRanges.Where(seasonRange
=> availabilityRequest.CheckInDate <= seasonRange.EndDate && seasonRange.StartDate <= availabilityRequest.CheckOutDate));
protected IQueryable <TEntity> Include(params Expression <Func <TEntity, object> >[] includes)
{
IIncludableQueryable <TEntity, object> query = null;
if (includes.Length > 0)
{
query = DbSet.Include(includes[0]);
}
for (int queryIndex = 1; queryIndex < includes.Length; ++queryIndex)
{
query = query.Include(includes[queryIndex]);
}
return(query == null ? DbSet : (IQueryable <TEntity>)query);
}
public IQueryable <T> Include(params Expression <Func <T, object> >[] includes)
{
IIncludableQueryable <T, object> query = null;
if (includes.Length > 0)
{
query = this.EPlastDBContext.Set <T>().Include(includes[0]);
}
for (int queryIndex = 1; queryIndex < includes.Length; ++queryIndex)
{
query = query.Include(includes[queryIndex]);
}
return(query == null?this.EPlastDBContext.Set <T>() : (IQueryable <T>)query);
}
/// <summary>
/// include records from child table
/// </summary>
/// <param name="includes">multiple entities</param>
/// <returns></returns>
public IQueryable <T> GetIncluding(params Expression <Func <T, object> >[] includes)
{
IIncludableQueryable <T, object> query = null;
if (includes.Length > 0)
{
query = dbSet.Include(includes[0]);
}
for (int queryIndex = 1; queryIndex < includes.Length; ++queryIndex)
{
query = query.Include(includes[queryIndex]);
}
return(query == null ? dbSet : (IQueryable <T>)query);
}
//public IEnumerable<TEntity> Include(params Expression<Func<TEntity, object>>[] includes)
//{
// IDbSet<TEntity> dbSet = Context.Set<TEntity>();
// IEnumerable<TEntity> query = null;
// foreach (var include in includes)
// {
// query = dbSet.Include(include);
// }
// return query ?? dbSet;
//}
public IEnumerable <T> Include(params Expression <Func <T, object> >[] includes)
{
// IDbSet<T> dbSet = Context.Set<T>();
IIncludableQueryable <T, object> dbSet = null;
IEnumerable <T> query = null;
foreach (var include in includes)
{
query = dbSet.Include(include);
}
return(query ?? dbSet);
}
public async Task <IQueryable <TEntity> > Include(params Expression <Func <TEntity, object> >[] includes)
{
IIncludableQueryable <TEntity, object> query = null;
if (includes.Length > 0)
{
query = _applicationDbContext.Set <TEntity>().AsQueryable().Include(includes[0]);
}
for (int queryIndex = 1; queryIndex < includes.Length; ++queryIndex)
{
query = query.Include(includes[queryIndex]);
}
return(query ?? _applicationDbContext.Set <TEntity>().AsQueryable());
}
public async Task <List <T> > IncludeAsync(params Expression <Func <T, object> >[] includes)
{
IIncludableQueryable <T, object> query = null;
if (includes.Length > 0)
{
query = dbSet.Include(includes[0]);
}
for (int queryIndex = 1; queryIndex < includes.Length; ++queryIndex)
{
query = query.Include(includes[queryIndex]);
}
return(await((IQueryable <T>)query).ToListAsync());
}
public static IIncludableQueryable <TEntity, TProperty> IncludeData <TEntity, TProperty>(this IIncludableQueryable <TEntity, TProperty> query,
Expression <Func <TEntity, TProperty> > include)
where TEntity : class
{
return(query.Include(include));
}
public static IIncludableQueryable <Projet, IEnumerable <PieceJointe> > IncludePieceJointe(
this IIncludableQueryable <Projet, Professionnel> includable) =>
includable.Include(p => p.Declarations).ThenInclude(d => d.PiecesJointes);
public static IIncludableQueryable <ContractAccommodationRelation, Country> IncludeLocation(
this IIncludableQueryable <ContractAccommodationRelation, IEnumerable <RoomOccupancy> > queryable)
=> queryable.Include(relation => relation.Accommodation)
.ThenInclude(accommodation => accommodation.Location)
.ThenInclude(location => location.Country);
public static IIncludableQueryable <ContractAccommodationRelation, IEnumerable <RoomOccupancy> > IncludeRoomOccupations(
this IIncludableQueryable <ContractAccommodationRelation, IEnumerable <RoomPromotionalOffer> > queryable, AvailabilityRequest availabilityRequest)
=> queryable.Include(relation => relation.Accommodation)
.ThenInclude(accommodation => accommodation.Rooms)
.ThenInclude(room => room.RoomOccupations.Where(roomOccupation
=> availabilityRequest.CheckInDate <= roomOccupation.FromDate && roomOccupation.ToDate <= availabilityRequest.CheckOutDate));
public static IIncludableQueryable <ContractAccommodationRelation, IEnumerable <RoomPromotionalOffer> > IncludePromotionalOffers(
this IIncludableQueryable <ContractAccommodationRelation, IEnumerable <SeasonRange> > queryable, AvailabilityRequest availabilityRequest)
=> queryable.Include(relation => relation.Accommodation)
.ThenInclude(accommodation => accommodation.Rooms)
.ThenInclude(room => room.RoomPromotionalOffers.Where(promotionalOffer
=> availabilityRequest.CheckInDate <= promotionalOffer.ValidToDate && promotionalOffer.ValidFromDate <= availabilityRequest.CheckOutDate));
