/// <inheritdoc /> public virtual async Task <(ProofRequestMessage, string)> CreateProofRequestAsync(IAgentContext agentContext, string connectionId, string proofRequestJson) { Logger.LogInformation(LoggingEvents.CreateProofRequest, "ConnectionId {0}", connectionId); var connection = await ConnectionService.GetAsync(agentContext, connectionId); if (connection.State != ConnectionState.Connected) { throw new AgentFrameworkException(ErrorCode.RecordInInvalidState, $"Connection state was invalid. Expected '{ConnectionState.Connected}', found '{connection.State}'"); } var proofJobj = JObject.Parse(proofRequestJson); var proofRecord = new ProofRecord { Id = Guid.NewGuid().ToString(), ConnectionId = connection.Id, RequestJson = proofRequestJson }; proofRecord.SetTag(TagConstants.Nonce, proofJobj["nonce"].ToObject <string>()); proofRecord.SetTag(TagConstants.Role, TagConstants.Requestor); await RecordService.AddAsync(agentContext.Wallet, proofRecord); return(new ProofRequestMessage { ProofRequestJson = proofRequestJson }, proofRecord.Id); }
/// <inheritdoc /> public virtual async Task <ProofRequestMessage> CreateProofRequestAsync(Wallet wallet, string connectionId, string proofRequestJson) { Logger.LogInformation(LoggingEvents.CreateProofRequest, "ConnectionId {0}", connectionId); var connection = await ConnectionService.GetAsync(wallet, connectionId); var proofJobj = JObject.Parse(proofRequestJson); var proofRecord = new ProofRecord { Id = Guid.NewGuid().ToString(), ConnectionId = connection.ConnectionId, RequestJson = proofRequestJson }; proofRecord.Tags[TagConstants.Nonce] = proofJobj["nonce"].ToObject <string>(); proofRecord.Tags[TagConstants.ConnectionId] = connection.GetId(); proofRecord.Tags[TagConstants.Role] = TagConstants.Requestor; await RecordService.AddAsync(wallet, proofRecord); var proofRequest = await MessageSerializer.PackSealedAsync <ProofRequestMessage>( new ProofRequestDetails { ProofRequestJson = proofRequestJson }, wallet, connection.MyVk, connection.TheirVk); proofRequest.Type = MessageUtils.FormatDidMessageType(connection.TheirDid, MessageTypes.ProofRequest); return(proofRequest); }
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(); }
/// <inheritdoc /> public virtual async Task <string> ProcessProofRequestAsync(IAgentContext agentContext, ProofRequestMessage proofRequest, ConnectionRecord connection) { var requestJson = proofRequest.ProofRequestJson; // Write offer record to local wallet var proofRecord = new ProofRecord { Id = Guid.NewGuid().ToString(), RequestJson = requestJson, ConnectionId = connection.Id, State = ProofState.Requested }; proofRecord.SetTag(TagConstants.LastThreadId, proofRequest.GetThreadId()); proofRecord.SetTag(TagConstants.Role, TagConstants.Holder); await RecordService.AddAsync(agentContext.Wallet, proofRecord); EventAggregator.Publish(new ServiceMessageProcessingEvent { RecordId = proofRecord.Id, MessageType = proofRequest.Type, ThreadId = proofRequest.GetThreadId() }); return(proofRecord.Id); }
public ProofRequestViewModel(IUserDialogs userDialogs, INavigationService navigationService, IProofService proofService, IAgentProvider agentContextProvider, IMessageService messageService, IConnectionService connectionService, IEventAggregator eventAggregator, IWalletRecordService recordService, IProofCredentialSelector proofCredentialSelector, ProofRecord proof) : base(AppResources.ProofRequestPageTitle, userDialogs, navigationService) { _proofRecord = proof; _proofService = proofService; _agentContextProvider = agentContextProvider; _messageService = messageService; _connectionService = connectionService; _eventAggregator = eventAggregator; _userDialogs = userDialogs; _recordService = recordService; _navigationService = navigationService; _proofCredentialSelector = proofCredentialSelector; GetConnectionAlias(); _proofRequest = JsonConvert.DeserializeObject <ProofRequest>(_proofRecord.RequestJson); ProofName = _proofRequest.Name; Version = _proofRequest.Version; State = ProofStateTranslator.Translate(_proofRecord.State); AreButtonsVisible = _proofRecord.State == ProofState.Requested; Attributes = new List <ProofAttributeViewModel>(); }
public async Task <GetCredentialsForProofResponse> Handle ( GetCredentialsForProofRequest aGetCredentialsForProofRequest, CancellationToken aCancellationToken ) { IAgentContext agentContext = await AgentProvider.GetContextAsync(); ProofRecord proofRecord = await ProofService.GetAsync(agentContext, aGetCredentialsForProofRequest.ProofId); ProofRequest proofRequest = JsonConvert.DeserializeObject <ProofRequest>(proofRecord.RequestJson); //ProofServiceUtils.GetAutoRequestedCredentialsForProofCredentials List <Credential> credentials = await ProofService .ListCredentialsForProofRequestAsync ( agentContext, proofRequest, aGetCredentialsForProofRequest.Referent ); var response = new GetCredentialsForProofResponse(credentials, aGetCredentialsForProofRequest.CorrelationId); return(response); }
/// <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); }
/// <inheritdoc /> public virtual async Task <string> ProcessProofRequestAsync(IAgentContext agentContext, ProofRequestMessage proofRequest) { var requestJson = proofRequest.ProofRequestJson; var offer = JObject.Parse(requestJson); var nonce = offer["nonce"].ToObject <string>(); // Write offer record to local wallet var proofRecord = new ProofRecord { Id = Guid.NewGuid().ToString(), RequestJson = requestJson, ConnectionId = agentContext.Connection.Id, State = ProofState.Requested }; proofRecord.SetTag(TagConstants.Nonce, nonce); proofRecord.SetTag(TagConstants.Role, TagConstants.Holder); await RecordService.AddAsync(agentContext.Wallet, proofRecord); EventAggregator.Publish(new ServiceMessageProcessingEvent { RecordId = proofRecord.Id, MessageType = proofRequest.Type, }); return(proofRecord.Id); }
public async Task <ProofRequestViewModel> Assemble(ProofRecord proofRecord) { if (proofRecord == null) { return(null); } ProofRequestViewModel proofRequest2 = _scope.Resolve <ProofRequestViewModel>(new NamedParameter("proof", proofRecord)); proofRequest2.Id = proofRecord.Id; if (proofRecord.ProofJson != null) { var partialProof = JsonConvert.DeserializeObject <PartialProof>(proofRecord.ProofJson); var proofRequest = JsonConvert.DeserializeObject <ProofRequest>(proofRecord.RequestJson); proofRequest2.Attributes.Clear(); foreach (var revealedAttributeKey in partialProof.RequestedProof.RevealedAttributes.Keys) { var proofAttribute = new ProofAttributeViewModel { Name = proofRequest.RequestedAttributes[revealedAttributeKey].Name, // TODO: Que faire pour gérer l'attribut Names? IsPredicate = false, IsRevealed = true, Type = "Text", Value = partialProof.RequestedProof.RevealedAttributes[revealedAttributeKey].Raw }; proofRequest2.Attributes.Add(proofAttribute); } } else { ProofRequest proofRequest = JsonConvert.DeserializeObject <ProofRequest>(proofRecord.RequestJson); proofRequest2.Attributes.Clear(); foreach (KeyValuePair <string, ProofAttributeInfo> requestedAttribute in proofRequest.RequestedAttributes) { proofRequest2.Attributes.Add(new ProofAttributeViewModel { Id = requestedAttribute.Key, Name = requestedAttribute.Value.Name // TODO: Que faire pour gérer l'attribut Names? }); } foreach (KeyValuePair <string, ProofPredicateInfo> requestedAttribute in proofRequest.RequestedPredicates) { proofRequest2.Attributes.Add(new ProofAttributeViewModel { Id = requestedAttribute.Key, Name = requestedAttribute.Value.Name, // TODO: Que faire pour gérer l'attribut Names? IsPredicate = true }); } } proofRequest2.State = ProofStateTranslator.Translate(proofRecord.State); return(proofRequest2); }
private async Task ScanInvite() { var expectedFormat = ZXing.BarcodeFormat.QR_CODE; var opts = new ZXing.Mobile.MobileBarcodeScanningOptions { PossibleFormats = new List <ZXing.BarcodeFormat> { expectedFormat } }; var context = await _agentContextProvider.GetContextAsync(); var scanner = new ZXing.Mobile.MobileBarcodeScanner(); var result = await scanner.Scan(opts); if (result == null) { return; } AgentMessage message = await MessageDecoder.ParseMessageAsync(result.Text); switch (message) { case ConnectionInvitationMessage invitation: break; case RequestPresentationMessage presentation: RequestPresentationMessage proofRequest = (RequestPresentationMessage)presentation; var service = message.GetDecorator <ServiceDecorator>(DecoratorNames.ServiceDecorator); ProofRecord proofRecord = await _proofService.ProcessRequestAsync(context, proofRequest, null); proofRecord.SetTag("RecipientKey", service.RecipientKeys.ToList()[0]); proofRecord.SetTag("ServiceEndpoint", service.ServiceEndpoint); await _recordService.UpdateAsync(context.Wallet, proofRecord); _eventAggregator.Publish(new ApplicationEvent { Type = ApplicationEventType.ProofRequestUpdated }); break; default: DialogService.Alert("Invalid invitation!"); return; } Device.BeginInvokeOnMainThread(async() => { if (message is ConnectionInvitationMessage) { await NavigationService.NavigateToAsync <AcceptInviteViewModel>(message as ConnectionInvitationMessage, NavigationType.Modal); } }); }
public static async Task <(ProofRecord holderProofRecord, ProofRecord RequestorProofRecord)> ProofProtocolAsync( IProofService proofService, IProducerConsumerCollection <AgentMessage> messages, ConnectionRecord holderConnection, ConnectionRecord requestorConnection, IAgentContext holderContext, IAgentContext requestorContext, ProofRecord requestorProofRecord) { // Holder accepts the proof requests and builds a proof var holderRequestPresentationMessage = FindContentMessage <RequestPresentationMessage>(messages); Assert.NotNull(holderRequestPresentationMessage); //Holder stores the proof request if they haven't created it already var holderProofRecord = await proofService.ProcessRequestAsync(holderContext, holderRequestPresentationMessage, holderConnection); Assert.Equal(ProofState.Requested, holderProofRecord.State); Console.WriteLine(holderProofRecord.RequestJson); var holderProofRequest = JsonConvert.DeserializeObject <ProofRequest>(holderProofRecord.RequestJson); // Auto satisfy the proof with which ever credentials in the wallet are capable var requestedCredentials = await ProofServiceUtils.GetAutoRequestedCredentialsForProofCredentials(holderContext, proofService, holderProofRequest); //Holder accepts the proof request and sends a proof (var proofMessage, _) = await proofService.CreatePresentationAsync( holderContext, holderProofRecord.Id, requestedCredentials); messages.TryAdd(proofMessage); //Requestor retrives proof message from their cloud agent var proof = FindContentMessage <PresentationMessage>(messages); Assert.NotNull(proof); //Requestor stores proof requestorProofRecord = await proofService.ProcessPresentationAsync(requestorContext, proof); //Requestor verifies proof var requestorVerifyResult = await proofService.VerifyProofAsync(requestorContext, requestorProofRecord.Id); //Verify the proof is valid Assert.True(requestorVerifyResult); var requestorProofRecordResult = await proofService.GetAsync(requestorContext, requestorProofRecord.Id); var holderProofRecordResult = await proofService.GetAsync(holderContext, holderProofRecord.Id); return(holderProofRecordResult, requestorProofRecordResult); }
private async Task DisplayRequestPresentation(string recordId) { IAgentContext context = await _agentContextProvider.GetContextAsync(); ProofRecord proofRecord = await _proofService.GetAsync(context, recordId); ProofRequestViewModel proofRequest = await _proofAssembler.Assemble(proofRecord); await _requestPresentationFiller.Fill(proofRequest); await NavigationService.NavigateToAsync(proofRequest, null, NavigationType.Modal); }
public async Task <GetProofResponse> Handle ( GetProofRequest aGetProofRequest, CancellationToken aCancellationToken ) { IAgentContext agentContext = await AgentProvider.GetContextAsync(); ProofRecord proofRecord = await ProofService.GetAsync(agentContext, aGetProofRequest.ProofId); var response = new GetProofResponse(proofRecord, aGetProofRequest.CorrelationId); return(await Task.Run(() => response)); }
/// <inheritdoc /> public virtual async Task <string> ProcessProofRequestAsync(IAgentContext agentContext, ProofRequestMessage proofRequest, ConnectionRecord connection, bool isVcOidc) { var requestJson = proofRequest.ProofRequestJson; // Write offer record to local wallet var proofRecord = new ProofRecord { Id = Guid.NewGuid().ToString(), RequestJson = requestJson, ConnectionId = isVcOidc ? null : connection.Id, State = ProofState.Requested }; proofRecord.SetTag(TagConstants.LastThreadId, proofRequest.GetThreadId()); proofRecord.SetTag(TagConstants.Role, TagConstants.Holder); if (!connection.Sso && !isVcOidc) { await RecordService.AddAsync(agentContext.Wallet, proofRecord); EventAggregator.Publish(new ServiceMessageProcessingEvent { RecordId = proofRecord.Id, MessageType = proofRequest.Type, ThreadId = proofRequest.GetThreadId() }); } else { if (isVcOidc) { connection.Endpoint = new AgentEndpoint { Uri = proofRequest.ServiceDecorator.ServiceEndpoint?.ToString() }; } await SelectCredentialsForProofAsync(agentContext, proofRecord, connection); } return(proofRecord.Id); }
/// <inheritdoc /> public virtual async Task <string> ProcessProofRequestAsync(Wallet wallet, ProofRequestMessage proofRequest) { var(didOrKey, _) = MessageUtils.ParseMessageType(proofRequest.Type); var connectionSearch = await ConnectionService.ListAsync(wallet, new SearchRecordQuery { { TagConstants.MyDid, didOrKey } }); if (!connectionSearch.Any()) { throw new Exception($"Can't find connection record for type {proofRequest.Type}"); } var connection = connectionSearch.First(); var(requestDetails, _) = await MessageSerializer.UnpackSealedAsync <ProofRequestDetails>(proofRequest.Content, wallet, connection.MyVk); var requestJson = requestDetails.ProofRequestJson; var offer = JObject.Parse(requestJson); var nonce = offer["nonce"].ToObject <string>(); // Write offer record to local wallet var proofRecord = new ProofRecord { Id = Guid.NewGuid().ToString(), RequestJson = requestJson, ConnectionId = connection.GetId(), State = ProofState.Requested }; proofRecord.Tags[TagConstants.ConnectionId] = connection.GetId(); proofRecord.Tags[TagConstants.Nonce] = nonce; proofRecord.Tags[TagConstants.Role] = TagConstants.Holder; await RecordService.AddAsync(wallet, proofRecord); return(proofRecord.GetId()); }
public ProofRequestViewModel(IUserDialogs userDialogs, INavigationService navigationService, IProofService proofService, IAgentProvider agentProvider, IMessageService messageService, IEventAggregator eventAggregator, IConnectionService connectionService, ProofRecord proofRequestRecord) : base(nameof(ProofRequestViewModel), userDialogs, navigationService) { Title = "Proof Request"; _proofService = proofService; _agentProvider = agentProvider; _messageService = messageService; _connectionService = connectionService; _proofRequestRecord = proofRequestRecord; _eventAggregator = eventAggregator; _proofRequest = _proofRequestRecord.RequestJson.ToObject <ProofRequest>(); if (_proofRequestRecord.CreatedAtUtc != null) { IssuedDate = (DateTime)_proofRequestRecord.CreatedAtUtc; } }
public async Task CreateProofRequestFromProposal() { var events = 0; _eventAggregator.GetEventByType <ServiceMessageProcessingEvent>() .Where(_ => (_.MessageType == MessageTypes.PresentProofNames.ProposePresentation || _.MessageType == MessageTypes.PresentProofNames.RequestPresentation || _.MessageType == MessageTypes.IssueCredentialNames.RequestCredential || _.MessageType == MessageTypes.IssueCredentialNames.IssueCredential)) .Subscribe(_ => { events++; }); // Setup secure connection between issuer and holder var(issuerConnection, holderConnection) = await Scenarios.EstablishConnectionAsync( _connectionService, _messages, _issuerWallet, _holderWallet); var(issuerCredential, holderCredential) = await Scenarios.IssueCredentialAsync( _schemaService, _credentialService, _messages, issuerConnection, holderConnection, _issuerWallet, _holderWallet, await _holderWallet.Pool, TestConstants.DefaultMasterSecret, false, new List <CredentialPreviewAttribute> { new CredentialPreviewAttribute("first_name", "Test"), new CredentialPreviewAttribute("last_name", "Test"), new CredentialPreviewAttribute("salary", "100000"), new CredentialPreviewAttribute("age", "25"), new CredentialPreviewAttribute("wellbeing", "100") }); Assert.Equal(issuerCredential.State, holderCredential.State); Assert.Equal(CredentialState.Issued, issuerCredential.State); var(message, record) = await _proofService.CreateProposalAsync(_holderWallet, new ProofProposal { Comment = "Hello, World", ProposedAttributes = new List <ProposedAttribute> { new ProposedAttribute { Name = "first_name", CredentialDefinitionId = holderCredential.CredentialDefinitionId, Referent = "Proof of Name", Value = "Joe" }, new ProposedAttribute { Name = "last_name", CredentialDefinitionId = holderCredential.CredentialDefinitionId, Referent = "Proof of Name", Value = "Shmoe" }, new ProposedAttribute { Name = "age", CredentialDefinitionId = holderCredential.CredentialDefinitionId, Referent = "Proof of Age", Value = "Shmoe" } }, ProposedPredicates = new List <ProposedPredicate> { new ProposedPredicate { Name = "salary", CredentialDefinitionId = holderCredential.CredentialDefinitionId, Predicate = ">", Threshold = 99999, Referent = "Proof of Salary > $99,999" }, new ProposedPredicate { Name = "wellbeing", CredentialDefinitionId = holderCredential.CredentialDefinitionId, Referent = "Proof of Wellbeing", Predicate = "<", Threshold = 99999 } } }, holderConnection.Id); Assert.NotNull(message); // Process Proposal record = await _proofService.ProcessProposalAsync(_issuerWallet, message, issuerConnection); // RequestPresentationMessage requestMessage; (requestMessage, record) = await _proofService.CreateRequestFromProposalAsync(_issuerWallet, new ProofRequestParameters { Name = "Test", Version = "1.0", NonRevoked = null }, record.Id, issuerConnection.Id); Assert.NotNull(requestMessage); Assert.NotNull(record); var actualProofRequest = record.RequestJson.ToObject <ProofRequest>(); var expectedProofRequest = new ProofRequest { Name = "Test", Version = "1.0", Nonce = actualProofRequest.Nonce, RequestedAttributes = new Dictionary <string, ProofAttributeInfo> { { "Proof of Name", new ProofAttributeInfo { Name = null, Names = new string[] { "first_name", "last_name" }, NonRevoked = null, Restrictions = new List <AttributeFilter> { new AttributeFilter { CredentialDefinitionId = holderCredential.CredentialDefinitionId } } } }, { "Proof of Age", new ProofAttributeInfo { Name = "age", Names = null, NonRevoked = null, Restrictions = new List <AttributeFilter> { new AttributeFilter { CredentialDefinitionId = holderCredential.CredentialDefinitionId } } } } }, RequestedPredicates = new Dictionary <string, ProofPredicateInfo> { { "Proof of Salary > $99,999", new ProofPredicateInfo { Name = "salary", Names = null, NonRevoked = null, PredicateType = ">", PredicateValue = 99999, Restrictions = new List <AttributeFilter> { new AttributeFilter { CredentialDefinitionId = holderCredential.CredentialDefinitionId } } } }, { "Proof of Wellbeing", new ProofPredicateInfo { Name = "wellbeing", Names = null, NonRevoked = null, PredicateType = "<", PredicateValue = 99999, Restrictions = new List <AttributeFilter> { new AttributeFilter { CredentialDefinitionId = holderCredential.CredentialDefinitionId } } } } } }; var expectedProofRecord = new ProofRecord { State = ProofState.Requested, RequestJson = expectedProofRequest.ToJson(), }; actualProofRequest.Should().BeEquivalentTo(expectedProofRequest); }
public IHttpActionResult GetProofRecord(string id) { var tlist = new ProofRecord().GetProofRecord(id); return(Ok(tlist)); }
private async Task SelectCredentialsForProofAsync(IAgentContext agentContext, ProofRecord proof, ConnectionRecord connection) { var requestJson = (JObject)JsonConvert.DeserializeObject(proof.RequestJson); JObject _requestedAttributes = (JObject)requestJson["requested_attributes"]; JObject _requestedPredicates = (JObject)requestJson["requested_predicates"]; IList <string> _requestedAttributesKeys = _requestedAttributes?.Properties().Select(p => p.Name).ToList(); IList <string> _requestedPredicatesKeys = _requestedPredicates?.Properties().Select(p => p.Name).ToList(); JToken cred_def_id = null; try { cred_def_id = _requestedAttributes[_requestedAttributesKeys[0]]["restrictions"][0]["cred_def_id"]; } catch (Exception) { cred_def_id = null; } var credentials = new List <CredentialRecord>(); if (cred_def_id != null) { credentials = await RecordService.SearchAsync <CredentialRecord>(agentContext.Wallet, SearchQuery.And(SearchQuery.Equal(nameof(CredentialRecord.State), CredentialState.Issued.ToString("G")), SearchQuery.Equal(nameof(CredentialRecord.CredentialDefinitionId), cred_def_id.ToString())), null, 100); } else { credentials = await RecordService.SearchAsync <CredentialRecord>(agentContext.Wallet, SearchQuery.Equal(nameof(CredentialRecord.State), CredentialState.Issued.ToString("G")), null, 100); } bool credentialFound = false; if (credentials.Count > 0) { Dictionary <string, RequestedAttribute> requestedAttributes = new Dictionary <string, RequestedAttribute>(); Dictionary <string, RequestedAttribute> requestedPredicates = new Dictionary <string, RequestedAttribute>(); foreach (var credential in credentials) { if (!credentialFound) { IEnumerable <CredentialAttribute> Attributes = credential.CredentialAttributesValues .Select(p => new CredentialAttribute() { Name = p.Name, Value = p.Value?.ToString(), Type = "Text" }) .ToList(); foreach (var item in _requestedAttributesKeys) { foreach (var attrib in Attributes) { if (_requestedAttributes[item]["name"].ToString() == attrib.Name) { RequestedAttribute requestedAttribute = new RequestedAttribute(); requestedAttribute.CredentialId = credential.CredentialId; requestedAttribute.Revealed = true; requestedAttribute.Timestamp = ((DateTimeOffset)DateTime.UtcNow).ToUnixTimeMilliseconds(); requestedAttributes.Add(item, requestedAttribute); credentialFound = true; } } if (!credentialFound) { requestedAttributes.Clear(); } } foreach (var item in _requestedPredicatesKeys) { RequestedAttribute requestedAttribute = new RequestedAttribute(); requestedAttribute.CredentialId = credential.CredentialId; requestedAttribute.Timestamp = ((DateTimeOffset)DateTime.UtcNow).ToUnixTimeMilliseconds(); requestedPredicates.Add(item, requestedAttribute); } } } if (credentialFound) { RequestedCredentials requestedCredentials = new RequestedCredentials(); requestedCredentials.RequestedAttributes = requestedAttributes; requestedCredentials.RequestedPredicates = requestedPredicates; var proofJson = await CreateProofJsonAsync(agentContext, requestedCredentials, proof.RequestJson); var threadId = proof.GetTag(TagConstants.LastThreadId); var proofMsg = new ProofMessage { ProofJson = proofJson }; proofMsg.ThreadFrom(threadId); await MessageService.SendAsync(agentContext.Wallet, proofMsg, connection); } } }
public GetProofResponse(ProofRecord aProofRecord, Guid aCorrelationId) : base(aCorrelationId) { ProofRecord = aProofRecord; }