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