Skip to content

A self-hosted media server and file management system

17.1 KB
Raw Blame
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,
    };
});