A self-hosted media server and file management system
Vue ffmpegfile-serverjellyfinlaravelmediamedia-playermedia-servermediabrowsermediaservermusicmusic-librarymusic-playermusicplayerself-hostedvuejs
import type { CategoryResource, FolderResource, MetadataResource, SeriesResource, VideoResource } from '@/types/resources';
import type { SortCriteria, SortKey } from '@/service/sort/types';
import { formatFileSize, toFormattedDuration } from '@/service/util';
import { resetUserDependantQueries } from '@/service/vue-query';
import { computed, ref, watch } from 'vue';
import { useRoute, useRouter } from 'vue-router';
import { CompareStrategies } from '@/service/sort/strategies';
import { sortObjectNew } from '@/service/sort/baseSort';
import { toParamNumber } from '@/util/route';
import { defineStore } from 'pinia';
import { MediaType } from '@/types/types';
import { toast } from '@aminnausin/cedar-ui';
import mediaAPI from '@/service/mediaAPI.ts';
// dir: {id: 1, name: 'anime', folders: ["id": "6", "name": "Frieren", "path": "anime/Frieren", "file_count": 28, "category_id": "1","series": null] } -> api/categories/1 -> folders dont hold video data
// folder: {id: 11, name: 'BOCCHI THE ROCK', videos: [id, name, pat, date, metadata], series: {}}
const emptyLibrary: CategoryResource = {
id: 0,
name: '',
folders: [],
folders_count: 0,
total_size: 0,
last_scan: -1,
downloads_enabled: false,
downloads_require_auth: false,
storyboard_enabled: false,
fonts_enabled: false,
};
const emptyFolder: FolderResource = {
id: 0,
name: '',
title: '',
path: '',
file_count: 0,
completion_count: 0,
total_size: 0,
is_majority_audio: false,
category_id: 0,
videos: [],
last_scan: -1,
};
const emptyMedia: VideoResource = {
id: 0,
name: '',
path: '',
view_count: 0,
progress_offset: 0,
progress_percentage: 0,
completion_count: 0,
video_tags: [],
subtitles: [],
created_at: '',
};
const DEFAULT_SORT = { column: 'name', dir: 1 };
export const useContentStore = defineStore('Content', () => {
const router = useRouter();
const route = useRoute();
// #region State data
const stateDirectory = ref<CategoryResource>(emptyLibrary);
const stateFolder = ref<FolderResource>(emptyFolder);
const stateVideo = ref<VideoResource>(emptyMedia);
const isStateFolderAudio = computed(() => stateFolder.value.is_majority_audio);
const isStateVideoAudio = computed(() => stateVideo.value.metadata?.media_type === MediaType.AUDIO);
const isLoadingContent = ref(false);
// Video search and sort and results
const videoSort = ref<SortCriteria<VideoResource>>({ column: 'title', dir: 1 });
const searchQuery = ref('');
const stateFilteredPlaylist = computed<VideoResource[]>(() => {
if (!stateFolder.value?.videos) return [];
// TODO: pre-generate this search string on load and on update per video instead of regenerating all videos on every change
const searchTerm = searchQuery.value.toLowerCase().trim();
const filteredResult = searchTerm
? stateFolder.value.videos.filter((video) => {
try {
const strRepresentation = [
video.name,
video.title,
video.description,
video.file_modified_at,
video.episode ?? '',
video.season ?? '',
video.view_count,
toFormattedDuration(video.duration) ?? 'N/A',
video.video_tags?.map((tag) => tag?.name).join(' ') ?? '',
video.file_size ? formatFileSize(video.file_size) : '',
video.metadata?.codec ?? '',
video.metadata?.album ?? '',
video.metadata?.artist ?? '',
video.metadata?.resolution_height ? `${video.metadata.resolution_height}p` : '',
];
return strRepresentation.join(' ').toLowerCase().includes(searchTerm);
} catch (error) {
console.error('Error filtering video:', video, error);
return false;
}
})
: stateFolder.value.videos;
let sortCriteria: SortKey<VideoResource>[] = [{ key: videoSort.value.column }];
if (videoSort.value.column === 'episode') {
sortCriteria = [{ compareFn: CompareStrategies.episode }];
}
if (['released_at', 'file_modified_at', 'progress_updated_at', 'progress_created_at', 'edited_at'].includes(videoSort.value.column)) {
sortCriteria[0].compareFn = CompareStrategies.date;
}
if (['edited_at'].includes(videoSort.value.column)) {
sortCriteria[0].nullsLast = true;
}
// old sorting function: return filteredResult.sort(sortObject(videoSort.value.column, videoSort.value.dir));
return [...filteredResult].sort(sortObjectNew(sortCriteria, videoSort.value.dir));
});
// Relative media tracking
const currentMediaIndex = computed(() => {
if (!stateFilteredPlaylist.value || !stateVideo.value) return -1;
return stateFilteredPlaylist.value.findIndex((video) => video.id === stateVideo.value?.id);
});
const nextVideoURL = computed(() => {
if (!stateDirectory.value.name || !stateFolder.value.name) return '';
if (currentMediaIndex.value === -1 || currentMediaIndex.value === stateFilteredPlaylist.value.length - 1) return '';
return encodeURI(`/${stateDirectory.value.name}/${stateFolder.value.name}?video=${stateFilteredPlaylist.value[currentMediaIndex.value + 1].id}`);
});
const previousVideoURL = computed(() => {
if (!stateDirectory.value.name || !stateFolder.value.name) return '';
if (currentMediaIndex.value <= 0) return '';
return encodeURI(`/${stateDirectory.value.name}/${stateFolder.value.name}?video=${stateFilteredPlaylist.value[currentMediaIndex.value - 1].id}`);
});
/**
* Select a video by ID or default to the first video.
* @param queryId - ID of the video from url query params or table
* @returns {boolean} if stateVideo was updated
*/
function playlistFind(queryId?: number): boolean {
let result: VideoResource | undefined;
// select based on the canonical list from the stateFolder rather than the user filtered playlist
if (Number.isFinite(queryId)) {
result = stateFolder.value.videos.find((media) => media.id === queryId);
} else {
// the default is the first video in the list
result = stateFilteredPlaylist.value.length > 0 ? stateFilteredPlaylist.value[0] : stateFolder.value.videos[0];
}
// Media matching query not found or no media in playlist in the first place
if (!result) {
// Reset state video on invalid selection
stateVideo.value = emptyMedia;
toast.add('Invalid File', {
type: 'danger',
description: stateFolder.value.videos?.length ? 'Selected file cannot be found...' : 'This folder has no files...',
});
return false;
}
// Queried media already loaded
if (stateVideo.value.id === result.id) {
return false;
}
// Load queried media
stateVideo.value = result;
return true;
}
/**
* needs to go in the computed property
* what is this ???
*/
function playlistSort(sort: SortCriteria<VideoResource>) {
videoSort.value = { ...videoSort.value, ...(sort ?? DEFAULT_SORT) };
}
// #endregion
//#region DATA FETCHING
/**
* Loads a category and optional folder by name and updates the current category and folder state
* @param URL_CATEGORY string url parameter describing category name or id
* @param URL_FOLDER optional string url parameter describing folder name or id
* @returns True if successful, false otherwise
*/
async function getCategory(URL_CATEGORY: string, URL_FOLDER?: string, play: boolean = true): Promise<boolean> {
try {
const { data: response } = await mediaAPI.getCategory(`${URL_CATEGORY}${URL_FOLDER ? '/' + URL_FOLDER : ''}`); // => {dir: {id,name,folderCount}, folder: {id,name,videos[],series}}
// statedir (list of folders) = dir => /api/categories/1
// statefolder (list of videos) = folder => /api/folders/8?videos=true
stateDirectory.value = response.data.dir;
stateFolder.value = response.data.folder; // Can be the specified folder (null if invalid folder / no folders) or the first folder if not specified
// This never happens because the api returns a 404 if the folder does not exist
if (!stateFolder.value.id) {
toast.add('Invalid folder', { type: 'danger', description: `The folder '${stateFolder.value.name}' does not exist.` });
return false;
}
// build based on folder title (from series) and category name
const correctCategory = stateDirectory.value.name;
const correctFolder = stateFolder.value.title ?? stateFolder.value.name;
// rebuilds url with exact values if url parameters were partial
if (route.params.category !== correctCategory || route.params.folder !== correctFolder) {
router.replace({
name: route.name,
params: {
...route.params,
category: correctCategory,
folder: correctFolder,
},
query: route.query,
});
}
searchQuery.value = '';
setDefaultSortKey();
if (play) playlistFind(toParamNumber(route.query.video));
return true;
} catch (error: any) {
const message = error?.response?.data?.message || error?.message || 'Unable to load data.';
toast.add('Error', {
type: 'danger',
description: message,
});
console.error('Failed to load category:', error);
clearState();
return false;
}
}
/**
* Loads a folder by name and updates the current folder state
* @param nextFolderName Name or title of the folder to load
* @param loadSelectedVideo Find the queried videoId from the folder's videos and select it
* @param forceReload Force re-fetch folder data even if it is cached
* @returns True if successful, false otherwise
*/
async function getFolder(nextFolderName: string, loadSelectedVideo: boolean = true, forceReload: boolean = true): Promise<boolean> {
const isCurrentFolder = stateFolder.value.name === nextFolderName || stateFolder.value.title === nextFolderName;
if (isCurrentFolder) {
if (loadSelectedVideo) playlistFind(toParamNumber(route.query.video));
return true;
}
const targetFolder = stateDirectory.value.folders?.find((folder) => folder.name === nextFolderName || folder.title === nextFolderName);
if (!targetFolder?.id) {
toast.add('Invalid folder', { type: 'danger', description: `The folder '${nextFolderName}' does not exist.` });
stateFolder.value = emptyFolder;
stateVideo.value = emptyMedia;
return false;
}
try {
searchQuery.value = '';
if (forceReload || !targetFolder.videos?.length) {
const { data: folder } = await mediaAPI.getFolder(targetFolder.id); // get videos with given folder id (list of videos organised by folder id)
stateFolder.value = { ...folder };
updateCachedFolder(folder);
} else {
stateFolder.value = { ...targetFolder };
}
setDefaultSortKey();
} catch (error: any) {
const message = error?.response?.data?.message || error?.message || 'Failed to load folder';
toast.add('Error loading folder', { type: 'danger', description: message });
console.error('Failed to load folder:', error);
return false;
}
if (loadSelectedVideo) playlistFind(toParamNumber(route.query.video));
return true;
}
function getMetadataById(metadataId: number): MetadataResource | undefined {
if (stateVideo.value.metadata?.id === metadataId) return stateVideo.value.metadata;
return stateFolder.value.videos?.find((v) => v.metadata?.id === metadataId)?.metadata;
}
function setDefaultSortKey() {
if ((videoSort.value.column === 'title' && stateFolder.value.is_majority_audio) || (videoSort.value.column === 'episode' && !stateFolder.value.is_majority_audio)) {
videoSort.value.column = stateFolder.value.is_majority_audio ? 'episode' : 'title';
}
}
//#endregion
//#region DATA UPDATES
/**
* Adds a view to a video (and metadata)
* @param id media id
*/
async function updateViewCount(id: number): Promise<void> {
try {
await mediaAPI.viewVideo(id);
// has default value of 0
stateVideo.value.view_count += 1;
} catch (error: any) {
const message = error?.message || 'Unknown error occurred';
console.log(message);
throw new Error(message);
}
}
/**
* Updates metadata for a video locally
* @param data partial video resource containing updated data
*/
function updateVideoData(data: Partial<VideoResource>) {
if (!data?.id) return;
if (data.id === stateVideo.value.id) stateVideo.value = { ...stateVideo.value, ...data };
const updatedVideos = (stateFolder.value.videos ?? []).map((video) => (video.id === data.id ? { ...video, ...data } : video));
stateFolder.value = {
...stateFolder.value,
videos: updatedVideos,
};
}
/**
* Updates series for a folder locally
* @param data partial series resource containing updated data
*/
function updateFolderData(data: SeriesResource) {
if (!data?.id) return;
if (data.folder_id === stateFolder.value.id) stateFolder.value = { ...stateFolder.value, series: { ...stateFolder.value.series, ...data } };
const updatedFolders = (stateDirectory.value.folders ?? []).map((folder) => (folder.id === data.folder_id ? { ...folder, series: { ...folder.series, ...data } } : folder));
stateDirectory.value = {
...stateDirectory.value,
folders: updatedFolders,
};
}
function updateCachedFolder(data: FolderResource) {
if (!data?.id) return;
const idx = stateDirectory.value.folders!.findIndex((f) => f.id === data.id);
if (idx !== -1) stateDirectory.value.folders![idx] = { ...data };
}
function clearState(onlyVideo = false) {
if (!onlyVideo) {
stateDirectory.value = emptyLibrary;
stateFolder.value = emptyFolder;
}
stateVideo.value = emptyMedia;
}
function clearUserContentState() {
resetUserDependantQueries();
stateFolder.value.videos.forEach((video) => {
video.progress_offset = 0;
video.progress_percentage = 0;
video.completion_count = 0;
});
}
function updatePlaybackProgress(id: number, data: { progress_offset: number; progress_percentage: number; completion_count: number }) {
if (Number.isNaN(id)) return;
const apply = (video: VideoResource) => {
const duration = video.duration ?? 0;
if (data.completion_count == video.completion_count + 1 && data.progress_percentage === 100) {
// TODO: trigger activity toast? This is a good point to save series watch activity. toast.add('Video Completed', { description: 'Save to Anilist?' });
}
video.progress_offset = Math.min(data.progress_offset, duration);
video.progress_percentage = data.progress_percentage;
video.completion_count = data.completion_count;
};
if (stateVideo.value.metadata?.id === id) {
apply(stateVideo.value);
return;
}
for (const video of stateFolder.value.videos ?? []) {
if (video.metadata?.id === id) {
apply(video);
return;
}
}
}
//#endregion
/**
* Watches the current route and clears app state when leaving the video player page.
*/
watch(route, (to) => {
if (to.name === 'home') return;
clearState(route.name === 'folder-details');
});
return {
stateDirectory,
stateFolder,
stateVideo,
isStateFolderAudio,
isStateVideoAudio,
searchQuery,
stateFilteredPlaylist,
videoSort,
nextVideoURL,
previousVideoURL,
currentMediaIndex,
isLoadingContent,
getCategory,
getFolder,
getMetadataById,
updateViewCount,
updateVideoData,
updateFolderData,
updatePlaybackProgress,
playlistFind,
playlistSort,
clearUserContentState,
};
});