> For the complete documentation index, see [llms.txt](https://docs.realmjoin.com/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.realmjoin.com/fr/automatisation/runbooks/runbook-customization.md).

# Personnalisation des runbooks

Adaptez les runbooks génériques de RealmJoin aux besoins de vos environnements.

## Aperçu

L’implémentation des runbooks RealmJoin offre des possibilités de personnalisation à l’auteur d’un runbook ou à l’administrateur d’un environnement, afin qu’ils puissent :

* Héberger des paramètres et des modèles spécifiques au client/Tenant
* Proposer des éléments d’interface comme des sélecteurs d’utilisateurs ou des listes déroulantes
* Présenter des explications de paramètres lisibles par l’humain
* Masquer les éléments d’interface inutiles

<figure><img src="https://1100180853-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-MkrcM7cKOpXKri1kVrh%2Fuploads%2FmVmZrDFgG1ShkZlo1Fbe%2Fimage.png?alt=media&amp;token=39876732-3578-41d2-acf1-8571bb941e68" alt=""><figcaption></figcaption></figure>

Les personnalisations peuvent être incluses dans le runbook lui-même et/ou stockées dans l’instance RealmJoin Portal du client. Par défaut, nous essaierons de proposer des valeurs par défaut pertinentes dans les runbooks proposés sur [GitHub](https://github.com/realmjoin/realmjoin-runbooks).

Certains runbooks seront fournis avec des exemples de configuration de modèles spécifiques au client, comme la définition d’emplacements de bureau pour l’intégration des utilisateurs.

### Formater

La personnalisation peut être définie (par ordre décroissant de priorité)

* Bloc JSON dans [paramètres du RealmJoin Portal](https://portal.realmjoin.com/settings/runbooks-customizations), remplaçant le comportement par défaut du runbook
* Bloc JSON dans l’en-tête d’un runbook

En complément (avec la priorité la plus faible)

* par paramètre dans l’en-tête du runbook
* par paramètre dans le bloc de paramètres du runbook (en utilisant le module RJRb Helper)

Certaines fonctionnalités (comme les modèles) ne sont disponibles qu’au format JSON. D’autres (comme la création d’un sélecteur d’utilisateur) ne sont disponibles qu’en spécifiant un type de données dans le bloc param. Vous pouvez combiner plusieurs types de personnalisations pour obtenir les meilleurs résultats.

## Bloc de paramètres du runbook

Le RealmJoin Portal analyse le bloc param PowerShell d’un runbook pour déterminer quels champs de saisie afficher. Lorsque c’est possible, il valide également les entrées selon le type .NET fourni pour une variable.

Les types de données suivants sont actuellement pris en charge :

* `[bool]`, `[booléen]` - affichera un commutateur binaire
* `[chaîne]` - affichera une zone de texte pour saisir toute entrée alphanumérique
* `[entier]` - affichera une zone de texte, n’autorisant que les saisies numériques
* `[DateTime]`, `[DateTimeOffset]` - affichera un sélecteur de date/heure

Vous pouvez appliquer aux paramètres des modificateurs PowerShell standards. RealmJoin Portal comprendra notamment si vous spécifiez `[Parameter(Mandatory = $true)]` pour indiquer un paramètre obligatoire et imposer que ces paramètres soient renseignés.

Lorsque c’est possible, RealmJoin Portal lira et affichera également les valeurs par défaut fournies dans l’interface.

Attention, les valeurs par défaut du runbook peuvent être remplacées par des personnalisations. De plus, des paramètres peuvent être totalement masqués par des personnalisations.

### Personnalisation des paramètres

Pour pouvoir personnaliser des paramètres, veillez à inclure le module PS Runbook Helper de RealmJoin dans votre runbook :

`#Requires -Modules @{ModuleName = "RealmJoin.RunbookHelper"; ModuleVersion = "0.6.0" }`

Vous pouvez ensuite inclure `[ValidateScript( { Use-RJInterface ... } )]` des instructions dans les définitions des paramètres. Par exemple, ce qui suit créera un sélecteur d’utilisateur, permettant de choisir un utilisateur Entra ID et transmettra son identifiant objet sous forme de chaîne au runbook.

```powershell
param(
    [ValidateScript( { Use-RJInterface -DisplayName "Assign device to this user (optional)" -Type Graph -Entity User } )]
    [string] $AssignedUserId = ""
)
```

Décortiquons cela pas à pas. `[ValidateScript...]` est un modificateur pour le paramètre suivant défini dans le bloc param. Dans ce cas, la variable `$AssignedUserId`.

`Use-RJInterface` fait partie de notre [RealmJoin Runbook Helper](https://github.com/realmjoin/RealmJoin.RunbookHelper) module PowerShell. Il vous permet de spécifier le type d’entrée attendu en utilisant `-Type` et `-Entity`, si cela n’est pas déjà entièrement défini par le type de la variable.

`-DisplayName` vous permet de transmettre à RealmJoin Portal une invite / description lisible pour ce paramètre.

#### Ressources Graph

Dans l’exemple ci-dessus, la source d’information est MS Graph, comme indiqué par `-Type Graph`. Pour MS Graph, utilisez `-Entity` pour spécifier le type de ressource attendu. Les entités disponibles sont `User`, `Groupe`, `Appareil`. Cela produira un sélecteur pour les utilisateurs, les groupes ou les appareils dans l’Entra ID donné.

Le sélecteur inclut une recherche rapide, pour localiser facilement la ressource requise.

![Exemple de sélecteur](https://1100180853-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-MkrcM7cKOpXKri1kVrh%2Fuploads%2Fgit-blob-0c393c4ea73a77b34da2c678b0712a6556ed3bc2%2Frunbook-customization-img2.png?alt=media)

Actuellement, la sélection multiple n’est pas possible avec un sélecteur.

Par défaut, un sélecteur MS Graph renverra l’ID de l’objet. Si vous avez besoin par exemple du nom principal d’utilisateur à la place, veillez à inclure "name" comme suffixe dans le nom de votre variable. Donc, en pratique, pour obtenir l’id d’un utilisateur, nommez le paramètre `$userid`. Si vous voulez un UPN, nommez-le `$username`.

#### Filtrage Graph

Si vous utilisez un sélecteur basé sur MS Graph, vous pouvez aussi spécifier `-Filter` et utiliser un [filtre ODATA](https://docs.microsoft.com/en-us/graph/query-parameters?context=graph%2Fapi%2F1.0\&view=graph-rest-1.0#filter-parameter) pour limiter les objets proposés dans le sélecteur.

L’exemple suivant listera uniquement les groupes de l’Entra ID commençant par "LIC\_".

```powershell
param(
    [Parameter(Mandatory = $true)]
    [ValidateScript( { Use-RJInterface -Type Graph -Entity Group -Filter "startswith(DisplayName, 'LIC_')" -DisplayName "License group" } )]
    [String] $GroupID_License
)
```

Vous pouvez préparer des filtres et les réutiliser dans plusieurs scripts en utilisant le [magasin de données central](#graph-filters). Dans ce cas, référencez simplement le filtre par son nom en utilisant `-Filter "ref:LicenseGroup"`, où `ref:` indique qu’il faut rechercher un filtre stocké.

```powershell
param(
    [Parameter(Mandatory = $true)]
    [ValidateScript( { Use-RJInterface -Type Graph -Entity Group -Filter "ref:LicenseGroup" } )]
    [String] $GroupID_License
)
```

Cet exemple précis `ref:LicenseGroup` est disponible par défaut sans configuration supplémentaire.

![filtre ODATA](https://1100180853-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-MkrcM7cKOpXKri1kVrh%2Fuploads%2Fgit-blob-4913ddfbc3324fc7a3522de2bc6887e8d2745e35%2Frunbook-customization-img3.png?alt=media)

## En-tête du runbook

Le portail peut analyser la [section d’aide basée sur les commentaires](https://docs.microsoft.com/en-us/powershell/module/microsoft.powershell.core/about/about_comment_based_help?view=powershell-5.1) du runbook, si elle est présente.

Voici un exemple :

```powershell
<#
  .SYNOPSIS
  (Dés)attribuer une licence à un utilisateur via l’appartenance à un groupe.

  .DESCRIPTION
  (Dés)attribuer une licence à un utilisateur via l’appartenance à un groupe. Description plus détaillée...

  .PARAMETER DefaultGroups
  Liste de groupes à attribuer, séparés par des virgules. ex. "DL Sales,LIC Internal Product"

  .NOTES
  Autorisations :
  MS Graph (API) :
  - User.Read.All
  - GroupMember.ReadWrite.All 
  - Group.ReadWrite.All

  .INPUTS
  RunbookCustomization: {
        "Parameters": {
            "UserName": {
                "Hide": true
            },
            "Remove": {
                "DisplayName": "Assign or Remove License",
                "SelectSimple": {
                    "Attribuer une licence à l’utilisateur": false,
                    "Supprimer la licence de l’utilisateur": true
                }
            }
        }
    }
#>
```

`.SYNOPSIS` - Donnez une très brève description de la fonction de votre runbook. Elle sera affichée dans la liste des runbooks disponibles.

`.DESCRIPTION` - Donnez une description de la fonction de votre runbook. Peut contenir un peu plus de détails, car elle sera affichée dans la boîte de dialogue d’exécution / de paramètres des runbooks.

`.PARAMETER` - Doit être suivi du nom d’un paramètre. Permet de donner une explication détaillée de l’entrée attendue pour le paramètre en question.

`.INPUTS` - Peut contenir un bloc de personnalisation de runbook basé sur JSON.

`.NOTES` - N’est pas analysé / rendu. Veuillez utiliser cet espace pour indiquer quelles autorisations et exigences existent pour votre runbook.

`.EXAMPLE` - N’est pas analysé / rendu. Peut contenir un exemple de personnalisation basée sur JSON à utiliser dans le magasin de données RealmJoin de votre Tenant. Il peut s’agir d’exemples de création de modèles, par ex. pour différents flux de travail ou classes d’utilisateurs.

## personnalisation basée sur JSON

### Magasin de données central

Chaque Tenant Azure peut héberger un magasin de données « Runbook Customizations », disponible à <https://portal.realmjoin.com/settings/runbooks-customizations> .

Le format est du JSON avec commentaires, autorisant les virgules finales. Actuellement, il existe trois sections pertinentes, `Settings`, `Modèles`, `Runbooks`.

```json
{
    "Settings": {
    },
    "Modèles": {
    },
    "Runbooks": {
    }
}
```

### Section Runbooks

`Runbooks` est analysée par le portail lors du démarrage d’un runbook. Si une section portant le même nom que le runbook Azure Automation actuel existe, son contenu sera utilisé pour personnaliser le front-end affiché à l’utilisateur.

Supposons le runbook de démonstration simple suivant, appelé `rjgit-device_demo-runbook-customizing`.

```powershell
<#
  .SYNOPSIS
  Démontrer la personnalisation de runbook

  .DESCRIPTION
  Démontrer la personnalisation de runbook, par exemple une liste déroulante/sélection
#>

#Requires -Modules @{ModuleName = "RealmJoin.RunbookHelper"; ModuleVersion = "0.6.0" }

param(
    [string] $DeviceId,
    [bool] $ExtraWorkflow = $true,
    [int] $ExtraWorkflowTime = 15
)

"## Traitement de l’appareil '$DeviceID'"

# Flux de travail complexe hautement optionnel
if ($ExtraWorkflow) {
    "## Exécution de la méditation..."
    Start-Sleep -Seconds $ExtraWorkflowTime
}
```

Sans personnalisation, il sera présenté ainsi dans le front-end :

![Démo - avant](https://1100180853-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-MkrcM7cKOpXKri1kVrh%2Fuploads%2Fgit-blob-931b958f4b949268736f6ff3f174913cf56adcf7%2Frunbook-customization-img4.png?alt=media)

Réflexions :

* Comme ce runbook est lancé depuis le contexte d’un appareil dans le portail, le `$DeviceId` est une information redondante pour un utilisateur. Je sais déjà sur quel appareil je travaille.
* Que se passe-t-il si j’active ou désactive « Extra Workflow » ? Dois-je me soucier de « Extra Workflow Time » si je désactive « Extra Workflow » ?

Améliorons cela. L’exemple JSON suivant dans le magasin de données central modifiera l’interface du runbook.

```json
{
    "Runbooks": {
        "rjgit-device_demo-runbook-customizing": {
            "Liste des paramètres": [
                {
                    "Name": "DeviceId",
                    "Hide": true
                }, 
                {
                    "Name": "ExtraWorkflow",
                    "Hide": true
                },
                {
                    "Name": "ExtraWorkflowTime",
                    "DisplayName": "Combien de temps méditer ?",
                },
                {
                    "DisplayName": "Exécuter le flux de travail supplémentaire",
                    "DisplayBefore": "ExtraWorkflowTime",
                    "Sélection": {
                        "Options": [
                            {
                                "Display": "Exécuter la méditation (facultatif)",
                                "Personnalisation": {
                                    "Par défaut": {
                                        "ExtraWorkflow": true
                                    }
                                }
                            },
                            {
                                "Display": "Ignorer la pleine conscience de l’appareil",
                                "Personnalisation": {
                                    "Par défaut": {
                                        "ExtraWorkflow": false
                                    },
                                    "Hide": [
                                        "ExtraWorkflowTime"
                                    ]
                                }
                            }
                        ],
                        
                    },
                    "Default": "Ignorer la pleine conscience de l’appareil"
                }
            ]
        }
    }
}
```

Vous pouvez utiliser la même notation / les mêmes fonctionnalités dans votre [en-tête de runbook](#runbook-header).

#### ParameterList

Chaque paramètre possède sa propre section dans `ParameterList`. [Modificateurs](#modifiers) permettent de modifier le comportement de ce paramètre.

Le résultat ressemblera à ceci :

![Démo - après masquage](https://1100180853-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-MkrcM7cKOpXKri1kVrh%2Fuploads%2Fgit-blob-4ae4e681371ad29f076063c5f1925a0cb8113872%2Frunbook-customization-img5.png?alt=media)

Le choix du flux de travail supplémentaire affichera (révélera) davantage de paramètres :

![Démo - après affichage](https://1100180853-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-MkrcM7cKOpXKri1kVrh%2Fuploads%2Fgit-blob-7960cf8309d8bbdf12ab1539c073714211715411%2Frunbook-customization-img6.png?alt=media)

Cela montre moins d’encombrement par rapport à l’état précédent l’application de la personnalisation. En même temps, davantage d’informations sur les alternatives de « Extra Workflow » sont disponibles pour l’utilisateur. De plus, l’utilisateur ne se préoccupera désormais de « Extra Workflow Time » que si c’est pertinent.

La modification de la visibilité de ce champ a été effectuée à l’aide d’un `"Customization"` bloc à l’intérieur de l’une des `"Select"` options. Vous pouvez actuellement avoir au maximum un tel `"Customization"` bloc actif à la fois.

Comme vous pouvez le voir, le paramètre `$DeviceId` est complètement masqué. Cela se fait en définissant le `"Hide": true` pour ce paramètre.

Les paramètres peuvent avoir un `DisplayName`. Nous avons proposé une formulation conviviale `DisplayName` pour remplacer `$ExtraWorkflowTime` dans l’interface. Voir les autres [modificateurs](#modifiers) pour en savoir plus.

Vous pouvez insérer des paramètres « sans nom » (à qui manque le `Nom` instruction) comme la section « Exécuter le flux de travail supplémentaire », si vous souhaitez proposer des éléments d’interface sans renvoyer directement une valeur. Cela n’est normalement utilisé qu’en combinaison avec `Sélectionnez`.

#### Sélectionnez

Nous avons utilisé `Sélectionnez`pour afficher une liste de `options` dans une liste déroulante. Chaque option peut `afficher` du texte, ou déclencher une `personnalisation`, comme définir une `Masquer` ou un `Valeur par défaut` valeur sur d’autres paramètres. Dans notre exemple, nous l’avons utilisée pour (dé)masquer `$ExtraWorkflowTime` et remplacer `$ExtraWorkflow`la valeur de $ExtraWorkflow.

`$ExtraWorkflowTime` est ainsi affiché uniquement lorsque c’est pertinent et le commutateur binaire `$ExtraWorkflow` est désormais remplacé par des alternatives porteuses de sens du point de vue de l’utilisateur.

Dans le cas d’un `Sélectionnez` pour un paramètre nommé, chaque option doit avoir un `"ParameterValue": "..."` à transmettre au runbook. Vous pouvez placer un `"ShowValue: false"` dans le `Sélectionnez` bloc afin d’afficher uniquement la liste déroulante et non un champ pour la valeur résultante du paramètre.

Exemple de paramètre nommé :

```json
{
    "Name": "ExtraWorkflow",
    "DefaultValue": true,
    "DisplayName": "Exécuter le flux de travail supplémentaire",
    "DisplayBefore": "ExtraWorkflowTime",
    "Sélection": {
        "Options": [
            {
                "Display": "Exécuter la méditation (facultatif)",
                "ParameterValue": true
            },
            {
                "Display": "Ignorer la pleine conscience de l’appareil",
                "ParameterValue": false,
                "Personnalisation": {
                    "Hide": [
                        "ExtraWorkflowTime"
                    ]
                }
            }
        ],
        "ShowValue": false
    }
}
```

Le `Valeur par défaut` / `DefaultValue` dans le paramètre spécifie également l’état initial de la liste déroulante. Dans le cas d’un paramètre sans nom, utilisez la `DisplayName` de l’option souhaitée, sinon fournissez une valeur de retour par défaut, comme "true" ou "false" ou une chaîne quelconque.

#### Paramètres

Si vous n’avez que des paramètres nommés, vous pouvez utiliser le format légèrement plus court `Paramètres` à la place de `ParameterList`.

Pour un exemple, voir SelectSimple

#### SelectSimple

Si toute la puissance d’une `Sélectionnez` n’est pas nécessaire et que vous souhaitez simplement proposer une liste de valeurs possibles dans une liste déroulante (sans appliquer de personnalisation supplémentaire), vous pouvez utiliser `SelectSimple`.

`SelectSimple` n’est utilisable que pour les paramètres nommés.

Exemple :

```json
{
    "Runbooks": {
        "rjgit-device_demo-runbook-customizing": {
            "Parameters": {
                "DeviceId": {
                    "Hide": true
                }, 
                "ExtraWorkflow": {
                    "Name": "ExtraWorkflow",
                    "DisplayName": "Exécuter le flux de travail supplémentaire",
                    "Default": false,
                    "SelectSimple": {
                        "Exécuter la méditation (facultatif)": true,
                        "Ignorer la pleine conscience de l’appareil": false
                    }
                },
                "ExtraWorkflowTime": {
                    "DisplayName": "Combien de temps méditer ?"
                }
            }
        }
    }
}
```

La plus grande différence avec notre exemple précédent, en dehors du fait qu’il est beaucoup plus court, est que `$ExtraWorkflowTime` est toujours visible.

#### Modificateurs

Chaque paramètre peut avoir un ou plusieurs des modificateurs suivants :

* `"DisplayName": "text"` - Afficher « text » comme nom du paramètre dans l’interface
* `"Hide": true / false` - Masquer ce paramètre
* `"Mandatory": true / false` - Exiger que ce paramètre soit renseigné
* `"ReadOnly": true / false` - Empêcher que ce paramètre soit modifié par rapport à sa valeur par défaut
* `"DefaultValue": "..."` - Définir une valeur par défaut pour ce paramètre. (Vous pouvez aussi utiliser `Valeur par défaut` à la place.)
* `"GraphFilter": "startswith(DisplayName, 'LIC_')"` - voir [Filtrage Graph](#graph-filtering)
* `"AllowEdit": true / false` - Protéger ce paramètre de la modification manuelle. (à combiner avec les modèles)

### Settings

`Settings` vous permet de stocker des données de configuration comme les noms de Storage Account Azure dans un emplacement central, tout en les gardant séparées de vos runbooks.

Vous pouvez accéder à des valeurs individuelles depuis le bloc param d’un runbook en utilisant `Use-RJInterface`.

Prenons cet exemple de bloc param d’un runbook :

```powershell
param(
    [ValidateScript( { Use-RJInterface -Type Setting -Attribute "RJReport.StorageAccount.ResourceGroup" } )]
    [string] $ResourceGroupName,
    [ValidateScript( { Use-RJInterface -Type Setting -Attribute "RJReport.StorageAccount.StorageAccountName" } )]
    [string] $StorageAccountName,
    [ValidateScript( { Use-RJInterface -Type Setting -Attribute "RJReport.StorageAccount.LinkExpiryDays" } )]
    [int] $LinkExpiryDays = 6
)
```

Le portail essaiera de préremplir chaque paramètre avec les valeurs du magasin de données central, si elles sont présentes. Cela fonctionne également si le paramètre a été masqué dans l’interface.

Un JSON possible dans le magasin de données pour ce runbook serait :

```json
{
    "Settings": {
        "RJReport": {
            "StorageAccount": {
                "ResourceGroup": "rj-runbooks-01",
                "StorageAccountName": "rjrbexports01"
            }
        }
    }
}
```

L’élément manquant `LinkExpiryDays` ne sera simplement pas prérempli dans l’interface, de sorte que le paramètre conserve sa valeur par défaut de `6`.

Un bloc de runbook dans la `Runbooks` section peut contenir son propre `Settings`. Pour chaque valeur, le portail regarde d’abord là, puis seulement ensuite dans le global `Settings`, de sorte que les runbooks individuels peuvent utiliser des valeurs différentes. Voir [Utiliser un autre Storage Account pour certains runbooks](https://docs.realmjoin.com/fr/automatisation/runbooks/runbook-report-settings.md#use-a-different-storage-account-for-individual-runbooks) pour un exemple.

### Modèles

`Modèles` utilisez des références JSON pour récupérer des données - par exemple une longue liste d’emplacements de bureau - lors de l’utilisation d’une `Sélectionnez` instruction.

Cela permet de conserver une personnalisation neutre/réutilisable/séparée des données réelles.

Prenons l’exemple de l’intégration de nouveaux utilisateurs. Vous pouvez avoir plusieurs options pour les services ou les emplacements de bureau, où l’attribution d’un emplacement de bureau impose aussi une certaine adresse, un pays, un État, etc.

L’exemple suivant de personnalisation de runbook utilise la `$ref` dans le `Runbooks` section pour référencer/importer un sous-arbre depuis la `Modèles` section. Repérez les `$id`/`$values` mots-clés. Notez que `$id`/`$values` doivent être définis avant d’être référencés à l’aide de `$ref`. C’est pourquoi `Modèles` est défini avant `Runbooks` dans cet exemple.

Dans cet exemple, nous indiquons au portail de récupérer le sous-arbre avec le `$id` appelé `LocationOptions` et d’inclure ses `$values`, en remplaçant la `$ref` instruction. Ainsi, le portail affichera un `Sélectionnez` comme décrit dans la `Runbooks` section, mais incluera les options réelles depuis `Modèles`.

Un modèle peut contenir toute instruction prise en charge à l’emplacement de référencement. Dans cet exemple, nous utilisons une `personnalisation` instruction pour modifier d’autres paramètres comme `StreetAddress`.

Ainsi, nous pouvons avoir une personnalisation spécifique au runbook dans `Runbooks` réutilisable dans plusieurs environnements, tout en gardant les données réelles séparées.

```json
{
    "Modèles": {
        "Options": [
            {
                "$id": "LocationOptions",
                "$values": [
                    {
                        "Affichage": "DE-OF",
                        "Personnalisation": {
                            "Par défaut": {
                                "Adresse": "Kaiserstraße 39",
                                "Code postal": "63065",
                                "Ville": "Offenbach",
                                "Pays": "Allemagne"
                            }
                        }
                    },
                    {
                        "Affichage": "DE-DEG",
                        "Personnalisation": {
                            "Par défaut": {
                                "Adresse": "Lateinschulgassse 24-26",
                                "Code postal": "94469",
                                "Ville": "Deggendorf",
                                "Pays": "Allemagne"
                            }
                        }
                    },
                    {
                        "Affichage": "DE-HH",
                        "Personnalisation": {
                            "Par défaut": {
                                "Adresse": "Hans-Henny-Jahnn-Weg 53",
                                "Code postal": "22085",
                                "Ville": "Hambourg",
                                "Pays": "Allemagne"
                            }
                        }
                    },
                    {
                        "Affichage": "FI-HS",
                        "Personnalisation": {
                            "Par défaut": {
                                "Adresse": "Quelque part 42",
                                "Code postal": "12345",
                                "Ville": "Helsinki",
                                "Pays": "Finlande"
                            }
                        }
                    }
                ]
            },
            {
                "$id": "CompanyOptions",
                "$values": [
                    {
                        "Id": "gkg",
                        "Display": "glueckkanja",
                        "Value": "glueckkanja AG"
                    },
                    {
                        "Id": "pp",
                        "Display": "PRIMEPULSE",
                        "Value": "PRIMEPULSE SE"
                    }
                ]
            }
        ]
    },
    "Runbooks": {
        "rjgit-org_general_add-user": {
            "Liste des paramètres": [
                {
                    "Nom d'affichage": "Emplacement Office",
                    "Afficher après": "CompanyName",
                    "Sélection": {
                        "Options": {
                            "$ref": "LocationOptions"
                        }
                    }
                },
                {
                    "Nom": "CompanyName",
                    "Sélection": {
                        "Options": {
                            "$ref": "CompanyOptions"
                        },
                        "Autoriser la modification": false
                    }
                }
            ],
            "Lecture seule": [
                "StreetAddress",
                "PostalCode",
                "City",
                "Country"
            ]
        }
    }
}
```

Cela créera l’interface suivante :

![Démo - emplacement de référence](https://1100180853-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-MkrcM7cKOpXKri1kVrh%2Fuploads%2Fgit-blob-93295541748dcc12dbc72208851138efd0808d51%2Frunbook-customization-img7.png?alt=media)

![Démo - adresse de référence](https://1100180853-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-MkrcM7cKOpXKri1kVrh%2Fuploads%2Fgit-blob-11e2812670e56cf10bb03fe7588059d232a8addf%2Frunbook-customization-img8.png?alt=media)

### Filtres Graph

Vous pouvez préparer [des filtres Graph ODATA](https://docs.microsoft.com/en-us/graph/query-parameters?context=graph%2Fapi%2F1.0\&view=graph-rest-1.0#filter-parameter) pour les utiliser dans plusieurs runbooks. Stockez-les dans une section appelée `GraphFilters`.

L’exemple suivant filtre pour un certain préfixe dans le `DisplayName` d’un groupe, pour n’afficher que les groupes liés à la licence dans un sélecteur de groupes.

```json
"GraphFilters": {
    "LicenseGroup": "startswith(DisplayName, 'LIC_')" // également inclus dans le code RJ par défaut
  }
```

Voir [Filtrage du graphe](#graph-filtering) sur la façon de l’utiliser depuis un runbook.


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation by asking a question.

Perform an HTTP GET request on the following URL with the `ask` and `goal` query parameters:

```
GET https://docs.realmjoin.com/fr/automatisation/runbooks/runbook-customization.md?ask=<question>&goal=<user_goal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is what the user is ultimately trying to achieve, the reason they need the answer. Sharing it helps GitBook give you a better, more relevant answer. A goal is most helpful when it describes the outcome the user wants rather than restating the question. For example, with `ask=how do I create an API token`, a goal like `automate deployments from our CI pipeline` lets GitBook tailor the answer to that use case.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.
