public ConsentManagementService(IDataAccessService dataAccessService, IAccountsService accountsService,
IRelationsProofsValidationService relationsProofsValidationService, IConfigurationService configurationService,
IHashCalculationsRepository hashCalculationsRepository, ILoggerService loggerService, IHubContext <ConsentManagementHub> hubContext)
{
_logger = loggerService.GetLogger(nameof(ConsentManagementService));
_dataAccessService = dataAccessService;
_accountsService = accountsService;
_relationsProofsValidationService = relationsProofsValidationService;
_hubContext = hubContext;
_azureConfiguration = configurationService.Get <IAzureConfiguration>();
_hashCalculation = hashCalculationsRepository.Create(Globals.DEFAULT_HASH);
PipeIn = new ActionBlock <PacketBase>(async p =>
{
try
{
if (p is GroupsRelationsProofs relationsProofs)
{
_logger.LogIfDebug(() => $"[{_accountId}]: checking relation proofs {JsonConvert.SerializeObject(relationsProofs, new ByteArrayJsonConverter())}");
UtxoPersistency utxoPersistency = _executionContextManager.ResolveUtxoExecutionServices(_accountId);
utxoPersistency.ClientCryptoService.DecodeEcdhTuple(relationsProofs.EcdhTuple, relationsProofs.TransactionPublicKey, out byte[] blindingFactor, out byte[] imageHash, out byte[] issuer, out byte[] sessionKey);
string keyImage = relationsProofs.KeyImage.ToString();
_proofsSessions.AddOrUpdate(keyImage, new ProofsSession {
SessionKey = sessionKey.ToHexString(), CreationTime = DateTime.UtcNow
}, (k, v) => v);
RelationProofsSession relationProofsSession = PopRelationProofSession(sessionKey.ToHexString());
_logger.LogIfDebug(() => $"{nameof(relationProofsSession)}={JsonConvert.SerializeObject(relationProofsSession, new ByteArrayJsonConverter())}");
RelationProofsValidationResults validationResults
= await _relationsProofsValidationService
.VerifyRelationProofs(relationsProofs, _clientCryptoService, relationProofsSession)
.ConfigureAwait(false);
await _hubContext.Clients.Group(sessionKey.ToHexString()).SendAsync("ValidationResults", validationResults).ConfigureAwait(false);
}
else if (p is TransitionCompromisedProofs compromisedProofs)
{
if (_proofsSessions.TryGetValue(compromisedProofs.CompromisedKeyImage.ToHexString(), out ProofsSession proofsSession))
{
await _hubContext.Clients.Group(proofsSession.SessionKey).SendAsync("ProofsCompromised", proofsSession).ConfigureAwait(false);
}
}
}
catch (Exception ex)
{
_logger.Error($"[{_accountId}]: failure during processing {p.GetType().Name}", ex);
}
});
PipInNotifications = new ActionBlock <SynchronizerNotificationBase>(n =>
{
});
}
protected Queue(IAzureConfiguration azureConfiguration, string queueName)
{
if (azureConfiguration == null)
{
throw new ArgumentNullException(nameof(azureConfiguration));
}
ConnectionString = azureConfiguration.ServiceBusConnectionString;
Name = queueName ?? throw new ArgumentNullException(nameof(queueName));
}
public static IAzureConfiguration AddDeployment(this IAzureConfiguration azureConfiguration)
{
if (azureConfiguration is null)
{
throw new ArgumentNullException(nameof(azureConfiguration));
}
azureConfiguration.Services
.TryAddSingleton <IAzureDeploymentService, AzureDeploymentService>();
return(azureConfiguration);
}
public UserRepository(IAzureConfiguration azureConfiguration)
{
this.AzureConfiguration = azureConfiguration;
var connectionString = this.AzureConfiguration.GetConnectionString(ASPNETAUTHCONNECTIONSTRING);
// note: the method to create this ApplicationUserManager is taken from the default visual studio asp.net project template with individual user account auth.
// this ApplicationUserManager will be consumed by this repository similarly to how the AccountController in the default template consumes it.
var appContext = new ApplicationDbContext(connectionString);
this.ApplicationUserManager = new ApplicationUserManager(new UserStore <ApplicationUser>(appContext));
this.ApplicationRoleManager = new ApplicationRoleManager(new RoleStore <IdentityRole>(appContext));
}
public O10InherenceService(IDataAccessService dataAccessService,
IAccountsService accountsService,
IConfigurationService configurationService,
ISpValidationsService spValidationsService,
IExecutionContextManager executionContextManager,
IUniversalProofsPool universalProofsPool,
IIdentityKeyProvidersRegistry identityKeyProvidersRegistry,
IHubContext <O10InherenceHub> o10InherenceHubContext,
ILoggerService loggerService)
{
_sessions = new ConcurrentDictionary <string, TaskCompletionSource <InherenceData> >();
_dataAccessService = dataAccessService;
_accountsService = accountsService;
_spValidationsService = spValidationsService;
_o10InherenceHubContext = o10InherenceHubContext;
_portalConfiguration = configurationService.Get <IPortalConfiguration>();
_azureConfiguration = configurationService.Get <IAzureConfiguration>();
_logger = loggerService.GetLogger(nameof(O10InherenceService));
_executionContextManager = executionContextManager;
_universalProofsPool = universalProofsPool;
_identityKeyProvider = identityKeyProvidersRegistry.GetInstance();
PipeIn = new ActionBlock <PacketBase>(
async p =>
{
try
{
if (p is IdentityProofs identityProofs)
{
ProcessIdentityProofs(identityProofs);
}
else if (p is UniversalTransport universalTransport)
{
await ProcessUniversalTransport(universalTransport).ConfigureAwait(false);
}
}
catch
{
_logger.Error("Unexpected exception at PipeIn");
}
});
PipInNotifications = new ActionBlock <SynchronizerNotificationBase>(n =>
{
});
}
public ExternalIdpsInitializer(IDataAccessService dataAccessService, IAccountsService accountsService, IExecutionContextManager executionContextManager,
IConfigurationService configurationService, ILoggerService loggerService)
{
if (configurationService is null)
{
throw new System.ArgumentNullException(nameof(configurationService));
}
if (loggerService is null)
{
throw new System.ArgumentNullException(nameof(loggerService));
}
_dataAccessService = dataAccessService ?? throw new System.ArgumentNullException(nameof(dataAccessService));
_accountsService = accountsService ?? throw new System.ArgumentNullException(nameof(accountsService));
_executionContextManager = executionContextManager;
_azureConfiguration = configurationService.Get <IAzureConfiguration>();
_logger = loggerService.GetLogger(nameof(ExternalIdpsInitializer));
}
public TaskRequestQueue(IAzureConfiguration azureConfiguration)
{
_azureConfiguration = azureConfiguration;
ConnectionString = _azureConfiguration.ServiceBusConnectionString;
}
public BlobService(ICloudStorageAccount cloudStorageAccount, IAzureConfiguration azureConfiguration)
{
this.cloudStorageAccount = cloudStorageAccount;
this.azureConfiguration = azureConfiguration;
}
public static void SetDeploymentArtifactsProvider <T>(this IAzureConfiguration azureConfiguration)
where T : class, IAzureDeploymentArtifactsProvider
=> (azureConfiguration ?? throw new ArgumentNullException(nameof(azureConfiguration)))
public AzureService(IAzureConfiguration azureConfiguration)
{
_azureConfiguration = azureConfiguration;
}
protected TaskRequestQueue(IAzureConfiguration azureConfiguration, string taskQueueName) : base(azureConfiguration, taskQueueName)
{
}
public O10BotService(IConfigurationService configurationService, ILoggerService loggerService)
{
_telegramConfiguration = configurationService.Get <ITelegramConfiguration>();
_azureConfiguration = configurationService.Get <IAzureConfiguration>();
_logger = loggerService.GetLogger(nameof(O10BotService));
}
