Skip to Content

Automatisera din videoflöde med hjälp av Snapencode-API:et

Lär dig hur du bygger en fullständigt automatiserad videoflödespipeline, från uppladdning till bearbetning och leverans, med hjälp av Snapencode klientfokuserade API och ett enkelt Node.js-skript.

av
TS
The Snapencode Team
•
Hero image for Automatisera din videoflöde med hjälp av Snapencode-API:et

I dagens innehållsdrivna värld kan manuell videouppladdning och bearbetning vara en betydande flaskhals, som fördröjer hela innehållspipelinen. Plattformen Snapencode har ett API-först design, vilket möjliggör att automatisera dessa upprepade uppgifter och återvinna värdefull tid.

I den här guiden kommer vi att bygga en praktisk “watch folder” skript som övervakar en mapp för nya videofiler, automatiskt laddar upp dem till Snapencode och bekräftar deras bearbetningsstatus.

Målet: En “Watch Folder”-Uploader

Vår målsättning är att skapa ett Node.js-skript som uppnår följande:

  1. Övervakar en specifik mapp på en lokal maskin eller server.
  2. När en ny videofil (.mp4, .mov osv.) läggs till, laddas den automatiskt upp till en angiven samling i Snapencode.
  3. Efter uppladdningen pollerar den bearbetningsstatusändpunkten tills videon är “slutad.”
  4. När den är slutförd loggar den videons ID och är redo för nästa fil.

Detta är ett perfekt lösning för flöden där innehåll genereras programmatiskt eller läggs till i en gemensam mapp av icke-tekniska teammedlemmar.

Förutsättningar

  • En Snapencode API-nyckel: Generera en från din dashboard under Inställningar > API-nycklar.
  • Node.js: Vi kommer att använda JavaScript och Node.js-körningen för vårt skript.
  • axios och chokidar: Två enkla paket för att göra API-anrop och övervaka filer.
npm install axios chokidar form-data

Byggande av Automatiseringsskript

Vi kommer att skapa ett enda, komplett skript. Låt oss kalla det upload-watcher.js.

Steg 1: Konfigurera Skriptet

Först ska vi ställa upp konfigurationsvariabler och importera nödvändiga bibliotek på toppen av vårt upload-watcher.js-fil.

upload-watcher.js
const axios = require('axios');
const FormData = require('form-data');
const fs = require('fs');
const path = require('path');
const chokidar = require('chokidar');
 
// --- Konfiguration ---
const API_BASE_URL = 'https://din-Snapencode-domän.com/api/client/v1';
const API_KEY = process.env.Snapencode_API_KEY || 'sk_din_api_nyckel_här'; // Bästa praxis: Använd miljövariabler
const TARGET_FOLDER = 'rot/automatiserade-uploader'; // Samlingsvägen i Snapencode
const WATCH_DIRECTORY = './videos-to-upload';
 
// En sätt för att hålla reda på filer som för närvarande bearbetas för att undvika dubbeluppladdningar
const processingFiles = new Set();

Användning av miljövariabler (process.env.Snapencode_API_KEY) för din API-nyckel är mycket säkrare än att direkt koda den i skriptet.

Steg 2: Skapa de Huvudsakliga Funktionerna

Nästa ska vi lägga till de två huvudsakliga funktionerna: en för hantering av filuppladdningen och en annan för övervakning av bearbetningsstatus.

upload-watcher.js
// (Lägg till detta kodblock under konfigurationsavsnittet)
 
async function uploadVideo(filePath) {
console.log(`[UPPLADDNING] Starta uppladdning för: ${path.basename(filePath)}`);
processingFiles.add(filePath); // Markera filen som bearbetas
 
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, {
huvud: { ...form.getHeaders(), 'Authorization': `Bearer ${API_KEY}` },
});
console.log(`[LYCKATS] Uppladdning accepterad! Videoid: ${response.data.data.id}`);
return response.data.data.id;
} catch (error) {
console.error(`[MISSLYCKATS] Uppladdning misslyckades för ${path.basename(filePath)}:`, error.response?.data?.message || error.message);
return null;
}
}
 
async function monitorStatus(videoId, filePath) {
if (!videoId) {
processingFiles.delete(filePath); // Ta bort från bearbetningsuppsättningen vid misslyckande
return;
}
 
console.log(`[ÖVERVAKA] Övervaka status för Videoid: ${videoId}`);
const interval = setInterval(async () => {
try {
const response = await axios.get(`${API_BASE_URL}/uploads/${videoId}`, {
huvud: { 'Authorization': `Bearer ${API_KEY}` },
});
const { status, status_text } = response.data.data;
 
if (status === 6) { // Slutförd
console.log(`✅ [SLUT] Bearbetning slutförd för Videoid: ${videoId}!`);
clearInterval(interval);
processingFiles.delete(filePath); // Ta bort från uppsättningen vid framgång
} else if (status === 7) { // Misslyckad
console.error(`❌ [MISSLYCKATS] Bearbetning misslyckades för Videoid: ${videoId}.`);
clearInterval(interval);
processingFiles.delete(filePath);
} else {
console.log(`[STATUS] Videoid ${videoId}: ${status_text} (${status})`);
}
} catch (error) {
console.error(`[FEJL] Kunde inte hämta status för ${videoId}:`, error.message);
clearInterval(interval);
processingFiles.delete(filePath);
}
}, 5000); // Kontrollera varje 5 sekunder
}

Detta skript demonstrerar en server-till-server interaktion. Nevär exponera din hemliga API-nyckel i klient-sidig webbläsarkod.

Steg 3: Initiera Filövervakaren

Slutligen ska vi lägga till chokidar logiken på slutet av skriptet. Detta kommer att övervaka mappen och utlösa våra funktioner när en ny fil läggs till.

upload-watcher.js
// (Lägg till detta kodblock på slutet av filen)
 
function initializeWatcher() {
console.log(`--- Snapencode Watch Folder Initierad ---`);
console.log(`Övervaka nya videofiler i: ${path.resolve(WATCH_DIRECTORY)}`);
 
if (!fs.existsSync(WATCH_DIRECTORY)) {
console.log(`Skapa övervakningsmapp...`);
fs.mkdirSync(WATCH_DIRECTORY, { rekursiv: true });
}
 
const watcher = chokidar.watch(WATCH_DIRECTORY, {
ignorerade: /(^|[\/\\])\../, // Ignorera dotfiler
persistent: true,
ignoreInitial: true, // Undvik att ladda upp filer som redan finns på start
});
 
watcher.on('add', (filePath) => {
if (processingFiles.has(filePath)) {
return; // Skippa om redan bearbetas
}
console.log(`[DETEKT] Ny fil: ${path.basename(filePath)}`);
// Vänta en stund för att säkerställa att filen är fullständigt skriven innan uppladdning
setTimeout(async () => {
const videoId = await uploadVideo(filePath);
await monitorStatus(videoId, filePath);
}, 2000);
});
}
 
initializeWatcher();

Steg 4: Kör Din Övervakare

Med upload-watcher.js-filen komplett kan du köra den från din terminal.

# Bästa praxis: Sätt API-nyckeln som en miljövariabel
export Snapencode_API_KEY="sk_din_api_nyckel_här"
 
# Kör skriptet
node upload-watcher.js

Nu kommer någon ny videofil du lägger till i ./videos-to-upload-mappen att automatiskt laddas upp och bearbetas!