Example #1
0
        public void Delete(UserAccountDto entity)
        {
            UserAccount UserAccount = Mapper.mapper.Map <UserAccount>(entity);

            _context.Set <UserAccount>().Remove(UserAccount);
            _context.SaveChanges();
        }
Example #2
0
        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));
        }
Example #6
0
        /// <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);
        }
Example #8
0
        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);
        }
Example #10
0
        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;
        }
Example #12
0
        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
     });
 }
Example #14
0
        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();
        }
Example #15
0
        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);
        }
Example #17
0
        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);
        }
Example #18
0
        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);
            }
        }
Example #19
0
        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
     });
 }
Example #21
0
        /// <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);
        }
Example #23
0
 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;
 }
Example #24
0
        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);
        }
Example #26
0
 /// <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)));
        }
Example #28
0
        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);
        }
Example #29
0
        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);
        }
Example #30
0
        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();
     }
 }