# General Translation Platform: awaitJobs
URL: https://generaltranslation.com/fr/docs/platform/core/reference/gt-class-methods/translation/await-jobs.mdx
---

title: awaitJobs
description: Interroge les jobs de traduction en file d’attente jusqu’à ce qu’ils soient terminés, échouent ou expirent. Référence de l’API pour awaitJobs.

---

Interroge l’état des jobs de traduction et se termine une fois que chaque job a atteint un état terminal (`completed`, `failed` ou `unknown`) ou qu’un délai d’expiration est atteint. Il s’agit d’un wrapper pratique autour de [`checkJobStatus`](/docs/platform/core/reference/gt-class-methods/translation/check-job-status) qui gère l’interrogation à votre place.

## Vue d’ensemble [#overview]

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

```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(
  enqueueResult: EnqueueFilesResult,
  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` dans une boucle `while`.
* **États terminaux.** La méthode se résout lorsque tous les jobs sont `completed`, `failed` ou `unknown`. Les jobs introuvables par l’API sont traités comme `'unknown'`.
* **Délai d’expiration en mode best effort.** Le délai d’expiration est une limite appliquée au mieux : la méthode termine l’interrogation en cours avant de se résoudre.
* **Entrée vide.** Si `enqueueResult` ne contient aucun job, la méthode se résout immédiatement avec `{ complete: true, jobs: [] }`.

## Paramètres [#parameters]

| Paramètre                          | Description                                  | Type                                                                                             | Facultatif | Par défaut |
| ---------------------------------- | -------------------------------------------- | ------------------------------------------------------------------------------------------------ | ---------- | ---------- |
| [`enqueueResult`](#enqueue-result) | L’objet résultat renvoyé par `enqueueFiles`. | [`EnqueueFilesResult`](/docs/platform/core/reference/gt-class-methods/translation/enqueue-files) | Non        | —          |
| [`options`](#options)              | Configuration de l’interrogation.            | `AwaitJobsOptions`                                                                               | Oui        | —          |

### `enqueueResult` [#enqueue-result]

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

Le résultat renvoyé par [`enqueueFiles`](/docs/platform/core/reference/gt-class-methods/translation/enqueue-files). Son `jobData` indique quels jobs interroger.

### `options` [#options]

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

Configuration de l’interrogation :

| 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 job :

```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 aucun job n&#39;est encore en cours ; `false` si le délai d&#39;attente a été atteint. | `boolean`                                                                                            |
| `jobs`          | État final de chaque job.                                                                        | `JobResult[]`                                                                                        |
| `jobs[].jobId`  | L&#39;identifiant du job.                                                                        | `string`                                                                                             |
| `jobs[].status` | État terminal : `'completed'`, `'failed'` ou `'unknown'`.                                        | [`JobStatus`](/docs/platform/core/reference/gt-class-methods/translation/check-job-status#jobstatus) |
| `jobs[].error`  | Détails de l&#39;erreur si le job a échoué.                                                      | `{ message: string }`                                                                                |

## Exemples [#examples]

```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 tous les jobs (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 jobs introuvables par l’API sont considérés comme ayant l’état `'unknown'`.
* Si `enqueueResult` ne contient aucun job, la méthode se résout immédiatement avec `{ complete: true, jobs: [] }`.
* Le délai d’expiration est une limite appliquée au mieux — la méthode termine l’interrogation en cours avant de se résoudre.