364 lines
12 KiB
TypeScript
364 lines
12 KiB
TypeScript
export interface XBVRConfig {
|
|
url: string;
|
|
apiKey?: string;
|
|
}
|
|
|
|
export interface ImportProgress {
|
|
current: number;
|
|
total: number;
|
|
stage: 'idle' | 'fetching' | 'importing' | 'complete' | 'error';
|
|
message: string;
|
|
videosImported: number;
|
|
actorsImported: number;
|
|
errors: string[];
|
|
}
|
|
|
|
export interface XBVRVideo {
|
|
title: string;
|
|
videoLength: number;
|
|
thumbnailUrl: string;
|
|
video_url: string;
|
|
}
|
|
|
|
export interface XBVRVideoDetail {
|
|
id: number;
|
|
title: string;
|
|
description: string;
|
|
date: number;
|
|
thumbnailUrl: string;
|
|
rating_avg: number;
|
|
screenType: string;
|
|
stereoMode: string;
|
|
videoLength: number;
|
|
paysite?: {
|
|
name: string;
|
|
};
|
|
actors: Array<{
|
|
id: number;
|
|
name: string;
|
|
}>;
|
|
categories: Array<{
|
|
tag: {
|
|
name: string;
|
|
};
|
|
}>;
|
|
}
|
|
|
|
export interface XBVRSceneList {
|
|
scenes: Array<{
|
|
name: string;
|
|
list: XBVRVideo[];
|
|
}>;
|
|
}
|
|
|
|
export type LogCallback = (message: string) => void;
|
|
export type ProgressCallback = (progress: Partial<ImportProgress>) => void;
|
|
|
|
export async function importFromXBVR(
|
|
config: XBVRConfig,
|
|
logCallback: LogCallback,
|
|
progressCallback: ProgressCallback
|
|
): Promise<ImportProgress> {
|
|
const progress: ImportProgress = {
|
|
current: 0,
|
|
total: 0,
|
|
stage: 'fetching',
|
|
message: 'Connecting to DeoVR API...',
|
|
videosImported: 0,
|
|
actorsImported: 0,
|
|
errors: []
|
|
};
|
|
|
|
try {
|
|
logCallback('Starting DeoVR import...');
|
|
|
|
// Step 0: Fetch existing media and cast to check for duplicates
|
|
logCallback('Fetching existing media from Kyoo API...');
|
|
const existingMediaResponse = await fetch('http://192.168.1.102:6400/api/media?limit=1000');
|
|
const existingMediaData = await existingMediaResponse.json();
|
|
const existingTitles = new Set(
|
|
existingMediaData.data?.items?.map((m: any) => m.title) || []
|
|
);
|
|
logCallback(`Found ${existingTitles.size} existing videos in database`);
|
|
|
|
logCallback('Fetching existing cast from Kyoo API...');
|
|
const existingCastResponse = await fetch('http://192.168.1.102:6400/api/cast?limit=1000');
|
|
const existingCastData = await existingCastResponse.json();
|
|
const existingActors = new Map(
|
|
(existingCastData.data?.items || []).map((c: any) => [c.name, c])
|
|
);
|
|
logCallback(`Found ${existingActors.size} existing actors in database`);
|
|
|
|
// Step 1: Fetch scene list from DeoVR API
|
|
logCallback(`Fetching scene list from ${config.url}/deovr...`);
|
|
progressCallback({ message: 'Fetching scene list from DeoVR...' });
|
|
|
|
const scenesListResponse = await fetch(`${config.url}/deovr`);
|
|
if (!scenesListResponse.ok) {
|
|
throw new Error(`Failed to connect to DeoVR API: ${scenesListResponse.statusText}`);
|
|
}
|
|
|
|
const scenesListData: XBVRSceneList = await scenesListResponse.json();
|
|
logCallback('Received scene list structure');
|
|
|
|
// Extract only videos from the 'Recent' scene group
|
|
const allVideos: XBVRVideo[] = [];
|
|
if (scenesListData.scenes && Array.isArray(scenesListData.scenes)) {
|
|
const recentGroup = scenesListData.scenes.find((group) => group.name === 'Recent');
|
|
if (recentGroup && recentGroup.list && Array.isArray(recentGroup.list)) {
|
|
allVideos.push(...recentGroup.list);
|
|
}
|
|
}
|
|
|
|
logCallback(`Found ${allVideos.length} videos in 'Recent' scene group`);
|
|
|
|
// Step 2: Fetch details for each video
|
|
progressCallback({
|
|
total: allVideos.length,
|
|
stage: 'importing',
|
|
message: 'Fetching video details...'
|
|
});
|
|
|
|
const videoDetails: XBVRVideoDetail[] = [];
|
|
const actorSet = new Map<number, any>();
|
|
|
|
for (let i = 0; i < allVideos.length; i++) {
|
|
const video = allVideos[i];
|
|
try {
|
|
logCallback(`Fetching details for video: ${video.title} (${i + 1}/${allVideos.length})`);
|
|
|
|
const detailResponse = await fetch(video.video_url);
|
|
if (!detailResponse.ok) {
|
|
throw new Error(`Failed to fetch details: ${detailResponse.statusText}`);
|
|
}
|
|
|
|
const detailData: XBVRVideoDetail = await detailResponse.json();
|
|
videoDetails.push(detailData);
|
|
|
|
// Extract actors from video details
|
|
if (detailData.actors && Array.isArray(detailData.actors)) {
|
|
detailData.actors.forEach((actor) => {
|
|
// Skip actors containing 'aka:' anywhere in the name
|
|
if (actor.name.toLowerCase().includes('aka:')) {
|
|
return;
|
|
}
|
|
// Deduplicate by actor ID
|
|
if (!actorSet.has(actor.id)) {
|
|
actorSet.set(actor.id, actor);
|
|
}
|
|
});
|
|
}
|
|
|
|
logCallback(`✓ Fetched details for: ${video.title}`);
|
|
} catch (error) {
|
|
const errorMessage = error instanceof Error ? error.message : 'Unknown error';
|
|
logCallback(`✗ Failed to fetch details for ${video.title}: ${errorMessage}`);
|
|
progress.errors.push(`Failed to fetch details for ${video.title}: ${errorMessage}`);
|
|
progressCallback({ errors: progress.errors });
|
|
}
|
|
|
|
progressCallback({
|
|
current: i + 1,
|
|
message: `Fetching video details... ${Math.round(((i + 1) / allVideos.length) * 100)}%`
|
|
});
|
|
}
|
|
|
|
const uniqueActors = Array.from(actorSet.values());
|
|
logCallback(`Found ${uniqueActors.length} unique actors across all videos`);
|
|
|
|
// Step 3: Import actors first
|
|
progressCallback({
|
|
total: uniqueActors.length + videoDetails.length,
|
|
current: 0,
|
|
message: 'Importing actors...'
|
|
});
|
|
|
|
let actorsImported = 0;
|
|
const actorErrors: string[] = [];
|
|
|
|
for (let i = 0; i < uniqueActors.length; i++) {
|
|
const actor = uniqueActors[i];
|
|
|
|
// Skip actors containing 'aka:' anywhere in the name
|
|
if (actor.name.toLowerCase().includes('aka:')) {
|
|
logCallback(`⊘ Skipped 'aka:' actor: ${actor.name}`);
|
|
progressCallback({ current: i + 1 });
|
|
continue;
|
|
}
|
|
|
|
const existingActor = existingActors.get(actor.name);
|
|
|
|
try {
|
|
if (existingActor) {
|
|
// Update existing actor - XBVR doesn't have photos, so just ensure it exists
|
|
logCallback(`⊘ Actor already exists: ${actor.name}`);
|
|
} else {
|
|
// Create new actor
|
|
const response = await fetch('http://192.168.1.102:6400/api/cast', {
|
|
method: 'POST',
|
|
headers: { 'Content-Type': 'application/json' },
|
|
body: JSON.stringify({
|
|
name: actor.name,
|
|
photo: null,
|
|
bio: null,
|
|
birthDate: null,
|
|
birthPlace: null,
|
|
occupations: ['Actor']
|
|
})
|
|
});
|
|
|
|
if (response.ok) {
|
|
actorsImported++;
|
|
logCallback(`✓ Imported actor: ${actor.name}`);
|
|
} else {
|
|
const error = await response.text();
|
|
actorErrors.push(`Failed to import actor ${actor.name}: ${error}`);
|
|
logCallback(`✗ Failed to import actor: ${actor.name}`);
|
|
}
|
|
}
|
|
} catch (error) {
|
|
actorErrors.push(`Error importing actor ${actor.name}: ${error}`);
|
|
logCallback(`✗ Error importing actor: ${actor.name}`);
|
|
}
|
|
|
|
progressCallback({
|
|
current: i + 1,
|
|
actorsImported,
|
|
errors: actorErrors
|
|
});
|
|
}
|
|
|
|
logCallback(`Imported ${actorsImported}/${uniqueActors.length} actors`);
|
|
|
|
// Step 4: Import videos
|
|
progressCallback({
|
|
current: uniqueActors.length,
|
|
message: 'Importing videos...'
|
|
});
|
|
|
|
let videosImported = 0;
|
|
const videoErrors: string[] = [];
|
|
|
|
for (let i = 0; i < videoDetails.length; i++) {
|
|
const video = videoDetails[i];
|
|
|
|
// Skip videos starting with 'aka:'
|
|
if (video.title.toLowerCase().startsWith('aka:')) {
|
|
logCallback(`⊘ Skipped 'aka:' video: ${video.title}`);
|
|
progressCallback({
|
|
current: uniqueActors.length + i + 1
|
|
});
|
|
continue;
|
|
}
|
|
|
|
// Check for duplicate
|
|
if (existingTitles.has(video.title)) {
|
|
logCallback(`⊘ Skipped duplicate: ${video.title}`);
|
|
progressCallback({
|
|
current: uniqueActors.length + i + 1
|
|
});
|
|
continue;
|
|
}
|
|
|
|
try {
|
|
// Extract categories/tags
|
|
const categories = video.categories && Array.isArray(video.categories)
|
|
? video.categories.map((c) => c.tag?.name).filter(Boolean)
|
|
: [];
|
|
|
|
// Extract actors
|
|
const staff = video.actors && Array.isArray(video.actors)
|
|
? video.actors.map((a) => ({
|
|
name: a.name,
|
|
role: 'Actor',
|
|
photo: null,
|
|
characterName: a.name,
|
|
characterImage: null
|
|
}))
|
|
: [];
|
|
|
|
// Convert Unix timestamp to date
|
|
const releaseDate = video.date ? new Date(video.date * 1000).toISOString().split('T')[0] : null;
|
|
const year = video.date ? new Date(video.date * 1000).getFullYear() : new Date().getFullYear();
|
|
|
|
// Determine aspect ratio based on DeoVR screenType and stereoMode
|
|
let aspectRatio: '2/3' | '16/9' | '1/1' = '16/9';
|
|
if (video.screenType === '360' || video.screenType === '360180') {
|
|
aspectRatio = '1/1'; // VR360 videos are typically square for SBS
|
|
} else if (video.screenType === '180' || video.screenType === 'dome') {
|
|
aspectRatio = '16/9'; // VR180 videos are typically 16:9 for SBS
|
|
} else if (video.stereoMode === 'tb' && (video.screenType === '360' || video.screenType === '180')) {
|
|
aspectRatio = '1/1'; // Top-bottom format is taller
|
|
}
|
|
|
|
const mediaData = {
|
|
title: video.title,
|
|
year: year,
|
|
poster: video.thumbnailUrl || null,
|
|
banner: null,
|
|
description: video.description || null,
|
|
rating: video.rating_avg || null,
|
|
category: 'Adult',
|
|
type: 'Movie',
|
|
status: 'completed',
|
|
aspectRatio: aspectRatio,
|
|
runtime: video.videoLength || null,
|
|
director: null,
|
|
writer: null,
|
|
releaseDate: releaseDate,
|
|
genres: categories,
|
|
tags: categories,
|
|
studios: video.paysite?.name ? [video.paysite.name] : [],
|
|
staff: staff
|
|
};
|
|
|
|
const response = await fetch('http://192.168.1.102:6400/api/media', {
|
|
method: 'POST',
|
|
headers: { 'Content-Type': 'application/json' },
|
|
body: JSON.stringify(mediaData)
|
|
});
|
|
|
|
if (response.ok) {
|
|
videosImported++;
|
|
logCallback(`✓ Imported video: ${video.title}`);
|
|
} else {
|
|
const error = await response.text();
|
|
videoErrors.push(`Failed to import video ${video.title}: ${error}`);
|
|
logCallback(`✗ Failed to import video: ${video.title}`);
|
|
}
|
|
} catch (error) {
|
|
videoErrors.push(`Error importing video ${video.title}: ${error}`);
|
|
logCallback(`✗ Error importing video: ${video.title}`);
|
|
}
|
|
|
|
progressCallback({
|
|
current: uniqueActors.length + i + 1,
|
|
videosImported,
|
|
errors: [...actorErrors, ...videoErrors]
|
|
});
|
|
}
|
|
|
|
logCallback(`Imported ${videosImported}/${videoDetails.length} videos`);
|
|
|
|
// Complete
|
|
progress.stage = 'complete';
|
|
progress.message = 'Import complete!';
|
|
progress.current = uniqueActors.length + videoDetails.length;
|
|
progress.total = uniqueActors.length + videoDetails.length;
|
|
progress.videosImported = videosImported;
|
|
progress.actorsImported = actorsImported;
|
|
progress.errors = [...actorErrors, ...videoErrors];
|
|
logCallback('Import completed successfully!');
|
|
|
|
return progress;
|
|
|
|
} catch (error) {
|
|
const errorMessage = error instanceof Error ? error.message : 'Unknown error';
|
|
progress.stage = 'error';
|
|
progress.message = `Import failed: ${errorMessage}`;
|
|
progress.errors = [...progress.errors, errorMessage];
|
|
logCallback(`✗ Import failed: ${errorMessage}`);
|
|
return progress;
|
|
}
|
|
}
|