/// <inheritdoc/>
        public bool IsAnonymous(BaseTokenModel token)
        {
            if (token != null && token.RoleClaims != null)
            {
                return(!token.RoleClaims.Contains(RoleType.User.ToString()));
            }

            return(true);
        }
        private void SetBaseToken(BaseTokenModel token, UserModel user)
        {
            int now = DateTime.Now.ToUnix();

            token.Sub        = user.Id;
            token.Iss        = configuration.Options.AuthOptions.JwtOptions.Issuer;
            token.Aud        = configuration.Options.AuthOptions.JwtOptions.Audience;
            token.Nbf        = now;
            token.Iat        = now;
            token.RoleClaims = user.Roles;
        }
        public async Task <BaseTokenModel> LoginAsync([FromBody] LoginDTO loginDTO)
        {
            BaseTokenModel baseTokenModel = new BaseTokenModel();

            try
            {
                if (loginDTO == null)
                {
                    baseTokenModel.Message    = _iStringConstant.InvalidRequest;
                    baseTokenModel.StatusCode = (int)EnumList.ResponseType.Error;
                }
                else
                {
                    BaseResponse responseModel = await _iAccountRepository.ValidateUserAsync(loginDTO);

                    if (responseModel.StatusCode == (int)EnumList.ResponseType.Success)
                    {
                        UserTokenDTO userData = (UserTokenDTO)responseModel.Data;

                        var secretKey          = new SymmetricSecurityKey(Encoding.UTF8.GetBytes("KeyForSignInDeepakAPI@123"));
                        var signingCredentials = new SigningCredentials(secretKey, SecurityAlgorithms.HmacSha256);

                        //For calime which we get the data from accessToken
                        var claims = new[] {
                            new Claim("FirstName", userData.FirstName),
                            new Claim("LastName", userData.LastName),
                            new Claim("MobileNumber", userData.MobileNumber),
                            new Claim(ClaimTypes.NameIdentifier, userData.Id.ToString()),
                            new Claim("Email", userData.Email)
                        };

                        //Create token based on our claims and signingCredentials
                        var tokeOptions = new JwtSecurityToken(
                            issuer: _config["Jwt:ValidIssuer"],
                            audience: _config["Jwt:ValidIssuer"],
                            claims: claims,
                            expires: DateTime.Now.AddDays(1),
                            signingCredentials: signingCredentials
                            );
                        var tokenString = new JwtSecurityTokenHandler().WriteToken(tokeOptions);

                        baseTokenModel.Id           = userData.Id.ToString();
                        baseTokenModel.FirstName    = userData.FirstName;
                        baseTokenModel.LastName     = userData.LastName;
                        baseTokenModel.Email        = userData.Email;
                        baseTokenModel.MobileNumber = userData.MobileNumber;
                        baseTokenModel.AccessToken  = tokenString;
                        baseTokenModel.Message      = _iStringConstant.LoginSuccessfull;
                        baseTokenModel.StatusCode   = Convert.ToInt32(EnumList.ResponseType.Success);
                    }
                    else
                    {
                        baseTokenModel.Message    = responseModel.Message;
                        baseTokenModel.StatusCode = responseModel.StatusCode;
                    }
                }
            }
            catch (Exception ex)
            {
                _logger.LogError(ex.Message);
                baseTokenModel.Message    = ex.Message;
                baseTokenModel.StatusCode = Convert.ToInt32(EnumList.ResponseType.Exception);
            }
            return(baseTokenModel);
        }