public async Task <IActionResult> Post([FromBody] NewUserDTO dto)
{
var newUser = new ApplicationUser
{
UserName = dto.UserName,
Email = dto.Email,
PhoneNumber = dto.Phone.ToString()
};
bool RoleExists = await _roleManager.RoleExistsAsync(dto.RoleName);
Console.WriteLine(dto.RoleName);
IdentityResult roleResult;
if (!RoleExists)
{
roleResult = await _roleManager.CreateAsync(new IdentityRole(dto.RoleName));
}
IdentityResult result = await _userManager.CreateAsync(newUser, dto.Password);
if (result.Succeeded)
{
ApplicationUser current = await _userManager.FindByNameAsync(dto.UserName);
result = await _userManager.AddToRoleAsync(current, dto.RoleName);
}
return((result.Succeeded) ? Ok() : (IActionResult)Unauthorized());
}
public async Task <ActionResult> RegisterUser(NewUserDTO input)
{
// Check that api key is correct to the one supplied in environment files
if (!ValidAPIKey(input.APIKey))
{
return(StatusCode(StatusCodes.Status403Forbidden, new GenericReturnMessageDTO {
Status = 403, Message = ErrorMessages.APIKeyInCorrect
}));
}
// Check that the username is not already in use in another keytab
if (await _repo.UserExists(input.NewUserUsername))
{
return(BadRequest(new GenericReturnMessageDTO {
Status = 400, Message = ErrorMessages.UserAlreadyExists
}));
}
// Create users principal and keytab
$"create-user.sh {Regex.Escape(input.NewUserUsername)}".Bash();
var newUserKeyTabFilePath = $"/keytabs/{input.NewUserUsername}.user.keytab";
var user = await _repo.CreateNewUser(_mapper.Map <User>(input), input.NewUserPassword, newUserKeyTabFilePath);
return(StatusCode(StatusCodes.Status201Created, new GenericReturnMessageDTO
{
Status = 201,
Message = SuccessMessages.UserCreated
}));
}
public Task <bool> CreateNewUser(NewUserDTO data) => Task.Run(() =>
{
Users user = new Users
{
Userid = Guid.NewGuid().ToString(),
Usermoney = 0,
Useremail = data.userEmail,
Userlastname = data.userLastName,
Username = data.userName,
Userpassword = data.userPassword
};
try
{
context.Users.Add(user);
context.SaveChanges();
}
catch (DbUpdateException e)
{
return(false);
}
bup.createNewBudget(new GetBudgetDTO {
ownerId = user.Userid
});
context.SaveChanges();
return(true);
});
public async Task <ActionResult <UULResponse> > NewUser(NewUserDTO newUser)
{
UULResponse response;
try {
if (!newUser.isValid(out var msg))
{
return(Error.ProfileValidationFailed.CreateErrorResponse(_logger, "NewProfile", new Exception(msg)));
}
var exist = await _context.Users.AnyAsync(u => u.Login.Equals(newUser.Login) && u.ApartmentCode == newUser.ApartmentCode);
if (exist)
{
return(Error.ProfileAlreadyExists.CreateErrorResponse(_logger, "NewProfile"));
}
var user = UserDao.AddFromDto(_context, newUser);
await _context.SaveChangesAsync();
var userInfo = new UserInfoDTO(user);
var tokenString = SecHelper.GenerateJSONWebToken(userInfo.Login, userInfo.ApartmentCode, _config);
response = new UULResponse()
{
Success = true, Message = tokenString, Data = userInfo
};
} catch (Exception e) {
response = Error.ProfileCreationFailed.CreateErrorResponse(_logger, "NewProfile", e);
}
return(response);
}
public IActionResult AddNewUserToGroup(int groupId, [FromBody] NewUserDTO newUser)
{
var user = new NewUserDTO(newUser.FirstName, newUser.LastName, newUser.PhoneNumber);
_userService.AddNewUserToGroup(user, groupId);
return(Ok());
}
public static User NewUserDtoToUserModel(NewUserDTO userDto) =>
new User
{
FirstName = userDto.FirstName,
LastName = userDto.LastName,
PhoneNumber = userDto.PhoneNumber
};
public async Task <IActionResult> PutUser([FromRoute] string userName, [FromBody] NewUserDTO user)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var uti = await _context.User.SingleOrDefaultAsync(m => m.UserName == user.UserName);
if (uti == null)
{
return(NotFound());
}
uti.UserName = user.UserName;
uti.Email = user.Email;
uti.PhoneNumber = user.Phone.ToString();
await _userManager.RemovePasswordAsync(uti);
await _userManager.AddPasswordAsync(uti, user.Password);
_context.Entry(uti).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
throw;
}
return(NoContent());
}
public async Task <IActionResult> Post([FromBody] NewUserDTO dto)
{
ApplicationUser newUser = new ApplicationUser {
UserName = dto.UserName,
Email = dto.Email,
IsCertified = dto.IsCertified,
Language = dto.Language,
NameCertified = dto.NameCertified,
IsMale = dto.IsMale,
BirthDate = dto.BirthDate
};
IdentityResult result = await _userManager.CreateAsync(newUser, dto.Password);
bool userExist = await _roleManager.RoleExistsAsync("user");
if (!userExist)
{
await _roleManager.CreateAsync(new IdentityRole("user"));
}
await _userManager.AddToRoleAsync(newUser, "user");
// TODO: retourner un Created à la place du Ok;
return((result.Succeeded)?Ok():(IActionResult)BadRequest());
}
public async Task <ReqResult> CreateNewUser(SignupDTO newUserInfo)
{
var emailIsUsed = await _context.Users
.Where(user => user.email == newUserInfo.email)
.FirstOrDefaultAsync();
if (emailIsUsed != null)
{
return(ReqResult.EmailInUse);
}
var newHash = BCrypt.Net.BCrypt.HashPassword(newUserInfo.password);
var newUser = new NewUserDTO
{
email = newUserInfo.email,
first_name = newUserInfo.first_name,
last_name = newUserInfo.last_name,
password_hash = newHash
};
var dbInsertPayload = _mapper.Map <User>(newUser);
await _context.AddAsync(dbInsertPayload);
await _context.SaveChangesAsync();
return(ReqResult.Ok);
}
private void SubmitASMX_Click(object sender, RoutedEventArgs e)
{
if (_CheckInput())
{
NewUserDTO newUser = new NewUserDTO()
{
FirstName = textBoxFirstName.Text,
LastName = textBoxLastName.Text,
Email = textBoxEmail.Text,
Password = passwordBox1.Password,
CompanyId = _rCompanyService.GetCompanyIdByName(comboBoxCompany.SelectedItem.ToString())
};
var client = new RegistrationASMXServiceSoapClient();
var result = client.RegisterUser(newUser);
if (string.IsNullOrWhiteSpace(result))
{
errormessage.Text = "";
MessageBox.Show("You have Registered successfully!");
}
else
{
errormessage.Text = result.ToString();
}
}
}
public static User AddFromDto(UULContext context, NewUserDTO newUser)
{
var salt = SecHelper.CreateSalt();
var habitant = new Habitant(newUser);
context.Habitants.Add(habitant);
var userToSave = new User {
Login = newUser.Login,
IsActivated = false,
CreatedAt = DateOperations.Now(),
Hash = SecHelper.SaltAndHashPwd(newUser.Pwd, salt),
Salt = salt,
ApartmentCode = newUser.ApartmentCode,
Habitants = new List <Habitant>()
{
habitant
}
};
context.Users.Add(userToSave);
return(userToSave);
}
public User Create([FromBody] NewUserDTO NewUserData)
{
if (!NewUserData.Validate())
{
throw new HttpResponseException(new HttpResponseMessage()
{
StatusCode = System.Net.HttpStatusCode.InternalServerError,
ReasonPhrase = "Trying to Create invalid User",
Content = new StringContent("The User is not valid and can't be created")
});
}
try
{
var NewUser = new User()
{
Name = NewUserData.Name,
Birthdate = NewUserData.Birthdate,
};
return(UserService.Create(NewUser));
}
catch (HttpResponseException Ex) //catches an exception from a deeper layer.
{
throw Ex;
}
}
/// <summary>
/// Creates a new user in the database and creates their empty main collection
/// </summary>
/// <param name="newUser">Object{FirstName: string, LastName: string, FirebaseUid:GUID, AvatarId:GUID}</param>
/// <returns>True if no errors thrown</returns>
public bool AddNewUserToDatabase(NewUserDTO newUser)
{
using (var db = new SqlConnection(_connectionString))
{
newUser.DateCreated = DateTime.Now;
var sql = @"INSERT INTO [User]
(
[FirstName],
[LastName],
[FirebaseUid],
[AvatarId],
[DateCreated]
)
OUTPUT INSERTED.Id
VALUES
(
@firstName,
@lastName,
@firebaseUid,
@avatarId,
@dateCreated
)";
var userId = db.QueryFirst <Guid>(sql, newUser);
return(_collectionRepo.addMainCollectionForNewUser(userId));
}
}
public async Task <UserDTO> Register(NewUserDTO creatingUser)
{
var userSN = new NewUserSocialNetworkDTO()
{
UId = creatingUser.UId,
ProviderName = creatingUser.ProviderName,
SocialNetworkUrl = creatingUser.ProviderUrl,
};
var user = _mapper.Map <User>(creatingUser);
user.CreatedAt = DateTime.Now;
_context.Add(user);
await _context.SaveChangesAsync();
var userDto = _mapper.Map <UserDTO>(user);
userSN.UserId = userDto.Id;
var userSNEntity = _mapper.Map <UserSocialNetwork>(userSN);
_context.Add(userSNEntity);
await _context.SaveChangesAsync();
var emailModel = _emailBuilder.GetSignUpLetter(creatingUser.Email, creatingUser.FirstName);
await _emailService.SendEmailAsync(new List <string> {
emailModel.Email
}, emailModel.Subject, emailModel.Title, emailModel.Body);
return(_mapper.Map <UserDTO>(user));
}
public async Task <IActionResult> Put([FromRoute] string userName, [FromBody] NewUserDTO dto)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var user = await _userManager.FindByNameAsync(userName);
if (user != null)
{
var token = await _userManager.GeneratePasswordResetTokenAsync(user);
if (dto.Email == user.Email)
{
IdentityResult result = await _userManager.ResetPasswordAsync(user, token, dto.Password);
return((result.Succeeded)? Ok() : (IActionResult)BadRequest());
}
return((IActionResult)BadRequest());
}
else
{
return(NotFound());
}
}
/// <summary>
/// Create user with role organizer.
/// </summary>
/// <param name="newUserDTO">Details of new user to be created.</param>
/// <returns>Returns created user or an appropriate error message.</returns>
public async Task <UserDTO> CreateOrganizerAsync(NewUserDTO newUserDTO)
{
var user = new User()
{
FirstName = newUserDTO.FirstName ?? throw new ArgumentException(Exceptions.RequiredFirstName),
LastName = newUserDTO.LastName ?? throw new ArgumentException(Exceptions.RequiredLastName),
Email = newUserDTO.Email ?? throw new ArgumentException(Exceptions.RequiredEmail),
UserName = newUserDTO.Email,
Rank = await this.dbContext.Ranks.FirstOrDefaultAsync(r => r.Name.ToLower() == "organizer"),
CreatedOn = DateTime.UtcNow
};
if (await this.userManager.FindByEmailAsync(newUserDTO.Email) == null)
{
var result = await this.userManager.CreateAsync(user, newUserDTO.Password);
if (result.Succeeded)
{
await this.userManager.AddToRoleAsync(user, "Organizer");
}
else
{
throw new ArgumentException(Exceptions.IncorrectPassword);
}
}
else
{
throw new ArgumentException(Exceptions.ExistingEmail);
}
await this.dbContext.SaveChangesAsync();
return(new UserDTO(user));
}
public async Task <IActionResult> CreateOrganizer(CreateUserViewModel model)
{
if (ModelState.IsValid)
{
try
{
var newUserDTO = new NewUserDTO()
{
FirstName = model.FirstName,
LastName = model.LastName,
Email = model.Email,
EmailConfirmed = model.EmailConfirmed,
Password = model.Password
};
var user = await this.userService.CreateOrganizerAsync(newUserDTO);
return(RedirectToAction(nameof(Index)));
}
catch (Exception e)
{
toastNotification.AddErrorToastMessage(e.Message, new NotyOptions());
return(View());
}
}
return(View());
}
public async Task <UserDTO> Register(NewUserDTO creatingUser)
{
var userSNEntity = new UserSocialNetwork()
{
UId = creatingUser.UId,
ProviderName = creatingUser.ProviderName,
SocialNetworkUrl = creatingUser.ProviderUrl,
};
var user = _mapper.Map <User>(creatingUser, opt => opt.AfterMap((src, dst) =>
{
dst.CreatedAt = DateTime.Now;
dst.UserSocialNetworks = new List <UserSocialNetwork> {
userSNEntity
};
}));
_context.Add(user);
await _context.SaveChangesAsync();
var emailModel = _emailBuilder.GetSignUpLetter(creatingUser.Email, creatingUser.FirstName);
await _emailService.SendEmailAsync(new List <string> {
emailModel.Email
}, emailModel.Subject, emailModel.Title, emailModel.Body);
return(_mapper.Map <UserDTO>(user));
}
public async Task <IActionResult> Post([FromBody] NewUserDTO dto)
{
using (var contextTransaction = _context.Database.BeginTransaction()){
try{
var newUser = new ApplicationUser {
UserName = dto.UserName,
Email = dto.Email
};
IdentityResult result = await _userManager.CreateAsync(newUser, dto.Password);
bool userExist = await _roleManager.RoleExistsAsync("USER");
if (!userExist)
{
await _roleManager.CreateAsync(new IdentityRole("USER"));
}
await _userManager.AddToRoleAsync(newUser, "USER");
// TODO: retourner un Created à la place du Ok;
contextTransaction.Commit();
return((result.Succeeded)?Ok():(IActionResult)BadRequest());
}catch (Exception) {
contextTransaction.Rollback();
return(StatusCode(500));
}
}
}
public UserDTO AddNew(NewUserDTO newUser, int userId)
{
var user = Mapper.Map <User>(newUser);
user.CreatedAt = DateTime.Now;
user.UpdatedAt = DateTime.Now;
user.CreatedBy = userId;
user.UpdatedBy = userId;
user.Password = _hashService.Hash(user.Password);
if (FindByCondition(u => u.Email == user.Email).Any())
{
return(null);
}
try
{
Create(user);
Save();
}
catch (Exception)
{
return(null);
}
return(Mapper.Map <UserDTO>(user));
}
public IActionResult AddNewExternalUserToStep(AddResponsibleUserToStepDTO addExternalUserToStep)
{
Response.StatusCode = StatusCodes.Status202Accepted;
if (string.IsNullOrEmpty(addExternalUserToStep.Step) && addExternalUserToStep.PlanId <= 0)
{
Response.StatusCode = StatusCodes.Status400BadRequest;
return(PartialView("~/Views/User/Partials/_AddNewUser.cshtml"));
}
var newExternaluser = addExternalUserToStep.NewResponsibleUser;
if (TryValidateModel(newExternaluser))
{
if (_userRepository.FindByCondition(u => u.Email == newExternaluser.Email).Any())
{
ModelState.AddModelError("NewUser.Email", sharedResource.userAddNewExternalUserToStepEmailAlreadyExist);
return(PartialView("~/Views/User/Partials/_AddNewUser.cshtml"));
}
var newUser = new NewUserDTO
{
Email = newExternaluser.Email,
FirstName = newExternaluser.FirstName,
LastName = newExternaluser.LastName
};
newUser.Password = _userRepository.GeneratePassword();
newUser.Role = Roles.External;
var user = _userRepository.AddNew(newUser, HttpContext.GetUserId());
if (user == null)
{
ModelState.AddModelError(string.Empty, sharedResource.userAddNewExternalUserToStepFailed);
return(PartialView("~/Views/User/Partials/_AddNewUser.cshtml"));
}
if (!_emailService.SendPasswordToUser(newUser.Password, user))
{
ModelState.AddModelError(string.Empty, sharedResource.userAddNewExternalUserToStepEmailNotSent);
return(PartialView("~/Views/User/Partials/_AddNewUser.cshtml"));
}
if (!_planRepository.AddUserToPlanStep(user.Id, addExternalUserToStep.PlanId, addExternalUserToStep.Step))
{
ModelState.AddModelError(string.Empty, sharedResource.userAddNewExternalUserToStepNotAddedToteam);
return(PartialView("~/Views/User/Partials/_AddNewUser.cshtml"));
}
Response.StatusCode = StatusCodes.Status201Created;
}
return(PartialView("~/Views/User/Partials/_AddNewUser.cshtml"));
}
public static void CreateDummyData(UULContext context)
{
for (int i = 0; i < 20; i++)
{
var user = new NewUserDTO()
{
Login = "******" + i, AvatarSrc = "Default", Name = "Inhabitant_" + i, ApartmentCode = "T" + i, Pwd = "12345"
};
UserDao.AddFromDto(context, user);
}
context.SaveChanges();
List <TimeSlot> timeSlots = new();
var today = DateTime.UtcNow;
for (int i = 0; i < 3; i++)
{
var slots = TimeSlotsFactory.CreateTimeSlotsForDateUTC(context, new DateTime(today.Year, today.Month, today.Day - i).ToUniversalTime(), 5);
slots.Wait();
timeSlots.AddRange(slots.Result);
}
var habitants = context.Habitants.ToList();
var size = habitants.Count;
var rnd = new Random();
foreach (TimeSlot timeSlot in timeSlots)
{
for (int i = 0; i < rnd.Next(4); i++)
{
if (timeSlot.OccupiedBy == null)
{
timeSlot.OccupiedBy = new List <Habitant>();
}
timeSlot.OccupiedBy.Add(habitants.ElementAt(rnd.Next(size)));
}
}
context.TimeSlots.AddRange(timeSlots);
var newsList = new List <News>();
for (int i = 0; i < 5; i++)
{
newsList.Add(new News()
{
Title = "Title " + i, Content = " Content " + i + dummyContent, Author = "Dummy data generator", CreatedAt = DateTime.UtcNow, Auditory = Auditory.GUESTS, NewsType = NewsType.INFO
});
}
newsList.Add(new News()
{
Title = "Title Registered", Content = " Content Registered", Author = "Dummy data generator", CreatedAt = DateTime.UtcNow, Auditory = Auditory.REGISTERED, NewsType = NewsType.CALL_TO_ACTION
});
newsList.Add(new News()
{
Title = "Title Activated", Content = " Content Activated", Author = "Dummy data generator", CreatedAt = DateTime.UtcNow, Auditory = Auditory.ACTIVATED, NewsType = NewsType.ALERT
});
context.News.AddRange(newsList);
}
public TwitterUser DtoToUser(NewUserDTO newUserDto)
{
return(new TwitterUser()
{
FirstName = newUserDto.FirstName,
LastName = newUserDto.LastName,
Email = newUserDto.Email,
UserName = newUserDto.Email
});
}
public async Task <IActionResult> Post([FromBody] NewUserDTO dto)
{
var newUser = new ApplicationUser {
UserName = dto.UserName,
Email = dto.Email
};
IdentityResult result = await _userManager.CreateAsync(newUser, dto.Password);
// TODO: retourner un Created à la place du Ok;
return((result.Succeeded)?Ok():(IActionResult)BadRequest());
}
public ApplicationUserDTO AddNewApplicationUser(NewUserDTO newUser)
{
_uow.Users.Add(new ApplicationUser
{
UserName = newUser.UserName,
Email = newUser.UserName,
Name = newUser.Name,
Registered = DateTime.Now
}, newUser.Password);
return(_applicationUserFactory.Transform(_uow.Users.FindByName(newUser.UserName)));
}
public async Task <IActionResult> AddUser([FromBody] NewUserDTO data)
{
if (await Task.Run(() => _userProcessor.AddNewUser(data)))
{
return(Ok("User Added"));
}
else
{
return(BadRequest("This user already exists"));
}
}
public IActionResult AddNewUserToDatabase(NewUserDTO newUser)
{
if (_repo.AddNewUserToDatabase(newUser))
{
return(Created($"user/{newUser.FirstName}", newUser));
}
else
{
return(BadRequest());
}
}
public async Task <IActionResult> AddUser([FromBody] NewUserDTO data)
{
if (await Task.Run(() => _userProcessor.CreateNewUser(data)))
{
return(Ok("User Added"));
}
else
{
return(BadRequest("User with that email already exists!"));
}
}
public UserDTO AddUser(NewUserDTO newUserDTO)
{
var user = DtoFactory.NewUserDtoToUserModel(newUserDTO);
db.Users.AddEntity(user);
db.Save();
var id = user.Id;
var newUserModel = db.Users.GetUserById(id);
return(DtoFactory.UserModelToUserDTO(newUserModel));
}
public IActionResult Admin([FromBody] NewUserDTO dto)
{
if (!IsInRole("Admin"))
{
return(Unauthorized());
}
else
{
return(Ok());
}
}
