def __init__(self, create_key):
assert (create_key == FileModel.__create_key), \
"FileModel objects must be created using FileModel.get_instance()"
super(FileModel, self).__init__()
self.settings = QSettings()
path = self.settings.value("sync_path")
if os.path.isdir(path):
self.tree = tree_builder.get_tree_from_system(path)
self.current_folder = LocalDirectory(self.tree)
self.previous_folder = None
def test_get_data(self):
# scendo di una directory
self.model_test.current_folder = LocalDirectory(
self.model_test.current_folder._node.get_children()[0],
self.model_test.current_folder._node.get_children()[0].get_name())
# eseguo get_data
files, dirs = self.model_test.get_data()
# costruisco una parent directory come nella funzione
parent_directory = LocalDirectory(
self.model_test.current_folder._node._parent, '..')
# costruisco lista di file e cartelle
test_files = self.model_test.current_folder._files
test_dirs = self.model_test.current_folder._dirs
# test di uguaglianza
self.assertEqual(parent_directory._node,
self.model_test.previous_folder._node)
self.assertEqual(parent_directory._name,
self.model_test.previous_folder._name)
self.assertEqual(files, test_files)
self.assertEqual(dirs, test_dirs)
def get_data(self) -> Tuple[list[LocalFile], list[LocalDirectory]]:
list_of_files = self.current_folder._files # lista file dalla dir
list_of_dirs = self.current_folder._dirs # lista dir dalla dir
if self.current_folder._node._parent:
self.previous_folder = LocalDirectory(
self.current_folder._node._parent, '..')
list_of_dirs.insert(0, self.previous_folder)
else:
self.previous_folder = None
return list_of_files, list_of_dirs
def test_get_data_root(self):
# vado su root
self.model_test.current_folder = LocalDirectory(
self.model_test.current_folder._node._parent,
self.model_test.current_folder._node._parent.get_name())
# eseguo get_data
files, dirs = self.model_test.get_data()
# ricostruisco lista di file e cartelle
test_files = self.model_test.current_folder._files
test_dirs = self.model_test.current_folder._dirs
# test di uguaglianza
self.assertEqual(None, self.model_test.previous_folder)
self.assertEqual(files, test_files)
self.assertEqual(dirs, test_dirs)
def test_search_node_from_path(self):
# vado su root
if (self.model_test.current_folder._name != "ROOT"):
self.model_test.current_folder = LocalDirectory(
self.model_test.current_folder._node._parent,
self.model_test.current_folder._node._parent.get_name())
# ottengo nodo
test_node = self.model_test.current_folder._node.get_children()[0]
# ottengo path
path_to_search = self.model_test.current_folder._node.get_children(
)[0].get_path()
# chiamo search_node_from_path
result_node = self.model_test.search_node_from_path(path_to_search)
# test di uguaglianza
self.assertEqual(test_node.get_path(), result_node.get_path())
def test_search_through_children_wrong_name(self):
# vado su root
if (self.model_test.current_folder._name != "ROOT"):
self.model_test.current_folder = LocalDirectory(
self.model_test.current_folder._node._parent,
self.model_test.current_folder._node._parent.get_name())
# ottengo nome
name_to_search = "NomeCheNonEsiste"
# ottengo nodo
node_to_search = self.model_test.current_folder._node
# chiamo _search_through_children
result_node = self.model_test._search_through_children(
name_to_search, node_to_search)
# test di uguaglianza
self.assertEqual(None, result_node)
def test_set_current_node(self):
# ottengo path
path_to_set = self.model_test.current_folder._node.get_children(
)[0].get_payload().path
# creo directory per testare ritorno
test_target_directory = LocalDirectory(
self.model_test.current_folder._node.get_children()[0],
self.model_test.current_folder._node.get_children()[0].get_name())
# eseguo set_current_node
self.model_test.set_current_node(path_to_set)
# test di uguaglianza
self.assertEqual(
self.model_test.current_folder._node.get_payload().path,
test_target_directory._node.get_payload().path)
self.assertEqual(self.model_test.current_folder._name,
test_target_directory._name)
def test_search_node_from_path_path_does_not_exist(self):
# vado su root
if (self.model_test.current_folder._name != "ROOT"):
self.model_test.current_folder = LocalDirectory(
self.model_test.current_folder._node._parent,
self.model_test.current_folder._node._parent.get_name())
# ottengo nodo
test_node = self.model_test.current_folder._node.get_children()[0]
# ottengo path
path_to_search = self.model_test.current_folder._node.get_children(
)[0].get_path()
path_to_search = os.path.join(path_to_search, "FolderCheNonEsiste")
print(path_to_search)
# chiamo search_node_from_path
result_node = self.model_test.search_node_from_path(path_to_search)
# test di uguaglianza
self.assertEqual(test_node.get_path(), result_node.get_path())
def test_search_through_children(self):
# vado su root
if (self.model_test.current_folder._name != "ROOT"):
self.model_test.current_folder = LocalDirectory(
self.model_test.current_folder._node._parent,
self.model_test.current_folder._node._parent.get_name())
# ottengo nome
name_to_search = self.model_test.current_folder._node.get_children(
)[0].get_name()
# ottengo nodo
node_to_search = self.model_test.current_folder._node
# ottengo nodo obiettivo
test_node = self.model_test.current_folder._node.get_children()[0]
# chiamo _search_through_children
result_node = self.model_test._search_through_children(
name_to_search, node_to_search)
# test di uguaglianza
self.assertEqual(test_node.get_path(), result_node.get_path())
def test_double_clicked_action_exists_local(self):
test_dir = LocalDirectory(default_code._get_test_node())
test_dir_widget = LocalDirectoryWidget(test_dir)
test_dir_widget.double_clicked_action()
class FileModel(QObject):
Sg_model_changed = Signal()
__model = None
__create_key = object()
@classmethod
def get_instance(cls):
if FileModel.__model is None:
FileModel.__model = FileModel(cls.__create_key)
return FileModel.__model
def __init__(self, create_key):
assert (create_key == FileModel.__create_key), \
"FileModel objects must be created using FileModel.get_instance()"
super(FileModel, self).__init__()
self.settings = QSettings()
path = self.settings.value("sync_path")
if os.path.isdir(path):
self.tree = tree_builder.get_tree_from_system(path)
self.current_folder = LocalDirectory(self.tree)
self.previous_folder = None
@Slot()
def Sl_update_model(self) -> None:
# ricreo tree dalla root
path = self.settings.value("sync_path")
if os.path.isdir(path):
try:
self.tree = tree_builder.get_tree_from_system(path)
self.current_folder._node = self.search_node_from_path(
self.current_folder._node.get_payload().path)
# cerco il nodo attuale nel nuovo tree
self.current_folder.update_list_of_content()
# aggiorno lista carelle e file
self.Sg_model_changed.emit()
except FileNotFoundError as e:
print("File not found: " + str(e))
else:
self.clear_view()
def clear_view(self):
self.current_folder._files.clear()
self.current_folder._dirs.clear()
self.Sg_model_changed.emit()
def get_data(self) -> Tuple[list[LocalFile], list[LocalDirectory]]:
list_of_files = self.current_folder._files # lista file dalla dir
list_of_dirs = self.current_folder._dirs # lista dir dalla dir
if self.current_folder._node._parent:
self.previous_folder = LocalDirectory(
self.current_folder._node._parent, '..')
list_of_dirs.insert(0, self.previous_folder)
else:
self.previous_folder = None
return list_of_files, list_of_dirs
def set_current_node(self, path: str) -> None:
name = path.split('/')[-1] # ottengo nome folder desiderato
child = self._search_through_children(
name, self.current_folder._node) # cerco figlio
if (child):
# imposto figlio come node folder
self.current_folder._node = child
self.current_folder._name = child.get_name()
else:
# imposto genitore come node folder
result_node = self.search_node_from_path(path)
self.current_folder._node = result_node
self.current_folder._name = result_node.get_name()
self.Sl_update_model()
def search_node_from_path(self, path: str) -> Optional[TreeNode]:
relative_path = path
folder_name = self.settings.value("sync_path").split(os.sep)[-1]
relative_path = relative_path[relative_path.find(folder_name):]
folders = relative_path.split(os.path.sep)
curr_node = self.tree
if self.tree.get_name() == "ROOT":
folders = folders[1:]
for f in folders:
folder_found = self._search_through_children(f, curr_node)
if folder_found is None:
return curr_node
else:
curr_node = folder_found
return curr_node
else:
return None
def _search_through_children(self, name: str,
node: TreeNode) -> Optional[TreeNode]:
for i in node.get_children():
if i.get_name() == name:
return i
return None