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

title: queryFileData
description: Vérifiez l’état de la traduction et les métadonnées des fichiers téléversés ou traduits. Référence API pour queryFileData.

---

Récupère des données sur un ou plusieurs fichiers source ou de traduction avec General Translation. Utilisez cette fonction pour suivre l’avancement de la traduction, vérifier son état d’achèvement et voir quelles traductions sont disponibles.

## Vue d’ensemble [#overview]

Appelez `queryFileData` avec un objet indiquant les fichiers source et/ou les fichiers traduits à interroger. La fonction renvoie les métadonnées de chaque fichier demandé.

```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' },
  ],
});
```

Signature :

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

*Remarque : `queryFileData` nécessite un `apiKey` (ou `devApiKey`) et un `projectId` sur l’instance GT.*

## Fonctionnement [#how-it-works]

* **Finalisation.** Une traduction est terminée lorsque son `completedAt` n’est pas `null`.
* **Cycle de vie.** Une traduction terminée peut encore nécessiter une approbation (`approvedAt`) avant d’être publiée (`publishedAt`).
* **Suivi par lots.** Interrogez plusieurs fichiers en une seule fois pour vérifier efficacement l’état de plusieurs tâches de traduction.
* **Gestion des versions.** Toutes les requêtes sur les fichiers nécessitent `branchId` pour la gestion des versions avec prise en charge des branches.

## Paramètres [#parameters]

| Paramètre             | Description                                                                 | Type                           | Facultatif | Par défaut |
| --------------------- | --------------------------------------------------------------------------- | ------------------------------ | ---------- | ---------- |
| [`data`](#data)       | Objet contenant les requêtes du fichier source et du fichier de traduction. | `FileDataQuery`                | Non        | —          |
| [`options`](#options) | Configuration de la requête.                                                | `CheckFileTranslationsOptions` | Oui        | —          |

### `data` [#data]

**Type** `FileDataQuery` · **Obligatoire**

Les fichiers à interroger, répartis entre fichiers source et fichiers traduits :

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

| Champ             | Description                                    | Type       | Facultatif |
| ----------------- | ---------------------------------------------- | ---------- | ---------- |
| `sourceFiles`     | Tableau de requêtes sur les fichiers source.   | `object[]` | Oui        |
| `translatedFiles` | Tableau de requêtes sur les fichiers traduits. | `object[]` | Oui        |

### `options` [#options]

**Type** `CheckFileTranslationsOptions` · **Facultatif**

| Champ     | Description                                         | Type     | Facultatif |
| --------- | --------------------------------------------------- | -------- | ---------- |
| `timeout` | Délai d’expiration de la requête, en millisecondes. | `number` | Oui        |

## Retourne [#returns]

**Type** `Promise<FileDataResult>`

Renvoie un `FileDataResult` contenant les métadonnées du fichier source demandé et des fichiers traduits :

```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;
  }[];
};
```

| Propriété         | Description                                    | Type       |
| ----------------- | ---------------------------------------------- | ---------- |
| `sourceFiles`     | Tableau de données de fichiers source.         | `object[]` |
| `translatedFiles` | Tableau de données sur l’état des traductions. | `object[]` |

## Exemples [#examples]

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

// (2) Téléverser le fichier
const fileUpload = {
  content: fileContents,
  fileName: filePath,
  fileFormat: 'JSON',
  locale: 'en',
};
const files = [{ source: fileUpload }];
const { uploadedFiles } = await gt.uploadSourceFiles(files, { sourceLocale: 'en' });

// (3) Mettre en file d'attente le job de traduction du fichier
const enqueueResult = await gt.enqueueFiles(uploadedFiles, {
  sourceLocale: 'en',
  targetLocales: targetLocales,
});

// (4) Attendre que toutes les traductions soient terminées
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) Télécharger les fichiers
const downloadResult = await gt.downloadFileBatch(
  translatedFileQueries.map(({ fileId, branchId, locale }) => ({
    fileId,
    branchId,
    locale,
  }))
);
```

## Notes [#notes]

* Une traduction est terminée lorsque `completedAt` n’est pas `null`.
* Les traductions terminées peuvent encore nécessiter une approbation (`approvedAt`) avant d’être publiées (`publishedAt`).
* Utilisez cette méthode pour vérifier efficacement l’état lors du suivi de plusieurs tâches de traduction.
* Toutes les requêtes de fichier nécessitent `branchId` pour la gestion des versions avec gestion des branches.