mirror of
https://github.com/ynput/ayon-core.git
synced 2025-12-24 21:04:40 +01:00
1094 lines
41 KiB
Python
1094 lines
41 KiB
Python
import os
|
|
import subprocess
|
|
import sys
|
|
from functools import partial
|
|
|
|
from Qt import QtWidgets, QtCore, QtGui
|
|
from Qt.QtCore import Qt
|
|
|
|
from openpype.tools.settings import (
|
|
ProjectListWidget,
|
|
style
|
|
)
|
|
|
|
from openpype.api import get_local_site_id
|
|
from openpype.lib import PypeLogger
|
|
|
|
from avalon.tools.delegates import pretty_timestamp
|
|
from avalon.vendor import qtawesome
|
|
|
|
from openpype.modules.sync_server.tray.models import (
|
|
SyncRepresentationSummaryModel,
|
|
SyncRepresentationDetailModel
|
|
)
|
|
|
|
from openpype.modules.sync_server.tray import lib
|
|
from openpype.modules.sync_server.tray import delegates
|
|
|
|
log = PypeLogger().get_logger("SyncServer")
|
|
|
|
|
|
class SyncProjectListWidget(ProjectListWidget):
|
|
"""
|
|
Lists all projects that are synchronized to choose from
|
|
"""
|
|
|
|
def __init__(self, sync_server, parent):
|
|
super(SyncProjectListWidget, self).__init__(parent)
|
|
self.sync_server = sync_server
|
|
self.project_list.setContextMenuPolicy(QtCore.Qt.CustomContextMenu)
|
|
self.project_list.customContextMenuRequested.connect(
|
|
self._on_context_menu)
|
|
self.project_name = None
|
|
self.local_site = None
|
|
self.icons = {}
|
|
|
|
self.layout().setContentsMargins(0, 0, 0, 0)
|
|
|
|
def validate_context_change(self):
|
|
return True
|
|
|
|
def refresh(self):
|
|
model = self.project_list.model()
|
|
model.clear()
|
|
|
|
project_name = None
|
|
for project_name in self.sync_server.sync_project_settings.\
|
|
keys():
|
|
if self.sync_server.is_paused() or \
|
|
self.sync_server.is_project_paused(project_name):
|
|
icon = self._get_icon("paused")
|
|
else:
|
|
icon = self._get_icon("synced")
|
|
|
|
model.appendRow(QtGui.QStandardItem(icon, project_name))
|
|
|
|
if len(self.sync_server.sync_project_settings.keys()) == 0:
|
|
model.appendRow(QtGui.QStandardItem(lib.DUMMY_PROJECT))
|
|
|
|
self.current_project = self.project_list.currentIndex().data(
|
|
QtCore.Qt.DisplayRole
|
|
)
|
|
if not self.current_project:
|
|
self.current_project = self.project_list.model().item(0). \
|
|
data(QtCore.Qt.DisplayRole)
|
|
|
|
if project_name:
|
|
self.local_site = self.sync_server.get_active_site(project_name)
|
|
|
|
def _get_icon(self, status):
|
|
if not self.icons.get(status):
|
|
resource_path = os.path.dirname(__file__)
|
|
resource_path = os.path.join(resource_path, "..",
|
|
"resources")
|
|
pix_url = "{}/{}.png".format(resource_path, status)
|
|
icon = QtGui.QIcon(pix_url)
|
|
self.icons[status] = icon
|
|
else:
|
|
icon = self.icons[status]
|
|
return icon
|
|
|
|
def _on_context_menu(self, point):
|
|
point_index = self.project_list.indexAt(point)
|
|
if not point_index.isValid():
|
|
return
|
|
|
|
self.project_name = point_index.data(QtCore.Qt.DisplayRole)
|
|
|
|
menu = QtWidgets.QMenu(self)
|
|
actions_mapping = {}
|
|
|
|
can_edit = self.model.can_edit
|
|
|
|
if can_edit:
|
|
if self.sync_server.is_project_paused(self.project_name):
|
|
action = QtWidgets.QAction("Unpause")
|
|
actions_mapping[action] = self._unpause
|
|
else:
|
|
action = QtWidgets.QAction("Pause")
|
|
actions_mapping[action] = self._pause
|
|
menu.addAction(action)
|
|
|
|
if self.local_site == get_local_site_id():
|
|
action = QtWidgets.QAction("Clear local project")
|
|
actions_mapping[action] = self._clear_project
|
|
menu.addAction(action)
|
|
|
|
result = menu.exec_(QtGui.QCursor.pos())
|
|
if result:
|
|
to_run = actions_mapping[result]
|
|
if to_run:
|
|
to_run()
|
|
|
|
def _pause(self):
|
|
if self.project_name:
|
|
self.sync_server.pause_project(self.project_name)
|
|
self.project_name = None
|
|
self.refresh()
|
|
|
|
def _unpause(self):
|
|
if self.project_name:
|
|
self.sync_server.unpause_project(self.project_name)
|
|
self.project_name = None
|
|
self.refresh()
|
|
|
|
def _clear_project(self):
|
|
if self.project_name:
|
|
self.sync_server.clear_project(self.project_name, self.local_site)
|
|
self.project_name = None
|
|
self.refresh()
|
|
|
|
|
|
class _SyncRepresentationWidget(QtWidgets.QWidget):
|
|
"""
|
|
Summary dialog with list of representations that matches current
|
|
settings 'local_site' and 'remote_site'.
|
|
"""
|
|
active_changed = QtCore.Signal() # active index changed
|
|
message_generated = QtCore.Signal(str)
|
|
|
|
def _selection_changed(self, _new_selected, _all_selected):
|
|
idxs = self.selection_model.selectedRows()
|
|
self._selected_ids = set()
|
|
|
|
for index in idxs:
|
|
self._selected_ids.add(self.model.data(index, Qt.UserRole))
|
|
|
|
def _set_selection(self):
|
|
"""
|
|
Sets selection to 'self._selected_id' if exists.
|
|
|
|
Keep selection during model refresh.
|
|
"""
|
|
existing_ids = set()
|
|
for selected_id in self._selected_ids:
|
|
index = self.model.get_index(selected_id)
|
|
if index and index.isValid():
|
|
mode = QtCore.QItemSelectionModel.Select | \
|
|
QtCore.QItemSelectionModel.Rows
|
|
self.selection_model.select(index, mode)
|
|
existing_ids.add(selected_id)
|
|
|
|
self._selected_ids = existing_ids
|
|
|
|
def _double_clicked(self, index):
|
|
"""
|
|
Opens representation dialog with all files after doubleclick
|
|
"""
|
|
# priority editing
|
|
if self.model.can_edit:
|
|
column_name = self.model.get_column(index.column())
|
|
if column_name[0] in self.model.EDITABLE_COLUMNS:
|
|
self.model.is_editing = True
|
|
self.table_view.openPersistentEditor(index)
|
|
return
|
|
|
|
_id = self.model.data(index, Qt.UserRole)
|
|
detail_window = SyncServerDetailWindow(
|
|
self.sync_server, _id, self.model.project, parent=self)
|
|
detail_window.exec()
|
|
|
|
def _on_context_menu(self, point):
|
|
"""
|
|
Shows menu with loader actions on Right-click.
|
|
|
|
Supports multiple selects - adds all available actions, each
|
|
action handles if it appropriate for item itself, if not it skips.
|
|
"""
|
|
is_multi = len(self._selected_ids) > 1
|
|
point_index = self.table_view.indexAt(point)
|
|
if not point_index.isValid() and not is_multi:
|
|
return
|
|
|
|
if is_multi:
|
|
index = self.model.get_index(list(self._selected_ids)[0])
|
|
item = self.model.data(index, lib.FullItemRole)
|
|
else:
|
|
item = self.model.data(point_index, lib.FullItemRole)
|
|
|
|
can_edit = self.model.can_edit
|
|
action_kwarg_map, actions_mapping, menu = self._prepare_menu(item,
|
|
is_multi,
|
|
can_edit)
|
|
|
|
result = menu.exec_(QtGui.QCursor.pos())
|
|
if result:
|
|
to_run = actions_mapping[result]
|
|
to_run_kwargs = action_kwarg_map.get(result, {})
|
|
if to_run:
|
|
to_run(**to_run_kwargs)
|
|
|
|
self.model.refresh()
|
|
|
|
def _prepare_menu(self, item, is_multi, can_edit):
|
|
menu = QtWidgets.QMenu(self)
|
|
|
|
actions_mapping = {}
|
|
action_kwarg_map = {}
|
|
|
|
active_site = self.model.active_site
|
|
remote_site = self.model.remote_site
|
|
|
|
local_progress = item.local_progress
|
|
remote_progress = item.remote_progress
|
|
|
|
project = self.model.project
|
|
|
|
for site, progress in {active_site: local_progress,
|
|
remote_site: remote_progress}.items():
|
|
provider = self.sync_server.get_provider_for_site(project, site)
|
|
if provider == 'local_drive':
|
|
if 'studio' in site:
|
|
txt = " studio version"
|
|
else:
|
|
txt = " local version"
|
|
action = QtWidgets.QAction("Open in explorer" + txt)
|
|
if progress == 1.0 or is_multi:
|
|
actions_mapping[action] = self._open_in_explorer
|
|
action_kwarg_map[action] = \
|
|
self._get_action_kwargs(site)
|
|
menu.addAction(action)
|
|
|
|
if can_edit and (remote_progress == 1.0 or is_multi):
|
|
action = QtWidgets.QAction("Re-sync Active site")
|
|
action_kwarg_map[action] = self._get_action_kwargs(active_site)
|
|
actions_mapping[action] = self._reset_site
|
|
menu.addAction(action)
|
|
|
|
if can_edit and (local_progress == 1.0 or is_multi):
|
|
action = QtWidgets.QAction("Re-sync Remote site")
|
|
action_kwarg_map[action] = self._get_action_kwargs(remote_site)
|
|
actions_mapping[action] = self._reset_site
|
|
menu.addAction(action)
|
|
|
|
if can_edit and active_site == get_local_site_id():
|
|
action = QtWidgets.QAction("Completely remove from local")
|
|
action_kwarg_map[action] = self._get_action_kwargs(active_site)
|
|
actions_mapping[action] = self._remove_site
|
|
menu.addAction(action)
|
|
|
|
if can_edit:
|
|
action = QtWidgets.QAction("Change priority")
|
|
action_kwarg_map[action] = self._get_action_kwargs(active_site)
|
|
actions_mapping[action] = self._change_priority
|
|
menu.addAction(action)
|
|
|
|
# # temp for testing only !!!
|
|
# action = QtWidgets.QAction("Download")
|
|
# action_kwarg_map[action] = self._get_action_kwargs(active_site)
|
|
# actions_mapping[action] = self._add_site
|
|
# menu.addAction(action)
|
|
|
|
if not actions_mapping:
|
|
action = QtWidgets.QAction("< No action >")
|
|
actions_mapping[action] = None
|
|
menu.addAction(action)
|
|
|
|
return action_kwarg_map, actions_mapping, menu
|
|
|
|
def _pause(self, selected_ids=None):
|
|
log.debug("Pause {}".format(selected_ids))
|
|
for representation_id in selected_ids:
|
|
item = lib.get_item_by_id(self.model, representation_id)
|
|
if item.status not in [lib.STATUS[0], lib.STATUS[1]]:
|
|
continue
|
|
for site_name in [self.model.active_site, self.model.remote_site]:
|
|
check_progress = self._get_progress(item, site_name)
|
|
if check_progress < 1:
|
|
self.sync_server.pause_representation(self.model.project,
|
|
representation_id,
|
|
site_name)
|
|
|
|
self.message_generated.emit("Paused {}".format(representation_id))
|
|
|
|
def _unpause(self, selected_ids=None):
|
|
log.debug("UnPause {}".format(selected_ids))
|
|
for representation_id in selected_ids:
|
|
item = lib.get_item_by_id(self.model, representation_id)
|
|
if item.status not in lib.STATUS[3]:
|
|
continue
|
|
for site_name in [self.model.active_site, self.model.remote_site]:
|
|
check_progress = self._get_progress(item, site_name)
|
|
if check_progress < 1:
|
|
self.sync_server.unpause_representation(
|
|
self.model.project,
|
|
representation_id,
|
|
site_name)
|
|
|
|
self.message_generated.emit("Unpause {}".format(representation_id))
|
|
|
|
# temporary here for testing, will be removed TODO
|
|
def _add_site(self, selected_ids=None, site_name=None):
|
|
log.debug("Add site {}:{}".format(selected_ids, site_name))
|
|
for representation_id in selected_ids:
|
|
item = lib.get_item_by_id(self.model, representation_id)
|
|
if item.local_site == site_name or item.remote_site == site_name:
|
|
# site already exists skip
|
|
continue
|
|
|
|
try:
|
|
self.sync_server.add_site(
|
|
self.model.project,
|
|
representation_id,
|
|
site_name)
|
|
self.message_generated.emit(
|
|
"Site {} added for {}".format(site_name,
|
|
representation_id))
|
|
except ValueError as exp:
|
|
self.message_generated.emit("Error {}".format(str(exp)))
|
|
self.sync_server.reset_timer()
|
|
|
|
def _remove_site(self, selected_ids=None, site_name=None):
|
|
"""
|
|
Removes site record AND files.
|
|
|
|
This is ONLY for representations stored on local site, which
|
|
cannot be same as SyncServer.DEFAULT_SITE.
|
|
|
|
This could only happen when artist work on local machine, not
|
|
connected to studio mounted drives.
|
|
"""
|
|
log.debug("Remove site {}:{}".format(selected_ids, site_name))
|
|
for representation_id in selected_ids:
|
|
log.info("Removing {}".format(representation_id))
|
|
try:
|
|
self.sync_server.remove_site(
|
|
self.model.project,
|
|
representation_id,
|
|
site_name,
|
|
True)
|
|
self.message_generated.emit(
|
|
"Site {} removed".format(site_name))
|
|
except ValueError as exp:
|
|
self.message_generated.emit("Error {}".format(str(exp)))
|
|
|
|
self.model.refresh(
|
|
load_records=self.model._rec_loaded)
|
|
self.sync_server.reset_timer()
|
|
|
|
def _reset_site(self, selected_ids=None, site_name=None):
|
|
"""
|
|
Removes errors or success metadata for particular file >> forces
|
|
redo of upload/download
|
|
"""
|
|
log.debug("Reset site {}:{}".format(selected_ids, site_name))
|
|
for representation_id in selected_ids:
|
|
item = lib.get_item_by_id(self.model, representation_id)
|
|
check_progress = self._get_progress(item, site_name, True)
|
|
|
|
# do not reset if opposite side is not fully there
|
|
if check_progress != 1:
|
|
log.debug("Not fully available {} on other side, skipping".
|
|
format(check_progress))
|
|
continue
|
|
|
|
self.sync_server.reset_provider_for_file(
|
|
self.model.project,
|
|
representation_id,
|
|
site_name=site_name,
|
|
force=True)
|
|
|
|
self.model.refresh(
|
|
load_records=self.model._rec_loaded)
|
|
self.sync_server.reset_timer()
|
|
|
|
def _open_in_explorer(self, selected_ids=None, site_name=None):
|
|
log.debug("Open in Explorer {}:{}".format(selected_ids, site_name))
|
|
for selected_id in selected_ids:
|
|
item = lib.get_item_by_id(self.model, selected_id)
|
|
if not item:
|
|
return
|
|
|
|
fpath = item.path
|
|
project = self.model.project
|
|
fpath = self.sync_server.get_local_file_path(project,
|
|
site_name,
|
|
fpath)
|
|
|
|
fpath = os.path.normpath(os.path.dirname(fpath))
|
|
if os.path.isdir(fpath):
|
|
if 'win' in sys.platform: # windows
|
|
subprocess.Popen('explorer "%s"' % fpath)
|
|
elif sys.platform == 'darwin': # macOS
|
|
subprocess.Popen(['open', fpath])
|
|
else: # linux
|
|
try:
|
|
subprocess.Popen(['xdg-open', fpath])
|
|
except OSError:
|
|
raise OSError('unsupported xdg-open call??')
|
|
|
|
def _change_priority(self, **kwargs):
|
|
"""Open editor to change priority on first selected row"""
|
|
if self._selected_ids:
|
|
# get_index returns dummy index with column equals to 0
|
|
index = self.model.get_index(list(self._selected_ids)[0])
|
|
column_no = self.model.get_header_index("priority") # real column
|
|
real_index = self.model.index(index.row(), column_no)
|
|
self.model.is_editing = True
|
|
self.table_view.openPersistentEditor(real_index)
|
|
|
|
def _get_progress(self, item, site_name, opposite=False):
|
|
"""Returns progress value according to site (side)"""
|
|
progress = {'local': item.local_progress,
|
|
'remote': item.remote_progress}
|
|
side = 'remote'
|
|
if site_name == self.model.active_site:
|
|
side = 'local'
|
|
if opposite:
|
|
side = 'remote' if side == 'local' else 'local'
|
|
|
|
return progress[side]
|
|
|
|
def _get_action_kwargs(self, site_name):
|
|
"""Default format of kwargs for action"""
|
|
return {"selected_ids": self._selected_ids, "site_name": site_name}
|
|
|
|
def _save_scrollbar(self):
|
|
self._scrollbar_pos = self.table_view.verticalScrollBar().value()
|
|
|
|
def _set_scrollbar(self):
|
|
if self._scrollbar_pos:
|
|
self.table_view.verticalScrollBar().setValue(self._scrollbar_pos)
|
|
|
|
|
|
class SyncRepresentationSummaryWidget(_SyncRepresentationWidget):
|
|
|
|
default_widths = (
|
|
("asset", 190),
|
|
("subset", 170),
|
|
("version", 60),
|
|
("representation", 145),
|
|
("local_site", 160),
|
|
("remote_site", 160),
|
|
("files_count", 50),
|
|
("files_size", 60),
|
|
("priority", 70),
|
|
("status", 110)
|
|
)
|
|
|
|
def __init__(self, sync_server, project=None, parent=None):
|
|
super(SyncRepresentationSummaryWidget, self).__init__(parent)
|
|
|
|
self.sync_server = sync_server
|
|
|
|
self._selected_ids = set() # keep last selected _id
|
|
|
|
txt_filter = QtWidgets.QLineEdit()
|
|
txt_filter.setPlaceholderText("Quick filter representations..")
|
|
txt_filter.setClearButtonEnabled(True)
|
|
txt_filter.addAction(
|
|
qtawesome.icon("fa.filter", color="gray"),
|
|
QtWidgets.QLineEdit.LeadingPosition)
|
|
self.txt_filter = txt_filter
|
|
|
|
self._scrollbar_pos = None
|
|
|
|
top_bar_layout = QtWidgets.QHBoxLayout()
|
|
top_bar_layout.addWidget(self.txt_filter)
|
|
|
|
table_view = QtWidgets.QTableView()
|
|
headers = [item[0] for item in self.default_widths]
|
|
|
|
model = SyncRepresentationSummaryModel(sync_server, headers, project,
|
|
parent=self)
|
|
table_view.setModel(model)
|
|
table_view.setContextMenuPolicy(QtCore.Qt.CustomContextMenu)
|
|
table_view.setSelectionMode(
|
|
QtWidgets.QAbstractItemView.ExtendedSelection)
|
|
table_view.setSelectionBehavior(
|
|
QtWidgets.QAbstractItemView.SelectRows)
|
|
table_view.horizontalHeader().setSortIndicator(
|
|
-1, Qt.AscendingOrder)
|
|
table_view.setAlternatingRowColors(True)
|
|
table_view.verticalHeader().hide()
|
|
table_view.viewport().setAttribute(QtCore.Qt.WA_Hover, True)
|
|
|
|
column = table_view.model().get_header_index("local_site")
|
|
delegate = delegates.ImageDelegate(self)
|
|
table_view.setItemDelegateForColumn(column, delegate)
|
|
|
|
column = table_view.model().get_header_index("remote_site")
|
|
delegate = delegates.ImageDelegate(self)
|
|
table_view.setItemDelegateForColumn(column, delegate)
|
|
|
|
column = table_view.model().get_header_index("priority")
|
|
priority_delegate = delegates.PriorityDelegate(self)
|
|
table_view.setItemDelegateForColumn(column, priority_delegate)
|
|
|
|
layout = QtWidgets.QVBoxLayout(self)
|
|
layout.setContentsMargins(0, 0, 0, 0)
|
|
layout.addLayout(top_bar_layout)
|
|
layout.addWidget(table_view)
|
|
|
|
self.table_view = table_view
|
|
self.model = model
|
|
|
|
horizontal_header = HorizontalHeader(self)
|
|
|
|
table_view.setHorizontalHeader(horizontal_header)
|
|
table_view.setSortingEnabled(True)
|
|
|
|
for column_name, width in self.default_widths:
|
|
idx = model.get_header_index(column_name)
|
|
table_view.setColumnWidth(idx, width)
|
|
|
|
table_view.doubleClicked.connect(self._double_clicked)
|
|
self.txt_filter.textChanged.connect(lambda: model.set_word_filter(
|
|
self.txt_filter.text()))
|
|
table_view.customContextMenuRequested.connect(self._on_context_menu)
|
|
|
|
model.refresh_started.connect(self._save_scrollbar)
|
|
model.refresh_finished.connect(self._set_scrollbar)
|
|
model.modelReset.connect(self._set_selection)
|
|
|
|
self.selection_model = self.table_view.selectionModel()
|
|
self.selection_model.selectionChanged.connect(self._selection_changed)
|
|
|
|
def _prepare_menu(self, item, is_multi, can_edit):
|
|
action_kwarg_map, actions_mapping, menu = \
|
|
super()._prepare_menu(item, is_multi, can_edit)
|
|
|
|
if can_edit and (
|
|
item.status in [lib.STATUS[0], lib.STATUS[1]] or is_multi):
|
|
action = QtWidgets.QAction("Pause in queue")
|
|
actions_mapping[action] = self._pause
|
|
# pause handles which site_name it will pause itself
|
|
action_kwarg_map[action] = {"selected_ids": self._selected_ids}
|
|
menu.addAction(action)
|
|
|
|
if can_edit and (item.status == lib.STATUS[3] or is_multi):
|
|
action = QtWidgets.QAction("Unpause in queue")
|
|
actions_mapping[action] = self._unpause
|
|
action_kwarg_map[action] = {"selected_ids": self._selected_ids}
|
|
menu.addAction(action)
|
|
|
|
return action_kwarg_map, actions_mapping, menu
|
|
|
|
|
|
class SyncServerDetailWindow(QtWidgets.QDialog):
|
|
"""Wrapper window for SyncRepresentationDetailWidget
|
|
|
|
Creates standalone window with list of files for selected repre_id.
|
|
"""
|
|
def __init__(self, sync_server, _id, project, parent=None):
|
|
log.debug(
|
|
"!!! SyncServerDetailWindow _id:: {}".format(_id))
|
|
super(SyncServerDetailWindow, self).__init__(parent)
|
|
self.setWindowFlags(QtCore.Qt.Window)
|
|
self.setFocusPolicy(QtCore.Qt.StrongFocus)
|
|
|
|
self.setStyleSheet(style.load_stylesheet())
|
|
self.setWindowIcon(QtGui.QIcon(style.app_icon_path()))
|
|
self.resize(1000, 400)
|
|
|
|
body = QtWidgets.QWidget()
|
|
footer = QtWidgets.QWidget()
|
|
footer.setFixedHeight(20)
|
|
|
|
container = SyncRepresentationDetailWidget(sync_server, _id, project,
|
|
parent=self)
|
|
body_layout = QtWidgets.QHBoxLayout(body)
|
|
body_layout.addWidget(container)
|
|
body_layout.setContentsMargins(0, 0, 0, 0)
|
|
|
|
self.message = QtWidgets.QLabel()
|
|
self.message.hide()
|
|
|
|
footer_layout = QtWidgets.QVBoxLayout(footer)
|
|
footer_layout.addWidget(self.message)
|
|
footer_layout.setContentsMargins(0, 0, 0, 0)
|
|
|
|
layout = QtWidgets.QVBoxLayout(self)
|
|
layout.addWidget(body)
|
|
layout.addWidget(footer)
|
|
|
|
self.setLayout(body_layout)
|
|
self.setWindowTitle("Sync Representation Detail")
|
|
|
|
|
|
class SyncRepresentationDetailWidget(_SyncRepresentationWidget):
|
|
"""
|
|
Widget to display list of synchronizable files for single repre.
|
|
|
|
Args:
|
|
_id (str): representation _id
|
|
project (str): name of project with repre
|
|
parent (QDialog): SyncServerDetailWindow
|
|
"""
|
|
active_changed = QtCore.Signal() # active index changed
|
|
|
|
default_widths = (
|
|
("file", 290),
|
|
("local_site", 185),
|
|
("remote_site", 185),
|
|
("size", 60),
|
|
("priority", 60),
|
|
("status", 110)
|
|
)
|
|
|
|
def __init__(self, sync_server, _id=None, project=None, parent=None):
|
|
super(SyncRepresentationDetailWidget, self).__init__(parent)
|
|
|
|
log.debug("Representation_id:{}".format(_id))
|
|
self.project = project
|
|
|
|
self.sync_server = sync_server
|
|
|
|
self.representation_id = _id
|
|
self._selected_ids = set()
|
|
|
|
self.txt_filter = QtWidgets.QLineEdit()
|
|
self.txt_filter.setPlaceholderText("Quick filter representation..")
|
|
self.txt_filter.setClearButtonEnabled(True)
|
|
self.txt_filter.addAction(qtawesome.icon("fa.filter", color="gray"),
|
|
QtWidgets.QLineEdit.LeadingPosition)
|
|
|
|
self._scrollbar_pos = None
|
|
|
|
top_bar_layout = QtWidgets.QHBoxLayout()
|
|
top_bar_layout.addWidget(self.txt_filter)
|
|
|
|
table_view = QtWidgets.QTableView()
|
|
headers = [item[0] for item in self.default_widths]
|
|
|
|
model = SyncRepresentationDetailModel(sync_server, headers, _id,
|
|
project)
|
|
model.is_running = True
|
|
|
|
table_view.setModel(model)
|
|
table_view.setContextMenuPolicy(QtCore.Qt.CustomContextMenu)
|
|
table_view.setSelectionMode(
|
|
QtWidgets.QAbstractItemView.ExtendedSelection)
|
|
table_view.setSelectionBehavior(
|
|
QtWidgets.QTableView.SelectRows)
|
|
table_view.horizontalHeader().setSortIndicator(-1, Qt.AscendingOrder)
|
|
table_view.horizontalHeader().setSortIndicatorShown(True)
|
|
table_view.setAlternatingRowColors(True)
|
|
table_view.verticalHeader().hide()
|
|
|
|
column = model.get_header_index("local_site")
|
|
delegate = delegates.ImageDelegate(self)
|
|
table_view.setItemDelegateForColumn(column, delegate)
|
|
|
|
column = model.get_header_index("remote_site")
|
|
delegate = delegates.ImageDelegate(self)
|
|
table_view.setItemDelegateForColumn(column, delegate)
|
|
|
|
if model.can_edit:
|
|
column = table_view.model().get_header_index("priority")
|
|
priority_delegate = delegates.PriorityDelegate(self)
|
|
table_view.setItemDelegateForColumn(column, priority_delegate)
|
|
|
|
layout = QtWidgets.QVBoxLayout(self)
|
|
layout.setContentsMargins(0, 0, 0, 0)
|
|
layout.addLayout(top_bar_layout)
|
|
layout.addWidget(table_view)
|
|
|
|
self.model = model
|
|
|
|
self.selection_model = table_view.selectionModel()
|
|
self.selection_model.selectionChanged.connect(self._selection_changed)
|
|
|
|
horizontal_header = HorizontalHeader(self)
|
|
|
|
table_view.setHorizontalHeader(horizontal_header)
|
|
table_view.setSortingEnabled(True)
|
|
|
|
for column_name, width in self.default_widths:
|
|
idx = model.get_header_index(column_name)
|
|
table_view.setColumnWidth(idx, width)
|
|
|
|
self.table_view = table_view
|
|
|
|
self.txt_filter.textChanged.connect(lambda: model.set_word_filter(
|
|
self.txt_filter.text()))
|
|
table_view.doubleClicked.connect(self._double_clicked)
|
|
table_view.customContextMenuRequested.connect(self._on_context_menu)
|
|
|
|
model.refresh_started.connect(self._save_scrollbar)
|
|
model.refresh_finished.connect(self._set_scrollbar)
|
|
model.modelReset.connect(self._set_selection)
|
|
|
|
def _double_clicked(self, index):
|
|
"""
|
|
Opens representation dialog with all files after doubleclick
|
|
"""
|
|
# priority editing
|
|
if self.model.can_edit:
|
|
column_name = self.model.get_column(index.column())
|
|
if column_name[0] in self.model.EDITABLE_COLUMNS:
|
|
self.model.is_editing = True
|
|
self.table_view.openPersistentEditor(index)
|
|
return
|
|
|
|
def _show_detail(self, selected_ids=None):
|
|
"""
|
|
Shows windows with error message for failed sync of a file.
|
|
"""
|
|
detail_window = SyncRepresentationErrorWindow(self.model, selected_ids)
|
|
|
|
detail_window.exec()
|
|
|
|
def _prepare_menu(self, item, is_multi, can_edit):
|
|
"""Adds view (and model) dependent actions to default ones"""
|
|
action_kwarg_map, actions_mapping, menu = \
|
|
super()._prepare_menu(item, is_multi, can_edit)
|
|
|
|
if item.status == lib.STATUS[2] or is_multi:
|
|
action = QtWidgets.QAction("Open error detail")
|
|
actions_mapping[action] = self._show_detail
|
|
action_kwarg_map[action] = {"selected_ids": self._selected_ids}
|
|
|
|
menu.addAction(action)
|
|
|
|
return action_kwarg_map, actions_mapping, menu
|
|
|
|
def _reset_site(self, selected_ids=None, site_name=None):
|
|
"""
|
|
Removes errors or success metadata for particular file >> forces
|
|
redo of upload/download
|
|
"""
|
|
for file_id in selected_ids:
|
|
item = lib.get_item_by_id(self.model, file_id)
|
|
check_progress = self._get_progress(item, site_name, True)
|
|
|
|
# do not reset if opposite side is not fully there
|
|
if check_progress != 1:
|
|
log.debug("Not fully available {} on other side, skipping".
|
|
format(check_progress))
|
|
continue
|
|
|
|
self.sync_server.reset_provider_for_file(
|
|
self.model.project,
|
|
self.representation_id,
|
|
site_name=site_name,
|
|
file_id=file_id,
|
|
force=True)
|
|
self.model.refresh(
|
|
load_records=self.model._rec_loaded)
|
|
|
|
|
|
class SyncRepresentationErrorWindow(QtWidgets.QDialog):
|
|
"""Wrapper window to show errors during sync on file(s)"""
|
|
def __init__(self, model, selected_ids, parent=None):
|
|
super(SyncRepresentationErrorWindow, self).__init__(parent)
|
|
self.setWindowFlags(QtCore.Qt.Window)
|
|
self.setFocusPolicy(QtCore.Qt.StrongFocus)
|
|
|
|
self.setStyleSheet(style.load_stylesheet())
|
|
self.setWindowIcon(QtGui.QIcon(style.app_icon_path()))
|
|
self.resize(900, 150)
|
|
|
|
body = QtWidgets.QWidget()
|
|
|
|
container = SyncRepresentationErrorWidget(model,
|
|
selected_ids,
|
|
parent=self)
|
|
body_layout = QtWidgets.QHBoxLayout(body)
|
|
body_layout.addWidget(container)
|
|
body_layout.setContentsMargins(0, 0, 0, 0)
|
|
|
|
message = QtWidgets.QLabel()
|
|
message.hide()
|
|
|
|
layout = QtWidgets.QVBoxLayout(self)
|
|
layout.addWidget(body)
|
|
|
|
self.setLayout(body_layout)
|
|
self.setWindowTitle("Sync Representation Error Detail")
|
|
|
|
|
|
class SyncRepresentationErrorWidget(QtWidgets.QWidget):
|
|
"""
|
|
Dialog to show when sync error happened, prints formatted error message
|
|
"""
|
|
def __init__(self, model, selected_ids, parent=None):
|
|
super(SyncRepresentationErrorWidget, self).__init__(parent)
|
|
|
|
layout = QtWidgets.QVBoxLayout(self)
|
|
|
|
no_errors = True
|
|
for file_id in selected_ids:
|
|
item = lib.get_item_by_id(model, file_id)
|
|
if not item.created_dt or not item.sync_dt or not item.error:
|
|
continue
|
|
|
|
no_errors = False
|
|
dt = max(item.created_dt, item.sync_dt)
|
|
|
|
txts = []
|
|
txts.append("{}: {}<br>".format("<b>Last update date</b>",
|
|
pretty_timestamp(dt)))
|
|
txts.append("{}: {}<br>".format("<b>Retries</b>",
|
|
str(item.tries)))
|
|
txts.append("{}: {}<br>".format("<b>Error message</b>",
|
|
item.error))
|
|
|
|
text_area = QtWidgets.QTextEdit("\n\n".join(txts))
|
|
text_area.setReadOnly(True)
|
|
layout.addWidget(text_area)
|
|
|
|
if no_errors:
|
|
text_area = QtWidgets.QTextEdit()
|
|
text_area.setText("<h4>No errors located</h4>")
|
|
text_area.setReadOnly(True)
|
|
layout.addWidget(text_area)
|
|
|
|
|
|
class HorizontalHeader(QtWidgets.QHeaderView):
|
|
"""Reiplemented QHeaderView to contain clickable changeable button"""
|
|
def __init__(self, parent=None):
|
|
super(HorizontalHeader, self).__init__(QtCore.Qt.Horizontal, parent)
|
|
self._parent = parent
|
|
self.checked_values = {}
|
|
|
|
self.setModel(self._parent.model)
|
|
|
|
self.setSectionsClickable(True)
|
|
|
|
self.menu_items_dict = {}
|
|
self.menu = None
|
|
self.header_cells = []
|
|
self.filter_buttons = {}
|
|
|
|
self.filter_icon = qtawesome.icon("fa.filter", color="gray")
|
|
self.filter_set_icon = qtawesome.icon("fa.filter", color="white")
|
|
|
|
self.init_layout()
|
|
|
|
self._resetting = False
|
|
|
|
@property
|
|
def model(self):
|
|
"""Keep model synchronized with parent widget"""
|
|
return self._parent.model
|
|
|
|
def init_layout(self):
|
|
"""Initial preparation of header's content"""
|
|
for column_idx in range(self.model.columnCount()):
|
|
column_name, column_label = self.model.get_column(column_idx)
|
|
filter_rec = self.model.get_filters().get(column_name)
|
|
if not filter_rec:
|
|
continue
|
|
|
|
icon = self.filter_icon
|
|
button = QtWidgets.QPushButton(icon, "", self)
|
|
|
|
button.setFixedSize(24, 24)
|
|
button.setStyleSheet(
|
|
"QPushButton::menu-indicator{width:0px;}"
|
|
"QPushButton{border: none;background: transparent;}")
|
|
button.clicked.connect(partial(self._get_menu,
|
|
column_name, column_idx))
|
|
button.setFlat(True)
|
|
self.filter_buttons[column_name] = button
|
|
|
|
def showEvent(self, event):
|
|
"""Paint header"""
|
|
super(HorizontalHeader, self).showEvent(event)
|
|
|
|
for i in range(len(self.header_cells)):
|
|
cell_content = self.header_cells[i]
|
|
cell_content.setGeometry(self.sectionViewportPosition(i), 0,
|
|
self.sectionSize(i) - 1, self.height())
|
|
|
|
cell_content.show()
|
|
|
|
def _set_filter_icon(self, column_name):
|
|
"""Set different states of button depending on its engagement"""
|
|
button = self.filter_buttons.get(column_name)
|
|
if button:
|
|
if self.checked_values.get(column_name):
|
|
button.setIcon(self.filter_set_icon)
|
|
else:
|
|
button.setIcon(self.filter_icon)
|
|
|
|
def _reset_filter(self, column_name):
|
|
"""
|
|
Remove whole column from filter >> not in $match at all (faster)
|
|
"""
|
|
self._resetting = True # mark changes to consume them
|
|
if self.checked_values.get(column_name) is not None:
|
|
self.checked_values.pop(column_name)
|
|
self._set_filter_icon(column_name)
|
|
self._filter_and_refresh_model_and_menu(column_name, True, True)
|
|
self._resetting = False
|
|
|
|
def _apply_filter(self, column_name, values, state):
|
|
"""
|
|
Sets 'values' to specific 'state' (checked/unchecked),
|
|
sends to model.
|
|
"""
|
|
if self._resetting: # event triggered by _resetting, skip it
|
|
return
|
|
|
|
self._update_checked_values(column_name, values, state)
|
|
self._set_filter_icon(column_name)
|
|
self._filter_and_refresh_model_and_menu(column_name, True, False)
|
|
|
|
def _apply_text_filter(self, column_name, items, line_edit):
|
|
"""
|
|
Resets all checkboxes, prefers inserted text.
|
|
"""
|
|
le_text = line_edit.text()
|
|
self._update_checked_values(column_name, items, 0) # reset other
|
|
if self.checked_values.get(column_name) is not None or \
|
|
le_text == '':
|
|
self.checked_values.pop(column_name) # reset during typing
|
|
|
|
if le_text:
|
|
self._update_checked_values(column_name, {le_text: le_text}, 2)
|
|
self._set_filter_icon(column_name)
|
|
self._filter_and_refresh_model_and_menu(column_name, True, True)
|
|
|
|
def _filter_and_refresh_model_and_menu(self, column_name,
|
|
model=True, menu=True):
|
|
"""
|
|
Refresh model and its content and possibly menu for big changes.
|
|
"""
|
|
if model:
|
|
self.model.set_column_filtering(self.checked_values)
|
|
self.model.refresh()
|
|
if menu:
|
|
self._menu_refresh(column_name)
|
|
|
|
def _get_menu(self, column_name, index):
|
|
"""Prepares content of menu for 'column_name'"""
|
|
menu = QtWidgets.QMenu(self)
|
|
filter_rec = self.model.get_filters()[column_name]
|
|
self.menu_items_dict[column_name] = filter_rec.values()
|
|
|
|
# text filtering only if labels same as values, not if codes are used
|
|
if 'text' in filter_rec.search_variants():
|
|
line_edit = QtWidgets.QLineEdit(menu)
|
|
line_edit.setClearButtonEnabled(True)
|
|
line_edit.addAction(self.filter_icon,
|
|
QtWidgets.QLineEdit.LeadingPosition)
|
|
|
|
line_edit.setFixedHeight(line_edit.height())
|
|
txt = ""
|
|
if self.checked_values.get(column_name):
|
|
txt = list(self.checked_values.get(column_name).keys())[0]
|
|
line_edit.setText(txt)
|
|
|
|
action_le = QtWidgets.QWidgetAction(menu)
|
|
action_le.setDefaultWidget(line_edit)
|
|
line_edit.textChanged.connect(
|
|
partial(self._apply_text_filter, column_name,
|
|
filter_rec.values(), line_edit))
|
|
menu.addAction(action_le)
|
|
menu.addSeparator()
|
|
|
|
if 'checkbox' in filter_rec.search_variants():
|
|
action_all = QtWidgets.QAction("All", self)
|
|
action_all.triggered.connect(partial(self._reset_filter,
|
|
column_name))
|
|
menu.addAction(action_all)
|
|
|
|
action_none = QtWidgets.QAction("Unselect all", self)
|
|
state_unchecked = 0
|
|
action_none.triggered.connect(partial(self._apply_filter,
|
|
column_name,
|
|
filter_rec.values(),
|
|
state_unchecked))
|
|
menu.addAction(action_none)
|
|
menu.addSeparator()
|
|
|
|
# nothing explicitly >> ALL implicitly >> first time
|
|
if self.checked_values.get(column_name) is None:
|
|
checked_keys = self.menu_items_dict[column_name].keys()
|
|
else:
|
|
checked_keys = self.checked_values[column_name]
|
|
|
|
for value, label in self.menu_items_dict[column_name].items():
|
|
checkbox = QtWidgets.QCheckBox(str(label), menu)
|
|
|
|
# temp
|
|
checkbox.setStyleSheet("QCheckBox{spacing: 5px;"
|
|
"padding:5px 5px 5px 5px;}")
|
|
if value in checked_keys:
|
|
checkbox.setChecked(True)
|
|
|
|
action = QtWidgets.QWidgetAction(menu)
|
|
action.setDefaultWidget(checkbox)
|
|
|
|
checkbox.stateChanged.connect(partial(self._apply_filter,
|
|
column_name, {value: label}))
|
|
menu.addAction(action)
|
|
|
|
self.menu = menu
|
|
|
|
self._show_menu(index, menu)
|
|
|
|
def _show_menu(self, index, menu):
|
|
"""Shows 'menu' under header column of 'index'"""
|
|
global_pos_point = self.mapToGlobal(
|
|
QtCore.QPoint(self.sectionViewportPosition(index), 0))
|
|
menu.setMinimumWidth(self.sectionSize(index))
|
|
menu.setMinimumHeight(self.height())
|
|
menu.exec_(QtCore.QPoint(global_pos_point.x(),
|
|
global_pos_point.y() + self.height()))
|
|
|
|
def _menu_refresh(self, column_name):
|
|
"""
|
|
Reset boxes after big change - word filtering or reset
|
|
"""
|
|
for action in self.menu.actions():
|
|
if not isinstance(action, QtWidgets.QWidgetAction):
|
|
continue
|
|
|
|
widget = action.defaultWidget()
|
|
if not isinstance(widget, QtWidgets.QCheckBox):
|
|
continue
|
|
|
|
if not self.checked_values.get(column_name) or \
|
|
widget.text() in self.checked_values[column_name].values():
|
|
widget.setChecked(True)
|
|
else:
|
|
widget.setChecked(False)
|
|
|
|
def _update_checked_values(self, column_name, values, state):
|
|
"""
|
|
Modify dictionary of set values in columns for filtering.
|
|
|
|
Modifies 'self.checked_values'
|
|
"""
|
|
copy_menu_items = dict(self.menu_items_dict[column_name])
|
|
checked = self.checked_values.get(column_name, copy_menu_items)
|
|
set_items = dict(values.items()) # prevent dict change during loop
|
|
for value, label in set_items.items():
|
|
if state == 2 and label: # checked
|
|
checked[value] = label
|
|
elif state == 0 and checked.get(value):
|
|
checked.pop(value)
|
|
|
|
self.checked_values[column_name] = checked
|
|
|
|
def paintEvent(self, event):
|
|
self._fix_size()
|
|
super(HorizontalHeader, self).paintEvent(event)
|
|
|
|
def _fix_size(self):
|
|
for column_idx in range(self.model.columnCount()):
|
|
vis_index = self.visualIndex(column_idx)
|
|
index = self.logicalIndex(vis_index)
|
|
section_width = self.sectionSize(index)
|
|
|
|
column_name = self.model.headerData(column_idx,
|
|
QtCore.Qt.Horizontal,
|
|
lib.HeaderNameRole)
|
|
button = self.filter_buttons.get(column_name)
|
|
if not button:
|
|
continue
|
|
|
|
pos_x = self.sectionViewportPosition(
|
|
index) + section_width - self.height()
|
|
|
|
pos_y = 0
|
|
if button.height() < self.height():
|
|
pos_y = int((self.height() - button.height()) / 2)
|
|
button.setGeometry(
|
|
pos_x,
|
|
pos_y,
|
|
self.height(),
|
|
self.height())
|