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

title: awaitJobs
description: Esegue il polling dei job di traduzione in coda finché non vengono completati, non falliscono o non scade il timeout. Riferimento API per awaitJobs.

---

Esegue il polling dello stato dei job di traduzione e si risolve quando tutti i job raggiungono uno stato terminale (`completed`, `failed` o `unknown`) oppure quando viene raggiunto il timeout. È un pratico wrapper di [`checkJobStatus`](/docs/platform/core/reference/gt-class-methods/translation/check-job-status) che gestisce il polling al posto tuo.

## Panoramica [#overview]

Passa il risultato di [`enqueueFiles`](/docs/platform/core/reference/gt-class-methods/translation/enqueue-files) a `awaitJobs`, opzionalmente con le impostazioni di polling. La promise si risolve con lo stato finale di ciascun 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');
}
```

Firma:

```typescript
awaitJobs(
  enqueueResult: EnqueueFilesResult,
  options?: AwaitJobsOptions
): Promise<AwaitJobsResult>
```

*Avvertenza: `complete: true` significa che tutti i job hanno raggiunto uno stato terminale — **non** significa che tutti i job siano andati a buon fine. Controlla ogni `job.status` per verificare l&#39;esito positivo.*

## Come funziona [#how-it-works]

* **Polling automatico.** Sostituisce i cicli di polling manuali: non devi chiamare tu stesso `checkJobStatus` in un ciclo `while`.
* **Stati terminali.** Si risolve quando ogni job è `completed`, `failed` o `unknown`. I job che l&#39;API non riesce a trovare vengono trattati come `'unknown'`.
* **Timeout best-effort.** Il timeout è un limite best-effort: il metodo completa il polling corrente prima di risolversi.
* **Input vuoto.** Se `enqueueResult` non contiene job, il metodo si risolve immediatamente con `{ complete: true, jobs: [] }`.

## Parametri [#parameters]

| Parametro                          | Descrizione                                           | Type                                                                                             | Facoltativo | Predefinito |
| ---------------------------------- | ----------------------------------------------------- | ------------------------------------------------------------------------------------------------ | ----------- | ----------- |
| [`enqueueResult`](#enqueue-result) | L&#39;oggetto risultato restituito da `enqueueFiles`. | [`EnqueueFilesResult`](/docs/platform/core/reference/gt-class-methods/translation/enqueue-files) | No          | —           |
| [`options`](#options)              | Configurazione del polling.                           | `AwaitJobsOptions`                                                                               | Sì          | —           |

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

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

Il risultato restituito da [`enqueueFiles`](/docs/platform/core/reference/gt-class-methods/translation/enqueue-files). Il relativo `jobData` identifica i job da monitorare.

### `options` [#options]

**Type** `AwaitJobsOptions` · **Facoltativo**

Configurazione del polling:

| Campo                    | Descrizione                                                     | Type     | Facoltativo | Predefinito    |
| ------------------------ | --------------------------------------------------------------- | -------- | ----------- | -------------- |
| `pollingIntervalSeconds` | Frequenza con cui controllare gli aggiornamenti di stato.       | `number` | Sì          | `5`            |
| `timeoutSeconds`         | Tempo massimo di attesa prima di restituire gli stati correnti. | `number` | Sì          | `600` (10 min) |

## Restituisce [#returns]

**Tipo** `Promise<AwaitJobsResult>`

Restituisce un `AwaitJobsResult` con un flag complessivo e lo stato finale di ciascun job:

```typescript
type AwaitJobsResult = {
  /** Se tutti i job hanno raggiunto uno stato terminale (non necessariamente di successo). */
  complete: boolean;
  jobs: JobResult[];
};

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

| Proprietà       | Descrizione                                                                      | Tipo                                                                                                 |
| --------------- | -------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------- |
| `complete`      | `true` se nessun job è ancora in corso; `false` se è stato raggiunto il timeout. | `boolean`                                                                                            |
| `jobs`          | Stato finale di ciascun job.                                                     | `JobResult[]`                                                                                        |
| `jobs[].jobId`  | L&#39;ID del job.                                                                | `string`                                                                                             |
| `jobs[].status` | Stato finale: `'completed'`, `'failed'` o `'unknown'`.                           | [`JobStatus`](/docs/platform/core/reference/gt-class-methods/translation/check-job-status#jobstatus) |
| `jobs[].error`  | Dettagli dell&#39;errore se il job non è andato a buon fine.                     | `{ message: string }`                                                                                |

## Esempi [#examples]

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

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

// Carica e accoda
const { uploadedFiles } = await gt.uploadSourceFiles(files, {
  sourceLocale: 'en',
});

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

// Attendi il completamento di tutti i job (polling ogni 10s, timeout dopo 5 min)
const result = await gt.awaitJobs(enqueueResult, {
  pollingIntervalSeconds: 10,
  timeoutSeconds: 300,
});

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

// Controlla i risultati dei singoli job
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}`);
  }
}
```

## Note [#notes]

* I job che l&#39;API non trova vengono considerati con stato `'unknown'`.
* Se `enqueueResult` non contiene job, il metodo si completa immediatamente con `{ complete: true, jobs: [] }`.
* Il timeout è un limite best-effort: prima di completarsi, il metodo termina il polling in corso.