def _files_listed():
f_w = logged_gui.test_get_files_widget()
assert f_w.isVisible()
assert f_w.table_files.rowCount() == 2
assert f_w.table_files.item(1, 1).text() == "file1.txt"
assert f_w.table_files.item(1, 2).text() == format_datetime(year_n10)
assert f_w.table_files.item(1, 3).text() == format_datetime(year_n10)
def _wait_for_files():
assert f_w.table_files.rowCount() == 3
assert f_w.table_files.item(1, 1).text() == "file1.txt"
assert f_w.table_files.item(1, 2).text() == format_datetime(year_n10)
assert f_w.table_files.item(1, 3).text() == format_datetime(year_n10)
assert f_w.table_files.item(2, 1).text() == "file2.txt"
assert f_w.table_files.item(2, 2).text() == format_datetime(year_n20)
assert f_w.table_files.item(2, 3).text() == format_datetime(year_n20)
def reload_workspace_name(self, workspace_name):
self.workspace_name = workspace_name
display = workspace_name
extra_space = 40
if not self.timestamped:
if not self.is_shared:
shared_message = _("TEXT_WORKSPACE_IS_PRIVATE")
elif not self.is_owner:
shared_message = _("TEXT_WORKSPACE_IS_OWNED_BY_user").format(
user=self.owner.short_user_display)
elif len(self.others) == 1 and self.others[0]:
user, = self.others
shared_message = _("TEXT_WORKSPACE_IS_SHARED_WITH_user"
).format(user=user.short_user_display)
else:
n = len(self.others)
assert n > 1
shared_message = _(
"TEXT_WORKSPACE_IS_SHARED_WITH_n_USERS").format(n=n)
display += " ({})".format(shared_message)
if self.is_shared:
extra_space += 40
if self.is_owner:
extra_space += 40
else:
display += "-" + _("TEXT_WORKSPACE_IS_TIMESTAMPED_date").format(
date=format_datetime(self.workspace_fs.timestamp))
self.label_title.setToolTip(display)
size = self.size().width() - extra_space
self.label_title.setText(
ensure_string_size(display, size, self.label_title.font()))
def reload_workspace_name(self, workspace_name):
self.workspace_name = workspace_name
display = workspace_name
if not self.timestamped:
if not self.is_shared:
shared_message = _("TEXT_WORKSPACE_IS_PRIVATE")
elif not self.is_owner:
shared_message = _("TEXT_WORKSPACE_IS_OWNED_BY_user").format(
user=self.owner)
elif len(self.others) == 1:
user, = self.others
shared_message = _(
"TEXT_WORKSPACE_IS_SHARED_WITH_user").format(user=user)
else:
n = len(self.others)
assert n > 1
shared_message = _(
"TEXT_WORKSPACE_IS_SHARED_WITH_n_USERS").format(n=n)
display += " ({})".format(shared_message)
else:
display += "-" + _("TEXT_WORKSPACE_IS_TIMESTAMPED_date").format(
date=format_datetime(self.workspace_fs.timestamp))
self.label_title.setToolTip(display)
if len(display) > 20:
display = display[:20] + "..."
self.label_title.setText(display)
def __init__(self, user_name, is_current_user, is_admin, certified_on,
is_revoked, current_user_is_admin):
super().__init__()
self.setupUi(self)
self.current_user_is_admin = current_user_is_admin
self.is_admin = is_admin
self.is_revoked = is_revoked
self._is_revoked = is_revoked
self.certified_on = certified_on
self.is_current_user = is_current_user
self.user_name = user_name
self.label_username.setText(user_name)
self.user_icon.apply_style()
self.setContextMenuPolicy(Qt.CustomContextMenu)
self.customContextMenuRequested.connect(self.show_context_menu)
self.label_created_on.setText(
format_datetime(self.certified_on, full=True))
self.label_role.setText(
_("TEXT_USER_ROLE_ADMIN") if self.
is_admin else _("TEXT_USER_ROLE_CONTRIBUTOR"))
if self.is_current_user:
self.label_user_is_current.setText("({})".format(
_("TEXT_USER_IS_CURRENT")))
effect = QGraphicsDropShadowEffect(self)
effect.setColor(QColor(0x99, 0x99, 0x99))
effect.setBlurRadius(10)
effect.setXOffset(2)
effect.setYOffset(2)
self.setGraphicsEffect(effect)
def add_file(
self,
file_name,
entry_id,
file_size,
created_on,
updated_on,
is_synced,
is_confined,
selected=False,
):
if is_confined and not self.config.gui_show_confined:
return
entry_id = entry_id.hex
row_idx = self.rowCount()
self.insertRow(row_idx)
item = FileTableItem(is_synced, is_confined, file_name.str)
item.setData(NAME_DATA_INDEX, 1)
item.setData(TYPE_DATA_INDEX, FileType.File)
item.setData(ENTRY_ID_DATA_INDEX, entry_id)
self.setItem(row_idx, Column.ICON, item)
item = CustomTableItem(file_name.str)
item.setToolTip("\n".join(file_name.str[i:i + 64]
for i in range(0, len(file_name.str), 64)))
item.setData(NAME_DATA_INDEX, file_name.str)
item.setData(TYPE_DATA_INDEX, FileType.File)
item.setData(ENTRY_ID_DATA_INDEX, entry_id)
self.setItem(row_idx, Column.NAME, item)
item = CustomTableItem(format_datetime(created_on))
item.setData(NAME_DATA_INDEX, created_on)
item.setData(TYPE_DATA_INDEX, FileType.File)
item.setData(ENTRY_ID_DATA_INDEX, entry_id)
self.setItem(row_idx, Column.CREATED, item)
item = CustomTableItem(format_datetime(updated_on))
item.setData(NAME_DATA_INDEX, updated_on)
item.setData(TYPE_DATA_INDEX, FileType.File)
item.setData(ENTRY_ID_DATA_INDEX, entry_id)
self.setItem(row_idx, Column.UPDATED, item)
item = CustomTableItem(get_filesize(file_size))
item.setData(NAME_DATA_INDEX, file_size)
item.setData(TYPE_DATA_INDEX, FileType.File)
item.setData(ENTRY_ID_DATA_INDEX, entry_id)
self.setItem(row_idx, Column.SIZE, item)
if selected:
self.setRangeSelected(
QTableWidgetSelectionRange(row_idx, 0, row_idx,
len(Column) - 1), True)
def __init__(self, pending):
super().__init__()
self.setupUi(self)
self.pending = pending
accept_pix = Pixmap(":/icons/images/material/done.svg")
accept_pix.replace_color(QColor(0x00, 0x00, 0x00),
QColor(0xFF, 0xFF, 0xFF))
reject_pix = Pixmap(":/icons/images/material/clear.svg")
reject_pix.replace_color(QColor(0x00, 0x00, 0x00),
QColor(0xFF, 0xFF, 0xFF))
self.button_accept.setIcon(QIcon(accept_pix))
self.button_reject.setIcon(QIcon(reject_pix))
self.label_date.setText(format_datetime(pending.submitted_on))
if isinstance(self.pending, PkiEnrollementAccepterInvalidSubmittedCtx):
if self.pending.submitter_x509_certificate:
self.widget_cert_infos.setVisible(True)
self.widget_cert_error.setVisible(False)
self.label_name.setText(
self.pending.submitter_x509_certificate.subject_common_name
)
self.label_email.setText(
self.pending.submitter_x509_certificate.
subject_email_address)
self.label_issuer.setText(
self.pending.submitter_x509_certificate.issuer_common_name)
else:
self.widget_cert_infos.setVisible(False)
self.widget_cert_error.setVisible(True)
self.label_error.setText(
translate("TEXT_ENROLLMENT_ERROR_WITH_CERTIFICATE"))
self.button_accept.setVisible(False)
self.label_cert_validity.setStyleSheet(
"#label_cert_validity { color: #F44336; }")
self.label_cert_validity.setText(
"✘ " + translate("TEXT_ENROLLMENT_CERTIFICATE_IS_INVALID"))
self.label_cert_validity.setToolTip(
textwrap.fill(str(self.pending.error), 80))
else:
assert isinstance(self.pending,
PkiEnrollementAccepterValidSubmittedCtx)
self.widget_cert_infos.setVisible(True)
self.widget_cert_error.setVisible(False)
self.button_accept.setVisible(True)
self.label_name.setText(
self.pending.submitter_x509_certificate.subject_common_name)
self.label_email.setText(
self.pending.submitter_x509_certificate.subject_email_address)
self.label_issuer.setText(
self.pending.submitter_x509_certificate.issuer_common_name)
self.label_cert_validity.setStyleSheet(
"#label_cert_validity { color: #8BC34A; }")
self.label_cert_validity.setText(
"✔ " + translate("TEXT_ENROLLMENT_CERTIFICATE_IS_VALID"))
self.button_accept.clicked.connect(
lambda: self.accept_clicked.emit(self))
self.button_reject.clicked.connect(
lambda: self.reject_clicked.emit(self))
def add_file(self,
file_name,
uuid,
file_size,
created_on,
updated_on,
is_synced,
selected=False):
row_idx = self.rowCount()
self.insertRow(row_idx)
item = FileTableItem(is_synced, file_name)
item.setData(NAME_DATA_INDEX, 1)
item.setData(TYPE_DATA_INDEX, FileType.File)
item.setData(UUID_DATA_INDEX, uuid)
self.setItem(row_idx, Column.ICON, item)
item = CustomTableItem(file_name)
item.setToolTip("\n".join(file_name[i:i + 64]
for i in range(0, len(file_name), 64)))
item.setData(NAME_DATA_INDEX, file_name)
item.setData(TYPE_DATA_INDEX, FileType.File)
item.setData(UUID_DATA_INDEX, uuid)
self.setItem(row_idx, Column.NAME, item)
item = CustomTableItem(format_datetime(created_on))
item.setData(NAME_DATA_INDEX, created_on)
item.setData(TYPE_DATA_INDEX, FileType.File)
item.setData(UUID_DATA_INDEX, uuid)
self.setItem(row_idx, Column.CREATED, item)
item = CustomTableItem(format_datetime(updated_on))
item.setData(NAME_DATA_INDEX, updated_on)
item.setData(TYPE_DATA_INDEX, FileType.File)
item.setData(UUID_DATA_INDEX, uuid)
self.setItem(row_idx, Column.UPDATED, item)
item = CustomTableItem(get_filesize(file_size))
item.setData(NAME_DATA_INDEX, file_size)
item.setData(TYPE_DATA_INDEX, FileType.File)
item.setData(UUID_DATA_INDEX, uuid)
self.setItem(row_idx, Column.SIZE, item)
if selected:
self.setRangeSelected(
QTableWidgetSelectionRange(row_idx, 0, row_idx,
len(Column) - 1), True)
def reload_workspace_name(self, workspace_name):
self.workspace_name = workspace_name
display = workspace_name
if self.is_shared and self.is_creator:
display += " ({})".format(_("TEXT_WORKSPACE_IS_SHARED"))
if isinstance(self.workspace_fs, WorkspaceFSTimestamped):
display += "-" + _("TEXT_WORKSPACE_IS_TIMESTAMPED_date").format(
date=format_datetime(self.workspace_fs.timestamp))
self.label_title.setToolTip(display)
if len(display) > 20:
display = display[:20] + "..."
self.label_title.setText(display)
def __init__(self, version, creator, name, size, src, dst, timestamp):
super().__init__()
self.setupUi(self)
self.label_version.setText(str(version))
self.label_user.setText(creator)
self.label_size.setText(get_filesize(size) if size is not None else "")
self.label_date.setText(format_datetime(timestamp))
if not src:
self.label_src.hide()
else:
self.label_src.setText(str(src))
if not dst:
self.label_dst.hide()
else:
self.label_dst.setText(str(dst))
async def test_workspace_button_timestamped(qtbot, workspace_fs, core_config,
alice_user_info):
switch_language(core_config, "en")
timestamp = pendulum.now().add(seconds=10)
roles = {alice_user_info.user_id: (WorkspaceRole.OWNER, alice_user_info)}
ts_workspace_fs = WorkspaceFSTimestamped(workspace_fs, timestamp)
w = WorkspaceButton.create(
workspace_name=EntryName("Workspace"),
workspace_fs=ts_workspace_fs,
users_roles=roles,
is_mounted=True,
timestamped=True,
)
assert w.timestamp == timestamp
label = w.widget_empty.layout().itemAt(0).widget().label_timestamp
assert label.text() == format_datetime(timestamp)
def apply_state(self,
workspace_name,
workspace_fs,
users_roles,
is_mounted,
files=None,
timestamped=False):
# Not meant to change
assert timestamped == self.timestamped
assert workspace_fs == self.workspace_fs
# Update attributes
self.workspace_name = workspace_name
self.workspace_fs = workspace_fs
self.users_roles = users_roles
self.files = files or []
# Update dependent widgets
if not self.timestamped:
if not len(self.files):
self.widget_empty.show()
self.widget_files.hide()
else:
self.widget_files.show()
self.widget_empty.hide()
for i, f in enumerate(files, 1):
if i > 4:
break
label = getattr(self, "file{}_name".format(i))
label.setText(f.str)
else:
widget_temp = self.widget_empty.layout().itemAt(0).widget()
widget_temp.label_timestamp.setText(format_datetime(
self.timestamp))
# Retrieve current role for ourself
user_id = self.workspace_fs.device.user_id
try:
current_role, _ = self.users_roles[user_id]
except KeyError:
current_role = NOT_SHARED_KEY
self.label_role.setText(get_role_translation(current_role))
self.label_owner.setVisible(self.is_owner)
self.label_shared.setVisible(self.is_shared)
self.reload_workspace_name(self.workspace_name)
self.set_mountpoint_state(is_mounted)
def enable_with_timestamp(self):
creation = self.limits_job.ret.in_timezone("local")
self.limits_job = None
self.creation_date = (creation.year, creation.month, creation.day)
self.creation_time = (creation.hour, creation.minute, creation.second)
self.label_info.setText(
_("TEXT_WORKSPACE_TIMESTAMPED_INSTRUCTIONS_created").format(
created=format_datetime(creation, full=True)
)
)
now = pendulum.now().in_timezone("local")
self.now_date = (now.year, now.month, now.day)
self.now_time = (now.hour, now.minute, now.second)
self.calendar_widget.setMinimumDate(QDate(*self.creation_date))
self.calendar_widget.setMaximumDate(QDate(*self.now_date))
self.calendar_widget.selectionChanged.connect(self.set_time_limits)
self.set_time_limits()
self.time_edit.setDisplayFormat("h:mm:ss")
def __init__(
self,
workspace_name,
workspace_fs,
users_roles,
is_mounted,
files=None,
timestamped=False,
reencryption_needs=None,
):
super().__init__()
self.setupUi(self)
self.users_roles = users_roles
self.workspace_name = workspace_name
self.workspace_fs = workspace_fs
self.timestamped = timestamped
self.switch_button = SwitchButton()
self.widget_actions.layout().insertWidget(0, self.switch_button)
self.switch_button.clicked.connect(self._on_switch_clicked)
self.reencrypting = None
self.reencryption_needs = reencryption_needs
self.setCursor(QCursor(Qt.PointingHandCursor))
self.setContextMenuPolicy(Qt.CustomContextMenu)
self.customContextMenuRequested.connect(self.show_context_menu)
self.label_role.setText(get_role_translation(self.current_role))
files = files or []
if not self.timestamped:
self.button_delete.hide()
if not len(files):
self.widget_empty.show()
self.widget_files.hide()
self.widget_empty.layout().addWidget(EmptyWorkspaceWidget())
else:
for i, f in enumerate(files, 1):
if i > 4:
break
label = getattr(self, "file{}_name".format(i))
label.setText(f)
self.widget_files.show()
self.widget_empty.hide()
else:
self.switch_button.setChecked(True)
self.button_reencrypt.hide()
self.button_remount_ts.hide()
self.button_share.hide()
self.button_rename.hide()
self.label_shared.hide()
self.label_owner.hide()
self.switch_button.hide()
widg_tmp = TemporaryWorkspaceWidget()
widg_tmp.label_timestamp.setText(format_datetime(self.timestamp))
self.widget_empty.layout().addWidget(widg_tmp)
self.widget_empty.show()
self.widget_files.hide()
effect = QGraphicsDropShadowEffect(self)
effect.setColor(QColor(0x99, 0x99, 0x99))
effect.setBlurRadius(10)
effect.setXOffset(2)
effect.setYOffset(2)
self.setGraphicsEffect(effect)
if not self.is_owner:
self.button_reencrypt.hide()
self.widget_reencryption.hide()
self.button_share.clicked.connect(self.button_share_clicked)
self.button_share.apply_style()
self.button_reencrypt.clicked.connect(self.button_reencrypt_clicked)
self.button_reencrypt.apply_style()
self.button_delete.clicked.connect(self.button_delete_clicked)
self.button_delete.apply_style()
self.button_rename.clicked.connect(self.button_rename_clicked)
self.button_rename.apply_style()
self.button_remount_ts.clicked.connect(self.button_remount_ts_clicked)
self.button_remount_ts.apply_style()
self.button_open.clicked.connect(self.button_open_workspace_clicked)
self.button_open.apply_style()
self.label_owner.apply_style()
self.label_shared.apply_style()
if not self.is_owner:
self.label_owner.hide()
if not self.is_shared:
self.label_shared.hide()
self.reload_workspace_name(self.workspace_name)
self.set_mountpoint_state(is_mounted)
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.setupUi(self)
now = pendulum.now()
self.label_date.setText(format_datetime(now))
self.button_close.clicked.connect(self.emit_close_clicked)
async def get_status(self):
path_info = await self.workspace_fs.path_info(self.path)
block_info = None
if path_info["type"] == "file":
block_info: BlockInfo = await self.workspace_fs.get_blocks_by_type(
self.path)
self.label_size.setText(get_filesize(path_info["size"]))
version_lister = self.workspace_fs.get_version_lister()
version_list = await version_lister.list(path=self.path)
user_id = version_list[0][0].creator.user_id
created_time = version_list[0][0].updated
updated_time = path_info["updated"]
version_list = await version_lister.list(
path=self.path, starting_timestamp=updated_time)
user_id_last = version_list[0][-1].creator.user_id
creator = await self.core.get_user_info(user_id)
last_author = await self.core.get_user_info(user_id_last)
full_path = self.core.mountpoint_manager.get_path_in_mountpoint(
self.workspace_fs.workspace_id,
self.path,
self.workspace_fs.timestamp
if isinstance(self.workspace_fs, WorkspaceFSTimestamped) else None,
)
self.label_location.setText(str(full_path))
self.label_filetype.setText(str(path_info["type"]))
self.label_workspace.setText(
self.workspace_fs.get_workspace_name().str)
self.label_created_on.setText(format_datetime(created_time))
self.label_last_updated_on.setText(format_datetime(updated_time))
self.label_created_by.setText(creator.short_user_display)
self.label_last_updated_by.setText(last_author.short_user_display)
if block_info:
local_blocks = len(block_info.local_only_blocks)
remote_blocks = len(block_info.remote_only_blocks)
local_and_remote_blocks = len(block_info.local_and_remote_blocks)
total_blocks = local_blocks + remote_blocks + local_and_remote_blocks
local_block_count = local_blocks + local_and_remote_blocks
local_block_percentage = int(
(local_block_count / total_blocks if total_blocks else 1) *
100.0)
remote_block_count = remote_blocks + local_and_remote_blocks
remote_block_percentage = int(
(remote_block_count / total_blocks if total_blocks else 1) *
100.0)
if local_block_count == total_blocks:
self.label_availability.setText(_("TEXT_YES"))
else:
self.label_availability.setText(_("TEXT_NO"))
if remote_block_count == total_blocks:
self.label_uploaded.setText(_("TEXT_YES"))
else:
self.label_uploaded.setText(_("TEXT_NO"))
self.label_local.setText(
f"{local_block_count}/{total_blocks} ({local_block_percentage}%)"
)
self.label_remote.setText(
f"{remote_block_count}/{total_blocks} ({remote_block_percentage}%)"
)
self.label_default_block_size.setText(
get_filesize(DEFAULT_BLOCK_SIZE))
