ffplayout/frontend/pages/media.vue

697 lines
28 KiB
Vue
Raw Normal View History

2020-01-30 15:25:10 -05:00
<template>
2024-04-16 12:13:28 -04:00
<div>
<div class="h-[calc(100vh-140px)] px-2">
<nav class="text-sm breadcrumbs px-3">
<ul @dragover.prevent>
<li
v-for="(crumb, index) in mediaStore.crumbs"
:key="index"
@drop="handleDrop($event, crumb.path, null)"
@dragover="handleDragOver"
@dragleave="handleDragLeave"
2024-04-08 11:07:03 -04:00
>
2024-04-16 12:13:28 -04:00
<button
v-if="mediaStore.crumbs.length > 1 && mediaStore.crumbs.length - 1 > index"
@click="mediaStore.getTree(crumb.path)"
2024-04-07 17:27:52 -04:00
>
2024-04-16 12:13:28 -04:00
<i class="bi-folder-fill me-1" />
{{ crumb.text }}
</button>
<span v-else><i class="bi-folder-fill me-1" /> {{ crumb.text }}</span>
</li>
</ul>
</nav>
2024-04-07 09:45:26 -04:00
2024-04-16 12:13:28 -04:00
<div class="relative h-[calc(100%-34px)] min-h-[300px] bg-base-100">
<div v-if="mediaStore.isLoading" class="w-full h-full absolute z-10 flex justify-center bg-base-100/70">
<span class="loading loading-spinner loading-lg" />
</div>
<splitpanes :horizontal="horizontal" class="h-full border border-my-gray rounded shadow">
2024-04-16 12:13:28 -04:00
<pane
min-size="14"
max-size="80"
size="20"
class="h-full bg-base-300"
2024-04-16 12:13:28 -04:00
:class="horizontal ? 'rounded-t' : 'rounded-s'"
>
<div class="relative h-full overflow-y-auto">
<table
v-if="mediaStore.folderTree.parent"
class="table table-zebra table-fixed"
@dragover.prevent
>
<tbody>
<template v-if="mediaStore.folderTree.parent_folders.length > 0">
<tr
v-for="folder in mediaStore.folderTree.parent_folders"
:key="folder.uid"
class="grid grid-cols-[auto_30px] border-b border-base-content/20"
:class="
filename(mediaStore.folderTree.source) === folder.name &&
'!bg-secondary text-black'
"
@drop="handleDrop($event, folder, true)"
@dragover="handleDragOver"
@dragleave="handleDragLeave"
>
<td class="px-2 py-1.5 truncate">
<a
class="cursor-pointer"
@click="
mediaStore.getTree(
`/${parent(mediaStore.folderTree.source)}/${folder.name}`
)
"
>
<i class="bi-folder-fill" />
{{ folder.name }}
</a>
</td>
2024-04-07 09:45:26 -04:00
<td class="px-2 py-1.5 text-center">
<button
class="opacity-30 hover:opacity-100"
@click="
;(showDeleteModal = true),
(deleteName = `/${parent(mediaStore.folderTree.source)}/${
folder.name
}`.replace(/\/[/]+/g, '/'))
"
>
<i class="bi-x-circle-fill" />
</button>
</td>
</tr>
</template>
<tr v-else>
<td class="px-2 py-1.5 border-b border-base-content/20">
<i class="bi-folder-fill" />
{{ mediaStore.folderTree.parent }}
</td>
</tr>
</tbody>
</table>
</div>
2024-04-16 12:13:28 -04:00
</pane>
<pane class="h-full !bg-base-300" :class="horizontal ? 'rounded-b' : 'rounded-e'">
<div class="relative h-full overflow-y-auto">
<table
v-if="mediaStore.folderTree.parent"
class="table table-zebra table-fixed"
@dragover.prevent
2024-04-16 12:13:28 -04:00
>
<tbody>
<tr
v-for="folder in mediaStore.folderTree.folders"
:key="folder.uid"
class="grid grid-cols-[auto_40px] border-b border-base-content/20"
@drop="handleDrop($event, folder, false)"
@dragover="handleDragOver"
@dragleave="handleDragLeave"
2024-04-16 12:13:28 -04:00
>
<td class="px-2 py-1.5 truncate cursor-pointer">
<a
class="truncate"
@click="
mediaStore.getTree(
`/${mediaStore.folderTree.source}/${folder.name}`
2024-04-16 12:13:28 -04:00
)
"
>
<i class="bi-folder-fill" />
{{ folder.name }}
</a>
</td>
<td class="ps-2 pe-[14px] py-1.5 text-right">
<button
class="opacity-30 hover:opacity-100"
@click="
;(showDeleteModal = true),
(deleteName =
`/${mediaStore.folderTree.source}/${folder.name}`.replace(
/\/[/]+/g,
'/'
))
"
>
<i class="bi-x-circle-fill" />
</button>
</td>
</tr>
<tr
v-for="(element, index) in mediaStore.folderTree.files"
:id="`file_${index}`"
:key="element.name"
class="grid grid-cols-[auto_170px] border-b border-base-content/20"
draggable="true"
@dragstart="handleDragStart($event, element)"
2024-04-16 12:13:28 -04:00
>
<td class="px-2 py-1.5 truncate cursor-grab">
<i
v-if="mediaType(element.name) === 'audio'"
class="bi-music-note-beamed"
/>
<i v-else-if="mediaType(element.name) === 'video'" class="bi-film" />
<i
v-else-if="mediaType(element.name) === 'image'"
class="bi-file-earmark-image"
/>
<i v-else class="bi-file-binary" />
2023-01-11 04:54:25 -05:00
{{ element.name }}
</td>
<td class="px-2 py-1.5 flex">
<button
class="w-7"
@click=";(showPreviewModal = true), setPreviewData(element.name)"
>
<i class="bi-play-fill" />
</button>
<div class="inline-block w-[82px]">{{ toMin(element.duration) }}</div>
<button
class="w-7"
@click="
;(showRenameModal = true),
setRenameValues(
`/${mediaStore.folderTree.source}/${element.name}`.replace(
/\/[/]+/g,
'/'
)
)
"
>
<i class="bi-pencil-square" />
</button>
<button
class="w-7 opacity-30 hover:opacity-100"
@click="
;(showDeleteModal = true),
(deleteName =
`/${mediaStore.folderTree.source}/${element.name}`.replace(
/\/[/]+/g,
'/'
))
"
>
<i class="bi-x-circle-fill" />
</button>
</td>
</tr>
</tbody>
</table>
</div>
2024-04-16 12:13:28 -04:00
</pane>
</splitpanes>
2023-01-11 04:54:25 -05:00
</div>
2024-04-07 09:45:26 -04:00
2024-04-16 12:13:28 -04:00
<div class="flex justify-end py-4 pe-2">
<div class="join">
<button
class="btn btn-sm btn-primary join-item"
:title="t('media.create')"
2024-04-16 12:13:28 -04:00
@click="showCreateModal = true"
>
<i class="bi-folder-plus" />
</button>
<button
class="btn btn-sm btn-primary join-item"
:title="t('media.upload')"
2024-04-16 12:13:28 -04:00
@click="showUploadModal = true"
>
<i class="bi-upload" />
</button>
</div>
2024-04-06 17:16:13 -04:00
</div>
2024-04-16 12:13:28 -04:00
</div>
2024-04-07 09:45:26 -04:00
2024-04-16 12:13:28 -04:00
<GenericModal
:show="showDeleteModal"
:title="t('media.deleteTitle')"
:text="`${t('media.deleteQuestion')}:<br /><strong>${deleteName}</strong>`"
2024-04-16 12:13:28 -04:00
:modal-action="deleteFileOrFolder"
2024-10-01 16:13:03 -04:00
>
<div>
<input class="input input-sm w-full" type="text" :value="deleteName" disabled />
<div v-if="!extensionsArr.some(suffix => deleteName.endsWith(suffix))" class="form-control mt-3">
<label class="label cursor-pointer w-1/4">
<input v-model="recursive" type="checkbox" class="checkbox checkbox-sm checkbox-warning" />
<span class="label-text">{{ t('media.recursive') }}</span>
</label>
</div>
</div>
</GenericModal>
2024-04-07 09:45:26 -04:00
2024-04-16 12:13:28 -04:00
<GenericModal
:show="showPreviewModal"
:title="`${t('media.preview')}: ${previewName}`"
2024-04-16 12:13:28 -04:00
:modal-action="closePlayer"
:hide-buttons="true"
2024-04-16 12:13:28 -04:00
>
<div class="w-[1024px] max-w-full aspect-video">
<VideoPlayer v-if="isVideo && previewOpt" reference="previewPlayer" :options="previewOpt" />
<img v-else :src="previewUrl" class="img-fluid" :alt="previewName" />
2024-04-16 12:13:28 -04:00
</div>
</GenericModal>
2023-01-11 04:54:25 -05:00
<GenericModal :show="showRenameModal" :title="t('media.rename')" :modal-action="renameFile">
2024-04-16 12:13:28 -04:00
<label class="form-control w-full max-w-md">
2024-04-07 09:45:26 -04:00
<div class="label">
<span class="label-text">{{ t('media.newFile') }}</span>
2024-04-06 17:16:13 -04:00
</div>
<input v-model="renameNewName" type="text" class="input input-bordered w-full" />
2024-04-07 09:45:26 -04:00
</label>
2024-04-16 12:13:28 -04:00
</GenericModal>
<GenericModal :show="showCreateModal" :title="t('media.createFolder')" :modal-action="createFolder">
2024-04-16 12:13:28 -04:00
<label class="form-control w-full max-w-md">
2024-04-07 09:45:26 -04:00
<div class="label">
<span class="label-text">{{ t('media.foldername') }}</span>
2024-04-07 09:45:26 -04:00
</div>
<input v-model="folderName.name" type="text" class="input input-bordered w-full" />
2024-04-07 09:45:26 -04:00
</label>
2024-04-16 12:13:28 -04:00
</GenericModal>
<GenericModal :show="showUploadModal" :title="t('media.upload')" :modal-action="uploadFiles">
2024-04-16 12:13:28 -04:00
<div class="w-[700px] max-w-full">
<input
ref="fileInputName"
type="file"
class="file-input file-input-bordered w-full"
:accept="extensions"
multiple
@change="onFileChange"
/>
2024-04-16 12:13:28 -04:00
<label class="form-control w-full mt-3">
<div class="label">
<span class="label-text">{{ t('media.current') }}:</span>
2024-04-16 12:13:28 -04:00
</div>
<progress class="progress progress-accent" :value="currentProgress" max="100" />
</label>
<label class="form-control w-full mt-1">
<div class="label">
<span class="label-text"
>{{ t('media.overall') }} ({{ currentNumber }}/{{ inputFiles.length }}):</span
2024-04-16 12:13:28 -04:00
>
</div>
<progress class="progress progress-accent" :value="overallProgress" max="100" />
</label>
<label class="form-control w-full mt-1">
<div class="label">
<span class="label-text">{{ t('media.uploading') }}:</span>
2024-04-16 12:13:28 -04:00
</div>
<input v-model="uploadTask" type="text" class="input input-sm input-bordered w-full" disabled />
2024-04-16 12:13:28 -04:00
</label>
</div>
</GenericModal>
</div>
2020-01-30 15:25:10 -05:00
</template>
2023-01-11 04:54:25 -05:00
<script setup lang="ts">
2023-03-27 10:28:13 -04:00
import { storeToRefs } from 'pinia'
2024-04-13 18:01:45 -04:00
const { t } = useI18n()
2024-04-08 03:35:31 -04:00
const { width } = useWindowSize({ initialWidth: 800 })
2023-01-11 04:54:25 -05:00
const authStore = useAuth()
const configStore = useConfig()
const indexStore = useIndex()
const mediaStore = useMedia()
2024-04-07 17:27:52 -04:00
const { toMin, mediaType, filename, parent } = stringFormatter()
const { i } = storeToRefs(useConfig())
2023-03-27 10:28:13 -04:00
2023-01-11 04:54:25 -05:00
useHead({
2024-04-16 08:07:50 -04:00
title: `${t('button.media')} | ffplayout`,
2023-01-11 04:54:25 -05:00
})
2024-04-08 03:35:31 -04:00
watch([width], () => {
if (width.value < 640) {
horizontal.value = true
} else {
horizontal.value = false
}
})
const horizontal = ref(false)
2023-03-27 10:28:13 -04:00
const deleteName = ref('')
2024-10-01 16:13:03 -04:00
const recursive = ref(false)
2023-03-27 10:28:13 -04:00
const renameOldName = ref('')
const renameOldPath = ref('')
2023-03-27 10:28:13 -04:00
const renameNewName = ref('')
const previewName = ref('')
const previewUrl = ref('')
const previewOpt = ref()
const isVideo = ref(false)
2024-04-07 09:45:26 -04:00
const showDeleteModal = ref(false)
const showPreviewModal = ref(false)
const showRenameModal = ref(false)
const showCreateModal = ref(false)
const showUploadModal = ref(false)
2023-01-11 04:54:25 -05:00
const extensions = ref('')
2024-10-01 16:13:03 -04:00
const extensionsArr = ref([] as string[])
const folderName = ref({} as Folder)
2023-01-11 04:54:25 -05:00
const inputFiles = ref([] as File[])
2023-04-06 05:05:15 -04:00
const fileInputName = ref()
2023-01-11 04:54:25 -05:00
const currentNumber = ref(0)
const uploadTask = ref('')
const overallProgress = ref(0)
const currentProgress = ref(0)
const lastPath = ref('')
const xhr = ref(new XMLHttpRequest())
onMounted(async () => {
let config_extensions = configStore.playout.storage.extensions
let extra_extensions = configStore.channels[configStore.i].extra_extensions
if (typeof config_extensions === 'string') {
config_extensions = config_extensions.split(',')
}
if (typeof extra_extensions === 'string') {
extra_extensions = extra_extensions.split(',')
}
2024-10-01 16:13:03 -04:00
extensionsArr.value = [...config_extensions, ...extra_extensions].map((ext) => {
2023-01-11 04:54:25 -05:00
return `.${ext}`
})
2024-10-01 16:13:03 -04:00
extensions.value = extensionsArr.value.join(', ')
2023-03-27 10:28:13 -04:00
if (!mediaStore.folderTree.parent || !mediaStore.currentPath) {
2024-04-08 11:07:03 -04:00
await mediaStore.getTree('')
2023-03-27 10:28:13 -04:00
}
})
watch([i], () => {
2024-04-08 11:07:03 -04:00
mediaStore.getTree('')
2023-01-11 04:54:25 -05:00
})
2024-04-07 17:27:52 -04:00
function handleDragStart(event: any, itemData: any) {
event.dataTransfer.setData('application/json', JSON.stringify(itemData))
}
function handleDragOver(event: any) {
event.target.style.fontWeight = 'bold'
if (event.target.firstChild && event.target.firstChild.classList.contains('bi-folder-fill')) {
event.target.firstChild.classList.remove('bi-folder-fill')
event.target.firstChild.classList.add('bi-folder2-open')
}
}
function handleDragLeave(event: any) {
if (event.target && event.target.style) {
event.target.style.fontWeight = null
}
if (event.target.firstChild && event.target.firstChild.classList.contains('bi-folder2-open')) {
event.target.firstChild.classList.remove('bi-folder2-open')
event.target.firstChild.classList.add('bi-folder-fill')
}
}
async function handleDrop(event: any, targetFolder: any, isParent: boolean | null) {
const itemData = JSON.parse(event.dataTransfer.getData('application/json'))
2024-04-08 11:07:03 -04:00
const source = `/${mediaStore.folderTree.source}/${itemData.name}`.replace(/\/[/]+/g, '/')
2024-04-07 17:27:52 -04:00
let target
if (isParent === null) {
target = `${targetFolder}/${itemData.name}`.replace(/\/[/]+/g, '/')
} else if (isParent) {
2024-04-08 11:07:03 -04:00
target = `/${parent(mediaStore.folderTree.source)}/${targetFolder.name}/${itemData.name}`.replace(
/\/[/]+/g,
'/'
)
2024-04-07 17:27:52 -04:00
} else {
2024-04-08 11:07:03 -04:00
target = `/${mediaStore.folderTree.source}/${targetFolder.name}/${itemData.name}`.replace(/\/[/]+/g, '/')
2024-04-07 17:27:52 -04:00
}
event.target.style.fontWeight = null
if (event.target.firstChild.classList.contains('bi-folder2-open')) {
event.target.firstChild.classList.remove('bi-folder2-open')
event.target.firstChild.classList.add('bi-folder-fill')
}
if (source !== target) {
await fetch(`/api/file/${configStore.channels[configStore.i].id}/rename/`, {
2024-04-07 17:27:52 -04:00
method: 'POST',
2024-04-16 08:07:50 -04:00
headers: { ...configStore.contentType, ...authStore.authHeader },
2024-04-07 17:27:52 -04:00
body: JSON.stringify({ source, target }),
})
2024-04-16 08:07:50 -04:00
.then(async (res) => {
if (res.status >= 400) {
indexStore.msgAlert('error', await res.json(), 3)
} else {
mediaStore.getTree(mediaStore.folderTree.source)
}
2024-04-07 17:27:52 -04:00
})
.catch((e) => {
2024-04-13 18:01:45 -04:00
indexStore.msgAlert('error', `${t('media.moveError')}: ${e}`, 3)
2024-04-07 17:27:52 -04:00
})
}
}
2023-03-27 10:28:13 -04:00
function setPreviewData(path: string) {
/*
Set path and player options for video preview.
*/
let fullPath = path
if (!path.includes('/')) {
fullPath = `/${mediaStore.folderTree.parent}/${mediaStore.folderTree.source}/${path}`.replace(/\/[/]+/g, '/')
}
previewName.value = fullPath.split('/').slice(-1)[0]
previewUrl.value = encodeURIComponent(`/file/${configStore.channels[configStore.i].id}${fullPath}`).replace(
/%2F/g,
'/'
)
2023-03-27 10:28:13 -04:00
const ext = previewName.value.split('.').slice(-1)[0].toLowerCase()
const fileType =
mediaType(previewName.value) === 'audio'
? `audio/${ext}`
: mediaType(previewName.value) === 'live'
? 'application/x-mpegURL'
: `video/${ext}`
2023-03-27 10:28:13 -04:00
if (configStore.playout.storage.extensions.includes(`${ext}`)) {
2023-03-27 10:28:13 -04:00
isVideo.value = true
previewOpt.value = {
liveui: false,
controls: true,
suppressNotSupportedError: true,
autoplay: false,
preload: 'auto',
sources: [
{
type: fileType,
src: previewUrl.value,
},
],
}
} else {
isVideo.value = false
}
}
2024-04-07 09:45:26 -04:00
async function deleteFileOrFolder(del: boolean) {
2023-03-27 10:28:13 -04:00
/*
Delete function, works for files and folders.
*/
2024-04-07 09:45:26 -04:00
showDeleteModal.value = false
if (del) {
await fetch(`/api/file/${configStore.channels[configStore.i].id}/remove/`, {
2024-04-07 09:45:26 -04:00
method: 'POST',
2024-04-16 08:07:50 -04:00
headers: { ...configStore.contentType, ...authStore.authHeader },
2024-10-01 16:13:03 -04:00
body: JSON.stringify({ source: deleteName.value, recursive: recursive.value }),
2023-03-27 10:28:13 -04:00
})
2024-04-07 09:45:26 -04:00
.then(async (response) => {
if (response.status !== 200) {
indexStore.msgAlert('error', `${await response.text()}`, 5)
2024-04-07 09:45:26 -04:00
}
2024-04-08 11:07:03 -04:00
mediaStore.getTree(mediaStore.folderTree.source)
2024-04-07 09:45:26 -04:00
})
.catch((e) => {
2024-04-13 18:01:45 -04:00
indexStore.msgAlert('error', `${t('media.deleteError')}: ${e}`, 5)
2024-04-07 09:45:26 -04:00
})
2024-10-01 16:13:03 -04:00
recursive.value = false
2024-04-07 09:45:26 -04:00
}
deleteName.value = ''
2023-03-27 10:28:13 -04:00
}
function setRenameValues(path: string) {
const index = path.lastIndexOf('/')
const dir = path.substring(0, index + 1) || '/'
const file = path.substring(index + 1)
renameOldName.value = file
renameOldPath.value = dir
renameNewName.value = file
2023-03-27 10:28:13 -04:00
}
2024-04-07 09:45:26 -04:00
async function renameFile(ren: boolean) {
2023-03-27 10:28:13 -04:00
/*
Form submit for file rename request.
*/
2024-04-07 09:45:26 -04:00
showRenameModal.value = false
2023-03-27 10:28:13 -04:00
2024-04-16 08:07:50 -04:00
if (ren && renameOldName.value !== renameNewName.value) {
await fetch(`/api/file/${configStore.channels[configStore.i].id}/rename/`, {
2024-04-07 09:45:26 -04:00
method: 'POST',
2024-04-16 08:07:50 -04:00
headers: { ...configStore.contentType, ...authStore.authHeader },
body: JSON.stringify({
source: `${renameOldPath.value}${renameOldName.value}`,
target: `${renameOldPath.value}${renameNewName.value}`,
}),
2023-03-27 10:28:13 -04:00
})
2024-04-16 08:07:50 -04:00
.then(async (res) => {
if (res.status >= 400) {
indexStore.msgAlert('error', await res.text(), 3)
} else {
mediaStore.getTree(mediaStore.folderTree.source)
}
2024-04-07 09:45:26 -04:00
})
.catch((e) => {
2024-04-13 18:01:45 -04:00
indexStore.msgAlert('error', `${t('media.moveError')}: ${e}`, 3)
2024-04-07 09:45:26 -04:00
})
}
2023-03-27 10:28:13 -04:00
renameOldName.value = ''
renameOldPath.value = ''
2023-03-27 10:28:13 -04:00
renameNewName.value = ''
}
function closePlayer() {
2024-04-07 09:45:26 -04:00
showPreviewModal.value = false
2023-03-27 10:28:13 -04:00
isVideo.value = false
}
2024-04-07 09:45:26 -04:00
async function createFolder(create: boolean) {
showCreateModal.value = false
2023-01-11 04:54:25 -05:00
2024-04-07 09:45:26 -04:00
if (create) {
const path = `${mediaStore.folderTree.source}/${folderName.value.name}`.replace(/\/[/]+/g, '/')
lastPath.value = mediaStore.folderTree.source
2023-01-11 04:54:25 -05:00
2024-04-07 09:45:26 -04:00
if (mediaStore.folderTree.folders.includes(folderName.value)) {
2024-04-13 18:01:45 -04:00
indexStore.msgAlert('warning', `${t('media.folderExists')}! "${folderName.value.name}"`, 2)
2020-04-13 15:35:24 -04:00
2024-04-07 09:45:26 -04:00
return
}
2020-01-31 07:45:56 -05:00
await $fetch(`/api/file/${configStore.channels[configStore.i].id}/create-folder/`, {
2024-04-07 09:45:26 -04:00
method: 'POST',
2024-04-16 08:07:50 -04:00
headers: { ...configStore.contentType, ...authStore.authHeader },
2024-04-07 09:45:26 -04:00
body: JSON.stringify({ source: path }),
})
.then(() => {
2024-04-13 18:01:45 -04:00
indexStore.msgAlert('success', t('media.folderCreate'), 2)
2024-04-07 09:45:26 -04:00
})
.catch((e: string) => {
2024-04-13 18:01:45 -04:00
indexStore.msgAlert('error', `${t('media.folderError')}: ${e}`, 3)
indexStore.alertVariant = 'error'
2024-04-07 09:45:26 -04:00
})
2024-04-08 11:07:03 -04:00
mediaStore.getTree(lastPath.value)
2024-04-07 09:45:26 -04:00
}
2020-01-30 15:25:10 -05:00
folderName.value = {} as Folder
2020-04-20 12:07:12 -04:00
}
2023-01-11 04:54:25 -05:00
function onFileChange(evt: any) {
const files = evt.target.files || evt.dataTransfer.files
2020-05-04 06:16:35 -04:00
2023-01-11 04:54:25 -05:00
if (!files.length) {
return
}
2020-05-04 06:16:35 -04:00
2023-01-11 04:54:25 -05:00
inputFiles.value = files
2020-05-04 06:16:35 -04:00
}
2023-12-20 06:55:24 -05:00
async function upload(file: any): Promise<null | undefined> {
2023-04-06 05:05:15 -04:00
const formData = new FormData()
formData.append(file.name, file)
xhr.value = new XMLHttpRequest()
2023-06-28 05:01:17 -04:00
return new Promise((resolve) => {
2023-01-11 04:54:25 -05:00
xhr.value.open(
'PUT',
`/api/file/${configStore.channels[configStore.i].id}/upload/?path=${encodeURIComponent(
2023-01-11 04:54:25 -05:00
mediaStore.crumbs[mediaStore.crumbs.length - 1].path
)}`
)
2020-04-20 12:07:12 -04:00
2023-01-11 04:54:25 -05:00
xhr.value.setRequestHeader('Authorization', `Bearer ${authStore.jwtToken}`)
2020-04-20 12:07:12 -04:00
2023-06-28 05:01:17 -04:00
xhr.value.upload.onprogress = (event: any) => {
2023-01-11 04:54:25 -05:00
currentProgress.value = Math.round((100 * event.loaded) / event.total)
}
2020-01-31 07:45:56 -05:00
2023-06-28 05:01:17 -04:00
xhr.value.upload.onerror = () => {
2024-04-13 18:01:45 -04:00
indexStore.msgAlert('error', `${t('media.folderError')}: ${xhr.value.status}`, 3)
2023-04-06 05:05:15 -04:00
resolve(undefined)
2023-01-11 04:54:25 -05:00
}
// upload completed successfully
2023-06-28 05:01:17 -04:00
xhr.value.onload = () => {
2023-01-11 04:54:25 -05:00
currentProgress.value = 100
2023-06-28 05:01:17 -04:00
resolve(xhr.value.response)
2023-01-11 04:54:25 -05:00
}
xhr.value.send(formData)
})
2023-04-06 05:05:15 -04:00
}
2024-04-07 09:45:26 -04:00
async function uploadFiles(upl: boolean) {
if (upl) {
2024-04-07 09:48:55 -04:00
authStore.inspectToken()
2024-04-07 09:45:26 -04:00
lastPath.value = mediaStore.folderTree.source
2023-04-06 05:05:15 -04:00
2024-04-07 09:45:26 -04:00
for (let i = 0; i < inputFiles.value.length; i++) {
const file = inputFiles.value[i]
uploadTask.value = file.name
currentProgress.value = 0
currentNumber.value = i + 1
2023-04-06 05:05:15 -04:00
2024-04-07 09:45:26 -04:00
if (mediaStore.folderTree.files.find((f) => f.name === file.name)) {
2024-04-13 18:01:45 -04:00
indexStore.msgAlert('warning', t('media.fileExists'), 3)
2024-04-07 09:45:26 -04:00
} else {
await upload(file)
}
2023-04-06 05:05:15 -04:00
2024-04-07 09:45:26 -04:00
overallProgress.value = (currentNumber.value * 100) / inputFiles.value.length
}
2023-04-06 05:05:15 -04:00
2024-04-07 09:45:26 -04:00
uploadTask.value = 'Done...'
2024-04-08 11:07:03 -04:00
mediaStore.getTree(lastPath.value)
2024-04-07 09:45:26 -04:00
setTimeout(() => {
fileInputName.value = null
currentNumber.value = 0
currentProgress.value = 0
overallProgress.value = 0
inputFiles.value = []
uploadTask.value = ''
showUploadModal.value = false
}, 1500)
} else {
fileInputName.value = null
2023-01-11 04:54:25 -05:00
inputFiles.value = []
2024-04-07 09:45:26 -04:00
overallProgress.value = 0
currentProgress.value = 0
2023-04-06 05:05:15 -04:00
uploadTask.value = ''
2024-04-07 09:45:26 -04:00
xhr.value.abort()
showUploadModal.value = false
2023-03-27 10:28:13 -04:00
}
}
2024-04-07 09:45:26 -04:00
</script>