public async Task <APIKeyData> GetKey(string apiKey)
 {
     using (var context = _applicationDbContextFactory.CreateContext())
     {
         return(await EntityFrameworkQueryableExtensions.SingleOrDefaultAsync(context.ApiKeys,
                                                                              data => data.Id == apiKey && data.Type != APIKeyType.Legacy));
     }
 }
Exemple #2
0
        public async Task <IActionResult> DeleteConfirmed(int id)
        {
            var contacts = await EntityFrameworkQueryableExtensions.SingleOrDefaultAsync(_context.Contacts, m => m.ID == id);

            _context.Contacts.Remove(contacts);
            await _context.SaveChangesAsync();

            return(RedirectToAction("Index"));
        }
Exemple #3
0
        public async Task <IActionResult> DeleteConfirmed(int id)
        {
            var tweet = await EntityFrameworkQueryableExtensions.SingleOrDefaultAsync <Tweet>(_context.Tweet, m => m.Id == id);

            _context.Tweet.Remove(tweet);
            await _context.SaveChangesAsync();

            return(RedirectToAction("Index"));
        }
Exemple #4
0
        public async Task <ICMODailyDto> Get(ICMODailyDto input)
        {
            var entity = EntityFrameworkQueryableExtensions.SingleOrDefaultAsync(context.ICMODaily, p => p.FID == input.FID);

            if (entity != null)
            {
                return(entity.MapTo <ICMODailyDto>());
            }

            return(new ICMODailyDto());
        }
        public async Task Remove(string id, string getUserId)
        {
            using (var context = _applicationDbContextFactory.CreateContext())
            {
                var key = await EntityFrameworkQueryableExtensions.SingleOrDefaultAsync(context.ApiKeys,
                                                                                        data => data.Id == id && data.UserId == getUserId);

                context.ApiKeys.Remove(key);
                await context.SaveChangesAsync();
            }
        }
        private async Task<SensorInfo> GetSensorInfo(int sensorId)
        {
            SensorInfo result;

            using (var uow = new UnitOfWork<SensorPoco>(new RomiDbContext()))
            {
                var poco = await EntityFrameworkQueryableExtensions.SingleOrDefaultAsync<SensorPoco>(
                               uow.Repository().Query(x => x.Id == sensorId).Include(t => t.Host));
                result = this._mapper.Map<SensorInfo>(poco);
            }

            return result;
        }
        private async Task<SensorInfo> GetSensorInfo(string typeName)
        {
            Type sensorType = Type.GetType(typeName, true, true);
            SensorInfo result;

            using (var uow = new UnitOfWork<SensorPoco>(new RomiDbContext()))
            {
                var poco = await EntityFrameworkQueryableExtensions.SingleOrDefaultAsync<SensorPoco>(
                               uow.Repository().Query(x => x.TypeName == typeName).Include(t => t.Host));
                result = this._mapper.Map<SensorInfo>(poco);
            }

            return result;
        }
Exemple #8
0
        // GET: Tweets/Edit/5
        public async Task <IActionResult> Edit(int?id)
        {
            if (id == null)
            {
                return(NotFound());
            }

            var tweet = await EntityFrameworkQueryableExtensions.SingleOrDefaultAsync <Tweet>(_context.Tweet, m => m.Id == id);

            if (tweet == null)
            {
                return(NotFound());
            }
            return(View(tweet));
        }
Exemple #9
0
        // GET: Contacts/Delete/5
        public async Task <IActionResult> Delete(int?id)
        {
            if (id == null)
            {
                return(NotFound());
            }

            var contacts = await EntityFrameworkQueryableExtensions.SingleOrDefaultAsync(_context.Contacts, m => m.ID == id);

            if (contacts == null)
            {
                return(NotFound());
            }

            return(View(contacts));
        }
Exemple #10
0
        // GET: Contacts/Details/5
        public async Task <IActionResult> Details(int?id)
        {
            if (id == null)
            {
                return(NotFound());
            }

            var contacts = await EntityFrameworkQueryableExtensions.SingleOrDefaultAsync(_context.Contacts, m => m.ID == id);

            if (contacts == null)
            {
                return(NotFound());
            }

            //var results = context.Actions.Include("User");
            return(View(contacts));
        }
 public virtual async Task <T> FindAsync(Expression <Func <T, bool> > match)
 {
     return(await EntityFrameworkQueryableExtensions.SingleOrDefaultAsync(_context.Set <T>(), match));
 }
 public Task <TSource> SingleOrDefaultAsync <TSource>(
     IQueryable <TSource> source,
     CancellationToken cancellationToken = default) =>
 EntityFrameworkQueryableExtensions.SingleOrDefaultAsync(source, cancellationToken);
Exemple #13
0
 /// <inheritdoc cref="EntityFrameworkQueryableExtensions.SingleOrDefaultAsync{TSource}(IQueryable{TSource}, Expression{Func{TSource, bool}}, CancellationToken)"/>
 public static Task <TSource> SingleOrDefaultAsyncEF <TSource>(
     this IQueryable <TSource> source,
     Expression <Func <TSource, bool> > predicate,
     CancellationToken cancellationToken = default)
 => EntityFrameworkQueryableExtensions.SingleOrDefaultAsync(source, predicate, cancellationToken);
 public Task <TEntity> SingleOrDefaultAsync <TEntity>(IQueryable <TEntity> source, CancellationToken cancellationToken)
 {
     return(EntityFrameworkQueryableExtensions.SingleOrDefaultAsync(source, cancellationToken));
 }
        public async Task Extension_methods_validate_arguments()
        {
            // ReSharper disable AssignNullToNotNullAttribute

            await ArgumentNullTest("source", () => EntityFrameworkQueryableExtensions.FirstAsync <int>(null));
            await ArgumentNullTest("source", () => EntityFrameworkQueryableExtensions.FirstAsync <int>(null, s => true));
            await ArgumentNullTest("predicate", () => Source().FirstAsync(null));
            await ArgumentNullTest("source", () => EntityFrameworkQueryableExtensions.FirstOrDefaultAsync <int>(null));
            await ArgumentNullTest("source", () => EntityFrameworkQueryableExtensions.FirstOrDefaultAsync <int>(null, s => true));
            await ArgumentNullTest("predicate", () => Source().FirstOrDefaultAsync(null));
            await ArgumentNullTest("source", () => EntityFrameworkQueryableExtensions.SingleAsync <int>(null));
            await ArgumentNullTest("source", () => EntityFrameworkQueryableExtensions.SingleAsync <int>(null, s => true));
            await ArgumentNullTest("predicate", () => Source().SingleAsync(null));
            await ArgumentNullTest("source", () => EntityFrameworkQueryableExtensions.SingleOrDefaultAsync <int>(null));
            await ArgumentNullTest("source", () => EntityFrameworkQueryableExtensions.SingleOrDefaultAsync <int>(null, s => true));
            await ArgumentNullTest("predicate", () => Source().SingleOrDefaultAsync(null));
            await ArgumentNullTest("source", () => EntityFrameworkQueryableExtensions.ContainsAsync(null, 1));
            await ArgumentNullTest("source", () => EntityFrameworkQueryableExtensions.ContainsAsync(null, 1, new CancellationToken()));
            await ArgumentNullTest("source", () => EntityFrameworkQueryableExtensions.AnyAsync <int>(null));
            await ArgumentNullTest("source", () => EntityFrameworkQueryableExtensions.AnyAsync <int>(null, s => true));
            await ArgumentNullTest("predicate", () => Source().AnyAsync(null));
            await ArgumentNullTest("source", () => EntityFrameworkQueryableExtensions.AllAsync <int>(null, s => true));
            await ArgumentNullTest("source", () => EntityFrameworkQueryableExtensions.AllAsync <int>(null, s => true, new CancellationToken()));
            await ArgumentNullTest("predicate", () => Source().AllAsync(null));
            await ArgumentNullTest("predicate", () => Source().AllAsync(null, new CancellationToken()));
            await ArgumentNullTest("source", () => EntityFrameworkQueryableExtensions.CountAsync <int>(null));
            await ArgumentNullTest("source", () => EntityFrameworkQueryableExtensions.CountAsync <int>(null, s => true));
            await ArgumentNullTest("predicate", () => Source().CountAsync(null));
            await ArgumentNullTest("source", () => EntityFrameworkQueryableExtensions.LongCountAsync <int>(null));
            await ArgumentNullTest("source", () => EntityFrameworkQueryableExtensions.LongCountAsync <int>(null, new CancellationToken()));
            await ArgumentNullTest("source", () => EntityFrameworkQueryableExtensions.LongCountAsync <int>(null, s => true));
            await ArgumentNullTest("source", () => EntityFrameworkQueryableExtensions.LongCountAsync <int>(null, s => true, new CancellationToken()));
            await ArgumentNullTest("predicate", () => Source().LongCountAsync(null));
            await ArgumentNullTest("predicate", () => Source().LongCountAsync(null, new CancellationToken()));
            await ArgumentNullTest("source", () => EntityFrameworkQueryableExtensions.MinAsync <int>(null));
            await ArgumentNullTest("source", () => EntityFrameworkQueryableExtensions.MinAsync <int>(null, new CancellationToken()));
            await ArgumentNullTest("source", () => EntityFrameworkQueryableExtensions.MinAsync <int, bool>(null, s => true));
            await ArgumentNullTest("source", () => EntityFrameworkQueryableExtensions.MinAsync <int, bool>(null, s => true, new CancellationToken()));
            await ArgumentNullTest("selector", () => Source().MinAsync <int, bool>(null));
            await ArgumentNullTest("selector", () => Source().MinAsync <int, bool>(null, new CancellationToken()));
            await ArgumentNullTest("source", () => EntityFrameworkQueryableExtensions.MaxAsync <int>(null));
            await ArgumentNullTest("source", () => EntityFrameworkQueryableExtensions.MaxAsync <int>(null, new CancellationToken()));
            await ArgumentNullTest("source", () => EntityFrameworkQueryableExtensions.MaxAsync <int, bool>(null, s => true));
            await ArgumentNullTest("source", () => EntityFrameworkQueryableExtensions.MaxAsync <int, bool>(null, s => true, new CancellationToken()));
            await ArgumentNullTest("selector", () => Source().MaxAsync <int, bool>(null));
            await ArgumentNullTest("selector", () => Source().MaxAsync <int, bool>(null, new CancellationToken()));
            await ArgumentNullTest("source", () => ((IQueryable <int>)null).SumAsync());
            await ArgumentNullTest("source", () => ((IQueryable <int?>)null).SumAsync());
            await ArgumentNullTest("source", () => ((IQueryable <long>)null).SumAsync());
            await ArgumentNullTest("source", () => ((IQueryable <long?>)null).SumAsync());
            await ArgumentNullTest("source", () => ((IQueryable <float>)null).SumAsync());
            await ArgumentNullTest("source", () => ((IQueryable <float?>)null).SumAsync());
            await ArgumentNullTest("source", () => ((IQueryable <double>)null).SumAsync());
            await ArgumentNullTest("source", () => ((IQueryable <double?>)null).SumAsync());
            await ArgumentNullTest("source", () => ((IQueryable <decimal>)null).SumAsync());
            await ArgumentNullTest("source", () => ((IQueryable <decimal?>)null).SumAsync());
            await ArgumentNullTest("source", () => ((IQueryable <int>)null).SumAsync(i => 0));
            await ArgumentNullTest("source", () => ((IQueryable <int>)null).SumAsync(i => 0, new CancellationToken()));
            await ArgumentNullTest("source", () => ((IQueryable <int?>)null).SumAsync(i => 0));
            await ArgumentNullTest("source", () => ((IQueryable <int?>)null).SumAsync(i => 0, new CancellationToken()));
            await ArgumentNullTest("source", () => ((IQueryable <long>)null).SumAsync(i => 0));
            await ArgumentNullTest("source", () => ((IQueryable <long>)null).SumAsync(i => 0, new CancellationToken()));
            await ArgumentNullTest("source", () => ((IQueryable <long?>)null).SumAsync(i => 0));
            await ArgumentNullTest("source", () => ((IQueryable <long?>)null).SumAsync(i => 0, new CancellationToken()));
            await ArgumentNullTest("source", () => ((IQueryable <float>)null).SumAsync(i => 0));
            await ArgumentNullTest("source", () => ((IQueryable <float>)null).SumAsync(i => 0, new CancellationToken()));
            await ArgumentNullTest("source", () => ((IQueryable <float?>)null).SumAsync(i => 0));
            await ArgumentNullTest("source", () => ((IQueryable <float?>)null).SumAsync(i => 0, new CancellationToken()));
            await ArgumentNullTest("source", () => ((IQueryable <double>)null).SumAsync(i => 0));
            await ArgumentNullTest("source", () => ((IQueryable <double>)null).SumAsync(i => 0, new CancellationToken()));
            await ArgumentNullTest("source", () => ((IQueryable <double?>)null).SumAsync(i => 0));
            await ArgumentNullTest("source", () => ((IQueryable <double?>)null).SumAsync(i => 0, new CancellationToken()));
            await ArgumentNullTest("source", () => ((IQueryable <decimal>)null).SumAsync(i => 0));
            await ArgumentNullTest("source", () => ((IQueryable <decimal>)null).SumAsync(i => 0, new CancellationToken()));
            await ArgumentNullTest("source", () => ((IQueryable <decimal?>)null).SumAsync(i => 0));
            await ArgumentNullTest("source", () => ((IQueryable <decimal?>)null).SumAsync(i => 0, new CancellationToken()));
            await ArgumentNullTest("selector", () => Source <int>().SumAsync((Expression <Func <int, int> >)null));
            await ArgumentNullTest("selector", () => Source <int?>().SumAsync((Expression <Func <int?, int> >)null));
            await ArgumentNullTest("selector", () => Source <long>().SumAsync((Expression <Func <long, int> >)null));
            await ArgumentNullTest("selector", () => Source <long?>().SumAsync((Expression <Func <long?, int> >)null));
            await ArgumentNullTest("selector", () => Source <float>().SumAsync((Expression <Func <float, int> >)null));
            await ArgumentNullTest("selector", () => Source <float?>().SumAsync((Expression <Func <float?, int> >)null));
            await ArgumentNullTest("selector", () => Source <double>().SumAsync((Expression <Func <double, int> >)null));
            await ArgumentNullTest("selector", () => Source <double?>().SumAsync((Expression <Func <double?, int> >)null));
            await ArgumentNullTest("selector", () => Source <decimal>().SumAsync((Expression <Func <decimal, int> >)null));
            await ArgumentNullTest("selector", () => Source <decimal?>().SumAsync((Expression <Func <decimal?, int> >)null));
            await ArgumentNullTest("source", () => ((IQueryable <int>)null).AverageAsync());
            await ArgumentNullTest("source", () => ((IQueryable <int>)null).AverageAsync(new CancellationToken()));
            await ArgumentNullTest("source", () => ((IQueryable <int?>)null).AverageAsync());
            await ArgumentNullTest("source", () => ((IQueryable <int?>)null).AverageAsync(new CancellationToken()));
            await ArgumentNullTest("source", () => ((IQueryable <long>)null).AverageAsync());
            await ArgumentNullTest("source", () => ((IQueryable <long>)null).AverageAsync(new CancellationToken()));
            await ArgumentNullTest("source", () => ((IQueryable <long?>)null).AverageAsync());
            await ArgumentNullTest("source", () => ((IQueryable <long?>)null).AverageAsync(new CancellationToken()));
            await ArgumentNullTest("source", () => ((IQueryable <float>)null).AverageAsync());
            await ArgumentNullTest("source", () => ((IQueryable <float>)null).AverageAsync(new CancellationToken()));
            await ArgumentNullTest("source", () => ((IQueryable <float?>)null).AverageAsync());
            await ArgumentNullTest("source", () => ((IQueryable <float?>)null).AverageAsync(new CancellationToken()));
            await ArgumentNullTest("source", () => ((IQueryable <double>)null).AverageAsync());
            await ArgumentNullTest("source", () => ((IQueryable <double>)null).AverageAsync(new CancellationToken()));
            await ArgumentNullTest("source", () => ((IQueryable <double?>)null).AverageAsync());
            await ArgumentNullTest("source", () => ((IQueryable <double?>)null).AverageAsync(new CancellationToken()));
            await ArgumentNullTest("source", () => ((IQueryable <decimal>)null).AverageAsync());
            await ArgumentNullTest("source", () => ((IQueryable <decimal>)null).AverageAsync(new CancellationToken()));
            await ArgumentNullTest("source", () => ((IQueryable <decimal?>)null).AverageAsync());
            await ArgumentNullTest("source", () => ((IQueryable <decimal?>)null).AverageAsync(new CancellationToken()));
            await ArgumentNullTest("source", () => ((IQueryable <int>)null).AverageAsync(i => 0));
            await ArgumentNullTest("source", () => ((IQueryable <int>)null).AverageAsync(i => 0, new CancellationToken()));
            await ArgumentNullTest("source", () => ((IQueryable <int?>)null).AverageAsync(i => 0));
            await ArgumentNullTest("source", () => ((IQueryable <int?>)null).AverageAsync(i => 0, new CancellationToken()));
            await ArgumentNullTest("source", () => ((IQueryable <long>)null).AverageAsync(i => 0));
            await ArgumentNullTest("source", () => ((IQueryable <long>)null).AverageAsync(i => 0, new CancellationToken()));
            await ArgumentNullTest("source", () => ((IQueryable <long?>)null).AverageAsync(i => 0));
            await ArgumentNullTest("source", () => ((IQueryable <long?>)null).AverageAsync(i => 0, new CancellationToken()));
            await ArgumentNullTest("source", () => ((IQueryable <float>)null).AverageAsync(i => 0));
            await ArgumentNullTest("source", () => ((IQueryable <float>)null).AverageAsync(i => 0, new CancellationToken()));
            await ArgumentNullTest("source", () => ((IQueryable <float?>)null).AverageAsync(i => 0));
            await ArgumentNullTest("source", () => ((IQueryable <float?>)null).AverageAsync(i => 0, new CancellationToken()));
            await ArgumentNullTest("source", () => ((IQueryable <double>)null).AverageAsync(i => 0));
            await ArgumentNullTest("source", () => ((IQueryable <double>)null).AverageAsync(i => 0, new CancellationToken()));
            await ArgumentNullTest("source", () => ((IQueryable <double?>)null).AverageAsync(i => 0));
            await ArgumentNullTest("source", () => ((IQueryable <double?>)null).AverageAsync(i => 0, new CancellationToken()));
            await ArgumentNullTest("source", () => ((IQueryable <decimal>)null).AverageAsync(i => 0));
            await ArgumentNullTest("source", () => ((IQueryable <decimal>)null).AverageAsync(i => 0, new CancellationToken()));
            await ArgumentNullTest("source", () => ((IQueryable <decimal?>)null).AverageAsync(i => 0));
            await ArgumentNullTest("source", () => ((IQueryable <decimal?>)null).AverageAsync(i => 0, new CancellationToken()));
            await ArgumentNullTest("selector", () => Source <int>().AverageAsync((Expression <Func <int, int> >)null));
            await ArgumentNullTest("selector", () => Source <int>().AverageAsync((Expression <Func <int, int> >)null, new CancellationToken()));
            await ArgumentNullTest("selector", () => Source <int?>().AverageAsync((Expression <Func <int?, int> >)null));
            await ArgumentNullTest("selector", () => Source <int?>().AverageAsync((Expression <Func <int?, int> >)null, new CancellationToken()));
            await ArgumentNullTest("selector", () => Source <long>().AverageAsync((Expression <Func <long, int> >)null));
            await ArgumentNullTest("selector", () => Source <long>().AverageAsync((Expression <Func <long, int> >)null, new CancellationToken()));
            await ArgumentNullTest("selector", () => Source <long?>().AverageAsync((Expression <Func <long?, int> >)null));
            await ArgumentNullTest("selector", () => Source <long?>().AverageAsync((Expression <Func <long?, int> >)null, new CancellationToken()));
            await ArgumentNullTest("selector", () => Source <float>().AverageAsync((Expression <Func <float, int> >)null));
            await ArgumentNullTest("selector", () => Source <float>().AverageAsync((Expression <Func <float, int> >)null, new CancellationToken()));
            await ArgumentNullTest("selector", () => Source <float?>().AverageAsync((Expression <Func <float?, int> >)null));
            await ArgumentNullTest("selector", () => Source <float?>().AverageAsync((Expression <Func <float?, int> >)null, new CancellationToken()));
            await ArgumentNullTest("selector", () => Source <double>().AverageAsync((Expression <Func <double, int> >)null));
            await ArgumentNullTest("selector", () => Source <double>().AverageAsync((Expression <Func <double, int> >)null, new CancellationToken()));
            await ArgumentNullTest("selector", () => Source <double?>().AverageAsync((Expression <Func <double?, int> >)null));
            await ArgumentNullTest("selector", () => Source <double?>().AverageAsync((Expression <Func <double?, int> >)null, new CancellationToken()));
            await ArgumentNullTest("selector", () => Source <decimal>().AverageAsync((Expression <Func <decimal, int> >)null));
            await ArgumentNullTest("selector", () => Source <decimal>().AverageAsync((Expression <Func <decimal, int> >)null, new CancellationToken()));
            await ArgumentNullTest("selector", () => Source <decimal?>().AverageAsync((Expression <Func <decimal?, int> >)null));
            await ArgumentNullTest("selector", () => Source <decimal?>().AverageAsync((Expression <Func <decimal?, int> >)null, new CancellationToken()));

            // ReSharper restore AssignNullToNotNullAttribute
        }
Exemple #16
0
 /// <summary>
 /// SingleOrDefault asíncrono.
 /// </summary>
 /// <typeparam name="T"></typeparam>
 /// <param name="query"></param>
 /// <returns></returns>
 public static Task <T> SingleOrDefaultAsync <T>(this IQueryable <T> query) where T : class
 {
     return(EntityFrameworkQueryableExtensions.SingleOrDefaultAsync(query));
 }
Exemple #17
0
#pragma warning restore CS8619 // Nullability of reference types in value doesn't match target type.

        /// <inheritdoc cref="EntityFrameworkQueryableExtensions.SingleOrDefaultAsync{TSource}(IQueryable{TSource}, Expression{Func{TSource, bool}}, CancellationToken)"/>
        public Task <TSource?> SingleOrDefaultAsync <TSource>(
            IQueryable <TSource> source,
            Expression <Func <TSource, bool> > predicate,
            CancellationToken token)
#pragma warning disable CS8619 // Nullability of reference types in value doesn't match target type.
        => EntityFrameworkQueryableExtensions.SingleOrDefaultAsync(source, predicate, token);
Exemple #18
0
 public async Task <ToDoItem> GetToDoItem(int id)
 {
     return(await EntityFrameworkQueryableExtensions.SingleOrDefaultAsync <ToDoItem>(_db.ToDoItem, m => m.Id == id));
 }
Exemple #19
0
 public Task <TSource> SingleOrDefaultAsync <TSource>(IQueryable <TSource> source, Expression <Func <TSource, bool> > predicate)
 {
     return(EntityFrameworkQueryableExtensions.SingleOrDefaultAsync(source, predicate));
 }
Exemple #20
0
 public Task <TSource> SingleOrDefaultAsync <TSource>(IQueryable <TSource> source)
 {
     return(EntityFrameworkQueryableExtensions.SingleOrDefaultAsync(source));
 }
Exemple #21
0
 public Task <TSource> SingleOrDefaultAsync <TSource>(IQueryable <TSource> source, Expression <Func <TSource, bool> > predicate, CancellationToken cancellationToken = default(CancellationToken))
 {
     return(EntityFrameworkQueryableExtensions.SingleOrDefaultAsync(source, predicate, cancellationToken));
 }
Exemple #22
0
 /// <summary>
 /// Asynchronously loads first record from query.
 /// Returns <c>default(TSource)</c>, if query doesn't return any records.
 /// Throws exception, if query returns more than one record.
 /// </summary>
 /// <typeparam name="TSource">Query element type.</typeparam>
 /// <param name="source">Source query.</param>
 /// <param name="token">Optional asynchronous operation cancellation token.</param>
 /// <returns>First record from query results or <c>default(TSource)</c> for empty resultset.</returns>
 public static Task <TSource> SingleOrDefaultAsyncEF <TSource>(
     this IQueryable <TSource> source,
     CancellationToken token = default)
 => EntityFrameworkQueryableExtensions.SingleOrDefaultAsync(source, token);