public async Task <bool> Update(ProvisioningConfiguration provisioningConfiguration, CancellationToken cancellationToken)
{
var update = Builders <ProvisioningConfiguration> .Update.Set(s => s, provisioningConfiguration);
await _dbContext.ProvisioningConfigurationLst.UpdateOneAsync(a => a.Id == provisioningConfiguration.Id, update);
return(true);
}
protected JObject BuildHTTPRequest(JObject representation, ProvisioningConfiguration configuration)
{
var result = new JObject();
var mappingRules = configuration.GetMappingRules();
foreach (var mappingRule in mappingRules)
{
var token = representation.SelectToken(mappingRule.Key);
if (token == null)
{
continue;
}
var splitted = mappingRule.Value.Split('.');
JObject childRecord = null;
if (splitted.Length == 1)
{
result.Add(splitted.First(), token);
}
else
{
for (int i = splitted.Length - 1; i >= 0; i--)
{
var name = splitted[i];
if (childRecord == null)
{
childRecord = new JObject();
childRecord.Add(name, token);
continue;
}
if (i == 0)
{
var cl = result.SelectToken(name) as JObject;
if (cl != null)
{
foreach (var kvp in childRecord)
{
cl.Add(kvp.Key, kvp.Value);
}
}
else
{
result.Add(name, childRecord);
}
}
else
{
var rec = new JObject();
rec.Add(name, childRecord);
childRecord = rec;
}
}
}
}
return(result);
}
/// <inheritdoc />
public virtual async Task ProvisionAgentAsync(Wallet wallet, ProvisioningConfiguration provisioningConfiguration)
{
if (provisioningConfiguration == null)
{
throw new ArgumentNullException(nameof(provisioningConfiguration));
}
if (provisioningConfiguration.EndpointUri == null)
{
throw new ArgumentNullException(nameof(provisioningConfiguration.EndpointUri));
}
var record = await GetProvisioningAsync(wallet);
if (record != null)
{
throw new WalletAlreadyProvisionedException();
}
var agent = await Did.CreateAndStoreMyDidAsync(wallet,
provisioningConfiguration.AgentSeed != null
?new { seed = provisioningConfiguration.AgentSeed }.ToJson()
: "{}");
var masterSecretId = await AnonCreds.ProverCreateMasterSecretAsync(wallet, null);
record = new ProvisioningRecord
{
IssuerSeed = provisioningConfiguration.IssuerSeed,
AgentSeed = provisioningConfiguration.AgentSeed,
MasterSecretId = masterSecretId,
Endpoint =
{
Uri = provisioningConfiguration.EndpointUri.ToString(),
Did = agent.Did,
Verkey = agent.VerKey
},
Owner =
{
Name = provisioningConfiguration.OwnerName,
ImageUrl = provisioningConfiguration.OwnerImageUrl
},
TailsBaseUri = provisioningConfiguration.TailsBaseUri.ToString()
};
if (provisioningConfiguration.CreateIssuer)
{
var issuer = await Did.CreateAndStoreMyDidAsync(wallet,
provisioningConfiguration.IssuerSeed != null
?new { seed = provisioningConfiguration.IssuerSeed }.ToJson()
: "{}");
record.IssuerDid = issuer.Did;
record.IssuerVerkey = issuer.VerKey;
}
await RecordService.AddAsync(wallet, record);
}
/// <summary>
/// Initializes a new instance of the <see cref="T:AgentFramework.AspNetCore.Hosting.AgentHostedService"/> class.
/// </summary>
/// <param name="provisioningService">Provisioning service.</param>
/// <param name="provisioningConfiguration">Provisioning configuration.</param>
/// <param name="poolService">Pool service.</param>
/// <param name="poolOptions">Pool options.</param>
public ProvisioningHostedService(
ProvisioningConfiguration provisioningConfiguration,
IProvisioningService provisioningService,
IPoolService poolService,
IOptions <PoolOptions> poolOptions)
{
ProvisioningConfiguration = provisioningConfiguration;
_provisioningService = provisioningService;
_poolService = poolService;
_poolOptions = poolOptions.Value;
}
public static ProvisioningConfigurationResult ToDto(ProvisioningConfiguration provisioning)
{
return(new ProvisioningConfigurationResult
{
Id = provisioning.Id,
ResourceType = provisioning.ResourceType,
Type = provisioning.Type,
UpdateDateTime = provisioning.UpdateDateTime,
Records = provisioning.Records.Select(r => ProvisioningConfigurationRecordResult.ToDto(r)).ToList()
});
}
protected override async Task <WorkflowResult> LaunchWorkflow(ProvisioningConfiguration configuration, ConsumeContext <RepresentationAddedEvent> context)
{
using (var httpClient = new HttpClient())
{
var processInstanceId = await CreateProcessInstance(configuration, httpClient);
await LaunchProcessInstance(processInstanceId, configuration, httpClient);
await RaiseEvent(processInstanceId, configuration, context, httpClient);
return(new WorkflowResult(processInstanceId, configuration.GetBpmnFileId()));
}
}
public virtual async Task ProvisionAgentAsync(Wallet wallet, ProvisioningConfiguration provisioningConfiguration)
{
if (provisioningConfiguration == null)
{
throw new ArgumentNullException(nameof(provisioningConfiguration));
}
if (provisioningConfiguration.EndpointUri == null)
{
throw new ArgumentNullException(nameof(provisioningConfiguration.EndpointUri));
}
ProvisioningRecord record = null;
try
{
record = await GetProvisioningAsync(wallet);
}
catch (AgentFrameworkException e) when(e.ErrorCode == ErrorCode.RecordNotFound)
{
}
if (record != null)
{
throw new AgentFrameworkException(ErrorCode.WalletAlreadyProvisioned);
}
var agent = await Did.CreateAndStoreMyDidAsync(wallet,
provisioningConfiguration.AgentSeed != null
?new { seed = provisioningConfiguration.AgentSeed }.ToJson()
: "{}");
var masterSecretId = await AnonCreds.ProverCreateMasterSecretAsync(wallet, null);
record = new ProvisioningRecord
{
MasterSecretId = masterSecretId,
Endpoint =
{
Uri = provisioningConfiguration.EndpointUri.ToString(),
Did = agent.Did,
Verkey = agent.VerKey
},
Owner =
{
Name = provisioningConfiguration.OwnerName,
ImageUrl = provisioningConfiguration.OwnerImageUrl
}
};
await provisioningConfiguration.ConfigureAsync(record, new DefaultAgentContext { Wallet = wallet });
await RecordService.AddAsync(wallet, record);
}
private async Task RaiseEvent(string processInstanceId, ProvisioningConfiguration configuration, ConsumeContext <RepresentationAddedEvent> context, HttpClient httpClient)
{
var message = ParseMessageToken(configuration, context);
var request = new HttpRequestMessage
{
RequestUri = new Uri($"{configuration.GetBpmnEndpoint()}/processinstances/{processInstanceId}/messages"),
Method = HttpMethod.Post,
Content = new StringContent(message, Encoding.UTF8, "application/json")
};
var httpResult = await httpClient.SendAsync(request);
httpResult.EnsureSuccessStatusCode();
}
public SovrinTokenConfigurationService(
IApplicationLifetime applicationLifetime,
IOptions <ProvisioningConfiguration> configuration,
IPaymentService paymentService,
IProvisioningService provisioningService,
IAgentProvider agentProvider,
IWalletRecordService recordService,
ILogger <SovrinTokenConfigurationService> logger)
{
applicationLifetime.ApplicationStarted.Register(CreateDefaultPaymentAddress);
AgentConfiguration = configuration.Value;
this.paymentService = paymentService;
this.provisioningService = provisioningService;
this.agentProvider = agentProvider;
this.recordService = recordService;
this.logger = logger;
}
private async Task <string> CreateProcessInstance(ProvisioningConfiguration configuration, HttpClient httpClient)
{
var content = new JObject();
content.Add("processFileId", configuration.GetBpmnFileId());
var request = new HttpRequestMessage
{
RequestUri = new Uri($"{configuration.GetBpmnEndpoint()}/processinstances"),
Method = HttpMethod.Post,
Content = new StringContent(content.ToString(), Encoding.UTF8, "application/json")
};
var httpResult = await httpClient.SendAsync(request);
httpResult.EnsureSuccessStatusCode();
var str = await httpResult.Content.ReadAsStringAsync();
return(JObject.Parse(str).SelectToken("content[0].id").ToString());
}
protected async Task <string> GetAccessToken(ProvisioningConfiguration configuration, CancellationToken cancellatinToken)
{
using (var httpClient = new HttpClient())
{
var request = new HttpRequestMessage
{
RequestUri = new Uri(configuration.GetTokenEndpoint()),
Method = HttpMethod.Post,
Content = new FormUrlEncodedContent(new Dictionary <string, string>
{
{ "client_id", configuration.GetClientId() },
{ "client_secret", configuration.GetClientSecret() },
{ "grant_type", "client_credentials" },
{ "scope", string.Join(" ", configuration.GetScopes()) }
})
};
var httpResult = await httpClient.SendAsync(request, cancellatinToken);
var json = await httpResult.Content.ReadAsStringAsync(cancellatinToken);
var jObj = JObject.Parse(json);
return(jObj["access_token"].ToString());
}
}
private static string ParseMessageToken(ProvisioningConfiguration configuration, ConsumeContext <RepresentationAddedEvent> context)
{
var representation = context.Message.Representation;
var regularExpression = new Regex(@"\{{([a-zA-Z]|_|[0-9]|\[|\]|\.)*\}}");
var result = regularExpression.Replace(configuration.GetMessageToken(), (m) =>
{
if (string.IsNullOrWhiteSpace(m.Value))
{
return(string.Empty);
}
var value = m.Value.Replace("{{", "");
value = value.Replace("}}", "");
var token = representation.SelectToken(value);
if (token == null)
{
return(string.Empty);
}
return(token.ToString());
});
return(result);
}
public static string GetTargetUrl(this ProvisioningConfiguration provisioningConfiguration)
{
return(provisioningConfiguration.Records.First(r => r.Name == "targetUrl").ValuesString.First());
}
private async Task LaunchProcessInstance(string processInstanceId, ProvisioningConfiguration configuration, HttpClient httpClient)
{
var httpResult = await httpClient.GetAsync($"{configuration.GetBpmnEndpoint()}/processinstances/{processInstanceId}/start");
httpResult.EnsureSuccessStatusCode();
}
/// <inheritdoc />
public virtual async Task ProvisionAgentAsync(ProvisioningConfiguration configuration)
{
if (configuration == null)
{
throw new ArgumentNullException(nameof(configuration));
}
if (configuration.WalletConfiguration == null ||
configuration.WalletCredentials == null)
{
throw new ArgumentNullException(nameof(configuration),
"Wallet configuration and credentials must be specified");
}
// Create agent wallet
await WalletService.CreateWalletAsync(configuration.WalletConfiguration, configuration.WalletCredentials);
var wallet =
await WalletService.GetWalletAsync(configuration.WalletConfiguration, configuration.WalletCredentials);
// Configure agent endpoint
AgentEndpoint endpoint = null;
if (configuration.EndpointUri != null)
{
endpoint = new AgentEndpoint {
Uri = configuration.EndpointUri?.ToString()
};
if (configuration.AgentSeed != null)
{
var agent = await Did.CreateAndStoreMyDidAsync(wallet, new { seed = configuration.AgentSeed }.ToJson());
endpoint.Did = agent.Did;
endpoint.Verkey = agent.VerKey;
}
else if (configuration.AgentDid != null && configuration.AgentVerkey != null)
{
endpoint.Did = configuration.AgentDid;
endpoint.Verkey = configuration.AgentVerkey;
}
else
{
var agent = await Did.CreateAndStoreMyDidAsync(wallet, "{}");
endpoint.Did = agent.Did;
endpoint.Verkey = agent.VerKey;
}
}
var masterSecretId = await AnonCreds.ProverCreateMasterSecretAsync(wallet, null);
var record = new ProvisioningRecord
{
MasterSecretId = masterSecretId,
Endpoint = endpoint,
Owner =
{
Name = configuration.OwnerName,
ImageUrl = configuration.OwnerImageUrl
},
PassCode = configuration.PassCode
};
// Populate initial tags if any passed
if (configuration.Tags != null && configuration.Tags.Any())
{
foreach (var item in configuration.Tags)
{
record.Tags.Add(item.Key, item.Value);
}
}
// Create issuer
await configuration.ConfigureAsync(record, new DefaultAgentContext { Wallet = wallet });
await RecordService.AddAsync(wallet, record);
}
public async Task Seed(ProvisioningOperations operation, string representationId, JObject representation, ProvisioningConfiguration configuration, CancellationToken cancellationToken)
{
var accessToken = await GetAccessToken(configuration, cancellationToken);
HttpRequestMessage request = null;
switch (operation)
{
case ProvisioningOperations.ADD:
{
var content = BuildHTTPRequest(representation, configuration);
request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri(configuration.GetTargetUrl()),
Content = new StringContent(content, Encoding.UTF8, "application/json")
};
}
break;
case ProvisioningOperations.UPDATE:
{
var httpRequest = BuildHTTPRequest(representation, configuration);
request = new HttpRequestMessage
{
Method = HttpMethod.Put,
RequestUri = new Uri($"{configuration.GetTargetUrl()}/{representationId}"),
Content = new StringContent(httpRequest.ToString(), Encoding.UTF8, "application/json")
};
}
break;
case ProvisioningOperations.DELETE:
request = new HttpRequestMessage
{
Method = HttpMethod.Delete,
RequestUri = new Uri($"{configuration.GetTargetUrl()}/{representationId}")
};
break;
}
using (var httpClient = new HttpClient())
{
request.Headers.Add("Authorization", $"Bearer {accessToken}");
var httpResult = await httpClient.SendAsync(request, cancellationToken);
httpResult.EnsureSuccessStatusCode();
}
}
protected string BuildHTTPRequest(JObject representation, ProvisioningConfiguration configuration)
{
var template = configuration.GetHttpRequestTemplate();
return(TemplateParser.ParseMessage(template, representation));
}
public Task <bool> Update(ProvisioningConfiguration provisioningConfiguration, CancellationToken cancellationToken)
{
_dbContext.ProvisioningConfigurations.Update(provisioningConfiguration);
return(Task.FromResult(true));
}
protected override Task <WorkflowResult> LaunchWorkflow(ProvisioningConfiguration configuration, ConsumeContext <UserAddedEvent> context)
{
return(Task.FromResult((WorkflowResult) new WorkflowResult(string.Empty, string.Empty)));
}
public static string GetMessageToken(this ProvisioningConfiguration provisioningConfiguration)
{
return(provisioningConfiguration.Records.First(r => r.Name == "messageToken").ValuesString.First());
}
public static string GetTokenEndpoint(this ProvisioningConfiguration provisioningConfiguration)
{
return(provisioningConfiguration.Records.First(r => r.Name == "tokenEdp").ValuesString.First());
}
public static string GetClientSecret(this ProvisioningConfiguration provisioningConfiguration)
{
return(provisioningConfiguration.Records.First(r => r.Name == "clientSecret").ValuesString.First());
}
public static ICollection <string> GetScopes(this ProvisioningConfiguration provisioningConfiguration)
{
return(provisioningConfiguration.Records.First(r => r.Name == "scopes").ValuesString);
}
protected override Task <WorkflowResult> LaunchWorkflow(ProvisioningConfiguration configuration, ConsumeContext <RepresentationUpdatedEvent> context)
{
return(Task.FromResult((WorkflowResult)null));
}
public static string GetBpmnFileId(this ProvisioningConfiguration provisioningConfiguration)
{
return(provisioningConfiguration.Records.First(r => r.Name == "bpmnFileId").ValuesString.First());
}
public Task <bool> Update(ProvisioningConfiguration provisioningConfiguration, CancellationToken cancellationToken)
{
return(Task.FromResult(true));
}
public static string GetHttpRequestTemplate(this ProvisioningConfiguration provisioningConfiguration)
{
return(provisioningConfiguration.Records.First(r => r.Name == "httpRequestTemplate").ValuesString.First());
}
public static Dictionary <string, string> GetMappingRules(this ProvisioningConfiguration provisioningConfiguration)
{
return(new Dictionary <string, string>(provisioningConfiguration.Records.First(r => r.Name == "mapping").Values.Select(v => new KeyValuePair <string, string>(v.Name, v.ValuesString.First()))));
}
protected abstract Task <WorkflowResult> LaunchWorkflow(ProvisioningConfiguration configuration, ConsumeContext <TMessage> context);
private static string ParseMessageToken(ProvisioningConfiguration configuration, ConsumeContext <RepresentationAddedEvent> context)
{
var representation = context.Message.Representation;
return(TemplateParser.ParseMessage(configuration.GetMessageToken(), representation));
}
