def upload_node(self, node: TreeNode, parent_id: str = "LOCAL_ROOT"):
"""Carica un nodo, all'interno del parent passato"""
headers = {"cookie": self.cookie}
name = node.get_name()
content = open(node.get_payload().path, "rb")
updated_at = node.get_updated_at()
created_at = node.get_payload().created_at
multipart_form = {
"command": "upload",
"name": name,
"content": content,
"parent": self.get_user_id() + "/" + parent_id,
"updated-at": updated_at,
"created-at": created_at
}
response = requests.post(self.url_files,
headers=headers,
files=multipart_form)
if response.ok:
self.logger.info(
f"Upload del file {name}, completato con successo")
else:
self.logger.info(f"Upload del file {name}, fallito")
# alzo le eccezioni del caso
self.check_status_code(response)
def _test_tree_node(self, node_to_test: TreeNode, test_node: TreeNode):
self.assertEqual(node_to_test.get_name(), test_node.get_name())
payload_to_test = node_to_test.get_payload()
test_payload = test_node.get_payload()
self.assertEqual(payload_to_test.id, test_payload.id)
self.assertEqual(payload_to_test.type, test_payload.type)
self.assertEqual(payload_to_test.updated_at, test_payload.updated_at)
self.assertEqual(payload_to_test.created_at, test_payload.created_at)
self.assertEqual(payload_to_test.path, test_payload.path)
def _compareFiles(client: TreeNode, server: TreeNode) -> list:
client_files = _get_only_files(client._children)
server_files = _get_only_files(server._children)
update_files: list = []
for cl_file in client_files:
trovato = False
for sr_file in server_files:
if cl_file.get_name() == sr_file.get_name():
if cl_file.get_updated_at() > sr_file.get_updated_at():
update_files.append({
"node": cl_file,
"id": server.get_payload().id,
"action": Actions.CLIENT_UPDATE_FILE
})
elif sr_file.get_updated_at() > cl_file.get_updated_at():
update_files.append({
"node":
sr_file,
"path":
client.get_payload().path,
"snap_last_update":
cl_file.get_updated_at(),
"action":
Actions.SERVER_UPDATE_FILE
})
trovato = True
break
if not trovato:
# Il client ha un file che nel server non c'è
update_files.append({
"node": cl_file,
"id": server.get_payload().id,
"action": Actions.CLIENT_NEW_FILE
})
for sr_file in server_files:
trovato = False
for cl_file in client_files:
if sr_file.get_name() == cl_file.get_name():
trovato = True
if not trovato:
# Il server ha un file che nel client non c'è
update_files.append({
"node": sr_file,
"path": client.get_payload().path,
"action": Actions.SERVER_NEW_FILE
})
return update_files
def download_file(node: TreeNode, path_folder: str) -> Optional[dict]:
node_id = node.get_payload().id
if settings_model.is_id_in_sync_list(node_id):
quota_libera = settings_model.get_quota_libera()
return network_model.download_node(node, path_folder, quota_libera)
else:
return None
def __init__(self, tree: TreeNode, override_name: str = None):
self._name = tree.get_name(
) if override_name is None else override_name
self._node = tree
self._files = []
self._dirs = []
self._path = tree.get_payload().path
self.update_list_of_content()
def compareFolders(client: TreeNode, server: TreeNode) -> list:
update_files: list = []
# Controllo prima SOLO i file
update_files.extend(_compareFiles(client, server))
client_folders = _get_only_folders(client._children)
server_folders = _get_only_folders(server._children)
for cl_folder in client_folders:
trovato = False
for sr_folder in server_folders:
if cl_folder.get_name() == sr_folder.get_name():
trovato = True
update_files.extend(compareFolders(cl_folder, sr_folder))
if not trovato:
# Il client ha un cartella che nel server non c'è
update_files.append({
"node": cl_folder,
"id": server.get_payload().id,
"action": Actions.CLIENT_NEW_FOLDER
})
for sr_folder in server_folders:
trovato = False
for cl_folder in client_folders:
if sr_folder.get_name() == cl_folder.get_name():
trovato = True
if not trovato:
# Il server ha una cartella che nel client non c'è
update_files.append({
"node": sr_folder,
"path": client.get_payload().path,
"action": Actions.SERVER_NEW_FOLDER
})
return update_files
def download_node(self, node: TreeNode, path_folder: str,
quota_libera: float) -> dict:
remote_node = self.api_implementation.get_content_from_node(
node.get_payload().id)
file_size = remote_node["getNode"]["size"]
# Se ho spazio procedo al download
if quota_libera > file_size:
result = self.api_implementation.download_node(node, path_folder)
return {
"node_name": node.get_name(),
"result": result,
"type": "network_error" if not result else ""
}
return {
"node_name": node.get_name(),
"result": False,
"type": "space_error"
}
def download_node(self, node: TreeNode, path: str) -> bool:
"""Il TreeNode viene scaricato e salvato nel path, ritorna un bool a seconda dell'esito"""
headers = {"cookie": self.cookie}
payload = node.get_payload()
url = f"{self.url_files}{self.get_user_id()}/{payload.id}"
response = requests.get(url, headers=headers)
if response.ok:
path = os.path.join(path, payload.name)
with open(path, "wb") as fh:
fh.write(response.content)
# Cambiare la data di creazione sembra non funzionare
os.utime(path, (payload.created_at, payload.updated_at))
self.logger.info(
f"Download del file {payload.name}, completato con successo")
return True
else:
self.logger.info(f"Download del file {payload.name}, fallito")
# alzo le eccezioni del caso
self.check_status_code(response)
return False
def __init__(self, node: TreeNode):
super().__init__(node)
self._path = node.get_payload().path
self._size = SettingsModel.convert_size(
os.stat(node.get_payload().path).st_size)
class TestTreeNode(unittest.TestCase):
def setUp(self):
"""Metodo che viene chiamato prima di ogni metodo"""
self.files: list[Node] = [
Node("CLIENT_NODE", "Test", Type.File, 1000, 1022,
"root/file.txt"),
Node("CLIENT_NODE", "Test2", Type.File, 1000, 1024,
"root/file2.txt"),
Node("CLIENT_NODE", "Test3", Type.File, 1000, 1026,
"root/root2/file3.txt"),
]
self.folders: list[Node] = [
Node("CLIENT_NODE", "Test Folder", Type.Folder, 1000, 1022,
"root"),
Node("CLIENT_NODE", "Test Folder2", Type.Folder, 1000, 1025,
"root/root2"),
]
self.tree_node = TreeNode(self.folders[0])
self.tree_node.add_node(TreeNode(self.files[0]))
self.tree_node.add_node(TreeNode(self.files[1]))
self.tree_node_sub = TreeNode(self.folders[1])
self.tree_node_sub.add_node(TreeNode(self.files[2]))
self.tree_node.add_node(self.tree_node_sub)
def test_is_directory(self) -> None:
self.assertTrue(self.tree_node.is_directory())
self.assertFalse(self.tree_node._children[0].is_directory())
self.assertFalse(self.tree_node._children[1].is_directory())
self.assertTrue(self.tree_node._children[2].is_directory())
self.assertFalse(
self.tree_node._children[2]._children[0].is_directory())
def test_get_name(self) -> None:
tests = {
"Test Folder": self.tree_node.get_name(),
"Test": self.tree_node._children[0].get_name(),
"Test2": self.tree_node._children[1].get_name(),
"Test Folder2": self.tree_node._children[2].get_name(),
"Test3": self.tree_node._children[2]._children[0].get_name()
}
for expected, values in tests.items():
self.assertEqual(expected, values)
def test_get_updated_at(self) -> None:
self.assertEqual(1022, self.tree_node.get_updated_at())
self.assertEqual(1022, self.tree_node._children[0].get_updated_at())
self.assertEqual(1024, self.tree_node._children[1].get_updated_at())
self.assertEqual(1025, self.tree_node._children[2].get_updated_at())
self.assertEqual(
1026, self.tree_node._children[2]._children[0].get_updated_at())
def test_get_children(self) -> None:
self.assertEqual(self.folders[0], self.tree_node.get_payload())
self.assertEqual(self.files[0],
self.tree_node._children[0].get_payload())
self.assertEqual(self.files[1],
self.tree_node._children[1].get_payload())
self.assertEqual(self.folders[1],
self.tree_node._children[2].get_payload())
self.assertEqual(
self.files[2],
self.tree_node._children[2]._children[0].get_payload())
def test_get_payload(self) -> None:
self.assertEqual(3, len(self.tree_node.get_children()))
self.assertEqual(
self.files[2],
self.tree_node._children[2]._children[0].get_payload())
def test_parent(self) -> None:
self.assertEqual(self.tree_node, self.tree_node._children[0]._parent)
self.assertEqual(self.tree_node, self.tree_node._children[1]._parent)
self.assertEqual(self.tree_node, self.tree_node._children[2]._parent)
self.assertEqual(self.tree_node._children[2],
self.tree_node._children[2]._children[0]._parent)
def test_add_node_exception(self) -> None:
root = TreeNode(self.files[0])
with self.assertRaises(ValueError):
root.add_node(TreeNode(self.files[1]))
def test_str(self) -> None:
res = ("Test Folder - Folder (1022 -> 01/01/1970 00:17:02)\n"
" Test (1022 -> 01/01/1970 00:17:02)\n"
" Test2 (1024 -> 01/01/1970 00:17:04)\n"
" Test Folder2 - Folder (1025 -> 01/01/1970 00:17:05)\n"
" Test3 (1026 -> 01/01/1970 00:17:06)\n")
self.assertEqual(res, str(self.tree_node))
def __init__(self, node: TreeNode):
self._name = node.get_name()
self._creation_date = self._convert_int_to_date(
node.get_payload().created_at)
self._last_modified_date = self._convert_int_to_date(
node.get_updated_at())
def __init__(self, node: TreeNode):
super().__init__(node)
self.id = node.get_payload().id
self.size = SettingsModel.convert_size(node.get_payload().size)
self.last_editor = node.get_payload().last_editor
