# General Translation Platform: queryFileData
URL: https://generaltranslation.com/it/docs/platform/core/reference/gt-class-methods/translation/query-file-data.mdx
---

title: queryFileData
description: Controlla lo stato della traduzione e i metadati dei file caricati o tradotti. Riferimento API per queryFileData.

---

Recupera i dati di uno o più file sorgente o di traduzione con General Translation. Usalo per monitorare l'avanzamento della traduzione, controllarne lo stato di completamento e vedere quali traduzioni sono disponibili.

## Panoramica [#overview]

Chiama `queryFileData` con un oggetto contenente l'elenco dei file sorgente e/o tradotti da interrogare. Restituisce i metadati per ciascun file richiesto.

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

const result = await gt.queryFileData({
  sourceFiles: [{ fileId: 'file-123', versionId: 'version-456', branchId: 'branch-789' }],
  translatedFiles: [
    { fileId: 'file-123', versionId: 'version-456', branchId: 'branch-789', locale: 'es' },
  ],
});
```

Firma:

```typescript
queryFileData(
  data: FileDataQuery,
  options?: CheckFileTranslationsOptions
): Promise<FileDataResult>
```

*Nota: `queryFileData` richiede una `apiKey` (o `devApiKey`) e `projectId` sull&#39;istanza GT.*

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

* **Completamento.** Una traduzione è completa quando `completedAt` non è `null`.
* **Ciclo di vita.** Una traduzione completata può comunque richiedere l&#39;approvazione (`approvedAt`) prima di essere pubblicata (`publishedAt`).
* **Monitoraggio batch.** Esegui query su molti file contemporaneamente per controllare in modo efficiente lo stato di più job di traduzione.
* **Gestione delle versioni.** Tutte le query sui file richiedono `branchId` per la gestione delle versioni con supporto per i branch.

## Parametri [#parameters]

| Parametro             | Descrizione                                                             | Tipo                           | Facoltativo | Predefinito |
| --------------------- | ----------------------------------------------------------------------- | ------------------------------ | ----------- | ----------- |
| [`data`](#data)       | Oggetto contenente le query del file sorgente e del file di traduzione. | `FileDataQuery`                | No          | —           |
| [`options`](#options) | Configurazione per la richiesta.                                        | `CheckFileTranslationsOptions` | Sì          | —           |

### `data` [#data]

**Tipo** `FileDataQuery` · **Obbligatorio**

I file su cui eseguire la query, suddivisi in file sorgente e file tradotti:

```typescript
type FileDataQuery = {
  sourceFiles?: {
    fileId: string;
    versionId: string;
    branchId: string;
  }[];
  translatedFiles?: {
    fileId: string;
    versionId: string;
    branchId: string;
    locale: string;
  }[];
};
```

| Campo             | Descrizione                         | Type       | Facoltativo |
| ----------------- | ----------------------------------- | ---------- | ----------- |
| `sourceFiles`     | Array di query per i file sorgente. | `object[]` | Sì          |
| `translatedFiles` | Array di query per i file tradotti. | `object[]` | Sì          |

### `options` [#options]

**Tipo** `CheckFileTranslationsOptions` · **Facoltativo**

| Campo     | Descrizione                              | Tipo     | Facoltativo |
| --------- | ---------------------------------------- | -------- | ----------- |
| `timeout` | Timeout della richiesta in millisecondi. | `number` | Sì          |

## Restituisce [#returns]

**Tipo** `Promise<FileDataResult>`

Si risolve con un `FileDataResult` contenente i metadati dei file sorgente e tradotti richiesti:

```typescript
type FileDataResult = {
  sourceFiles?: {
    branchId: string;
    fileId: string;
    versionId: string;
    fileName: string;
    fileFormat: string;
    dataFormat: string | null;
    createdAt: string;
    updatedAt: string;
    publishedAt: string | null;
    locales: string[];
    sourceLocale: string;
  }[];
  translatedFiles?: {
    fileId: string;
    versionId: string;
    branchId: string;
    locale: string;
    fileFormat: string;
    dataFormat: string | null;
    completedAt: string | null;
    approvedAt: string | null;
    publishedAt: string | null;
    createdAt: string;
    updatedAt: string;
  }[];
};
```

| Proprietà         | Descrizione                                           | Tipo       |
| ----------------- | ----------------------------------------------------- | ---------- |
| `sourceFiles`     | Array contenente i dati dei file sorgente.            | `object[]` |
| `translatedFiles` | Array contenente i dati sullo stato delle traduzioni. | `object[]` |

## Esempi [#examples]

```typescript title="index.ts"
// (1) Crea un'istanza GT
const targetLocales = ['es', 'fr', 'de'];
const gt = new GT({
  projectId: 'your-project-id',
  apiKey: 'your-api-key',
});

// (2) Carica il file
const fileUpload = {
  content: fileContents,
  fileName: filePath,
  fileFormat: 'JSON',
  locale: 'en',
};
const files = [{ source: fileUpload }];
const { uploadedFiles } = await gt.uploadSourceFiles(files, { sourceLocale: 'en' });

// (3) Accoda il translation job del file
const enqueueResult = await gt.enqueueFiles(uploadedFiles, {
  sourceLocale: 'en',
  targetLocales: targetLocales,
});

// (4) Attendi il completamento di tutte le traduzioni
const { fileId, versionId, branchId } = uploadedFiles[0];
const translatedFileQueries = targetLocales.map((locale) => ({
  fileId,
  versionId,
  branchId,
  locale,
}));

while (true) {
  const result = await gt.queryFileData({
    translatedFiles: translatedFileQueries,
  });

  const allCompleted = result.translatedFiles?.every((file) => file.completedAt !== null);

  if (allCompleted) {
    break;
  }

  await new Promise((resolve) => setTimeout(resolve, 1000));
}

// (5) Scarica i file
const downloadResult = await gt.downloadFileBatch(
  translatedFileQueries.map(({ fileId, branchId, locale }) => ({
    fileId,
    branchId,
    locale,
  }))
);
```

## Note [#notes]

* Una traduzione è completa quando `completedAt` non è `null`.
* Le traduzioni completate possono comunque richiedere l&#39;approvazione (`approvedAt`) prima di essere pubblicate (`publishedAt`).
* Usa questo metodo per verificare in modo efficiente lo stato quando monitori più job di traduzione.
* Tutte le query sui file richiedono `branchId` per la gestione delle versioni con supporto dei branch.