Bielu.AspNetCore.Identity.Ldap

using Bielu.AspNetCore.Identity.Ldap.Extensions;

var builder = WebApplication.CreateBuilder(args);

// Calls AddIdentity + registers LdapOptions, ILdapService, and LDAP stores
builder.Services.AddLdapIdentity(builder.Configuration);

builder.Services.AddLdapIdentity(builder.Configuration, sectionName: "MyApp:Directory");

builder.Services.AddLdapIdentity(options =>
{
    options.Host = "ldap.example.com";
    options.Port = 636;
    options.UsesSsl = true;
    options.BindDn = "cn=readonly,dc=example,dc=com";
    options.BindPassword = "secret";
    options.UserSearchBase = "ou=People,dc=example,dc=com";
    options.UserSearchFilter = "(&(objectClass=person)(uid={0}))";
    options.GroupSearchBase = "ou=Groups,dc=example,dc=com";
    options.GroupSearchFilter = "(&(objectClass=groupOfNames)(member={0}))";
});

using Bielu.AspNetCore.Identity.Ldap;
using Bielu.AspNetCore.Identity.Ldap.Extensions;

builder.Services
    .AddIdentity<LdapUser, LdapRole>(options =>
    {
        // Configure Identity options (lockout, password rules, etc.)
        options.SignIn.RequireConfirmedAccount = false;
    })
    .AddLdapStores(builder.Configuration);  // registers LdapOptions, ILdapService, and stores

using Bielu.AspNetCore.Identity.Ldap.Abstractions;
using Bielu.AspNetCore.Identity.Ldap.Extensions;

// EF owns the Identity stores
builder.Services.AddIdentity<ApplicationUser, IdentityRole>()
    .AddEntityFrameworkStores<AppDbContext>();

// Register LDAP as a service (no stores — just ILdapService for credential validation)
builder.Services.AddLdapServices(builder.Configuration);

public class HybridLoginService
{
    private readonly ILdapService _ldap;
    private readonly UserManager<ApplicationUser> _users;
    private readonly SignInManager<ApplicationUser> _signIn;

    public HybridLoginService(
        ILdapService ldap,
        UserManager<ApplicationUser> users,
        SignInManager<ApplicationUser> signIn)
    {
        _ldap = ldap;
        _users = users;
        _signIn = signIn;
    }

    public async Task<SignInResult> LoginAsync(string username, string password)
    {
        // Try LDAP first
        if (await _ldap.ValidateCredentialsAsync(username, password))
        {
            // Find or create a local EF user linked to the LDAP account
            var user = await _users.FindByNameAsync(username);
            if (user is null)
            {
                var ldapEntry = await _ldap.FindUserAsync(username);
                user = new ApplicationUser
                {
                    UserName = username,
                    Email = ldapEntry?.GetAttribute("mail"),
                    AuthenticationSource = "LDAP",
                };
                var createResult = await _users.CreateAsync(user);
                if (!createResult.Succeeded)
                {
                    return SignInResult.Failed;
                }
            }

            await _signIn.SignInAsync(user, isPersistent: false);
            return SignInResult.Success;
        }

        // Fall back to local password
        return await _signIn.PasswordSignInAsync(username, password, false, false);
    }
}

using Bielu.AspNetCore.Identity.Ldap;
using Bielu.AspNetCore.Identity.Ldap.Extensions;
using Microsoft.AspNetCore.Components.Authorization;
using Microsoft.AspNetCore.Identity;

var builder = WebApplication.CreateBuilder(args);

// 1. Register Identity with LDAP stores (builds on top of AddIdentity)
builder.Services
    .AddIdentity<LdapUser, LdapRole>()
    .AddLdapStores(builder.Configuration);

// 2. Add authentication & authorization
builder.Services.AddAuthentication(options =>
{
    options.DefaultScheme = IdentityConstants.ApplicationScheme;
    options.DefaultSignInScheme = IdentityConstants.ExternalScheme;
})
.AddCookie(IdentityConstants.ApplicationScheme);

builder.Services.AddAuthorization();
builder.Services.AddCascadingAuthenticationState();

// 3. Add Blazor services
builder.Services.AddRazorComponents()
    .AddInteractiveServerComponents();

var app = builder.Build();

app.UseAuthentication();
app.UseAuthorization();
app.UseAntiforgery();

app.MapRazorComponents<App>()
    .AddInteractiveServerRenderMode();

app.Run();

using Bielu.AspNetCore.Identity.Ldap;
using Bielu.AspNetCore.Identity.Ldap.Extensions;
using Microsoft.AspNetCore.Identity;

var builder = WebApplication.CreateBuilder(args);

builder.Services
    .AddIdentity<LdapUser, LdapRole>()
    .AddLdapStores(builder.Configuration);

builder.Services.AddAuthentication(options =>
{
    options.DefaultScheme = IdentityConstants.ApplicationScheme;
})
.AddCookie(IdentityConstants.ApplicationScheme);

builder.Services.AddAuthorization();

var app = builder.Build();

app.UseAuthentication();
app.UseAuthorization();

// Minimal API login endpoint for the WASM client
app.MapPost("/api/login", async (
    LoginRequest request,
    SignInManager<LdapUser> signInManager) =>
{
    var result = await signInManager.PasswordSignInAsync(
        request.Username, request.Password,
        isPersistent: false, lockoutOnFailure: false);

    return result.Succeeded
        ? Results.Ok()
        : Results.Unauthorized();
});

app.MapPost("/api/logout", async (SignInManager<LdapUser> signInManager) =>
{
    await signInManager.SignOutAsync();
    return Results.Ok();
});

app.MapGet("/api/me", (HttpContext context) =>
{
    if (context.User.Identity?.IsAuthenticated != true)
        return Results.Unauthorized();

    return Results.Ok(new
    {
        Name = context.User.Identity.Name,
        Roles = context.User.Claims
            .Where(c => c.Type == System.Security.Claims.ClaimTypes.Role)
            .Select(c => c.Value)
    });
}).RequireAuthorization();

app.MapRazorPages();
app.MapFallbackToFile("index.html");

app.Run();

record LoginRequest(string Username, string Password);

using Bielu.AspNetCore.Identity.Ldap;
using Bielu.AspNetCore.Identity.Ldap.Extensions;
using Microsoft.AspNetCore.Identity;

var builder = WebApplication.CreateBuilder(args);

builder.Services
    .AddIdentity<LdapUser, LdapRole>()
    .AddLdapStores(builder.Configuration);
builder.Services.AddAuthentication(IdentityConstants.ApplicationScheme)
    .AddCookie(IdentityConstants.ApplicationScheme);
builder.Services.AddAuthorization();

var app = builder.Build();

app.UseAuthentication();
app.UseAuthorization();

app.MapPost("/login", async (LoginRequest req, SignInManager<LdapUser> signIn) =>
{
    var result = await signIn.PasswordSignInAsync(
        req.Username, req.Password, false, false);
    return result.Succeeded ? Results.Ok() : Results.Unauthorized();
});

app.MapGet("/me", (HttpContext ctx) => Results.Ok(new
{
    Name = ctx.User.Identity?.Name
})).RequireAuthorization();

app.Run();

record LoginRequest(string Username, string Password);

public const string SectionName = "Ldap"; // LdapOptions.SectionName

using Bielu.AspNetCore.Identity.Ldap;
using Bielu.AspNetCore.Identity.Ldap.Extensions;
using Bielu.AspNetCore.Identity.Ldap.OpenTelemetry.Extensions;

// 1. Register Identity with LDAP stores
builder.Services
    .AddIdentity<LdapUser, LdapRole>()
    .AddLdapStores(builder.Configuration);

// 2. Wrap with OpenTelemetry instrumentation (decorator pattern via Scrutor)
builder.Services.AddLdapOpenTelemetryInstrumentation();

// 3. Wire up OTel exporters
builder.Services.AddOpenTelemetry()
    .WithTracing(tracing => tracing
        .AddLdapIdentityInstrumentation()     // subscribe to LDAP ActivitySource
        .AddOtlpExporter())
    .WithMetrics(metrics => metrics
        .AddLdapIdentityMetrics()             // subscribe to LDAP Meter
        .AddOtlpExporter());