public async Task <EnrollmentResponse> Execute()
{
var validDate = _DateTimeProvider.Now().AddDays(1); //TODO smells like a setting
var entity = new KeyReleaseWorkflowState
{
LabConfirmationId = _NumberGenerator.GenerateToken(),
Created = _DateTimeProvider.Now(),
BucketId = Convert.ToBase64String(_NumberGenerator.GenerateKey()),
ConfirmationKey = Convert.ToBase64String(_NumberGenerator.GenerateKey()),
ValidUntil = new DateTime(validDate.Year, validDate.Month, validDate.Day, 4, 0, 0, DateTimeKind.Local) //TODO smells like a setting
};
_Logger.LogDebug("Writing.");
await _DbContextProvider.KeyReleaseWorkflowStates.AddAsync(entity);
_Logger.LogDebug("Committing.");
_DbContextProvider.SaveAndCommit();
_Logger.LogDebug("Committed.");
return(new EnrollmentResponse
{
ConfirmationKey = entity.ConfirmationKey,
BucketId = entity.BucketId,
LabConfirmationId = $"{entity.LabConfirmationId.Substring(0, 3)}-{entity.LabConfirmationId.Substring(3, 3)}", //TODO UI concern in DB!
Validity = (long)(entity.ValidUntil - _DateTimeProvider.Now()).TotalSeconds
});
}
public async Task ValidateShouldReturnTrueOnValidTIHJwt()
{
var validToken = "eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJleHAiOiIxNTk5NzUzMTk5IiwiYWNjZXNzX3Rva2VuIjoidGVzdF9hY2Nlc3NfdG9rZW4iLCJpZCI6IjAifQ.osL8kyPx90gUapZzz6Iv-H8DPwgtJTMSKTJA1VtMirU";
var validExp = _DateTimeProvider.Now().AddHours(_ClaimLifetimeHours - .1).ToUnixTimeU64();
var testClaims = new Dictionary <string, string>
{
{ "id", "0" },
{ "exp", validExp.ToString() },
{ "access_token", validToken }
};
_Server.Reset();
_Server.Given(
Request.Create()
.WithHeader("Authorization", "Bearer " + validToken)
.WithPath("/ggdghornl_test/oauth2/v1/verify").UsingGet()
)
.RespondWith(
Response.Create()
.WithStatusCode(200)
.WithHeader("Content-Type", "application/json")
.WithBody("{\"audience\":1234}")
);
Assert.True(await _JwtClaimValidator.ValidateAsync(testClaims));
}
public async Task <SnapshotEksInputResult> Execute(DateTime snapshotStart)
{
_Logger.LogDebug("Snapshot publishable TEKs.");
_SnapshotStart = snapshotStart;
var stopwatchStart = _DateTimeProvider.Now();
const int pagesize = 10000;
var index = 0;
using var tx = _WorkflowDbContext.BeginTransaction();
var page = ReadTeksFromWorkflow(index, pagesize);
while (page.Count > 0)
{
var db = _PublishingDbContextFactory();
await db.BulkInsertAsync2(page.ToList(), new SubsetBulkArgs());
index += page.Count;
page = ReadTeksFromWorkflow(index, pagesize);
}
var result = new SnapshotEksInputResult
{
SnapshotSeconds = (_DateTimeProvider.Now() - stopwatchStart).TotalSeconds,
TekInputCount = index
};
_Logger.LogInformation($"TEKs to publish - Count:{index}.");
return(result);
}
/// <summary>
/// Generate Icc with configuration length and A-Z, 0-9 characters
/// </summary>
/// <param name="userId"></param>
/// <param name="save"></param>
/// <param name="batchId"></param>
/// <returns></returns>
public async Task <InfectionConfirmationCodeEntity> GenerateIcc(string userId, string batchId)
{
var length = Convert.ToInt32(_Configuration.GetSection("IccConfig:Code:Length").Value);
var generatedIcc = _RandomGenerator.GenerateToken(length);
var icc = new InfectionConfirmationCodeEntity
{
Code = generatedIcc, GeneratedBy = userId, Created = _DateTimeProvider.Now(), BatchId = batchId
};
await _DbContext.InfectionConfirmationCodes.AddAsync(icc);
return(icc);
}
public bool Validate(ReleaseTeksArgs args, KeyReleaseWorkflowState workflow)
{
if (args == null)
{
return(false);
}
if (workflow.ValidUntil.AddMinutes(_Config.GracePeriodMinutes) <= _DateTimeProvider.Now()) //30 minutes grace period
{
_Logger.LogWarning($"Workflow is not valid anymore: {args.BucketId}");
return(false);
}
if (_Config.TemporaryExposureKeyCountMin > args.Keys.Length || args.Keys.Length > _Config.TemporaryExposureKeyCountMax)
{
_Logger.LogWarning($"Invalid number of keys: {args.BucketId}");
return(false);
}
if (!args.Keys.All(_TemporaryExposureKeyValidator.Valid))
{
_Logger.LogWarning($"One or more keys not valid: {args.BucketId}");
return(false);
}
return(true);
}
public async Task Execute(HttpContext httpContext)
{
//if (httpContext.Request.Headers.TryGetValue("if-none-match", out var etagValue))
//{
// httpContext.Response.ContentLength = 0;
// httpContext.Response.StatusCode = 400;
//}
var now = _DateTimeProvider.Now();
var e = await _ContentDb.SafeGetLatestContent(ContentTypes.Manifest, now);
if (e == null)
{
httpContext.Response.StatusCode = 200;
httpContext.Response.ContentLength = 0;
return;
}
//if (etagValue == content.PublishingId)
//{
// httpContext.Response.ContentLength = 0;
// httpContext.Response.StatusCode = 304;
// return;
//}
httpContext.Response.Headers.Add("etag", e.PublishingId);
httpContext.Response.Headers.Add("last-modified", e.Release.ToUniversalTime().ToString("r"));
httpContext.Response.Headers.Add("content-type", e.ContentTypeName);
httpContext.Response.Headers.Add("cache-control", _HttpResponseHeaderConfig.ManifestCacheControl);
httpContext.Response.Headers.Add("x-vws-signed", true.ToString());
httpContext.Response.StatusCode = 200;
httpContext.Response.ContentLength = e.Content?.Length ?? throw new InvalidOperationException("SignedContent empty.");
await httpContext.Response.Body.WriteAsync(e.Content);
}
public async Task Execute(WorkflowArgs args)
{
var e = args.ToEntity();
e.Created = _UtcDateTimeProvider.Now();
await _DbContextProvider.Current.AddAsync(e);
}
public ManifestEntity Execute()
{
_DbContext.BeginTransaction(); //TODO should be using WebDbContentProvider
var now = _DateTimeProvider.Now();
var releaseCutoff = now - TimeSpan.FromHours(_GaenContentConfig.ManifestLifetimeHours);
var e = _DbContext.ManifestContent
.Where(x => x.Release > releaseCutoff)
.OrderByDescending(x => x.Release)
.Take(1)
.SingleOrDefault();
if (e != null)
{
return(e);
}
_DbContext.BulkDelete(_DbContext.Set <ManifestEntity>().ToList()); //TODO execute sql.
var content = JsonConvert.SerializeObject(_ManifestBuilder.Execute());
var bytes = Encoding.UTF8.GetBytes(content);
e = new ManifestEntity
{
Release = now,
ContentTypeName = ContentHeaderValues.Json,
Content = bytes,
};
e.PublishingId = _PublishingId.Create(e.Content);
_DbContext.ManifestContent.Add(e);
_DbContext.SaveAndCommit();
return(e);
}
public ContentDatabaseCreateCommand(ContentDbContext dbContextProvider, IUtcDateTimeProvider dateTimeProvider, ContentValidator validator, ContentInsertDbCommand insertDbCommand)
{
_DbContextProvider = dbContextProvider ?? throw new ArgumentNullException(nameof(dbContextProvider));
_DateTimeProvider = dateTimeProvider ?? throw new ArgumentNullException(nameof(dateTimeProvider));
_Validator = validator ?? throw new ArgumentNullException(nameof(validator));
_InsertDbCommand = insertDbCommand ?? throw new ArgumentNullException(nameof(insertDbCommand));
_Snapshot = _DateTimeProvider.Now();
}
public async Task AddExampleContent()
{
await using var tx = await _DbContextProvider.Database.BeginTransactionAsync();
await Write(
new ResourceBundleArgs
{
Release = _DateTimeProvider.Now(),
Text = new Dictionary <string, Dictionary <string, string> >
{
{
"en-GB", new Dictionary <string, string>()
{
{ "InfectedMessage", "You're possibly infected" }
}
},
{
"nl-NL", new Dictionary <string, string>
{
{ "InfectedMessage", "U bent mogelijk geinvecteerd" }
}
}
}
}
);
var rbd = ReadFromResource <ResourceBundleArgs>("RiskCalcDefaults.json");
rbd.Release = _DateTimeProvider.Now();
await Write(rbd);
var rcd = ReadFromResource <RiskCalculationConfigArgs>("RiskCalcDefaults.json");
rcd.Release = _DateTimeProvider.Now();
await Write(rcd);
var acd = ReadFromResource <AppConfigArgs>("AppConfigDefaults.json");
acd.Release = _DateTimeProvider.Now();
await Write(acd);
_DbContextProvider.SaveAndCommit();
}
public string Next()
{
return(_JwtService.Generate(
_DateTimeProvider.Now().AddSeconds(30).ToUnixTimeU64(), //TODO setting?
new Dictionary <string, object>
{
[PayloadElement] = Guid.NewGuid().ToString() // make polltoken unique //TODO use RNG here instead cos index clustering
}));
}
public string Next()
{
return(_JwtService.Generate(
_DateTimeProvider.Now().AddSeconds(30).ToUnixTimeU64(),
new Dictionary <string, object>
{
[PayloadElement] = Guid.NewGuid().ToString()
}));
}
public string GenerateToken()
{
return(_JwtService.Generate(
_DateTimeProvider.Now().AddSeconds(30).ToUnixTime(),
new Dictionary <string, object>
{
[PayloadElement] = Guid.NewGuid().ToString() // make polltoken unique
}));
}
public async Task Execute()
{
var now = _UtcDateTimeProvider.Now();
var hushNow = _Context.Set <KeyReleaseWorkflowState>()
.Where(x => x.Created < now - TimeSpan.FromDays(_GaenContentConfig.KeysLastSecretLifetimeDays))
.ToArray();
await _Context.BulkDeleteAsync(hushNow);
}
public RiskCalculationContentEntity Execute()
{
var now = _DateTimeProvider.Now();
return(_DbConfig.Set <RiskCalculationContentEntity>()
.Where(x => x.Release <= now)
.OrderByDescending(x => x.Release)
.Take(1)
.SingleOrDefault());
}
public async Task <EksEngineResult> Execute()
{
if (_Fired)
{
throw new InvalidOperationException("One use only.");
}
_Fired = true;
_Logger.LogInformation("Started - JobName:{_JobName}", _JobName);
if (!WindowsIdentityStuff.CurrentUserIsAdministrator()) //TODO remove warning when UAC is not in play
{
_Logger.LogWarning("{JobName} started WITHOUT elevated privileges - errors may occur when signing content.", _JobName);
}
_EksEngineResult.Started = _DateTimeProvider.Snapshot; //Not strictly true but we need the jobname for the dispose.
await ClearJobTables();
var snapshotResult = await _Snapshotter.Execute(_EksEngineResult.Started);
_EksEngineResult.InputCount = snapshotResult.TekInputCount;
_EksEngineResult.SnapshotSeconds = snapshotResult.SnapshotSeconds;
_EksEngineResult.TransmissionRiskNoneCount = await GetTransmissionRiskNoneCount();
if (snapshotResult.TekInputCount != 0)
{
await Stuff();
await BuildOutput();
await CommitResults();
}
_EksEngineResult.TotalSeconds = (_DateTimeProvider.Now() - _EksEngineResult.Started).TotalSeconds;
_EksEngineResult.EksInfo = _EksResults.ToArray();
_Logger.LogInformation("Reconciliation - Teks in EKSs matches usable input and stuffing - Delta:{ReconcileOutputCount}", _EksEngineResult.ReconcileOutputCount);
_Logger.LogInformation("Reconciliation - Teks in EKSs matches output count - Delta:{ReconcileEksSumCount}", _EksEngineResult.ReconcileEksSumCount);
_Logger.LogInformation("{JobName} complete.", _JobName);
return(_EksEngineResult);
}
public async Task Execute()
{
var now = _UtcDateTimeProvider.Now();
var timeToDie = _DbConfig.Set <ExposureKeySetContentEntity>()
.Where(x => x.Release < now - TimeSpan.FromDays(_GaenContentConfig.ExposureKeySetLifetimeDays))
.ToList();
await _DbConfig.BulkDeleteAsync(timeToDie);
}
public async Task Execute()
{
var now = _UtcDateTimeProvider.Now();
var hushNow = _DbConfig.Current.Set <KeysFirstWorkflowEntity>()
.Where(x => x.Created < now - TimeSpan.FromDays(_AgConfig.WorkflowSecretLifetimeDays))
.ToArray();
await _DbConfig.Current.BulkDeleteAsync(hushNow);
}
public void Execute(string token)
{
var e = new TokenFirstWorkflowEntity
{
Created = _DateTimeProvider.Now(),
SecretToken = token,
State = TokenFirstWorkflowState.Unauthorised
};
_DbContextProvider.Current.TokenFirstWorkflows.Add(e);
}
public string Execute()
{
var now = _DateTimeProvider.Now();
return(_DbConfig.Current.Set <RivmAdviceContentEntity>()
.Where(x => x.Release <= now)
.OrderByDescending(x => x.Release)
.Take(1)
.Select(x => x.PublishingId)
.SingleOrDefault());
}
public void Execute()
{
var expired = _DateTimeProvider.Now() - TimeSpan.FromDays(_TokenFirstWorkflowConfig.WorkflowWriteWindowDurationMinutes);
_DbContextProvider.BeginTransaction();
var q = _DbContextProvider.Current.TokenFirstWorkflows
.Where(x => x.State == TokenFirstWorkflowState.Receiving && x.ReceivingStarted < expired);
_DbContextProvider.Current.TokenFirstWorkflows.RemoveRange(q);
_DbContextProvider.Current.SaveChanges();
_DbContextProvider.SaveAndCommit();
}
public async Task <ManifestEntity?> Execute(string _)
{
var e = new ManifestEntity
{
Release = _DateTimeProvider.Now(),
};
var content = _ManifestBuilder.Execute();
var formatter = new StandardContentEntityFormatter(new ZippedSignedContentFormatter(_Signer), new StandardPublishingIdFormatter(_Signer));
await formatter.Fill(e, content);
return(e);
}
public async Task <ManifestContent> Execute()
{
var now = _DateTimeProvider.Now();
var lo = now - TimeSpan.FromDays(_GaenContentConfig.ExposureKeySetLifetimeDays);
return(new ManifestContent
{
ExposureKeySets = await _ContentDbContext.SafeGetActiveContentIdList <ExposureKeySetContentEntity>(lo, now),
RiskCalculationParameters = await _ContentDbContext.SafeGetLatestContentId(ContentTypes.RiskCalculationParameters, now),
AppConfig = await _ContentDbContext.SafeGetLatestContentId(ContentTypes.AppConfig, now)
});
}
public void Execute()
{
var expired = _DateTimeProvider.Now() - TimeSpan.FromDays(_TokenFirstWorkflowConfig.WorkflowTokenTtlDays);
_DbContextProvider.BeginTransaction();
var q = _DbContextProvider.Current.TokenFirstWorkflows
.Where(x => x.State == TokenFirstWorkflowState.Unauthorised && x.Created < expired);
_DbContextProvider.Current.TokenFirstWorkflows.RemoveRange(q);
_DbContextProvider.Current.SaveChanges();
_DbContextProvider.SaveAndCommit();
}
public ExposureKeySetBatchJobMk2(/*IExposureKeySetBatchJobConfig jobConfig,*/ IGaenContentConfig gaenContentConfig, IExposureKeySetBuilder builder, WorkflowDbContext workflowDbContext, ExposureContentDbContext contentDbContext, IUtcDateTimeProvider dateTimeProvider, IPublishingId publishingId)
{
//_JobConfig = jobConfig;
_GaenContentConfig = gaenContentConfig;
_SetBuilder = builder;
_WorkflowDbContext = workflowDbContext;
_ContentDbContext = contentDbContext;
_PublishingId = publishingId;
_Used = new List <EksCreateJobInputEntity>(_GaenContentConfig.ExposureKeySetCapacity); //
_Start = dateTimeProvider.Now();
JobName = $"ExposureKeySetsJob_{_Start:u}".Replace(" ", "_").Replace(":", "_");
}
public void Execute(string secretToken)
{
var e = new TokenFirstWorkflowEntity
{
Created = _DateTimeProvider.Now(),
SecretToken = secretToken,
State = TokenFirstWorkflowState.Unauthorised
};
//TODO secret token already exists...
_DbContextProvider.Current.TokenFirstWorkflows.AddAsync(e);
_DbContextProvider.Current.SaveChangesAsync();
}
public ExposureKeySetBatchJobMk2(/*IExposureKeySetBatchJobConfig jobConfig,*/ IGaenContentConfig gaenContentConfig, IExposureKeySetBuilder builder, WorkflowDbContext workflowDbContext, PublishingJobDbContext publishingDbContext, ContentDbContext contentDbContext, IUtcDateTimeProvider dateTimeProvider, IPublishingId publishingId, ILogger <ExposureKeySetBatchJobMk2> logger)
{
//_JobConfig = jobConfig;
_GaenContentConfig = gaenContentConfig ?? throw new ArgumentNullException(nameof(gaenContentConfig));
_SetBuilder = builder ?? throw new ArgumentNullException(nameof(builder));
_WorkflowDbContext = workflowDbContext ?? throw new ArgumentNullException(nameof(workflowDbContext));
_PublishingDbContext = publishingDbContext ?? throw new ArgumentNullException(nameof(publishingDbContext));
_ContentDbContext = contentDbContext ?? throw new ArgumentNullException(nameof(contentDbContext));
_PublishingId = publishingId;
_Logger = logger ?? throw new ArgumentNullException(nameof(logger));
_Used = new List <EksCreateJobInputEntity>(_GaenContentConfig.ExposureKeySetCapacity); //
_Start = dateTimeProvider.Now();
_JobName = $"ExposureKeySetsJob_{_Start:u}".Replace(" ", "_").Replace(":", "_");
}
public async Task Execute()
{
var now = _UtcDateTimeProvider.Now();
var timeToDie = _DbConfig.Set <ExposureKeySetContentEntity>()
.Where(x => x.Release < now - TimeSpan.FromDays(_GaenContentConfig.ExposureKeySetLifetimeDays))
.ToList();
foreach (var i in timeToDie)
{
_Logger.LogInformation($"Deleting EKS - {i.PublishingId}.");
}
await _DbConfig.BulkDeleteAsync(timeToDie);
}
public void Execute()
{
var expired = _DateTimeProvider.Now() - TimeSpan.FromMinutes(_KeysLastWorkflowConfig.AuthorisationWindowDurationMinutes);
_DbContextProvider.BeginTransaction();
throw new NotImplementedException();
//var q = _DbContextProvider.KeysLastWorkflows
// .Where(x => x.State == KeysLastWorkflowState.Receiving && x.AuthorisationWindowStart < expired);
//_DbContextProvider.KeysLastWorkflows.RemoveRange(q);
_DbContextProvider.SaveChanges();
_DbContextProvider.SaveAndCommit();
}
public string Generate(ClaimsPrincipal claimsPrincipal)
{
if (claimsPrincipal == null)
{
throw new ArgumentNullException(nameof(claimsPrincipal));
}
var builder = CreateBuilder();
builder.AddClaim("exp", _DateTimeProvider.Now().AddHours(_IccPortalConfig.ClaimLifetimeHours).ToUnixTime());
builder.AddClaim("id", GetClaimValue(claimsPrincipal, ClaimTypes.NameIdentifier));
builder.AddClaim("email", GetClaimValue(claimsPrincipal, ClaimTypes.Email));
builder.AddClaim("access_token", GetClaimValue(claimsPrincipal, "http://schemas.u2uconsult.com/ws/2014/03/identity/claims/accesstoken"));
builder.AddClaim("name", GetClaimValue(claimsPrincipal, "http://schemas.u2uconsult.com/ws/2014/04/identity/claims/displayname"));
return(builder.Encode());
}
