public void Delete(UserAccountDto entity) { UserAccount UserAccount = Mapper.mapper.Map <UserAccount>(entity); _context.Set <UserAccount>().Remove(UserAccount); _context.SaveChanges(); }
public LoggedInSessionInfo CreateUserAccount(UserAccountDto userAccount) { var userSession = new LoggedInSessionInfo { }; userAccount.GravatarUrl = UserService.GetGravatarHash(userAccount.EmailAddress); var userId = accountRepository.Save(userAccount); //Create a default team for the user var team = new TeamDto { Name = userAccount.Name.Replace(" ", "-"), CreatedById = userId }; if (team.Name.Length > 19) { team.Name = team.Name.Substring(0, 19); } var teamId = teamRepository.SaveTeam(team); teamRepository.SaveTeamMember(teamId, userId, userId); teamRepository.SaveDefaultTeamForUser(userId, teamId); userSession.TeamId = teamId; userSession.UserId = userId; userSession.UserDisplayName = userAccount.Name; return(userSession); }
public static TokenResponse CreateToken(IConfiguration configuration, UserAccountDto userDetails) { var key = configuration["Jwt:key"]; var issuer = configuration["Jwt:issuer"]; var audience = configuration["Jwt:audience"]; var duration = Int32.Parse(configuration["Jwt:duration"]); if (duration == 0) { duration = 1; } var expireAt = DateTime.Now.AddHours(duration); List <Claim> claims = new List <Claim> { new Claim(ClaimTypes.Name, userDetails.Username) }; userDetails.Roles.ForEach(role => { claims.Add(new Claim("role", $"{role.Name}")); }); var token = _JwtTokenBuilder(key, issuer, audience, userDetails.Username, expireAt, claims); return(new TokenResponse { ExpireAt = expireAt, Status = System.Net.HttpStatusCode.OK, Token = token, UserDetails = userDetails }); }
public dynamic GetCompanies(String role, String email) { List <UserAccount> userAccount; List <UserAccountDto> userAccountDtos = new List <UserAccountDto>(); if (role == null && email != null) { userAccount = stocky.UserAccount.Where(e => e.Email == email).ToList(); } else if (email == null && role != null) { userAccount = stocky.UserAccount.Where(e => e.Role == role).ToList(); } else if (email == null && role == null) { userAccount = stocky.UserAccount.ToList(); } else { userAccount = stocky.UserAccount.Where(e => e.Email == email && e.Role == role).ToList(); } foreach (UserAccount com in userAccount) { UserAccountDto dto = new UserAccountDto(com.Id, com.Avatar, com.Fullname, com.IdentifyCardNumber, com.Address, com.Phone, com.Email, com.Status, com.Role, com.Description); userAccountDtos.Add(dto); } return(userAccountDtos); }
public UserDto GetUserFromUserAccount(UserAccountDto user) { UserAccount ua = Mapper.ToUserAccount(user); User userDetail = _dbContext.Users.Where(x => x.UserAccount.UserAccountID == ua.UserAccountID).SingleOrDefault(); return(Mapper.ToUserDto(userDetail)); }
/// <summary> /// ReactivateUser reactivates the user when given a username. /// <para> /// @author: Angelica Salas Tovar /// @update: 03/20/2018 /// </para> /// </summary> /// <param name="username">The user that will be reactivated.</param> /// <returns>Response Dto</returns> public ResponseDto <bool> ReactivateUser(UserAccountDto user) { // Validation Strategy var usernameValidation = new UsernameValidationStrategy(user); // Validate data transfer object var result = usernameValidation.ExecuteStrategy(); if (result.Error != null) { return(new ResponseDto <bool> { Data = false, Error = result.Error }); } // Gateway using (var gateway = new UserGateway()) { var gatewayResult = gateway.ReactivateUser(user.Username); if (gatewayResult.Data == false) { return(new ResponseDto <bool>() { Data = false, Error = gatewayResult.Error }); } return(new ResponseDto <bool> { Data = true }); } }
public ActionResult Join(AccountSignupVM model) { try { if (ModelState.IsValid) { var accountExists = accountManager.DoesAccountExist(model.Email); if (!accountExists) { var newUser = new UserAccountDto { EmailAddress = model.Email, Name = model.Name, Password = model.Password }; var userSession = accountManager.CreateUserAccount(newUser); if (userSession.UserId > 0) { SetUserIDToSession(userSession); } if (!String.IsNullOrEmpty(model.ReturnUrl)) return RedirectToAction("joinmyteam", "users", new { id = model.ReturnUrl }); return RedirectToAction("accountcreated"); } else { ModelState.AddModelError("", "Account already exists with this email address"); } } } catch (Exception ex) { log.Error(ex); } return View(model); }
public async Task <IActionResult> UpdateAccount([FromBody] UserAccountDto userAccountDto) { async Task UpdateAccount() { var user = await _userManager.GetUserAsync(HttpContext.User); await _accountHelper.ValidateCurrentPasswordIsCorrect(user, userAccountDto.CurrentPassword); if (!string.IsNullOrEmpty(userAccountDto.NewPassword)) { await _accountHelper.ChangePassword(user, userAccountDto.CurrentPassword, userAccountDto.NewPassword); } bool EmailHasChanged() { return(!string.IsNullOrEmpty(userAccountDto.Email) && !string.Equals(user.Email, userAccountDto.Email, StringComparison.CurrentCultureIgnoreCase)); } if (EmailHasChanged()) { await _accountHelper.ChangeEmail(user, userAccountDto.Email); } } return(await Execute(UpdateAccount)); }
public async Task <UserAccountDto> RegisterAsync(RegisterUserDto registerDto, CancellationToken cancellationToken) { registerDto.Email = registerDto.Email.ToLower().Trim(); registerDto.Username = registerDto.Username.ToLower().Trim(); var estate = await _estateEntityService.Queryable.FirstAsync(cancellationToken); await CheckIfUserIsValid(registerDto.Email, registerDto.Username, cancellationToken); var activationKey = _hasher.CalculateHash(registerDto.Firstname + registerDto.Lastname + registerDto.Email + registerDto.Username); var passwordHash = _passwordService.HashUserPassword(registerDto.Email, registerDto.Password); var reg = CreateUser(registerDto, UserGroup.AppClient, registerDto.Password, passwordHash, activationKey); _entityService.DbContext.SaveChanges(); var userDto = new UserAccountDto(); userDto.From(reg); return(userDto); //return await AuthenticateAsync(registerDto.Email, registerDto.Password, cancellationToken); }
public ActionResult <List <PostDto> > GetPosts(string?userName, [FromHeader] int accountID) { List <Post> posts; if (userName != null) { UserAccountDto user = userMockRepository.GetAccountByUserName(userName); int userID = user.UserAccountId; posts = postRepository.GetPostByUser(userID, accountID); if (posts == null) { return(StatusCode(StatusCodes.Status400BadRequest, "You can't see the posts because the user is blocked!")); } } else { posts = postRepository.GetPosts(); if (posts == null || posts.Count == 0) { return(NoContent()); } } fakeLoggerRepository.Log(LogLevel.Information, contextAccessor.HttpContext.TraceIdentifier, "", "Get all posts", null); return(Ok(mapper.Map <List <PostDto> >(posts))); }
/// <summary> /// Generate Token /// </summary> /// <param name="user"></param> /// <returns>Token</returns> private static JwtSecurityToken GenerateToken(UserAccountDto user) { var config = new ConfigurationBuilder() .SetBasePath(Directory.GetCurrentDirectory()) .AddJsonFile("appsettings.json") .Build(); var secretKey = config["Auth:SecretKey"]; var claims = new[] { new Claim("UserData", JsonConvert.SerializeObject(user)), new Claim("id", user.Id.ToString()), new Claim("email", user.Email), new Claim("name", user.Username), new Claim(ClaimTypes.Role, "Administrator") }; var key = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(secretKey)); var creds = new SigningCredentials(key, SecurityAlgorithms.HmacSha256); // Generamos el Token var token = new JwtSecurityToken ( issuer: config["Auth:Issuer"], audience: config["Auth:Audience"], claims: claims, expires: DateTime.UtcNow.AddDays(60), notBefore: DateTime.UtcNow, signingCredentials: creds ); return token; }
public async Task Test2() { ServiceProvider serviceProvider = service.BuildServiceProvider(); IUserAccountApplicationService userBusiness = serviceProvider.GetRequiredService <IUserAccountApplicationService>(); UserAccountDto user = await userBusiness.FindUserById("1ea57e74-6984-4d98-86b3-c516c464b356"); Assert.NotNull(user.Id); }
public UserAccount Convert(UserAccountDto userAccountDto) { return(new UserAccount { Login = userAccountDto.Login, Password = userAccountDto.Password }); }
public void Edit(UserAccountDto entity) { UserAccount UserAccount = Mapper.mapper.Map <UserAccount>(entity); UserAccount existingUserAccount = Mapper.mapper.Map <UserAccount>(GetSingle(UserAccount.UniqueKey)); existingUserAccount = UserAccount; _context.SaveChanges(); }
public void Add(UserAccountDto entity) { UserAccount UserAccount = Mapper.mapper.Map <UserAccount>(entity); UserAccount.UniqueKey = Guid.NewGuid(); //UserAccount.ID = (_context.Set<UserAccount>().OrderByDescending(u => u.ID).FirstOrDefault()).ID+1; _context.Set <UserAccount>().Add(UserAccount); _context.SaveChanges(); }
public Boolean UserExists(UserAccountDto user) { UserAccount ua = Mapper.ToUserAccount(user); Boolean result = _dbContext.UserAccounts.Where( x => x.EmailID.Equals(ua.EmailID)). SingleOrDefault() != null ? true : false; return(result); }
public Guid Get(UserAccountDto entity) { UserAccount UserAccount = Mapper.mapper.Map <UserAccount>(entity); var result = _context.Set <UserAccount>().Where(x => x.Email.Equals(UserAccount.Email) && x.Password.Equals(UserAccount.Password)). FirstOrDefault <UserAccount>(); return(result.UniqueKey); }
public void CreateAdminUser(RegisterViewModel registerModel) { UserAccountDto loginData = _userAccountManager.GetUserLoginData(registerModel.UserAccount.USERNAME, registerModel.UserAccount.PASSWORD); if (loginData == null || loginData.USERID == null || loginData.USERID == 0) { Register(registerModel); } }
public async Task <User> CreateUser(UserAccountDto modelDto) { var newUser = new User(modelDto.Email, modelDto.Password, AccountHelper.DefaultUserRole); db.Add(newUser); await db.SaveChangesAsync(); return(newUser); }
/// <summary> /// Maps the specified UserAccountDto to a UserAccountRecord instance /// </summary> /// <param name="dto">UserAccountDto to map</param> /// <returns>UserAccountRecord instance</returns> public static UserAccountRecord MapUserAccount(UserAccountDto dto) { return(new UserAccountRecord { UserId = dto.UserId, Provider = dto.Provider, ProviderData = dto.ProviderData }); }
/// <summary> /// The CreateFirstTimeSsoUser method. /// Creates a first time user registered from the SSO. /// <para> /// @author: Jennifer Nguyen /// @updated: 04/09/2018 /// </para> /// </summary> /// <param name="userAccountDto"></param> /// <returns></returns> public ResponseDto <bool> CreateFirstTimeSsoUser(UserAccountDto userAccountDto) { var createFirstTimeSsoUserPreLogicStrategy = new CreateFirstTimeSsoUserPreLogicValidationStrategy(userAccountDto); var saltGenerator = new SaltGenerator(); var payloadHasher = new PayloadHasher(); // Validate data transfer object var result = createFirstTimeSsoUserPreLogicStrategy.ExecuteStrategy(); if (result.Error != null) { return(new ResponseDto <bool> { Data = false, Error = result.Error }); } // Hash password var passwordSalt = new PasswordSalt(saltGenerator.GenerateSalt(128)); var userAccount = new UserAccount(username: userAccountDto.Username, password: userAccountDto.Password, isActive: true, isFirstTimeUser: true, roleType: userAccountDto.RoleType); userAccount.Password = payloadHasher.Sha256HashWithSalt(passwordSalt.Salt, userAccount.Password); // Validate domain models var createFirstTimeSsoUserPostLogicStrategy = new CreateFirstTimeSsoUserPostLogicValidationStrategy(userAccount, passwordSalt); result = createFirstTimeSsoUserPostLogicStrategy.ExecuteStrategy(); if (result.Error != null) { return(new ResponseDto <bool> { Data = false, Error = result.Error }); } // Store a user from Single Sign On registration request using (var userGateway = new UserGateway()) { var gatewayResult = userGateway.StoreSsoUser(userAccount, passwordSalt); if (gatewayResult.Data == false) { return(new ResponseDto <bool>() { Data = gatewayResult.Data, Error = GeneralErrorMessages.GENERAL_ERROR }); } } return(new ResponseDto <bool>() { Data = true }); }
public UserAccounts MapUserAccount(UserAccountDto userAccountDto) { if (userAccountDto == null) { return(null); } var user = System.Activator.CreateInstance <UserAccounts>(); user.InjectFrom(userAccountDto); return(user); }
private void SaltCredentials(UserAccountDto userAccount) { // generate a 128-bit salt using a secure PRNG byte[] salt = new byte[128 / 8]; using (var rng = RandomNumberGenerator.Create()) { rng.GetBytes(salt); } // derive a 256-bit subkey (use HMACSHA1 with 10000 iterations) userAccount.Password = GetHash(userAccount.Password, salt); userAccount.Salt = salt; }
public void UpdateProfile(UserAccountDto userAccountDto) { var user = db.Users.FirstOrDefault(s => s.ID == userAccountDto.Id); if (user != null) { user.FirstName = userAccountDto.Name; user.EmailAddress = userAccountDto.EmailAddress; db.Entry(user).State = EntityState.Modified; db.SaveChanges(); } }
public async Task<UserAccountDto> UpdateUser(Guid id, UserAccountDto updateUser) { UserAccounts user = userAccountDataService.GetById(id); user.Update(updateUser.Username, updateUser.Email, Crypto.GetSHA256Hash(updateUser.Password, user.Salt)); user = this.userAccountDataService.Update(user); var commited = await userAccountDataService.UnitOfWork.SaveEntitiesAsync(); return userAccountConverter.MapUserAccountDto(user); }
/// <summary> /// Inserts a new user account into the database /// </summary> /// <param name="userAccount">User account information</param> public async Task InsertUserAccount(UserAccountDto userAccount) { using (var ctx = DataAccessFactory.CreateContext <ISecurityDataOperations>()) { await ctx.InsertUserAccountAsync(new UserAccountRecord { UserId = userAccount.UserId, Provider = userAccount.Provider, ProviderData = userAccount.ProviderData }); } }
public UserDto IsValidUser(UserAccountDto user) { UserAccount ua = Mapper.ToUserAccount(user); UserAccount IsValidUserAccount = _dbContext.UserAccounts.Where( x => x.EmailID.Equals(ua.EmailID) && x.Password.Equals(ua.Password)).SingleOrDefault(); if (IsValidUserAccount == null) { return(null); } return(GetUserFromUserAccount(Mapper.ToUserAccountDto(IsValidUserAccount))); }
public bool Login(LoginViewModel loginModel, out int userId) { userId = 0; bool loginStats = false; UserAccountDto loginData = _userAccountManager.GetUserLoginData(loginModel.UserName, loginModel.Password); if (loginData != null) { userId = loginData.USERID; loginStats = !string.IsNullOrEmpty(loginData.USERNAME) && loginData.ACTIVATEAC == 1; } return(loginStats); }
public async Task SavePasswordResetRequest(UserAccountDto user) { var passwordResetRequest = new PasswordResetRequest { UserId = user.Id, ActivationCode = string.Format("{0}{1}{2}", Guid.NewGuid().ToString().Split('-').First(), user.Id, Guid.NewGuid().ToString().Split('-').First()) }; await this.userRepository.SavePasswordResetRequest(passwordResetRequest); passwordResetRequest.User = user; //Email await SendEmailNotificaionForResetPassword(passwordResetRequest); }
public int Save(UserAccountDto userAccount) { var userEntity = new User(); userEntity.FirstName = userAccount.Name; userEntity.EmailAddress = userAccount.EmailAddress; userEntity.Password = userAccount.Password; userEntity.Avatar = userAccount.GravatarUrl; userEntity.CreatedDate = DateTime.UtcNow; db.Users.Add(userEntity); db.SaveChanges(); return(userEntity.ID); }
// [Authorize(Roles = RoleName.ADMIN_ROLE)] public IHttpActionResult CreateUserAccount(UserAccountDto userAccountDto) { if (!ModelState.IsValid) { return(BadRequest()); } var userAccount = Mapper.Map <UserAccountDto, UserAccount>(userAccountDto); _context.UserAccounts.Add(userAccount); _context.SaveChanges(); userAccountDto.Id = userAccount.Id; return(Created(new Uri(Request.RequestUri + "/" + userAccount.Id), userAccountDto)); }
public async Task<int> CreateAccount(UserAccountDto userAccount) { var q = @"INSERT INTO [dbo].[User](FirstName,EmailAddress,Password,CreatedDate) VALUES(@n,@e,@p,@dt);SELECT CAST(SCOPE_IDENTITY() as int)"; using (var con = new SqlConnection(ConnectionString)) { con.Open(); var ss = await con.QueryAsync<int> (q, new { @n = userAccount.Name, @e = userAccount.EmailAddress, @p = userAccount.Password, @dt = DateTime.Now }); return ss.Single(); } }