public async Task <IActionResult> CreateUser([FromBody] UserCreateRequestModel user)
{
if (user == null)
{
return(BadRequest());
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var existingAccount = await _userService.GetAsync(user.AccountNumber);
if (existingAccount != null)
{
return(GetBadRequest(user, $"User with account number {user.AccountNumber} already exists."));
}
var userDto = Mapper.Map <UserCreateModel>(user);
var newUserId = await _userService.AddAsync(userDto);
return(await GetCreatedRequestModel(user, newUserId, "GetUser"));
}
public UserRequestModel InsertUser([FromBody] UserCreateRequestModel user)
{
try
{
_ = _userDataService.InsertUser(user).Result;
}
catch (Exception e)
{
UserRequestModel model = new UserRequestModel();
if (e.Message.Contains("Incorrect Data!"))
{
Response.StatusCode = 400;
model.Status = (System.Net.HttpStatusCode) 400;
model.ErrorMessage = e.Message;
return(model);
}
else if (e.Message.Contains("already exist"))
{
Response.StatusCode = 409;
model.Status = (System.Net.HttpStatusCode) 409;
model.ErrorMessage = e.Message;
return(model);
}
else
{
Response.StatusCode = 500;
model.Status = (System.Net.HttpStatusCode) 500;
model.ErrorMessage = e.Message;
return(model);
}
}
Response.StatusCode = 200;
return(new UserRequestModel());
}
public async Task <ActionResult <UserModel> > Initialize([FromBody] UserCreateRequestModel user)
{
var usersCount = await database.Count <UserModel>();
if (usersCount > 0L)
{
return(BadRequest(new ErrorModel(400, "already initialized")));
}
if (!user.IsValidUsername())
{
return(BadRequest(new ErrorModel(400, "invalid username")));
}
if (!user.IsValidPassword())
{
return(BadRequest(new ErrorModel(400, "invalid new password")));
}
user.AfterCreate();
user.LastLogin = default;
user.IsAdmin = true;
user.DisplayName = user.DisplayName.IsNullOrEmpty() ? user.UserName : user.DisplayName;
user.PasswordHash = hasher.Create(user.Password);
await database.Put(user);
var resUser = new UserModel(user);
return(Created("user", resUser));
}
public async Task <int> InsertUser(UserCreateRequestModel user)
{
Regex regex = new Regex(@"^[\w-\.]+@([\w-]+\.)+[\w-]{2,4}$");
Match match = regex.Match(user.Email);
if (!match.Success)
{
throw new BadRequestException("Incorrect Data! Email must have '@' and after that <string>.<string>, e.g. [email protected]");
}
validateString(user.Username, "Incorrect Data! Username must between " + _minCharValidationUsername + " and " + _maxCharValidationUsername + " symbols!");
validateString(user.Username, "Incorrect Data! Password must between " + _minCharValidationPassword + " and " + _maxCharValidationPassword + " symbols!");
if (!user.Password.Contains(user.Password2))
{
throw new BadRequestException("Incorrect Data! Entered Password and Confirm password do not match");
}
if (await IsUserExistingByName(user.Username))
{
throw new AlreadyExistException("User with username: "******" already exist!");
}
using var conn = await _database.CreateConnectionAsync();
string hashedPassword = BCrypt.HashPassword(user.Password);
var parameters = new
{
Username = user.Username,
Email = user.Email,
Password = hashedPassword,
};
return(await conn.ExecuteAsync("INSERT INTO [USER](Username, Email, Password) VALUES (@Username, @Email, @Password); SELECT SCOPE_IDENTITY();", parameters));
}
public async Task <IHttpActionResult> UpdateUser(UserCreateRequestModel model)
{
model.ModifiedBy = User.Identity.GetUserId();
model.Modified = DateTime.Now;
var isInSystemAdminRole = User.IsInRole(StaticRoles.SystemAdmin.Name);
if (isInSystemAdminRole)
{
return(Ok(await _service.UpdateUserAsync(model)));
}
if (string.IsNullOrWhiteSpace(model.TenantId))
{
model.TenantId = User.Identity.GetTenantId();
model.TenantName = User.Identity.GetTenantName();
model.CompanyId = User.Identity.GetCompanyId();
}
else
{
var tenant = await _tenantProvider.GetTenantAsync(model.TenantId);
model.TenantName = tenant.TenancyName;
model.CompanyId = _companyProvider.GetAll().FirstOrDefault(x => x.TenantId == tenant.Id)?.Id;
}
return(Ok(await _service.UpdateUserAsync(model)));
}
public async Task <IActionResult> UpdateUser(Guid id, [FromBody] UserCreateRequestModel user)
{
if (user == null)
{
return(BadRequest());
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var userExists = await _userService.ExistsAsync(id);
if (!userExists)
{
return(GetNotFound());
}
var userDto = Mapper.Map <UserCreateModel>(user);
await _userService.UpdateAsync(id, userDto);
return(NoContent());
}
public async Task <ActionResult <UserModel> > Create([FromBody] UserCreateRequestModel user)
{
// Validation is done by MVC request model.
//if (!user.IsValidUsername())
// return BadRequest(new ErrorModel(400, "invalid username"));
//if (!user.IsValidPassword())
// return BadRequest(new ErrorModel(400, "invalid new password"));
if (await database.GetUserByUserName(user.UserName) != null)
{
return(BadRequest(new ErrorModel(400, "username already taken")));
}
user.AfterCreate();
user.LastLogin = default;
user.DisplayName = user.DisplayName.IsNullOrEmpty() ? user.UserName : user.DisplayName;
user.PasswordHash = hasher.Create(user.Password);
// TODO: Replace with mail confirmation
user.EmailAddress = null;
await database.Put(user);
var resUser = new UserModel(user);
return(Created("user", resUser));
}
public ActionResult <CommonResponeModel> Create(UserCreateRequestModel model)
{
if (userRepository.IsExistUsername(model.Username))
{
string message = UserMessageGlobal.ExistUsername;
Result = new ErrorResult(ActionType.Login, message);
}
else
{
var databaseObject = model.MapTo <User>();
databaseObject.InitBeforeSave(RequestUsername, InitType.Create);
databaseObject.InitDefault();
databaseObject.SetPassword();
int result = userRepository.Insert(databaseObject);
if (result > 0)
{
Result = new SuccessResult(ActionType.Insert, AppGlobal.CreateSucess);
Data = databaseObject;
}
else
{
Result = new ErrorResult(ActionType.Insert, AppGlobal.CreateError);
Data = databaseObject;
}
}
return(GetCommonRespone());
}
private UserModel fromDtoToUser(UserCreateRequestModel userRequestModel)
{
UserModel userModel = new UserModel();
userRequestModel.Username = userModel.Username;
userRequestModel.Email = userModel.Email;
userRequestModel.Password = userModel.Password;
return(userModel);
}
public string CreateTenantAdminUser(TenantViewModel model, string tenantId, string companyId, string branchId, string adminRoleId)
{
string employeeId = CreateTenantAdminEmployee(model, tenantId, companyId, branchId);
var userId = Guid.NewGuid().ToString();
var adminUser = new UserCreateRequestModel
{
Id = userId,
FirstName = model.FirstName,
LastName = model.LastName,
Email = model.Email,
UserName = model.Email,
PhoneNumber = model.PhoneNumber,
PasswordHash = model.PasswordHash,
RetypePassword = model.RetypePassword,
SecurityStamp = Guid.NewGuid().ToString(),
RoleId = !string.IsNullOrWhiteSpace(adminRoleId) ? adminRoleId : _roleManager.GetByName(StaticRoles.Admin.Name)?.Id,
//EmailConfirmationCode = emailConfirmationCode,
//PhoneConfirmationCode = phoneNumberConfirmationCode,
TenantId = tenantId,
TenantName = model.TenancyName,
CompanyId = companyId,
BranchId = branchId,
EmployeeId = employeeId,
IsActive = true,
CreatedBy = null,
Created = DateTime.Now,
IsShouldChangedPasswordOnNextLogin = false,
};
_userService.CreateTenantAdminUser(adminUser);
var emailCode = _userManager.GenerateEmailConfirmationToken <User, string>(userId);
var phoneCode = _userManager.GenerateChangePhoneNumberToken(userId, model.PhoneNumber);
var user = _userManager.FindById(userId);
user.EmailConfirmationCode = emailCode;
user.PhoneConfirmationCode = phoneCode;
_userService.Update(user);
var task = Task.Run(async() => await _userService.SendEmailConfirmationLinkAsync(userId, user.FullName(), model.Email, emailCode));
task.Wait();
return(model.Id);
}
// take in user model to create a user entity and send to repository
public async Task <bool> CreateUser(UserCreateRequestModel model)
{
var user = new User
{
Email = model.Email,
Password = model.Password,
Fullname = model.Fullname,
JoinedOn = model.JoinedOn
};
var createduser = await _userRepository.AddAsync(user);
return(true);
}
public async Task <IActionResult> CreatePrincipal(UserCreateRequestModel model)
{
var schoolId = await this.userService.GetSchoolIdForUser(UserId);
model.SchoolId = schoolId;
if (!ModelState.IsValid)
{
return(View(nameof(CreatePrincipal)));
}
await this.userService.Create(model);
return(RedirectToAction("School", "Administrator", new { schoolId = schoolId }));
}
public async Task <IdentityResult> UpdateUserAsync(UserCreateRequestModel model)
{
var user = await UserManager.FindByIdAsync(model.Id);
var oldRoleId = user.Roles.FirstOrDefault()?.RoleId;
if (oldRoleId != model.RoleId)
{
await UpdateUserRoleAsync(user.Id, oldRoleId, model.RoleId);
}
if (model.PasswordHash != model.RetypePassword)
{
return(await UpdateUserAsync(user));
}
user.FirstName = model.FirstName;
user.LastName = model.LastName;
user.Email = model.Email;
user.PhoneNumber = model.PhoneNumber;
if (!string.IsNullOrEmpty(model.PasswordHash))
{
user.PasswordHash = new PasswordHasher().HashPassword(model.PasswordHash);
}
user.TenantId = model.TenantId;
user.TenantName = model.TenantName;
user.CompanyId = model.CompanyId;
user.BranchId = model.BranchId;
user.IsChangeEmail = model.ChangeEmailAddress;
user.AwaitingConfirmEmail = model.AwaitingVerifyEmailAddress;
user.EmployeeId = model.EmployeeId;
user.IsActive = model.IsActive;
user.IsShouldChangedPasswordOnNextLogin = model.IsShouldChangedPasswordOnNextLogin;
user.Created = model.Created.GetValueOrDefault();
user.CreatedBy = model.CreatedBy;
user.Modified = model.Modified;
user.ModifiedBy = model.ModifiedBy;
if (!user.Email.IsNullOrWhiteSpace() && !user.UserName.IsReservedUsername())
{
user.UserName = user.Email;
}
return(await UpdateUserAsync(user));
}
//POST : /api/User/Register
public async Task <IActionResult> Register(UserCreateRequestModel model)
{
var createUSer = new User();
createUSer.FirstName = model.FirstName;
createUSer.LastName = model.LastName;
createUSer.Email = model.Email;
createUSer.IsOnline = model.IsOnline;
var emailAlreadyExist = await _service.GetByEmail(createUSer.Email);
if (emailAlreadyExist != null)
{
return(Ok(null));
}
return(Ok(await _service.Add(createUSer)));
}
public async Task <IdentityResult> CreateUserAsync(UserCreateRequestModel model)
{
if (model.PasswordHash != model.RetypePassword)
{
return(new IdentityResult("Password does not match!"));
}
string id = model.Id;
if (string.IsNullOrWhiteSpace(model.Id))
{
id = Guid.NewGuid().ToString();
}
var applicationUser = GetReadyUserForCreate(model, id);
return(await CreateUserAsync(applicationUser));
}
public async Task <IdentityResult> CreateTenantAdminUserAsync(UserCreateRequestModel model)
{
if (model.PasswordHash != model.RetypePassword)
{
return(null);
}
string id = model.Id;
if (string.IsNullOrWhiteSpace(model.Id))
{
id = Guid.NewGuid().ToString();
}
User user = GetReadyUserForCreate(model, id);
var applicationUser = user;
return(await CreateTenantAdminUserAsync(applicationUser));
}
public async Task <User> Create(UserCreateRequestModel model)
{
var user = new User
{
UserName = model.UserName,
Email = model.Email,
FirstName = model.FirstName,
MiddleName = model.MiddleName,
LastName = model.LastName,
Role = model.Role,
SchoolId = model.SchoolId
};
var result = await this.userManager.CreateAsync(user, model.Password);
if (!result.Succeeded)
{
throw new Exception("Unnable to create user!");
}
return(user);
}
private static User GetReadyUserForCreate(UserCreateRequestModel model, string id)
{
return(new User()
{
Id = id,
FirstName = model.FirstName,
LastName = model.LastName,
Email = model.Email,
PhoneNumber = model.PhoneNumber,
UserName = model.UserName,
PasswordHash = new PasswordHasher().HashPassword(model.PasswordHash),
SecurityStamp = Guid.NewGuid().ToString(),
Roles = { new UserRole()
{
RoleId = model?.RoleId, UserId = id, TenantId = model?.TenantId, CompanyId = model?.CompanyId
} },
EmailConfirmed = model.EmailConfirmed,
EmailConfirmationCode = model.EmailConfirmationCode,
PhoneConfirmationCode = model.PhoneNumberConfirmationCode,
TenantId = model.TenantId,
TenantName = model.TenantName,
CompanyId = model.CompanyId,
BranchId = model.BranchId,
IsChangeEmail = model.ChangeEmailAddress,
AwaitingConfirmEmail = model.AwaitingVerifyEmailAddress,
EmployeeId = model.EmployeeId,
IsActive = model.IsActive,
IsShouldChangedPasswordOnNextLogin = model.IsShouldChangedPasswordOnNextLogin,
Created = DateTime.Now,
CreatedBy = model.CreatedBy,
//Modified= model.Modified,
//ModifiedBy= model.ModifiedBy,
});
}
public IActionResult Create(UserCreateRequestModel request)
{
return(View(request));
}
public async Task <IActionResult> CreateUser(UserCreateRequestModel user)
{
await _userService.CreateUser(user);
return(Ok());
}
public async Task <IHttpActionResult> CreateUser(UserCreateRequestModel model)
{
if (string.IsNullOrWhiteSpace(model.Id))
{
model.Id = Guid.NewGuid().ToString();
}
model.UserName = model.Email;
if (!string.IsNullOrWhiteSpace(model.UserName))
{
ModelState.Remove("model.UserName");
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (_service.IsEmailExist(model.Email))
{
return(BadRequest($"{model.Email} email address already exist."));
}
if (string.IsNullOrWhiteSpace(model.TenantId))
{
model.TenantId = User.Identity.GetTenantId();
model.TenantName = User.Identity.GetTenantName();
model.CompanyId = User.Identity.GetCompanyId();
}
else
{
var tenant = await _tenantProvider.GetTenantAsync(model.TenantId);
var company = await _tenantProvider.GetTenantCompanyAsync(model.TenantId);
model.TenantName = tenant.TenancyName;
model.CompanyId = company?.Id;
}
model.CreatedBy = User.Identity.GetUserId();
model.IsActive = !model.SendActivationEmailToUser;
model.EmailConfirmed = !model.SendActivationEmailToUser;
var featureUsers = _featureProvider.GetEditionFeatureValue(model.TenantId, StaticFeature.Users.Name);
bool isReachedMaximumUsersCount =
_service.IsReachedMaximumUsersCount(model.TenantId, Convert.ToInt32(featureUsers));
if (isReachedMaximumUsersCount)
{
return(BadRequest("You already have added " + featureUsers + " users. You can not add more user with your current subscription."));
}
var identityResult = await _service.CreateUserAsync(model);
if (model.SendActivationEmailToUser)
{
var user = await _service.GetUserAsync(model.Id);
user.EmailConfirmationCode = await UserManager.GenerateEmailConfirmationTokenAsync(model.Id);
user.EmailConfirmed = false;
user.EmailConfirmationCodeExpireTime = DateTime.Now.AddMinutes(30);
user.PhoneConfirmationCode = await UserManager.GenerateChangePhoneNumberTokenAsync(model.Id, model.PhoneNumber);
user.PhoneNumberConfirmed = false;
user.PhoneConfirmationCodeExpireTime = DateTime.Now.AddMinutes(30);
await _service.UpdateUserAsync(user);
await _service.SendEmailConfirmationLinkAsync(model.Id, model.FullName(), model.Email, user.EmailConfirmationCode);
}
return(Ok(identityResult));
}
public async Task <ActionResult <UserModel> > UpdateUser(
[FromRoute] Guid?uid, [FromBody] UserCreateRequestModel newUser)
{
if (uid == null)
{
return(NotFound());
}
var user = await database.Get <UserModel>(uid.Value);
// Update Username
if (user.UserName != newUser.UserName && !newUser.UserName.IsNullOrEmpty())
{
if (await database.GetUserByUserName(user.UserName) != null)
{
return(BadRequest(new ErrorModel(400, "username already taken")));
}
user.UserName = newUser.UserName;
}
// Update Displayname
if (!newUser.DisplayName.IsNullOrEmpty())
{
user.DisplayName = newUser.DisplayName;
}
// Update Email Address
if (newUser.EmailAddress != null && newUser.EmailAddress != user.EmailAddress)
{
user.EmailAddress = newUser.EmailAddress;
if (user.EmailAddress.Length > 0)
{
await SendMailConfirm(user);
}
else
{
user.EmailConfirmStatus = EmailConfirmStatus.UNSET;
}
}
// Update Username
if (newUser.Description != null)
{
user.Description = newUser.Description;
}
// Update Admin Status
if (newUser.IsAdmin != null)
{
if (!authClaims.User.IsAdmin.Equals(true))
{
return(BadRequest(new ErrorModel(400, "you need to be admin to change the admin state of a user")));
}
user.IsAdmin = newUser.IsAdmin.Equals(true);
}
// Update Password
if (!newUser.Password.IsNullOrEmpty())
{
if (!newUser.IsValidPassword())
{
return(BadRequest(new ErrorModel(400, "invalid new password")));
}
if (newUser.OldPassword.IsNullOrEmpty())
{
return(BadRequest(new ErrorModel(400, "old password is required")));
}
if (!hasher.Validate(newUser.OldPassword, user.PasswordHash))
{
return(BadRequest(new ErrorModel(400, "invalid old password")));
}
user.PasswordHash = hasher.Create(newUser.Password);
}
await database.Update(user);
return(Ok(user));
}
public Task <ActionResult <UserModel> > UpdateSelfUser([FromBody] UserCreateRequestModel newUser) => UpdateUser(authClaims.User?.Uid, newUser);
