Esempio n. 1
0
        public JWTService(IAuthContainerModel model)
        {
            if (model is null)
            {
                throw new ArgumentException($"'{nameof(model)}' cannot be null", nameof(model));
            }

            Model = model;
        }
Esempio n. 2
0
        public JWTService(IAuthContainerModel model)
        {
            if (model is null || model.Claims is null || model.Claims.Length == 0)
            {
                throw new ArgumentException($"'{nameof(model)}' cannot be null or empty", nameof(model));
            }

            Model = model;
        }
Esempio n. 3
0
        public static string GetToken(string name, string phone)
        {
            IAuthContainerModel model       = getJWTContainerModel(name, phone);
            IAuthService        authService = new JWTService(model.SecretKey);

            string token = authService.GenerateToken(model);

            return(token);
        }
Esempio n. 4
0
        private string _generateRefreshToken(string id, string deviceNumber)
        {
            IAuthContainerModel jwtModel = JwtTokenService.GetAuthModel(id, deviceNumber);

            jwtModel.SecretKey     = _secretKeyRefreshToken;
            jwtModel.ExpireMinutes = 13;
            IAuthService authService = new JWTService(jwtModel.SecretKey);

            return(authService.GenerateToken(jwtModel));
        }
Esempio n. 5
0
 public HomeController(
     ILogger <HomeController> logger,
     IAuthService authService,
     IConfiguration configuration,
     IAuthContainerModel authContainerModel)
 {
     _logger             = logger;
     _authService        = authService;
     _configuration      = configuration;
     _authContainerModel = authContainerModel;
 }
Esempio n. 6
0
        public ActionResult <string> LogIn([FromBody] User user)
        {
            User tempUser = userProcessor.LogInUser(user.UserName, user.Password);

            if (tempUser != null)
            {
                IAuthContainerModel model       = GetJWTContainerModel(tempUser.UserName, tempUser.EmailAddress, tempUser.UserRole);
                IAuthService        authService = new JWTService(clientSettings.Value.SecretKey);
                return(authService.GenerateToken(model));
            }
            return(BadRequest("Invalid login information was given"));
        }
Esempio n. 7
0
        private string GenerateToken(IAuthContainerModel model)
        {
            SecurityTokenDescriptor securityTokenDescriptor = new SecurityTokenDescriptor
            {
                Subject            = new ClaimsIdentity(model.Claims),
                Expires            = DateTime.UtcNow.AddMinutes(Convert.ToInt32(model.ExpireMinutes)),
                SigningCredentials = new SigningCredentials(GetSymmetricSecurityKey(), model.SecurityAlgorithm)
            };

            JwtSecurityTokenHandler jwtSecurityTokenHandler = new JwtSecurityTokenHandler();
            SecurityToken           securityToken           = jwtSecurityTokenHandler.CreateToken(securityTokenDescriptor);

            return(jwtSecurityTokenHandler.WriteToken(securityToken));
        }
Esempio n. 8
0
        public static string CreateJwtToken(string name, string value)
        {
            string              _value      = value;
            IAuthService        authService = new JWTService();
            IAuthContainerModel model       = GetJWTContainerModel(name, value);

            string token = authService.GenerateToken(model);

            if (!string.IsNullOrEmpty(token))
            {
                _value = token;
            }

            return(_value);
        }
Esempio n. 9
0
        public JwtToken(IAuthContainerModel model, string secretKey = "TW9zaGVFcmV6UHJpdmF0ZUtleQ==")
        {
            if (model == null)
            {
                throw new ArgumentNullException(nameof(model));
            }

            if (model.Claims == null || model.Claims.Length == 0)
            {
                throw new ArgumentException("Invalid model");
            }

            this.secretKey = secretKey ?? throw new ArgumentNullException(nameof(secretKey));

            token = GenerateToken(model);
        }
Esempio n. 10
0
        public List <SIS.Entity.Entities.Admin.ApplicationServer> get_List_ApplicationServer_UserCode(GetValue _GetValue)
        {
            using (var _db = new SIS.DataAccess.Admin.AdminListContext(_GetValue.ConStr))
            {
                string _sql = Helper.get_sql_ApplicationServer(_GetValue.Id.Value, _GetValue.IdStr, _GetValue.IdStr2);
                List <ApplicationServer> _return = _db.Database.SqlQuery <ApplicationServer>(_sql).ToList();


                IAuthService authService = new JWTService();

                foreach (ApplicationServer _ApplicationServer in _return)
                {
                    _ApplicationServer.Password = get_SqlPassword_Local(_ApplicationServer.Password);
                    _sql = $"Select * from ApplicationDatabase with (nolock) Where ApplicationId = { _GetValue.Id} And ServerId = {_ApplicationServer.Id} ";
                    _ApplicationServer.ApplicationDatabase = _db.Database.SqlQuery <ApplicationDatabase>(_sql).ToList();

                    foreach (ApplicationDatabase _ApplicationDatabase in _ApplicationServer.ApplicationDatabase)
                    {
                        string connection        = "";
                        string invoiceConnection = "";

                        if (_ApplicationServer.ServerCloude.Value)
                        {
                            connection        = $"Server = tcp:{_ApplicationServer.Server},1433; Initial Catalog = {_ApplicationDatabase.DatabaseName}; Persist Security Info = False; User ID = {_ApplicationServer.Username}; Password = {_ApplicationServer.Password}; MultipleActiveResultSets = True; Encrypt = True; TrustServerCertificate = False; Connection Timeout = 30;";
                            invoiceConnection = $"Server = tcp:{_ApplicationServer.Server},1433; Initial Catalog = SednaEInvoice; Persist Security Info = False; User ID = {_ApplicationServer.Username}; Password = {_ApplicationServer.Password}; MultipleActiveResultSets = True; Encrypt = True; TrustServerCertificate = False; Connection Timeout = 30;";
                        }
                        else
                        {
                            connection        = $"data source= {_ApplicationServer.Server};initial catalog={_ApplicationDatabase.DatabaseName};persist security info=True;user id={_ApplicationServer.Username};password={_ApplicationServer.Password};MultipleActiveResultSets=True;App=EntityFramework";
                            invoiceConnection = $"data source= {_ApplicationServer.Server};initial catalog=SednaEInvoice;persist security info=True;user id={_ApplicationServer.Username};password={_ApplicationServer.Password};MultipleActiveResultSets=True;App=EntityFramework";
                        }

                        #region Token
                        IAuthContainerModel model = GetJWTContainerModel("connection", connection);
                        string token  = authService.GenerateToken(model);
                        string token2 = authService.GenerateToken(GetJWTContainerModel("connection", invoiceConnection));
                        connection        = token;
                        invoiceConnection = token2;

                        #endregion

                        _ApplicationDatabase.ConnectionString = connection;
                    }
                }
                return(_return);
            }
        }
Esempio n. 11
0
        public HomeController()
        {
            IAuthContainerModel model       = GetJwtContainerModel("Nhat", "*****@*****.**");
            IAuthService        authService = new JwtService(model.SecretKey);
            string token = authService.GenerateToken(model);

            if (!authService.IsTokenValid(token))
            {
                throw new UnauthorizedAccessException();
            }
            else
            {
                List <Claim> claims = authService.GetTokenClaims(token).ToList();
                string       name   = claims.FirstOrDefault(e => e.Type.Equals(ClaimTypes.Name)).Value;
                string       email  = claims.FirstOrDefault(e => e.Type.Equals(ClaimTypes.Email)).Value;
            }
        }
Esempio n. 12
0
        public string GenerateToken(IAuthContainerModel model)
        {
            SecurityTokenDescriptor securityTokenDescriptor = new SecurityTokenDescriptor
            {
                Issuer             = "petro.com",
                Audience           = "petro.com",
                Subject            = new ClaimsIdentity(model.Claims),
                Expires            = DateTime.UtcNow.AddSeconds(model.ExpireInterval),
                SigningCredentials = new SigningCredentials(GetSymmetricSecurityKey(), model.SecurityAlgorithm),
            };

            JwtSecurityTokenHandler jwtSecurityTokenHandler = new JwtSecurityTokenHandler();
            SecurityToken           securityToken           = jwtSecurityTokenHandler.CreateToken(securityTokenDescriptor);
            string token = jwtSecurityTokenHandler.WriteToken(securityToken);

            return(token);
        }
        public string GenerateToken(IAuthContainerModel model)
        {
            if (model == null || model.Claims == null || model.Claims.Length == 0)
                throw new ArgumentException("Arguments to create token are not valid.");

            SecurityTokenDescriptor securityTokenDescriptor = new SecurityTokenDescriptor
            {
                Subject = new ClaimsIdentity(model.Claims),
                Expires = DateTime.UtcNow.AddMinutes(Convert.ToInt32(model.ExpireMinutes)),
                SigningCredentials = new SigningCredentials(GetSymmetricSecurityKey(), model.SecurityAlgorithm)
            };

            JwtSecurityTokenHandler jwtSecurityTokenHandler = new JwtSecurityTokenHandler();
            SecurityToken securityToken = jwtSecurityTokenHandler.CreateToken(securityTokenDescriptor);
            string token = jwtSecurityTokenHandler.WriteToken(securityToken);

            return token;
        }
Esempio n. 14
0
        public string GenerateToken(IAuthContainerModel model)
        {
            if (model == null || model.Claims == null || model.Claims.Length == 0)
            {
                throw new ArgumentException("Arguments to create token are not valid.");
            }
            _securityKey = new SymmetricSecurityKey(_signKey);
            _credentials = new SigningCredentials(_securityKey, model.SecurityAlgorithm);
            SecurityTokenDescriptor securityTokenDescriptor = new SecurityTokenDescriptor()
            {
                Subject            = new ClaimsIdentity(model.Claims),
                Expires            = DateTime.UtcNow.AddMinutes(Convert.ToInt32(model.ExpireMinutes)),
                SigningCredentials = _credentials
            };

            _securityToken = _handler.CreateToken(securityTokenDescriptor);
            return(_handler.WriteToken(_securityToken));
        }
Esempio n. 15
0
        // [AllowAnonymous]
        public IHttpActionResult GetToken(string username)
        {
            var people = _reader.Value.ReadUserData();
            var person = people.Where(x => x.Username.Equals(username, StringComparison.InvariantCultureIgnoreCase)).FirstOrDefault();

            if (person == null)
            {
                return(NotFound());
            }
            ;

            IAuthContainerModel model = GetJWTContainerModel(username.ToLower(), person.ID.ToString()); //might remove case sensitivity
            // IAuthContainerModel model = GetJWTContainerModel("a", "test"); //might remove case sensitivity
            IAuthService authService = new JWTService(model.SecretKey);
            string       token       = authService.GenerateToken(model);

            return(Ok(token));
        }
Esempio n. 16
0
        /// <summary>
        /// Создает токен для модели.
        /// Шифрует и возвращает.
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        public string GenerateToken(IAuthContainerModel model)
        {
            if (model == null || model.Claims == null || model.Claims.Length == 0)
            {
                throw new ArgumentException("Недопустимые аргументы для создания токена.");
            }
            SecurityTokenDescriptor securityTokenDescriptor = new SecurityTokenDescriptor
            {
                Subject            = new ClaimsIdentity(model.Claims),
                Expires            = DateTime.UtcNow.AddMinutes(Convert.ToUInt32(model.ExpireMinutes)),
                SigningCredentials = new SigningCredentials(GetSymmetricSecurityKey(), model.SecurityAlgorithm)
            };
            JwtSecurityTokenHandler jwtSecurityTokenHandler = new JwtSecurityTokenHandler();
            SecurityToken           securityToken           = jwtSecurityTokenHandler.CreateToken(securityTokenDescriptor);
            string token = jwtSecurityTokenHandler.WriteToken(securityToken);

            return(token);
        }
Esempio n. 17
0
        static void Main(string[] args)
        {
            IAuthContainerModel model       = GetJWTContainerModel("Moshe Binieli", "*****@*****.**");
            IAuthService        authService = new JWTService(model.SecretKey);

            string token = authService.GenerateToken(model);

            if (!authService.IsTokenValid(token))
            {
                throw new UnauthorizedAccessException();
            }
            else
            {
                List <Claim> claims = authService.GetTokenClaims(token).ToList();

                Console.WriteLine(claims.FirstOrDefault(e => e.Type.Equals(ClaimTypes.Name)).Value);
                Console.WriteLine(claims.FirstOrDefault(e => e.Type.Equals(ClaimTypes.Email)).Value);
            }
        }
Esempio n. 18
0
        public string GenerateToken(IAuthContainerModel model)
        {
            if (model == null || model.Claims == null || model.Claims.Length == 0)
            {
                throw new Exception("Argumentos da model não são válidos para geração do token.");
            }

            var securityTokenDescriptor = new SecurityTokenDescriptor()
            {
                Subject            = new ClaimsIdentity(model.Claims),
                Expires            = DateTime.UtcNow.AddMinutes((int)model.ExpireMinutes),
                SigningCredentials = new SigningCredentials(GetSimmetricSecurityKey(), model.SecurityAlgorithm)
            };

            var jwtSecurityTokenHandler = new JwtSecurityTokenHandler();
            var securityToken           = jwtSecurityTokenHandler.CreateToken(securityTokenDescriptor);
            var token = jwtSecurityTokenHandler.WriteToken(securityToken);

            return(token);
        }
Esempio n. 19
0
        static void Main(string[] args)
        {
            IAuthContainerModel model = GetJwtContainerModel("Ilya Gomel", "*****@*****.**");

            model.Expires = 8;
            IAuthService service = new JWTService(model.SecretKey);

            string token = service.GenerateToken(model);

            if (!service.IsValid(token))
            {
                throw  new UnauthorizedAccessException();
            }
            else
            {
                List <Claim> claims = service.GetTokenClaims(token).ToList();

                Console.WriteLine(claims.FirstOrDefault(c => c.Type.Equals(ClaimTypes.Name))?.Value);
                Console.WriteLine(claims.FirstOrDefault(c => c.Type.Equals(ClaimTypes.Email))?.Value);
            }
        }
        public string GenerateJWTtoken(string name, long cardNumber, string salt)
        {
            IAuthContainerModel model       = GetJWTContainerModel(name, cardNumber, salt);
            IAuthService        authService = new JWTService(model.SecretKey);

            string token = authService.GenerateToken(model);

            if (!authService.IsTokenValid(token))
            {
                throw new UnauthorizedAccessException();
            }
            else
            {
                List <Claim> claims = authService.GetTokenClaims(token).ToList();

                //Console.WriteLine(claims.FirstOrDefault(e => e.Type.Equals(ClaimTypes.Name)).Value);
                //Console.WriteLine(claims.FirstOrDefault(e => e.Type.Equals(ClaimTypes.Email)).Value);
                Console.WriteLine(token);
            }

            return(token);
        }
Esempio n. 21
0
        static void Main(string[] args)
        {
            IAuthContainerModel model       = GetJWTContainerModel("Harsimran Singh", "*****@*****.**");
            IAuthService        authService = new JWTService(model.SecretKey);

            string token = authService.GenerateToken(model);

            if (!authService.IsTokenValid(token))
            {
                throw new UnauthorizedAccessException();
            }
            else
            {
                Console.WriteLine("JSON :\n" + token);
                Console.WriteLine();
                List <Claim> claims = authService.GetTokenClaims(token).ToList();

                Console.WriteLine(claims.FirstOrDefault(e => e.Type.Equals(ClaimTypes.GivenName)).Value);
                Console.WriteLine(claims.FirstOrDefault(e => e.Type.Equals(ClaimTypes.Email)).Value);
                Console.ReadLine();
            }
        }
        public IHttpActionResult GetToken(Login login)
        {
            try
            {
                if (DatabaseAction.LoginAttempt(login.userName, login.password, out Employee user) == "Successfull")
                {
                    var roles = "user";
                    if (user.isAdmin == true)
                    {
                        roles = "admin";
                    }
                    IAuthContainerModel model       = GetJWTContainerModel(user.UserName, roles);
                    IAuthService        authService = new JWTService(model.SecretKey);

                    string token = authService.GenerateToken(model);

                    if (!authService.IsTokenValid(token))
                    {
                        throw new UnauthorizedAccessException();
                    }
                    else
                    {
                        List <Claim> claims = authService.GetTokenClaims(token).ToList();
                    }
                    LogFile.LoginLog(user.FirstName, user.Employee_id);
                    return(Ok(token));
                }
                else
                {
                    return(BadRequest("Invalid Credentials"));
                }
            }
            catch (Exception ex)
            {
                LogFile.WriteLog(ex);
                return(BadRequest());
            }
        }
Esempio n. 23
0
        public string GenerateToken(IAuthContainerModel model)
        {
            if (model == null || model.Claims == null || model.Claims.Count == 0)
            {
                throw new ArgumentNullException(nameof(model));
            }

            var securityTokenDescriptor = new SecurityTokenDescriptor
            {
                Subject               = new ClaimsIdentity(model.Claims),
                Expires               = DateTime.UtcNow.AddMinutes(Convert.ToInt32(model.ExpiryInMinutes)),
                Audience              = _authModel.Audience,
                Issuer                = _authModel.Issuer,
                SigningCredentials    = new SigningCredentials(GetSymmetricSiginingKey(), model.SigningAlgorithm),
                EncryptingCredentials = new EncryptingCredentials(GetSymmetricEncryptionKey(), model.EncryptionAlgorithm, model.EncryptionEncoding)
            };

            var jwtSecurityTokenHandler = new JwtSecurityTokenHandler();
            var securityToken           = jwtSecurityTokenHandler.CreateToken(securityTokenDescriptor);
            var token = jwtSecurityTokenHandler.WriteToken(securityToken);

            return(token);
        }
Esempio n. 24
0
        /// <summary>
        /// Generates token by given model.
        /// Validates whether the given model is valid, then gets the symmetric key.
        /// Encrypt the token and returns it.
        /// </summary>
        /// <param name="model"></param>
        /// <returns>Generated token.</returns>
        public string GenerateToken(IAuthContainerModel model)
        {
            if (model == null || model.Claims == null || model.Claims.Length == 0)
            {
                throw new ArgumentException("Arguments to create token are not valid.");
            }

            SecurityTokenDescriptor securityTokenDescriptor = new SecurityTokenDescriptor
            {
                Subject            = new ClaimsIdentity(model.Claims),
                Expires            = DateTime.UtcNow.AddMinutes(Convert.ToInt32(model.ExpireMinutes)),
                SigningCredentials = new SigningCredentials(new SymmetricSecurityKey(Encoding.ASCII.GetBytes(AppConfigs.Instance.Secret)), model.SecurityAlgorithm),
                //IssuedAt = DateTime.Now,
                //Issuer = AppConfigs.Instance["Auth0:Issuer"],
                //NotBefore = new DateTimeOffset(DateTime.Now).DateTime
            };

            var           jwtSecurityTokenHandler = new JwtSecurityTokenHandler();
            SecurityToken securityToken           = jwtSecurityTokenHandler.CreateToken(securityTokenDescriptor);
            string        token = jwtSecurityTokenHandler.WriteToken(securityToken);

            return(token);
        }
Esempio n. 25
0
        public async Task <object> Login([FromBody] UserLoginInfo info)
        {
            try
            {
                StringValues token;
                Request.Headers.TryGetValue("token", out token);
                string _token = token.FirstOrDefault();
                if (Utilities.IsValidToken(_token))
                {
                    return(Ok(Responder.Success("Already logined")));
                }
                Result result = await userService.LoginAsync(info.username, info.password);

                if (result.status != 200)
                {
                    return(StatusCode(result.status, Responder.Fail(result.data)));
                }
node1:
                HeplerTokenUser user = (HeplerTokenUser)result.data;
                IAuthContainerModel model       = JwtHelper.GetJWTContainerModel(user.userId, user.username, user.email, _jwtConfig);
                IAuthService        authService = new JWTService(model.SecretKey);
                string accessToken = authService.GenerateToken(model);
                if (!authService.IsTokenValid(accessToken))
                {
                    goto node1;
                }
                return(Ok(Responder.Success(new
                {
                    token = accessToken,
                    user = result.data
                })));
            }
            catch (Exception error)
            {
                return(BadRequest(Responder.Fail(error.Message)));
            }
        }
Esempio n. 26
0
        public async Task <IActionResult> GetTokenAsync([Required][FromBody] LoginModel body)
        {
            try
            {
                if (string.IsNullOrEmpty(body.Email) || string.IsNullOrEmpty(body.Password))
                {
                    throw new UnauthorizedAccessException();
                }
                var user = _context.Users.FirstOrDefault(x => x.Email == body.Email);
                if (user == null)
                {
                    throw new UnauthorizedAccessException();
                }

                if (SecurePasswordHasher.Verify(body.Password, user.Password))
                {
                    IAuthContainerModel model       = JwtFunctions.GetJwtContainerModel(user.Id, user.Email);
                    IAuthService        authService = new JwtService(model.SecretKey);

                    var token = authService.GenerateToken(model);

                    return(new OkObjectResult(new
                                              { token, expiresIn = model.ExpireMinutes, user = _mapper.Map <DTOUserModel>(user) }));
                }

                return(new UnauthorizedResult());
            }
            catch (UnauthorizedAccessException)
            {
                return(new UnauthorizedResult());
            }
            catch (Exception ex)
            {
                return(new BadRequestObjectResult(new { error = ex }));
            }
        }
Esempio n. 27
0
        private void set_DbAdmin_Database()
        {
            if (SIS.Client.blvalue.AppMain.AppValue.CloudLicense)
            {
                string _DbAdminDatabase = get_DbKodAdmin_Database(SIS.Client.blvalue.AppMain.AppValue.CustomerGuidId);
                if (_DbAdminDatabase == null)
                {
                    _DbAdminDatabase = "";
                }
                if (_DbAdminDatabase != "")
                {
                    SIS.Client.blvalue.AppMain.AppValue.DbAdminConnectionDTO.Database = _DbAdminDatabase;
                    string connection = SIS.Client.blvalue.AppMain.AppValue.DbAdminConnectionDTO.Connection(blvalue.Cloude);
                    #region Token
                    IAuthService        authService = new JWTService();
                    IAuthContainerModel model       = GetJWTContainerModel("connection", connection);

                    string token = authService.GenerateToken(model);
                    if (!string.IsNullOrEmpty(token))
                    {
                        connection = token;
                    }
                    #endregion

                    SIS.Client.blvalue.AppMain.AppValue.ConAdmin = connection;
                    SIS.Data.App.GetValue _GetValue = SIS.Client.Admin.bl.get_GetValue();
                    _GetValue.ConStr = SIS.Client.blvalue.AppMain.AppValue.ConAdmin;
                    //var result = bl.blcAdmin.Run<Service.Admin.Service.AdminService, SIS.Data.ReturnProcess>(r => r.UpdateSqlDatabase(_GetValue));
                }
                else
                {
                    string connection = SIS.Client.blvalue.AppMain.AppValue.AdminConnectionDTO.Connection(blvalue.Cloude);
                    SIS.Client.blvalue.AppMain.AppValue.ConAdmin = SIS.Client.blvalue.AppMain.CreateJwtToken("connection", connection);
                }
            }
        }
Esempio n. 28
0
 public void Setup()
 {
     model   = JWTContainerModel.GetJWTContainerModel("Dmitry Ershov", "*****@*****.**");
     service = new JWTAuthService(model.SecretKey);
 }
Esempio n. 29
0
 public JwtService(IAuthContainerModel authModel)
 {
     _authModel = authModel;
 }
Esempio n. 30
0
        public async Task <Response <MemberResult> > Login(string id, string pw)
        {
            string apiName = "LOGIN";

            #region Anonymous Method
            LoginBadResponse memberBadResponse = delegate(ConTextColor preColor, int status, ConTextColor setColor, string msg)
            {
                UserModel tempModel        = new UserModel();
                string    tempToken        = "";
                string    tempRefreshToken = "";

                ServiceManager.ShowRequestResult(apiName, preColor, status, setColor);
                return(new Response <MemberResult> {
                    data = new MemberResult {
                        token = tempToken, refreshToken = tempRefreshToken, member = tempModel
                    }, status = status, message = msg
                });
            };
            #endregion

            var loginArgs = ComUtil.GetStringLengths(id, pw);

            if (id != null && pw != null && loginArgs[0] > 0 && loginArgs[1] > 0)
            {
                try
                {
                    UserModel user = new UserModel();

                    using (IDbConnection db = GetConnection())
                    {
                        db.Open();

                        string selectSql = $@"
SELECT
    name, 
    email
FROM 
    member_tb
WHERE
    id = '{id}'
AND
    pw = '{pw}'
;";
                        var    response  = await userDBManager.GetSingleDataAsync(db, selectSql, id);

                        if (response != null)
                        {
                            user.id    = id;
                            user.name  = response.name;
                            user.email = response.email;

                            IAuthContainerModel model       = JWTService.GetJWTContainerModel(user.name, user.email);
                            IAuthService        authService = new JWTService(model.SecretKey);

                            string token = authService.GenerateToken(model);
                            // TODO : RefreshToken 발급. => 현재 임시로 빈 값 보냄

                            if (!authService.IsTokenValid(token))
                            {
                                throw new UnauthorizedAccessException();
                            }
                            else
                            {
                                List <Claim> claims = authService.GetTokenClaims(token).ToList();
                                Console.WriteLine("Login UserName : "******"Login Eamil : " + claims.FirstOrDefault(x => x.Type.Equals(ClaimTypes.Email)).Value);

                                ServiceManager.ShowRequestResult("LOGIN", ConTextColor.LIGHT_GREEN, ResponseStatus.OK, ConTextColor.WHITE);
                                return(new Response <MemberResult> {
                                    data = new MemberResult {
                                        token = token, refreshToken = "", member = user
                                    }, message = ResponseMessage.OK, status = ResponseStatus.OK
                                });
                            }
                        }
                        else
                        {
                            return(memberBadResponse(ConTextColor.RED, ResponseStatus.UNAUTHORIZED, ConTextColor.WHITE, ResponseMessage.UNAUTHORIZED));
                        }
                    }
                }
                catch (Exception e)
                {
                    Console.WriteLine(apiName + " ERROR : " + e.Message);
                    return(memberBadResponse(ConTextColor.PURPLE, ResponseStatus.INTERNAL_SERVER_ERROR, ConTextColor.WHITE, ResponseMessage.INTERNAL_SERVER_ERROR));
                }
            }
            else
            {
                return(memberBadResponse(ConTextColor.RED, ResponseStatus.BAD_REQUEST, ConTextColor.WHITE, ResponseMessage.BAD_REQUEST));
            }
        }