private static void AddAttributeConsumingServices(SPOptions options)
{
var a1 = new RequestedAttribute("urn:attributeName")
{
FriendlyName = "friendlyName",
NameFormat = RequestedAttribute.AttributeNameFormatUri,
AttributeValueXsiType = ClaimValueTypes.String,
IsRequired = true
};
a1.Values.Add("value1");
a1.Values.Add("value2");
var a2 = new RequestedAttribute("someName");
var acs = new AttributeConsumingService("attributeServiceName")
{
IsDefault = true
};
acs.RequestedAttributes.Add(a1);
acs.RequestedAttributes.Add(a2);
options.AttributeConsumingServices.Add(acs);
}
public override bool Equals(object obj)
{
if (!(obj is RequestedAttribute))
{
return(false);
}
RequestedAttribute other = (RequestedAttribute)obj;
return(_requestedTable == other._requestedTable && _columnName == other._columnName);
}
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;
}
public static AttributeConsumingService RequestAttribute(this AttributeConsumingService service, RequestedAttribute attribute)
{
service.RequestedAttributes.Add(attribute);
return(service);
}
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);
}
}
}
