Skip to content

A self-hosted media server and file management system

feat: migrate to contentstore.ts for video view

aminnausinc21dd238fe79
diff --git a/app/Http/Resources/VideoResource.php b/app/Http/Resources/VideoResource.php
index 9f4d068a..d675b208 100755
--- a/app/Http/Resources/VideoResource.php
+++ b/app/Http/Resources/VideoResource.php
@@ -19,7 +19,7 @@ class VideoResource extends JsonResource {
$metadata = $this->metadata;
return [
- 'id' => (string) $this->id,
+ 'id' => $this->id,
'name' => $this->name,
'path' => $this->path,
'date' => $this->date,
diff --git a/resources/js/service/sort/baseSort.ts b/resources/js/service/sort/baseSort.ts
index 1db89d73..f7948f28 100644
--- a/resources/js/service/sort/baseSort.ts
+++ b/resources/js/service/sort/baseSort.ts
@@ -1,4 +1,4 @@
-import type { SortDir } from '@/types/types';
+import type { SortDir, SortKey } from '@/service/sort/types';
import { CompareStrategies } from '@/service/sort/strategies';
@@ -23,11 +23,6 @@ export function sortObject<T>(column: keyof T, direction: SortDir = 1, dateColum
};
}
-export interface SortKey<T> {
- key?: keyof T;
- compareFn?: (a: T, b: T) => number;
-}
-
export function sortObjectNew<T>(keys: SortKey<T>[], direction: SortDir = 1) {
return (a: T, b: T): number => {
// Loops through keys and returns the first non 0 sort result (so same episode number will be skipped and move on to comparing seasons)
diff --git a/resources/js/service/sort/types.ts b/resources/js/service/sort/types.ts
new file mode 100644
index 00000000..cee0b926
--- /dev/null
+++ b/resources/js/service/sort/types.ts
@@ -0,0 +1,11 @@
+export declare type SortDir = 1 | -1;
+
+export interface SortKey<T> {
+ key?: keyof T;
+ compareFn?: (a: T, b: T) => number;
+}
+
+export interface SortCriteria<T> {
+ column: keyof T;
+ dir: SortDir;
+}
diff --git a/resources/js/stores/ContentStore.ts b/resources/js/stores/ContentStore.ts
new file mode 100644
index 00000000..89ddb05c
--- /dev/null
+++ b/resources/js/stores/ContentStore.ts
@@ -0,0 +1,320 @@
+import type { CategoryResource, FolderResource, SeriesResource, VideoResource } from '@/types/resources';
+import type { SortCriteria, SortDir, SortKey } from '@/service/sort/types';
+
+import { formatFileSize, toFormattedDuration } from '@/service/util';
+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 { toast } from '@/service/toaster/toastService';
+
+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: -1, name: '', folders: [], folders_count: 0, total_size: 0, last_scan: -1 };
+const emptyFolder: FolderResource = { id: -1, name: '', title: '', path: '', file_count: 0, total_size: 0, is_majority_audio: false, category_id: -1, videos: [], last_scan: -1 };
+const emptyMedia: VideoResource = { id: -1, name: '', path: '', view_count: 0, video_tags: [], date: '', date_created: '' };
+
+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);
+
+ // 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 [];
+
+ const searchTerm = searchQuery.value.toLowerCase().trim();
+ const filteredResult = searchTerm
+ ? stateFolder.value.videos.filter((video) => {
+ try {
+ const strRepresentation = [
+ video.name,
+ video.title,
+ video.description,
+ video.date_uploaded,
+ 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) : '',
+ ];
+ 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 (['date', 'date_released', 'date_uploaded'].includes(videoSort.value.column)) {
+ sortCriteria[0].compareFn = CompareStrategies.date;
+ }
+
+ // 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 nextVideoURL = computed(() => {
+ if (!stateFilteredPlaylist.value || !stateDirectory.value.name || !stateFolder.value.name || !stateVideo.value) return '';
+
+ const currentIndex = stateFilteredPlaylist.value.findIndex((video) => video.id === stateVideo.value?.id);
+
+ if (currentIndex === -1 || currentIndex === stateFilteredPlaylist.value.length - 1) return '';
+
+ return encodeURI(`/${stateDirectory.value.name}/${stateFolder.value.name}?video=${stateFilteredPlaylist.value[currentIndex + 1].id}`);
+ });
+
+ const previousVideoURL = computed(() => {
+ if (!stateFilteredPlaylist.value || !stateDirectory.value.name || !stateFolder.value.name || !stateVideo.value) return '';
+
+ const currentIndex = stateFilteredPlaylist.value.findIndex((video) => video.id === stateVideo.value?.id);
+
+ if (currentIndex <= 0) return '';
+
+ return encodeURI(`/${stateDirectory.value.name}/${stateFolder.value.name}?video=${stateFilteredPlaylist.value[currentIndex - 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;
+
+ if (Number.isFinite(queryId)) {
+ result = stateFilteredPlaylist.value.find((media) => media.id === queryId);
+ } else {
+ // the default is the first video in the list
+ result = stateFilteredPlaylist.value[0];
+ }
+
+ // Media matching query not found or no media in playlist in the first place
+ if (!result) {
+ toast.add('Invalid Video', { type: 'danger', description: 'Selected video cannot be found...' });
+ 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> = { column: 'name', dir: 1 }) {
+ videoSort.value = { ...videoSort.value, ...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): 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
+
+ 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;
+
+ // 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: {
+ category: correctCategory,
+ folder: correctFolder,
+ },
+ query: route.query,
+ });
+ }
+
+ searchQuery.value = '';
+ 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);
+ return false;
+ }
+ }
+
+ /**
+ * Loads a folder by name and updates the current folder state
+ * @param nextFolderName Name or title of the folder to load
+ * @returns True if successful, false otherwise
+ */
+ async function getFolder(nextFolderName: string): Promise<boolean> {
+ if (stateFolder.value.name === nextFolderName) {
+ return true;
+ }
+
+ const nextFolder = stateDirectory.value.folders?.find((folder) => {
+ return folder.name === nextFolderName || folder.title === nextFolderName;
+ });
+
+ if (!nextFolder?.id) {
+ toast.add('Invalid folder', { type: 'danger', description: `The folder '${nextFolderName}' does not exist.` });
+ return false;
+ }
+
+ try {
+ const { data } = await mediaAPI.getFolder(nextFolder.id); // get videos with given folder id (list of videos organised by folder id)
+
+ stateFolder.value = { ...data.data };
+ searchQuery.value = '';
+ playlistFind(toParamNumber(route.query.video));
+
+ return true;
+ } 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;
+ }
+ }
+ //#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) 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) return;
+
+ if (data.folder_id === stateFolder.value.id) stateFolder.value = { ...stateFolder.value, series: { ...data } };
+
+ const updatedFolders = (stateDirectory.value.folders ?? []).map((folder) => (folder.id === data.folder_id ? { ...folder, series: { ...data } } : folder));
+
+ stateDirectory.value = {
+ ...stateDirectory.value,
+ folders: updatedFolders,
+ };
+ }
+
+ //#endregion
+
+ /**
+ * Watches the current route and clears app state when leaving the video player page.
+ */
+ watch(route, (to) => {
+ const clearState = () => {
+ stateDirectory.value = emptyLibrary;
+ stateFolder.value = emptyFolder;
+ stateVideo.value = emptyMedia;
+ };
+
+ if (to.name !== 'home') {
+ clearState();
+ }
+ });
+
+ return {
+ stateDirectory,
+ stateFolder,
+ stateVideo,
+ searchQuery,
+ stateFilteredPlaylist,
+ videoSort,
+ nextVideoURL,
+ previousVideoURL,
+ getCategory,
+ getFolder,
+ updateViewCount,
+ updateVideoData,
+ updateFolderData,
+ playlistFind,
+ playlistSort,
+ };
+});
diff --git a/resources/js/util/route.ts b/resources/js/util/route.ts
new file mode 100644
index 00000000..b82b27c6
--- /dev/null
+++ b/resources/js/util/route.ts
@@ -0,0 +1,13 @@
+import type { LocationQueryValue } from 'vue-router';
+
+export function toParamString(param: LocationQueryValue | LocationQueryValue[] | undefined): string | undefined {
+ if (param == null) return undefined;
+ return Array.isArray(param) ? (param[0] ?? undefined) : param;
+}
+
+export function toParamNumber(param: LocationQueryValue | LocationQueryValue[] | undefined): number | undefined {
+ const asString = toParamString(param);
+ if (!asString) return undefined;
+ const n = Number(asString);
+ return Number.isFinite(n) ? n : undefined;
+}
diff --git a/resources/js/views/VideoView.vue b/resources/js/views/VideoView.vue
index f8122dff..3c9dd0bd 100755
--- a/resources/js/views/VideoView.vue
+++ b/resources/js/views/VideoView.vue
@@ -1,11 +1,13 @@
<script setup lang="ts">
import type { CategoryResource, FolderResource, VideoResource } from '@/types/resources';
+import type { SortDir } from '@/service/sort/types';
import type { Ref } from 'vue';
import { computed, nextTick, onMounted, ref, watch } from 'vue';
import { useRecordsLimited } from '@/service/records/useRecords';
import { useContentStore } from '@/stores/ContentStore';
import { toFormattedDate } from '@/service/util';
+import { toParamNumber } from '@/util/route';
import { useAppStore } from '@/stores/AppStore';
import { storeToRefs } from 'pinia';
import { useRoute } from 'vue-router';
@@ -37,6 +39,7 @@ const { searchQuery, stateFilteredPlaylist, stateDirectory, stateVideo, stateFol
const editVideoModal = useModal({ title: 'Edit Video Details', submitText: 'Submit Details' });
const shareVideoModal = useModal({ title: 'Share Video' });
+const queryVideoId = computed(() => toParamNumber(route.query.video));
const cachedVideo = ref<VideoResource>();
const cachedVideoUrl = computed(() => {
if (!cachedVideo.value) return '';
@@ -62,14 +65,15 @@ async function reload() {
if (isLoading.value) return;
try {
- const URL_CATEGORY = route.params.category;
- const URL_FOLDER = route.params.folder;
+ const toSingleParam = (p: string | string[]) => (Array.isArray(p) ? p[0] : p);
+
+ const URL_CATEGORY = toSingleParam(route.params.category);
+ const URL_FOLDER = toSingleParam(route.params.folder);
isLoading.value = true;
await nextTick();
document.body.scrollTo({ top: 0, behavior: 'instant' });
-
if (stateDirectory.value?.name && stateDirectory.value.name === URL_CATEGORY && URL_FOLDER) {
await getFolder(URL_FOLDER);
} else {
@@ -129,7 +133,7 @@ const sortingOptions = computed(() => {
];
});
-const handleSort = (column = 'date', dir = 1) => {
+const handleSort = (column: keyof VideoResource = 'date', dir: SortDir = 1) => {
playlistSort({ column, dir });
};
@@ -169,9 +173,12 @@ onMounted(async () => {
});
watch(
- () => route.query.video,
- (newVideo) => {
- if (stateFolder.value.name !== route.params.folder || !playlistFind(newVideo)) return;
+ queryVideoId,
+ (id) => {
+ if (id == null || stateFolder.value.name !== route.params.folder) return;
+
+ if (!playlistFind(id)) return;
+
setVideoAsDocumentTitle();
},
{ immediate: false },
@@ -201,7 +208,6 @@ watch(() => stateVideo.value, setVideoAsDocumentTitle, { immediate: true });
<TableBase
:data="stateFilteredPlaylist"
:row="VideoCard"
- :clickAction="playlistFind"
:otherAction="handleVideoAction"
:loading="isLoading"
:useToolbar="true"