Esempio n. 1
0
        protected virtual async Task <bool> HandleRemoteCallbackAsync()
        {
            var authResult = await HandleRemoteAuthenticateAsync();

            if (authResult == null || !authResult.Succeeded)
            {
                var errorContext = new ErrorContext(Context, authResult?.Error ?? new Exception("Invalid return state, unable to redirect."));
                Logger.LogInformation("Error from RemoteAuthentication: " + errorContext.Error.Message);
                await Options.Events.RemoteError(errorContext);

                if (errorContext.HandledResponse)
                {
                    return(true);
                }
                if (errorContext.Skipped)
                {
                    return(false);
                }

                Context.Response.StatusCode = 500;
                return(true);
            }

            // We have a ticket if we get here
            var ticket  = authResult.Ticket;
            var context = new TicketReceivedContext(Context, Options, ticket)
            {
                ReturnUri = ticket.Properties.RedirectUri,
            };

            // REVIEW: is this safe or good?
            ticket.Properties.RedirectUri = null;

            await Options.Events.TicketReceived(context);

            if (context.HandledResponse)
            {
                Logger.LogVerbose("The SigningIn event returned Handled.");
                return(true);
            }
            else if (context.Skipped)
            {
                Logger.LogVerbose("The SigningIn event returned Skipped.");
                return(false);
            }

            await Context.Authentication.SignInAsync(Options.SignInScheme, context.Principal, context.Properties);

            // Default redirect path is the base path
            if (string.IsNullOrEmpty(context.ReturnUri))
            {
                context.ReturnUri = "/";
            }

            Response.Redirect(context.ReturnUri);
            return(true);
        }
Esempio n. 2
0
        internal static Task OnTicketReceived(TicketReceivedContext context)
        {
            if (context.Principal != null && context.Options.SignInScheme == new IdentityCookieOptions().ExternalCookieAuthenticationScheme)
            {
                //This way we will know all events were fired.
                var identity = context.Principal.Identities.First();
                var manageStoreClaim = identity?.Claims.Where(c => c.Type == "ManageStore" && c.Value == "false").FirstOrDefault();
                if (manageStoreClaim != null)
                {
                    identity.RemoveClaim(manageStoreClaim);
                    identity.AddClaim(new Claim("ManageStore", "Allowed"));
                }
            }

            return Task.FromResult(0);
        }
 public override Task TicketReceived(TicketReceivedContext context)
 {
     return base.TicketReceived(context);
 }
 /// <summary>
 /// Invoked after the remote ticket has been recieved.
 /// </summary>
 public virtual Task TicketReceived(TicketReceivedContext context) => OnTicketReceived(context);
Esempio n. 5
0
 /// <summary>
 /// Invoked after the remote ticket has been recieved.
 /// </summary>
 public virtual Task TicketReceived(TicketReceivedContext context) => OnTicketReceived(context);