snapctl 0.32.0__py3-none-any.whl → 0.32.2__py3-none-any.whl

snapctl/commands/game.py

@@ -4,10 +4,13 @@
 import requests
 from requests.exceptions import RequestException
 
+import typer
 from rich.progress import Progress, SpinnerColumn, TextColumn
-from snapctl.config.constants import SERVER_CALL_TIMEOUT
-from snapctl.types.definitions import ResponseType
+from snapctl.config.constants import SERVER_CALL_TIMEOUT, SNAPCTL_INPUT_ERROR, \
+    SNAPCTL_SUCCESS, SNAPCTL_GAME_CREATE_ERROR, SNAPCTL_GAME_ENUMERATE_ERROR, \
+    HTTP_ERROR_DUPLICATE_GAME_NAME, SNAPCTL_GAME_CREATE_DUPLICATE_NAME_ERROR
 from snapctl.utils.echo import error, success
+from snapctl.utils.helper import snapctl_error, snapctl_success
 
 
 class Game:
@@ -23,85 +26,88 @@ class Game:
         self.base_url: str = base_url
         self.api_key: str = api_key
         self.name: str | None = name
+        # Validate input
+        self.validate_input()
 
-    def validate_input(self) -> ResponseType:
+    def validate_input(self) -> None:
         """
           Validator
         """
-        response: ResponseType = {
-            'error': True,
-            'msg': '',
-            'data': []
-        }
         # Check API Key and Base URL
         if not self.api_key or self.base_url == '':
-            response['msg'] = "Missing API Key."
-            return response
+            snapctl_error("Missing API Key.", SNAPCTL_INPUT_ERROR)
         # Check subcommand
         if not self.subcommand in Game.SUBCOMMANDS:
-            response['msg'] = \
-                f"Invalid command. Valid commands are {', '.join(Game.SUBCOMMANDS)}."
-            return response
+            snapctl_error(
+                f"Invalid command. Valid commands are {', '.join(Game.SUBCOMMANDS)}.",
+                SNAPCTL_INPUT_ERROR)
         # Check sdk-download commands
         if self.subcommand == 'create':
             if self.name is None or self.name == '':
-                response['msg'] = "Missing game name."
-                return response
-        # Send success
-        response['error'] = False
-        return response
+                snapctl_error("Missing game name.", SNAPCTL_INPUT_ERROR)
 
     def create(self) -> bool:
         """
           Create a game
         """
-        with Progress(
+        progress = Progress(
             SpinnerColumn(),
             TextColumn("[progress.description]{task.description}"),
             transient=True,
-        ) as progress:
-            progress.add_task(
-                description='Creating a new game on Snapser...', total=None)
-            try:
-                url = f"{self.base_url}/v1/snapser-api/games"
-                payload = {
-                    'name': self.name
-                }
-                res = requests.post(
-                    url, headers={'api-key': self.api_key},
-                    json=payload, timeout=SERVER_CALL_TIMEOUT
-                )
-                if res.ok:
-                    success(f"Game {self.name} has been created successfully.")
-                    return True
-                error('Unable to create a new game. Reason: ' + res.text)
-            except RequestException as e:
-                error(f"Exception: Unable to download the SDK {e}")
-            return False
+        )
+        progress.start()
+        progress.add_task(
+            description='Creating a new game on Snapser...', total=None)
+        try:
+            url = f"{self.base_url}/v1/snapser-api/games"
+            payload = {
+                'name': self.name
+            }
+            res = requests.post(
+                url, headers={'api-key': self.api_key},
+                json=payload, timeout=SERVER_CALL_TIMEOUT
+            )
+            if res.ok:
+                snapctl_success(
+                    f"Game {self.name} create successful", progress)
+            response_json = res.json()
+            if "api_error_code" in response_json and "message" in response_json:
+                if response_json['api_error_code'] == HTTP_ERROR_DUPLICATE_GAME_NAME:
+                    snapctl_error(f"Game {self.name} already exists.",
+                                  SNAPCTL_GAME_CREATE_DUPLICATE_NAME_ERROR, progress)
+            snapctl_error(
+                f'Server error: {response_json}', SNAPCTL_GAME_CREATE_ERROR, progress)
+        except RequestException as e:
+            snapctl_error(f"Exception: Unable to download the SDK {e}",
+                          SNAPCTL_GAME_CREATE_ERROR, progress)
+        snapctl_error('Failed to create game.',
+                      SNAPCTL_GAME_CREATE_ERROR, progress)
 
     def enumerate(self) -> bool:
         """
           Enumerate all games
         """
-        with Progress(
+        progress = Progress(
             SpinnerColumn(),
             TextColumn("[progress.description]{task.description}"),
             transient=True,
-        ) as progress:
-            progress.add_task(
-                description='Enumerating all your games...', total=None)
-            try:
-                url = f"{self.base_url}/v1/snapser-api/games"
-                res = requests.get(
-                    url, headers={'api-key': self.api_key},
-                    timeout=SERVER_CALL_TIMEOUT
-                )
-                response_json = res.json()
-                if res.ok:
-                    if 'games' in response_json:
-                        success(response_json['games'])
-                        return True
-                error(response_json)
-            except RequestException as e:
-                error(f"Exception: Unable to update your snapend {e}")
-            return False
+        )
+        progress.start()
+        progress.add_task(
+            description='Enumerating all your games...', total=None)
+        try:
+            url = f"{self.base_url}/v1/snapser-api/games"
+            res = requests.get(
+                url, headers={'api-key': self.api_key},
+                timeout=SERVER_CALL_TIMEOUT
+            )
+            response_json = res.json()
+            if res.ok and 'games' in response_json:
+                snapctl_success(response_json['games'], progress)
+            snapctl_error('Unable to enumerate games.',
+                          SNAPCTL_GAME_ENUMERATE_ERROR, progress)
+        except RequestException as e:
+            snapctl_error(f"Exception: Unable to update your snapend {e}",
+                          SNAPCTL_GAME_ENUMERATE_ERROR, progress)
+        snapctl_error('Failed to enumerate games.',
+                      SNAPCTL_GAME_ENUMERATE_ERROR, progress)

snapctl/commands/generate.py

@@ -2,13 +2,14 @@
     Generate CLI commands
 """
 import json
-from sys import platform
 import os
 from typing import Union
-
+from rich.progress import Progress, SpinnerColumn, TextColumn
+from snapctl.config.constants import SNAPCTL_INPUT_ERROR, \
+    SNAPCTL_GENERATE_GENERIC_ERROR
 from snapctl.config.hashes import BYOSNAP_TEMPLATE
-from snapctl.types.definitions import ResponseType
-from snapctl.utils.echo import error, success
+from snapctl.utils.echo import error
+from snapctl.utils.helper import snapctl_error, snapctl_success
 
 
 class Generate:
@@ -26,52 +27,67 @@ class Generate:
         self.base_url: str = base_url
         self.api_key: str = api_key
         self.out_path: Union[str, None] = out_path
+        # Validate input
+        self.validate_input()
 
     # Validator
 
-    def validate_input(self) -> ResponseType:
+    def validate_input(self) -> None:
         """
           Validator
         """
-        response: ResponseType = {
-            'error': True,
-            'msg': '',
-            'data': []
-        }
+        if self.subcommand not in Generate.SUBCOMMANDS:
+            snapctl_error(
+                f"Invalid command {self.subcommand}. Valid command are "
+                f"{Generate.SUBCOMMANDS}",
+                SNAPCTL_INPUT_ERROR
+            )
         if self.subcommand in ['byosnap-profile']:
             # Check path
             if self.out_path and not os.path.isdir(self.out_path):
-                response['msg'] = (
+                snapctl_error(
                     f"Invalid path {self.out_path}. Wont be able to "
-                    "store the byosnap-profile.json file"
+                    "store the byosnap-profile.json file",
+                    SNAPCTL_INPUT_ERROR
                 )
-                return response
-        # Send success
-        response['error'] = False
-        return response
 
-    def byosnap_profile(self) -> bool:
+    def byosnap_profile(self) -> None:
         """
             Generate snapser-byosnap-profile.json
         """
-        file_path_symbol = '/'
-        if platform == 'win32':
-            file_path_symbol = '\\'
-        if self.out_path is not None:
-            file_save_path = f"{self.out_path}{file_path_symbol}{Generate.BYOSNAP_PROFILE_FN}"
-        else:
-            file_save_path = f"{os.getcwd()}{file_path_symbol}{Generate.BYOSNAP_PROFILE_FN}"
+        progress = Progress(
+            SpinnerColumn(),
+            TextColumn("[progress.description]{task.description}"),
+            transient=True,
+        )
+        progress.start()
+        progress.add_task(
+            description='Promoting your staging snapend...', total=None)
         try:
+            if self.out_path is not None:
+                file_save_path = os.path.join(
+                    self.out_path, Generate.BYOSNAP_PROFILE_FN)
+            else:
+                file_save_path = os.path.join(
+                    os.getcwd(), Generate.BYOSNAP_PROFILE_FN)
+            file_written = False
             with open(file_save_path, "w") as file:
                 json.dump(BYOSNAP_TEMPLATE, file, indent=4)
-                success(
-                    f"{Generate.BYOSNAP_PROFILE_FN} saved at {file_save_path}"
+                file_written = True
+            if file_written:
+                snapctl_success(
+                    "BYOSNAP Profile generation successful. "
+                    f"{Generate.BYOSNAP_PROFILE_FN} saved at {file_save_path}",
+                    progress
                 )
-                return True
         except (IOError, OSError) as file_error:
-            error(f"File error: {file_error}")
+            snapctl_error(f"File error: {file_error}",
+                          SNAPCTL_GENERATE_GENERIC_ERROR, progress)
         except json.JSONDecodeError as json_error:
-            error(f"JSON error: {json_error}")
-        except Exception as exception_error:
-            error(f"An unexpected error occurred: {exception_error}")
-        return False
+            snapctl_error(f"JSON error: {json_error}",
+                          SNAPCTL_GENERATE_GENERIC_ERROR, progress)
+        snapctl_error(
+            "Failed to generate BYOSNAP Profile",
+            SNAPCTL_GENERATE_GENERIC_ERROR,
+            progress
+        )