# General Translation Platform: awaitJobs
URL: https://generaltranslation.com/it/docs/platform/core/reference/gt-class-methods/translation/await-jobs.mdx
Docs index: https://generaltranslation.com/llms.txt
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.

Attende che tutti i job siano in stato `completed`, `failed` o `unknown`, oppure che venga raggiunto il timeout. Supporta sia i job di traduzione sia i job di setup.

## Panoramica [#overview]

Passa il risultato di [`enqueueFiles`](/docs/platform/core/reference/gt-class-methods/translation/enqueue-files) o un array di ID job 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(
  jobs: EnqueueFilesResult | string[],
  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`](/docs/platform/core/reference/gt-class-methods/translation/check-job-status) 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'`.
* **Scadenza.** Ogni richiesta di stato ha un timeout massimo di 60 secondi, ridotto al tempo complessivo residuo. Allo scadere del timeout vengono restituiti gli ultimi stati noti con `complete: false`; i job potrebbero essere ancora in coda, in elaborazione o in stato sconosciuto. Le implementazioni personalizzate di fetch devono supportare l&#39;annullamento per potersi interrompere tempestivamente.
* **Errori.** Gli errori di stato che si verificano prima della scadenza causano il rifiuto della promise. Gli errori successivi alla scadenza producono invece risultati incompleti. L&#39;interruzione del polling non annulla i job remoti.
* **Input vuoto.** Dopo la convalida delle credenziali e dell&#39;ID progetto, un input vuoto si risolve con `{ complete: true, jobs: [] }`.

## Parametri [#parameters]

| Parametro             | Descrizione                                                                                                                                 | Tipo                                                                                                          | Facoltativo | Predefinito |
| --------------------- | ------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------- | ----------- | ----------- |
| [`jobs`](#jobs)       | Il risultato restituito da [`enqueueFiles`](/docs/platform/core/reference/gt-class-methods/translation/enqueue-files) o un array di ID job. | [`EnqueueFilesResult`](/docs/platform/core/reference/gt-class-methods/translation/enqueue-files) | `string[]` | No          | —           |
| [`options`](#options) | Configurazione del polling.                                                                                                                 | `AwaitJobsOptions`                                                                                            | Sì          | —           |

### `jobs`

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

Il risultato restituito da [`enqueueFiles`](/docs/platform/core/reference/gt-class-methods/translation/enqueue-files), oppure gli ID job restituiti da un altro workflow, ad esempio [`setupProject`](/docs/platform/core/reference/gt-class-methods/translation/setup-project). Quando passi un risultato di enqueue, il relativo `jobData` identifica i job da monitorare.

### `options`

**Tipo** `AwaitJobsOptions` · **Facoltativo**

Configurazione del polling da `generaltranslation/types`. A differenza delle [opzioni di polling dell&#39;API](/docs/platform/core/reference/api-client#job-polling), le opzioni della classe non espongono `onPoll` né un segnale del chiamante:

| Campo                    | Descrizione                                                     | Tipo     | Facoltativo | Predefinito    |
| ------------------------ | --------------------------------------------------------------- | -------- | ----------- | -------------- |
| `pollingIntervalSeconds` | Frequenza con cui eseguire il polling per 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 più recente; allo scadere del timeout potrebbe essere ancora `'queued'` o `'processing'`. | [`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]

Esegui direttamente il polling degli ID job:

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

Esegui il polling del risultato di [`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',
});

// 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'`.
* Un input vuoto restituisce `{ complete: true, jobs: [] }` dopo la validazione dell&#39;autenticazione.
* In caso di timeout vengono restituiti gli ultimi stati accettati, non necessariamente quelli terminali; i risultati del polling arrivati in ritardo vengono scartati.

## Sitemap

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