mirror of
https://github.com/lrnselfreliance/wrolpi.git
synced 2026-11-19 22:46:20 -05:00
Tags can be created and deleted in UI. Adding tag_file using id to avoid session error. Using UTC in test. Matching tag_names style in test. Tag icon is displayed on file rows. Archives, Videos and Files can be filtered by their tags. Tags can be added and removed from UI. Tags are displayed in VideoPlayer. The tags of a file are returned in it's JSON. Video favorites are converted to Favorite tag on channel config import. Updating tests to match frontend usage. PDF creator and modification time are displayed. Reworking file search to use Video.__json__ for complex video relations. Archives can be viewed. Removing ebook.title. Reworking alembic migration to be an upgrade rather than a replace. Skipping test on circleci. Clearing out video caption index only if extract_subtitles if off. Channel tests pass. Some video tests pass. Missing videos can be found. A video can be downloaded. Orphaned files can be found. Videos can be tagged. Videos can be searched. Videos can be modeled. Converting some tests to use FileGroup.primary_path. Adding archive and domains to alembic migration. Testing cascading Archive titles. Archives now uses FileGroup. archive.lib tests pass. Archive is partially converted to FileGroup. Calculating FileGroup.primary file on refresh, rather than on select. wrolpi tests pass. Using FilesType to convert between str/pathlib.Path for FileGroup.files. Using list of files in FileGroup.files instead of dictionary. Storing files in dedicated FileGroup.files to avoid overwriting them. Adding comment explaining CASE. Not overwriting FileGroup.data on refresh if no change has been detected. Removing File model in favor of FileGroup.data. Adding typing to Files methods. Files are indexed using the primary mimetype of the FileGroup. files test_lib tests pass. Removing file_group_file in favor of simple one-to-many relationship. PDF files are indexed during refresh. Adding Tag and TagFile to tag files with specific tags. Only iterating when full_stem_ids has contents. Testing that FileGroups are related to their Files. Files and file_groups are created and linked. Bump webpack from 5.75.0 to 5.76.1 in /app (#160) Bumps [webpack](https://github.com/webpack/webpack) from 5.75.0 to 5.76.1. - [Release notes](https://github.com/webpack/webpack/releases) - [Commits](https://github.com/webpack/webpack/compare/v5.75.0...v5.76.1) --- updated-dependencies: - dependency-name: webpack dependency-type: indirect ... Signed-off-by: dependabot[bot] <support@github.com> Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
201 lines
6.5 KiB
Python
201 lines
6.5 KiB
Python
from pathlib import Path
|
|
from typing import List, Dict, Union
|
|
|
|
from sqlalchemy.orm import Session
|
|
from sqlalchemy.orm.exc import NoResultFound
|
|
|
|
from wrolpi.common import run_after, logger, \
|
|
get_media_directory
|
|
from wrolpi.db import get_db_curs, optional_session
|
|
from wrolpi.errors import UnknownChannel, UnknownDirectory, APIError, ValidationError, InvalidDownload
|
|
from .. import schema
|
|
from ..common import check_for_channel_conflicts
|
|
from ..lib import save_channels_config
|
|
from ..models import Channel
|
|
|
|
logger = logger.getChild(__name__)
|
|
|
|
|
|
async def get_minimal_channels() -> List[dict]:
|
|
"""
|
|
Get the minimum amount of information necessary about all channels.
|
|
"""
|
|
with get_db_curs() as curs:
|
|
# Get all channels, even if they don't have videos.
|
|
stmt = '''
|
|
SELECT
|
|
c.id, name, directory, url, download_frequency, info_date,
|
|
(select next_download from download d where d.url=c.url) AS next_download
|
|
FROM
|
|
channel AS c
|
|
ORDER BY LOWER(name)
|
|
'''
|
|
curs.execute(stmt)
|
|
channels = list(map(dict, curs.fetchall()))
|
|
|
|
video_counts = await get_channels_video_count()
|
|
|
|
for channel in channels:
|
|
channel_id = channel['id']
|
|
channel['video_count'] = video_counts[channel_id]
|
|
|
|
return channels
|
|
|
|
|
|
async def get_channels_video_count() -> Dict[int, int]:
|
|
"""
|
|
Add video counts to all channels
|
|
"""
|
|
with get_db_curs() as curs:
|
|
stmt = 'SELECT id FROM channel'
|
|
curs.execute(stmt)
|
|
# Get all channel IDs, start them with a count of 0.
|
|
video_counts = {int(i['id']): 0 for i in curs.fetchall()}
|
|
|
|
stmt = '''
|
|
SELECT
|
|
c.id, COUNT(v.id) AS video_count
|
|
FROM
|
|
channel AS c
|
|
LEFT JOIN video AS v ON v.channel_id = c.id
|
|
GROUP BY 1
|
|
'''
|
|
curs.execute(stmt)
|
|
# Replace all the counts of those channels with videos.
|
|
video_counts.update({int(i['id']): int(i['video_count']) for i in curs.fetchall()})
|
|
return video_counts
|
|
|
|
|
|
COD = Union[dict, Channel]
|
|
|
|
|
|
@optional_session
|
|
def get_channel(session: Session, *, channel_id: int = None, source_id: str = None, url: str = None,
|
|
directory: str = None, name: str = None, return_dict: bool = True) -> COD:
|
|
"""
|
|
Attempt to find a Channel using the provided params. The params are in order of reliability.
|
|
|
|
Raises UnknownChannel if no channel is found.
|
|
"""
|
|
channel: COD = None # noqa
|
|
# Try to find the channel by the most reliable methods first.
|
|
if channel_id:
|
|
channel = session.query(Channel).filter_by(id=channel_id).one_or_none()
|
|
if not channel and source_id:
|
|
channel = session.query(Channel).filter_by(source_id=source_id).one_or_none()
|
|
if not channel and url:
|
|
channel = session.query(Channel).filter_by(url=url).one_or_none()
|
|
if not channel and directory:
|
|
directory = Path(directory)
|
|
if not directory.is_absolute():
|
|
directory = get_media_directory() / directory
|
|
channel = session.query(Channel).filter_by(directory=directory).one_or_none()
|
|
if not channel and name:
|
|
channel = session.query(Channel).filter_by(name=name).one_or_none()
|
|
|
|
if not channel:
|
|
raise UnknownChannel(f'No channel matches {channel_id=} {source_id=} {url=} {directory=}')
|
|
|
|
logger.debug(f'Found {channel=} using {channel_id=} {source_id=} {url=} {directory=}')
|
|
session.refresh(channel)
|
|
if return_dict:
|
|
statistics = channel.get_statistics()
|
|
channel = channel.dict()
|
|
channel['statistics'] = statistics
|
|
return channel
|
|
|
|
|
|
@run_after(save_channels_config)
|
|
@optional_session
|
|
def update_channel(session: Session, *, data: schema.ChannelPutRequest, channel_id: int) -> Channel:
|
|
"""Update a Channel's DB record"""
|
|
try:
|
|
channel: Channel = session.query(Channel).filter_by(id=channel_id).one()
|
|
except NoResultFound:
|
|
raise UnknownChannel()
|
|
|
|
# Only update directory if it was empty
|
|
if data.directory and not channel.directory:
|
|
data.directory = get_media_directory() / data.directory
|
|
if not data.directory.is_dir():
|
|
if data.mkdir:
|
|
data.directory.mkdir()
|
|
else:
|
|
raise UnknownDirectory()
|
|
elif data.directory:
|
|
# Keep the old directory because the user can't change a Channel's directory.
|
|
data.directory = channel.directory
|
|
|
|
# Verify that the URL/Name/directory aren't taken
|
|
check_for_channel_conflicts(
|
|
session,
|
|
id_=channel.id,
|
|
url=data.url,
|
|
name=data.name,
|
|
directory=data.directory,
|
|
)
|
|
|
|
# Apply the changes now that we've OK'd them
|
|
channel.update(data.__dict__)
|
|
|
|
session.commit()
|
|
|
|
return channel
|
|
|
|
|
|
@run_after(save_channels_config)
|
|
@optional_session
|
|
def create_channel(session: Session, data: schema.ChannelPostRequest, return_dict: bool = True) -> Union[Channel, dict]:
|
|
"""
|
|
Create a new Channel. Check for conflicts with existing Channels.
|
|
"""
|
|
try:
|
|
# Verify that the URL/Name/directory aren't taken
|
|
check_for_channel_conflicts(
|
|
session,
|
|
url=data.url or None,
|
|
name=data.name,
|
|
directory=data.directory,
|
|
source_id=data.source_id,
|
|
)
|
|
except APIError as e:
|
|
raise ValidationError() from e
|
|
|
|
channel = Channel(
|
|
name=data.name,
|
|
url=data.url or None,
|
|
match_regex=data.match_regex,
|
|
directory=get_media_directory() / data.directory,
|
|
download_frequency=data.download_frequency,
|
|
source_id=data.source_id,
|
|
)
|
|
session.add(channel)
|
|
session.commit()
|
|
session.flush()
|
|
session.refresh(channel)
|
|
|
|
return channel.dict() if return_dict else channel
|
|
|
|
|
|
@run_after(save_channels_config)
|
|
@optional_session
|
|
def delete_channel(session: Session, *, channel_id: int):
|
|
try:
|
|
channel = session.query(Channel).filter_by(id=channel_id).one()
|
|
except NoResultFound:
|
|
raise UnknownChannel()
|
|
|
|
channel.delete_with_videos()
|
|
|
|
session.commit()
|
|
|
|
|
|
def download_channel(id_: int):
|
|
"""Create a Download record for a Channel's entire catalog. Start downloading."""
|
|
channel = get_channel(channel_id=id_, return_dict=False)
|
|
session = Session.object_session(channel)
|
|
download = channel.get_download()
|
|
if not download:
|
|
raise InvalidDownload(f'Channel {channel.name} does not have a download!')
|
|
download.renew(reset_attempts=True)
|
|
session.commit()
|