public async Task <PaginationResult <Sensor> > GetSensorsAsync(SensateUser user, int skip = 0, int limit = 0, CancellationToken token = default)
{
var worker = this.m_links.GetByUserAsync(user, token);
var ownSensors = await this.m_sensors.GetAsync(user).AwaitBackground();
var links = await worker.AwaitBackground();
var sensorIds = links.Select(x => x.SensorId);
var linkedSensors = (await this.m_sensors.GetAsync(sensorIds).AwaitBackground()).ToList();
foreach (var linked in linkedSensors)
{
linked.Secret = "";
}
var rv = ownSensors.ToList();
rv.AddRange(linkedSensors);
var count = rv.Count;
if (skip > 0)
{
rv = rv.Skip(skip).ToList();
}
if (limit > 0)
{
rv = rv.Take(limit).ToList();
}
return(new PaginationResult <Sensor> {
Count = count,
Values = rv
});
}
public string GenerateJwtToken(SensateUser user, IEnumerable <string> roles, UserAccountSettings settings)
{
List <Claim> claims;
JwtSecurityToken token;
var key = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(settings.JwtKey));
var creds = new SigningCredentials(key, SecurityAlgorithms.HmacSha256);
var expires = DateTime.Now.AddMinutes(settings.JwtExpireMinutes);
claims = new List <Claim> {
new Claim(JwtRegisteredClaimNames.Email, user.Email),
new Claim(JwtRegisteredClaimNames.Jti, Guid.NewGuid().ToString()),
new Claim(JwtRegisteredClaimNames.Sub, user.Id),
};
roles.ToList().ForEach(x => {
claims.Add(new Claim(ClaimTypes.Role, x));
});
token = new JwtSecurityToken(
issuer: settings.JwtIssuer,
audience: settings.JwtIssuer,
claims: claims,
expires: expires,
signingCredentials: creds
);
return(new JwtSecurityTokenHandler().WriteToken(token));
}
public virtual async Task <IEnumerable <Sensor> > GetAsync(SensateUser user, int skip = 0, int limit = 0)
{
FilterDefinition <Sensor> filter;
var id = user.Id;
var builder = Builders <Sensor> .Filter;
filter = builder.Where(s => s.Owner == id);
var sensors = this._sensors.Aggregate().Match(filter);
if (sensors == null)
{
return(null);
}
if (skip > 0)
{
sensors = sensors.Skip(skip);
}
if (limit > 0)
{
sensors = sensors.Limit(limit);
}
return(await sensors.ToListAsync().AwaitBackground());
}
public async Task <IEnumerable <AuditLog> > GetByRouteAsync(SensateUser user, string route, int skip = 0, int limit = 0)
{
var query =
from log in this.Data
where log.AuthorId == user.Id &&
log.Route == route
orderby log.Timestamp
select log;
var data = query.AsQueryable();
if (skip > 0)
{
data = data.Skip(skip);
}
if (limit > 0)
{
data = data.Take(limit);
}
var result = await data.ToListAsync().AwaitBackground();
foreach (var log in result)
{
log.Timestamp = DateTime.SpecifyKind(log.Timestamp, DateTimeKind.Utc);
}
return(result);
}
public async Task <IEnumerable <AuditLog> > FindAsync(SensateUser user, string text, int skip = 0, int limit = 0, OrderDirection direction = OrderDirection.None)
{
var query = this.Data.Where(log => log.AuthorId == user.Id && log.Route.Contains(text));
if (skip > 0)
{
query = query.Skip(skip);
}
if (limit > 0)
{
query = query.Take(limit);
}
query = direction switch {
OrderDirection.Ascending => query.OrderBy(x => x.Timestamp),
OrderDirection.Descending => query.OrderByDescending(x => x.Timestamp),
_ => query
};
var result = await query.ToListAsync().AwaitBackground();
foreach (var log in result)
{
log.Timestamp = DateTime.SpecifyKind(log.Timestamp, DateTimeKind.Utc);
}
return(result);
}
public async Task <IEnumerable <SensateApiKey> > GetByUserAsync(SensateUser user, ApiKeyType type,
int skip = 0, int limit = 0,
CancellationToken token = default)
{
IQueryable <SensateApiKey> query = this.Data.Where(apikey => apikey.UserId == user.Id && apikey.Type == type).Include(apikey => apikey.User)
.ThenInclude(u => u.ApiKeys);
if (skip > 0)
{
query = query.Skip(skip);
}
if (limit > 0)
{
query = query.Take(limit);
}
var keys = await query.ToListAsync(token).AwaitBackground();
if (keys == null)
{
return(null);
}
foreach (var key in keys)
{
key.CreatedOn = DateTime.SpecifyKind(key.CreatedOn, DateTimeKind.Utc);
}
return(keys);
}
public async Task DeleteAsync(SensateUser user, CancellationToken ct = default)
{
var query = this.Data.Where(x => x.UserId == user.Id);
this.Data.RemoveRange(query);
await this.CommitAsync(ct).AwaitBackground();
}
protected AbstractController(IUserRepository users, IHttpContextAccessor ctx)
{
this._users = users;
if (this.CurrentUser == null)
{
this.CurrentUser = ctx?.HttpContext.Items["UserData"] as SensateUser;
}
}
public void InvalidateToken(SensateUser user, string value)
{
var token = this.GetById(user, value);
if (token == null)
{
return;
}
this.InvalidateToken(token);
}
public async Task DeleteBetweenAsync(SensateUser user, DateTime start, DateTime end)
{
var data = from log in this.Data
where log.AuthorId == user.Id &&
log.Timestamp >= start &&
log.Timestamp <= end
select log;
this.Data.RemoveRange(data);
await this._sqlContext.SaveChangesAsync().AwaitBackground();
}
public async Task InvalidateTokenAsync(SensateUser user, string value)
{
var token = this.GetById(user, value);
if (token == null)
{
return;
}
await this.InvalidateTokenAsync(token).AwaitBackground();
}
private AuthUserToken CreateAuthUserTokenEntry(SensateUser user)
{
var token = new AuthUserToken {
UserId = user.Id,
User = user,
ExpiresAt = DateTime.Now.AddMinutes(this._settings.JwtRefreshExpireMinutes),
LoginProvider = UserTokenRepository.JwtRefreshTokenProvider,
Value = this._tokens.GenerateRefreshToken()
};
return(token);
}
public async Task <object> Register([FromBody] Register register)
{
EmailBody mail;
var user = new SensateUser {
UserName = register.Email,
Email = register.Email,
FirstName = register.FirstName,
LastName = register.LastName,
RegisteredAt = DateTime.Now,
UnconfirmedPhoneNumber = register.PhoneNumber,
BillingLockout = false
};
var valid = await this._text.IsValidNumber(register.PhoneNumber);
if (!valid)
{
return(InvalidInputResult("Invalid phone number!"));
}
var result = await this._manager.CreateAsync(user, register.Password).AwaitBackground();
if (!result.Succeeded)
{
var objresult = StringifyIdentityResult(result);
return(this.BadRequest(objresult));
}
var mailTask = this.ReadMailTemplate("Confirm_Account_Registration.html", "Confirm_Account_Registration.txt");
user = await this._users.GetAsync(user.Id).AwaitBackground();
var code = await this._manager.GenerateEmailConfirmationTokenAsync(user).AwaitBackground();
code = Base64UrlEncoder.Encode(code);
var url = this.Url.EmailConfirmationLink(user.Id, code, this._settings.Scheme, this._settings.PublicUrl);
mail = await mailTask.AwaitBackground();
mail.HtmlBody = mail.HtmlBody.Replace("%%URL%%", url);
mail.TextBody = string.Format(mail.TextBody, url);
var updates = new[] {
this._manager.AddToRoleAsync(user, "Users"),
this._mailer.SendEmailAsync(user.Email, "Sensate email confirmation", mail),
};
await Task.WhenAll(updates);
return(this.Ok());
}
private async Task <IEnumerable <SensorStatisticsEntry> > GetStatsFor(SensateUser user, DateTime date)
{
var raw = await this._sensors.GetAsync(user).AwaitBackground();
var sensors = raw.ToList();
if (sensors.Count <= 0)
{
return(null);
}
return(await this._stats.GetAfterAsync(sensors, date).AwaitBackground());
}
public async Task <long> CountAsync(SensateUser user = null)
{
FilterDefinition <Sensor> filter;
if (user == null)
{
return(await this._sensors.CountDocumentsAsync(new BsonDocument()).AwaitBackground());
}
var builder = Builders <Sensor> .Filter;
filter = builder.Where(s => s.Owner == user.Id);
return(await this._sensors.CountDocumentsAsync(filter).AwaitBackground());
}
public async Task <long> CountAsync(SensateUser user, CancellationToken token = default)
{
using var builder = StoredProcedureBuilder.Create(this.m_ctx.Database.GetDbConnection());
builder.WithFunction(DataApi_Count);
builder.WithParameter("userid", Guid.Parse(user.Id), NpgsqlDbType.Uuid);
await using var reader = await builder.ExecuteAsync(token).ConfigureAwait(false);
if (!await reader.ReadAsync(token).ConfigureAwait(false))
{
return(0);
}
return(reader.GetInt64(0));
}
private async Task SendConfirmPhoneAsync(SensateUser user, string number)
{
var phonetoken = await this._manager.GenerateChangePhoneNumberTokenAsync(user, number).AwaitBackground();
var usertoken = await this._phonetokens.CreateAsync(user, phonetoken, number).AwaitBackground();
if (usertoken == null)
{
return;
}
var worker = this.ReadTextTemplate("Confirm_PhoneNumber.txt", usertoken);
var body = await worker.AwaitBackground();
this._text.Send(this._text_settings.AlphaCode, number, body);
}
public async Task <IEnumerable <AuthUserToken> > GetByUserAsync(SensateUser user, int skip = 0, int limit = 0, CancellationToken ct = default)
{
var data = from token in this.Data
where token.UserId == user.Id
select token;
if (skip > 0)
{
data = data.Skip(skip);
}
if (limit > 0)
{
data = data.Take(limit);
}
return(await data.ToListAsync(ct).AwaitBackground());
}
public async Task <IEnumerable <AuditLog> > GetByRouteAsync(SensateUser user,
string route,
DateTime start,
DateTime end,
int skip = 0,
int limit = 0,
OrderDirection direction = OrderDirection.None)
{
var result =
from log in this.Data
where log.AuthorId == user.Id &&
log.Route == route &&
log.Timestamp >= start &&
log.Timestamp <= end
orderby log.Timestamp
select log;
var data = result.AsQueryable();
if (skip > 0)
{
data = data.Skip(skip);
}
if (limit > 0)
{
data = data.Take(limit);
}
data = direction switch {
OrderDirection.Ascending => data.OrderBy(x => x.Timestamp),
OrderDirection.Descending => data.OrderByDescending(x => x.Timestamp),
_ => data
};
var rv = await data.ToListAsync().AwaitBackground();
foreach (var log in result)
{
log.Timestamp = DateTime.SpecifyKind(log.Timestamp, DateTimeKind.Utc);
}
return(rv);
}
public async Task <PaginationResult <AuditLog> > GetByRequestTypeAsync(SensateUser user,
RequestMethod method,
int skip = 0,
int limit = 0,
OrderDirection direction = OrderDirection.None)
{
var rv = new PaginationResult <AuditLog>();
var query =
from log in this.Data
where log.AuthorId == user.Id &&
log.Method == method
orderby log.Timestamp
select log;
var data = query.AsQueryable();
rv.Count = await data.CountAsync().AwaitBackground();
if (skip > 0)
{
data = data.Skip(skip);
}
if (limit > 0)
{
data = data.Take(limit);
}
data = direction switch {
OrderDirection.Ascending => data.OrderBy(x => x.Timestamp),
OrderDirection.Descending => data.OrderByDescending(x => x.Timestamp),
_ => data
};
rv.Values = await data.ToListAsync().AwaitBackground();
foreach (var log in rv.Values)
{
log.Timestamp = DateTime.SpecifyKind(log.Timestamp, DateTimeKind.Utc);
}
return(rv);
}
private async Task <SensateApiKey> CreateSystemApiKeyAsync(SensateUser user)
{
SensateApiKey key;
key = new SensateApiKey {
Id = Guid.NewGuid().ToString(),
User = user,
UserId = user.Id,
Type = ApiKeyType.SystemKey,
Revoked = false,
CreatedOn = DateTime.Now.ToUniversalTime(),
ReadOnly = false,
Name = Guid.NewGuid().ToString()
};
await this._keys.CreateAsync(key, CancellationToken.None).AwaitBackground();
return(key);
}
public async Task <ChangePhoneNumberToken> GetLatest(SensateUser user)
{
var tokens = from token in this.Data
where token.UserId == user.Id &&
token.PhoneNumber == user.UnconfirmedPhoneNumber
select token;
var single = tokens.OrderByDescending(t => t.Timestamp);
var value = await single.FirstOrDefaultAsync().AwaitBackground();
if (value == null)
{
return(null);
}
value.Timestamp = DateTime.SpecifyKind(value.Timestamp, DateTimeKind.Utc);
return(value);
}
public async Task <PaginationResult <SensateApiKey> > FilterAsync(SensateUser user,
IList <ApiKeyType> types,
string query = null,
bool revoked = true,
int skip = 0,
int limit = 0)
{
var rv = new PaginationResult <SensateApiKey>();
var q = this.Data.Where(x => x.UserId == user.Id && types.Contains(x.Type));
if (!string.IsNullOrEmpty(query))
{
q = q.Where(x => x.Name.Contains(query));
}
if (!revoked)
{
q = q.Where(x => !x.Revoked);
}
rv.Count = await q.CountAsync().AwaitBackground();
if (skip > 0)
{
q = q.Skip(skip);
}
if (limit > 0)
{
q = q.Take(limit);
}
q = q.Include(key => key.User);
rv.Values = await q.ToListAsync().AwaitBackground();
foreach (var key in rv.Values)
{
key.CreatedOn = DateTime.SpecifyKind(key.CreatedOn, DateTimeKind.Utc);
}
return(rv);
}
public override async Task <IEnumerable <string> > GetRolesAsync(SensateUser user)
{
var id = $"user_roles:{user.Id}";
var obj = await this._cache.GetAsync(id, CancellationToken.None).ConfigureAwait(false);
if (obj != null)
{
return(JsonConvert.DeserializeObject <IEnumerable <string> >(obj));
}
var roles = await base.GetRolesAsync(user).ConfigureAwait(false);
if (roles != null)
{
obj = JsonConvert.SerializeObject(roles);
await this._cache.SetAsync(id, obj, CacheTimeout.TimeoutShort.ToInt()).ConfigureAwait(false);
}
return(roles);
}
public override async Task<IEnumerable<Sensor>> GetAsync(SensateUser user, int skip = 0, int limit = 0)
{
string key, data;
IEnumerable<Sensor> sensors;
key = $"sensors:uuid:{user.Id}:{skip}:{limit}";
data = await this._cache.GetAsync(key);
if(data != null) {
return JsonConvert.DeserializeObject<IEnumerable<Sensor>>(data);
}
sensors = await base.GetAsync(user, skip, limit).AwaitBackground();
if(sensors == null) {
return null;
}
await this._cache.SetAsync(key, JsonConvert.SerializeObject(sensors), CacheTimeout.TimeoutMedium.ToInt()).AwaitBackground();
return sensors;
}
public async Task <string> CreateAsync(SensateUser user, string token, string phone)
{
ChangePhoneNumberToken t;
t = new ChangePhoneNumberToken {
PhoneNumber = phone,
IdentityToken = token,
UserToken = this._rng.NextString(UserTokenLength),
UserId = user.Id,
Timestamp = DateTime.UtcNow
};
try {
await this.CreateAsync(t).AwaitBackground();
} catch (Exception e) {
Debug.WriteLine($"Unable to create token: {e.Message}");
return(null);
}
return(t.UserToken);
}
public async Task <IEnumerable <SensorLink> > GetByUserAsync(SensateUser user, CancellationToken token = default)
{
using var builder = StoredProcedureBuilder.Create(this.m_ctx.Database.GetDbConnection());
builder.WithFunction(DataApi_GetByUserID);
builder.WithParameter("userid", Guid.Parse(user.Id), NpgsqlDbType.Uuid);
await using var reader = await builder.ExecuteAsync(token).ConfigureAwait(false);
var list = new List <SensorLink>();
while (await reader.ReadAsync(token).ConfigureAwait(false))
{
var link = new SensorLink {
SensorId = reader.GetString(0),
UserId = reader.GetGuid(1).ToString()
};
list.Add(link);
}
return(list);
}
public async Task <PaginationResult <Sensor> > GetSensorsAsync(SensateUser user, string name, int skip = 0, int limit = 0, CancellationToken token = default)
{
var sensors = await this.GetSensorsAsync(user, token : token).AwaitBackground();
var nameLower = name.ToLowerInvariant();
var list = sensors.Values.ToList();
list = list.Where(x => x.Name.ToLowerInvariant().Contains(nameLower)).ToList();
sensors.Count = list.Count;
if (skip > 0)
{
list = list.Skip(skip).ToList();
}
if (limit > 0)
{
list = list.Take(limit).ToList();
}
sensors.Values = list;
return(sensors);
}
public async Task <PaginationResult <AuditLog> > GetByUserAsync(SensateUser user,
int skip = 0,
int limit = 0,
OrderDirection direction = OrderDirection.None)
{
var data = this.Data.Where(x => x.AuthorId == user.Id);
var rv = new PaginationResult <AuditLog> {
Count = await data.CountAsync().AwaitBackground()
};
if (skip > 0)
{
data = data.Skip(skip);
}
if (limit > 0)
{
data = data.Take(limit);
}
data = direction switch {
OrderDirection.Ascending => data.OrderBy(x => x.Timestamp),
OrderDirection.Descending => data.OrderByDescending(x => x.Timestamp),
_ => data
};
rv.Values = await data.ToListAsync().AwaitBackground();
foreach (var log in rv.Values)
{
log.Timestamp = DateTime.SpecifyKind(log.Timestamp, DateTimeKind.Utc);
}
return(rv);
}
}
public static async Task Initialize(SensateSqlContext ctx, RoleManager <SensateRole> roles, UserManager <SensateUser> manager)
{
if (ctx == null)
{
throw new ArgumentNullException(nameof(ctx));
}
if (manager == null)
{
throw new ArgumentNullException(nameof(manager));
}
if (roles == null)
{
throw new ArgumentNullException(nameof(roles));
}
SensateUser user;
await ctx.Database.EnsureCreatedAsync().ConfigureAwait(false);
IEnumerable <string> adminroles = new List <string> {
"Administrators", "Users"
};
if (ctx.Roles.Any() || ctx.Users.Any() || ctx.UserRoles.Any())
{
return;
}
var uroles = new[] {
new SensateRole {
Name = UserRoles.Administrator,
Description = "System administrators",
},
new SensateRole {
Name = UserRoles.NormalUser,
Description = "Normal users"
},
new SensateRole {
Name = UserRoles.Banned,
Description = "Banned users"
}
};
foreach (var role in uroles)
{
await roles.CreateAsync(role).AwaitBackground();
}
user = new SensateUser {
Email = "*****@*****.**",
FirstName = "System",
LastName = "Administrator",
PhoneNumber = "0600000000",
PhoneNumberConfirmed = true,
EmailConfirmed = true
};
user.UserName = user.Email;
user.EmailConfirmed = true;
await manager.CreateAsync(user, "Root1234#xD").AwaitBackground();
await ctx.SaveChangesAsync().ConfigureAwait(false);
user = await manager.FindByEmailAsync("*****@*****.**").AwaitBackground();
await manager.AddToRolesAsync(user, adminroles).AwaitBackground();
}
