Skip to Content

Automatizarea fluxului dvs. de video cu API-ul Snapencode

Învățați cum să construiți un flux de video complet automatizat, de la încărcare până la procesare și livrare, folosind API-ul client-facing Snapencode și o simplă scripți Node.js.

de către
TS
The Snapencode Team
•
Hero image for Automatizarea fluxului dvs. de video cu API-ul Snapencode

În lumea noastră de astăzi, care se bazează pe conținut, încărcarea și procesarea video manual pot fi o piedică semnificativă, lentând întregul flux de conținut. Puterea reală a unei platforme ca Snapencode stă în designul său API-first, care permite automatizarea acestor sarcini repetitive și recuperează timp valoros.

În această tutorial, vom crea un script practic “watch folder” care monitorizează o directorie pentru noi fișiere video, încarcă automat acestea în Snapencode și confirmă starea de procesare.

Obiectivul: Un “Watch Folder” Uploader

Scopul nostru este să creăm un script Node.js care atinge următoarele obiective:

  1. Monitorizează o anumită directorie pe o mașină locală sau server.
  2. Când se adaugă o nouă fișier video (.mp4, .mov, etc.), îl încarcă automat într-o colecție specificată în Snapencode.
  3. După încărcare, poll-urile endpoint-ul de stare până când videoul este “complet.”
  4. Odată ce este complet, loghează ID-ul videoului și este gata pentru următorul fișier.

Acesta este o soluție perfectă pentru fluxuri de lucru unde conținutul se generează programatic sau se lasă într-o folder comună de către membrii echipei non-tehnicieni.

Cerințe

  • Cheia API Snapencode: Generează una din panoului dvs. sub Setări > Chei API.
  • Node.js: Vom folosi JavaScript și runtime-ul Node.js pentru scriptul nostru.
  • axios și chokidar: Două pachete simple pentru a face cereri API și de urmărire a fișierelor.
npm install axios chokidar form-data

Crearea Scriptului de Automatizare

Vom crea un singur script complet. Să numim-l upload-watcher.js.

Pasul 1: Configurația Scriptului

În primul rând, să configurăm variabilele de configurație și să importăm bibliotecile necesare la începutul fișierului nostru 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');
 
// --- Configurație ---
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'; // Sfaturi: folosiți variabilele de mediu
const TARGET_FOLDER = 'root/automated-uploads'; // Calea colecției în Snapencode
const WATCH_DIRECTORY = './videos-to-upload';
 
// Un set pentru a ține evidența fișierelor curent încărcate pentru a evita încărcările duble
const processingFiles = new Set();

Folosirea variabilelor de mediu (process.env.Snapencode_API_KEY) pentru cheia dvs. API este mult mai sigură decât codarea direct în script.

Pasul 2: Crearea funcțiilor principale

În următorul pas, adăugați cele două funcții principale: una pentru a gestiona încărcarea fișierului și alta pentru monitorizarea stării de procesare.

upload-watcher.js
// (Adăugați acest cod sub secțiunea de configurație)
 
async function uploadVideo(filePath) {
    console.log(`[UPLOADING] Începe încărcarea pentru: ${path.basename(filePath)}`);
    processingFiles.add(filePath); // Marca fișierul ca fiind încărcat
 
    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] Încărcarea acceptată! ID-ul videoului: ${response.data.data.id}`);
        return response.data.data.id;
    } catch (error) {
        console.error(`[FAILURE] Încărcarea a eșuat pentru ${path.basename(filePath)}:`, error.response?.data?.message || error.message);
        return null;
    }
}
 
async function monitorStatus(videoId, filePath) {
    if (!videoId) {
        processingFiles.delete(filePath); // Elimina din setul de procesare pe eşuare
        return;
    }
 
    console.log(`[MONITORING] Urmărește starea pentru ID-ul videoului: ${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) { // Complet
                console.log(`✅ [COMPLETE] Procesarea finalizată pentru ID-ul videoului: ${videoId}!`);
                clearInterval(interval);
                processingFiles.delete(filePath); // Elimina din set pe succes
            } else if (status === 7) { // Eșuat
                console.error(`❌ [FAILED] Procesarea a eșuat pentru ID-ul videoului: ${videoId}.`);
                clearInterval(interval);
                processingFiles.delete(filePath);
            } else {
                console.log(`[STATUS] ID-ul videoului ${videoId}: ${status_text} (${status})`);
            }
        } catch (error) {
            console.error(`[ERROR] Nu s-a putut obține starea pentru ${videoId}:`, error.message);
            clearInterval(interval);
            processingFiles.delete(filePath);
        }
    }, 5000); // Verifică la fiecare 5 secunde
}

Acest script demonstrează o interacțiune server-server. Nevinovați niciodată să expuneți cheia dvs. secretă în codul client-side.

Pasul 3: Inițializarea Următoarei Fișiere

În final, adăugați logica chokidar la sfârșitul scriptului. Acesta va urmări directoriile și va declanșa funcțiile noastre atunci când se adaugă un nou fișier.

upload-watcher.js
// (Adăugați acest cod la sfârșitul fișierului)
 
function initializeWatcher() {
    console.log(`--- Snapencode Watch Folder Inițializat ---`);
    console.log(`Urmărește pentru noi fișiere în: ${path.resolve(WATCH_DIRECTORY)}`);
 
    if (!fs.existsSync(WATCH_DIRECTORY)) {
        console.log(`Crează directorul de urmărire...`);
        fs.mkdirSync(WATCH_DIRECTORY, { recursive: true });
    }
 
    const watcher = chokidar.watch(WATCH_DIRECTORY, {
        ignored: /(^|[\/\\])\../, // Ignora fișierele cu puncte
        persistent: true,
        ignoreInitial: true, // Nu încărcați fișierele care sunt deja acolo la pornire
    });
 
    watcher.on('add', (filePath) => {
        if (processingFiles.has(filePath)) {
            return; // Ignora dacă este deja în procesare
        }
 
        console.log(`[DETECTED] Nou fișier: ${path.basename(filePath)}`);
        // Așteptați o clipă pentru a asigura că fișierul este complet scris înainte de încărcare
        setTimeout(async () => {
            const videoId = await uploadVideo(filePath);
            await monitorStatus(videoId, filePath);
        }, 2000);
    });
}
 
initializeWatcher();

Pasul 4: Rularea Următoarei Fișiere

Cu fișierul upload-watcher.js complet, puteți rula-l din consola dvs.

# Sfaturi: setați cheia API ca o variabilă de mediu
export Snapencode_API_KEY="sk_your_api_key_here"
 
# Rulați scriptul
node upload-watcher.js

Acum, orice nou fișier video pe care îl lansați în directorul ./videos-to-upload va fi încărcat și procesat automat!