sources/uClasses.py - master - VolcanoByte/vbCinema

sources/uClasses.py
211 строк7 KB
Eugene Gavrilyuk
fix
31 дек 2025, 17:40
31 дек 2025, 17:40503f9b6
import datetime as dt

from PyQt6.QtCore import Qt, QSortFilterProxyModel
from PyQt6.QtGui import QFont
from PyQt6.QtSql import QSqlQueryModel
from PyQt6.QtWidgets import (QTableView, QListView, QComboBox)

from uConsts import AppConsts, StoreConsts, DoubleClick
from uDB import db
from uGlobal import MovieColumns, store
from uSQL import SQL_TAG_SELECT_ALL_BY_COUNT


class MovieTableView(QTableView):

    def __init__(self, parent):
        super().__init__(parent)

        self.parent = parent

        self.movieQuery = db.queryAllMovies()
        self.movieModel = QSqlQueryModel()
        self.movieModel.setQuery(self.movieQuery)

        self.movieProxy = MovieProxyModel(self.movieModel)
        self.setModel(self.movieProxy)

        self.editFunc = None
        self.runFunc = None
        self.viewPageKinopoiskFunc = None
        self.viewPageIMDBFunc = None

    def mouseDoubleClickEvent(self, event):
        _action = int(store.value(StoreConsts.OptionsDoubleClick,
                                  AppConsts.DefaultDoubleClick))

        if _action == DoubleClick.MovieRun:
            if self.runFunc:
                self.runFunc()
        elif _action == DoubleClick.MovieModify:
            if self.editFunc:
                self.editFunc()
        elif _action == DoubleClick.MovieIMDB:
            if self.viewPageIMDBFunc:
                self.viewPageIMDBFunc()
        elif _action == DoubleClick.MovieKinopoisk:
            if self.viewPageKinopoiskFunc:
                self.viewPageKinopoiskFunc()


class MovieProxyModel(QSortFilterProxyModel):
    """Промежуточная модель для фильтрации, сортировки и цветового выделения"""

    def __init__(self, model: QSqlQueryModel):
        super().__init__()

        self.isWanted = None
        self.isWatched = None

        self.sortOrder = Qt.SortOrder.AscendingOrder
        self.sortColumn = 2

        self.setSourceModel(model)

    def headerData(self, section, orientation, role=None):
        if role == Qt.ItemDataRole.DisplayRole:
            if orientation == Qt.Orientation.Horizontal:
                if section > len(MovieColumns) - 1:
                    print(section, len(MovieColumns))
                else:
                    return MovieColumns[section][1]

    @staticmethod
    def tryGetFloat(value) -> (bool, float):
        if value:
            try:
                return True, float(value)
            except ValueError:
                return False, None
        else:
            return False, None

    def data(self, index, role):
        if role == Qt.ItemDataRole.DisplayRole:
            if (index.column() < len(MovieColumns) and
                    MovieColumns[index.column()][0] in ['fldMovieAddedAt',
                                                        'fldMovieWatchedAt']):
                src_index = self.mapToSource(index)
                _dt = self.sourceModel().data(src_index, role)

                isFloat, _dt_float = self.tryGetFloat(_dt)
                if isFloat:
                    return dt.datetime.fromtimestamp(_dt_float).strftime(
                        "%Y-%m-%d %H:%M:%S")

        return QSortFilterProxyModel.data(self, index, role)

    def sort(self, column, order=None):
        if MovieColumns[column][5]:
            _order = order
        else:
            if order == Qt.SortOrder.AscendingOrder:
                _order = Qt.SortOrder.DescendingOrder
            else:
                _order = Qt.SortOrder.AscendingOrder

        self.sortOrder = _order
        self.sortColumn = column

        super().sort(column, _order)

    def isFilters(self) -> bool:
        """True, если установлены какие-.либо фильтры"""
        return bool(self.isWanted) or self.isWatched is not None

    def clearFilters(self):
        """Сброс фильтров"""
        self.isWanted = None
        self.isWatched = None

    def filterAcceptsRow(self, source_row, source_parent):
        watched = self.sourceModel().index(source_row, 9,
                                           source_parent).data()
        wanted = self.sourceModel().index(source_row, 10,
                                          source_parent).data()

        _result = True
        if self.isWatched is not None:
            _result = watched == self.isWatched

        if self.isWanted:
            _result = _result and bool(wanted)

        return _result


class TagListView(QListView):
    def __init__(self, parent):
        super().__init__(parent)

        self.tagsSelected = set()
        self.refreshFunc = None

        self.tagModel = TagQueryModel(self)
        self.tagModel.setQuery(SQL_TAG_SELECT_ALL_BY_COUNT)
        self.setModel(self.tagModel)
        self.setModelColumn(1)

    def refresh(self):
        if self.refreshFunc:
            if self.tagsSelected:
                self.refreshFunc(db.queryTagsMovies(self.tagsSelected))
            else:
                self.refreshFunc(db.queryAllMovies())

    def clearTags(self):
        self.tagsSelected.clear()

        if self.refreshFunc:
            self.refreshFunc(db.queryAllMovies())

    def mouseDoubleClickEvent(self, event):
        _item = self.indexAt(event.pos())
        if _item is None:
            return

        _name = _item.data()
        _id = db.getTagId(_name)
        if _id in self.tagsSelected:
            self.tagsSelected.remove(_id)
        else:
            self.tagsSelected.add(_id)

        self.refresh()

    def checkIsTagsExists(self):
        """Метод вызывается после удаления заметки и после процедуры
        DB.prepareTags и убирает удаленные теги из self.tagsSelected,
        затем пересчитывает заметки."""
        self.tagsSelected = set(filter(lambda n: db.getTagName(n) is not None,
                                       self.tagsSelected))
        self.refresh()


class TagQueryModel(QSqlQueryModel):
    def __init__(self, parent):
        super().__init__()

        self.parent = parent

    def data(self, item, role=None):
        res = QSqlQueryModel.data(self, item, role)

        if role == Qt.ItemDataRole.FontRole:
            _id = db.getTagId(item.data())
            if _id in self.parent.tagsSelected:
                font = QFont()
                font.setBold(True)
                return font
        return res


class TagComboBox(QComboBox):
    def __init__(self, parent):
        super().__init__(parent)

        # Модель для тегов ComboBox
        self.tagComboBoxModel = QSqlQueryModel(self)
        self.tagComboBoxModel.setQuery(SQL_TAG_SELECT_ALL_BY_COUNT)
        self.setModel(self.tagComboBoxModel)
        self.setModelColumn(1)