public string GenerateToken(UserTokenInfo tokenInfo)
{
if (tokenInfo == null)
{
throw new ArgumentNullException(nameof(tokenInfo));
}
var config = _jwtConfig.CurrentValue;
var identity = new ClaimsIdentity();
identity.AddClaim(new Claim(ClaimTypes.NameIdentifier, tokenInfo.Id.ToString(CultureInfo.InvariantCulture.NumberFormat), ClaimValueTypes.Integer64));
identity.AddClaim(new Claim(VersionClaimType, tokenInfo.Version.ToString(CultureInfo.InvariantCulture.NumberFormat), ClaimValueTypes.Integer64));
var tokenDescriptor = new SecurityTokenDescriptor()
{
Subject = identity,
Issuer = config.Issuer,
Audience = config.Audience,
SigningCredentials = new SigningCredentials(_tokenSecurityKey, SecurityAlgorithms.HmacSha384),
IssuedAt = _clock.GetCurrentTime(),
Expires = tokenInfo.ExpireAt,
NotBefore = _clock.GetCurrentTime() // I must explicitly set this or it will use the current time by default and mock is not work in which case test will not pass.
};
var token = _tokenHandler.CreateToken(tokenDescriptor);
var tokenString = _tokenHandler.WriteToken(token);
return(tokenString);
}
public async Task <UserTokenCreateResult> CreateTokenAsync(string username, string password, DateTime?expireAt = null)
{
expireAt = expireAt?.MyToUtc();
if (username == null)
{
throw new ArgumentNullException(nameof(username));
}
if (password == null)
{
throw new ArgumentNullException(nameof(password));
}
var userId = await _userService.VerifyCredential(username, password);
var user = await _userService.GetUserAsync(userId);
var token = _userTokenService.GenerateToken(new UserTokenInfo
{
Id = user.Id,
Version = user.Version,
ExpireAt = expireAt ?? _clock.GetCurrentTime() + TimeSpan.FromSeconds(_tokenOptionsMonitor.CurrentValue.DefaultExpireSeconds)
});
_logger.LogInformation(Resource.LogTokenCreate, user.Username, userId);
return(new UserTokenCreateResult {
Token = token, User = user
});
}
public async Task <ICacheableDataDigest> SetAvatarAsync(long userId, ByteData avatar)
{
if (avatar is null)
{
throw new ArgumentNullException(nameof(avatar));
}
await _imageService.ValidateAsync(avatar.Data, avatar.ContentType, true);
await _basicUserService.ThrowIfUserNotExist(userId);
var entity = await _database.UserAvatars.Where(a => a.UserId == userId).SingleOrDefaultAsync();
await using var transaction = await _database.Database.BeginTransactionAsync();
var tag = await _dataManager.RetainEntryAsync(avatar.Data);
var now = _clock.GetCurrentTime();
if (entity is null)
{
var newEntity = new UserAvatarEntity
{
DataTag = tag,
Type = avatar.ContentType,
LastModified = now,
UserId = userId
};
_database.Add(newEntity);
}
else
{
if (entity.DataTag is not null)
{
await _dataManager.FreeEntryAsync(entity.DataTag);
}
entity.DataTag = tag;
entity.Type = avatar.ContentType;
entity.LastModified = now;
}
await _database.SaveChangesAsync();
await transaction.CommitAsync();
_logger.LogInformation(Resource.LogSetAvatar, userId);
return(new CacheableDataDigest(tag, now));
}
public async Task <ActionResult <HttpCreateTokenResponse> > Create([FromBody] HttpCreateTokenRequest request)
{
try
{
DateTime?expireTime = null;
if (request.Expire is not null)
{
expireTime = _clock.GetCurrentTime().AddDays(request.Expire.Value);
}
var result = await _userTokenManager.CreateTokenAsync(request.Username, request.Password, expireTime);
return(new HttpCreateTokenResponse
{
Token = result.Token,
User = await _mapper.MapAsync <HttpUser>(result.User, Url, User)
});
}
catch (EntityNotExistException)
{
return(BadRequestWithCommonResponse(ErrorCodes.TokenController.CreateBadCredential, Resource.MessageTokenCreateBadCredential));
}
catch (BadPasswordException)
{
return(BadRequestWithCommonResponse(ErrorCodes.TokenController.CreateBadCredential, Resource.MessageTokenCreateBadCredential));
}
}
private HardwareStatus ParseV4StatusElements(IReadOnlyList <string> elements)
{
log.Info("V4 status");
var elementsLength = elements.Count;
if (elementsLength != 23)
{
var message = $"V4 GINF packet had wrong number of elements: expected 23, found {elementsLength}";
log.Error(message);
var ex = new ArgumentException(message, "status");
ex.Data["V4 Status Elements"] = elements;
ex.Data["ExpectedElements"] = 23;
ex.Data["ActualElements"] = elementsLength;
throw ex;
}
try
{
var status = new HardwareStatus
{
TimeStamp = timeSource.GetCurrentTime(),
FirmwareVersion = elements[0],
DomeCircumference = Convert.ToInt16(elements[1]),
HomePosition = Convert.ToInt16(elements[2]),
Coast = Convert.ToInt16(elements[3]),
CurrentAzimuth = Convert.ToInt16(elements[4]),
Slaved = elements[5] == "1" ? true : false,
ShutterSensor = (SensorState)Enum.Parse(typeof(SensorState), elements[6]),
DsrSensor = (SensorState)Enum.Parse(typeof(SensorState), elements[7]),
AtHome = elements[8] == "0" ? true : false,
HomeCounterClockwise = Convert.ToInt16(elements[9]),
HomeClockwise = Convert.ToInt16(elements[10]),
UserPins = Convert.ToByte(elements[11]),
WeatherAge = Convert.ToInt16(elements[12]),
WindDirection = Convert.ToInt16(elements[13]),
WindSpeed = Convert.ToInt16(elements[14]),
Temperature = Convert.ToInt16(elements[15]),
Humidity = Convert.ToInt16(elements[16]),
Wetness = Convert.ToInt16(elements[17]),
Snow = Convert.ToInt16(elements[18]),
WindPeak = Convert.ToInt16(elements[19]),
Lx200Azimuth = Convert.ToInt16(elements[20]),
DeadZone = Convert.ToInt16(elements[21]),
Offset = Convert.ToInt16(elements[22])
};
return(status);
}
catch (Exception ex)
{
log.Error(ex, "Exception while parsing GINF packet");
ex.Data["V4 Status Elements"] = elements;
throw;
}
}
public async Task BackupAsync(CancellationToken cancellationToken = default)
{
var backupDirPath = _pathProvider.GetDatabaseBackupDirectory();
Directory.CreateDirectory(backupDirPath);
var fileName = _clock.GetCurrentTime().ToString("yyyy-MM-ddTHH-mm-ss", CultureInfo.InvariantCulture);
var path = Path.Combine(backupDirPath, fileName);
await _database.Database.ExecuteSqlInterpolatedAsync($"VACUUM INTO {path}", cancellationToken);
_logger.LogWarning(Resource.DatabaseBackupServiceFinishBackup, path);
}
protected TimelineEntity CreateNewTimelineEntity(string?name, long ownerId)
{
var currentTime = _clock.GetCurrentTime();
return(new TimelineEntity
{
Name = name,
NameLastModified = currentTime,
OwnerId = ownerId,
Visibility = TimelineVisibility.Register,
CreateTime = currentTime,
LastModified = currentTime,
CurrentPostLocalId = 0,
Members = new List <TimelineMemberEntity>()
});
}
/// <summary>Initializes a new instance of the <see cref="SimulatorStateMachine" /> class.</summary>
/// <param name="timeSource">A source of the current time.</param>
/// <param name="simulatorConfiguration"></param>
public SimulatorStateMachine(IClock timeSource, SimulatorConfiguration simulatorConfiguration, ILog logger)
{
Contract.Requires(timeSource != null);
log = logger;
Configuration = simulatorConfiguration;
this.timeSource = timeSource;
DomeSupportRingOpen = false;
ShutterStuck = false;
HardwareStatus = new HardwareStatus
{
AtHome = false,
Coast = 1,
CurrentAzimuth = 0,
DeadZone = 3,
DomeCircumference = 414,
DsrSensor = SensorState.Indeterminate,
FirmwareVersion = "V4",
HomeClockwise = 16,
HomeCounterClockwise = 1,
HomePosition = 8,
Humidity = 255,
Lx200Azimuth = 999,
Offset = 0,
ShutterSensor = SensorState.Indeterminate,
Slaved = false,
Snow = 255,
// For weather items, 255 means no data
Temperature = 255,
TimeStamp = timeSource.GetCurrentTime(),
UserPins = 0,
WeatherAge = 128,
WindDirection = 255,
WindPeak = 255,
WindSpeed = 255
};
SetAzimuthDependentSensorsAndStates();
// Set the starting state and begin receiving.
SimulatorState.Transition(new StateStartup(this));
var receiveObservable = receiveSubject.AsObservable();
receiveSubscription = receiveObservable.Subscribe(InputStimulus, EndOfSimulation);
}
public async Task <bool> AddHighlightTimelineAsync(long timelineId, long?operatorId)
{
await _timelineService.ThrowIfTimelineNotExist(timelineId);
if (operatorId.HasValue)
{
await _userService.ThrowIfUserNotExist(operatorId.Value);
}
var alreadyIs = await _database.HighlightTimelines.AnyAsync(t => t.TimelineId == timelineId);
if (alreadyIs)
{
return(false);
}
_database.HighlightTimelines.Add(new HighlightTimelineEntity {
TimelineId = timelineId, OperatorId = operatorId, AddTime = _clock.GetCurrentTime(), Order = await _database.HighlightTimelines.CountAsync() + 1
});
await _database.SaveChangesAsync();
return(true);
}
public async Task ChangePropertyAsync(long id, TimelineChangePropertyParams newProperties)
{
if (newProperties is null)
{
throw new ArgumentNullException(nameof(newProperties));
}
if (newProperties.Name is not null)
{
CheckTimelineName(newProperties.Name, nameof(newProperties));
}
if (newProperties.Color is not null)
{
var(result, message) = _colorValidator.Validate(newProperties.Color);
if (!result)
{
throw new ArgumentException(message, nameof(newProperties));
}
}
var entity = await _database.Timelines.Where(t => t.Id == id).SingleOrDefaultAsync();
if (entity is null)
{
throw CreateTimelineNotExistException(id);
}
var changed = false;
var nameChanged = false;
if (newProperties.Name is not null)
{
var conflict = await _database.Timelines.AnyAsync(t => t.Name == newProperties.Name);
if (conflict)
{
throw CreateTimelineConflictException(newProperties.Name);
}
entity.Name = newProperties.Name;
changed = true;
nameChanged = true;
}
if (newProperties.Title != null)
{
changed = true;
entity.Title = newProperties.Title;
}
if (newProperties.Description != null)
{
changed = true;
entity.Description = newProperties.Description;
}
if (newProperties.Visibility.HasValue)
{
changed = true;
entity.Visibility = newProperties.Visibility.Value;
}
if (newProperties.Color is not null)
{
changed = true;
entity.Color = newProperties.Color;
}
if (changed)
{
var currentTime = _clock.GetCurrentTime();
entity.LastModified = currentTime;
if (nameChanged)
{
entity.NameLastModified = currentTime;
}
}
await _database.SaveChangesAsync();
_logger.LogInformation(Resource.LogTimelineUpdated, id);
}
public async Task <TimelinePostEntity> CreatePostAsync(long timelineId, long authorId, TimelinePostCreateRequest request)
{
if (request is null)
{
throw new ArgumentNullException(nameof(request));
}
if (request.Color is not null)
{
CheckColor(request.Color, nameof(request));
}
if (request.DataList is null)
{
throw new ArgumentException(Resource.ExceptionDataListNull, nameof(request));
}
if (request.DataList.Count == 0)
{
throw new ArgumentException(Resource.ExceptionDataListEmpty, nameof(request));
}
if (request.DataList.Count > 100)
{
throw new ArgumentException(Resource.ExceptionDataListTooLarge, nameof(request));
}
for (int index = 0; index < request.DataList.Count; index++)
{
var data = request.DataList[index];
switch (data.ContentType)
{
case MimeTypes.ImageGif:
case MimeTypes.ImageJpeg:
case MimeTypes.ImagePng:
case MimeTypes.ImageWebp:
try
{
await _imageValidator.ValidateAsync(data.Data, data.ContentType);
}
catch (ImageException e)
{
throw new TimelinePostCreateDataException(index, Resource.ExceptionPostDataImageInvalid, e);
}
break;
case MimeTypes.TextPlain:
case MimeTypes.TextMarkdown:
try
{
new UTF8Encoding(false, true).GetString(data.Data);
}
catch (DecoderFallbackException e)
{
throw new TimelinePostCreateDataException(index, Resource.ExceptionPostDataNotValidUtf8, e);
}
break;
default:
throw new TimelinePostCreateDataException(index, Resource.ExceptionPostDataUnsupportedType);
}
}
request.Time = request.Time?.MyToUtc();
await _basicTimelineService.ThrowIfTimelineNotExist(timelineId);
await _basicUserService.ThrowIfUserNotExist(authorId);
var currentTime = _clock.GetCurrentTime();
var finalTime = request.Time ?? currentTime;
await using var transaction = await _database.Database.BeginTransactionAsync();
var postEntity = new TimelinePostEntity
{
AuthorId = authorId,
TimelineId = timelineId,
Time = finalTime,
LastUpdated = currentTime,
Color = request.Color
};
var timelineEntity = await _database.Timelines.Where(t => t.Id == timelineId).SingleAsync();
timelineEntity.CurrentPostLocalId += 1;
postEntity.LocalId = timelineEntity.CurrentPostLocalId;
_database.TimelinePosts.Add(postEntity);
await _database.SaveChangesAsync();
List <string> dataTags = new List <string>();
for (int index = 0; index < request.DataList.Count; index++)
{
var data = request.DataList[index];
var tag = await _dataManager.RetainEntryAsync(data.Data);
_database.TimelinePostData.Add(new TimelinePostDataEntity
{
DataTag = tag,
Kind = data.ContentType,
Index = index,
PostId = postEntity.Id,
LastUpdated = currentTime,
});
}
await _database.SaveChangesAsync();
await transaction.CommitAsync();
_logger.LogInformation(Resource.LogTimelinePostCreated, timelineId, postEntity.Id);
return(postEntity);
}
public async Task <UserEntity> ModifyUserAsync(long id, ModifyUserParams?param)
{
if (param is not null)
{
if (param.Username is not null)
{
CheckUsernameFormat(param.Username, nameof(param));
}
if (param.Password is not null)
{
CheckPasswordFormat(param.Password, nameof(param));
}
if (param.Nickname is not null)
{
CheckNicknameFormat(param.Nickname, nameof(param));
}
}
var entity = await _databaseContext.Users.Where(u => u.Id == id).SingleOrDefaultAsync();
if (entity is null)
{
throw CreateUserNotExistException(id);
}
if (param is not null)
{
var now = _clock.GetCurrentTime();
bool updateLastModified = false;
var username = param.Username;
if (username is not null && username != entity.Username)
{
var conflict = await _databaseContext.Users.AnyAsync(u => u.Username == username);
if (conflict)
{
throw CreateUsernameConflictException(username);
}
entity.Username = username;
entity.UsernameChangeTime = now;
updateLastModified = true;
}
var password = param.Password;
if (password is not null)
{
entity.Password = _passwordService.HashPassword(password);
entity.Version += 1;
}
var nickname = param.Nickname;
if (nickname is not null && nickname != entity.Nickname)
{
entity.Nickname = nickname;
updateLastModified = true;
}
if (updateLastModified)
{
entity.LastModified = now;
}
await _databaseContext.SaveChangesAsync();
_logger.LogInformation(Resource.LogUserModified, entity.Username, id);
}
return(entity);
}
