# General Translation Platform: awaitJobs
URL: https://generaltranslation.com/fr/docs/platform/core/reference/gt-class-methods/translation/await-jobs.mdx
Docs index: https://generaltranslation.com/llms.txt
Description: Interroge les tâches de traduction en file d’attente jusqu’à ce qu’elles soient terminées, échouent ou expirent. Référence de l’API pour awaitJobs.

Attend que chaque tâche soit à l’état `completed`, `failed` ou `unknown`, ou que le délai d’expiration soit atteint. Prend en charge les tâches de traduction et de configuration.

## Vue d’ensemble [#overview]

Transmettez le résultat de [`enqueueFiles`](/docs/platform/core/reference/gt-class-methods/translation/enqueue-files) ou un tableau d’identifiants de tâches à `awaitJobs`, éventuellement avec des options d’interrogation. La promesse renvoie l’état final de chaque tâche.

```typescript
const gt = new GT({ projectId: 'your-project-id', apiKey: 'your-api-key' });

const enqueueResult = await gt.enqueueFiles(uploadedFiles, {
  sourceLocale: 'en',
  targetLocales: ['es', 'fr'],
});

const result = await gt.awaitJobs(enqueueResult);

if (result.complete) {
  console.log('All jobs finished');
} else {
  console.log('Timed out — some jobs still in progress');
}
```

Signature :

```typescript
awaitJobs(
  jobs: EnqueueFilesResult | string[],
  options?: AwaitJobsOptions
): Promise<AwaitJobsResult>
```

*Attention : `complete: true` signifie que toutes les tâches ont atteint un état terminal — cela ne veut **pas** dire qu’elles ont toutes réussi. Vérifiez chaque `job.status` pour confirmer la réussite.*

## Fonctionnement [#how-it-works]

* **Interrogation automatique.** Remplace les boucles d’interrogation manuelles : vous n’avez pas à appeler vous-même [`checkJobStatus`](/docs/platform/core/reference/gt-class-methods/translation/check-job-status) dans une boucle `while`.
* **États terminaux.** La méthode se résout lorsque toutes les tâches sont `completed`, `failed` ou `unknown`. Les tâches introuvables par l’API sont traitées comme `'unknown'`.
* **Échéance.** Chaque requête d’état dispose d’un délai d’expiration de 60 secondes au maximum, ramené au temps global restant s’il est inférieur. À l’expiration, les derniers états connus sont renvoyés avec `complete: false` ; les tâches peuvent alors être encore en file d’attente, en cours de traitement ou dans un état inconnu. Les implémentations personnalisées de fetch doivent prendre en charge l’annulation pour s’interrompre rapidement.
* **Erreurs.** Une erreur d’état survenant avant l’échéance entraîne le rejet de la promesse. Après l’échéance, les erreurs donnent lieu à des résultats incomplets plutôt qu’à un rejet. L’arrêt de l’interrogation n’annule pas les tâches distantes.
* **Entrée vide.** Après validation des identifiants et du project ID, une entrée vide se résout avec `{ complete: true, jobs: [] }`.

## Paramètres [#parameters]

| Paramètre             | Description                                                                                                                                      | Type                                                                                                          | Facultatif | Par défaut |
| --------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------- | ---------- | ---------- |
| [`jobs`](#jobs)       | Le résultat renvoyé par [`enqueueFiles`](/docs/platform/core/reference/gt-class-methods/translation/enqueue-files) ou un tableau d’ID de tâches. | [`EnqueueFilesResult`](/docs/platform/core/reference/gt-class-methods/translation/enqueue-files) | `string[]` | Non        | —          |
| [`options`](#options) | Configuration de l’interrogation.                                                                                                                | `AwaitJobsOptions`                                                                                            | Oui        | —          |

### `jobs`

**Type** [`EnqueueFilesResult`](/docs/platform/core/reference/gt-class-methods/translation/enqueue-files) | `string[]` · **Obligatoire**

Le résultat renvoyé par [`enqueueFiles`](/docs/platform/core/reference/gt-class-methods/translation/enqueue-files), ou les ID de tâches renvoyés par un autre workflow tel que [`setupProject`](/docs/platform/core/reference/gt-class-methods/translation/setup-project). Lorsque vous transmettez un résultat d&#39;enqueue, son `jobData` indique quelles tâches interroger.

### `options`

**Type** `AwaitJobsOptions` · **Facultatif**

Configuration de l’interrogation, issue de `generaltranslation/types`. Contrairement aux [options d’interrogation de l’API](/docs/platform/core/reference/api-client#job-polling), les options de la classe n’exposent ni `onPoll` ni signal fourni par l’appelant :

| Champ                    | Description                                                   | Type     | Facultatif | Par défaut     |
| ------------------------ | ------------------------------------------------------------- | -------- | ---------- | -------------- |
| `pollingIntervalSeconds` | Fréquence de vérification des mises à jour d’état.            | `number` | Oui        | `5`            |
| `timeoutSeconds`         | Durée maximale d’attente avant de renvoyer les états actuels. | `number` | Oui        | `600` (10 min) |

## Renvoie [#returns]

**Type** `Promise<AwaitJobsResult>`

Renvoie un `AwaitJobsResult` avec un indicateur global et l’état final de chaque tâche :

```typescript
type AwaitJobsResult = {
  /** Indique si tous les jobs ont atteint un état terminal (pas nécessairement un succès). */
  complete: boolean;
  jobs: JobResult[];
};

type JobResult = {
  jobId: string;
  status: JobStatus;
  error?: { message: string };
};
```

| Propriété       | Description                                                                                      | Type                                                                                                 |
| --------------- | ------------------------------------------------------------------------------------------------ | ---------------------------------------------------------------------------------------------------- |
| `complete`      | `true` si aucune tâche n&#39;est encore en cours ; `false` si le délai d&#39;attente a été atteint. | `boolean`                                                                                            |
| `jobs`          | État final de chaque tâche.                                                                        | `JobResult[]`                                                                                        |
| `jobs[].jobId`  | L&#39;identifiant de la tâche.                                                                        | `string`                                                                                             |
| `jobs[].status` | Dernier état connu ; peut encore être `'queued'` ou `'processing'` à l&#39;expiration du délai.  | [`JobStatus`](/docs/platform/core/reference/gt-class-methods/translation/check-job-status#jobstatus) |
| `jobs[].error`  | Détails de l&#39;erreur si la tâche a échoué.                                                      | `{ message: string }`                                                                                |

## Exemples [#examples]

Interrogez directement les ID des tâches :

```typescript
const result = await gt.awaitJobs(['job-123', 'job-456']);
```

Interrogez le résultat de [`enqueueFiles`](/docs/platform/core/reference/gt-class-methods/translation/enqueue-files) :

```typescript title="index.ts"
import { GT } from 'generaltranslation';

const gt = new GT({
  projectId: 'your-project-id',
  apiKey: 'your-api-key',
});

// Téléverser et mettre en file d'attente
const { uploadedFiles } = await gt.uploadSourceFiles(files, {
  sourceLocale: 'en',
});

const enqueueResult = await gt.enqueueFiles(uploadedFiles, {
  sourceLocale: 'en',
  targetLocales: ['es', 'fr', 'de'],
});

// Attendre la fin de toutes les tâches (interrogation toutes les 10 s, délai d'attente après 5 min)
const result = await gt.awaitJobs(enqueueResult, {
  pollingIntervalSeconds: 10,
  timeoutSeconds: 300,
});

if (!result.complete) {
  console.warn('Some jobs did not finish in time');
}

// Vérifier les résultats individuels
for (const job of result.jobs) {
  if (job.status === 'completed') {
    console.log(`Job ${job.jobId} succeeded`);
  } else if (job.status === 'failed') {
    console.error(`Job ${job.jobId} failed: ${job.error?.message}`);
  }
}
```

## Remarques [#notes]

* Les tâches introuvables par l’API sont considérées comme ayant l’état `'unknown'`.
* Une entrée vide renvoie `{ complete: true, jobs: [] }` après la validation de l’authentification.
* En cas de dépassement du délai d’expiration, la méthode renvoie les derniers états acceptés, qui ne sont pas forcément des états finaux ; les résultats d’interrogation arrivés en retard sont ignorés.

## Sitemap

See the full [sitemap](https://generaltranslation.com/sitemap.md) for all pages.