private void AddOrUpdateConnection(ConnectionRecord connectionRecord)
{
foreach (ConnectionViewModel connection in Connections)
{
if (connectionRecord.Id == connection.Id)
{
connection.ConnectionSubtitle = ConnectionStateTranslator.Translate(connectionRecord.State);
return;
}
}
var con = _scope.Resolve <ConnectionViewModel>(new NamedParameter("record", connectionRecord));
if (string.IsNullOrWhiteSpace(con.ConnectionName))
{
con.ConnectionName = "Agent Médiateur";
}
con.ConnectionSubtitle = ConnectionStateTranslator.Translate(connectionRecord.State);
DateTime datetime = DateTime.Now;
if (connectionRecord.CreatedAtUtc.HasValue)
{
datetime = connectionRecord.CreatedAtUtc.Value.ToLocalTime();
con.DateTime = datetime;
}
Connections.Insert(0, con);
}
private void UpdateConnection(ConnectionRecord connection)
{
txtServer.Text = connection.Server;
txtDatabase.Text = connection.Database;
txtUser.Text = connection.User;
txtPassword.Text = connection.Password;
}
public async Task CanUpdateRecordWithTags()
{
var tagName = Guid.NewGuid().ToString();
var tagValue = Guid.NewGuid().ToString();
var id = Guid.NewGuid().ToString();
var record = new ConnectionRecord {
ConnectionId = id
};
record.Tags.Add(tagName, tagValue);
await _recordService.AddAsync(_wallet, record);
var retrieved = await _recordService.GetAsync <ConnectionRecord>(_wallet, id);
retrieved.MyDid = "123";
retrieved.Tags[tagName] = "value";
await _recordService.UpdateAsync(_wallet, retrieved);
var updated = await _recordService.GetAsync <ConnectionRecord>(_wallet, id);
Assert.NotNull(updated);
Assert.Equal(updated.GetId(), record.GetId());
Assert.True(updated.Tags.ContainsKey(tagName));
Assert.Equal("value", updated.Tags[tagName]);
Assert.Equal("123", updated.MyDid);
}
public async Task CanStoreAndRetrieveRecordWithTagsUsingSearch()
{
var tagName = Guid.NewGuid().ToString();
var tagValue = Guid.NewGuid().ToString();
var record = new ConnectionRecord {
ConnectionId = Guid.NewGuid().ToString()
};
record.Tags.Add(tagName, tagValue);
await _recordService.AddAsync(_wallet, record);
var search =
await _recordService.SearchAsync <ConnectionRecord>(_wallet,
new SearchRecordQuery()
{
{ tagName, tagValue }
}, null, 100);
var retrieved = search.Single();
Assert.NotNull(retrieved);
Assert.Equal(retrieved.GetId(), record.GetId());
Assert.True(retrieved.Tags.ContainsKey(tagName));
Assert.Equal(tagValue, retrieved.Tags[tagName]);
}
public void InitialConnectionRecordIsInvitedAndHasTag()
{
var record = new ConnectionRecord();
Assert.True(record.State == ConnectionState.Invited);
Assert.True(record.Tags[TagConstants.State] == ConnectionState.Invited.ToString("G"));
}
/// <inheritdoc />
public virtual async Task <string> AcceptInvitationAsync(Wallet wallet, ConnectionInvitationMessage invitation)
{
Logger.LogInformation(LoggingEvents.AcceptInvitation, "Key {0}, Endpoint {1}",
invitation.ConnectionKey, invitation.Endpoint.Uri);
var my = await Did.CreateAndStoreMyDidAsync(wallet, "{}");
var connection = new ConnectionRecord
{
Endpoint = invitation.Endpoint,
MyDid = my.Did,
MyVk = my.VerKey,
ConnectionId = Guid.NewGuid().ToString().ToLowerInvariant()
};
connection.Tags.Add(TagConstants.MyDid, my.Did);
if (!string.IsNullOrEmpty(invitation.Name) || !string.IsNullOrEmpty(invitation.ImageUrl))
{
connection.Alias = new ConnectionAlias
{
Name = invitation.Name,
ImageUrl = invitation.ImageUrl
};
if (string.IsNullOrEmpty(invitation.Name))
{
connection.Tags.Add(TagConstants.Alias, invitation.Name);
}
}
await connection.TriggerAsync(ConnectionTrigger.InvitationAccept);
await RecordService.AddAsync(wallet, connection);
var provisioning = await ProvisioningService.GetProvisioningAsync(wallet);
var connectionDetails = new ConnectionDetails
{
Did = my.Did,
Verkey = my.VerKey,
Endpoint = provisioning.Endpoint
};
var request = await MessageSerializer.PackSealedAsync <ConnectionRequestMessage>(connectionDetails, wallet,
my.VerKey, invitation.ConnectionKey);
request.Key = invitation.ConnectionKey;
request.Type = MessageUtils.FormatKeyMessageType(invitation.ConnectionKey, MessageTypes.ConnectionRequest);
var forwardMessage = new ForwardToKeyEnvelopeMessage
{
Type = MessageUtils.FormatKeyMessageType(invitation.ConnectionKey, MessageTypes.ForwardToKey),
Content = request.ToJson()
};
await RouterService.ForwardAsync(forwardMessage, invitation.Endpoint);
return(connection.GetId());
}
/// <summary>
/// This constructor is used when proof request details are fetched from mediator
/// </summary>
public ProofRequestViewModel(IUserDialogs userDialogs,
INavigationService navigationService,
IAgentProvider agentContextProvider,
IProofService proofService,
ILifetimeScope scope,
ICredentialService credentialService,
IConnectionService connectionService,
IEventAggregator eventAggregator,
IMessageService messageService,
ProofRecord proofRecord,
ConnectionRecord connection) : base("Proof Request Detail", userDialogs, navigationService)
{
this.userDialogs = userDialogs;
this.navigationService = navigationService;
this.agentContextProvider = agentContextProvider;
this.proofService = proofService;
this.scope = scope;
this.credentialService = credentialService;
this.connectionService = connectionService;
this.eventAggregator = eventAggregator;
this.messageService = messageService;
this.proofRecord = proofRecord;
this.connection = connection;
ConnectionLogo = connection.Alias.ImageUrl;
ConnectionName = connection.Alias.Name;
ProofRequest = JsonConvert.DeserializeObject <ProofRequest>(proofRecord.RequestJson);
ProofRequestName = ProofRequest?.Name;
RequestedAttributes = new ObservableCollection <ProofRequestAttributeViewModel>();
HasLogo = !string.IsNullOrWhiteSpace(ConnectionLogo);
}
public ConnectionViewModel(IUserDialogs userDialogs,
INavigationService navigationService,
ICustomAgentContextProvider agentContextProvider,
IMessageService messageService,
IDiscoveryService discoveryService,
IConnectionService connectionService,
IEventAggregator eventAggregator,
ConnectionRecord record) :
base(nameof(ConnectionViewModel),
userDialogs,
navigationService)
{
_agentContextProvider = agentContextProvider;
_messageService = messageService;
_discoveryService = discoveryService;
_connectionService = connectionService;
_eventAggregator = eventAggregator;
_record = record;
MyDid = _record.MyDid;
TheirDid = _record.TheirDid;
ConnectionName = _record.Alias.Name;
ConnectionSubtitle = $"{_record.State:G}";
ConnectionImageUrl = _record.Alias.ImageUrl;
}
public ConnectionViewModel(IUserDialogs userDialogs,
INavigationService navigationService,
IAgentProvider agentProvider,
IMessageService messageService,
IDiscoveryService discoveryService,
IConnectionService connectionService,
IEventAggregator eventAggregator,
ConnectionRecord record) : base(nameof(ConnectionsViewModel), userDialogs, navigationService)
{
_agentProvider = agentProvider;
_messageService = messageService;
_discoveryService = discoveryService;
_connectionService = connectionService;
_eventAggregator = eventAggregator;
_record = record;
someMaterialColor = new Helpers.SomeMaterialColor();
MyDid = _record.MyDid;
TheirDid = _record.TheirDid;
ConnectionName = _record.Alias.Name;
ConnectionSubtitle = $"{_record.State:G}";
Title = "Connection Detail";
if (this._connectionImageUrl == null)
{
_connectionImageUrl = $"https://ui-avatars.com/api/?name={_connectionName}&length=1&background={_organizeColor}&color=fff&size=128";
}
else
{
_connectionImageUrl = _record.Alias.ImageUrl;
}
if (_record.CreatedAtUtc != null)
{
_createdDate = (DateTime)_record.CreatedAtUtc;
}
}
private async Task AddDeviceInfoAsync(IAgentContext agentContext, ConnectionRecord connection, AddDeviceInfoMessage addDeviceInfoMessage)
{
var inboxId = connection.GetTag("InboxId");
if (inboxId == null)
{
throw new InvalidOperationException("Inbox was not found. Create an inbox first");
}
var deviceRecord = new DeviceInfoRecord
{
InboxId = inboxId,
DeviceId = addDeviceInfoMessage.DeviceId,
DeviceVendor = addDeviceInfoMessage.DeviceVendor
};
try
{
await recordService.AddAsync(agentContext.Wallet, deviceRecord);
}
catch (WalletItemAlreadyExistsException)
{
}
catch (Exception e)
{
logger.LogError(e, "Unable to register device", addDeviceInfoMessage);
}
}
public async Task CanUpdateRecordWithTags()
{
var tagName = Guid.NewGuid().ToString();
var tagValue = Guid.NewGuid().ToString();
var id = Guid.NewGuid().ToString();
var record = new ConnectionRecord {
Id = id
};
record.SetTag(tagName, tagValue);
await recordService.AddAsync(Context.Wallet, record);
var retrieved = await recordService.GetAsync <ConnectionRecord>(Context.Wallet, id);
retrieved.MyDid = "123";
retrieved.SetTag(tagName, "value");
await recordService.UpdateAsync(Context.Wallet, retrieved);
var updated = await recordService.GetAsync <ConnectionRecord>(Context.Wallet, id);
Assert.NotNull(updated);
Assert.Equal(updated.Id, record.Id);
Assert.NotNull(updated.GetTag(tagName));
Assert.Equal("value", updated.GetTag(tagName));
Assert.Equal("123", updated.MyDid);
}
public async Task <OfferCredentialResponse> Handle
(
OfferCredentialRequest aOfferCredentialRequest,
CancellationToken aCancellationToken
)
{
IAgentContext agentContext = await AgentProvider.GetContextAsync();
ProvisioningRecord provisioningRecord = await ProvisioningService.GetProvisioningAsync(agentContext.Wallet);
ConnectionRecord connectionRecord = await ConnectionService.GetAsync(agentContext, aOfferCredentialRequest.ConnectionId);
(CredentialOfferMessage credentialOfferMessage, _) =
await CredentialService.CreateOfferAsync
(
agentContext,
new OfferConfiguration
{
CredentialDefinitionId = aOfferCredentialRequest.CredentialDefinitionId,
IssuerDid = provisioningRecord.IssuerDid,
CredentialAttributeValues = aOfferCredentialRequest.CredentialPreviewAttributes
}
);
await MessageService.SendAsync(agentContext.Wallet, credentialOfferMessage, connectionRecord);
var response = new OfferCredentialResponse(aOfferCredentialRequest.CorrelationId);
return(response);
}
public void InitialConnectionRecordIsInvitedAndHasTag()
{
var record = new ConnectionRecord();
Assert.True(record.State == ConnectionState.Invited);
Assert.True(record.GetTag(nameof(ConnectionRecord.State)) == ConnectionState.Invited.ToString("G"));
}
/// <summary>
/// Initializes a new instance of the <see cref="AriesFrameworkException"/> class.
/// </summary>
/// <param name="errorCode">The error code.</param>
/// <param name="message">The message.</param>
/// <param name="contextRecord"></param>
/// <param name="connectionRecord"></param>
public AriesFrameworkException(ErrorCode errorCode, string message, RecordBase contextRecord, ConnectionRecord connectionRecord) :
base(message)
{
ErrorCode = errorCode;
ContextRecord = contextRecord;
ConnectionRecord = connectionRecord;
}
public override async Task InitializeAsync(object navigationData)
{
_connectionRecord = navigationData as ConnectionRecord;
var context = await _agentContextProvider.GetContextAsync();
var credentialsRecords = await _credentialService.ListAsync(context);
List <SchemaRecord> schemasList = new List <SchemaRecord>();
List <DefinitionRecord> definitionsList = new List <DefinitionRecord>();
foreach (var credentialRecord in credentialsRecords)
{
if (credentialRecord.State == CredentialState.Rejected)
{
continue;
}
var schemaResp = await _ledgerService.LookupSchemaAsync(context, credentialRecord.SchemaId);
var schemaJobj = JObject.Parse(schemaResp?.ObjectJson ?? "");
schemasList.Add(new SchemaRecord {
Id = schemaResp.Id, Name = schemaJobj.GetValue("name").ToString()
});
var defResp = await _ledgerService.LookupDefinitionAsync(context, credentialRecord.CredentialDefinitionId);
definitionsList.Add(new DefinitionRecord {
Id = defResp.Id
});
}
Schemas.InsertRange(schemasList);
CredDefinitions.InsertRange(definitionsList);
//CredDefinitions = await _schemaService.ListCredentialDefinitionsAsync(context.Wallet);
await base.InitializeAsync(navigationData);
}
/// <summary>
/// Constructs my DID doc in a pairwise relationship from a connection record and the agents provisioning record.
/// </summary>
/// <param name="connection">Connection record.</param>
/// <param name="provisioningRecord">Provisioning record.</param>
/// <returns>DID Doc</returns>
public static DidDoc MyDidDoc(this ConnectionRecord connection, ProvisioningRecord provisioningRecord)
{
var doc = new DidDoc
{
Keys = new List <DidDocKey>
{
new DidDocKey
{
Id = $"{connection.MyDid}#keys-1",
Type = DefaultKeyType,
Controller = connection.MyDid,
PublicKeyBase58 = connection.MyVk
}
}
};
if (!string.IsNullOrEmpty(provisioningRecord.Endpoint.Uri))
{
doc.Services = new List <IDidDocServiceEndpoint>
{
new IndyAgentDidDocService
{
Id = $"{connection.MyDid};indy",
ServiceEndpoint = provisioningRecord.Endpoint.Uri,
RecipientKeys = connection.MyVk != null ? new[] { connection.MyVk } : new string[0],
RoutingKeys = provisioningRecord.Endpoint?.Verkey != null ? new[] { provisioningRecord.Endpoint.Verkey } : new string[0]
}
};
}
return(doc);
}
/// <inheritdoc />
public async Task <string> ProcessCredentialRequestAsync(IAgentContext agentContext, CredentialRequestMessage
credentialRequest, ConnectionRecord connection)
{
Logger.LogInformation(LoggingEvents.StoreCredentialRequest, "Type {0},", credentialRequest.Type);
// TODO Handle case when no thread is included
var credential = await this.GetByThreadIdAsync(agentContext, credentialRequest.GetThreadId());
var credentialAttachment = credentialRequest.Requests.FirstOrDefault(x => x.Id == "libindy-cred-request-0")
?? throw new ArgumentException("Credential request attachment not found.");
if (credential.State != CredentialState.Offered)
{
throw new AriesFrameworkException(ErrorCode.RecordInInvalidState,
$"Credential state was invalid. Expected '{CredentialState.Offered}', found '{credential.State}'");
}
credential.RequestJson = credentialAttachment.Data.Base64.GetBytesFromBase64().GetUTF8String();
credential.ConnectionId = connection?.Id;
await credential.TriggerAsync(CredentialTrigger.Request);
await RecordService.UpdateAsync(agentContext.Wallet, credential);
EventAggregator.Publish(new ServiceMessageProcessingEvent
{
RecordId = credential.Id,
MessageType = credentialRequest.Type,
ThreadId = credentialRequest.GetThreadId()
});
return(credential.Id);
}
public ConnectionViewModel Assemble(ConnectionRecord connectionRecord)
{
if (connectionRecord == null)
{
return(null);
}
ConnectionViewModel connection = _scope.Resolve <ConnectionViewModel>(new NamedParameter("record", connectionRecord));
if (string.IsNullOrWhiteSpace(connection.ConnectionName))
{
connection.ConnectionName = "Agent Médiateur";
}
connection.ConnectionSubtitle = ConnectionStateTranslator.Translate(connectionRecord.State);
DateTime datetime = DateTime.Now;
if (connectionRecord.CreatedAtUtc.HasValue)
{
datetime = connectionRecord.CreatedAtUtc.Value.ToLocalTime();
connection.DateTime = datetime;
}
return(connection);
}
/// <summary>
/// Look for the module of the user and create an instance of the database
/// </summary>
/// <param name="connectionId"></param>
/// <param name="userId"></param>
/// <returns></returns>
public static Common.Database.DatabaseManager CreateDatabase(string connectionId, int userId)
{
DatabaseContext dbContext = GetDatabase(Syncytium.Module.Administration.DatabaseContext.AREA_NAME);
// Get the current connection properties to retrieve the user's area
ConnectionRecord currentConnection = dbContext._Connection.FirstOrDefault(c => c.ConnectionId.Equals(connectionId) &&
c.Machine.Equals(Environment.MachineName) &&
c.UserId == userId);
if (currentConnection == null)
{
Common.Logger.LoggerManager.Instance.Error("DatabaseManager", $"The connection '{connectionId}' doesn't exist!");
throw new ExceptionDefinitionRecord("ERR_CONNECTION");
}
string area = currentConnection.Area;
if (area == null || area.Equals(DatabaseContext.AREA_NAME))
{
return(new Syncytium.Common.Database.DatabaseManager(dbContext, new UserManager(dbContext), connectionId, userId));
}
// look for the current database manager
dbContext.Dispose();
dbContext = null;
return(CreateDatabase(area, connectionId, userId));
}
public async Task CanSearchMulipleProperties()
{
var record1 = new ConnectionRecord {
State = ConnectionState.Connected, ConnectionId = "1"
};
var record2 = new ConnectionRecord
{
State = ConnectionState.Connected,
ConnectionId = "2",
Tags = { ["tagName"] = "tagValue" }
};
var record3 = new ConnectionRecord
{
State = ConnectionState.Invited,
ConnectionId = "3",
Tags = { ["tagName"] = "tagValue" }
};
await _recordService.AddAsync(_wallet, record1);
await _recordService.AddAsync(_wallet, record2);
await _recordService.AddAsync(_wallet, record3);
var searchResult = await _recordService.SearchAsync <ConnectionRecord>(_wallet,
new SearchRecordQuery
{
{ "State", ConnectionState.Connected.ToString("G") },
{ "tagName", "tagValue" }
}, null, 10);
Assert.Single(searchResult);
Assert.Equal("2", searchResult.Single().ConnectionId);
}
private async Task AcceptProofRequest()
{
if (_proofRecord.State != ProofState.Requested)
{
await DialogService.AlertAsync(string.Format(AppResources.ProofStateShouldBeMessage, ProofStateTranslator.Translate(ProofState.Requested)));
return;
}
RequestedCredentials requestedCredentials = new RequestedCredentials()
{
RequestedAttributes = new Dictionary <string, RequestedAttribute>(),
RequestedPredicates = new Dictionary <string, RequestedAttribute>()
};
foreach (ProofAttributeViewModel proofAttribute in Attributes)
{
if (proofAttribute.IsPredicate)
{
requestedCredentials.RequestedPredicates.Add(proofAttribute.Id, new RequestedAttribute {
CredentialId = proofAttribute.CredentialId, Revealed = proofAttribute.IsRevealed
});
}
else
{
requestedCredentials.RequestedAttributes.Add(proofAttribute.Id, new RequestedAttribute {
CredentialId = proofAttribute.CredentialId, Revealed = proofAttribute.IsRevealed
});
}
}
// TODO: Mettre le Timestamp à null car lorsqu'il est présent, la création de la preuve ne marche pas. Pourquoi?
//foreach (var keyValue in requestedCredentials.RequestedAttributes.Values)
//{
// keyValue.Timestamp = null;
//}
var context = await _agentContextProvider.GetContextAsync();
ProofRecord proofRecord = await _recordService.GetAsync <ProofRecord>(context.Wallet, _proofRecord.Id);
var(msg, rec) = await _proofService.CreatePresentationAsync(context, proofRecord.Id, requestedCredentials);
if (string.IsNullOrEmpty(proofRecord.ConnectionId))
{
await _messageService.SendAsync(context.Wallet, msg, proofRecord.GetTag("RecipientKey"), proofRecord.GetTag("ServiceEndpoint"));
}
else
{
ConnectionRecord connectionRecord = await _recordService.GetAsync <ConnectionRecord>(context.Wallet, proofRecord.ConnectionId);
await _messageService.SendAsync(context.Wallet, msg, connectionRecord);
}
_eventAggregator.Publish(new ApplicationEvent {
Type = ApplicationEventType.ProofRequestUpdated
});
await NavigationService.PopModalAsync();
}
public async Task SendToConnectionAsyncThrowsInvalidMessageNoType()
{
var connection = new ConnectionRecord
{
Alias = new ConnectionAlias
{
Name = "Test"
},
Endpoint = new AgentEndpoint
{
Uri = "https://mock.com"
},
TheirVk = Guid.NewGuid().ToString()
};
var agentContext = new AgentContext()
{
Wallet = _wallet
};
var ex = await Assert.ThrowsAsync <AriesFrameworkException>(async() =>
await _messagingService.SendAsync(agentContext, new MockAgentMessage {
Id = Guid.NewGuid().ToString()
}, connection));
Assert.True(ex.ErrorCode == ErrorCode.InvalidMessage);
}
public Task UpdateConnectionRecordAsync(ConnectionRecord record, CancellationToken cancellationToken = default)
=> UpdateItemAsync(
record,
pk: CONNECTION_PREFIX + record.ConnectionId,
sk: INFO,
cancellationToken
);
public async Task <CreateProofRequestResponse> Handle
(
CreateProofRequestRequest aCreateProofRequestRequest,
CancellationToken aCancellationToken
)
{
IAgentContext agentContext = await AgentProvider.GetContextAsync();
ConnectionRecord connectionRecord = await ConnectionService.GetAsync(agentContext, aCreateProofRequestRequest.ConnectionId);
aCreateProofRequestRequest.ProofRequest.Nonce = await AnonCreds.GenerateNonceAsync();
(RequestPresentationMessage requestPresentationMessage, ProofRecord proofRecord) =
await ProofService.CreateRequestAsync(agentContext, aCreateProofRequestRequest.ProofRequest, aCreateProofRequestRequest.ConnectionId);
await MessageService.SendAsync(agentContext, requestPresentationMessage, connectionRecord);
//(requestPresentationMessage, proofRecord) =
// await ProofService.CreateRequestAsync(agentContext, aSendRequestForProofRequest.ProofRequest);
//string endpointUri = (await ProvisioningService.GetProvisioningAsync(agentContext.Wallet)).Endpoint.Uri;
//string encodedRequestPresentationMessage = requestPresentationMessage.ToJson().ToBase64();
//string proofRequestUrl = $"{endpointUri}?c_i={encodedRequestPresentationMessage}";
var response = new CreateProofRequestResponse(requestPresentationMessage, aCreateProofRequestRequest.CorrelationId);
return(await Task.Run(() => response));
}
public async Task <bool> SetConnectionRecordStateAsync(ConnectionRecord record, ConnectionState state, CancellationToken cancellationToken = default)
{
try {
await DynamoDbClient.UpdateItemAsync(new UpdateItemRequest {
TableName = TableName,
Key = new Dictionary <string, AttributeValue> {
["PK"] = new AttributeValue(CONNECTION_PREFIX + record.ConnectionId),
["SK"] = new AttributeValue(INFO)
},
UpdateExpression = "SET #State = :state, #Modified = :modified",
ExpressionAttributeNames =
{
["#State"] = nameof(record.State),
["#Modified"] = "_Modified"
},
ExpressionAttributeValues =
{
[":state"] = new AttributeValue(state.ToString()),
[":modified"] = new AttributeValue {
N = DateTimeOffset.UtcNow.ToUnixTimeSeconds().ToString()
}
}
});
record.State = state;
return(true);
} catch (ConditionalCheckFailedException) {
return(false);
}
}
/// <summary>
/// Constructs their DID doc in a pairwise relationship from a connection record.
/// </summary>
/// <param name="connection">Connectio record.</param>
/// <returns>DID Doc</returns>
public static DidDoc TheirDidDoc(this ConnectionRecord connection)
{
return(new DidDoc
{
Keys = new List <DidDocKey>
{
new DidDocKey
{
Id = $"{connection.MyDid}#keys-1",
Type = DefaultKeyType,
Controller = connection.TheirDid,
PublicKeyBase58 = connection.TheirVk
}
},
Services = new List <IDidDocServiceEndpoint>
{
new IndyAgentDidDocService
{
Id = $"{connection.MyDid};indy",
ServiceEndpoint = connection.Endpoint.Verkey,
RecipientKeys = connection.TheirVk != null ? new[] { connection.TheirVk } : new string[0],
RoutingKeys = connection.Endpoint?.Verkey != null ? new[] { connection.Endpoint.Verkey } : new string[0]
}
}
});
}
public ConnectionViewModel(IUserDialogs userDialogs,
INavigationService navigationService,
IAgentProvider agentContextProvider,
IMessageService messageService,
IDiscoveryService discoveryService,
IConnectionService connectionService,
IEventAggregator eventAggregator,
IWalletRecordService walletRecordService,
ILifetimeScope scope,
ConnectionRecord record) :
base(nameof(ConnectionViewModel),
userDialogs,
navigationService)
{
_agentContextProvider = agentContextProvider;
_messageService = messageService;
_discoveryService = discoveryService;
_connectionService = connectionService;
_eventAggregator = eventAggregator;
_walletRecordSevice = walletRecordService;
_scope = scope;
_record = record;
MyDid = _record.MyDid;
TheirDid = _record.TheirDid;
ConnectionName = _record.Alias?.Name ?? _record.Id;
ConnectionSubtitle = $"{_record.State:G}";
ConnectionImageUrl = _record.Alias?.ImageUrl;
ConnectionImageSource = Base64StringToImageSource.Base64StringToImage(_record.Alias?.ImageUrl);
Messages = new ObservableCollection <RecordBase>();
}
/// <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[0] : null),
MyDid = my.Did,
MyVk = my.VerKey,
Id = Guid.NewGuid().ToString().ToLowerInvariant()
};
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
{
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",
Content = new AttachmentContent {
Links = new[] { provisioning.Owner.ImageUrl }
}
});
}
await RecordService.AddAsync(agentContext.Wallet, connection);
return(request,
connection);
}
public Task CreateConnectionAsync(ConnectionRecord record, CancellationToken cancellationToken = default)
=> PutItemsAsync(
record,
pk: CONNECTION_PREFIX + record.ConnectionId,
sk: INFO,
CreateItemConfig,
cancellationToken
);
/// <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 AgentFrameworkException(ErrorCode.RecordInInvalidState, "Provision record has no endpoint information specified");
}
await RecordService.AddAsync(agentContext.Wallet, connection);
return(new ConnectionInvitationMessage
{
ServiceEndpoint = provisioning.Endpoint.Uri,
RoutingKeys = provisioning.Endpoint.Verkey != null ? new[] { provisioning.Endpoint.Verkey } : null,
RecipientKeys = new[] { connectionKey },
Label = config.MyAlias.Name ?? provisioning.Owner.Name,
ImageUrl = config.MyAlias.ImageUrl ?? provisioning.Owner.ImageUrl
}, connection);
}
