# generaltranslation: General Translation Core SDK: uploadTranslations
URL: https://generaltranslation.com/it/docs/core/class/methods/translation/upload-translations.mdx
---
title: uploadTranslations
description: Riferimento API del metodo uploadTranslations per caricare file di traduzione esistenti
---

## Panoramica

Il metodo `uploadTranslations` carica i file di traduzione corrispondenti ai file sorgente caricati in precedenza.
È utile quando hai traduzioni già esistenti che vuoi caricare direttamente, anziché generarle tramite il servizio di traduzione.

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

const result = await gt.uploadTranslations(files, {
  sourceLocale: 'en'
});
```

<Callout type="info">
  Prima di caricare le traduzioni, devi aver già caricato i file sorgente usando [`uploadSourceFiles`](/docs/core/class/methods/translation/upload-source-files).
</Callout>


## Riferimento

### Parametri

| Nome      | Tipo                  | Descrizione                                                        |
| --------- | --------------------- | ------------------------------------------------------------------ |
| `files`   | `TranslationUpload[]` | Array di riferimenti ai file sorgente con le relative traduzioni |
| `options` | `UploadFilesOptions`  | Opzioni di configurazione per l&#39;upload                         |

#### Struttura TranslationUpload

```typescript
type TranslationUpload = {
  source: FileUpload;      // Riferimento al file sorgente esistente (nessun contenuto necessario)
  translations: FileUpload[]; // Array di file tradotti con contenuto
}
```


#### Struttura FileUpload (per il file sorgente di riferimento)

| Nome         | Tipo         | Descrizione                                                          |
| ------------ | ------------ | -------------------------------------------------------------------- |
| `fileName`   | `string`     | Nome del file corrispondente al file sorgente caricato in precedenza |
| `fileFormat` | `FileFormat` | Formato del file (JSON, MDX, MD, XML, ecc.)                          |
| `fileId?`    | `string`     | ID facoltativo del file sorgente                                     |
| `versionId?` | `string`     | ID facoltativo della versione del file sorgente                      |

#### Struttura FileUpload (per le traduzioni)

| Nome         | Tipo         | Descrizione                                     |
| ------------ | ------------ | ----------------------------------------------- |
| `content`    | `string`     | Contenuto grezzo del file tradotto come stringa |
| `fileName`   | `string`     | Nome del file della traduzione                  |
| `fileFormat` | `FileFormat` | Formato del file (JSON, MDX, MD, XML, ecc.)     |
| `locale`     | `string`     | Impostazione regionale di destinazione          |
| `fileId?`    | `string`     | ID del file facoltativo                         |
| `versionId?` | `string`     | ID della versione facoltativo                   |

#### UploadFilesOptions

| Nome           | Tipo     | Descrizione                                        |
| -------------- | -------- | -------------------------------------------------- |
| `sourceLocale` | `string` | L&#39;impostazione regionale di origine dei file   |
| `branchId?`    | `string` | ID branch facoltativo su cui eseguire l&#39;upload |
| `timeout?`     | `number` | Timeout della richiesta in millisecondi            |

### Restituisce

`Promise<UploadFilesResponse>` - Contiene i risultati dell&#39;upload e i riferimenti ai file.

```typescript
type UploadFilesResponse = {
  uploadedFiles: FileReference[];
  count: number;
  message: string;
}
```

| Proprietà       | Tipo              | Descrizione                                |
| --------------- | ----------------- | ------------------------------------------ |
| `uploadedFiles` | `FileReference[]` | Array di riferimenti ai file caricati      |
| `count`         | `number`          | Numero di file caricati correttamente      |
| `message`       | `string`          | Messaggio di stato restituito dall&#39;API |

***


## Esempi

### Uso di base

Carica le traduzioni dei file sorgente caricati in precedenza:

```typescript copy
import { GT } from 'generaltranslation';
import fs from 'fs';

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

// Si presuppone che il file sorgente sia stato caricato in precedenza
const files = [
  {
    source: {
      fileName: 'common.json',
      fileFormat: 'JSON' as const,
      fileId: 'source-file-id',
      versionId: 'source-version-id'
    },
    translations: [
      {
        content: fs.readFileSync('./locales/es/common.json', 'utf8'),
        fileName: 'common.json',
        fileFormat: 'JSON' as const,
        locale: 'es'
      },
      {
        content: fs.readFileSync('./locales/fr/common.json', 'utf8'),
        fileName: 'common.json',
        fileFormat: 'JSON' as const,
        locale: 'fr'
      }
    ]
  }
];

const result = await gt.uploadTranslations(files, {
  sourceLocale: 'en'
});

console.log(`Uploaded ${result.count} translation files`);
```


### Caricamento delle traduzioni dopo quello dei file sorgente

Flusso di lavoro completo per caricare prima i file sorgente e poi le traduzioni:

```typescript copy
import { GT } from 'generaltranslation';
import fs from 'fs';

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

// Passaggio 1: carica i file sorgente
const sourceFiles = [
  {
    source: {
      content: fs.readFileSync('./locales/en/messages.json', 'utf8'),
      fileName: 'messages.json',
      fileFormat: 'JSON' as const,
      locale: 'en'
    }
  }
];

const { uploadedFiles } = await gt.uploadSourceFiles(sourceFiles, {
  sourceLocale: 'en'
});

// Passaggio 2: carica le traduzioni esistenti
const translationFiles = [
  {
    source: {
      fileName: uploadedFiles[0].fileName,
      fileFormat: uploadedFiles[0].fileFormat,
      fileId: uploadedFiles[0].fileId,
      versionId: uploadedFiles[0].versionId
    },
    translations: [
      {
        content: fs.readFileSync('./locales/es/messages.json', 'utf8'),
        fileName: 'messages.json',
        fileFormat: 'JSON' as const,
        locale: 'es'
      },
      {
        content: fs.readFileSync('./locales/de/messages.json', 'utf8'),
        fileName: 'messages.json',
        fileFormat: 'JSON' as const,
        locale: 'de'
      }
    ]
  }
];

const translationResult = await gt.uploadTranslations(translationFiles, {
  sourceLocale: 'en'
});

console.log(`Caricate ${translationResult.count} traduzioni`);
```


### Upload di più file in batch

Carica le traduzioni per più file sorgente:

```typescript copy
import { glob } from 'glob';
import path from 'path';

async function uploadAllTranslations(
  sourceRefs: FileReference[],
  targetLocales: string[]
) {
  const files = sourceRefs.map(sourceRef => ({
    source: {
      fileName: sourceRef.fileName,
      fileFormat: sourceRef.fileFormat,
      fileId: sourceRef.fileId,
      versionId: sourceRef.versionId
    },
    translations: targetLocales
      .map(locale => {
        const translationPath = `./locales/${locale}/${sourceRef.fileName}`;
        try {
          return {
            content: fs.readFileSync(translationPath, 'utf8'),
            fileName: sourceRef.fileName,
            fileFormat: sourceRef.fileFormat,
            locale
          };
        } catch {
          // Il file di traduzione non esiste per questa impostazione regionale
          return null;
        }
      })
      .filter(Boolean)
  }));

  const result = await gt.uploadTranslations(files, {
    sourceLocale: 'en',
    timeout: 60000
  });

  return result;
}
```

***


## Note

* I file sorgente devono prima essere caricati usando [`uploadSourceFiles`](/docs/core/class/methods/translation/upload-source-files)
* L&#39;oggetto `source` in ogni voce di file è un riferimento a un file sorgente esistente (il contenuto non è necessario)
* Ogni traduzione nell&#39;array `translations` deve includere il contenuto e un&#39;impostazione regionale di destinazione
* Questo metodo è utile per migrare traduzioni esistenti o caricare traduzioni revisionate da un revisore umano
* I riferimenti ai file includono `branchId` per una corretta gestione delle versioni con supporto ai branch

## Passaggi successivi

* Consulta [`uploadSourceFiles`](/docs/core/class/methods/translation/upload-source-files) per caricare prima i file sorgente
* Consulta [`enqueueFiles`](/docs/core/class/methods/translation/enqueue-files) per generare automaticamente le traduzioni
* Consulta [`downloadFile`](/docs/core/class/methods/translation/download-file) per scaricare le traduzioni
* Consulta [`queryFileData`](/docs/core/class/methods/translation/query-file-data) per verificare lo stato della traduzione