/// <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)); }