protected virtual async Task <TokenResponse> ProcessRefreshTokenRequestAsync(TokenRequestValidationResult request)
{
var authRecord = new AuthRecord
{
AccessToken = TokenUtils.GenerateToken(),
RefreshToken = TokenUtils.GenerateToken(),
RefreshedAt = Clock.UtcNow.UtcDateTime,
};
var result = await AuthRecordUpdateCommand.Execute(new UpdateAuthRecordRequest
{
RefreshToken = request.ValidatedRequest.RefreshTokenHandle,
AuthRecord = authRecord
});
var response = new TokenResponse
{
AccessToken = authRecord.AccessToken,
AccessTokenLifetime = request.ValidatedRequest.AccessTokenLifetime,
Custom = request.CustomResponse,
Scope = string.Join(" ", request.ValidatedRequest.RefreshToken.Scopes),
RefreshToken = authRecord.RefreshToken
};
return(response);
}
public async Task Update(string refreshToken, AuthRecord updatedAuthRecord)
{
var filter = Builders <AuthRecord> .Filter.Eq("refreshToken", refreshToken);
var update = Builders <AuthRecord> .Update
.Set("refreshToken", updatedAuthRecord.RefreshToken)
.Set("accessToken", updatedAuthRecord.AccessToken)
.Set("refreshedAt", updatedAuthRecord.RefreshedAt);
await _authRecords.UpdateOneAsync(filter, update);
}
public async Task StoreAsync <T>(string key, T value)
{
var collection = _database.GetCollection <AuthRecord <T> >(COLLECTION_NAME);
AuthRecord <T> authRecord = new AuthRecord <T>(value, key);
var replaceOneResult = await collection.ReplaceOneAsync(
doc => doc.Id == key,
authRecord,
new UpdateOptions { IsUpsert = true });
_logger.Debug("mongo upsert match count: {matchCount}", replaceOneResult.MatchedCount);
}
public async Task <bool?> InsertAuthenticationRecord([NotNull] AuthRecord authRecord)
{
try {
await _dbContext.AuthRecords.AddAsync(authRecord);
var result = await _dbContext.SaveChangesAsync();
return(result != 0);
}
catch (DbUpdateException e) {
await _coreLogService.InsertRoutinizeCoreLog(new RoutinizeCoreLog {
Location = $"{ nameof(AuthenticationService) }.{ nameof(InsertAuthenticationRecord) }",
Caller = $"{ new StackTrace().GetFrame(4)?.GetMethod()?.DeclaringType?.FullName }",
BriefInformation = nameof(DbUpdateException),
DetailedInformation = $"Error while inserting entry into AuthRecords.\n\n{ e.StackTrace }",
ParamData = $"{ nameof(authRecord.AccountId) } = { authRecord.AccountId }",
Severity = SharedEnums.LogSeverity.High.GetEnumValue()
});
return(null);
}
}
public async ValueTask <MuzlanResponse <DownloadRecord> > DownloadTrack(TrackRecord track, AuthRecord auth, CancellationToken cancellationToken = default)
{
var sourceUri = new Uri(track.DownloadUri, $"?key={auth.MediaToken}");
var fileExtension = NormalizeFileExtension(Path.GetExtension(sourceUri.LocalPath));
var fileName = track.Name;
try
{
using var response = await _client.GetAsync(sourceUri, HttpCompletionOption.ResponseHeadersRead, cancellationToken).ConfigureAwait(false);
response.EnsureSuccessStatusCode();
var contentLength = response.Content.Headers.GetValues("Content-Length").First();
var fileSize = int.Parse(contentLength);
var fileOffset = 0;
var bytesRead = 0;
var fileData = new byte[fileSize];
await OnDownloadProgressChanged(fileOffset, fileSize).ConfigureAwait(false);
using var stream = await response.Content.ReadAsStreamAsync(cancellationToken).ConfigureAwait(false);
bool hasCompletedEvent = false;
do
{
if (fileOffset >= fileSize)
{
break;
}
bytesRead = await stream.ReadAsync(
ConvertToMemory(fileData, fileOffset, 8192),
cancellationToken).ConfigureAwait(false);
fileOffset += bytesRead;
if (fileOffset == fileSize)
{
hasCompletedEvent = true;
}
await OnDownloadProgressChanged(fileOffset, fileSize).ConfigureAwait(false);
} while (bytesRead > 0);
if (!hasCompletedEvent)
{
await OnDownloadProgressChanged(fileSize, fileSize).ConfigureAwait(false);
}
var file = new DownloadRecord(fileName + fileExtension, fileData, sourceUri);
return(MuzlanResponse <DownloadRecord> .FromResult(file, sourceUri));
}
catch (Exception ex)
{
return(MuzlanResponse <DownloadRecord> .FromException(ex, sourceUri));
}
}
public async Task Insert(AuthRecord authRecord)
{
await _authRecords.InsertOneAsync(authRecord);
}
