/// <inheritdoc />
public virtual async Task <string> ProcessRequestAsync(IAgentContext agentContext, ConnectionRequestMessage request, ConnectionRecord connection)
{
Logger.LogInformation(LoggingEvents.ProcessConnectionRequest, "Did {0}", request.Connection.Did);
var my = await Did.CreateAndStoreMyDidAsync(agentContext.Wallet, "{}");
//TODO throw exception or a problem report if the connection request features a did doc that has no indy agent did doc convention featured
//i.e there is no way for this agent to respond to messages. And or no keys specified
await Did.StoreTheirDidAsync(agentContext.Wallet, new { did = request.Connection.Did, verkey = request.Connection.DidDoc.Keys[0].PublicKeyBase58 }.ToJson());
if (request.Connection.DidDoc.Services != null &&
request.Connection.DidDoc.Services.Count > 0 &&
request.Connection.DidDoc.Services[0] is IndyAgentDidDocService service)
{
connection.Endpoint = new AgentEndpoint(service.ServiceEndpoint, null, service.RoutingKeys != null && service.RoutingKeys.Count > 0 ? service.RoutingKeys.ToArray() : null);
}
connection.TheirDid = request.Connection.Did;
connection.TheirVk = request.Connection.DidDoc.Keys[0].PublicKeyBase58;
connection.MyDid = my.Did;
connection.MyVk = my.VerKey;
connection.SetTag(TagConstants.LastThreadId, request.Id);
if (connection.Alias == null)
{
connection.Alias = new ConnectionAlias();
}
if (!string.IsNullOrEmpty(request.Label) && string.IsNullOrEmpty(connection.Alias.Name))
{
connection.Alias.Name = request.Label;
}
if (!string.IsNullOrEmpty(request.ImageUrl) && string.IsNullOrEmpty(connection.Alias.ImageUrl))
{
connection.Alias.ImageUrl = request.ImageUrl;
}
if (!connection.MultiPartyInvitation)
{
await connection.TriggerAsync(ConnectionTrigger.InvitationAccept);
await RecordService.UpdateAsync(agentContext.Wallet, connection);
EventAggregator.Publish(new ServiceMessageProcessingEvent
{
RecordId = connection.Id,
MessageType = request.Type,
ThreadId = request.GetThreadId()
});
return(connection.Id);
}
var newConnection = connection.DeepCopy();
newConnection.Id = Guid.NewGuid().ToString();
newConnection.MultiPartyInvitation = false;
await newConnection.TriggerAsync(ConnectionTrigger.InvitationAccept);
await RecordService.AddAsync(agentContext.Wallet, newConnection);
EventAggregator.Publish(new ServiceMessageProcessingEvent
{
RecordId = newConnection.Id,
MessageType = request.Type,
ThreadId = request.GetThreadId()
});
return(newConnection.Id);
}
/// <inheritdoc />
public virtual async Task <(ConnectionInvitationMessage, ConnectionRecord)> CreateInvitationAsync(IAgentContext agentContext,
InviteConfiguration config = null)
{
var connectionId = !string.IsNullOrEmpty(config?.ConnectionId)
? config.ConnectionId
: Guid.NewGuid().ToString();
config = config ?? new InviteConfiguration();
Logger.LogInformation(LoggingEvents.CreateInvitation, "ConnectionId {0}", connectionId);
var connectionKey = await Crypto.CreateKeyAsync(agentContext.Wallet, "{}");
var connection = new ConnectionRecord {
Id = connectionId
};
connection.SetTag(TagConstants.ConnectionKey, connectionKey);
if (config.AutoAcceptConnection)
{
connection.SetTag(TagConstants.AutoAcceptConnection, "true");
}
connection.MultiPartyInvitation = config.MultiPartyInvitation;
if (!config.MultiPartyInvitation)
{
connection.Alias = config.TheirAlias;
if (!string.IsNullOrEmpty(config.TheirAlias.Name))
{
connection.SetTag(TagConstants.Alias, config.TheirAlias.Name);
}
}
foreach (var tag in config.Tags)
{
connection.SetTag(tag.Key, tag.Value);
}
var provisioning = await ProvisioningService.GetProvisioningAsync(agentContext.Wallet);
if (string.IsNullOrEmpty(provisioning.Endpoint.Uri))
{
throw new AriesFrameworkException(ErrorCode.RecordInInvalidState, "Provision record has no endpoint information specified");
}
await RecordService.AddAsync(agentContext.Wallet, connection);
IList <string> routingKeys = null;
if (provisioning.Endpoint.Verkey != null)
{
routingKeys = (config.UseDidKeyFormat
? provisioning.Endpoint.Verkey
.Where(DidUtils.IsFullVerkey)
.Select(DidUtils.ConvertVerkeyToDidKey)
: provisioning.Endpoint.Verkey).ToList();
}
string recipientKey = config.UseDidKeyFormat ? DidUtils.ConvertVerkeyToDidKey(connectionKey) : connectionKey;
return(new ConnectionInvitationMessage(agentContext.UseMessageTypesHttps)
{
ServiceEndpoint = provisioning.Endpoint.Uri,
RoutingKeys = routingKeys,
RecipientKeys = new[] { recipientKey },
Label = config.MyAlias.Name ?? provisioning.Owner.Name,
ImageUrl = config.MyAlias.ImageUrl ?? provisioning.Owner.ImageUrl
}, connection);
}
/// <inheritdoc />
public virtual async Task <(ConnectionRequestMessage, ConnectionRecord)> CreateRequestAsync(IAgentContext agentContext, ConnectionInvitationMessage invitation)
{
Logger.LogInformation(LoggingEvents.AcceptInvitation, "Key {0}, Endpoint {1}",
invitation.RecipientKeys[0], invitation.ServiceEndpoint);
var my = await Did.CreateAndStoreMyDidAsync(agentContext.Wallet, "{}");
var connection = new ConnectionRecord
{
Endpoint = new AgentEndpoint(invitation.ServiceEndpoint, null, invitation.RoutingKeys != null && invitation.RoutingKeys.Count != 0 ? invitation.RoutingKeys.ToArray() : null),
MyDid = my.Did,
MyVk = my.VerKey,
Id = Guid.NewGuid().ToString().ToLowerInvariant()
};
connection.SetTag("InvitationKey", invitation.RecipientKeys.First());
if (!string.IsNullOrEmpty(invitation.Label) || !string.IsNullOrEmpty(invitation.ImageUrl))
{
connection.Alias = new ConnectionAlias
{
Name = invitation.Label,
ImageUrl = invitation.ImageUrl
};
if (string.IsNullOrEmpty(invitation.Label))
{
connection.SetTag(TagConstants.Alias, invitation.Label);
}
}
await connection.TriggerAsync(ConnectionTrigger.InvitationAccept);
var provisioning = await ProvisioningService.GetProvisioningAsync(agentContext.Wallet);
var request = new ConnectionRequestMessage(agentContext.UseMessageTypesHttps)
{
Connection = new Connection
{
Did = connection.MyDid,
DidDoc = connection.MyDidDoc(provisioning)
},
Label = provisioning.Owner?.Name,
ImageUrl = provisioning.Owner?.ImageUrl
};
// also set image as attachment
if (provisioning.Owner?.ImageUrl != null)
{
request.AddAttachment(new Attachment
{
Nickname = "profile-image",
Data = new AttachmentContent {
Links = new[] { provisioning.Owner.ImageUrl }
}
});
}
await RecordService.AddAsync(agentContext.Wallet, connection);
return(request, connection);
}
