public async Task <ActionResult <LoggedInUserModel> > Register([FromBody] RegisterAccountModel account)
{
var newUser = new User()
{
Email = account.Email,
UserName = account.Username,
YearOfBirth = account.YearOfBirth
};
var libraryId = _libraryService.Add(new LibraryDTO()
{
Name = newUser.Email + "_Library"
});
newUser.LibraryId = libraryId;
var creationResult = await _userManager.CreateAsync(newUser, account.Password);
if (!creationResult.Succeeded)
{
return(null);
}
var user = await _userManager.FindByEmailAsync(account.Email);
return(new LoggedInUserModel {
UserId = user.Id, Username = account.Username, LibraryId = libraryId
});
}
public Account Register(RegisterAccountModel param)
{
if (param == null)
{
return(null);
}
if (string.IsNullOrWhiteSpace(param.Email))
{
return(null);
}
string mail = param.Email.Trim().ToLower();
Account acc = context.Accounts.FirstOrDefault(d => d.Mail == mail);
if (acc != null)
{
return(acc);
}
acc = new Account();
acc.Id = GuidGen.NewGUID();
acc.Mail = mail;
acc.Password = param.Password;
acc.Frozened = false;
acc.ActivationTime = DateTime.UtcNow;
acc.ExpireTime = DateTime.UtcNow.AddYears(10);
acc.Type = "";
context.Accounts.Add(acc);
context.SaveChangesAsync();
return(acc);
}
public RegisterAccountModel GetNewAccount()
{
var registerModel = new RegisterAccountModel();
Uri baseUrl = new Uri(Constant.GET_NEW_ACCOUNT_URL);
IRestClient client = new RestClient(baseUrl);
IRestRequest request = new RestRequest("get", Method.GET);
IRestResponse response = client.Execute(request);
try
{
if (response.StatusCode == System.Net.HttpStatusCode.OK)
{
var content = response.Content;
if (content == "0")
{
return(new RegisterAccountModel());
}
registerModel = Newtonsoft.Json.JsonConvert.DeserializeObject <RegisterAccountModel>(content);
if (registerModel == null || registerModel.Id == 0)
{
return(new RegisterAccountModel());
}
}
}
catch
{
return(new RegisterAccountModel());
}
return(registerModel);
}
public async Task <UserRegisteredDto> RegisterAccount(RegisterAccountModel registerAccountModel)
{
if (string.IsNullOrWhiteSpace(registerAccountModel.Password))
{
throw new Exception("Password is required");
}
if (_dbContext.Users.Any(x => x.Username == registerAccountModel.Username))
{
throw new Exception("Username \"" + registerAccountModel.Username + "\" is already taken");
}
byte[] passwordHash, passwordSalt;
CreatePasswordHash(registerAccountModel.Password, out passwordHash, out passwordSalt);
var user = _mapper.Map <User>(registerAccountModel);
user.PasswordHash = passwordHash;
user.PasswordSalt = passwordSalt;
await _dbContext.Users.AddAsync(user);
await _dbContext.SaveChangesAsync();
var registeredUserDto = _mapper.Map <UserRegisteredDto>(user);
return(registeredUserDto);
}
public bool Create(RegisterAccountModel account)
{
if (string.IsNullOrEmpty(account.Username))
{
throw new ArgumentNullException(nameof(account.Username));
}
if (string.IsNullOrEmpty(account.Password))
{
throw new ArgumentNullException(nameof(account.Password));
}
if (string.IsNullOrEmpty(account.Pin))
{
throw new ArgumentNullException(nameof(account.Pin));
}
if (string.IsNullOrEmpty(account.Name))
{
throw new ArgumentNullException(nameof(account.Name));
}
if (account.Username.Length < 6 || account.Password.Length < 6 || account.Pin.Length < 4 || account.Pin.Length > 6)
{
return(false);
}
if (profileRepository.GetAccount(account.Username) != null)
{
return(false);
}
return(profileRepository.Create(account) != 0);
// acount username already exists return false otherwise else create
}
public bool Post([FromBody] RegisterAccountModel registerAccountModel)
{
if (registerAccountModel == null)
{
throw new ArgumentNullException(nameof(registerAccountModel));
}
return(accountService.Create(registerAccountModel));
}
public async Task <ActionResult> Register([FromBody] RegisterAccountModel accountModel)
{
var account = Map <Account>(accountModel);
var result = await _service.CreateAccountAsync(account);
if (!result.Sucess)
{
return(BadRequest(result.Errors));
}
return(new StatusCodeResult(StatusCodes.Status201Created));
}
public IActionResult Register([FromBody] RegisterAccountModel value)
{
if (ModelState.IsValid == false)
{
return(BadRequest(ModelState));
}
Account acc = accountMan.Register(value);
if (acc == null)
{
return(BadRequest());
}
return(Ok(acc));
}
public HttpResponseMessage Register([FromBody] RegisterAccountModel model)
{
try
{
if (ModelState.ContainsKey("model.DateOfBirth") && ModelState["model.DateOfBirth"].Errors.Any(x => x.Exception != null))
{
ModelState.AddModelError("DateOfBirth", WellknownResponseMessages.InvalidBirthDateFormat);
}
if (ModelState.IsValid)
{
if (string.IsNullOrEmpty(model.PAUMemberSource))
{
model.PAUMemberSource = PauHelper.PromotionSite;
}
var contactDetails = PauHelper.MapRegisterAccountModelToContactDetailEntity(model);
contactDetails.PasswordResetGuid = Guid.NewGuid().ToString();
_eloquaService.CreateOrUpdateContact(contactDetails);
return(Request.CreateResponse(HttpStatusCode.OK, new ResponseDTO
{
Success = true,
StatusCode = 200,
Message = WellknownResponseMessages.Success
}));
}
return(Request.CreateResponse(HttpStatusCode.BadRequest, new ResponseDTO
{
Success = false,
StatusCode = 400,
Message = WellknownResponseMessages.Falied,
Errors = ModelState.AllErrors()
}));
}
catch (Exception ex)
{
return(Request.CreateResponse(HttpStatusCode.InternalServerError, new ResponseDTO
{
Success = false,
StatusCode = 500,
Message = WellknownResponseMessages.Falied,
Errors = new List <string> {
ex.Message + "\r\n" + ex.StackTrace
}
}));
}
}
public ActionResult Register(RegisterAccountModel accountModel)
{
AccountModel acc = LoginUtils.RegisterAccount(accountModel);
if (acc != null)
{
String baseUrl = Request.Url.GetLeftPart(UriPartial.Authority);
if (!baseUrl.Contains("localhost"))
{
String[] urlPart = baseUrl.Split(':');
baseUrl = urlPart[0] + urlPart[1];
}
LoginUtils.SendConfirmationMail(acc, baseUrl);
return(RedirectToAction("Confirmation"));
}
return(RedirectToAction("Register"));
}
public async Task <bool> CreateAccount(RegisterAccountModel model, CancellationToken token = default)
{
var account = model.MapToAccount(_scopeControl.GetUserId());
if (account.IsInValid())
{
_scopeControl.AddNotifications(account.Notifications);
return(false);
}
if (token.IsCancellationRequested)
{
return(false);
}
_repository.Add(account);
return(await _repository.UnitOfWork.Commit(token));
}
public int Create(RegisterAccountModel registerAccountModel)
{
var query = @"INSERT INTO Profile (Username, Password)
VALUES (@Username, @Password);
SELECT CAST(SCOPE_IDENTITY() as int)";
int userId = dbConnection.Query <int>(query, new { registerAccountModel.Username, registerAccountModel.Password }).Single();
query = @"INSERT INTO [dbo].[Account]
([Id],[Name],[Number],[Balance] ,[Pin]) VALUES (@Id , @Name, @Number, @Balance ,@Pin,)";
dbConnection.Execute(query, new
{
Id = userId,
registerAccountModel.Name,
registerAccountModel.Number,
registerAccountModel.Balance,
registerAccountModel.Pin
});
return(userId);
}
public static AccountModel RegisterAccount(RegisterAccountModel registerAccountModel)
{
var adm = AccountDataMapper.GetAccountDataMapper();
if (adm.GetById(registerAccountModel.Username.ToLower()) == null)
{
AccountModel accountModel = new AccountModel();
accountModel.Username = registerAccountModel.Username.ToLower();
accountModel.Password = registerAccountModel.Password;
accountModel.Email = registerAccountModel.Email;
EncryptPassword(accountModel);
accountModel.Roles = new List <string>()
{
"User"
};
adm.Add(accountModel);
AddToConfirmList(accountModel);
return(accountModel);
}
return(null);
}
public async Task <User> RegisterUserAsync(RegisterAccountModel registerAccountModel)
{
// Generate new salt.
string salt = _securityProvider.GetNewSalt();
// Hash user's password.
string hashedSecret = _securityProvider.HashPassword(registerAccountModel.Password, salt);
var user = new User()
{
Email = registerAccountModel.Email,
FirstName = registerAccountModel.FirstName,
LastName = registerAccountModel.LastName,
ConsultantArea = new ConsultantArea()
{
Identifier = registerAccountModel.ConsultantAreaId
},
Location = new Location()
{
Identifier = registerAccountModel.LocationId
},
Salt = salt,
Password = hashedSecret
};
string accessToken = GenerateAccessToken(user);
user.AccessToken = accessToken;
try
{
await _dataAccessManager.UserDataAccessManager().Create(user);
}
catch (Exception)
{
throw;
}
return(user);
}
public async Task <IActionResult> Register([FromBody] RegisterAccountModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var appUser = new AppUser
{
UserName = model.Name,
Email = model.Email
};
if (!await _roleManager.RoleExistsAsync(model.Role))
{
return(BadRequest("Role doesn't exist"));
}
var result = await _userManager.CreateAsync(appUser, model.Password);
if (result.Succeeded)
{
await _userManager.AddToRoleAsync(appUser, model.Role);
}
else
{
foreach (var error in result.Errors)
{
ModelState.AddModelError(string.Empty, error.Description);
}
return(BadRequest(ModelState));
}
var token = await GenerateToken(appUser);
return(Ok(new { access_token = token }));
}
public async Task <IActionResult> Post([FromBody] RegisterAccountModel model)
{
var mapping = new Func <Account, Task <Account> >(async(entity) =>
{
if (string.IsNullOrWhiteSpace(model.OrganizationId))
{
model.OrganizationId = await _GetCurrentUserOrganId();
}
entity.Name = model.Name;
entity.Description = model.Description;
if (!string.IsNullOrWhiteSpace(model.Password))
{
entity.Password = Md5.CalcString(model.Password);
}
if (!string.IsNullOrWhiteSpace(model.DepartmentId))
{
entity.DepartmentId = model.DepartmentId;
}
entity.Mail = model.Mail;
entity.Frozened = false;
var t1 = DataHelper.ParseDateTime(model.ActivationTime);
var t2 = DataHelper.ParseDateTime(model.ExpireTime);
entity.ActivationTime = t1 != DateTime.MinValue ? t1 : DateTime.Now;
entity.ExpireTime = t2 != DateTime.MinValue ? t2 : DateTime.Now.AddYears(10);
entity.Type = await _GetAccountType(model.IsAdmin);
entity.Location = model.Location;
entity.Phone = model.Phone;
entity.Mail = model.Mail;
entity.OrganizationId = model.OrganizationId;
return(await Task.FromResult(entity));
});
return(await _PostRequest(mapping));
}
public async Task <IActionResult> Register(RegisterAccountModel registerAccount)
{
if (await UserExists(registerAccount.Username))
{
return(BadRequest("Username is taken!"));
}
using var hmac = new HMACSHA512();
var user = new AppUser
{
UserName = registerAccount.Username.ToLower(),
PasswordHash = hmac.ComputeHash(Encoding.UTF8.GetBytes(registerAccount.Password)),
PasswordSalt = hmac.Key
};
_context.Users.Add(user);
await _context.SaveChangesAsync();
return(Ok(new UserDTO {
Username = user.UserName,
Token = _tokenService.CreateToken(user)
}));
}
public async Task <UserRegisteredDto> RegisterAccount(RegisterAccountModel model)
{
return(await _userRepository.RegisterAccount(model));
}
public async Task <object> Register(RegisterAccountModel model)
{
var response = await ExecuteRequestAsync <RegisterAccountModel, object>("/api/auth/register", Method.POST, model);
return(response.Data);
}
public async Task <IActionResult> Register([FromBody] RegisterAccountModel model)
{
// check the phone is already registered or not
var isPhoneNumberExist = _userService.IsUserPhoneNumberExist(model.PhoneNumber);
if (isPhoneNumberExist)
{
return(Conflict("Phone number already exist"));
}
var result = await _authServices.Register(new RegisterModel
{
Username = model.Email,
Email = model.Email,
Password = model.Password,
CellPhone = model.PhoneNumber,
ConfirmPassword = model.Password
}, true, true);
if (result.Result.Succeeded)
{
AssignModelState();
var response = _userDetailService.Create(new UserDetailMediCoreModel
{
Id = 0,
FirstName = model.FirstName,
LastName = model.LastName,
UserId = result.UserId
});
if (!String.IsNullOrWhiteSpace(result.GeneratedToken))
{
var callbackUrl = Url.Action("ConfirmEmail", "Account", new { userId = result.UserId, code = result.GeneratedToken }, protocol: HttpContext.Request.Scheme);
var sendgrid = _sender.Create(SenderFactory.EMAIL);
string template = TemplateGenerator.GenerateTemplate(new TemplateOption
{
TemplateType = TemplateType.Activation,
TemplateFolderPath = String.Format("{0}/{1}/{2}", _hostingEnvironment.ContentRootPath, "Resources", "Template")
});
template = template.Replace("{CONFIRMATION_LINK}", callbackUrl);
template = template.Replace("{FIRST_NAME}", model.FirstName);
//send email confirmation to user
await sendgrid.SendAsync(model.Email, "Aktivasi", template);
}
if (!String.IsNullOrWhiteSpace(result.GenerateSMSToken))
{
var smsSender = _sender.Create(SenderFactory.SMS);
string template = TemplateGenerator.GenerateSMSTemplate(new TemplateOption
{
TemplateType = TemplateType.Activation,
TemplateFolderPath = String.Format("{0}/{1}/{2}", _hostingEnvironment.ContentRootPath, "Resources", "Template")
});
template = template.Replace("{TOKEN}", result.GenerateSMSToken);
await smsSender.SendAsync(model.PhoneNumber, "Aktivasi", template);
}
if (response.Success)
{
return(Ok(response.Item));
}
return(BadRequest(response.Message));
}
return(BadRequest(result.Result.Errors.FirstOrDefault()));
}
public Task <IActionResult> Register([FromBody] RegisterAccountModel model)
{
return(HandleCommand(model));
}
public static FinancialAccount MapToAccount(this RegisterAccountModel model, Guid aspNetUserId) =>
public RegisterAccount_HLCSite(RegisterAccountModel data)
{
this.data = data;
}
public RegisterViewModel(IViewModelNavigator viewModelNavigator, IAccountsRepository accountsRepository)
{
RegisterModel = new RegisterAccountModel();
ViewModelNavigator = viewModelNavigator;
AccountsRepository = accountsRepository;
}
