private string GenerateJSONWebToken(Data.Domain.Entity.User user)
        {
            var securityKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(_config["Jwt:Key"]));
            var credentials = new SigningCredentials(securityKey, SecurityAlgorithms.HmacSha256);

            var claims = new[] {
                new Claim(JwtRegisteredClaimNames.Sub, user.Username),
                new Claim(JwtRegisteredClaimNames.Email, user.Email)
            };

            var token = new JwtSecurityToken(_config["Jwt:Issuer"],
                                             _config["Jwt:Issuer"],
                                             claims,
                                             expires: DateTime.Now.AddMinutes(120),
                                             signingCredentials: credentials);

            return(new JwtSecurityTokenHandler().WriteToken(token));
        }
        public async Task <ActionResult <RegisteredUserDto> > RegisterUser([FromBody] UserRegisterDto userRegisterDto)
        {
            Data.Domain.Entity.User registeredButNotConfirmedUser = null;

            try
            {
                registeredButNotConfirmedUser = await _userService.RegisterAsync(userRegisterDto.Username, userRegisterDto.Email, userRegisterDto.Password);
            }
            catch (ArgumentException ex)
            {
                _logger.LogError($"failed register ${userRegisterDto.Email}: {ex.Message}");
                return(BadRequest());
            }

            var registeredUserDto = new RegisteredUserDto()
            {
                Username     = registeredButNotConfirmedUser.Username,
                ConfirmToken = registeredButNotConfirmedUser.ConfirmToken
            };


            return(Ok(registeredUserDto));
        }
        public async Task <ActionResult <AuthentificatedUserDto> > Login([FromBody] UserLoginDto userLoginDto)
        {
            Data.Domain.Entity.User user = null;

            try
            {
                user = await _userService.LoginAsync(userLoginDto.Email, userLoginDto.Password);
            }
            catch (ArgumentException ex)
            {
                _logger.LogError($"failed login ${userLoginDto.Email}: {ex.Message}");
                return(Unauthorized());
            }

            var authentificatedUserDto = new AuthentificatedUserDto()
            {
                Username = user.Username,
                Token    = GenerateJSONWebToken(user)
            };


            return(Ok(authentificatedUserDto));
        }
        public async Task <ActionResult <AuthentificatedUserDto> > Confirm([FromRoute] string confirmToken)
        {
            Data.Domain.Entity.User user = null;

            try
            {
                user = await _userService.ConfirmUserAsync(confirmToken);
            }
            catch (ArgumentException ex)
            {
                _logger.LogError($"failed confirm ${confirmToken}: {ex.Message}");
                return(BadRequest());
            }

            var authentificatedUserDto = new AuthentificatedUserDto()
            {
                Username = user.Username,
                Token    = GenerateJSONWebToken(user)
            };


            return(Ok(authentificatedUserDto));
        }