internal static async Task <(ConnectionRecord firstParty, ConnectionRecord secondParty)> EstablishConnectionAsync(
IConnectionService connectionService,
IProducerConsumerCollection <IEnvelopeMessage> _messages,
Wallet firstWallet,
Wallet secondWallet,
bool autoConnectionFlow = false)
{
// Create invitation by the issuer
var issuerConnectionId = Guid.NewGuid().ToString();
var inviteConfig = new DefaultCreateInviteConfiguration()
{
ConnectionId = issuerConnectionId,
AutoAcceptConnection = autoConnectionFlow,
MyAlias = new ConnectionAlias()
{
Name = "Issuer",
ImageUrl = "www.issuerdomain.com/profilephoto"
},
TheirAlias = new ConnectionAlias()
{
Name = "Holder",
ImageUrl = "www.holderdomain.com/profilephoto"
}
};
// Issuer creates an invitation
var invitation = await connectionService.CreateInvitationAsync(firstWallet, inviteConfig);
var connectionIssuer = await connectionService.GetAsync(firstWallet, issuerConnectionId);
Assert.Equal(ConnectionState.Invited, connectionIssuer.State);
Assert.True(invitation.Name == inviteConfig.MyAlias.Name &&
invitation.ImageUrl == inviteConfig.MyAlias.ImageUrl);
// Holder accepts invitation and sends a message request
var holderConnectionId = await connectionService.AcceptInvitationAsync(secondWallet, invitation);
var connectionHolder = await connectionService.GetAsync(secondWallet, holderConnectionId);
Assert.Equal(ConnectionState.Negotiating, connectionHolder.State);
// Issuer processes incoming message
var issuerMessage = _messages.OfType <ForwardToKeyEnvelopeMessage>()
.First(x => x.Type.Contains(connectionIssuer.Tags.Single(item => item.Key == "connectionKey").Value));
var requestMessage = GetContentMessage(issuerMessage) as ConnectionRequestMessage;
Assert.NotNull(requestMessage);
// Issuer processes the connection request by storing it and accepting it if auto connection flow is enabled
await connectionService.ProcessRequestAsync(firstWallet, requestMessage);
if (!autoConnectionFlow)
{
connectionIssuer = await connectionService.GetAsync(firstWallet, issuerConnectionId);
Assert.Equal(ConnectionState.Negotiating, connectionIssuer.State);
// Issuer accepts the connection request
await connectionService.AcceptRequestAsync(firstWallet, issuerConnectionId);
}
connectionIssuer = await connectionService.GetAsync(firstWallet, issuerConnectionId);
Assert.Equal(ConnectionState.Connected, connectionIssuer.State);
// Holder processes incoming message
var holderMessage = _messages.OfType <ForwardEnvelopeMessage>()
.First(x => x.Type.Contains(connectionHolder.MyDid));
var responseMessage = GetContentMessage(holderMessage) as ConnectionResponseMessage;
Assert.NotNull(responseMessage);
// Holder processes the response message by accepting it
await connectionService.ProcessResponseAsync(secondWallet, responseMessage);
// Retrieve updated connection state for both issuer and holder
connectionIssuer = await connectionService.GetAsync(firstWallet, issuerConnectionId);
connectionHolder = await connectionService.GetAsync(secondWallet, holderConnectionId);
Assert.True(connectionIssuer.Alias.Name == inviteConfig.TheirAlias.Name &&
connectionIssuer.Alias.ImageUrl == inviteConfig.TheirAlias.ImageUrl);
Assert.True(connectionHolder.Alias.Name == inviteConfig.MyAlias.Name &&
connectionHolder.Alias.ImageUrl == inviteConfig.MyAlias.ImageUrl);
return(connectionIssuer, connectionHolder);
}
/// <inheritdoc />
public virtual async Task <ConnectionInvitationMessage> CreateInvitationAsync(Wallet wallet,
DefaultCreateInviteConfiguration config = null)
{
var connectionId = !string.IsNullOrEmpty(config?.ConnectionId)
? config.ConnectionId
: Guid.NewGuid().ToString();
Logger.LogInformation(LoggingEvents.CreateInvitation, "ConnectionId {0}", connectionId);
var connectionKey = await Crypto.CreateKeyAsync(wallet, "{}");
var connection = new ConnectionRecord();
connection.ConnectionId = connectionId;
connection.Tags.Add(TagConstants.ConnectionKey, connectionKey);
if (config != null && config.AutoAcceptConnection)
{
connection.Tags.Add(TagConstants.AutoAcceptConnection, "true");
}
if (config?.TheirAlias != null)
{
connection.Alias = config.TheirAlias;
if (!string.IsNullOrEmpty(config.TheirAlias.Name))
{
connection.Tags.Add(TagConstants.Alias, config.TheirAlias.Name);
}
}
if (config?.Tags != null)
{
foreach (var tag in config.Tags)
{
if (!connection.Tags.Keys.Contains(tag.Key))
{
connection.Tags.Add(tag.Key, tag.Value);
}
}
}
await RecordService.AddAsync(wallet, connection);
var provisioning = await ProvisioningService.GetProvisioningAsync(wallet);
var invite = new ConnectionInvitationMessage
{
Endpoint = provisioning.Endpoint,
ConnectionKey = connectionKey
};
if (!string.IsNullOrEmpty(provisioning.Owner?.Name))
{
invite.Name = provisioning.Owner.Name;
}
if (!string.IsNullOrEmpty(provisioning.Owner?.ImageUrl))
{
invite.ImageUrl = provisioning.Owner.ImageUrl;
}
if (!string.IsNullOrEmpty(config?.MyAlias?.Name))
{
invite.Name = config.MyAlias.Name;
}
if (!string.IsNullOrEmpty(config?.MyAlias?.ImageUrl))
{
invite.ImageUrl = config.MyAlias.ImageUrl;
}
return(invite);
}
