Skip to Content

Automazione del Flusso di Lavoro Video con l'API Snapencode

Impara a costruire un flusso di lavoro video completamente automatizzato, dal caricamento alla elaborazione e alla consegna, utilizzando l'API client-facing di Snapencode e uno script Node.js semplice.

da parte di
TS
The Snapencode Team
•
Hero image for Automazione del Flusso di Lavoro Video con l'API Snapencode

In questo mondo guidato dal contenuto, l’upload e la elaborazione dei video manuali possono essere un significativo ostacolo, rallentando tutto il tuo pipeline di contenuti. La vera potenza di una piattaforma come Snapencode risiede nella sua progettazione basata sull’API, che consente di automatizzare queste attività ripetitive e recuperare tempo prezioso.

In questo tutorial, costruiremo un “script di monitoraggio della cartella” pratico che monitora una directory per nuovi file video, li carica automaticamente su Snapencode e conferma lo stato di elaborazione.

L’Obiettivo: Un Caricatore di Cartella “Watch”

Il nostro obiettivo è creare uno script Node.js che raggiunga i seguenti punti:

  1. Monitora una directory specifica su un computer locale o server.
  2. Quando viene aggiunto un nuovo file video (.mp4, .mov, ecc.), carica automaticamente il file nella raccolta designata in Snapencode.
  3. Dopo l’upload, polla lo stato dell’endpoint di elaborazione fino a quando il video non è “completo”.
  4. Una volta completato, registra l’ID del video e si prepara per il prossimo file.

Questa è una soluzione perfetta per i flussi di lavoro in cui il contenuto viene generato programmaticamente o lasciato in una cartella condivisa da membri non tecnici dell’équipe.

Prerequisiti

  • Una chiave API di Snapencode: Generala dal tuo dashboard sotto Impostazioni > Chiavi API.
  • Node.js: Utilizzeremo JavaScript e il runtime Node.js per lo script.
  • axios e chokidar: Due pacchetti semplici per effettuare richieste API e monitorare file.
npm install axios chokidar form-data

Costruire lo Script di Automazione

Creeremo uno script completo. Chiamiamo il nostro script upload-watcher.js.

Passo 1: Configurare lo Script

Prima, impostiamo le variabili di configurazione e importiamo le librerie necessarie all’inizio del nostro file upload-watcher.js.

upload-watcher.js
const axios = require('axios');
const FormData = require('form-data');
const fs = require('fs');
const path = require('path');
const chokidar = require('chokidar');
 
// --- Configurazione ---
const API_BASE_URL = 'https://your-Snapencode-domain.com/api/client/v1';
const API_KEY = process.env.Snapencode_API_KEY || 'sk_your_api_key_here'; // Consiglio: utilizzare variabili di ambiente
const TARGET_FOLDER = 'root/automated-uploads'; // La cartella di destinazione in Snapencode
const WATCH_DIRECTORY = './videos-to-upload';
 
// Un set per tenere traccia dei file attualmente in elaborazione per evitare caricamenti duplicati
const processingFiles = new Set();

Utilizzare le variabili di ambiente (process.env.Snapencode_API_KEY) per la tua chiave API è molto più sicuro che non hardcoded direttamente nello script.

Passo 2: Creare le Funzioni Principali

Successivamente, aggiungiamo le due funzioni principali: una per gestire l’upload del file e un’altra per monitorare lo stato di elaborazione.

upload-watcher.js
// (Aggiungi questo codice sotto la sezione di configurazione)
 
async function uploadVideo(filePath) {
console.log(`[UPLOADING] Inizia l'upload per: ${path.basename(filePath)}`);
processingFiles.add(filePath); // Marca il file come in elaborazione
 
const form = new FormData();
form.append('video', fs.createReadStream(filePath));
form.append('folder', TARGET_FOLDER);
 
try {
const response = await axios.post(`${API_BASE_URL}/uploads`, form, {
headers: { ...form.getHeaders(), 'Authorization': `Bearer ${API_KEY}` },
});
console.log(`[SUCCESS] L'upload è stato accettato! ID del video: ${response.data.data.id}`);
return response.data.data.id;
} catch (error) {
console.error(`[FAILURE] L'upload ha fallito per ${path.basename(filePath)}:`, error.response?.data?.message || error.message);
return null;
}
}
 
async function monitorStatus(videoId, filePath) {
if (!videoId) {
processingFiles.delete(filePath); // Rimuovi dal set di elaborazione in caso di fallimento
return;
}
 
console.log(`[MONITORING] Stato in attesa per ID del video: ${videoId}`);
const interval = setInterval(async () => {
try {
const response = await axios.get(`${API_BASE_URL}/uploads/${videoId}`, {
headers: { 'Authorization': `Bearer ${API_KEY}` },
});
const { status, status_text } = response.data.data;
 
if (status === 6) { // Completato
console.log(`✅ [COMPLETE] L'elaborazione è stata completata per ID del video: ${videoId}!`);
clearInterval(interval);
processingFiles.delete(filePath); // Rimuovi dal set in caso di successo
} else if (status === 7) { // Fallito
console.error(`❌ [FAILED] L'elaborazione ha fallito per ID del video: ${videoId}.`);
clearInterval(interval);
processingFiles.delete(filePath);
} else {
console.log(`[STATUS] ID del video ${videoId}: ${status_text} (${status})`);
}
} catch (error) {
console.error(`[ERROR] Non è stato possibile ottenere lo stato per ${videoId}:`, error.message);
clearInterval(interval);
processingFiles.delete(filePath);
}
}, 5000); // Controlla ogni 5 secondi
}

Questo script dimostra un’interazione server-to-server. Non esporre mai la tua chiave API in codice client-side.

Passo 3: Inizializzare il Monitoraggio della Cartella

Infine, aggiungi la logica chokidar alla fine dello script. Questo monitorerà la directory e attiverà le nostre funzioni quando viene aggiunto un nuovo file.

upload-watcher.js
// (Aggiungi questo codice alla fine del file)
 
function initializeWatcher() {
console.log(`--- Snapencode Watch Folder Inizializzato ---`);
console.log(`Monitora nuovi video in: ${path.resolve(WATCH_DIRECTORY)}`);
 
if (!fs.existsSync(WATCH_DIRECTORY)) {
console.log(`Crea la directory di monitoraggio...`);
fs.mkdirSync(WATCH_DIRECTORY, { recursive: true });
}
 
const watcher = chokidar.watch(WATCH_DIRECTORY, {
ignored: /(^|[\/\\])\../, // ignora file con estensione
persistent: true,
ignoreInitial: true, // Non caricare file già presenti all'avvio
});
 
watcher.on('add', (filePath) => {
if (processingFiles.has(filePath)) {
return; // Ignora se già in elaborazione
}
console.log(`[DETECTED] Nuovo file: ${path.basename(filePath)}`);
// Aspetta un momento per assicurarsi che il file sia scritto completamente prima di caricarlo
setTimeout(async () => {
const videoId = await uploadVideo(filePath);
await monitorStatus(videoId, filePath);
}, 2000);
});
}
 
initializeWatcher();

Passo 4: Eseguire il tuo Caricatore

Con il file upload-watcher.js completo, puoi eseguirlo dalla tua riga di comando.

# Consiglio: impostare la chiave API come variabile di ambiente
export Snapencode_API_KEY="sk_your_api_key_here"
 
# Esegui lo script
node upload-watcher.js

Ora, qualsiasi nuovo file video che lasci nella directory ./videos-to-upload verrà caricato e elaborato automaticamente!