# Diagnostic 401 Unauthorized - Backend

## Problème

Erreur lors de l'appel au backend :
```
Received: 'Unauthorized, status code 401' when invoking REST Client method: 
'dev.lions.user.manager.client.service.RoleServiceClient#getAllRealmRoles'
```

## Causes Possibles

### 1. Token JWT non envoyé au backend

**Vérification** :
- Ouvrir les DevTools du navigateur (F12)
- Aller dans l'onglet "Network"
- Filtrer par "XHR" ou "Fetch"
- Cliquer sur une requête vers `/api/roles/realm`
- Vérifier l'en-tête `Authorization: Bearer <token>`

**Solution** :
- Vérifier que `bearer-token-propagation=true` est configuré dans `application.properties`
- Vérifier que le client est bien authentifié via OIDC

### 2. Backend ne peut pas valider le token

**Vérification** :
- Vérifier les logs du backend pour voir les erreurs OIDC
- Chercher les messages : `Bearer access token is not available`, `Token validation failed`, etc.

**Solution** :
- Vérifier que `quarkus.oidc.enabled=true` dans `application-dev.properties`
- Vérifier que `quarkus.oidc.auth-server-url` pointe vers le bon realm (`lions-user-manager`)
- Vérifier que `quarkus.oidc.token.issuer` correspond au realm

### 3. Rôles non extraits du token

**Vérification** :
- Vérifier les logs du backend pour voir : `No claim exists at the path 'realm_access/roles'`
- Obtenir le token JWT et le décoder sur https://jwt.io
- Vérifier que le claim `realm_access.roles` existe et contient les rôles

**Solution** :
- Vérifier que `quarkus.oidc.roles.role-claim-path=realm_access/roles` est configuré
- Vérifier que le client Keycloak a le scope "roles" activé
- Vérifier que `fullScopeAllowed=true` est configuré pour le client

### 4. Token expiré

**Vérification** :
- Vérifier les logs du backend pour voir : `Token expired`
- Obtenir le token JWT et vérifier le claim `exp`

**Solution** :
- Se reconnecter pour obtenir un nouveau token
- Augmenter la durée de vie du token dans Keycloak si nécessaire

## Étapes de Diagnostic

### Étape 1 : Vérifier les logs du backend

Redémarrer le backend avec les logs DEBUG activés et chercher :

```bash
# Logs à surveiller
- "Bearer access token is not available"
- "No claim exists at the path"
- "Token validation failed"
- "Roles extracted from claim"
```

### Étape 2 : Vérifier le token JWT

1. Obtenir le token JWT (via DevTools ou script)
2. Décoder sur https://jwt.io
3. Vérifier :
   - `iss` : doit être `http://localhost:8180/realms/lions-user-manager`
   - `realm_access.roles` : doit contenir les rôles (`admin`, `user_manager`, etc.)
   - `exp` : doit être dans le futur

### Étape 3 : Vérifier la configuration OIDC

**Backend** (`application-dev.properties`) :
```properties
quarkus.oidc.enabled=true
quarkus.oidc.auth-server-url=http://localhost:8180/realms/lions-user-manager
quarkus.oidc.application-type=service
quarkus.oidc.token.issuer=http://localhost:8180/realms/lions-user-manager
quarkus.oidc.roles.role-claim-path=realm_access/roles
quarkus.oidc.verify-access-token=true
```

**Client** (`application.properties`) :
```properties
quarkus.rest-client."lions-user-manager-api".bearer-token-propagation=true
```

### Étape 4 : Tester manuellement avec curl

```bash
# 1. Obtenir un token
TOKEN=$(curl -X POST "http://localhost:8180/realms/lions-user-manager/protocol/openid-connect/token" \
  -H "Content-Type: application/x-www-form-urlencoded" \
  -d "username=test-user" \
  -d "password=test123" \
  -d "grant_type=password" \
  -d "client_id=lions-user-manager-client" \
  -d "client_secret=NTuaQpk5E6qiMqAWTFrCOcIkOABzZzKO" \
  -d "scope=openid profile email roles" | jq -r '.access_token')

# 2. Tester l'endpoint backend
curl -X GET "http://localhost:8081/api/roles/realm?realm=master" \
  -H "Authorization: Bearer $TOKEN" \
  -H "Content-Type: application/json"
```

## Configuration Actuelle

### Backend OIDC
- **Realm** : `lions-user-manager`
- **Type** : `service` (valide les tokens sans client-id/secret)
- **Role Claim Path** : `realm_access/roles`
- **Token Audience** : `optional` (accepte tous les clients)

### Client OIDC
- **Realm** : `lions-user-manager`
- **Client ID** : `lions-user-manager-client`
- **Bearer Token Propagation** : `true`

## Solution Recommandée

1. **Vérifier que le backend est démarré** sur le port 8081
2. **Vérifier que Keycloak est démarré** sur le port 8180
3. **Vérifier que l'utilisateur `test-user` est connecté** au client
4. **Vérifier les logs du backend** pour voir exactement où l'erreur se produit
5. **Tester manuellement avec curl** pour isoler le problème

## Logs à Surveiller

### Backend (port 8081)
```bash
# Chercher ces messages dans les logs
DEBUG [io.qu.oi.ru.BearerAuthenticationMechanism] Starting a bearer access token authentication
DEBUG [io.qu.oi.ru.OidcUtils] Looking for a token in the authorization header
DEBUG [io.qu.oi.ru.OidcUtils] Roles extracted from claim 'realm_access/roles': [...]
```

### Client (port 8080)
```bash
# Chercher ces messages dans les logs
DEBUG [io.qu.oi.ru.OidcAuthenticationMechanism] q_session_chunk_1 cookie set
DEBUG [io.qu.oi.ru.OidcUtils] No claim exists at the path 'realm_access/roles'
```

