wrolpi/app/src/components/Videos.js
Roland 73fafcd645
Search: fast ABC mode by default, opt-in deep search
The file_group.textsearch tsvector indexes all four text columns;
d_text (captions, document text, zip contents) is ~90% of the data,
making ts_rank searches take seconds on large libraries.  Add a
textsearch_abc generated column (title/author/description only, ~8x
smaller) and default all searches to it, with deep=true opting into the
full column.

Database:
- Migration adds the generated column and a GIN index (rewrites the
  table; a few minutes on large libraries).

Backend:
- FilesSearchRequest, VideoSearchRequest, ArchiveSearchRequest, and
  DocSearchRequest accept `deep`; each search function picks the column.
- /api/search_file_estimates returns both counts in one index-bound
  query (COUNT FILTER on the abc subset): `file_groups` (fast) and
  `file_groups_deep`.

UI (one coherent story across the count surfaces):
- The typing dropdown always suggests the deep count (what is findable).
- The tab badge shows the active mode's count so it matches the result
  list.
- The gap is reconciled by a hint offering deep search: count-aware on
  the global search ("No results in fast search. N results available in
  deep search." / "N more results available..."), generic on the module
  pages (no deep estimate there).  The hint resets pagination.
- "Search Depth" toggle in the search filter modals, persisted as
  ?deep=true.

Tests that relied on d_text matches now pass deep=True, with fast-mode
assertions alongside.  Also skip flaky test_download_channel on
CircleCI.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
2026-07-03 10:32:16 -06:00

962 lines
35 KiB
JavaScript

import React, {useContext, useEffect, useRef, useState} from 'react';
import {Link, Outlet, useParams} from "react-router";
import {useHotkeys} from "react-hotkeys-hook";
import {
APIButton,
CardLink,
CardPoster,
Duration,
encodeMediaPath,
ErrorMessage,
FileIcon,
findPosterPath,
humanFileSize,
humanNumber,
HelpHeader,
InfoHeader,
isoDatetimeToAgoPopup,
mimetypeColor,
PageContainer,
PreviewLink,
scrollToTop,
secondsToFullDuration,
TabLinks,
textEllipsis,
useTitle,
CookiesUnlockModal
} from "./Common"
import VideoPage from "./VideoPlayer";
import {
CardContent,
CardDescription,
CardHeader,
Container,
Form,
FormDropdown,
FormInput,
FormField,
TextArea,
Image,
Label,
PlaceholderHeader,
PlaceholderLine,
StatisticLabel,
StatisticValue,
TableCell
} from "semantic-ui-react";
import {useChannel, useSearchOrder, useSearchVideos, useVideo, useVideoStatistics} from "../hooks/customHooks";
import {DeepSearchHint, FileRowTagIcon, FilesView, SearchControlBar} from "./Files";
import Grid from "semantic-ui-react/dist/commonjs/collections/Grid";
import Icon from "semantic-ui-react/dist/commonjs/elements/Icon";
import {Button, Card, Header, Loader, Modal, Placeholder, Popup, Segment, Statistic} from "./Theme";
import {BulkTagModal} from "./BulkTagModal";
import {TaggedDeleteConfirmModal} from "./TaggedDeleteConfirmModal";
import {
deleteFileGroups,
deleteCookies,
fetchSuggestedUserAgent,
fetchVideoDownloaderConfig,
getCookiesStatus,
lockCookies,
postVideoFileFormat,
previewBatchReorganization,
updateVideoDownloaderConfig,
uploadCookies,
} from "../api";
import {QueryContext, ThemeContext} from "../contexts/contexts";
import _ from "lodash";
import {defaultFileOrder, defaultSearchOrder} from "./Vars";
import {InputForm, ToggleForm, useForm} from "../hooks/useForm";
import {VideoFormatSelectorForm, VideoResolutionSelectorForm} from "./Download";
import {BatchReorganizeModal} from "./collections/BatchReorganizeModal";
export function VideoWrapper() {
const {fileGroupId} = useParams();
const {videoFile, prevFile, nextFile, fetchVideo} = useVideo(fileGroupId);
// Scroll to the top when fileGroupId changes.
useEffect(scrollToTop, [fileGroupId]);
return <VideoPage videoFile={videoFile} prevFile={prevFile} nextFile={nextFile} fetchVideo={fetchVideo}
autoplay={true}/>
}
export function VideosPage() {
const {channelId} = useParams();
const {searchParams} = React.useContext(QueryContext);
const [selectedVideos, setSelectedVideos] = useState([]);
const [bulkTagOpen, setBulkTagOpen] = useState(false);
const [taggedFileGroups, setTaggedFileGroups] = useState(null);
const searchInputRef = React.useRef();
useHotkeys('f', (e) => {
e.preventDefault();
if (searchInputRef.current) {
searchInputRef.current.focus();
}
}, {enableOnFormTags: false});
let searchOrder = defaultFileOrder;
if (searchParams.get('order')) {
// Use whatever order the user specified.
searchOrder = searchParams.get('order');
} else if (searchParams.get('q')) {
// User used a search_str
searchOrder = defaultSearchOrder;
}
const {searchStr, setSearchStr, videos, activePage, setPage, totalPages, fetchVideos, loading} =
useSearchVideos(null, channelId, searchOrder);
const {channel} = useChannel(channelId);
let title = 'Videos';
if (channel && channel.name) {
title = `${channel.name} Videos`;
}
useTitle(title);
let videoOrders = [
{value: 'published_datetime', text: 'Published Date', short: 'P.Date'},
{value: 'length', text: 'Length'},
{value: 'size', text: 'Size'},
{value: 'size_to_duration', text: 'Size to Duration', short: 'S/Duration'},
{value: 'view_count', text: 'Views'},
{value: 'viewed', text: 'Recently Viewed', short: 'R.Viewed'},
{value: 'download_datetime', text: 'Download Date', short: 'D.Date'},
]
if (searchStr) {
videoOrders = [{value: 'rank', text: 'Search'}, ...videoOrders];
}
let header;
if (channel && channel.name) {
const editLink = `/videos/channel/${channelId}/edit`;
header = <>
<Header as='h1'>
{channel.name}
<Link to={editLink}>
<Icon name='edit' style={{marginLeft: '0.5em'}}/>
</Link>
</Header>
</>;
} else if (channelId) {
header = <Placeholder style={{marginBottom: '1em'}}>
<PlaceholderHeader>
<PlaceholderLine/>
</PlaceholderHeader>
</Placeholder>;
}
const onSelect = (path, checked) => {
const newSelectedVideos = checked && path ? [...selectedVideos, path] : selectedVideos.filter(i => i !== path);
console.debug(`Selected Videos: ${newSelectedVideos}`);
setSelectedVideos(newSelectedVideos);
}
const onDelete = async (force = false) => {
const fileGroupIds = videos.filter(i => selectedVideos.indexOf(i['primary_path']) >= 0).map(i => i['id']);
const result = await deleteFileGroups(fileGroupIds, force);
if (result && result.tagged) {
setTaggedFileGroups(result.file_groups);
return;
}
await fetchVideos();
setSelectedVideos([]);
}
const invertSelection = async () => {
const newSelectedVideos = videos.map(video => video['key']).filter(i => selectedVideos.indexOf(i) < 0);
setSelectedVideos(newSelectedVideos);
}
const clearSelection = async (e) => {
if (e) e.preventDefault();
setSelectedVideos([]);
}
const onBulkTagComplete = async () => {
await fetchVideos();
setSelectedVideos([]);
}
const selectElm = <div style={{marginTop: '0.5em'}}>
<Button
color='violet'
disabled={_.isEmpty(selectedVideos)}
onClick={() => setBulkTagOpen(true)}
>Tag</Button>
<APIButton
color='red'
disabled={_.isEmpty(selectedVideos)}
confirmButton='Delete'
confirmContent='Are you sure you want to delete these video files? This cannot be undone.'
onClick={() => onDelete(false)}
>Delete</APIButton>
<Button
color='grey'
onClick={() => invertSelection()}
disabled={_.isEmpty(videos)}
>
Invert
</Button>
<Button
color='yellow'
onClick={() => clearSelection()}
disabled={_.isEmpty(videos) || _.isEmpty(selectedVideos)}
>
Clear
</Button>
<BulkTagModal
open={bulkTagOpen}
onClose={() => setBulkTagOpen(false)}
paths={selectedVideos}
onComplete={onBulkTagComplete}
/>
</div>;
const {body, paginator, viewButton} = FilesView(
{
files: videos,
activePage: activePage,
totalPages: totalPages,
selectElem: selectElm,
selectedKeys: selectedVideos,
onSelect: onSelect,
setPage: setPage,
headlines: !!searchStr,
loading: loading,
},
);
return <>
{header}
<SearchControlBar
searchStr={searchStr}
setSearchStr={setSearchStr}
placeholder='Search Videos...'
inputRef={searchInputRef}
viewButton={viewButton}
sorts={videoOrders}
showCensored={true}
showDeep={true}
/>
{body}
<DeepSearchHint searchStr={searchStr} files={videos}/>
{paginator}
<TaggedDeleteConfirmModal
open={taggedFileGroups !== null}
taggedFileGroups={taggedFileGroups}
onCancel={() => setTaggedFileGroups(null)}
onConfirm={async () => {
setTaggedFileGroups(null);
await onDelete(true);
}}
/>
</>
}
function VideoFileNameForm({form}) {
const [message, setMessage] = React.useState(null);
const debouncedOnChange = React.useCallback(
_.debounce(async (value) => {
const response = await postVideoFileFormat(value);
const {error, preview} = await response.json();
if (error) {
setMessage({content: error, header: 'Invalid File Name', negative: true});
} else {
setMessage({content: preview, header: 'File Name Preview', positive: true});
}
}, 300),
[]
);
// Cleanup debounce on unmount
React.useEffect(() => {
return () => debouncedOnChange.cancel();
}, [debouncedOnChange]);
const onChange = debouncedOnChange;
const label = <InfoHeader
headerSize='h5'
headerContent='Video File Format'
popupProps={{wide: 'very', position: 'top left'}}
popupContent={<>
<p>Common yt-dlp variables:</p>
<ul>
<li><code>%(title)s</code> - Video title</li>
<li><code>%(uploader)s</code> - Channel/uploader name</li>
<li><code>%(upload_date)s</code> - Upload date (YYYYMMDD)</li>
<li><code>%(upload_year)s</code> - Upload year (YYYY)</li>
<li><code>%(upload_month)s</code> - Upload month (01-12)</li>
<li><code>%(id)s</code> - Video ID</li>
<li><code>%(channel)s</code> - Channel name</li>
<li><code>%(duration)s</code> - Duration in seconds</li>
<li><code>%(playlist_index)s</code> - Playlist index</li>
<li><code>%(ext)s</code> - File extension (required, must be at end)</li>
</ul>
<p>See yt-dlp docs for all variables. Subdirectories supported.</p>
</>}
/>;
return <InputForm
form={form}
name='file_name_format'
path='yt_dlp_options.file_name_format'
label={label}
onChange={onChange}
message={message}
/>
}
export function VideosSettingsPage() {
useTitle('Videos Settings');
const [batchModalOpen, setBatchModalOpen] = useState(false);
const [channelsNeedingReorg, setChannelsNeedingReorg] = useState(0);
const [fetchingReorgCount, setFetchingReorgCount] = useState(true);
// Check how many channels need reorganization on mount
useEffect(() => {
setFetchingReorgCount(true);
previewBatchReorganization('channel')
.then(data => {
setChannelsNeedingReorg(data.total_collections || 0);
})
.catch(() => {
setChannelsNeedingReorg(0);
})
.finally(() => {
setFetchingReorgCount(false);
});
}, []);
const emptyFormData = {
video_resolutions: ['1080p', '720p', '480p', 'maximum'],
yt_dlp_options: {
continue_dl: true,
file_name_format: '%(uploader)s_%(upload_date)s_%(id)s_%(title)s.%(ext)s',
merge_output_format: 'mp4',
nooverwrites: true,
writeautomaticsub: true,
writeinfojson: true,
writesubtitles: true,
writethumbnail: true,
},
yt_dlp_extra_args: '',
download_missing_video_comments: false,
user_agent: '',
sleep_requests: 0.75,
};
const configSubmitter = async () => {
return await updateVideoDownloaderConfig(configForm.formData);
};
const configForm = useForm({
fetcher: fetchVideoDownloaderConfig,
submitter: configSubmitter,
emptyFormData,
});
const [suggestedUserAgent, setSuggestedUserAgent] = useState('');
React.useEffect(() => {
const fetchSuggested = async () => {
const ua = await fetchSuggestedUserAgent();
setSuggestedUserAgent(ua);
};
fetchSuggested();
}, []);
const downloadMissingVideoCommentsLabel = <InfoHeader
headerSize='h5'
headerContent='Download Missing Video Comments'
popupContent='When enabled, WROLPi will automatically download comments for videos that are missing them.'
/>;
return <>
<Segment>
<Header as='h3'>Video Downloader Config</Header>
<Form>
<Grid>
<Grid.Row columns={2}>
<Grid.Column mobile={16} computer={8}>
<VideoResolutionSelectorForm
form={configForm}
name='video_resolutions'
path='video_resolutions'
/>
</Grid.Column>
<Grid.Column mobile={16} computer={4}>
<VideoFormatSelectorForm
form={configForm}
name='merge_output_format'
path='yt_dlp_options.merge_output_format'
/>
</Grid.Column>
<Grid.Column mobile={16} computer={4}>
<VideoFileNameForm form={configForm}/>
</Grid.Column>
</Grid.Row>
<Grid.Row columns={2}>
<Grid.Column mobile={16} computer={8}>
<ToggleForm
form={configForm}
label='Do not overwrite existing files'
name='nooverwrites'
path='yt_dlp_options.nooverwrites'
icon='file video'
/>
</Grid.Column>
<Grid.Column mobile={16} computer={8}>
<ToggleForm
form={configForm}
label='Download automatic subtitles'
name='writeautomaticsub'
path='yt_dlp_options.writeautomaticsub'
icon='closed captioning'
/>
</Grid.Column>
</Grid.Row>
<Grid.Row columns={2}>
<Grid.Column mobile={16} computer={8}>
<ToggleForm
form={configForm}
label='Download subtitles'
name='writesubtitles'
path='yt_dlp_options.writesubtitles'
icon='closed captioning outline'
/>
</Grid.Column>
<Grid.Column mobile={16} computer={8}>
<ToggleForm
form={configForm}
label='Download thumbnail'
name='writethumbnail'
path='yt_dlp_options.writethumbnail'
icon='image'
/>
</Grid.Column>
</Grid.Row>
<Grid.Row columns={2}>
<Grid.Column mobile={16} computer={8}>
<ToggleForm
form={configForm}
label='Download info JSON'
name='writeinfojson'
path='yt_dlp_options.writeinfojson'
icon='file code'
/>
</Grid.Column>
<Grid.Column mobile={16} computer={8}>
<ToggleForm
form={configForm}
label='Continue partial downloads'
name='continue_dl'
path='yt_dlp_options.continue_dl'
icon='play'
/>
</Grid.Column>
</Grid.Row>
<Grid.Row>
<Grid.Column mobile={16} computer={8}>
<ToggleForm
form={configForm}
label={downloadMissingVideoCommentsLabel}
name='download_missing_video_comments'
path='download_missing_video_comments'
icon='comments'
/>
</Grid.Column>
</Grid.Row>
<Grid.Row>
<Grid.Column mobile={16} computer={8}>
<InputForm
form={configForm}
name='yt_dlp_extra_args'
path='yt_dlp_extra_args'
label='Extra yt-dlp Arguments'
placeholder='--prefer-free-formats'
icon='terminal'
/>
</Grid.Column>
<Grid.Column mobile={16} computer={4}>
<Form.Field>
<InfoHeader
headerSize='h5'
headerContent='Sleep Between Requests'
popupContent='Seconds to sleep between yt-dlp API requests. Helps avoid rate limiting and bot detection. Set to 0 to disable. Does not affect video download speed.'
/>
<FormInput
type='number'
step='0.25'
min='0'
max='10'
value={configForm.formData.sleep_requests ?? 0.75}
onChange={(e) => configForm.setValue('sleep_requests', parseFloat(e.target.value) || 0)}
placeholder='0.75'
label={{basic: true, content: 'seconds'}}
labelPosition='right'
/>
</Form.Field>
</Grid.Column>
</Grid.Row>
<Grid.Row>
<Grid.Column mobile={16} computer={16}>
<Form.Field>
<InfoHeader
headerSize='h5'
headerContent='User Agent'
popupContent='Custom user-agent string for yt-dlp. Should match the browser used to export cookies. Click "Use Current Browser" to auto-fill with your browser&apos;s user-agent.'
/>
<FormInput
value={configForm.formData.user_agent || ''}
onChange={(e) => configForm.setValue('user_agent', e.target.value)}
placeholder='Leave empty to use yt-dlp default'
action={{
content: 'Use Current Browser',
onClick: () => configForm.setValue('user_agent', suggestedUserAgent),
}}
/>
</Form.Field>
</Grid.Column>
</Grid.Row>
<Grid.Row columns={1}>
<Grid.Column textAlign='right'>
<APIButton
disabled={configForm.disabled || !configForm.ready}
type='submit'
style={{marginTop: '0.5em'}}
onClick={configForm.onSubmit}
id='video_settings_save_button'
>Save</APIButton>
</Grid.Column>
</Grid.Row>
</Grid>
</Form>
</Segment>
<Segment>
<Header as='h4'>File Organization</Header>
<p>
{fetchingReorgCount
? 'Checking for channels that need reorganization...'
: <>
<strong>{channelsNeedingReorg}</strong> channel{channelsNeedingReorg !== 1 ? 's' : ''}
{channelsNeedingReorg > 0
? ' have files that do not match the current file name format.'
: '. All channels are organized correctly.'}
</>
}
</p>
<Button
color='orange'
onClick={() => setBatchModalOpen(true)}
id='reorganize_all_channels_button'
disabled={fetchingReorgCount || channelsNeedingReorg === 0}
loading={fetchingReorgCount}
>
<Icon name='folder open outline'/> Reorganize All Channels
</Button>
</Segment>
<CookiesSettingsSection/>
<BatchReorganizeModal
open={batchModalOpen}
onClose={() => setBatchModalOpen(false)}
kind='channel'
onComplete={() => {
setBatchModalOpen(false);
setChannelsNeedingReorg(0);
}}
/>
</>
}
function CookiesSettingsSection() {
const [status, setStatus] = useState({cookies_exist: false, cookies_unlocked: false});
const [loading, setLoading] = useState(true);
const [uploadModalOpen, setUploadModalOpen] = useState(false);
const [unlockModalOpen, setUnlockModalOpen] = useState(false);
const [cookiesContent, setCookiesContent] = useState('');
const [password, setPassword] = useState('');
const [submitting, setSubmitting] = useState(false);
const cookiesContentRef = useRef(null);
useEffect(() => {
if (uploadModalOpen) {
const timer = setTimeout(() => {
if (cookiesContentRef.current) {
cookiesContentRef.current.focus();
}
}, 100);
return () => clearTimeout(timer);
}
}, [uploadModalOpen]);
const fetchStatus = async () => {
setLoading(true);
const result = await getCookiesStatus();
if (result) {
setStatus(result);
}
setLoading(false);
};
useEffect(() => {
fetchStatus();
}, []);
const handleUpload = async () => {
if (password.length < 8) {
return;
}
setSubmitting(true);
const result = await uploadCookies(cookiesContent, password);
setSubmitting(false);
if (result.success) {
setUploadModalOpen(false);
setCookiesContent('');
setPassword('');
fetchStatus();
}
};
const handleLock = async () => {
setSubmitting(true);
await lockCookies();
setSubmitting(false);
fetchStatus();
};
const handleDelete = async () => {
setSubmitting(true);
await deleteCookies();
setSubmitting(false);
fetchStatus();
};
const getStatusLabel = () => {
if (loading) return <Label color='grey'>Loading...</Label>;
if (!status.cookies_exist) return <Label color='grey'>No cookies stored</Label>;
if (status.cookies_unlocked) return <Label color='green'>Unlocked</Label>;
return <Label color='yellow'>Locked</Label>;
};
return <Segment>
<HelpHeader
headerSize='h4'
headerContent='Encrypted Cookies'
helpPath='/modules/videos/cookies/'
/>
<p>Use this feature at your own risk! You may be suspended or blocked if abused!
</p>
<div style={{marginBottom: '1em'}}>
<strong>Status:</strong> {getStatusLabel()}
</div>
<Button.Group>
{!status.cookies_exist && (
<Button
color='blue'
onClick={() => setUploadModalOpen(true)}
disabled={loading}
>
<Icon name='upload'/> Upload Cookies
</Button>
)}
{status.cookies_exist && !status.cookies_unlocked && (
<Button
color='green'
onClick={() => setUnlockModalOpen(true)}
disabled={loading}
>
<Icon name='unlock'/> Unlock Cookies
</Button>
)}
{status.cookies_exist && status.cookies_unlocked && (
<Button
color='yellow'
onClick={handleLock}
loading={submitting}
disabled={loading || submitting}
>
<Icon name='lock'/> Lock Cookies
</Button>
)}
{status.cookies_exist && (
<>
<Button
color='blue'
onClick={() => setUploadModalOpen(true)}
disabled={loading}
>
<Icon name='refresh'/> Replace
</Button>
<APIButton
color='red'
onClick={handleDelete}
confirmButton='Delete'
confirmContent='Are you sure you want to delete the stored cookies? This cannot be undone.'
disabled={loading || submitting}
>
<Icon name='trash'/> Delete
</APIButton>
</>
)}
</Button.Group>
{/* Upload Modal */}
<Modal
open={uploadModalOpen}
onClose={() => setUploadModalOpen(false)}
size='small'
>
<Modal.Header>Upload Cookies</Modal.Header>
<Modal.Content>
<Form>
<FormField>
<label>Cookies Content</label>
<TextArea
ref={cookiesContentRef}
placeholder='Paste your cookies.txt content here (Netscape/Mozilla format)'
value={cookiesContent}
onChange={(e) => setCookiesContent(e.target.value)}
rows={10}
/>
</FormField>
<FormInput
label='Encryption Password'
type='password'
placeholder='Minimum 8 characters'
value={password}
onChange={(e) => setPassword(e.target.value)}
error={password.length > 0 && password.length < 8 ? 'Password must be at least 8 characters' : null}
/>
<p style={{color: 'grey', fontSize: '0.9em'}}>
Remember this password - you'll need it to unlock cookies after each restart.
</p>
</Form>
</Modal.Content>
<Modal.Actions>
<Button onClick={() => setUploadModalOpen(false)}>Cancel</Button>
<Button
color='blue'
onClick={handleUpload}
loading={submitting}
disabled={!cookiesContent || password.length < 8 || submitting}
>
<Icon name='lock'/> Encrypt & Save
</Button>
</Modal.Actions>
</Modal>
<CookiesUnlockModal
open={unlockModalOpen}
onClose={() => setUnlockModalOpen(false)}
onSuccess={fetchStatus}
/>
</Segment>;
}
export function VideosStatistics() {
useTitle('Video Statistics');
const {statistics} = useVideoStatistics();
if (statistics === null) {
// Request is pending.
return <Loader active inline='centered'/>
} else if (statistics === undefined) {
return <ErrorMessage>Unable to fetch Video Statistics</ErrorMessage>
}
const {videos, historical, channels} = statistics;
const videoNames = [
{key: 'videos', label: 'Videos'},
{key: 'sum_size', label: 'Total Size'},
{key: 'max_size', label: 'Largest Video'},
{key: 'week', label: 'Downloads Past Week'},
{key: 'month', label: 'Downloads Past Month'},
{key: 'year', label: 'Downloads Past Year'},
{key: 'sum_duration', label: 'Total Duration'},
{key: 'censored_videos', label: 'Censored Videos'},
];
const commentsNames = [
{key: 'have_comments', label: 'Have Comments'},
{key: 'missing_comments', label: 'Missing Comments'},
{key: 'failed_comments', label: 'Failed Comments'},
];
const historicalNames = [
{key: 'average_count', label: 'Average Monthly Downloads'},
{key: 'average_size', label: 'Average Monthly Usage'},
];
const channelNames = [
{key: 'channels', label: 'Channels'},
{key: 'tagged_channels', label: 'Tagged Channels'},
];
const buildSegment = (title, names, stats) => {
return <Segment>
<Header textAlign='center' as='h1'>{title}</Header>
<Statistic.Group>
{names.map(
({key, label}) =>
<Statistic key={key} style={{margin: '2em'}}>
<StatisticValue>{stats[key]}</StatisticValue>
<StatisticLabel>{label}</StatisticLabel>
</Statistic>
)}
</Statistic.Group>
</Segment>
}
return <>
{buildSegment('Videos', videoNames, videos)}
{buildSegment('Video Comments', commentsNames, videos)}
{buildSegment('Historical Video', historicalNames, historical)}
{buildSegment('Channels', channelNames, channels)}
</>
}
export function VideosTabLayout() {
const links = [
{text: 'Videos', to: '/videos', key: 'videos', end: true},
{text: 'Channels', to: '/videos/channel', key: 'channel'},
{text: 'Settings', to: '/videos/settings', key: 'settings'},
{text: 'Statistics', to: '/videos/statistics', key: 'statistics'},
];
return <PageContainer>
<TabLinks links={links}/>
<Outlet/>
</PageContainer>
}
export function VideoCard({file}) {
const {video} = file;
const {s} = useContext(ThemeContext);
const {sort} = useSearchOrder();
const sortField = sort ? sort.replace(/^-/, '') : null;
// Default to video FilePreview for lone video files.
let video_url = `/videos/${file.id}`;
// A video may not have a channel.
const channel = video.channel ? video.channel : null;
let channel_url = null;
if (channel) {
channel_url = `/videos/channel/${channel.id}/video`;
}
let poster = <CardPoster to={video_url} file={file}/>;
const title = file.title || file.name || video.stem || video.name;
let header = <span {...s} className='card-title-ellipsis'>{title}</span>;
if (video_url) {
// Link to Channel-Video page or Video page.
header = <Link to={video_url} className="no-link-underscore card-link">{header}</Link>;
} else {
// Video is just a lone video file.
header = <PreviewLink file={file}>
{header}
</PreviewLink>;
}
const color = mimetypeColor(file.mimetype);
return <Card color={color}>
{poster}
<Duration totalSeconds={file.length}/>
<CardContent {...s}>
<CardHeader>
<Container textAlign='left'>
<Popup on='hover'
trigger={header}
content={title}/>
</Container>
</CardHeader>
<CardDescription>
<Container textAlign='left'>
{channel && <Link to={channel_url} className="no-link-underscore card-link">
<b {...s}>{channel.name}</b>
</Link>}
{sortField === 'length'
? <p {...s}>{secondsToFullDuration(file.length || 0)}</p>
: sortField === 'size'
? <p {...s}>{humanFileSize(file.size)}</p>
: sortField === 'view_count'
? <p {...s}>{humanNumber(video.view_count || 0)} views</p>
: sortField === 'viewed'
? <p {...s}>{isoDatetimeToAgoPopup(file.viewed, false)}</p>
: sortField === 'download_datetime'
? <p {...s}>{isoDatetimeToAgoPopup(file.download_datetime, false)}</p>
: <p {...s}>{isoDatetimeToAgoPopup(file.published_datetime, false)}</p>
}
</Container>
</CardDescription>
</CardContent>
</Card>
}
export function VideoRowCells({file}) {
const {video} = file;
let {sort} = useSearchOrder();
sort = sort ? sort.replace(/^-+/, '') : null;
let video_url = `/videos/${file.id}`;
const poster_path = findPosterPath(file);
const poster_url = poster_path ? `/media/${encodeMediaPath(poster_path)}` : null;
let poster;
if (poster_url) {
poster = <CardLink to={video_url}>
<Image wrapped
src={poster_url}
width='50px'
/>
</CardLink>
} else {
poster = <FileIcon file={file} size='large'/>;
}
let dataCell = file.published_datetime ? isoDatetimeToAgoPopup(file.published_datetime) : '';
if (sort === 'length') {
dataCell = secondsToFullDuration(file.length || 0);
} else if (sort === 'size') {
dataCell = humanFileSize(file.size);
} else if (sort === 'view_count') {
dataCell = humanNumber(video.view_count || 0);
} else if (sort === 'viewed') {
dataCell = isoDatetimeToAgoPopup(file.viewed);
}
// Fragment for SelectableRow
return <React.Fragment>
<TableCell>
<center>
{poster}
</center>
</TableCell>
<TableCell>
<CardLink to={video_url}>
<FileRowTagIcon file={file}/>
{textEllipsis(file.title || video.stem || video.video_path)}
</CardLink>
</TableCell>
<TableCell>{dataCell}</TableCell>
</React.Fragment>
}