public async Task UpdateLastLogin(Data_Access_Layer.User user)
        {
            user.LastLogin     = DateTime.UtcNow;
            user.SecurityStamp = Guid.NewGuid().ToString();

            UserRepository.Update(user);
        }
        public async Task AddUser(AddUser model)
        {
            var transaction = _dbContext.Database.BeginTransaction();

            try
            {
                var passwordHash = _passwordManager.GetHash(model.Password);

                var entity = new Data_Access_Layer.User()
                {
                    UserName     = model.Username,
                    FirstName    = model.FirstName,
                    LastName     = model.LastName,
                    Email        = model.Email,
                    PasswordHash = passwordHash
                };

                await UserRepository.Add(entity);

                Save();

                if (model.Role != null)
                {
                    var role = await RoleRepository.Find(model.Role.Name);

                    if (role != null)
                    {
                        await UserRoleRepository.Add(
                            new UserRole
                        {
                            User = entity,
                            Role = role
                        });

                        Save();
                    }
                }

                if (model.Claims != null)
                {
                    var claims = model.Claims.Select(cl => new UserClaim
                    {
                        UserId     = entity.Id,
                        ClaimType  = cl.Type,
                        ClaimValue = cl.Value
                    });

                    await UserClaimRepository.AddRange(claims);
                }

                Save();

                transaction.Commit();
            }
            catch (Exception)
            {
                transaction.Rollback();
                throw;
            }
        }
        public override Common.DTO.User Map(Data_Access_Layer.User entity)
        {
            var dto = base.Map(entity);

            Map(entity, dto);
            return(dto);
        }
        public void BlockUser(Data_Access_Layer.User user)
        {
            var userRepository = _userRepository;

            user.UserStatus = UserStatus.BLOCKED;

            userRepository.Update(user);

            Save();
        }
        public async Task <IList <System.Security.Claims.Claim> > GetUserClaims(Data_Access_Layer.User user)
        {
            var userClaims = UserClaimRepository
                             .GetForUser(user)
                             .Select(uc => new System.Security.Claims.Claim(uc.ClaimType, uc.ClaimValue));

            var roleClaims = RoleClaimRepository
                             .GetForRole(user.Role)
                             .Select(uc => new System.Security.Claims.Claim(uc.ClaimType, uc.ClaimValue));

            return(roleClaims.Union(userClaims, new ClaimEqualityComparer()).ToList());
        }
        public async Task AddUsers(IEnumerable <AddUser> users)
        {
            await RunTaskInTransaction(async() =>
            {
                foreach (var model in users)
                {
                    var passwordHash = _passwordManager.GetHash(model.Password);

                    var entity = new Data_Access_Layer.User()
                    {
                        UserName     = model.Username,
                        FirstName    = model.FirstName,
                        LastName     = model.LastName,
                        Email        = model.Email,
                        PasswordHash = passwordHash
                    };

                    await UserRepository.Add(entity);

                    if (model.Role != null)
                    {
                        var role = await RoleRepository.Find(model.Role.Name);

                        if (role != null)
                        {
                            await UserRoleRepository.Add(
                                new UserRole
                            {
                                UserId = entity.Id,
                                RoleId = role.Id
                            });
                        }
                    }

                    if (model.Claims != null)
                    {
                        var claims = model.Claims.Select(cl => new UserClaim
                        {
                            UserId     = entity.Id,
                            ClaimType  = cl.Type,
                            ClaimValue = cl.Value
                        });

                        await UserClaimRepository.AddRange(claims);
                    }
                }

                return(string.Empty);
            });
        }
        public void BlockUser(Data_Access_Layer.User user)
        {
            user.UserStatus = UserStatus.BLOCKED;

            UserRepository.Update(user);
        }