/// <summary>
/// Completes account recovery.
/// </summary>
/// <param name="memberId">the member id</param>
/// <param name="recoveryOperations">the member recovery operations</param>
/// <param name="privilegedKey">the privileged public key in the member recovery operations</param>
/// <param name="cryptoEngine">the new crypto engine</param>
/// <returns>the new member</returns>
public Task <ProtoMember> CompleteRecovery(
string memberId,
IList <MemberRecoveryOperation> recoveryOperations,
Key privilegedKey,
ICryptoEngine cryptoEngine)
{
var operations = recoveryOperations.Select(re => new MemberOperation {
Recover = re
}).ToList();
operations.Add(Util.ToAddKeyOperation(privilegedKey));
operations.Add(Util.ToAddKeyOperation(cryptoEngine.GenerateKey(Level.Standard)));
operations.Add(Util.ToAddKeyOperation(cryptoEngine.GenerateKey(Level.Low)));
var signer = cryptoEngine.CreateSigner(privilegedKey.Id);
var memberRequest = new GetMemberRequest {
MemberId = memberId
};
return(gateway.GetMemberAsync(memberRequest)
.ToTask(response => response.Member)
.FlatMap(member =>
{
var request = Util.ToUpdateMemberRequest(member, operations, signer);
return gateway.UpdateMemberAsync(request).ToTask(response => response.Member);
}));
}
/// <summary>
/// Recovers an eIDAS-verified member with eidas payload.
///
/// </summary>
/// <param name="payload">a payload containing member id, the certificate and a new key to add to the member</param>
/// <param name="signature">a payload signature with the private key corresponding to the certificate</param>
/// <param name="cryptoEngine">a crypto engine that must contain the privileged key that is included in
/// the payload(if it does not contain keys for other levels they will be generated)</param>
/// <returns>a task of a new member</returns>
public Task <ProtoMember> RecoverEidasMember(
EidasRecoveryPayload payload,
string signature,
ICryptoEngine cryptoEngine)
{
Key privilegedKey = payload.Key;
Key standardKey = GetOrGenerateKeyForLevel(cryptoEngine,
Level.Standard);
Key lowKey = GetOrGenerateKeyForLevel(cryptoEngine,
Level.Low);
IList <Key> keys = new List <Key> {
privilegedKey, standardKey, lowKey
};
ISigner signer = cryptoEngine.CreateSigner(privilegedKey.Id);
string memberId = payload.MemberId;
var request = new RecoverEidasRequest
{
Payload = payload,
Signature = signature
};
var memberRequest = new GetMemberRequest {
MemberId = memberId
};
return(Util.TwoTasks(
gateway.GetMemberAsync(memberRequest)
.ToTask(response => response.Member),
gateway.RecoverEidasMemberAsync(request)
.ToTask(response => response.RecoveryEntry))
.Map(memberAndEntry =>
{
IList <MemberOperation> operations = new List <MemberOperation>();
operations.Add(new MemberOperation {
Recover = memberAndEntry.Value
});
var list = keys
.Select(key => new MemberOperation
{
AddKey = new MemberAddKeyOperation
{
Key = key
}
})
.ToList();
foreach (var operation in list)
{
operations.Add(operation);
}
return Util.ToUpdateMemberRequest(memberAndEntry.Key,
operations,
signer);
})
.FlatMap(updateMember => gateway
.UpdateMemberAsync(updateMember)
.ToTask(response => response.Member)));
}
/// <summary>
/// Looks up member id for a given member ID.
/// </summary>
/// <param name="memberId">the member ID to check</param>
/// <returns>the member</returns>
public Task <ProtoMember> GetMember(string memberId)
{
var request = new GetMemberRequest {
MemberId = memberId
};
return(gateway.GetMemberAsync(request)
.ToTask(response => response.Member));
}
/// <summary>
/// Initiates the asynchronous execution of the GetMember operation.
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the GetMember operation.</param>
/// <param name="cancellationToken">
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
/// </param>
/// <returns>The task object representing the asynchronous operation.</returns>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/managedblockchain-2018-09-24/GetMember">REST API Reference for GetMember Operation</seealso>
public virtual Task <GetMemberResponse> GetMemberAsync(GetMemberRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var options = new InvokeOptions();
options.RequestMarshaller = GetMemberRequestMarshaller.Instance;
options.ResponseUnmarshaller = GetMemberResponseUnmarshaller.Instance;
return(InvokeAsync <GetMemberResponse>(request, options, cancellationToken));
}
internal virtual GetMemberResponse GetMember(GetMemberRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = GetMemberRequestMarshaller.Instance;
options.ResponseUnmarshaller = GetMemberResponseUnmarshaller.Instance;
return(Invoke <GetMemberResponse>(request, options));
}
/// <summary>
/// Looks up member information for a given user.
/// </summary>
/// <param name="memberId">the member id of the user</param>
/// <returns>the member</returns>
public Task <ProtoMember> GetMember(string memberId)
{
var request = new GetMemberRequest {
MemberId = memberId
};
return(gateway(authenticationContext()).GetMemberAsync(request)
.ToTask(response => response.Member));
}
public override async Task <GetMemberReply> GetClusterMembers(GetMemberRequest request, ServerCallContext context)
{
var response = new GetMemberReply();
await Task.Run(() =>
{
response.Members.Add("YO SOY IL BEST");
});
return(response);
}
public async Task <MemberData> GetMember(GetMemberRequest request)
{
var url = _urls.Phrase + UrlsConfig.PhraseOperations.GetMember(request.MemberId);
var response = await _httpClient.GetAsync(url);
var content = await response.Content.ReadAsStringAsync();
return(JsonConvert.DeserializeObject <MemberData>(content));
}
public Member GetMember(int id)
{
var request = new GetMemberRequest {
Id = id
};
var response = SendRequest <GetMemberRequest, GetMemberResponse>(RequestType.GetMember, request);
return(response.Member);
}
private BaseResponse _handler_GetMember(BasePacket packet)
{
GetMemberRequest p = packet as GetMemberRequest;
ProxyHolder proxy = this.GetProxyByID(p.ObjectID);
if (proxy == null)
{
throw new Exception("Proxy Nr. not found: " + p.ObjectID);
}
return(new GetMemberResponse(proxy.GetMember(p.Member, p.ReturnType), p));
}
/// <summary>
/// Create a recovery authorization for some agent to sign.
/// </summary>
/// <param name="memberId">the ID of the member we claim to be</param>
/// <param name="privilegedKey">the new privileged key we want to use</param>
/// <returns>the authorization</returns>
public Task <Authorization> CreateRecoveryAuthorization(string memberId, Key privilegedKey)
{
var request = new GetMemberRequest {
MemberId = memberId
};
return(gateway.GetMemberAsync(request)
.ToTask(response => new Authorization
{
MemberId = memberId,
MemberKey = privilegedKey,
PrevHash = response.Member.LastHash
}));
}
public async Task <IActionResult> GetMember(string memberUsername)
{
try
{
GetMemberRequest request = new GetMemberRequest()
{
MemberUsername = memberUsername
};
return(Ok(new Success(await Mediator.Send(request))));
}
catch (NotFoundException notFoundException)
{
return(Ok(new NotFoundError(notFoundException)));
}
catch (Exception exception)
{
return(Ok(new InternalServerError(exception)));
}
}
public override bool TryGetMember(GetMemberBinder binder, out object result)
{
GetMemberRequest req = new GetMemberRequest(this.ObjectID, binder.Name, binder.ReturnType);
this.Client.Send(req);
BaseResponse resp = this.Client.WaitForResponse(req, 50000);
if (resp is GetMemberResponse)
{
result = (resp as GetMemberResponse).Result;
}
else if (resp is ExceptionResponse)
{
throw new Exception((resp as ExceptionResponse).Message);
}
else
{
result = null;
return(false);
}
return(true);
}
/// <summary>
/// Completes account recovery if the default recovery rule was set.
/// </summary>
/// <param name="memberId">the member id</param>
/// <param name="verificationId">the verification id</param>
/// <param name="code">the code</param>
/// <param name="cryptoEngine">the new crypto engine</param>
/// <returns>the new member</returns>
public Task <ProtoMember> CompleteRecoveryWithDefaultRule(
string memberId,
string verificationId,
string code,
ICryptoEngine cryptoEngine)
{
var privilegedKey = cryptoEngine.GenerateKey(Level.Privileged);
var standardKey = cryptoEngine.GenerateKey(Level.Standard);
var lowKey = cryptoEngine.GenerateKey(Level.Low);
var signer = cryptoEngine.CreateSigner(Level.Privileged);
var operations = new List <Key> {
privilegedKey, standardKey, lowKey
}
.Select(Util.ToAddKeyOperation)
.ToList();
var memberRequest = new GetMemberRequest {
MemberId = memberId
};
return(Util.TwoTasks(
gateway.GetMemberAsync(memberRequest)
.ToTask(response => response.Member),
GetRecoveryAuthorization(verificationId, code, privilegedKey))
.Map(memberAndEntry =>
{
operations.Add(new MemberOperation {
Recover = memberAndEntry.Value
});
return Util.ToUpdateMemberRequest(memberAndEntry.Key, operations, signer);
})
.FlatMap(updateMember => gateway
.UpdateMemberAsync(updateMember)
.ToTask(response => response.Member)));
}
//获取member信息
public MemberModel Get(GetMemberRequest req)
{
var token = base.Request.Headers["Authorization"];
MemberModel mm = MemberModel.GetMember(token);
return mm;
}
public async Task <Member> Get([FromBody] GetMemberRequest request) => await _mediator.Send(request);
public async Task Members()
{
var x = new GetMemberRequest {
};
await _duplexStream2.RequestStream.WriteAsync(x);
}
public async Task <MemberData> GetMember([FromRoute] Guid memberId)
{
var request = new GetMemberRequest(memberId);
return(await _phraseApiClient.GetMember(request));
}
