# Démarrer

## Connectez-vous à votre serveur WorkflowGen

Avant d'utiliser la CLI WorkflowGen pour interagir avec votre serveur WorkflowGen, vous devez vous y connecter. Consultez la section [`login`](/cli-fr/1.0.0/liste-de-commandes.md#login) pour plus d'informations.

```
wfg login http://YOUR_SERVER/wfgen -u wfgen_admin -p YourPassword -c DEV
```

## Gestion de projet

Un projet est composé de processus, de sous-processus, d'applications de workflow personnalisées, de listes globales et de ressources de formulaires Web.

Un projet est basé sur une définition de fichier manifeste (voir la section [Manifeste de projet](/cli-fr/1.0.0/manifeste-de-projet.md)).

La gestion d'un projet avec la CLI vous permet d'exporter ou d'importer le contenu facilement.

### Créez un projet simple

Dans la plupart des cas, un projet WorkflowGen est composé de processus et de sous-processus. Le manifeste suivant définit un projet avec un processus et deux sous-processus, avec une liste globale :

```json
{
  "version": "1.0",
  "tag": "1.1.0",
	"processes":[
    {
      "name":"EMPLOYEE_ONBOARDING",
      "version":1,
      "folder":"HR"
    }
  ],
  "subProcesses":[
    {
      "name":"CREATE_AD_ACCOUNT",
      "version":1,
      "folder":"IT"
    },
    {
      "name":"CREATE_ERP_ACCESS",
      "version":1,
      "folder":"IT"
    }
  ],
  "globalLists": [
    "Country"
  ]
}
```

Vous pouvez utiliser la commande [`project init`](/cli-fr/1.0.0/liste-de-commandes.md#init) pour créer le manifeste avec l'interface de ligne de commande ou écrire la définition directement dans un fichier `manifest.json`.

{% hint style="info" %}
Si vous ajoutez des ressources de formulaire Web à votre manifeste, assurez-vous que vous avez correctement défini le chemin d'accès au dossier du formulaire Web sur le serveur WorkflowGen.

Le chemin du formulaire Web est également requis si vous souhaitez exporter le code de processus (contenu dans le fichier `Default.aspx`).
{% endhint %}

#### Exportez votre projet

Une fois votre fichier `manifest.json` correctement défini, vous pouvez utiliser la commande [`project export`](/cli-fr/1.0.0/liste-de-commandes.md#export) pour télécharger les liens de toutes les sources vers votre projet.

```
wfg project export -p PathToTheFolderWithTheManifest
```

Pour la définition du manifeste, vous devez avoir une structure de dossiers comme celle-ci :

```
| manifest.json
| definitions/
|    globallists/
|        Country.Xml
|    subprocesses/
|        CREATE_AD_ACCOUNTv1.xml
|        CREATE_ERP_ACCESSv1.xml
|    processes/
|        EMPLOYEE_ONBOARDINGv1.xml
| src/
|    processes/
|        CREATE_AD_ACCOUNT/
|                V1/
|                    Default.aspx
|                    Default.aspx.cs
|        CREATE_ERP_ACCESS/
|                V1/
|                    Default.aspx
|                    Default.aspx.cs
|        EMPLOYEE_ONBOARDING/
|                V1/
|                    Default.aspx
|                    Default.aspx.cs
```

#### Importez votre projet

Avec la commande [`project import`](/cli-fr/1.0.0/liste-de-commandes.md#import), vous pouvez importer votre projet dans un autre serveur WorkflowGen (tel que le serveur de production).

```
wfg project import --source PathToYourProjectFolder
```

La CLI importera toutes les définitions dans votre application WorkflowGen, créera des processus, des sous-processus, des applications et des listes globales, et déplacera les ressources du formulaire Web vers le dossier du formulaire Web.

### Exemple vidéo

{% embed url="<https://www.loom.com/share/8c64acc59c4f4b96abfc678312453bbc>" %}

## Utilisation d'une configuration à plusieurs serveurs

La CLI utilise des contextes pour identifier le serveur et l'utilisateur à utiliser pour se connecter à WorkflowGen. Vous pouvez définir plusieurs configurations, une pour chacun de vos serveurs WorkflowGen.

La commande `login` contient l'option `--context` pour donner un nom à votre contexte.

La commande `config get-contexts` vous permet d'afficher tous les contextes définis.

```
wfg config get-contexts
```

**Résultat :**

```
 ----------------------------------------------------- 
 | Current | Context name | Server name | User name  |
 ----------------------------------------------------- 
 |         | PROD         | CG9FDCK57K  | ZQPWB00VS3 |
 ----------------------------------------------------- 
 | *       | DEV          | CB6YHR11DD  | ACJTLYG0AZ |
 ----------------------------------------------------- 
 
 Count: 2
```

Vous pouvez passer à un autre contexte avec la commande `config use-context`.

```
wfg config use-context PROD
```

## Options globales

La CLI fournit des options globales pour vous donner d'autres informations.

### `help`

L'option `help` vous permet d'obtenir des informations sur la façon d'utiliser une commande spécifique ou de voir quelles commandes sont disponibles.

```
wfg --help
```

**Résultat :**

```
Usage:
  wfg [options] [command]

Options:
  --debug
  --verbose
  --version         Show version information
  -?, -h, --help    Show help and usage information

Commands:
  login <url>
  config
  process
  project
  global-list
  application
  graphql <query>
```

### `debug`

L'option `debug` vous permet d'afficher plus de logs dans votre terminal lors de l'exécution de la commande.

```
wfg process get --debug
```

### `verbose`

L'option `verbose` est comme l'option `debug`, mais la CLI affichera plus de logs que pour `debug`.

```
wfg process get --verbose
```

### `version`

L'option `version` renvoie la version actuelle de votre CLI WorkflowGen.

```
wfg --version
```

## Activation de la saisie semi-automatique via la touche Tab (tab completion)

{% tabs %}
{% tab title="PowerShell" %}

1. Installez l'outil global `dotnet-suggest` :

   ```
   dotnet tool install --global dotnet-suggest
   ```
2. Ouvrez votre profil PowerShell et ajoutez-y le code suivant. Vous pouvez obtenir le chemin de votre chemin de profil avec `echo $PROFILE`.

   ```bash
   # dotnet suggest shell start
   $availableToComplete = (dotnet-suggest list) | Out-String
   $availableToCompleteArray = $availableToComplete.Split([Environment]::NewLine, [System.StringSplitOptions]::RemoveEmptyEntries) 


       Register-ArgumentCompleter -Native -CommandName $availableToCompleteArray -ScriptBlock {
           param($commandName, $wordToComplete, $cursorPosition)
           $fullpath = (Get-Command $wordToComplete.CommandElements[0]).Source

           $arguments = $wordToComplete.Extent.ToString().Replace('"', '\"')
           dotnet-suggest get -e $fullpath --position $cursorPosition -- "$arguments" | ForEach-Object {
               [System.Management.Automation.CompletionResult]::new($_, $_, 'ParameterValue', $_)
           }
       }
   $env:DOTNET_SUGGEST_SCRIPT_VERSION = "1.0.0"
   # dotnet suggest script end
   ```

{% endtab %}

{% tab title="Bash" %}

1. Installez l'outil global `dotnet-suggest` :

   ```bash
   dotnet tool install --global dotnet-suggest
   ```
2. Ouvrez votre profil bash (`~/.bash_profile`) et ajoutez-y le code suivant :

   ```bash
   # dotnet suggest shell complete script start
   _dotnet_bash_complete()
   {
       local fullpath=`type -p ${COMP_WORDS[0]}`
       local escaped_comp_line=$(echo "$COMP_LINE" | sed s/\"/'\\\"'/g)
       local completions=`dotnet-suggest get --executable "${fullpath}" --position ${COMP_POINT} -- "${escaped_comp_line}"`

       if [ "${#COMP_WORDS[@]}" != "2" ]; then
           return
       fi

       local IFS=$'\n'
       local suggestions=($(compgen -W "$completions"))

       if [ "${#suggestions[@]}" == "1" ]; then
           local number="${suggestions[0]/%\ */}"
           COMPREPLY=("$number")
       else
           for i in "${!suggestions[@]}"; do
               suggestions[$i]="$(printf '%*s' "-$COLUMNS"  "${suggestions[$i]}")"
           done

           COMPREPLY=("${suggestions[@]}")
       fi
   }

   _dotnet_bash_register_complete()
   {
       local IFS=$'\n'
       complete -F _dotnet_bash_complete `dotnet-suggest list`
   }
   _dotnet_bash_register_complete
   export DOTNET_SUGGEST_SCRIPT_VERSION="1.0.1"
   # dotnet suggest shell complete script end
   ```

{% hint style="info" %}
Pour utiliser les outils `dotnet-suggest`, vous devez installer .NET Core 3.1.
{% endhint %}
{% endtab %}
{% endtabs %}


---

# Agent Instructions: Querying This Documentation

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

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.workflowgen.com/cli-fr/1.0.0/demarrer.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
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.
