Update SaveGameFiles after uploading saves

rare/components/dialogs/launch_dialog.py

@@ -11,7 +11,7 @@ from rare import image_dir, shared
 from rare.components.dialogs.login import LoginDialog
 from rare.ui.components.dialogs.launch_dialog import Ui_LaunchDialog
 from rare.utils.models import ApiResults
-from rare.utils.utils import download_images
+from rare.utils.utils import download_images, CloudWorker
 
 logger = getLogger("Login")
 
@@ -106,13 +106,16 @@ class LaunchDialog(QDialog, Ui_LaunchDialog):
                 ["mac", self.core.get_game_and_dlc_list, (True, "Mac")],
                 ["assets", self.core.egs.get_game_assets, ()],
                 ["no_assets", self.core.get_non_asset_library_items, ()],
-                ["saves", self.core.get_save_games, ()]
             ]
             for r in api_requests:
                 worker = ApiRequestWorker(*r)
                 worker.signals.result.connect(self.handle_api_worker_result)
                 self.thread_pool.start(worker)
 
+            cloud_worker = CloudWorker()
+            cloud_worker.signals.result_ready.connect(lambda x: self.handle_api_worker_result(x, "saves"))
+            self.thread_pool.start(cloud_worker)
+
         else:
             self.finished = True
             self.api_results.game_list, self.api_results.dlcs = self.core.get_game_and_dlc_list(False)

rare/components/tabs/games/__init__.py

@@ -43,6 +43,7 @@ class GamesTab(QStackedWidget, Ui_GamesTab):
         self.settings = QSettings()
         self.game_utils = GameUtils(parent=self)
         self.before_launch_sync = dict()
+        shared.api_results.saves = []
 
         self.game_list = shared.api_results.game_list
         self.dlcs = shared.api_results.dlcs

rare/components/tabs/games/cloud_save_utils.py

@@ -51,6 +51,16 @@ class SaveWorker(QRunnable):
             self.signals.finished.emit(str(e), self.model.app_name)
             logger.error(str(e))
             return
+        try:
+            if isinstance(self.model, UploadModel):
+                logger.info("Updating cloud saves...")
+                result = shared.core.get_save_games(self.model.app_name)
+                shared.api_results.saves = result
+        except Exception as e:
+            self.signals.finished.emit(str(e), self.model.app_name)
+            logger.error(str(e))
+            return
+
         self.signals.finished.emit("", self.model.app_name)
 
 
@@ -106,18 +116,22 @@ class CloudSaveUtils(QObject):
         self.core = shared.core
         saves = shared.api_results.saves
 
+        self.latest_saves = self.get_latest_saves(saves)
+
+        self.thread_pool = QThreadPool.globalInstance()
+
+    def get_latest_saves(self, saves):
         save_games = set()
         for igame in self.core.get_installed_list():
             game = self.core.get_game(igame.app_name)
             if self.core.is_installed(igame.app_name) and game.supports_cloud_saves:
                 save_games.add(igame.app_name)
 
-        self.latest_saves = dict()
+        latest_saves = dict()
         for s in sorted(saves, key=lambda a: a.datetime):
             if s.app_name in save_games:
-                self.latest_saves[s.app_name] = s
-
-        self.thread_pool = QThreadPool.globalInstance()
+                latest_saves[s.app_name] = s
+        return latest_saves
 
     def sync_before_launch_game(self, app_name) -> bool:
         igame = self.core.get_installed_game(app_name)
@@ -189,7 +203,9 @@ class CloudSaveUtils(QObject):
 
     def worker_finished(self, error_message: str, app_name: str):
         if not error_message:
+
             self.sync_finished.emit(app_name, False)
+            self.latest_saves = self.get_latest_saves(shared.api_results.saves)
         else:
             QMessageBox.warning(None, "Warning", self.tr("Syncing with cloud failed: \n ") + error_message)
             self.sync_finished.emit(app_name, True)

rare/components/tabs/games/game_widgets/installed_icon_widget.py

@@ -70,7 +70,7 @@ class InstalledIconWidget(BaseInstalledWidget):
         if self.game_running:
             self.info_label.setText(self.texts["hover"]["running"])
         elif not self.is_origin and self.igame.needs_verification:
-            self.info_label.setText(self.texts["hover"]["needs_verification"])
+            self.info_label.setText(self.texts["needs_verification"])
         elif self.update_available:
             self.info_label.setText(self.texts["hover"]["update_available"])
         else:

rare/components/tabs/settings/__init__.py

@@ -1,5 +1,6 @@
 import platform
 
+from rare import shared
 from rare.utils.extra_widgets import SideTabWidget
 from .about import About
 from .legendary import LegendarySettings
@@ -23,3 +24,4 @@ class SettingsTab(SideTabWidget):
         self.addTab(self.about, "About (!)" if self.about.update_available else "About")
 
         self.setCurrentIndex(0)
+        print(shared.api_results.saves)

rare/utils/utils.py

@@ -11,6 +11,7 @@ from typing import Tuple
 import requests
 from PyQt5.QtCore import pyqtSignal, pyqtSlot, QObject, QRunnable, QSettings, Qt
 from PyQt5.QtGui import QPalette, QColor, QPixmap, QImage
+from requests import HTTPError
 
 from .models import PathSpec
 
@@ -19,7 +20,7 @@ from .models import PathSpec
 if platform.system() == "Windows":
     from win32com.client import Dispatch  # pylint: disable=E0401
 
-from rare import languages_path, resources_path, image_dir
+from rare import languages_path, resources_path, image_dir, shared
 # Mac not supported
 
 from legendary.core import LegendaryCore
@@ -415,3 +416,21 @@ class WineResolver(QRunnable):
         # pylint: disable=E1136
         self.signals.result_ready[str].emit(real_path)
         return
+
+
+class CloudResultSignal(QObject):
+    result_ready = pyqtSignal(list)  # List[SaveGameFile]
+
+
+class CloudWorker(QRunnable):
+    def __init__(self):
+        super(CloudWorker, self).__init__()
+        self.signals = CloudResultSignal()
+        self.setAutoDelete(True)
+
+    def run(self) -> None:
+        try:
+            result = shared.core.get_save_games()
+        except HTTPError():
+            result = None
+        self.signals.result_ready.emit(result)