How do I create an external login provider?

[weirdyang]

I've been trying to implement a dummy external login provider, and using the OrchardCore.Users module as a reference.

However, this line of code always returns null:

        `var info = await _signInManager.GetExternalLoginInfoAsync();`

and I need the info data to have the userManager add a login:

        internal async Task<IUser> RegisterUser(RegisterViewModel model)
        {
            var info = await _signInManager.GetExternalLoginInfoAsync();
            var user = await _userService.CreateUserAsync(new User 
            { 
                UserName = model.UserName, 
                Email = model.Email, 
                EmailConfirmed = true, 
                IsEnabled = true,
            }, model.Password, (key, message) => this.ModelState.AddModelError(key, message)) as User;
            var allErrors = ModelState.Values.SelectMany(v => v.Errors);
            if (user is null)
            {
                return null;
            }
            await _signInManager.SignInAsync(user, isPersistent: false);
            var identityResult = await _signInManager
                .UserManager
                .AddLoginAsync(user, 
                new UserLoginInfo(
                    info.LoginProvider, 
                    info.ProviderKey, 
                    info.ProviderDisplayName));

            return user;
        }

How does the signInManager resolve the external login info?

[weirdyang]

The part that I am stuck is how do I go from the HandleRemoteAuthenticationAsync to another controller method where I create and link an orchardcore user to this external login

    public class RemoteOptions : RemoteAuthenticationOptions
    {
        public string AuthorizationEndpoint { get; set; } = "/remote-login";

        public static readonly string AuthenticationScheme = "remote";

        public static readonly string CallBackPath = "/signin-remote";
    }

    public class RemoteOptionsConfiguration :
        IConfigureOptions<AuthenticationOptions>,
        IConfigureNamedOptions<RemoteOptions>
    {
        private readonly IDataProtectionProvider _dataProtectionProvider;
        private readonly ShellSettings _shellSettings;
        private readonly ILogger _logger;
        private readonly string _tenantPrefix;

        public RemoteOptionsConfiguration(
            IDataProtectionProvider dataProtectionProvider,
            ShellSettings shellSettings,
            ILogger<RemoteOptionsConfiguration> logger)
        {
            _dataProtectionProvider = dataProtectionProvider;
            _shellSettings = shellSettings;
            _tenantPrefix = "/" + shellSettings.RequestUrlPrefix;
            _logger = logger;
        }

        public void Configure(AuthenticationOptions options)
        {

            options.AddScheme("ArcstoneLogin", builder =>
            {
                builder.DisplayName = "RemoteLogin";
                builder.HandlerType = typeof(RemoteHandler);
            });
        }

        public void Configure(string name, RemoteOptions options)
        {
            if (!String.Equals(name, RemoteOptions.AuthenticationScheme))
            {
                return;
            }
            options.SignInScheme = "Identity.External";
            options.SaveTokens = false;
            options.CallbackPath = new Microsoft.AspNetCore.Http.PathString(RemoteOptions.CallBackPath);
        }

        public void Configure(RemoteOptions options) => Debug.Fail("This infrastructure method shouldn't be called.");

    }

    public class RemoteHandler : RemoteAuthenticationHandler<RemoteOptions>
    {
        public RemoteHandler(
            IOptionsMonitor<RemoteOptions> options, 
            ILoggerFactory logger, 
            UrlEncoder encoder, 
            ISystemClock clock)
            : base(options, logger, encoder, clock)
        {
        }

        protected override async Task HandleChallengeAsync(AuthenticationProperties properties)
        {
            await Task.CompletedTask;
            string auth = OriginalPathBase + OriginalPathBase + Options.AuthorizationEndpoint;
            Response.Redirect(string.Format("{0}?callbackPath={1}",
                auth,
                Options.CallbackPath));
        }

        protected override async Task<HandleRequestResult> HandleRemoteAuthenticateAsync()
        {
            await Task.CompletedTask;
            string name = Request.Query["name"];

            if (string.IsNullOrWhiteSpace(name))
            {
                return HandleRequestResult.NoResult();
            }

            var claimsIdentity = new ClaimsIdentity(new List<Claim>
            {
                new Claim(ClaimTypes.NameIdentifier, name)
            }, RemoteOptions.AuthenticationScheme);

            var claimsPrincipal = new ClaimsPrincipal(claimsIdentity);
            var ticket = new AuthenticationTicket(claimsPrincipal, RemoteOptions.AuthenticationScheme);
            return HandleRequestResult.Success(ticket);
        }
    }

The cookie is created:

Any help will be much appreciated

[weirdyang]

ok I've figured it out, will share the code if anyone's interested