public ActionResult OAuth(string code) { var req = new TokenRequest { client_id = WePayConfig.clientId, client_secret = WePayConfig.clientSecret, code = code, redirect_uri = GlobalVars.hostUrl + @"/Home/OAuth" }; var resp = new OAuth().Authorize(req); if (resp.Error != null) { ViewBag.Error = resp.Error.error + " - " + resp.Error.error_description; return(View("Status")); } var randomNum = new Random(1).Next(99999); var accRequest = new AccountCreateRequest { accessToken = resp.access_token, name = "testSDK " + randomNum, description = "test account for SDK demo", reference_id = "test" + randomNum }; var accResponse = new Account().Post(accRequest); ViewBag.Msg = "UserId:" + resp.user_id + " Token:" + resp.access_token;//.Substring(0,7)+"..."; ViewBag.Msg += "New Account#:" + accResponse.account_id; return(View("Status")); }
public async Task Handle_CreateAccountNonExistingAccountType_ShouldReturnBusinessException() { var handler = new AccountCreateHandler(Mapper, _mockRepo.Object); var request = new AccountCreateRequest { AccountTypeId = 1, CustomerId = 2 }; MockReturnNullAccount(); _mockRepo .Setup(repo => repo.Customer.FindById(It.Is <int>(c => c == request.CustomerId), It.IsAny <List <string> >())) .Returns(new Customer { Id = request.CustomerId.Value }) .Verifiable(); _mockRepo .Setup(repo => repo.AccountType.FindById(It.Is <int>(at => at == request.AccountTypeId), It.IsAny <List <string> >())) .Returns(null as AccountType) .Verifiable(); await Assert.ThrowsAsync <BusinessException>(() => handler.Handle(request, default)); _mockRepo.Verify(); }
public int Create(AccountCreateRequest createRequest) { int newEntryId = 0; using (SqlConnection connection = new SqlConnection(connectionString)) { string sqlQuery = "Account_Create"; using (SqlCommand command = new SqlCommand(sqlQuery, connection)) { command.CommandType = System.Data.CommandType.StoredProcedure; SqlParameter parameter = new SqlParameter(); parameter.ParameterName = "@Id"; parameter.SqlDbType = System.Data.SqlDbType.Int; parameter.Direction = System.Data.ParameterDirection.Output; //Alternatively command.Parameters.Add("@Id", SqlDBType.Int).Direction = ParameterDirection.Output; command.Parameters.Add(parameter); command.Parameters.AddWithValue("@Email", createRequest.Email); command.Parameters.AddWithValue("@Password", createRequest.Password); command.Parameters.AddWithValue("@ModifiedBy", createRequest.Password); connection.Open(); command.ExecuteNonQuery(); //Non query means no result sets expected newEntryId = (int)command.Parameters["@Id"].Value; connection.Close(); } } return(newEntryId); }
protected void btnCreateAccount_Click(object sender, EventArgs e) { var request = new AccountCreateRequest(); request.CustomerName = this.txtCustomerRef.Text; new ApplicationAccountService().CreateAccount(request); ShowAllAccounts(); }
public async Task <IActionResult> Create(AccountCreateRequest request) { var response = await _accountCreateService.Execute(request); if (!response.Success()) { return(BadRequest(response.GetNotifications())); } return(Ok()); }
public Task SendSMSAsync(AccountCreateRequest model) { throw new NotImplementedException(); //int code = new Random().Next(10000, 90000); //TwilioClient.Init(accountSid, authToken); //var to = new PhoneNumber(model.PhoneNumber); //var message = await MessageResource.CreateAsync(to, //from: new PhoneNumber("+14243292698"), //body: $"Your verification code: {code}"); }
/// <summary> /// ¸öÈËÕ˺Ŵ´½¨ /// http://open.esign.cn/docs/xy/%E6%8E%A5%E5%8F%A3%E6%96%87%E6%A1%A3/%E7%AD%BE%E7%BD%B2%E6%96%B9%E4%BF%A1%E6%81%AFAPI/%E4%B8%AA%E4%BA%BA%E8%B4%A6%E5%8F%B7%E5%88%9B%E5%BB%BA.html /// </summary> /// <returns></returns> public async Task <ApiResult <AccountCreateResponse> > AccountCreate( AccountCreateRequest request) { var result = await Http.PostAsync < AccountCreateResponse, AccountCreateRequest>( $"{Option.BaseUrl}/v1/accounts/createByThirdPartyUserId", request ); return(result); }
public async Task <IActionResult> Create([FromForm] AccountCreateRequest request) { if (request == null || string.IsNullOrWhiteSpace(request.UserName) || string.IsNullOrWhiteSpace(request.Password) || string.IsNullOrWhiteSpace(request.DisplayName)) { return(BadRequest()); } var user = await _userManager.FindByNameAsync(request.UserName); if (user == null) { user = new WingTipUser { MigrationStatus = (int)MigrationStatus.New, UserName = request.UserName }; var displayNameClaim = new IdentityUserClaim <string> { ClaimType = DisplayNameClaimType, ClaimValue = request.DisplayName }; user.Claims.Add(displayNameClaim); if (!string.IsNullOrEmpty(request.PlayerTag)) { var playerTagClaim = new IdentityUserClaim <string> { ClaimType = PlayerTagClaimType, ClaimValue = request.PlayerTag }; user.Claims.Add(playerTagClaim); } // If the user does not exist, then creates the user in the SQL identity store with the Azure Active Directory-managed // password. await _userManager.CreateAsync(user, request.Password); } else { // If the user does exist, then update the password for the user in the SQL identity store to the Azure Active Directory-managed // password. await _userManager.SetPasswordAsync(user, request.Password); user.MigrationStatus = (int)MigrationStatus.MigratedWithPassword; await _userManager.UpdateAsync(user); } return(Ok(user)); }
public async Task <ActionResult <CustomerModel> > Create([FromBody, Required] AccountCreateRequest request) { try { var result = await _mediator.Send(request); return(CreatedAtAction(nameof(Create), result)); } catch (BusinessException businessException) { return(Conflict(new { message = businessException.Message })); } }
public IHttpActionResult CreateAccount([FromBody] AccountCreateRequest model) { var ret = Success(); try { var accountNo = _service.CreateAccount(model.firstName, model.lastName, model.contact, model.title, model.amount, model.notes); ret = (accountNo > 0) ? Success(accountNo) : Error("Account could not be created"); } catch (Exception ex) { ret = Error(ex); } return(ret); }
public async Task <IActionResult> Create([FromBody] AccountCreateRequest req) { //User with same email already exists if (await _userService.CheckIfUserExists(req.email_address.Trim())) { return(BadRequest(new { message = "User with same email already exists." })); } var user = await _userService.Create(req); if (user == null) { return(BadRequest(new { message = "Network error. User could not be created." })); } return(Created(string.Empty, user)); }
//private RepositoryPlaceholder _repo = new RepositoryPlaceholder(); public OpResult CreateAccount(AccountCreateRequest dto) { Account account = new Account { UserName = dto.Username, Password = dto.Password, Email = dto.Email, EmailVerificationCode = Guid.NewGuid().ToString("N") }; AccountValidator validator = new AccountValidator(); var validationResult = validator.Validate(account); if (!validationResult.IsValid) { return(OpResult.FailureResult(validationResult.Errors.Select(e => e.ErrorMessage).ToList())); } var existingAccount = _repo.GetFirst <Account>(a => a.UserName == dto.Username || a.Email == dto.Email); if (existingAccount != null) { if (existingAccount.UserName == dto.Username) { return(OpResult.FailureResult("username already exists")); } if (existingAccount.Email == dto.Email) { return(OpResult.FailureResult("eMail already exists")); } } var salt = EncryptionUtil.GenerateRandomSaltString(); var hashedPass = EncryptionUtil.GeneratePBKDF2Hash(dto.Password, salt); account.PasswordHash = hashedPass; account.PasswordSalt = salt; _repo.Create <Account>(account); _repo.Save(); _emailService.SendEmail(_configService.GetFromEmailAddress(), _configService.GetFromEmailName(), account.Email, "Verify Account", "Your verification code is " + account.EmailVerificationCode); return(OpResult.SuccessResult()); }
public async Task <AccountResponse> Create(AccountCreateRequest req) { var user = new AccountModel() { id = Guid.NewGuid(), first_name = req.first_name, last_name = req.last_name, password = BCrypt.Net.BCrypt.HashPassword(req.password), email_address = req.email_address, account_created = DateTime.Now, account_updated = DateTime.Now }; _context.Account.Add(user); await _context.SaveChangesAsync(); return(_mapper.Map <AccountResponse>(user.WithoutPassword())); }
public async Task <ResponseBase> Post([FromBody] AccountCreateRequest account) { if (!await registerTokens.IsCorrectRegisterToken(account.Email, account.AccessToken)) { return(ResponseStatusCode.IncorrectAccessToken); } var user = mapper.Map <User>(account); user.EmailConfirmed = true; var result = await UserManager.CreateAsync(user, account.Password); if (result.Succeeded) { await registerTokens.RemoveToken(account.Email); } return(ResponseStatusCode.OK); }
public async Task CreateUsers_UnitTest() { Random r = new Random(); var req = new AccountCreateRequest { first_name = "John", last_name = "Smith", password = "******", email_address = "john.smith" + r.Next(1, 9999) + "@example.com" }; var data = new List <AccountModel> { new AccountModel { first_name = "John", last_name = "Smith", email_address = "john.smith" + r.Next(1, 9999) + "@example.com" } }.AsQueryable(); var mockSet = new Mock <DbSet <AccountModel> >(); mockSet.As <IQueryable <AccountModel> >().Setup(m => m.Provider).Returns(data.Provider); mockSet.As <IQueryable <AccountModel> >().Setup(m => m.Expression).Returns(data.Expression); mockSet.As <IQueryable <AccountModel> >().Setup(m => m.ElementType).Returns(data.ElementType); mockSet.As <IQueryable <AccountModel> >().Setup(m => m.GetEnumerator()).Returns(data.GetEnumerator()); var mockDomain = new Mock <dbContext>(); mockDomain.Setup(c => c.Account).Returns(mockSet.Object); var expected = new AccountResponse(); var mockMapper = new Mock <IMapper>(); mockMapper.Setup(x => x.Map <AccountResponse>(It.IsAny <AccountModel>())).Returns(expected); var service = new UserService(mockDomain.Object, mockMapper.Object); var controller = new UserController(service); var actionResult = await controller.Create(req); _console.WriteLine("CreateUsers_UnitTest {0}", actionResult); Assert.IsType <CreatedResult>(actionResult); }
public IHttpActionResult CreateAccount([FromBody] AccountCreateRequest dto) { try { var result = _service.CreateAccount(dto); if (result.Success) { return(Json(ApiResult.Success())); } else { return(Json(ApiResult.Failure(result.Errors))); } } catch (Exception ex) { return(Json(ApiResult.Failure("Account creation Failed"))); } }
public HttpResponseMessage Create(AccountCreateRequest createRequest) { // validate the data that the client sent //1. Did they send us anything at all? if (createRequest == null) { ModelState.AddModelError("", "The request data is empty!"); //The emtpy string means the error applies to the whole request. } //2. check wheteher there aren any model errors. if (!ModelState.IsValid) { return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, ModelState)); } //3. If we got this far, then the data is valid and we should call the service. int newId = accountService.Create(createRequest); return(Request.CreateResponse(HttpStatusCode.OK, newId)); }
public async Task Create_NonExistingAccount_ShouldReturnCreatedAccount() { var request = new AccountCreateRequest { AccountTypeId = 1, CustomerId = 1 }; var createdAccount = GetTestAccount(99, request.CustomerId.Value); _mockMediator .Setup(m => m.Send(It.Is <AccountCreateRequest>(a => a.CustomerId == request.CustomerId && a.AccountTypeId == request.AccountTypeId), default)) .ReturnsAsync(createdAccount) .Verifiable(); var controller = new AccountController(Mapper, _mockMediator.Object); var result = await controller.Create(request); _mockMediator.Verify(); Assert.True(typeof(CreatedAtActionResult) == result.Result.GetType()); }
public IActionResult Create([FromBody] AccountCreateRequest account) { if (!ModelState.IsValid) { return(BadRequest(ModelState.GetReadableString())); } if ((account.Role == Role.Administrator || account.Role == Role.Supervisor) && !User.IsInRole(nameof(Role.Administrator))) { return(StatusCode(403, "Neither administrative nor supervisory accounts may be created by non-Administrative users.")); } if (AccountNameExists(account.Name)) { return(Conflict($"A user named '{account.Name}' already exists.")); } var accountRecord = new Account() { Id = Guid.NewGuid(), Name = account.Name, Role = account.Role, PasswordHash = Utility.ComputeSHA512Hash(account.Password), PasswordResetRequired = true, CreationDate = DateTime.UtcNow, CreationById = User.GetId(), LastUpdateDate = DateTime.UtcNow, LastUpdateById = User.GetId(), }; try { var createdAccount = AccountRepository.Create(accountRecord); return(StatusCode(201, MapAccountResponseFrom(createdAccount))); } catch (Exception ex) { throw new Exception($"Error creating Account for {account.Name}: {ex.Message}", ex); } }
public async Task <AccountResponse> Create(AccountCreateRequest model) { // validate if (await _accountRepository.FindByEmail(model.Email) != null) { throw new Exception($"Email '{model.Email}' is already registered"); } // map model to new account object var account = _mapper.Map <Account>(model); account.Created = DateTime.UtcNow; account.Verified = DateTime.UtcNow; // hash password account.PasswordHash = BC.HashPassword(model.Password); // save account await _accountRepository.Add(account); return(_mapper.Map <AccountResponse>(account)); }
public AccountCreateResponse CreateAccount(AccountCreateRequest request) { var response = new AccountCreateResponse(); response.Success = true; try { var account = new Account { CustomerRef = request.CustomerName }; _accountRepository.Add(account); } catch { response.Success = false; response.Message = "Unexpected error"; } return(response); }
public async Task <ActionResult <AccountCreateResponse> > Create([FromBody] AccountCreateRequest request) { request.EnsureValidation(); AccountCreateArgs accountCreateArgs = new AccountCreateArgs { AccountCode = request.Code, AccountName = request.Name, AccountDescription = request.Description, ParentAccountId = request.ParentId, DebitOrCredit = request.DebitOrCredit, IsHidden = request.IsHidden }; IMediator mediator = Factory.Resolve <IMediator>(); AccountCreateResult accountCreateResult = await mediator.Send(new AccountCreateCommand(accountCreateArgs)); accountCreateResult.EnsureSuccess(); AccountCreateResponse response = new AccountCreateResponse { IsSuccess = true }; return(Ok(response)); }
public void OnCreateClicked() { var username = usernameLabel.text; var password = passwordLabel.text; var confirm = confirmLabel.text; var request = new AccountCreateRequest(); request.username = username; request.password = password; request.confirm = confirm; var serviceClient = new SJServiceClient <AccountCreateRequest, AccountCreateResponse>(); serviceClient.Post(AccountCreateRequest.uri, request, (response) => { MainUI.s_Instance.ShowInfoPopup("계정 생성 완료."); MainUI.s_Instance.ShowLoginPanel(); }, Error); }
public AccountResponse Create(AccountCreateRequest model) { // validate if (_context.Accounts.Any(x => x.Email == model.Email)) { throw new AppException($"Email '{model.Email}' is already registered"); } // map model to new account object var account = _mapper.Map <Account>(model); account.Created = DateTime.UtcNow; account.Verified = DateTime.UtcNow; // hash password account.PasswordHash = BC.HashPassword(model.Password); // save account _context.Accounts.Add(account); _context.SaveChanges(); return(_mapper.Map <AccountResponse>(account)); }
public async Task <IActionResult> Registration(AccountCreateRequest request) { var newUser = await _accountManager.AddUserAsync(request.Email, request.Password, request.FirstName, request.LastName); if (newUser) { var identity = await _accountManager.GetIdentityAsync(request.Email, request.Password); var jwt = _accountManager.GetToken(identity); var response = new { access_token = jwt, username = identity.Name }; return(Json(response)); } else { return(BadRequest(new { errorText = "Thу user with this e-mail is already registered" })); } }
public async Task Handle_CreateNewAccount_ShouldReturnNewAccount() { var handler = new AccountCreateHandler(Mapper, _mockRepo.Object); var request = new AccountCreateRequest { AccountTypeId = 1, CustomerId = 2 }; MockReturnNullAccount(); _mockRepo .Setup(repo => repo.Customer.FindById(It.Is <int>(c => c == request.CustomerId), It.IsAny <List <string> >())) .Returns(new Customer { Id = request.CustomerId.Value }) .Verifiable(); _mockRepo .Setup(repo => repo.AccountType.FindById(It.Is <int>(at => at == request.AccountTypeId), It.IsAny <List <string> >())) .Returns(new AccountType { Id = 1 }) .Verifiable(); _mockRepo .Setup(repo => repo.Account.Create(It.Is <Account>(a => a.AccountTypeId == request.AccountTypeId && request.CustomerId == a.CustomerId))) .Callback <Account>(a => a.Id = 4) .Verifiable(); var result = await handler.Handle(request, default); _mockRepo.Verify(); Assert.IsType <AccountModel>(result); Assert.Equal(4, result.Id); }
public async Task <ActionResult <AccountResponse> > CreateAccount([FromBody] AccountCreateRequest accountToCreate) { // map request to entity var account = _mapper.Map <Account> (accountToCreate); // Role must be student/instructor only if (account.AccountRole == Role.Student) { account.Student = new Student() { Account = account } } ; else if (account.AccountRole == Role.Instructor) { account.Instructor = new Instructor() { Account = account } } ; else { return(BadRequest()); } // save _context.Accounts.Add(account); await _context.SaveChangesAsync(); // return response at location var accountResponse = _mapper.Map <AccountResponse> (account); return(CreatedAtAction(nameof(GetAccount), new { accountId = accountResponse.Id }, accountResponse)); }
public async Task <ActionResult <AccountResponse> > Create(AccountCreateRequest model) { var account = await _accountService.Create(model); return(Ok(account)); }
public ActionResult <AccountResponse> Create(AccountCreateRequest model) { var account = _accountService.Create(model); return(Ok(account)); }
public async Task <IActionResult> Create([FromBody] AccountCreateRequest request) { if (!ModelState.IsValid) { return(new StatusCodeResult((int)HttpStatusCode.BadRequest)); } try { //check if account already exists var userName = request.Email.Substring(0, request.Email.IndexOf("@", StringComparison.Ordinal)); var accountExists = _accountRepository .GetByUserName(userName) != null; if (!accountExists) { //generate a new api key var apiKey = "ARNIS-" + Guid.NewGuid().ToString().ToUpper().Substring(0, 4); //create client account var account = new Account { UserName = userName, Email = request.Email, ApiKey = apiKey }; await _accountRepository.Create(account); //create default workspace var workspace = new Workspace { AccountId = account.Id, Name = "default", Description = "Default workspace", Owners = new List <string> { account.UserName }, Solutions = new List <Solution>() }; await _workspaceRepository.Create(workspace); string baseUri = "http://arnis.azurewebsites.net"; string accountLocation = $"{baseUri}/{account.UserName.ToLower()}"; string workspaceLocation = $"{baseUri}/{account.UserName.ToLower()}/{workspace.Name.ToLower()}"; HttpContext.Response.StatusCode = (int)HttpStatusCode.OK; HttpContext.Response.Headers.Add("Location", accountLocation); var responseDto = new { userName = request.UserName, email = request.Email, apiKey, accountUri = accountLocation, workspaceUri = workspaceLocation }; return(new OkObjectResult(responseDto)); } else { HttpContext.Response.StatusCode = (int)HttpStatusCode.BadRequest; return(new ObjectResult(new { errorMessage = "Username already exists." })); } } catch (Exception ex) { HttpContext.Response.StatusCode = (int)HttpStatusCode.InternalServerError; return(new ObjectResult(new { errorMessage = ex.Message, errorDetails = ex.ToString() })); } }