Authentification de l'API Core .NET à l'aide d'Identity Server 4

Dans le flux de ressourcesSOWNERPASSWROD, vous pouvez conserver votre enregistrement et connecter la fonctionnalité à la clientèle et vous pouvez valider l'utilisateur à l'utilisateur de la base de données.

Vous devez implémenter votre utilisateur personnalisé pour la validation de l'utilisateur et l'ajout de revendications de la base de données. Modifier le code de démarrage Comme ci-dessous, l'USEREREPOSITORY Classe représente la communication de la base de données pour authentifier l'utilisateur et obtenir des réclamations à partir de la base de données: P>

Médiez la méthode de configuration de mise à jour pour la configuration d'identité: p>

public static class CustomIdentityServerBuilderExtensions
{
    public static IIdentityServerBuilder AddCustomUserStore(this IIdentityServerBuilder builder)
    {                   
        builder.AddProfileService<UserProfileService>();           
        builder.AddResourceOwnerValidator<UserResourceOwnerPasswordValidator>();
        return builder;
    }
}

public class UserProfileService : IProfileService
{
    public async Task GetProfileDataAsync(ProfileDataRequestContext context)
    {
            UserRepository userRepository=new UserRepository();
            var user = userRepository.GetUserById(int.Parse(context.Subject.GetSubjectId()));
            if (user != null)
            {
                var userTokenModel = _mapper.Map<UserTokenModel>(user);
                var claims = new List<Claim>();
                claims.Add(new Claim("UserId", user.UserId));
                // Add another claims here 
                context.IssuedClaims.AddRange(claims);                    
    }
    public async Task IsActiveAsync(IsActiveContext context)
    {          
    }
}

public class UserResourceOwnerPasswordValidator : IResourceOwnerPasswordValidator
{        
    public async Task ValidateAsync(ResourceOwnerPasswordValidationContext context)
    {           
            UserRepository userRepository=new UserRepository();
            var userLoginStatus = userRepository.GetUserById(context.UserName, context.Password);

            if (userLoginStatus != null)
            {

                    context.Result = new GrantValidationResult(userLoginStatus.UserId.ToString(),
                         OidcConstants.AuthenticationMethods.Password);                   
            }
            else
            {                    
                context.Result = new GrantValidationResult(TokenRequestErrors.InvalidClient, 
                        "Wrong Credentials");
            }            
    }
}

Comment puis-je ajouter les utilisateurs à ma base de données et authentifier l'utilisateur de la base de données et non le test. p>

Une autre chose que je ne comprends pas est l'endroit où je devrais mettre la fonctionnalité de connexion et enregistrer et comment ce code ressemblera. P> blockQuote>

Il existe un moyen de créer un exemple de travail conforme à vos exigences en utilisant principalement des implémentations à partir d'ItalyServer4 QuickStarts. P>

Les étapes sont (à l'aide de la base de données SQL): P>

Créez un projet de base MVC à l'aide de la gabarit IS4Aspid DotNet. Il configurera IdentityServer en tant que middleware pour le projet, vous pouvez mettre à jour la base de données avec la migration prête pour créer toutes les tables pour l'identité de base ASP.NET et la connexion, la déconnexion, le consentement, la fonctionnalité des subventions (UI) pour ItalyServer. (Dans CreeeticidentalSchema.cs Fichier Avant DB Mettre à jour, remplacez l'annotation de la colonne Identity pour vous conformer à la base de données SQL conformément à: Annotation («SQLSERVER: ValueGenerationStrategy», SQLServerValueGenerationtrategy.identityColumn), Schema dans le modèle est pour la base de données SQLITE) P> li>

Activer les pages RAZORE dans Startup.cs de MVC Core Project, ajout de services.AntazorPages () et des points finaux.Maprazorpages (), il sera alors possible d'ajouter des échafaudages et vous pouvez ajouter toutes les pages dont vous avez besoin pour vous inscrire et Maintenir les comptes d'utilisateurs (locaux et fournisseurs externes) à l'aide de la bibliothèque de classes de rasoir. Les pages de connexion et de déconnexion doivent rester sous le contrôle de ItalyServer pour un but d'authentification. P> li>

Ensuite, vous pouvez utiliser ConfigurationDBContext, persistedgrantdbcontext de contextes et leurs entités à partir du package ItalyServer4.entityFramework.storage Nuget pour créer une migration et une mise à jour de la base de données d'identité ASP.Net existante, ainsi que des tables pour les clients, les ressources et les étanches. données opérationnelles telles que les codes d'autorisation et rafraîchir les jetons. Pour ajouter, supprimer ou mettre à jour les données sur ces tables, vous pouvez créer manuellement une interface à l'aide de ces deux contextes. P> li>

La dernière étape consiste à créer des projets client et API en fonction de QuickStarts et de les configurer avec ItalyServer à utiliser. P> li> ol>

Démarrage.Cs Fichier à la fin sera le suivant: P>

    public class Startup
{
    public IWebHostEnvironment Environment { get; }
    public IConfiguration Configuration { get; }

    public Startup(IWebHostEnvironment environment, IConfiguration configuration)
    {
        Environment = environment;
        Configuration = configuration;
    }

    public void ConfigureServices(IServiceCollection services)
    {
        services.AddScoped<IEmailSender, EmailSender>();

        services.AddControllersWithViews();

        services.Configure<IISOptions>(iis =>
        {
            iis.AuthenticationDisplayName = "Windows";
            iis.AutomaticAuthentication = false;
        });

        services.Configure<IISServerOptions>(iis =>
        {
            iis.AuthenticationDisplayName = "Windows";
            iis.AutomaticAuthentication = false;
        });

        var migrationsAssembly =    typeof(Startup).GetTypeInfo().Assembly.GetName().Name;

        services.AddDbContext<ApplicationDbContext>(options =>
            options.UseSqlServer(Configuration.GetConnectionString("DefaultConnection")));

        services.AddIdentity<ApplicationUser, IdentityRole>()
            .AddEntityFrameworkStores<ApplicationDbContext>()
            .AddDefaultTokenProviders();
        
        var builder = services.AddIdentityServer(options =>
            {
                options.Events.RaiseErrorEvents = true;
                options.Events.RaiseInformationEvents = true;
                options.Events.RaiseFailureEvents = true;
                options.Events.RaiseSuccessEvents = true;
            })
            .AddConfigurationStore(options =>
            {
                options.ConfigureDbContext = b =>   b.UseSqlServer(Configuration.GetConnectionString("DefaultConnection"),
                    sql => sql.MigrationsAssembly(migrationsAssembly));
            })
            .AddOperationalStore(options =>
            {
                options.ConfigureDbContext = b =>           b.UseSqlServer(Configuration.GetConnectionString("DefaultConnection"),
                    sql => sql.MigrationsAssembly(migrationsAssembly));
            })
            .AddAspNetIdentity<ApplicationUser>();

        builder.AddDeveloperSigningCredential();

        services.AddRazorPages();

        services.AddAuthentication()
            .AddGoogle(options =>
            {
                options.ClientId = "copy client ID from Google here";
                options.ClientSecret = "copy client secret from Google here";
            });
    }

    public void Configure(IApplicationBuilder app)
    {
        if (Environment.IsDevelopment())
        {
            app.UseDeveloperExceptionPage();
            app.UseDatabaseErrorPage();
        }

        app.UseStaticFiles();

        app.UseRouting();
        app.UseIdentityServer();
        app.UseAuthorization();
        app.UseEndpoints(endpoints =>
        {
            endpoints.MapDefaultControllerRoute();
            endpoints.MapRazorPages();
        });
    }

}