public int StoreMember(MemberDto member)
{
var request = new CreateMemberRequest(baseUrl, member);
String response = requester.Put<MemberDto>(request);
return Convert.ToInt32(response);
}
public async Task <CreateMemberRequestResult> CreateAsync(CreateMemberRequest request)
{
var member = new Member
{
City = request.City,
FirstName = request.FirstName,
LastName = request.LastName,
State = request.State,
Street = request.Street,
ZipCode = request.ZipCode
};
var user = new CreditUnionUser
{
Email = request.Email,
LockoutEnabled = true,
UserName = request.Email,
Member = member
};
IdentityResult result = await _userManager.CreateAsync(user, request.Password);
if (!result.Succeeded)
{
return(new CreateMemberRequestResult
{
Errors = result.Errors.Select(s => s.Description).ToList()
});
}
return(new CreateMemberRequestResult
{
Member = member
});
}
/// <summary>
/// Edit a member
/// </summary>
/// <param name="memberID">ID of the member</param>
/// <param name="request">Request for the call</param>
/// <exception cref="InvalidIdException">Thrown when the member ID does not exist</exception>
/// <exception cref="UsernameExistsException">Thrown when the username provided is already in use</exception>
/// <exception cref="EmailExistsException">Thrown when the email address provided is already in use</exception>
public async Task <Member> EditMember(int memberID, CreateMemberRequest request)
{
return(await SendRequest <Member>(
$"core/members/{memberID}",
HttpMethod.Post,
request));
}
public void Create_Buyer()
{
var request = new CreateMemberRequest
{
MemberExternalId = Guid.NewGuid().ToString(),
Email = "*****@*****.**",
PhoneNumber = "905551111111",
Name = "Haluk Demir",
Address = "Suadiye Mah. Örnek Cd. No:23, 34740 Kadıköy/İstanbul",
ContactName = "Haluk",
ContactSurname = "Demir",
NegativeWalletAmountLimit = -50
};
var response = _craftgateClient.Onboarding().CreateMember(request);
Assert.NotNull(response.Id);
Assert.True(response.IsBuyer);
Assert.AreEqual(request.MemberExternalId, response.MemberExternalId);
Assert.AreEqual(request.Email, response.Email);
Assert.AreEqual(request.PhoneNumber, response.PhoneNumber);
Assert.AreEqual(request.Name, response.Name);
Assert.AreEqual(request.Address, response.Address);
Assert.AreEqual(request.ContactName, response.ContactName);
Assert.AreEqual(request.ContactSurname, response.ContactSurname);
Assert.AreEqual(request.NegativeWalletAmountLimit, response.NegativeWalletAmountLimit);
}
/// <summary>
/// Create a member
/// </summary>
/// <param name="request">Request for the call</param>
/// <exception cref="UsernameExistsException">Thrown when the username provided is already in use</exception>
/// <exception cref="EmailExistsException">Thrown when the email address provided is already in use</exception>
/// <exception cref="InvalidGroupException">Thrown when the group ID provided is not valid</exception>
/// <exception cref="NoUsernameOrEmailException">Thrown when no username or email address was provided for the account</exception>
/// <exception cref="NoPasswordException">Thrown when no password was provided for the account</exception>
public async Task <Member> CreateMember(CreateMemberRequest request)
{
return(await SendRequest <Member>(
$"core/members",
HttpMethod.Post,
request));
}
public CreateMemberRequestBuilder(string email)
{
_request = new CreateMemberRequest
{
Email = email
};
}
public Task <MemberResponse> CreateMemberAsync(CreateMemberRequest createMemberRequest)
{
var path = "/onboarding/v1/members";
return(AsyncRestClient.Post <MemberResponse>(RequestOptions.BaseUrl + path,
CreateHeaders(createMemberRequest, path, RequestOptions),
createMemberRequest));
}
/// <summary>
/// Initiates the asynchronous execution of the CreateMember operation.
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the CreateMember 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/CreateMember">REST API Reference for CreateMember Operation</seealso>
public virtual Task <CreateMemberResponse> CreateMemberAsync(CreateMemberRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var options = new InvokeOptions();
options.RequestMarshaller = CreateMemberRequestMarshaller.Instance;
options.ResponseUnmarshaller = CreateMemberResponseUnmarshaller.Instance;
return(InvokeAsync <CreateMemberResponse>(request, options, cancellationToken));
}
internal virtual CreateMemberResponse CreateMember(CreateMemberRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = CreateMemberRequestMarshaller.Instance;
options.ResponseUnmarshaller = CreateMemberResponseUnmarshaller.Instance;
return(Invoke <CreateMemberResponse>(request, options));
}
public async Task <MemberResponse> CreateMember(CreateMemberRequest request, string accessToken = null)
{
var url = ClientSettings.Origin + MembersEndpoint;
Token = accessToken ?? Token;
var response = await this.RunQuery <MemberResponse>(() => RequestHelper.PostRequest(this, url, request, Token));
return(response);
}
/// <summary>
/// Creates new member ID. After the method returns the ID is reserved on the server.
/// </summary>
/// <param name="createMemberType">the type of member to register</param>
/// <returns>the created member ID</returns>
public Task <string> CreateMemberId(CreateMemberType createMemberType)
{
var request = new CreateMemberRequest {
Nonce = Util.Nonce(),
MemberType = createMemberType
};
return(gateway.CreateMemberAsync(request)
.ToTask(response => response.MemberId));
}
public async Task <ActionResult> CreateMemberAsync(CreateMemberRequest request)
{
try
{
return(Ok(new Success(await Mediator.Send(request), "Member Created successfully")));
}
catch (Exception exception)
{
return(StatusCode((int)HttpStatusCode.InternalServerError, new InternalServerError(exception)));
}
}
/// <summary>
/// 创建后端服务器
/// </summary>
public CreateMemberResponse CreateMember(CreateMemberRequest createMemberRequest)
{
Dictionary <string, string> urlParam = new Dictionary <string, string>();
urlParam.Add("pool_id", createMemberRequest.PoolId.ToString());
string urlPath = HttpUtils.AddUrlPath("/v3/{project_id}/elb/pools/{pool_id}/members", urlParam);
SdkRequest request = HttpUtils.InitSdkRequest(urlPath, "application/json;charset=UTF-8", createMemberRequest);
HttpResponseMessage response = DoHttpRequestSync("POST", request);
return(JsonUtils.DeSerialize <CreateMemberResponse>(response));
}
public async Task <ActionResult <Member> > Post([FromBody] CreateMemberRequest request)
{
CreateMemberRequestResult result = await _membersService.CreateAsync(request);
if (!result.WasSuccessful)
{
ModelState.AddErrorListToModelState(result.Errors);
return(BadRequest(ModelState));
}
return(CreatedAtAction(nameof(Get), null, result.Member));
}
public object Any(CreateMemberRequest request)
{
AutoMapper.Mapper.CreateMap<CreateMemberRequest, CreateMemberRequestModel>();
var requestModel = AutoMapper.Mapper.Map<CreateMemberRequestModel>(request);
var repo = new MemberRepository().CreateMember(requestModel);
AutoMapper.Mapper.CreateMap<MemberEditResponseModel, MemberEditResponse>();
return AutoMapper.Mapper.Map<MemberEditResponse>(repo);
}
public async Task <CreateMemberResponse> CreateMemberAsync(CreateMemberRequest request)
{
var content = JsonConvert.SerializeObject(request);
var buffer = System.Text.Encoding.UTF8.GetBytes(content);
var buffercontent = new ByteArrayContent(buffer);
buffercontent.Headers.ContentType = new MediaTypeHeaderValue("application/json");
//var client = _httpClient.CreateClient("myBupaAPI");
var result = await _httpClient.PostAsync("/BupaAPI/CreateMember", buffercontent);
var responseContent = result.Content.ReadAsStringAsync();
return(JsonConvert.DeserializeObject <CreateMemberResponse>(responseContent.Result));
}
public void Validate(CreateMemberRequest request)
{
if (string.IsNullOrEmpty(request.Name))
{
throw new Exception("MemberName is empty");
}
if (string.IsNullOrEmpty(request.Surname))
{
throw new Exception("Surname is empty");
}
if (string.IsNullOrEmpty(request.Email))
{
throw new Exception("Email is empty");
}
}
public async Task <IActionResult> CreateMember([FromBody] CreateMemberRequest member)
{
_logger.LogDebug($"Creating new Member.");
return(Ok(MapToResponse(await _memberService.CreateMember(new Member
{
Name = member.Name,
Mail = member.Mail,
Phone = member.Phone,
Password = member.Password,
Active = member.Active,
DateOfBirth = member.DateOfBirth,
FirstRegistered = member.FirstRegistered
}))));
}
/// <summary>
/// Creates the member identifier.
/// </summary>
/// <returns>The member identifier.</returns>
/// <param name="createMemberType">Create member type.</param>
/// <param name="tokenRequestId">Token request identifier.</param>
/// <param name="partnerId">Partner identifier.</param>
/// <param name="realmId">Realm identifier.</param>
public Task <string> CreateMemberId(CreateMemberType createMemberType,
string tokenRequestId = null,
string partnerId = null,
string realmId = null)
{
var request = new CreateMemberRequest
{
Nonce = Util.Nonce(),
MemberType = createMemberType,
TokenRequestId = tokenRequestId ?? "",
PartnerId = partnerId ?? "",
RealmId = realmId ?? ""
};
return(gateway.CreateMemberAsync(request)
.ToTask(response => response.MemberId));
}
public CreateMemberResponse CreateMember(CreateMemberRequest request)
{
_validator.ValidateRequest(request);
var member = Member.New();
member.SetMemberInformation(request.Name, request.Surname, request.Email);
_memberManager.Save(member);
_messageProducer.Produce("member-event", member.ID.ToString());
return(new CreateMemberResponse()
{
MemberId = member.ID,
Name = member.Name,
Surname = member.Surname,
Email = member.Email
});
}
public void Handle(CreateMemberRequest message)
{
if (string.IsNullOrWhiteSpace(message.Member.Email?.Address))
{
Bus.Publish(new MemberUpdatedEvent().LinkTo(message)
.WithProcessResult(new ArgumentException("Email address is required"),
"Email address is required."));
MarkAsComplete();
}
Data.Email = message.Member.Email?.Address;
DataCache.SetItem(message, Data.Email);
var createUserRequest = new CreateUserRequest
{
UserUpdate = MappingService.Map <UserUpdateDto>(message.Member)
}.LinkTo(message);
Bus.Send(_commonBusEndpointSettings.Identity, createUserRequest);
}
public async Task Can_Create_Member()
{
var request = new CreateMemberRequest
{
Id = Guid.NewGuid(),
Name = "Hugo"
};
var response = new CreateMemberResponse
{
Id = Guid.NewGuid()
};
_membetApiClient.CreateMemberAsync(request).Returns(Task.FromResult(response));
var result = await _controller.CreateMember(request);
result.Id.Should().NotBeEmpty();
}
public async Task Cannot_Create_MemberAsync()
{
var request = new CreateMemberRequest
{
Id = Guid.NewGuid(),
Name = "Hugo"
};
var response = new CreateMemberResponse
{
Message = "Can not create member"
};
_membetApiClient.CreateMemberAsync(request).Returns(Task.FromResult(response));
var result = await _controller.CreateMember(request);
result.Message.Should().Be("Can not create member");
}
public void Should_Generate_Hash()
{
//given
var expectedSignature = "lxoBkNdEanGAXYOL63uz/7P03kB0guaSPl7lXWvRJ4o=";
var request = new CreateMemberRequest
{
MemberExternalId = "ext-1511",
Email = "*****@*****.**",
PhoneNumber = "905551111111",
Name = "Haluk Demir",
IdentityNumber = "11111111110"
};
//when
var signature = HashGenerator.GenerateHash("https://api.craftgate.io", "api-key", "secret-key",
"rand-2010",
request, "/onboarding/v1/members");
//then
Assert.AreEqual(expectedSignature, signature);
}
public void Create_Sub_Merchant()
{
var request = new CreateMemberRequest
{
IsBuyer = false,
IsSubMerchant = true,
ContactName = "Haluk",
ContactSurname = "Demir",
Email = "*****@*****.**",
PhoneNumber = "905551111111",
IdentityNumber = "11111111110",
LegalCompanyTitle = "Dem Zeytinyağı Üretim Ltd. Şti.",
Name = "Dem Zeytinyağı Üretim Ltd. Şti.",
MemberExternalId = Guid.NewGuid().ToString(),
MemberType = MemberType.LIMITED_OR_JOINT_STOCK_COMPANY,
TaxNumber = "1111111114",
TaxOffice = "Erenköy",
Iban = "TR930006701000000001111111",
SettlementEarningsDestination = SettlementEarningsDestination.IBAN,
Address = "Suadiye Mah. Örnek Cd. No:23, 34740 Kadıköy/İstanbul"
};
var response = _craftgateClient.Onboarding().CreateMember(request);
Assert.NotNull(response.Id);
Assert.AreEqual(request.ContactName, response.ContactName);
Assert.AreEqual(request.ContactSurname, response.ContactSurname);
Assert.AreEqual(request.Email, response.Email);
Assert.AreEqual(request.PhoneNumber, response.PhoneNumber);
Assert.AreEqual(request.Iban, response.Iban);
Assert.AreEqual(request.IdentityNumber, response.IdentityNumber);
Assert.AreEqual(request.LegalCompanyTitle, response.LegalCompanyTitle);
Assert.AreEqual(request.Name, response.Name);
Assert.AreEqual(request.MemberExternalId, response.MemberExternalId);
Assert.AreEqual("LIMITED_OR_JOINT_STOCK_COMPANY", response.MemberType);
Assert.AreEqual(request.TaxNumber, response.TaxNumber);
Assert.AreEqual(request.TaxOffice, response.TaxOffice);
Assert.AreEqual(request.Address, response.Address);
Assert.AreEqual("IBAN", response.SettlementEarningsDestination);
}
public override void Process(ServicePipelineArgs args)
{
CreateUserRequest request;
CreateUserResult result;
using (new DisposableThreadLifestyleScope())
{
CheckParametersAndSetupRequestAndResult(args, out request, out result);
if (IsFromUcommerce(request))
{
result.CommerceUser = _userRepository.Get(request.UserName);
return;
}
var createMemberPipeline = ObjectFactory.Instance.Resolve <IPipeline <IPipelineArgs <CreateMemberRequest, CreateMemberResponse> > >("CreateOrGetMember");
var clientContext = ObjectFactory.Instance.Resolve <IClientContext>();
var basket = clientContext.GetBasket(true);
basket.PurchaseOrder.Customer = CreateCustomer(request);
var createMemberRequest = new CreateMemberRequest
{
LoginName = request.UserName,
Password = request.Password,
Email = request.Email,
MemberGroup = new MemberGroup(basket.PurchaseOrder.ProductCatalogGroup.MemberGroupId),
MemberType = new MemberType(basket.PurchaseOrder.ProductCatalogGroup.MemberTypeId)
};
var createMemberResponse = new CreateMemberResponse();
createMemberRequest.Properties["FromUCommerce"] = false;
createMemberPipeline.Execute(new CreateMemberPipelineArgs(createMemberRequest, createMemberResponse));
result.CommerceUser = _userRepository.Get(createMemberResponse.Member.LoginName);
}
}
public async Task <ApiResponse <CreateMemberResponse> > Register(CreateMemberRequest request)
{
var createMemberResponse = await _httpClient.PostJsonAsync <ApiResponse <CreateMemberResponse> >(Constants.URI.Members.CreateMember, request);
return(createMemberResponse);
}
public async Task CreateMemberAsync(CreateMemberRequest request)
{
await EnsureInGroupAsync(request);
RequestDispatchingProxy.Dispatch(request);
}
public ActionResult Post([FromBody] CreateMemberRequest request)
{
var response = _memberService.CreateMember(request);
return(Ok(response));
}
public static Task <HttpResponseMessage> SendMembersPostRequestAsync(this HttpClient client, CreateMemberRequest model)
{
return(client.PostAsJsonAsync(Base, model));
}
public async Task <CreateMemberResponse> CreateMember([FromBody] CreateMemberRequest request)
{
return(await _membetApiClient.CreateMemberAsync(request));
}
