public async Task <IActionResult> RegisterAsync([FromBody] AccountRegisterRequest request, [FromServices] INotifier <UserCheckin> notifier)
{
try
{
var profile = new UserProfile
{
User = new User
{
Name = request.Email,
CreatedOver = request.UIClientId
},
Email = request.Email,
DisplayName = request.Email,
CompanyName = request.Company,
ManagerName = request.ManagerName,
};
var userCheckin = await _repo.RegisterAccountAsync(profile);
await notifier.CreateNotificationAsync(userCheckin);
await _repo.MarkUserCheckinNotifiedAsync(userCheckin);
return(Ok());
}
catch (UserAccountException ex)
{
return(BadRequest(ex.Message));
}
catch (Exception ex)
{
_logger.LogError(ex, $"error Register {this.GetType().Name}");
return(InternalServerError(ex));
}
}
public Account(AccountRegisterRequest request)
{
Name = request.Name;
Username = request.Username;
Email = request.Email;
Createdon = DateTime.Now;
Match = new HashSet <Match>();
}
public async Task <AccountRegisterResponse> Register(AccountRegisterRequest model, CancellationToken cancellationToken)
{
var user = new IdentityUser(model.Login);
var result = await _userManager.CreateAsync(user, model.Password);
if (!result.Succeeded)
{
return new AccountRegisterResponse()
{
IdentityResult = result
}
}
;
cancellationToken.ThrowIfCancellationRequested();
await _signInManager.SignInAsync(user, true);
if (model.ApplicationRoles == IdentityRoles.Administrator)
{
await _userManager.DeleteAsync(user);
return(new AccountRegisterResponse {
IdentityResult = IdentityResult.Failed(new IdentityError
{
Code = "IdentityRoleError",
Description = "Can't registered with role Administrator"
})
});
}
await _roleManager.CreateAsync(new IdentityRole(model.ApplicationRoles.Humanize()));
await _userManager.AddToRoleAsync(user, model.ApplicationRoles.Humanize());
switch (model.ApplicationRoles)
{
case IdentityRoles.Student:
await _context.Students.AddAsync(new StudentModel
{
Id = Guid.NewGuid(),
FirstName = model.FirstName,
LastName = model.LastName,
IdentityUser = user,
StudyGroupModel = await _context.StudyGroups.FirstOrDefaultAsync(w => w.Name == model.GroupName,
cancellationToken: cancellationToken) ??
throw new NullReferenceException()
}, cancellationToken);
_context.SaveChanges();
break;
public async Task <IActionResult> Register(
[FromBody] AccountRegisterRequest request)
{
var resultCustomer = await _customer.GetCustomerbyIDAsync(request.CustomerID);
if (resultCustomer.Code == ResultCodes.Success)
{
var resultAccount = await _account.RegisterAsync(resultCustomer.Data.CustomerId, request.Options);
return(Json(resultAccount));
}
else
{
return(Json(resultCustomer));
}
}
public IActionResult RegisterAccount([FromBody] AccountRegisterRequest accountRequest)
{
if (accountRequest == null)
{
return(BadRequest());
}
var resp = m_AccountMediator.RegisterAccount(accountRequest);
if (resp.StatusCode == (int)HttpStatusCode.OK)
{
return(Ok(resp));
}
else
{
return(BadRequest(resp));
}
}
public BaseApiResponse RegisterAccount(AccountRegisterRequest accountRequest)
{
var validUsername = ValidUsername(accountRequest.Username);
if (!validUsername)
{
return(new BaseApiResponse(HttpStatusCode.BadRequest, "Please enter a valid username."));
}
//check if username exists
var usernameExists = UsernameTaken(accountRequest.Username);
if (usernameExists)
{
return(new BaseApiResponse(HttpStatusCode.BadRequest, $"Username {accountRequest.Username} is already taken."));
}
var validPassword = ValidPassword(accountRequest.Password);
if (!validPassword)
{
return(new BaseApiResponse(HttpStatusCode.BadRequest, "Please enter a valid password"));
}
var passwordSaltBytes = PasswordHash.ArgonGenerateSalt();
var passwordSalt = System.Text.Encoding.ASCII.GetString(passwordSaltBytes);
var saltedPassword = accountRequest.Password + passwordSalt;
var passwordHash = PasswordHash.ArgonHashString(saltedPassword, PasswordHash.StrengthArgon.Interactive);
var newAccount = new PUAccountRecord
{
Username = accountRequest.Username,
PasswordSalt = passwordSalt,
PasswordHash = passwordHash
};
m_AccountContext.Accounts.Add(newAccount);
m_AccountContext.SaveChanges();
return(new ApiOkResponse());
}
public async Task <IActionResult> Register(
[FromBody] AccountRegisterRequest model,
CancellationToken cancellationToken)
{
var response = await _accountService.Register(model, cancellationToken);
if (!response.IdentityResult.Succeeded)
{
return(BadRequest(response.IdentityResult.Errors));
}
//TODO: вынести в отдельный мидлвар
HttpContext.Response.Cookies.Append(".AspNetCore.Application.Token", response.Token,
new CookieOptions
{
HttpOnly = true,
MaxAge = TimeSpan.FromDays(7),
});
return(Ok(response));
}
public bool Create(RegisterModels model, ref string msg)
{
try
{
AccountRegisterRequest paraBody = new AccountRegisterRequest();
// Hash password
model.CustomerDetail.Password = CommonHelper.GetSHA512(model.CustomerDetail.Password);
paraBody.CustomerDetail = model.CustomerDetail;
paraBody.Merchant = model.MerchantDetail;
NSLog.Logger.Info("ClientSideToRegister Request: ", paraBody);
//====================
var result = (NSApiResponse)ApiResponse.Post <NSApiResponse>(Commons.ClientSideToRegister, null, paraBody);
if (result != null)
{
if (result.Success)
{
return(true);
}
else
{
msg = result.Message;
return(false);
}
}
else
{
//NSLog.Logger.Info("AccountRegisterCreate", result);
return(false);
}
NSLog.Logger.Info("ClientSideToRegister Result", result);
}
catch (Exception e)
{
NSLog.Logger.Error("ClientSideToRegister_Fail", e);
return(false);
}
}
public bool ResellerRegisCustomer(AccountRegisterRequest paraBody, ref string CustomerIDreturn, ref string MerchantIDreturn, ref string msg)
{
try
{
paraBody.CustomerDetail.Password = CommonHelper.GetSHA512(paraBody.CustomerDetail.Password);
paraBody.CustomerDetail.ID = string.IsNullOrEmpty(paraBody.CustomerID) ? null : paraBody.CustomerID;
paraBody.Merchant.ID = string.IsNullOrEmpty(paraBody.MerchantID) ? null : paraBody.MerchantID;
NSLog.Logger.Info("ResellerRegisCustomer Request", paraBody);
var result = (NSApiResponse)ApiResponse.Post <NSApiResponse>(Commons.ClientSideToRegister, null, paraBody);
NSLog.Logger.Info("ResellerRegisCustomer Response", result);
if (result != null)
{
if (result.Success)
{
dynamic data = result.Data;
CustomerIDreturn = data["CustomerID"];
MerchantIDreturn = data["MerchantID"];
return(true);
}
else
{
msg = result.Message;
NSLog.Logger.Info("OrderDelete", result.Message);
return(false);
}
}
else
{
NSLog.Logger.Info("OrderDelete", result);
return(false);
}
}
catch (Exception e)
{
NSLog.Logger.Error("OrderDelete_Fail", e);
return(false);
}
}
public async Task <MessageOutputBase> Register([FromBody] AccountRegisterRequest request)
{
MessageOutputBase result = null;
request.Ip = GetClientIp();
await Execute(flow =>
{
flow.StartRegisterFlow()
.Add <AccountRegisterStep>();
flow.
When <AccountRegisterStep, AccountRegisterParams>(register =>
{
result = register.Response;
});
}, request,
error =>
{
result = error;
});
return(result);
}
public async Task <IActionResult> Post([FromBody] AccountRegisterRequest request)
{
Account response = await _services.Register(request);
return(Ok(response));
}
public async Task <AccountRegisterResponse> Register(AccountRegisterRequest request)
{
var response = await Mediator.Send(request);
return(response);
}
