/// <inheritdoc />
public async Task OnMessageAsync(IAgentContext agentContext, UnpackedMessageContext messageContext)
{
// TrustPingMessage event aggregator event doesn't include the connection so we can't verify whether the
// received trust ping comes from the connection we send the connection response to.
// For this reason we handle this specific case through a middleware where we do have the
// connection from which the trust ping message came
if (messageContext.GetMessageType() == MessageTypes.TrustPingMessageType)
{
var message = messageContext.GetMessage <TrustPingMessage>();
var THConnection = _cache.Get <TestHarnessConnection>(messageContext.Connection.Id);
if (THConnection != null && THConnection.State == TestHarnessConnectionState.Responded)
{
THConnection.State = TestHarnessConnectionState.Complete;
}
}
// When we receive a request presentation message we need to create a TestHarnessPresentationExchange and
// store it in the cache for future use. This allow us to keep track of the current state of the presentation exchange
else if (messageContext.GetMessageType() == MessageTypes.PresentProofNames.RequestPresentation)
{
var message = messageContext.GetMessage <RequestPresentationMessage>();
var proofRecord = await _proofService.GetByThreadIdAsync(agentContext, message.GetThreadId());
var THPresentationExchange = new TestHarnessPresentationExchange
{
ThreadId = message.GetThreadId(),
RecordId = proofRecord.Id,
State = TestHarnessPresentationExchangeState.RequestReceived,
};
_cache.Set(THPresentationExchange.ThreadId, THPresentationExchange);
}
}
/// <summary>
/// Processes the agent message
/// </summary>
/// <param name="agentContext">The agent context.</param>
/// <param name="messageContext">The agent message context.</param>
public async Task <AgentMessage> ProcessAsync(IAgentContext agentContext, UnpackedMessageContext messageContext)
{
await Task.Yield();
switch (messageContext.GetMessageType())
{
case CustomMessageTypes.TrustPingMessageType:
{
var pingMessage = messageContext.GetMessage <TrustPingMessage>();
if (pingMessage.ResponseRequested)
{
return(pingMessage.CreateThreadedReply <TrustPingResponseMessage>());
}
break;
}
case CustomMessageTypes.TrustPingResponseMessageType:
{
_eventAggregator.Publish(new ServiceMessageProcessingEvent
{
MessageType = CustomMessageTypes.TrustPingResponseMessageType
});
break;
}
}
return(null);
}
/// <summary>
/// Processes the agent message
/// </summary>
/// <param name="agentContext"></param>
/// <param name="messageContext">The agent message agentContext.</param>
/// <returns></returns>
/// <exception cref="AriesFrameworkException">Unsupported message type {messageType}</exception>
public async Task <AgentMessage> ProcessAsync(IAgentContext agentContext, UnpackedMessageContext messageContext)
{
switch (messageContext.GetMessageType())
{
// v1.0
case MessageTypes.PresentProofNames.RequestPresentation:
{
var message = messageContext.GetMessage <RequestPresentationMessage>();
var record = await _proofService.ProcessRequestAsync(agentContext, message, messageContext.Connection);
messageContext.ContextRecord = record;
break;
}
case MessageTypes.PresentProofNames.Presentation:
{
var message = messageContext.GetMessage <PresentationMessage>();
var record = await _proofService.ProcessPresentationAsync(agentContext, message);
messageContext.ContextRecord = record;
break;
}
default:
throw new AriesFrameworkException(ErrorCode.InvalidMessage,
$"Unsupported message type {messageContext.GetMessageType()}");
}
return(null);
}
/// <summary>
/// Processes the agent message
/// </summary>
/// <param name="agentContext"></param>
/// <param name="messageContext">The agent message.</param>
/// <returns></returns>
/// <exception cref="AriesFrameworkException">Unsupported message type {messageType}</exception>
public async Task <AgentMessage> ProcessAsync(IAgentContext agentContext, UnpackedMessageContext messageContext)
{
switch (messageContext.GetMessageType())
{
case CustomMessageTypes.AckPresentation:
case CustomMessageTypes.AckPresentationHttps:
{
var presentationAck = messageContext.GetMessage <AckPresentationMessage>();
var threadId = presentationAck.GetThreadId();
var THPresentationExchange = _proofCache.Get <TestHarnessPresentationExchange>(threadId);
if (presentationAck.Status == "OK" && THPresentationExchange.State == TestHarnessPresentationExchangeState.PresentationSent)
{
THPresentationExchange.State = TestHarnessPresentationExchangeState.Done;
}
break;
}
default:
throw new AriesFrameworkException(ErrorCode.InvalidMessage,
$"Unsupported message type {messageContext.GetMessageType()}");
}
return(null);
}
public static async Task <AgentMessage> ParseMessageAsync(string value)
{
string messageDecoded = null;
if (value.StartsWith("http", StringComparison.OrdinalIgnoreCase) ||
value.StartsWith("https", StringComparison.OrdinalIgnoreCase) ||
value.StartsWith("didcomm", StringComparison.OrdinalIgnoreCase) ||
value.StartsWith("id.streetcred", StringComparison.OrdinalIgnoreCase))
{
var url = new Uri(value);
var query = QueryHelpers.ParseQuery(url.Query);
if (query.TryGetValue("c_i", out var messageEncoded) ||
query.TryGetValue("d_m", out messageEncoded) ||
query.TryGetValue("m", out messageEncoded))
{
messageDecoded = Uri.UnescapeDataString(messageEncoded);
}
else
{
var client = new HttpClient(new HttpClientHandler {
AllowAutoRedirect = false
});
var response = await client.GetAsync(value);
var invitationUri = response.Headers.Location;
query = QueryHelpers.ParseNullableQuery(invitationUri.Query);
if (query.TryGetValue("c_i", out messageEncoded) ||
query.TryGetValue("d_m", out messageEncoded) ||
query.TryGetValue("m", out messageEncoded))
{
messageDecoded = Uri.UnescapeDataString(messageEncoded);
}
}
}
else
{
messageDecoded = Uri.UnescapeDataString(value);
}
// Because the decoder above strips the +
// https://github.com/aspnet/HttpAbstractions/blob/bc7092a32b1943c7f17439e419d3f66cd94ce9bd/src/Microsoft.AspNetCore.WebUtilities/QueryHelpers.cs#L165
messageDecoded = messageDecoded.Replace(' ', '+');
var json = messageDecoded.GetBytesFromBase64().GetUTF8String();
var unpackedMessage = new UnpackedMessageContext(json, senderVerkey: null);
switch (unpackedMessage.GetMessageType())
{
case MessageTypes.ConnectionInvitation:
return(unpackedMessage.GetMessage <ConnectionInvitationMessage>());
// case MessageTypes.EphemeralChallenge:
// return unpackedMessage.GetMessage<EphemeralChallengeMessage>();
case MessageTypes.PresentProofNames.RequestPresentation:
return(unpackedMessage.GetMessage <RequestPresentationMessage>());
}
return(null);
}
/// <summary>
/// Processes the agent message
/// </summary>
/// <param name="agentContext"></param>
/// <param name="messageContext">The agent message.</param>
/// <returns></returns>
/// <exception cref="AriesFrameworkException">Unsupported message type {messageType}</exception>
public async Task <AgentMessage> ProcessAsync(IAgentContext agentContext, UnpackedMessageContext messageContext)
{
switch (messageContext.GetMessageType())
{
// v1
case MessageTypes.IssueCredentialNames.OfferCredential:
{
var offer = messageContext.GetMessage <CredentialOfferMessage>();
var recordId = await _credentialService.ProcessOfferAsync(
agentContext, offer, messageContext.Connection);
messageContext.ContextRecord = await _credentialService.GetAsync(agentContext, recordId);
return(null);
}
case MessageTypes.IssueCredentialNames.RequestCredential:
{
var request = messageContext.GetMessage <CredentialRequestMessage>();
var recordId = await _credentialService.ProcessCredentialRequestAsync(
agentContext : agentContext,
credentialRequest : request,
connection : messageContext.Connection);
if (request.ReturnRoutingRequested() && messageContext.Connection == null)
{
var(message, record) = await _credentialService.CreateCredentialAsync(agentContext, recordId);
messageContext.ContextRecord = record;
return(message);
}
else
{
messageContext.ContextRecord = await _credentialService.GetAsync(agentContext, recordId);
return(null);
}
}
case MessageTypes.IssueCredentialNames.IssueCredential:
{
var credential = messageContext.GetMessage <CredentialIssueMessage>();
var recordId = await _credentialService.ProcessCredentialAsync(
agentContext, credential, messageContext.Connection);
messageContext.ContextRecord = await UpdateValuesAsync(
credentialId : recordId,
credentialIssue : messageContext.GetMessage <CredentialIssueMessage>(),
agentContext : agentContext);
return(null);
}
default:
throw new AriesFrameworkException(ErrorCode.InvalidMessage,
$"Unsupported message type {messageContext.GetMessageType()}");
}
}
public static async Task <AgentMessage> ParseMessageAsync(string value)
{
string messageDecoded = null;
UnpackedMessageContext unpackedMessage = null;
try
{
if (value.StartsWith("http", StringComparison.OrdinalIgnoreCase) ||
value.StartsWith("https", StringComparison.OrdinalIgnoreCase) ||
value.StartsWith("didcomm", StringComparison.OrdinalIgnoreCase))
{
var url = new Uri(value);
var query = QueryHelpers.ParseQuery(url.Query);
if (query.TryGetValue("c_i", out var messageEncoded) ||
query.TryGetValue("d_m", out messageEncoded) ||
query.TryGetValue("m", out messageEncoded))
{
messageDecoded = Uri.UnescapeDataString(messageEncoded);
}
else
{
var client = new HttpClient(new HttpClientHandler {
AllowAutoRedirect = false
});
var response = await client.GetAsync(value);
var invitationUri = response.Headers.Location;
query = QueryHelpers.ParseNullableQuery(invitationUri.Query);
if (query.TryGetValue("c_i", out messageEncoded) ||
query.TryGetValue("d_m", out messageEncoded) ||
query.TryGetValue("m", out messageEncoded))
{
messageDecoded = Uri.UnescapeDataString(messageEncoded);
}
}
// Because the decoder above strips the +
// https://github.com/aspnet/HttpAbstractions/blob/bc7092a32b1943c7f17439e419d3f66cd94ce9bd/src/Microsoft.AspNetCore.WebUtilities/QueryHelpers.cs#L165
messageDecoded = messageDecoded.Replace(' ', '+');
var json = messageDecoded.GetBytesFromBase64().GetUTF8String();
unpackedMessage = new UnpackedMessageContext(json, senderVerkey: null);
}
else
{
messageDecoded = Uri.UnescapeDataString(value);
var json2 = messageDecoded.GetBytesFromBase64().GetUTF8String();
unpackedMessage = new UnpackedMessageContext(json2, senderVerkey: null);
}
return(GetInternalMessage(unpackedMessage));
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
return(null);
}
}
/// <summary>
/// Processes the agent message
/// </summary>
/// <param name="agentContext"></param>
/// <param name="messageContext">The agent message agentContext.</param>
/// <returns></returns>
/// <exception cref="AriesFrameworkException">Unsupported message type {message.Type}</exception>
public async Task <AgentMessage> ProcessAsync(IAgentContext agentContext, UnpackedMessageContext messageContext)
{
switch (messageContext.GetMessageType())
{
case MessageTypesHttps.ConnectionAcknowledgement:
case MessageTypes.ConnectionAcknowledgement:
{
var acknowledgementMessage = messageContext.GetMessage <ConnectionAcknowledgeMessage>();
await _connectionService.ProcessAcknowledgementMessageAsync(agentContext, acknowledgementMessage);
return(null);
}
case MessageTypesHttps.ConnectionInvitation:
case MessageTypes.ConnectionInvitation:
{
var invitation = messageContext.GetMessage <ConnectionInvitationMessage>();
await _connectionService.ProcessInvitationAsync(agentContext, invitation);
return(null);
}
case MessageTypesHttps.ConnectionRequest:
case MessageTypes.ConnectionRequest:
{
var request = messageContext.GetMessage <ConnectionRequestMessage>();
var connectionId = await _connectionService.ProcessRequestAsync(agentContext, request, messageContext.Connection);
messageContext.ContextRecord = messageContext.Connection;
// Auto accept connection if set during invitation
if (messageContext.Connection.GetTag(TagConstants.AutoAcceptConnection) == "true")
{
var(message, record) = await _connectionService.CreateResponseAsync(agentContext, connectionId);
messageContext.ContextRecord = record;
return(message);
}
return(null);
}
case MessageTypesHttps.ConnectionResponse:
case MessageTypes.ConnectionResponse:
{
var response = messageContext.GetMessage <ConnectionResponseMessage>();
await _connectionService.ProcessResponseAsync(agentContext, response, messageContext.Connection);
messageContext.ContextRecord = messageContext.Connection;
return(null);
}
default:
throw new AriesFrameworkException(ErrorCode.InvalidMessage,
$"Unsupported message type {messageContext.GetMessageType()}");
}
}
/// <summary>
/// Finds the decorator with the specified name or returns <code>null</code>.
/// </summary>
/// <typeparam name="T">Type to cast the decorator to.</typeparam>
/// <param name="messageContext">Message Context.</param>
/// <param name="name">The name.</param>
/// <returns>The requested decorator or null</returns>
public static T FindDecorator <T>(this UnpackedMessageContext messageContext, string name) where T : class
{
if (messageContext.Packed)
{
throw new AriesFrameworkException(ErrorCode.InvalidMessage, "Cannot fetch decorator from packed message.");
}
var jObject = JsonConvert.DeserializeObject <JObject>(messageContext.GetMessageJson());
var decorator = jObject.Properties().FirstOrDefault(_ => _.Name == $"~{name}");
return(decorator?.Value.ToObject <T>());
}
/// <inheritdoc />
public async Task OnMessageAsync(IAgentContext agentContext, UnpackedMessageContext messageContext)
{
var message = messageContext.GetMessage <AnyAgentMessage>();
var requestDecorator = message.FindDecorator <PaymentRequestDecorator>("payment_request");
if (requestDecorator != null)
{
var record = new PaymentRecord
{
ConnectionId = messageContext.Connection.Id,
Details = requestDecorator.Details,
ReferenceId = requestDecorator.Details.Id,
Address = requestDecorator.Method.Data.PayeeId,
Amount = requestDecorator.Details.Total.Amount.Value
};
await record.TriggerAsync(PaymentTrigger.RequestReceived);
await _recordService.AddAsync(agentContext.Wallet, record);
if (messageContext.ContextRecord != null)
{
messageContext.ContextRecord.SetTag("PaymentRecordId", record.Id);
await _recordService.UpdateAsync(agentContext.Wallet, messageContext.ContextRecord);
}
}
var receiptDecorator = message.FindDecorator <PaymentReceiptDecorator>("payment_receipt");
if (receiptDecorator != null)
{
var search = await _recordService.SearchAsync <PaymentRecord>(
wallet : agentContext.Wallet,
query : SearchQuery.Equal(nameof(PaymentRecord.ReferenceId), receiptDecorator.RequestId),
options : null,
count : 5);
var record = search.FirstOrDefault() ?? new PaymentRecord();
record.ReceiptId = receiptDecorator.TransactionId;
await record.TriggerAsync(PaymentTrigger.ReceiptReceived);
if (search.Any())
{
await _recordService.UpdateAsync(agentContext.Wallet, record);
}
else
{
await _recordService.AddAsync(agentContext.Wallet, record);
}
}
}
public async Task <AgentMessage> ProcessAsync(IAgentContext agentContext, UnpackedMessageContext messageContext)
{
var msgJson = messageContext.GetMessageJson();
switch (messageContext.GetMessageType())
{
case BackupTypeNames.RetrieveBackupAgentMessage:
{
var message = messageContext.GetMessage <RetrieveBackupAgentMessage>();
var signature = message.Signature.GetBytesFromBase64();
var backupId = Multibase.Base58.Decode(message.BackupId);
var result = await Crypto.VerifyAsync(
message.BackupId,
backupId,
signature);
if (!result)
{
throw new ArgumentException($"{nameof(result)} signature does not match the signer");
}
var backupAttachments = await _storageService.RetrieveBackupAsync(message.BackupId);
return(new RetrieveBackupResponseAgentMessage
{
Payload = backupAttachments
});
}
case BackupTypeNames.ListBackupsAgentMessage:
{
var message = messageContext.GetMessage <ListBackupsAgentMessage>();
var backupList = await _storageService.ListBackupsAsync(message.BackupId);
var timestampList = backupList.Select(p => new DirectoryInfo(p).Name);
return(new ListBackupsResponseAgentMessage
{
BackupList = timestampList
.Select(x => long.Parse(x))
.OrderByDescending(x => x)
.ToList()
});
}
}
return(null);
}
public async Task CreateInboxRecordAsync()
{
UnpackedMessageContext unpackedMessage = new UnpackedMessageContext(
new CreateInboxMessage(),
new ConnectionRecord()
{
State = ConnectionState.Connected,
});
CreateInboxResponseMessage agentMessage = (CreateInboxResponseMessage)await routingInboxHandler.ProcessAsync(agentContext.Object, unpackedMessage);
walletService.Verify(w => w.CreateWalletAsync(It.Is <WalletConfiguration>(wc => wc.Id == agentMessage.InboxId), It.Is <WalletCredentials>(wc => wc.Key == agentMessage.InboxKey)));
recordService.Verify(m => m.AddAsync(agentContext.Object.Wallet, It.Is <InboxRecord>(i => i.Tags.Count == 0)), Times.Once());
recordService.Verify(m => m.UpdateAsync(agentContext.Object.Wallet, It.Is <ConnectionRecord>(c => c.GetTag("InboxId") == agentMessage.InboxId)));
}
public async Task <AgentMessage> ProcessAsync(IAgentContext agentContext, UnpackedMessageContext messageContext)
{
switch (messageContext.GetMessageType())
{
case MessageTypesHttps.DidExchange.Request:
var request = messageContext.GetMessage <DidExchangeRequestMessage>();
try
{
await _didExchangeService.ProcessRequestAsync(agentContext, request);
}
catch (Exception)
{
return(CreateProblemReportMessage(request));
}
return(null);
case MessageTypesHttps.DidExchange.Response:
var response = messageContext.GetMessage <DidExchangeResponseMessage>();
try
{
await _didExchangeService.ProcessResponseAsync(agentContext, response, messageContext.Connection);
}
catch (Exception)
{
return(CreateProblemReportMessage(response));
}
return(null);
case MessageTypesHttps.DidExchange.Complete:
var complete = messageContext.GetMessage <DidExchangeCompleteMessage>();
await _didExchangeService.ProcessComplete(agentContext, complete, messageContext.Connection);
return(null);
case MessageTypesHttps.DidExchange.ProblemReport:
var problemReport = messageContext.GetMessage <DidExchangeProblemReportMessage>();
await _didExchangeService.ProcessProblemReportMessage(agentContext, problemReport, messageContext.Connection);
return(null);
default:
throw new AriesFrameworkException(ErrorCode.InvalidMessage,
$"Unsupported message type {messageContext.GetMessageType()}");
}
}
/// <summary>
/// Adds return routing to message
/// </summary>
/// <param name="message">The message to add return routing</param>
public static bool ReturnRoutingRequested(this UnpackedMessageContext message)
{
try
{
var transportDecorator = message.FindDecorator <TransportDecorator>(DecoratorNames.TransportDecorator);
if (transportDecorator != null)
{
return(true);
}
return(false);
}
catch (Exception)
{
return(false);
}
}
public static async Task <AgentMessage> ProcessPackedMessage(Wallet wallet, InboxItemMessage message,
string senderKey)
{
try
{
var bytes = message.Data.GetUTF8Bytes();
var unpacked = await CryptoUtils.UnpackAsync(wallet, bytes);
var result = new UnpackedMessageContext(unpacked.Message, senderKey);
return(GetInternalMessage(result));
}
catch (Exception ex)
{
// throw new AriesFrameworkException(ErrorCode.InvalidMessage, "Failed to un-pack message", e);
Console.WriteLine(ex);
return(null);
}
}
public async Task OnMessageAsync(IAgentContext agentContext, UnpackedMessageContext messageContext)
{
await _credentialService.ListAsync(agentContext);
var messageType = messageContext.GetMessageType();
//var content = GetMessageContent(messageType);
var content = HandleMessageTypeEventAndNotification(messageType);
var notification = new NotificationRequest
{
NotificationId = 100,
Title = "Notification",
Description = content,
ReturningData = "Notification", // Returning data when tapped on notification.
};
NotificationCenter.Current.Show(notification);
Console.WriteLine($"thinhnnd - Message Type: {messageContext.GetMessageType()}");
}
/// <inheritdoc />
public async Task OnMessageAsync(IAgentContext agentContext, UnpackedMessageContext messageContext)
{
// TrustPingMessage event aggregator event doesn't include the connection so we can't verify whether the
// received trust ping comes from the connection we send the connection response to.
// For this reason we handle this specific case through a middleware where we do have the
// connection from which the trust ping message came
// TODO: should we also move the other events to here, or should we keep it as is for the rest?
if (messageContext.GetMessageType() == MessageTypes.TrustPingMessageType)
{
var message = messageContext.GetMessage <TrustPingMessage>();
var THConnection = _cache.Get <TestHarnessConnection>(messageContext.Connection.Id);
if (THConnection != null && THConnection.State == TestHarnessConnectionState.Responded)
{
THConnection.State = TestHarnessConnectionState.Complete;
}
}
}
public async Task OnMessageAsync(IAgentContext agentContext, UnpackedMessageContext messageContext)
{
if (messageContext.GetMessageType() == new ForwardMessage().Type)
{
ForwardMessage forwardMessage = messageContext.GetMessage <ForwardMessage>();
//if (forwardMessage.To == Environment.GetEnvironmentVariable("ACA_ROUTE"))
if (forwardMessage.To == this.acaList.FirstOrDefault(kvp => kvp.Key == forwardMessage.To).Key)
{
//var uri = new Uri(Environment.GetEnvironmentVariable("ACA_ENDPOINT"));
var uri = new Uri(this.acaList.First(kvp => kvp.Key == forwardMessage.To).Value);
var dispatcher = GetDispatcher(uri.Scheme);
//byte[] wireMsg = Encoding.UTF8.GetBytes(forwardMessage.ToString());
await dispatcher.DispatchAsync(uri, new PackedMessageContext(forwardMessage.Message));
}
}
}
/// <summary>
/// Processes the agent message
/// </summary>
/// <param name="agentContext"></param>
/// <param name="messageContext">The agent message agentContext.</param>
/// <returns></returns>
/// <exception cref="AriesFrameworkException">Unsupported message type {message.Type}</exception>
public async Task <AgentMessage> ProcessAsync(IAgentContext agentContext, UnpackedMessageContext messageContext)
{
switch (messageContext.GetMessageType())
{
case CustomMessageTypes.TransactionResponse:
case CustomMessageTypes.TransactionResponseHttps:
{
var transaction = messageContext.GetMessage <TransactionResponseMessage>();
await _transactionService.ProcessTransactionAsync(agentContext, transaction, messageContext.Connection);
messageContext.ContextRecord = messageContext.Connection;
return(null);
}
default:
throw new AriesFrameworkException(ErrorCode.InvalidMessage,
$"Unsupported message type {messageContext.GetMessageType()}");
}
}
public static AgentMessage GetInternalMessage(UnpackedMessageContext source)
{
switch (source.GetMessageType())
{
//MessageTypes.ConnectionInvitation
case MessageTypes.ConnectionInvitation:
return(source.GetMessage <ConnectionInvitationMessage>());
//MessageTypes.PresentProofNames
case MessageTypes.PresentProofNames.RequestPresentation:
return(source.GetMessage <RequestPresentationMessage>());
//MessageTypes.IssueCredentialNames
case MessageTypes.IssueCredentialNames.OfferCredential:
return(source.GetMessage <CredentialOfferMessage>());
default:
return(null);
}
}
public async Task CreateInboxRecordWithStorageConfigurationAndCredentialsAsync()
{
string keyDerivationMethod = "RAW";
object storageCredentials = new {};
WalletConfiguration.WalletStorageConfiguration storageConfiguration = new WalletConfiguration.WalletStorageConfiguration();
string storageType = "postgres_storage";
IOptions <AgentOptions> options = Options.Create <AgentOptions>(new AgentOptions()
{
WalletConfiguration = new WalletConfiguration()
{
StorageType = storageType,
StorageConfiguration = storageConfiguration
},
WalletCredentials = new WalletCredentials()
{
KeyDerivationMethod = keyDerivationMethod,
StorageCredentials = storageCredentials
}
});
UnpackedMessageContext unpackedMessage = new UnpackedMessageContext(
new CreateInboxMessage(),
new ConnectionRecord()
{
State = ConnectionState.Connected,
});
routingInboxHandler = new RoutingInboxHandler(recordService.Object, walletService.Object, routingStore.Object, options, logger.Object);
CreateInboxResponseMessage agentMessage = (CreateInboxResponseMessage)await routingInboxHandler.ProcessAsync(agentContext.Object, unpackedMessage);
walletService.Verify(w => w.CreateWalletAsync(It.Is <WalletConfiguration>(wc =>
wc.Id == agentMessage.InboxId &&
wc.StorageConfiguration == storageConfiguration &&
wc.StorageType == storageType
), It.Is <WalletCredentials>(wc =>
wc.Key == agentMessage.InboxKey &&
wc.KeyDerivationMethod == keyDerivationMethod &&
wc.StorageCredentials == storageCredentials
)));
}
public async Task <AgentMessage> ProcessAsync(IAgentContext agentContext, UnpackedMessageContext messageContext)
{
if (messageContext.Connection == null ||
messageContext.Connection.MultiPartyInvitation ||
messageContext.Connection.State != ConnectionState.Connected)
{
throw new InvalidOperationException("Connection is missing or invalid");
}
switch (messageContext.GetMessageType())
{
case RoutingTypeNames.CreateInboxMessage:
return(await CreateInboxAsync(agentContext, messageContext.Connection, messageContext.GetMessage <CreateInboxMessage>()));
case RoutingTypeNames.AddRouteMessage:
await AddRouteAsync(agentContext, messageContext.Connection, messageContext.GetMessage <AddRouteMessage>());
break;
case RoutingTypeNames.GetInboxItemsMessage:
return(await GetInboxItemsAsync(agentContext, messageContext.Connection, messageContext.GetMessage <GetInboxItemsMessage>()));
case RoutingTypeNames.DeleteInboxItemsMessage:
await DeleteInboxItemsAsync(agentContext, messageContext.Connection, messageContext.GetMessage <DeleteInboxItemsMessage>());
break;
case RoutingTypeNames.AddDeviceInfoMessage:
await AddDeviceInfoAsync(agentContext, messageContext.Connection, messageContext.GetMessage <AddDeviceInfoMessage>());
break;
default:
break;
}
return(null);
}
public async Task CreateInboxRecordWithMetadataAsync()
{
string key = "key", value = "value";
Dictionary <string, string> metadata = new Dictionary <string, string>()
{
{ key, value }
};
UnpackedMessageContext unpackedMessage = new UnpackedMessageContext(
new CreateInboxMessage()
{
Metadata = metadata
},
new ConnectionRecord()
{
State = ConnectionState.Connected,
});
CreateInboxResponseMessage agentMessage = (CreateInboxResponseMessage)await routingInboxHandler.ProcessAsync(agentContext.Object, unpackedMessage);
walletService.Verify(w => w.CreateWalletAsync(It.Is <WalletConfiguration>(wc => wc.Id == agentMessage.InboxId), It.Is <WalletCredentials>(wc => wc.Key == agentMessage.InboxKey)));
recordService.Verify(m => m.AddAsync(agentContext.Object.Wallet, It.Is <InboxRecord>(i => i.GetTag(key) == value)), Times.Once());
recordService.Verify(m => m.UpdateAsync(agentContext.Object.Wallet, It.Is <ConnectionRecord>(c => c.GetTag("InboxId") == agentMessage.InboxId)));
}
/// <inheritdoc />
protected override async Task <AgentMessage> ProcessAsync(ForwardMessage message, IAgentContext agentContext, UnpackedMessageContext messageContext)
{
var inboxId = await routingStore.FindRouteAsync(message.To);
var inboxRecord = await recordService.GetAsync <InboxRecord>(agentContext.Wallet, inboxId);
var edgeWallet = await walletService.GetWalletAsync(inboxRecord.WalletConfiguration, inboxRecord.WalletCredentials);
var inboxItemRecord = new InboxItemRecord {
ItemData = message.Message
};
await recordService.AddAsync(edgeWallet, inboxItemRecord);
eventAggregator.Publish(new InboxItemEvent
{
InboxId = inboxId,
ItemId = inboxRecord.Id
});
return(null);
}
/*
*
* [Issuer: Creates offer for Holder.]
* [Issuer: Sends offer for Holder.]
*
* Holder: Receives credential offer.
* Holder: Process the credential offer by storing it.
*
* (Holder: Creates master secret if not already.)
*
* Holder: Sends a credential request using the stored offer id.
*
* [Issuer: Retrieved credential request]
* [Issuer: Receives the credential request and sends a credential issue message]
*
* Holder: Receives the credential issue message.
* Holder: Process the message and store its.
*/
public async Task <AgentMessage> ProcessAsync(IAgentContext agentContext, UnpackedMessageContext messageContext)
{
switch (messageContext.GetMessageType())
{
// v1
case MessageTypesHttps.IssueCredentialNames.OfferCredential:
case MessageTypes.IssueCredentialNames.OfferCredential:
{
try
{
var navigation = App.Container.Resolve <INavigationService>();
var _credentialService = App.Container.Resolve <ICredentialService>();
var offer = messageContext.GetMessage <CredentialOfferMessage>();
Console.WriteLine("New Credential Offering: {0}", offer.Id);
var recordId = await _credentialService.ProcessOfferAsync(
agentContext, offer, messageContext.Connection);
messageContext.ContextRecord = await _credentialService.GetAsync(agentContext, recordId);
var transport = new CredentialOfferTransport()
{
Record = messageContext.ContextRecord as CredentialRecord,
Message = offer,
MessageContext = messageContext
};
await navigation.NavigateToAsync <CredentialOfferPageViewModel>(transport, NavigationType.Modal);
}
catch (Exception ex)
{
Tracking.TrackException(ex);
}
return(null);
}
case MessageTypesHttps.IssueCredentialNames.RequestCredential:
case MessageTypes.IssueCredentialNames.RequestCredential:
{
var request = messageContext.GetMessage <CredentialRequestMessage>();
var recordId = await _credentialService.ProcessCredentialRequestAsync(
agentContext : agentContext,
credentialRequest : request,
connection : messageContext.Connection);
if (request.ReturnRoutingRequested() && messageContext.Connection == null)
{
var(message, record) = await _credentialService.CreateCredentialAsync(agentContext, recordId);
messageContext.ContextRecord = record;
return(message);
}
else
{
// Auto create credential if set in the agent option
if (_agentOptions != null && _agentOptions.AutoRespondCredentialRequest)
{
var(message, record) =
await _credentialService.CreateCredentialAsync(agentContext, recordId);
messageContext.ContextRecord = record;
return(message);
}
messageContext.ContextRecord = await _credentialService.GetAsync(agentContext, recordId);
return(null);
}
}
case MessageTypesHttps.IssueCredentialNames.IssueCredential:
case MessageTypes.IssueCredentialNames.IssueCredential:
{
try
{
var navigation = App.Container.Resolve <INavigationService>();
var _credentialService = App.Container.Resolve <ICredentialService>();
var credential = messageContext.GetMessage <CredentialIssueMessage>();
var recordId = await _credentialService.ProcessCredentialAsync(
agentContext, credential, messageContext.Connection);
messageContext.ContextRecord = await UpdateValuesAsync(
credentialId : recordId,
credentialIssue : messageContext.GetMessage <CredentialIssueMessage>(),
agentContext : agentContext);
}
catch (Exception ex)
{
Crashes.TrackError(ex);
SentrySdk.CaptureException(ex);
Console.WriteLine(ex.Message);
}
return(null);
}
default:
throw new AriesFrameworkException(ErrorCode.InvalidMessage,
$"Unsupported message type {messageContext.GetMessageType()}");
}
}
/// <summary>
/// Processes the incoming <see cref="AgentMessage" />
/// </summary>
/// <param name="message">The message.</param>
/// <param name="agentContext">The message agentContext.</param>
/// <param name="messageContext">The message context.</param>
/// <returns></returns>
protected override async Task <AgentMessage> ProcessAsync(BasicMessage message, IAgentContext agentContext, UnpackedMessageContext messageContext)
{
var record = new BasicMessageRecord
{
Id = Guid.NewGuid().ToString(),
ConnectionId = messageContext.Connection.Id,
Text = message.Content,
SentTime = DateTime.TryParse(message.SentTime, out var dateTime) ? dateTime : DateTime.UtcNow,
Direction = MessageDirection.Incoming
};
await _recordService.AddAsync(agentContext.Wallet, record);
messageContext.ContextRecord = record;
return(null);
}
}
protected override async Task <AgentMessage> ProcessAsync(ForwardMessage message, IAgentContext agentContext, UnpackedMessageContext messageContext)
{
var connectionRecord = await _connectionService.ResolveByMyKeyAsync(agentContext, message.To);
if (agentContext is AgentContext context)
{
context.AddNext(new PackedMessageContext(message.Message, connectionRecord));
}
return(null);
}
public async Task <AgentMessage> ProcessAsync(IAgentContext agentContext, UnpackedMessageContext messageContext)
{
switch (messageContext.GetMessageType())
{
case MessageTypesHttps.ConnectionInvitation:
case MessageTypes.ConnectionInvitation:
{
var invitation = messageContext.GetMessage <ConnectionInvitationMessage>();
await _connectionService.CreateRequestAsync(agentContext, invitation);
return(null);
}
case MessageTypesHttps.ConnectionRequest:
case MessageTypes.ConnectionRequest:
{
var request = messageContext.GetMessage <ConnectionRequestMessage>();
var connectionId = await _connectionService.ProcessRequestAsync(agentContext, request, messageContext.Connection);
messageContext.ContextRecord = messageContext.Connection;
// Auto accept connection if set during invitation
if (messageContext.Connection.GetTag(TagConstants.AutoAcceptConnection) == "true")
{
var(message, record) = await _connectionService.CreateResponseAsync(agentContext, connectionId);
messageContext.ContextRecord = record;
return(message);
}
else
{
//var (message, record) = await _connectionService.CreateResponseAsync(agentContext, connectionId);
//messageContext.ContextRecord = record;
List <object> data = new List <object>();
data.Add(request);
data.Add(connectionId);
//data.Add(record);
//new WalletEventService().ShowAcceptRequestDialog(data);
Device.BeginInvokeOnMainThread(async() => await _navigationService.NavigateToAsync <AcceptRequestViewModel>(data, NavigationType.Modal));
return(null);
}
//return null;
}
case MessageTypesHttps.ConnectionResponse:
case MessageTypes.ConnectionResponse:
{
var response = messageContext.GetMessage <ConnectionResponseMessage>();
await _connectionService.ProcessResponseAsync(agentContext, response, messageContext.Connection);
messageContext.ContextRecord = messageContext.Connection;
var attachment = response.GetAttachment("agent-profile-pic");
messageContext.Connection.Alias.ImageUrl = attachment.Data.Base64;
var context = await _agentContextProvider.GetContextAsync();
await _walletRecordService.UpdateAsync(context.Wallet, messageContext.Connection);
return(null);
}
default:
throw new AriesFrameworkException(ErrorCode.InvalidMessage,
$"Unsupported message type {messageContext.GetMessageType()}");
}
}
/// <summary>
/// Processes the agent message
/// </summary>
/// <param name="agentContext"></param>
/// <param name="messageContext">The agent message.</param>
/// <returns></returns>
/// <exception cref="AriesFrameworkException">Unsupported message type {messageType}</exception>
public async Task <AgentMessage> ProcessAsync(IAgentContext agentContext, UnpackedMessageContext messageContext)
{
switch (messageContext.GetMessageType())
{
case MessageTypes.IssueCredentialNames.ProposeCredential:
case MessageTypesHttps.IssueCredentialNames.ProposeCredential:
{
var credentialProposal = messageContext.GetMessage <CustomCredentialProposeMessage>();
CredentialRecord credentialRecord;
TestHarnessCredentialExchange THCredentialExchange;
try
{
// Credential can be proposed for an existing exchange
// so we must first check if the message contains
THCredentialExchange = _credentialCache.Get <TestHarnessCredentialExchange>(credentialProposal.GetThreadId());
credentialRecord = await _credentialService.GetByThreadIdAsync(agentContext, THCredentialExchange.ThreadId);
// check if the proposal came from the same connection
if (messageContext.Connection?.Id != credentialRecord.ConnectionId)
{
throw new AriesFrameworkException(ErrorCode.RecordInInvalidState, "Connection from credential proposal is not same as previously stored record.");
}
}
catch
{
// Create new CredentialRecord if no existing credential record exists
credentialRecord = new CredentialRecord
{
Id = Guid.NewGuid().ToString(),
ConnectionId = messageContext.Connection?.Id,
};
credentialRecord.SetTag(TagConstants.Role, TagConstants.Issuer);
credentialRecord.SetTag(TagConstants.LastThreadId, credentialProposal.GetThreadId());
await _recordService.AddAsync(agentContext.Wallet, credentialRecord);
THCredentialExchange = new TestHarnessCredentialExchange
{
RecordId = credentialRecord.Id,
ThreadId = credentialProposal.GetThreadId(),
State = TestHarnessCredentialExchangeState.ProposalReceived,
};
_credentialCache.Set(THCredentialExchange.ThreadId, THCredentialExchange);
}
// Updates that should be applied both when the credential record already exists or not
credentialRecord.CredentialDefinitionId = credentialProposal.CredentialDefinitionId;
credentialRecord.SchemaId = credentialProposal.SchemaId;
credentialRecord.CredentialAttributesValues = credentialProposal.CredentialProposal?.Attributes
.Select(x => new CredentialPreviewAttribute
{
Name = x.Name,
MimeType = x.MimeType,
Value = x.Value
}).ToArray();
// State should be proposal-received
credentialRecord.State = CredentialState.Offered;
await _recordService.UpdateAsync(agentContext.Wallet, credentialRecord);
_eventAggregator.Publish(new ServiceMessageProcessingEvent
{
RecordId = credentialRecord.Id,
MessageType = credentialProposal.Type,
ThreadId = credentialProposal.GetThreadId()
});
messageContext.ContextRecord = credentialRecord;
return(null);
}
case MessageTypes.IssueCredentialNames.OfferCredential:
case MessageTypesHttps.IssueCredentialNames.OfferCredential:
{
var offer = messageContext.GetMessage <CredentialOfferMessage>();
var recordId = await this.ProcessOfferAsync(
agentContext, offer, messageContext.Connection);
messageContext.ContextRecord = await _credentialService.GetAsync(agentContext, recordId);
return(null);
}
case MessageTypes.IssueCredentialNames.RequestCredential:
case MessageTypesHttps.IssueCredentialNames.RequestCredential:
{
var request = messageContext.GetMessage <CredentialRequestMessage>();
var recordId = await _credentialService.ProcessCredentialRequestAsync(
agentContext : agentContext,
credentialRequest : request,
connection : messageContext.Connection);
if (request.ReturnRoutingRequested() && messageContext.Connection == null)
{
var(message, record) = await _credentialService.CreateCredentialAsync(agentContext, recordId);
messageContext.ContextRecord = record;
return(message);
}
else
{
messageContext.ContextRecord = await _credentialService.GetAsync(agentContext, recordId);
return(null);
}
}
case MessageTypes.IssueCredentialNames.IssueCredential:
case MessageTypesHttps.IssueCredentialNames.IssueCredential:
{
var credential = messageContext.GetMessage <CredentialIssueMessage>();
var recordId = await _credentialService.ProcessCredentialAsync(
agentContext, credential, messageContext.Connection);
messageContext.ContextRecord = await UpdateValuesAsync(
credentialId : recordId,
credentialIssue : messageContext.GetMessage <CredentialIssueMessage>(),
agentContext : agentContext);
return(null);
}
default:
throw new AriesFrameworkException(ErrorCode.InvalidMessage,
$"Unsupported message type {messageContext.GetMessageType()}");
}
}
protected override async Task <AgentMessage> ProcessAsync(BasicMessage message, IAgentContext agentContext, UnpackedMessageContext messageContext)
{
Console.WriteLine($"Processing message by {messageContext.Connection.Id}");
await _recordService.AddAsync(agentContext.Wallet, new BasicMessageRecord
{
Id = Guid.NewGuid().ToString(),
ConnectionId = messageContext.Connection.Id,
Text = message.Content,
SentTime = DateTime.TryParse(message.SentTime, out var dateTime) ? dateTime : DateTime.UtcNow,
Direction = MessageDirection.Incoming
});
