/// <summary> /// Update existing entity using object as a new state. /// </summary> /// <param name="entity">New state of existing entity.</param> /// <returns>A <see cref="Task"/> representing the result of the asynchronous operation.</returns> public async Task UpdateAsync(T entity) { await using CookingContext context = ContextFactory.Create(); T existing = await GetFullGraph(context.Set <T>()).FirstAsync(x => x.ID == entity.ID); Mapper.Map(entity, existing); await context.SaveChangesAsync(); }
/// <summary> /// Get entry, projected from <typeparamref name="T" />. /// </summary> /// <typeparam name="TProjection">Type of entry to project to.</typeparam> /// <param name="id">ID of entity to find and project.</param> /// <returns>Found projected entity.</returns> public TProjection GetProjected <TProjection>(Guid id) where TProjection : Entity { using CookingContext context = ContextFactory.Create(); TProjection?entryProjected = Mapper.ProjectTo <TProjection>(context.Set <T>()) .AsNoTracking() .FirstOrDefault(x => x.ID == id); return(Mapper.Map <TProjection>(entryProjected)); }
/// <summary> /// Remove entity from database. /// </summary> /// <param name="id">Id of entity to delete.</param> /// <returns>A <see cref="Task"/> representing the result of the asynchronous operation.</returns> public virtual async Task DeleteAsync(Guid id) { using CookingContext context = ContextFactory.Create(); // Remove entity without loading it, using stub object. context.Set <T>().Remove(new T { ID = id }); await context.SaveChangesAsync(); }
/// <summary> /// Create new entity in database. /// </summary> /// <param name="entity">Entity to insert into database.</param> /// <returns>A <see cref="Task{TResult}"/> representing the result of the asynchronous operation.</returns> public async Task <Guid> CreateAsync(T entity) { await using CookingContext context = ContextFactory.Create(); entity.Culture = GetCurrentCulture(); await context.Set <T>().AddAsync(entity); await context.SaveChangesAsync(); return(entity.ID); }
private T Get(Guid id, CookingContext context, bool isTracking = false) { IQueryable <T> set = context.Set <T>(); IQueryable <T> fullSet = GetFullGraph(set); if (!isTracking) { fullSet = fullSet.AsNoTracking(); } return(fullSet.AsSplitQuery().Single(x => x.ID == id)); }
/// <summary> /// Get a list of required properties for all objects matching filter. /// </summary> /// <typeparam name="TProperty">Type of property.</typeparam> /// <param name="propertySelector">Selector for a required property.</param> /// <param name="filter">Filter of objects to retrieve.</param> /// <returns>List of required properties for all objects matching filter.</returns> public List <TProperty> GetProperty <TProperty>(Expression <Func <T, TProperty> > propertySelector, Expression <Func <T, bool> >?filter = null) { using CookingContext context = ContextFactory.Create(); IQueryable <T> cultureSpecificSet = context.Set <T>().AsNoTracking(); if (filter != null) { cultureSpecificSet = cultureSpecificSet.Where(filter); } return(cultureSpecificSet.Select(propertySelector).ToList()); }
/// <summary> /// Get all entities for a type. /// </summary> /// <param name="predicate">Predicate to filter.</param> /// <returns>All entities for type <typeparamref name="T" />.</returns> public List <T> GetAll(Expression <Func <T, bool> >?predicate = null) { using CookingContext context = ContextFactory.Create(); IQueryable <T>?fullSet = GetFullGraph(context.Set <T>()); if (predicate != null) { fullSet = fullSet.Where(predicate); } return(fullSet.AsNoTracking() .AsSplitQuery() .ToList()); }
/// <summary> /// Get reipe list filtered by optional parameters. /// </summary> /// <typeparam name="T">Type of required projection.</typeparam> /// <param name="requiredTags">Filter reipies by tags.</param> /// <param name="requiredCalorieTypes">Filter reipies by calorie types.</param> /// <param name="maxComplexity">Filter reipies by maximal complexity.</param> /// <param name="minRating">Filter reipies by minimal rating.</param> /// <param name="onlyNew">Filter out reipies which already was cooked.</param> /// <returns>List of filtered recipies.</returns> public List <T> GetRecipiesByParametersProjected <T>(List <Guid>?requiredTags = null, List <CalorieType>?requiredCalorieTypes = null, int?maxComplexity = null, int?minRating = null, bool?onlyNew = false) where T : Entity { using CookingContext context = ContextFactory.Create(); IQueryable <Recipe> query = context.Set <Recipe>() .Include(x => x.Garnishes) .Include(x => x.Tags) .AsNoTracking() .AsQueryable(); if (requiredTags?.Count > 0) { query = query.Where(x => x.Tags !.Any(t => requiredTags.Contains(t.ID))); } if (requiredCalorieTypes?.Count > 0) { query = query.Where(x => requiredCalorieTypes.Contains(x.CalorieType)); } if (maxComplexity.HasValue) { query = query.Where(x => x.Difficulty <= maxComplexity.Value); } if (minRating.HasValue) { query = query.Where(x => x.Rating >= minRating.Value); } var queryResult = Mapper.ProjectTo <T>(query).ToList(); // Client filtration if (onlyNew.HasValue && onlyNew.Value) { queryResult = queryResult.Where(x => dayService.GetLastCookedDate(x.ID) == null).ToList(); } return(queryResult.OrderByDescending(x => DaysFromLasCook(x.ID)).ToList()); }
/// <summary> /// Get all entities of type <typeparamref name="T" /> mapped to TProjection. /// </summary> /// <typeparam name="TProjection">Type to map <typeparamref name="T" /> to.</typeparam> /// <param name="predicate">Filter of objects to retrieve.</param> /// <param name="clientsidePredicate">Predicate to filter after data loading.</param> /// <returns>List of all mapped entities.</returns> public List <TProjection> GetMapped <TProjection>(Expression <Func <T, bool> >?predicate = null, Func <T, bool>?clientsidePredicate = null) { using CookingContext context = ContextFactory.Create(); IQueryable <T> cultureSet = context.Set <T>(); IQueryable <T>?fullSet = GetFullGraph(cultureSet); IEnumerable <T>?set = fullSet.AsNoTracking(); if (predicate != null) { fullSet = fullSet.Where(predicate); } IEnumerable <T> queryResult = fullSet.AsEnumerable(); if (clientsidePredicate != null) { queryResult = queryResult.Where(clientsidePredicate); } return(Mapper.Map <List <TProjection> >(queryResult)); }
/// <summary> /// Get all entities of type <typeparamref name="T" /> projected to TProjection. /// </summary> /// <typeparam name="TProjection">Type to project <typeparamref name="T" /> to.</typeparam> /// <param name="predicate">Predicate to filter.</param> /// <param name="callAfterMap">Do mapping after projection to call AfterMap. Needs mapping from TProjection to TProjection, otherwise will have no effect.</param> /// <returns>List of all projected entities.</returns> public List <TProjection> GetProjected <TProjection>(Expression <Func <T, bool> >?predicate = null, bool callAfterMap = false) { using CookingContext context = ContextFactory.Create(); IQueryable <T> cultureSpecificSet = context.Set <T>().AsNoTracking(); if (predicate != null) { cultureSpecificSet = cultureSpecificSet.Where(predicate); } var allProjected = Mapper.ProjectTo <TProjection>(cultureSpecificSet).ToList(); if (callAfterMap) { // Here we mapping projected objects to themselves to enable AfterMap calls return(Mapper.Map <List <TProjection> >(allProjected)); } else { return(allProjected); } }
public virtual IQueryable <T> GetAll() { IQueryable <T> query = Context.Set <T>(); return(query); }