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);
        }
Beispiel #2
0
        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);
        }
Beispiel #3
0
        public async Task Fill(ProofRequestViewModel proof)
        {
            var context = await _agentContextProvider.GetContextAsync();

            var proofRecord = await _recordService.GetAsync <ProofRecord>(context.Wallet, proof.Id);

            var holderProofObject = JsonConvert.DeserializeObject <ProofRequest>(proofRecord.RequestJson);

            //var credentials = await _proofService.ListCredentialsForProofRequestAsync(context, holderProofObject, "username");

            if (proofRecord.State == ProofState.Requested)
            {
                var proofRequest = JsonConvert.DeserializeObject <ProofRequest>(proofRecord.RequestJson);
                foreach (var requestedAttribute3 in proofRequest.RequestedAttributes)
                {
                    var requestedAttribute = requestedAttribute3.Value;
                    if (requestedAttribute.Restrictions.Count > 0)
                    {
                        if (!string.IsNullOrEmpty(requestedAttribute.Restrictions[0].CredentialDefinitionId))
                        {
                            foreach (var credentialRecord in await _credentialService.ListIssuedCredentialsAsync(context))
                            {
                                if (credentialRecord.CredentialDefinitionId == requestedAttribute.Restrictions[0].CredentialDefinitionId)
                                {
                                    var requestedAttribute2 = new RequestedAttribute
                                    {
                                        CredentialId = credentialRecord.CredentialId,
                                        Timestamp    = ((DateTimeOffset)DateTime.UtcNow).ToUnixTimeMilliseconds()
                                    };

                                    //proof.BuildRequestedAttributesPredicatesMap(credentialRecord);
                                    foreach (var pa in proof.Attributes)
                                    {
                                        if (pa.Name == requestedAttribute.Name)
                                        {
                                            foreach (var cav in credentialRecord.CredentialAttributesValues)
                                            {
                                                if (cav.Name == requestedAttribute.Name)
                                                {
                                                    pa.Value        = cav.Value.ToString();
                                                    pa.CredentialId = credentialRecord.CredentialId;
                                                    //if (proof.RequestedAttributesMap.ContainsKey(requestedAttribute3.Key))
                                                    //{
                                                    //    if (proof.RequestedAttributesMap[requestedAttribute3.Key]?.CredentialId !=
                                                    //        requestedAttribute2.CredentialId)
                                                    //        proof.RequestedAttributesMap[requestedAttribute3.Key] = requestedAttribute2;
                                                    //}
                                                    //else
                                                    //{
                                                    //    proof.RequestedAttributesMap.Add(requestedAttribute3.Key, requestedAttribute2);
                                                    //}
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
            int bla = 1;
        }