public SuccessfulMessageResponse Register([FromBody] AccountRegisterModel model)
{
var emailExist = _readOnlyRepository.First <Account>(account1 => account1.Email == model.Email);
if (emailExist == null)
{
if (AccountHelpers.IsAValidRegister(model))
{
//string passwordEncode = BCrypt.Net.BCrypt.HashPassword(model.Password, 12);
var account = _mappingEngine.Map <AccountRegisterModel, Account>(model);
account.IsArchived = false;
//account.Password = passwordEncode;
account.Password = model.Password;
Account accountCreated = _writeOnlyRepository.Create(account);
if (accountCreated != null)
{
AccountHelpers.SendMessage(model.Email, model.FirstName + " " + model.LastName, 1);
AccountHelpers.CreateOrganization(accountCreated);
return(new SuccessfulMessageResponse("You have been registered succesfully"));
}
}
throw new BadRequestException("The Account couldn't be created");
}
throw new BadRequestException("The Email is already registered");
}
public AuthenticationModel Login([FromBody] AccountLoginModel model)
{
//var account = _readOnlyRepository.First<Account>(account1 => account1.Email == model.Email
// && BCrypt.Net.BCrypt.Verify(model.Password, account1.Password));
var account = _readOnlyRepository.First <Account>(account1 => account1.Email == model.Email &&
account1.Password == model.Password);
if (account != null)
{
var session = AccountHelpers.CreateNewSession(account);
var sessionCreated = _writeOnlyRepository.Create(session);
if (sessionCreated != null)
{
return new AuthenticationModel()
{
Token = session.Token,
YourSessionExpireIn = session.Duration
}
}
;
}
throw new BadRequestException("User or Password is incorrect");
}
public SuccessfulMessageResponse CreateOrganization([FromBody] OrganizationCreationModel model, string token)
{
var session = IsTokenExpired(token);
var account = _readOnlyRepository.First <Account>(account1 => account1.Id == session.User.Id);
AccountHelpers.CreateOrganizationDefault(account, model.Title, model.Description);
return(new SuccessfulMessageResponse("Organization has been created"));
}
public SuccessfulMessageResponse ChangePasswordLink([FromBody] AccountForgottenPasswordModel model)
{
var account = _readOnlyRepository.First <Account>(account1 => account1.Email == model.Email);
if (account != null)
{
AccountHelpers.SendMessage(model.Email, account.FirstName + " " + account.LastName, 2);
}
throw new BadRequestException("Your email is not registered");
}
/* public void Seed()
* {
* IList<Account> accountList = Builder<Account>.CreateListOfSize(10).Build();
* foreach (Account account in accountList)
* {
* var boards = Builder<Board>.CreateListOfSize(2).Build();
* foreach (var board in boards)
* {
* _session.Save(board);
* }
* account.AddBoard(boards[0]);
* account.AddBoard(boards[1]);
* _session.Save(account);
* }
* var account1 = new Account();
*
*
* }*/
public void Seed()
{
var acount = new Board();
var accountList = (IList <Account>)acount.Members;
foreach (Account account in accountList)
{
account.AddBoard(AccountHelpers.CreateBoard(account));
_session.Save(account);
}
}
public async Task <IActionResult> Edit(UserView result)
{
if (!ModelState.IsValid)
{
return(View(result));
}
var user = await _userManager.FindByIdAsync(result.Id);
await _userManager.UpdateAsync(AccountHelpers.MergeViewWithModel(user, result));
return(RedirectToAction("List", "Account", new { Area = "Admin" }));
}
public async Task <IActionResult> Edit(string Id)
{
User user = null;
if (string.IsNullOrEmpty(Id))
{
user = await _userManager.GetUserAsync(User);
}
else
{
user = await _userManager.FindByIdAsync(Id);
}
return(View(AccountHelpers.ConvertToView(user)));
}
public SuccessfulMessageResponse AddBoardToOrganization([FromBody] AddBoardToOrganizationModel model, string token)
{
var session = IsTokenExpired(token);
var account = _readOnlyRepository.First <Account>(account1 => account1.Id == session.User.Id);
var organization = _readOnlyRepository.GetById <Organization>(model.Organization_id);
if (organization != null)
{
var board = _mappingEngine.Map <AddBoardToOrganizationModel, Board>(model);
board.Administrador = account;
board.AddLanes(AccountHelpers.CreateLane("Basic", 1));
board.AddLanes(AccountHelpers.CreateLane("Intermediate", 2));
board.AddLanes(AccountHelpers.CreateLane("Advanced", 3));
organization.AddBoard(board);
return(new SuccessfulMessageResponse("Organization has been created"));
}
throw new BadRequestException("Board could not be added");
}
public ActionResult Manage(ManageUserViewModel model)
{
ViewBag.HasLocalPassword = true;
ViewBag.ReturnUrl = Url.Action("Manage");
if (!ModelState.IsValid)
{
return(View(model));
}
var username = HttpContext.User.Identity.Name;
var account = _accountRepositoryAsync
.Query(x => x.Username == username)
.Include(r => r.Role)
.Select()
.SingleOrDefault();
if (account == null)
{
return(RedirectToAction("Manage", new { Message = ManageMessageId.Error }));
}
// validate first for old password
if (!AccountHelpers.ValidatePassword(model.OldPassword, account.Salt, account.Password))
{
return(RedirectToAction("Manage", new { Message = ManageMessageId.OldPasswordFailed }));
}
var newPassword = AccountHelpers.HashPassword(model.NewPassword);
account.Salt = newPassword.Salt;
account.Password = newPassword.HashPassword;
account.IsResetPassword = false;
account.ObjectState = ObjectState.Modified;
_accountRepositoryAsync.Update(account);
_unitOfWorkAsync.SaveChanges();
var role = account.Role.RoleType;
return(RedirectToAction("Index", IsAdminHr(role) ? "Employees" : "Document"));
}
public SuccessfulMessageResponse ChangePassword([FromBody] AccountForgottenPasswordModel model)
{
var account = _readOnlyRepository.First <Account>(account1 => account1.Email == model.Email && account1.Password == model.OldPassword);
if (account != null)
{
AccountHelpers.SendMessage(model.Email, account.FirstName + " " + account.LastName, 2);
if (model.NewPassword != model.ConfirmPassword)
{
throw new BadRequestException("Password and Confirm Password are different");
}
account.Password = model.NewPassword;
Account accountCreated = _writeOnlyRepository.Update(account);
if (accountCreated != null)
{
return(new SuccessfulMessageResponse("Your password has been changed"));
}
}
throw new BadRequestException("Your email or your password is incorrect");
}
public ActionResult UserEdit(Account model)
{
IEnumerable <SelectListItem> categories = _employeeRepositoryAsync.Query().Select().ToList()
.Select(s => new SelectListItem
{
Value = s.Id.ToString(),
Text = s.Fullname
});
ViewBag.EmployeeId = new SelectList(categories, "Value", "Text");
IEnumerable <SelectListItem> roles = _roleRepositoryAsync.Query().Select().ToList()
.Select(s => new SelectListItem
{
Value = s.Id.ToString(),
Text = s.RoleType
});
ViewBag.RoleId = new SelectList(roles, "Value", "Text");
if (ModelState.IsValid)
{
if (model.Id == 0)
{
var account = _accountRepositoryAsync
.Query(e => e.Username == model.Username)
.Include(r => r.Role)
.Select()
.SingleOrDefault();
if (account != null)
{
ModelState.AddModelError("Username", "Username already exists!");
}
else
{
var password = AccountHelpers.HashPassword(model.Password);
model.Salt = password.Salt;
model.Password = password.HashPassword;
_accountRepositoryAsync.Insert(model);
_unitOfWorkAsync.SaveChanges();
return(RedirectToAction("Index", "User"));
}
}
else
{
var account = _accountRepositoryAsync
.Query(e => e.Username == model.Username)
.Include(r => r.Role)
.Select()
.SingleOrDefault();
if (account != null)
{
if (account.Id != model.Id)
{
ModelState.AddModelError("Username", "Username already exists!");
}
}
else
{
if (model.Password != "")
{
var password = AccountHelpers.HashPassword(model.Password);
model.Salt = password.Salt;
model.Password = password.HashPassword;
}
_accountRepositoryAsync.Update(model);
_unitOfWorkAsync.SaveChanges();
return(RedirectToAction("Index", "User"));
}
}
}
return(View("Edit", model));
}
public async Task <IActionResult> CreateNewUser([FromBody] RegisterViewModel model)
{
if (ModelState.IsValid)
{
Regex regex = new Regex(@"[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?");
Match match = regex.Match(model.Email.Trim().ToLower());
if (!match.Success)
{
return(new JsonResult(new { code = 0, Err = "" }));
}
var user = new MyUsers
{
UserName = model.Email,
Email = model.Email,
PhoneNumber = model.PhoneNumber,
CodeConfirm = AccountHelpers.GenerateCodeConfirm(),
IsActivated = true,
LockoutEnabled = false,
CreatedDate = DateTime.Now,
DisplayName = model.FullName
};
var roleInDb = _db.AspNetRoles.Where(x => x.Id == Int32.Parse(model.RoleId)).FirstOrDefault();
var result = await _userManager.CreateAsync(user, model.Password).ConfigureAwait(true);
if (result.Succeeded)
{
var useraddress = new UserAddress
{
UserId = user.Id,
WardId = model.WardId,
ProvinceId = model.ProvinceId,
DistrictId = model.DistrictId,
PlaceDetails = model.PlaceDetail + _db.Ward.Find(model.WardId).WardName + "," + _db.Districts.Find(model.DistrictId).DistrictName + "," + _db.Provinces.Find(model.ProvinceId).ProvinceName
};
_db.UserAddress.Add(useraddress);
await _db.SaveChangesAsync();
#region Assign to Role, default Customer
var resultRole = new IdentityResult();
if (roleInDb == null)
{
if (!await _roleManager.RoleExistsAsync(SD.Customer))
{
await _roleManager.CreateAsync(new IdentityRole <int> {
Name = SD.Customer
});
}
resultRole = await _userManager.AddToRoleAsync(user, SD.Customer);
if (resultRole.Succeeded)
{
return(RedirectToAction(nameof(AccountManager)));
}
else
{
return(Json(new { code = 0, Err = "Không thể gán role cho user:"******"" }));
}
}
else
{
resultRole = await _userManager.AddToRoleAsync(user, roleInDb.Name);
if (resultRole.Succeeded)
{
Response.StatusCode = (int)HttpStatusCode.OK;
return(Json(new { code = 1 }));
}
else
{
Response.StatusCode = (int)HttpStatusCode.BadRequest;
return(Json(new { code = 0, Err = "Không thể gán role cho user:"******"" }));
}
}
#endregion
}
}
Response.StatusCode = (int)HttpStatusCode.BadRequest;
return(new JsonResult(new { code = 0, Err = "*Có lỗi xảy ra, vui lòng thử lại" }));
}
//[Route("/[controller]/SignUpPost")]
public async Task <IActionResult> SignUp(RegisterViewModel model)
{
ViewBag.Error = "";
if (ModelState.IsValid)
{
Regex regex = new Regex(@"[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?");
Match match = regex.Match(model.Email.Trim().ToLower());
if (!match.Success)
{
return(new JsonResult(new { code = 0, Err = "" }));
}
var checkUser = _db.AspNetUsers.Where(x => x.Email == model.Email).FirstOrDefault();
if (checkUser != null)
{
return(Json(new { code = 0 }));
}
var user = new MyUsers
{
UserName = model.Email,
Email = model.Email,
DisplayName = model.FullName,
LockoutEnabled = false,
IsActivated = false,
CreatedDate = DateTime.Now,
PhoneNumber = model.PhoneNumber,
CodeConfirm = AccountHelpers.GenerateCodeConfirm()
};
var result = await _userManager.CreateAsync(user, model.Password).ConfigureAwait(true);
//var result = CustomRepository.CreateUser(model.Email, model.PhoneNumber, model.Password, model.FullName, model.ProvinceId, model.DistricId, model.WardId, model.PlaceDetail);
if (result.Succeeded)
{
//var userFromDb = _db.AspNetUsers.Where(x => x.Email == model.Email).FirstOrDefault();
if (!await _roleManager.RoleExistsAsync(SD.Customer))
{
await _roleManager.CreateAsync(new IdentityRole <int> {
Name = SD.Customer
});
}
await _userManager.AddToRoleAsync(user, SD.Customer);
var userAddress = new UserAddress
{
UserId = user.Id,
WardId = model.WardId,
ProvinceId = model.ProvinceId,
DistrictId = model.DistrictId,
PlaceDetails = model.PlaceDetail + _db.Ward.Find(model.WardId).WardName + "," + _db.Districts.Find(model.DistrictId).DistrictName + "," + _db.Provinces.Find(model.ProvinceId).ProvinceName
};
_db.UserAddress.Add(userAddress);
await _db.SaveChangesAsync();
return(RedirectToAction("SignIn", "Account"));
}
else
{
ViewBag.Error = "Người dùng đã tồn tại";
return(RedirectToAction(nameof(SignUp)));
}
}
return(new JsonResult(new { code = 0, Err = "*Có lỗi xảy ra, vui lòng thử lại" }));
}
public AccountController()
{
aOpenRunSpace = new OpenRunSpace();
aAccountHelpers = new AccountHelpers();
aCommomHelpers = new CommomHelpers();
}
