public override Task TokenEndpoint(OAuthTokenEndpointContext context)
        {
            foreach (var claim in context.Identity.Claims)
            {
                if (claim.Type == ClaimTypes.Email)
                {
                    context.AdditionalResponseParameters.Add("email", claim.Value);
                }

                if (claim.Type == ClaimTypes.Role)
                {
                    context.AdditionalResponseParameters.Add("role", claim.Value);
                }

                if (claim.Type == ClaimTypes.MobilePhone)
                {
                    context.AdditionalResponseParameters.Add("mobile_number", claim.Value);
                }

                if (claim.Type == ClaimTypes.Country)
                {
                    context.AdditionalResponseParameters.Add("country", claim.Value);
                }

                if(claim.Type == "MobileNumberConfirmed")
                {
                    context.AdditionalResponseParameters.Add("mobile_number_confirmed", claim.Value);
                }
            }

            return Task.FromResult<object>(null);
        }

 public override async Task TokenEndpoint(OAuthTokenEndpointContext context)
 {
     foreach (KeyValuePair<string, string> property in context.Properties.Dictionary)
     {
         context.AdditionalResponseParameters.Add(property.Key, property.Value);
     }
 }

        public override Task TokenEndpoint(OAuthTokenEndpointContext context) {
            foreach (KeyValuePair<string, string> property in context.Properties.Dictionary) {
                context.AdditionalResponseParameters.Add(property.Key, property.Value);
            }

            return Task.FromResult<object>(null);
        }

 public override Task TokenEndpoint(OAuthTokenEndpointContext context)
 {
     var isFilledClaim = context.Identity.Claims.FirstOrDefault(x => x.Type == "profileFiled");
     if (isFilledClaim != null)
     {
         var isFilled = isFilledClaim.Value;
         context.AdditionalResponseParameters.Add("isFilled",bool.Parse(isFilled));
     }
     return base.TokenEndpoint(context);
 }

 /// <summary>
 /// Is used to add additional return values to the token response message
 /// </summary>
 public override Task TokenEndpoint(OAuthTokenEndpointContext context)
 {
     foreach (var property in context.Properties.Dictionary)
     {
         context.AdditionalResponseParameters.Add(property.Key, property.Value);
     }
     //var userSessionClaim = context.Identity.FindFirst(claim => claim.Type == ApiConstants.Claims.UserSessionID);
     //context.AdditionalResponseParameters.Add(userSessionClaim.Type, userSessionClaim.Value);
     return Task.FromResult<object>(null);
 }

        public override Task TokenEndpoint(OAuthTokenEndpointContext context)
        {

            #region " Getting time to update service country and lease time "
            Int32 UpdateTimeInMinutes = 5;
            if (WebConfigurationManager.AppSettings["UpdateTimeInMinutes"] != null && WebConfigurationManager.AppSettings["UpdateTimeInMinutes"].Trim().Length > 0)
            {
                UpdateTimeInMinutes = Convert.ToInt32(WebConfigurationManager.AppSettings["UpdateTimeInMinutes"].Trim());
            }
            #endregion

            #region " Getting Token Expiry Time from Config file "
            Int32 days = 0;
            if (WebConfigurationManager.AppSettings["ExpiryDateTimeInDays"] != null && WebConfigurationManager.AppSettings["ExpiryDateTimeInDays"].Trim().Length > 0)
            {
                days = Convert.ToInt32(WebConfigurationManager.AppSettings["ExpiryDateTimeInDays"].Trim());
            } 
            #endregion

            #region " Assigning Token Expiry Time "
            foreach (KeyValuePair<string, string> property in context.Properties.Dictionary)
            {
                //.expires
                if (property.Key == ".expires")
                {
                    context.AdditionalResponseParameters.Add(property.Key, DateTime.Today.AddDays(days));
                }
                else if (property.Key == "expires_in")
                {
                    int seconds = days * 60 * 60;
                    context.AdditionalResponseParameters.Add(property.Key, seconds);
                }
                else
                {
                    context.AdditionalResponseParameters.Add(property.Key, property.Value);
                }

            } 
            #endregion

            #region " Writting values in Response object "
            context.AdditionalResponseParameters.Add("userName", userADName);
            context.AdditionalResponseParameters.Add("userEmail", userADEmail);
            context.AdditionalResponseParameters.Add("userPhone", userADPhone);
            context.AdditionalResponseParameters.Add("UpdateTimeInMinutes", UpdateTimeInMinutes); 
            #endregion
            return Task.FromResult<object>(null);
        }

        public override Task TokenEndpoint(OAuthTokenEndpointContext context)
        {
            if (context == null)
            {
                throw new ArgumentNullException("context");
            }

            var claims = context.Identity.Claims.ToArray();
            foreach (var claim in claims)
            {
                if (claim.ValueType == "self")
                {
                    context.AdditionalResponseParameters[claim.Type] = claim.Value;
                    context.Identity.RemoveClaim(claim);
                }
            }
            return base.TokenEndpoint(context);
        }

 public override Task TokenEndpoint(OAuthTokenEndpointContext context)
 {
     foreach (KeyValuePair<string, string> property in context.Properties.Dictionary)
     {
         context.AdditionalResponseParameters.Add(property.Key, property.Value);
     }
     # region Response back some additional parameters by using /Token method OR Identity
     if (HttpContext.Current.Request.Browser["IsMobileDevice"] == "true")
     {
         context.AdditionalResponseParameters.Add("AntiForgeryToken", deviceId);
     }
     else 
     {
         context.AdditionalResponseParameters.Add("AntiForgeryToken", ip);
     }
     #endregion
     return Task.FromResult<object>(null);
 }

        public override async Task TokenEndpoint(OAuthTokenEndpointContext context)
        {


           
                context.AdditionalResponseParameters.Add("empresaId", _usuario.EmpresaId);
                context.AdditionalResponseParameters.Add("ImagemUsuario", _usuario.ImagemUsuario);
                context.AdditionalResponseParameters.Add("EmpresaImagem", _usuario.Empresa.EmpresaImagem);
                context.AdditionalResponseParameters.Add("NomeEmpresa", _usuario.Empresa.NomeEmpresa);

            foreach (var role in _roles)
            {
                context.AdditionalResponseParameters.Add("roles", role.Key);
                context.AdditionalResponseParameters.Add("IdRole", role.Value);
            }

            await Task.FromResult(context);

        }

        public override Task TokenEndpoint(OAuthTokenEndpointContext context)
        {
            var issued = context.Properties.Dictionary[".issued"];
            var expires = context.Properties.Dictionary[".expires"];
            var roles = context.Properties.Dictionary["roles"];
            var userId = context.Properties.Dictionary["userId"];
            var userName = context.Properties.Dictionary["userName"];
            var firstName = context.Properties.Dictionary["firstName"];
            var lastName = context.Properties.Dictionary["lastName"];

            context.AdditionalResponseParameters.Add(".issued", issued);
            context.AdditionalResponseParameters.Add(".expires", expires);
            context.AdditionalResponseParameters.Add("roles", roles);
            context.AdditionalResponseParameters.Add("userId", userId);
            context.AdditionalResponseParameters.Add("userName", userName);
            context.AdditionalResponseParameters.Add("firstName", firstName);
            context.AdditionalResponseParameters.Add("lastName", lastName);

            return Task.FromResult<object>(null);
        }

 public Task TokenEndpoint(OAuthTokenEndpointContext context)
 {
     throw new NotImplementedException();
 }

        /// <summary>
        /// Called at the final stage of a successful Token endpoint request. An application may implement this call in order to do any final 
        /// modification of the claims being used to issue access or refresh tokens. This call may also be used in order to add additional 
        /// response parameters to the Token endpoint's json response body.
        /// </summary>
        /// <param name="context">The context of the event carries information in and results out.</param>
        /// <returns>Task to enable asynchronous execution</returns>
        public override Task TokenEndpoint(OAuthTokenEndpointContext context)
        {
            // Add all entries that we've added to the validated ticket (using the AuthenticationProperties):
            foreach (KeyValuePair<string, string> property in context.Properties.Dictionary)
            {
                context.AdditionalResponseParameters.Add(property.Key, property.Value);
            }

            return Task.FromResult<object>(null);
        }

 public override Task TokenEndpoint(OAuthTokenEndpointContext context)
 {
     foreach (KeyValuePair<string, string> property in context.Properties.Dictionary)
     {
         context.AdditionalResponseParameters.Add(property.Key, property.Value);
     }
     //to jest tymczasowe rozwiązanie , czyli pewnie juz tak zostanie 
     context.AdditionalResponseParameters.Add("roles",
         context.Identity.Name == "Admin" ? "Admin" : "User");
     return Task.FromResult<object>(null);
 }

 public override Task TokenEndpoint(OAuthTokenEndpointContext context)
 {
     //Called at the final stage of a successful Token endpoint request. do any final modification of the claims being used to issue access or refresh tokens
     return base.TokenEndpoint(context);
 }

 public override Task TokenEndpoint(OAuthTokenEndpointContext context)
 {
     foreach (KeyValuePair<string, string> keyValuePair in (IEnumerable<KeyValuePair<string, string>>)context.Properties.Dictionary)
         context.AdditionalResponseParameters.Add(keyValuePair.Key, (object)keyValuePair.Value);
     return (Task)Task.FromResult<object>((object)null);
 }

        public override Task TokenEndpoint(OAuthTokenEndpointContext context)
        {
            foreach (var property in context.Properties.Dictionary)
            {
                context.AdditionalResponseParameters.Add(property.Key, property.Value);
            }
            if (!context.AdditionalResponseParameters.ContainsKey("UserId"))
            {
                context.AdditionalResponseParameters.Add("UserId", context.Identity.GetUserId());
            }
            else
            {
                context.AdditionalResponseParameters["UserId"] = context.Identity.GetUserId();
            }

            return Task.FromResult<object>(null);
        }

        /// <summary>
        /// Called at the final stage of a successful Token endpoint request. An application may implement this call in order to do any final
        /// modification of the claims being used to issue access or refresh tokens. This call may also be used in order to add additional
        /// response parameters to the Token endpoint's json response body.
        /// </summary>
        /// <param name="context">The context of the event carries information in and results out.</param>
        /// <returns>
        /// Task to enable asynchronous execution
        /// </returns>
        public override Task TokenEndpoint(OAuthTokenEndpointContext context)
        {
         
            var userType = context.OwinContext.Get<string>("user_type");

            context.AdditionalResponseParameters.Add("user_type", userType);


            return Task.FromResult<object>(null);
        }

 public override Task TokenEndpoint(OAuthTokenEndpointContext context)
 {
     foreach (KeyValuePair<string, string> keyValuePair in context.Properties.Dictionary)
     {
         if (keyValuePair.Key == "isFirstLogin")
         {
             bool result;
             if (!bool.TryParse(keyValuePair.Value, out result))
                 result = false;
             context.AdditionalResponseParameters.Add(keyValuePair.Key, result ? 1 : 0);
         }
         else
             context.AdditionalResponseParameters.Add(keyValuePair.Key, keyValuePair.Value);
     }
     if (context.Properties.Dictionary["as:client_id"] == "MMuaVe")
     {
         var list = context.OwinContext.Get<IList<Claim>>("data:claims");
         if (list != null)
         {
             foreach (KeyValuePair<string, string> keyValuePair in _mobileProfileClaims)
             {
                 KeyValuePair<string, string> profileClaim = keyValuePair;
                 Claim claim = list.FirstOrDefault(m => m.Type == profileClaim.Key);
                 if (claim != null)
                     context.AdditionalResponseParameters.Add(profileClaim.Value, string.IsNullOrEmpty(claim.Value) ? string.Empty : claim.Value);
                 else
                     context.AdditionalResponseParameters.Add(profileClaim.Value, string.Empty);
             }
         }
     }
     return Task.FromResult<object>(null);
 }

 public override async Task TokenEndpoint(OAuthTokenEndpointContext context)
 {
     using (var repo = new AuthRepository())
     {
         var role = context.Identity.Claims.First(c => c.Type == ClaimTypes.Role).Value;
             
         context.AdditionalResponseParameters.Add("role", role);
     }
 }

        public override Task TokenEndpoint(OAuthTokenEndpointContext context)
        {
            //Serialize useful information to token here
            if (context.Identity != null)
            {
                var roles = context.Identity.FindAll(ClaimTypes.Role)
                   .Select(x => x.Value)
                   .ToArray();
                var userNameClaim = context.Identity.FindFirst(ClaimTypes.Name);
                var userIdClaim = context.Identity.FindFirst(ClaimTypes.Sid);
                if (userNameClaim == null || userIdClaim == null)
                {
                    throw new InvalidOperationException("User id or user name claim is missing from the identity.");
                }
                context.AdditionalResponseParameters.Add("roles", JsonConvert.SerializeObject(roles));
                context.AdditionalResponseParameters.Add("userName", userNameClaim.Value);
                context.AdditionalResponseParameters.Add("userId", userIdClaim.Value);
            }

            return base.TokenEndpoint(context);
        }