public async Task <IList <TemperatureMeasurementModel> > GetAllAsync() { return(await SmartHomeAppDbContext.Query <TemperatureMeasurement>() .ProjectTo <TemperatureMeasurementModel>(Mapper.ConfigurationProvider) .OrderByDescending(x => x.MeasurementDateTime) .ToListAsync()); }
public async Task <IList <PermissionRoleModel> > GetAllUserPermissionsWithRolesAsync(long userId) { var user = await SmartHomeAppDbContext.SingleAsync <User>(userId); var userPermissions = await SmartHomeAppDbContext.Query <UserPermission>() .Where(x => x.UserId == userId) .ProjectTo <PermissionRoleModel>(Mapper.ConfigurationProvider) .ToListAsync(); var rolesStrings = (List <string>) await userManager.GetRolesAsync(user); var rolePermissions = await SmartHomeAppDbContext.Query <RolePermission>() .Where(x => rolesStrings.Contains(x.Role.Name)) .ProjectTo <PermissionRoleModel>(Mapper.ConfigurationProvider) .ToListAsync(); var comparer = EqualityComparerFactory.Create <PermissionRoleModel>( x => (int)x.PermissionId, (x, y) => x.PermissionId == y.PermissionId && string.Equals(x.RoleName, y.RoleName)); var resultPermissions = userPermissions.Union(rolePermissions, comparer); resultPermissions = resultPermissions.OrderBy(x => x.PermissionName); return(resultPermissions.ToList()); }
public async Task RemovePermissionsFromUserAsync(long userId, List <long> permissions) { var permissionsToRemove = await SmartHomeAppDbContext.Query <UserPermission>() .Where(x => x.UserId == userId) .Where(x => permissions.Contains(x.Permission.Id)) .ToListAsync(); await SmartHomeAppDbContext.DeleteRangeAsync(permissionsToRemove); }
public async Task <IdentityResult> RemoveFromRolesAsync(long userId, List <long> roleIds) { var user = await SmartHomeAppDbContext.SingleAsync <User>(userId); var roleNames = await SmartHomeAppDbContext.Query <Role>().Where(x => roleIds.Contains(x.Id)) .Select(x => x.Name).ToListAsync(); return(await userManager.RemoveFromRolesAsync(user, roleNames)); }
public async Task <IdentityResult> AddToRolesAsync(long userId, List <long> roleIds) { var user = await SmartHomeAppDbContext.SingleAsync <User>(userId); // this query needs for some reason roleIds to be List var roleNames = await SmartHomeAppDbContext.Query <Role>().Where(x => roleIds.Contains(x.Id)) .Select(x => x.Name).ToListAsync(); return(await userManager.AddToRolesAsync(user, roleNames)); }
public async Task <IList <PermissionModel> > GetUserOnlyPermissionsAsync(long userId) { var userPermissions = await SmartHomeAppDbContext.Query <UserPermission>() .Where(x => x.UserId == userId) .Select(x => x.Permission) .ProjectTo <PermissionModel>(Mapper.ConfigurationProvider) .ToListAsync(); return(userPermissions); }
public async Task <IList <PermissionModel> > GetRolePermissionsAsync(long roleId) { var rolePermissions = SmartHomeAppDbContext.Query <RolePermission>() .Where(x => x.RoleId == roleId) .Select(x => x.Permission) .OrderBy(x => x.Name) .ProjectTo <PermissionModel>(Mapper.ConfigurationProvider); var result = await rolePermissions.ToListAsync(); return(result); }
public async Task <IList <RoleModel> > GetUserRolesAsync(long userId) { var user = await SmartHomeAppDbContext.SingleAsync <User>(userId); var rolesStrings = (List <string>) await userManager.GetRolesAsync(user); return(SmartHomeAppDbContext.Query <Role>() .Where(x => rolesStrings.Contains(x.Name)) .ProjectTo <RoleModel>(Mapper.ConfigurationProvider) .ToList()); }
public async Task <TemperatureMeasurementModel?> GetSensorLastTemperatureMeasurementAsync(long sensorId) { var query = SmartHomeAppDbContext.Query <TemperatureMeasurement>() .Where(x => x.SensorId == sensorId); // take temperature measurement of given sensor with maximum date time var lastDateTime = query.DefaultIfEmpty().Max(y => y.MeasurementDateTime); var temperatureMeasurement = await query.FirstOrDefaultAsync(x => x.MeasurementDateTime == lastDateTime); return(Mapper.Map <TemperatureMeasurementModel>(temperatureMeasurement)); }
public async Task AddPermissionsToUserAsync(long userId, List <string> permissions) { var permissionIds = await SmartHomeAppDbContext.Query <Permission>() .Where(x => permissions.Contains(x.Name)) .Select(x => x.Id) .ToListAsync(); var entities = permissionIds.Select(x => new UserPermission() { UserId = userId, PermissionId = x }); await SmartHomeAppDbContext.AddRangeAsync(entities); }
public async Task <IList <OverviewTemperatureMeasurementModel> > GetAllSensorsLastTemperatureMeasurementAsync() { var orderedMeasurements = from item in SmartHomeAppDbContext.Query <TemperatureMeasurement>() orderby item.MeasurementDateTime descending select item; // TODO: ToListAsync() because EF Core 2.2 cannot translate GroupBy var query = await orderedMeasurements .Include(x => x.Place) .Include(x => x.Sensor) .ThenInclude(x => x.SensorType) .ToListAsync(); var groupedMeasurements = query.GroupBy(x => x.SensorId); // last temperature measurements for each sensor var lastTemperatureMeasurements = groupedMeasurements.Select(x => x.First()); return(lastTemperatureMeasurements.Select(x => Mapper.Map <OverviewTemperatureMeasurementModel>(x)).ToList()); }
private IQueryable <TemperatureMeasurement> GetTemperatureMeasurementsQuery(MeasurementFilter filter) { var query = SmartHomeAppDbContext.Query <TemperatureMeasurement>(); if (filter.From != null) { query = query.Where(x => x.MeasurementDateTime >= filter.From); } if (filter.To != null) { query = query.Where(x => x.MeasurementDateTime <= filter.To.Value); } if (filter.SensorId != null) { query = query.Where(x => x.SensorId == filter.SensorId.Value); } return(query); }
public async Task <bool> HasPermissionAsync(long userId, string permissionName) { var user = await SmartHomeAppDbContext.SingleAsync <User>(userId); bool hasPermission = await SmartHomeAppDbContext.Query <UserPermission>() .AnyAsync(x => x.UserId == userId && x.Permission.Name == permissionName); if (hasPermission) { return(true); } // has role that has that permission var roles = (List <string>) await userManager.GetRolesAsync(user); hasPermission = await SmartHomeAppDbContext.Query <RolePermission>() // filter only for roles that user has .Where(x => roles.Contains(x.Role.Name)) // does the role have that permission? .AnyAsync(x => x.Permission.Name == permissionName); return(hasPermission); }
public async Task <IList <EntityReference> > GetAllRoleReferences() { return(await SmartHomeAppDbContext.Query <Role>().ProjectTo <EntityReference>(Mapper.ConfigurationProvider).ToListAsync()); }
public async Task <PermissionModel?> GetByNameAsync(string name) { var permission = await SmartHomeAppDbContext.Query <Permission>().SingleOrDefaultAsync(x => x.Name == name); return(Mapper.Map <PermissionModel>(permission)); }
public async Task <IList <UserModel> > GetAllAsync() { return(await SmartHomeAppDbContext.Query <User>().ProjectTo <UserModel>(Mapper.ConfigurationProvider).ToListAsync()); }
public async Task <RoleModel> GetByNameAsync(string name) { var role = await SmartHomeAppDbContext.Query <Role>().SingleAsync(x => x.Name == name); return(Mapper.Map <RoleModel>(role)); }
public virtual async Task <IList <TModel> > GetAllAsync() { return(await SmartHomeAppDbContext.Query <TEntity>().ProjectTo <TModel>(Mapper.ConfigurationProvider).ToListAsync()); }
public async Task <IList <MeasurementStatisticsModel> > GetTemperatureMeasurementsAsync(StatisticsFilter filter) { var query = SmartHomeAppDbContext.Query <TemperatureMeasurement>(); if (filter.IsInside != null) { query = query.Where(x => x.Place.IsInside == filter.IsInside.Value); } if (filter.DateFrom != null) { query = query.Where(x => x.MeasurementDateTime >= filter.DateFrom); } if (filter.DateTo != null) { query = query.Where(x => x.MeasurementDateTime <= filter.DateTo); } IEnumerable <MeasurementStatisticsModel> modelQuery; switch (filter.AggregateOver) { case AggregateOver.DayOfYear: { modelQuery = AggregateOverDayOfYear(query, filter.AggregateOverPlace); break; } case AggregateOver.Month: { modelQuery = AggregateOverMonth(query, filter.AggregateOverPlace); break; } case AggregateOver.Year: { modelQuery = AggregateOverYear(query, filter.AggregateOverPlace); break; } case null: { IQueryable <Tuple <long?, DateTime, int, double> > groupedQuery; if (!filter.AggregateOverPlace) { groupedQuery = query // make groups that have same date + hour and place and make temperature average over them .GroupBy(x => new { x.MeasurementDateTime.Date, x.MeasurementDateTime.Hour, x.PlaceId }) .Select(x => Tuple.Create((long?)x.Key.PlaceId, x.Key.Date, x.Key.Hour, x.Average(y => y.Temperature))); } else { groupedQuery = query // make groups that have same date + hour and place and make temperature average over them .GroupBy(x => new { x.MeasurementDateTime.Date, x.MeasurementDateTime.Hour }) .Select(x => Tuple.Create((long?)null, x.Key.Date, x.Key.Hour, x.Average(y => y.Temperature))); } modelQuery = groupedQuery.AsEnumerable() .Select(x => new MeasurementStatisticsModel() { MeasurementDateTime = new DateTime(x.Item2.Year, x.Item2.Month, x.Item2.Day, x.Item3, 0, 0), Value = x.Item4, PlaceId = x.Item1 }); break; } default: throw new ArgumentOutOfRangeException(); } var list = modelQuery .ToList(); return(list); }