nsarchive 3.0.0a8__py3-none-any.whl → 3.0.0b2__py3-none-any.whl

nsarchive/models/base.py

@@ -2,7 +2,7 @@ import json
 import requests
 import typing
 
-from .. import utils
+from .. import utils, errors
 
 VERSION = 300
 
@@ -12,27 +12,25 @@ class NSID(str):
 
     ID unique et universel pour l'ensemble des entités et évènements. Il prend les `int`, les `str` et les autres instances `NSID` pour les convertir en un identifiant hexadécimal.
     """
+
     unknown = "0"
+
     admin = "1"
     gov = "2"
     court = "3"
     assembly = "4"
-    office = "5"
-    hexabank = "6"
-    archives = "7"
 
-    maintenance_com = "101"
-    audiovisual_dept = "102"
-    interior_dept = "103"
-    justice_dept = "104"
-    egalitary_com = "105"
-    antifraud_dept = "106"
+    tresor_public = "A"
+    office = "B"
+    hexabank = "C"
 
     def __new__(cls, value):
         if type(value) == int:
             value = hex(value)
         elif type(value) in (str, NSID):
             value = hex(int(value, 16))
+        elif value is None:
+            value = hex(int(cls.unknown, 16))
         else:
             raise TypeError(f"<{value}> is not NSID serializable")
 
@@ -57,6 +55,10 @@ class Interface:
             "Content-Type": "application/json",
         }
 
+        return
+
+        # Vérification (ralentit considérablement les requêtes)*
+
         try:
             test_res = requests.get(f'{self.url}/ping')
 
@@ -95,30 +97,36 @@ class Interface:
             "password": password
         })
 
-        if res.status_code == 200:
-            return res.json()["token"]
-        elif res.status_code in (401, 403):
-            raise PermissionError(res.json()['message'])
-        else:
-            raise Exception(f"Error {res.status_code}: {res.json()['message']}")
 
-    def _get_item(self, endpoint: str, body: dict = None, headers: dict = None) -> dict:
-        """
-        Récupère des données JSON depuis l'API
+        if 500 <= res.status_code < 600:
+            raise errors.globals.ServerDownError()
 
-        ## Paramètres
-        endpoint: `str`:
-            Endpoint de l'URL
-        headers: `dict` (optional)
-            Headers à envoyer
-        body: `dict` (optional)
-            Données à envoyer
+        _data = res.json()
 
-        ## Renvoie
-        - `list` de tous les élements correspondants
-        - `None` si aucune donnée n'est trouvée
+        if res.status_code == 400:
+            if _data['message'] == "MissingParam":
+                raise errors.globals.MissingParamError(f"Missing parameter '{_data['param']}'.")
+            elif _data['message'] == "InvalidParam":
+                raise errors.globals.InvalidParamError(f"Invalid parameter '{_data['param']}'.")
+            elif _data['message'] == "InvalidToken":
+                raise errors.globals.AuthError("Token is not valid.")
+
+        elif res.status_code == 401:
+            raise errors.globals.AuthError(_data['message'])
+
+        elif res.status_code == 403:
+            raise errors.globals.PermissionError(_data['message'])
+
+
+        return _data['token']
+
+    def _get_item(self, endpoint: str, body: dict = None, headers: dict = None) -> dict:
+        """
+        Obsolète.
         """
 
+        utils.warn("La fonction 'Interface._get_item' est obsolète et sera supprimée dans la version 3.0.0 de NSArchive.")
+
         if not headers:
             headers = self.default_headers
 
@@ -138,19 +146,14 @@ class Interface:
 
         return _data
 
-    def _put_in_db(self, endpoint: str, body: dict, headers: dict = None, use_PUT: bool = False) -> None:
+    def _put_in_db(self, endpoint: str, body: dict = {}, headers: dict = None, use_PUT: bool = False) -> None:
         """
-        Publie des données JSON dans une table nation-db.
-
-        ## Paramètres
-        endpoint: `str`
-            Endpoint de l'URL
-        body: `dict`
-            Données à envoyer
-        headers: `dict` (optionnel)
-            Headers à envoyer
+        Obsolète
         """
 
+        utils.warn("La fonction 'Interface._put_in_db' est obsolète et sera supprimée dans la version 3.0.0 de NSArchive.")
+
+
         if not headers:
             headers = headers
 
@@ -162,20 +165,15 @@ class Interface:
         if 200 <= res.status_code < 300:
             return res.json()
         else:
-            print(res.text)
             res.raise_for_status()
 
     def _delete(self, _class: str, ids: list[NSID]) -> None:
         """
-        Supprime des données JSON dans une table nation-db.
-
-        ## Paramètres
-        _class: `str`
-            Classe des entités à supprimer
-        ids: `list[NSID]`
-            ID des entités à supprimer
+        Obsolète
         """
 
+        utils.warn("La fonction 'Interface._delete' est obsolète et sera supprimée dans la version 3.0.0 de NSArchive.")
+
         res = requests.post(f"{self.url}/delete_{_class}", json = { "ids": ids })
 
         if 200 <= res.status_code < 300:
@@ -185,21 +183,33 @@ class Interface:
         else:
             raise Exception(f"Error {res.status_code}: {res.json()['message']}")
 
-    def _delete_by_ID(self, _class: str, id: NSID):
-        utils.warn("Method '_delete_by_id' is deprecated. Use '_delete' instead.")
-        self._delete(_class, id)
-
     def fetch(self, _class: str, **query: typing.Any) -> list:
         res = requests.get(f"{self.url}/fetch/{_class}", params = query)
 
-        if res.status_code == 200:
-            matches = res.json()
-        elif res.status_code in (401, 403):
-            matches = []
-        else:
-            res.raise_for_status()
+        if 500 <= res.status_code < 600:
+            raise errors.globals.ServerDownError()
+
+        _data = res.json()
+
+        if res.status_code == 400:
+            if _data['message'] == "MissingParam":
+                raise errors.globals.MissingParamError(f"Missing parameter '{_data['param']}'.")
+            elif _data['message'] == "InvalidParam":
+                raise errors.globals.InvalidParamError(f"Invalid parameter '{_data['param']}'.")
+            elif _data['message'] == "InvalidToken":
+                raise errors.globals.AuthError("Token is not valid.")
+
+        elif res.status_code == 401:
+            raise errors.globals.AuthError(_data['message'])
+
+        elif res.status_code == 403:
+            raise errors.globals.PermissionError(_data['message'])
+
+        elif res.status_code == 404:
+            return []
+
 
-        return matches
+        return res.json()
 
 
     def _upload_file(self, bucket: str, name: str, data: bytes, overwrite: bool = False, headers: dict = None) -> dict:
@@ -236,14 +246,28 @@ class Interface:
 
         res = requests.put(f"{self.url}/upload_file/{bucket}", headers = headers, json = body, files = [ file ])
 
-        if res.status_code == 200:
-            return res.json()
-        elif res.status_code in (403, 401):
-            raise PermissionError(res.json()['message'])
+
+        if 500 <= res.status_code < 600:
+            raise errors.globals.ServerDownError()
+
+        _data = res.json()
+
+        if res.status_code == 400:
+            if _data['message'] == "MissingParam":
+                raise errors.globals.MissingParamError(f"Missing parameter '{_data['param']}'.")
+            elif _data['message'] == "InvalidParam":
+                raise errors.globals.InvalidParamError(f"Invalid parameter '{_data['param']}'.")
+            elif _data['message'] == "InvalidToken":
+                raise errors.globals.AuthError("Token is not valid.")
+
+        elif res.status_code == 401:
+            raise errors.globals.AuthError(_data['message'])
+
+        elif res.status_code == 403:
+            raise errors.globals.PermissionError(_data['message'])
+
         elif res.status_code == 409:
-            raise FileExistsError(res.json()['message'])
-        else:
-            raise Exception(f"Error {res.status_code}: {res.json()['message']}") 
+            raise errors.globals.ConflictError(_data['message'])
 
     def _download_from_storage(self, bucket: str, path: str, headers: dict = None) -> bytes:
         """
@@ -264,9 +288,27 @@ class Interface:
 
         res = requests.get(f"{self.url}/drive/{bucket}/{path}", headers = headers)
 
-        if res.status_code == 200:
-            return res.json()
-        elif res.status_code in (403, 401):
-            raise PermissionError(res.json()['message'])
-        else:
-            raise Exception(f"Error {res.status_code}: {res.json()['message']}") 
+
+        if 500 <= res.status_code < 600:
+            raise errors.globals.ServerDownError()
+
+        _data = res.json()
+
+        if res.status_code == 400:
+            if _data['message'] == "MissingParam":
+                raise errors.globals.MissingParamError(f"Missing parameter '{_data['param']}'.")
+            elif _data['message'] == "InvalidParam":
+                raise errors.globals.InvalidParamError(f"Invalid parameter '{_data['param']}'.")
+            elif _data['message'] == "InvalidToken":
+                raise errors.globals.AuthError("Token is not valid.")
+
+        elif res.status_code == 401:
+            raise errors.globals.AuthError(_data['message'])
+
+        elif res.status_code == 403:
+            raise errors.globals.PermissionError(_data['message'])
+
+        elif res.status_code == 404:
+            return
+
+        return _data

nsarchive/models/economy.py

@@ -3,6 +3,7 @@ import time
 import urllib
 
 from .base import NSID
+from .. import errors
 
 
 class BankAccount:
@@ -64,9 +65,27 @@ class BankAccount:
 
         if res.status_code == 200:
             self.frozen = frozen
-        else:
-            print(res.text)
-            res.raise_for_status()
+        elif 500 <= res.status_code < 600:
+            raise errors.globals.ServerDownError()
+
+        _data = res.json()
+
+        if res.status_code == 400:
+            if _data['message'] == "MissingParam":
+                raise errors.globals.MissingParamError(f"Missing parameter '{_data['param']}'.")
+            elif _data['message'] == "InvalidParam":
+                raise errors.globals.InvalidParamError(f"Invalid parameter '{_data['param']}'.")
+            elif _data['message'] == "InvalidToken":
+                raise errors.globals.AuthError("Token is not valid.")
+
+        elif res.status_code == 401:
+            raise errors.globals.AuthError(_data['message'])
+
+        elif res.status_code == 403:
+            raise errors.globals.PermissionError(_data['message'])
+
+        elif res.status_code == 404:
+            raise errors.globals.NotFoundError(_data['message'])
 
     def flag(self, flagged: bool = True, reason: str = None) -> None:
         res = requests.post(f"{self._url}/flag?flagged={str(flagged).lower()}", headers = self._headers, json = {
@@ -75,8 +94,27 @@ class BankAccount:
 
         if res.status_code == 200:
             self.flagged = flagged
-        else:
-            res.raise_for_status()
+        elif 500 <= res.status_code < 600:
+            raise errors.globals.ServerDownError()
+
+        _data = res.json()
+
+        if res.status_code == 400:
+            if _data['message'] == "MissingParam":
+                raise errors.globals.MissingParamError(f"Missing parameter '{_data['param']}'.")
+            elif _data['message'] == "InvalidParam":
+                raise errors.globals.InvalidParamError(f"Invalid parameter '{_data['param']}'.")
+            elif _data['message'] == "InvalidToken":
+                raise errors.globals.AuthError("Token is not valid.")
+
+        elif res.status_code == 401:
+            raise errors.globals.AuthError(_data['message'])
+
+        elif res.status_code == 403:
+            raise errors.globals.PermissionError(_data['message'])
+
+        elif res.status_code == 404:
+            raise errors.globals.NotFoundError(_data['message'])
 
     def debit(self, amount: int, reason: str = None, target: NSID = None, loan: NSID = None, digicode: str = None) -> None:
         _target_query = f"&target={target}"
@@ -89,163 +127,53 @@ class BankAccount:
 
         if res.status_code == 200:
             self.amount -= amount
-        else:
-            res.raise_for_status()
-
-    def deposit(self, amount: int, reason: str = None) -> None:
-        res = requests.post(f"{self._url}/deposit?amount={amount}", headers = self._headers, json = {
-            "reason": reason,
-        })
-
-        if res.status_code == 200:
-            self.amount -= amount
-        else:
-            res.raise_for_status()
-
-class Item:
-    """
-    Article d'inventaire qui peut circuler sur le serveur
+        elif 500 <= res.status_code < 600:
+            raise errors.globals.ServerDownError()
 
-    ## Attributs
-    - id: `NSID`\n
-        Identifiant de l'objet
-    - name: `str`\n
-        Nom de l'objet
-    - emoji: `str`\n
-        Emoji lié à l'objet
-    """
-
-    def __init__(self) -> None:
-        self._url: str = ""
-        self._headers: dict = {}
+        _data = res.json()
 
-        self.id: NSID = NSID(round(time.time()))
-        self.name: str = "Unknown Object"
-        self.emoji: str = ":light_bulb:"
-        self.category: str = "common"
-        self.craft: dict = {}
+        if res.status_code == 400:
+            if _data['message'] == "MissingParam":
+                raise errors.globals.MissingParamError(f"Missing parameter '{_data['param']}'.")
+            elif _data['message'] == "InvalidParam":
+                raise errors.globals.InvalidParamError(f"Invalid parameter '{_data['param']}'.")
+            elif _data['message'] == "InvalidToken":
+                raise errors.globals.AuthError("Token is not valid.")
 
-    def _load(self, _data: dict, url: str, headers: dict) -> None:
-        self._url = url + '/marketplace/items/' + _data['id']
-        self._headers = headers
+        elif res.status_code == 401:
+            raise errors.globals.AuthError(_data['message'])
 
-        self.id = NSID(_data['id'])
+        elif res.status_code == 403:
+            raise errors.globals.PermissionError(_data['message'])
 
-        self.name = _data['name']
-        self.emoji = _data['emoji']
-        self.category = _data['category']
-        self.craft = _data['craft']
+        elif res.status_code == 404:
+            raise errors.globals.NotFoundError(_data['message'])
 
-    def rename(self, new_name: str):
-        res = requests.post(f"{self._url}/rename?name={new_name}", headers = self._headers)
+    def deposit(self, amount: int, reason: str = None) -> None:
+        res = requests.post(f"{self._url}/deposit?amount={amount}", headers = self._headers, json = {
+            "reason": reason,
+        })
 
         if res.status_code == 200:
-            self.name = new_name
-        else:
-            res.raise_for_status()
-
-class Sale:
-    """
-    Vente mettant en jeu un objet
-
-    ## Attributs
-    - id: `NSID`\n
-        Identifiant de la vente
-    - item: `NSID`\n
-        Identifiant de l'objet mis en vente
-    - quantity: `int`\n
-        Quantité d'objets mis en vente
-    - price: `int`\n
-        Prix total du lot
-    - seller_id: `NSID`\n
-        Identifiant du vendeur
-    """
-
-    def __init__(self, item: Item) -> None:
-        self._url: str = ""
-        self._headers: dict = {}
-
-        self.id: NSID = NSID(round(time.time()))
-        self.open: bool = True
-        self.seller_id: NSID = NSID('0')
-
-        self.item_id: NSID = NSID(item.id)
-        self.quantity: int = 1
-        self.price: int = 0
-
-    def _load(self, _data: dict, url: str, headers: dict) -> None:
-        self._url = url + '/marketplace/sales/' + _data['id']
-        self._headers = headers
-
-        self.id = _data['id']
-        self.open = _data['open']
-        self.seller_id = NSID(_data['seller_id'])
-
-        self.item_id = NSID(_data['item_id'])
-        self.quantity = _data['quantity']
-        self.price = _data['price']
-
-class Inventory:
-    """
-    Inventaire d'un membre
-
-    ## Attributs
-    - id: `NSID`\n
-        ID de l'inventaire
-    - owner_id: `NSID`\n
-        ID du propriétaire de l'inventaire
-    - tag: `str`\n
-        Étiquette de l'inventaire
-    - register_date: `int`\n
-        Date (timestamp) de création de l'inventaire
-    - items: `dict[NSID, int]`\n
-        Collection d'objets et leur quantité
-    """
-
-    def __init__(self, owner_id: NSID) -> None:
-        self._url: str = ""
-        self._headers: dict = {}
-
-        self.id: NSID = NSID(owner_id)
-        self.owner_id: NSID = NSID(owner_id)
-
-        self.tag: str = "inconnu"
-        self.register_date: int = 0
-
-        self.items: dict[NSID, int] = {}
-
-    def _load(self, _data: dict, url: str, headers: dict):
-        self._url = url + '/bank/inventories/' + _data['id']
-        self._headers = headers
-
-        self.id = NSID(_data['id'])
-        self.owner_id = NSID(_data['owner_id'])
+            self.amount -= amount
+        elif 500 <= res.status_code < 600:
+            raise errors.globals.ServerDownError()
 
-        self.tag = _data['tag']
-        self.register_date = _data['register_date']
+        _data = res.json()
 
-        self.items = _data['items']
+        if res.status_code == 400:
+            if _data['message'] == "MissingParam":
+                raise errors.globals.MissingParamError(f"Missing parameter '{_data['param']}'.")
+            elif _data['message'] == "InvalidParam":
+                raise errors.globals.InvalidParamError(f"Invalid parameter '{_data['param']}'.")
+            elif _data['message'] == "InvalidToken":
+                raise errors.globals.AuthError("Token is not valid.")
 
-    def deposit_item(self, item: Item, giver: NSID = None, quantity: int = 1, digicode: str = None):
-        res = requests.post(f"{self._url}/deposit?item={item.id}&amount={quantity}", headers = self._headers, json = {
-            "giver": giver,
-            "digicode": digicode
-        })
+        elif res.status_code == 401:
+            raise errors.globals.AuthError(_data['message'])
 
-        if res.status_code == 200:
-            if self.objects[item.id] > quantity:
-                self.objects[item.id] -= quantity
-            else:
-                self.objects[item.id] = 0
-        else:
-            res.raise_for_status()
-
-    def sell_item(self, item: Item, price: int, quantity: int = 1, digicode: str = None) -> NSID:
-        res = requests.post(f"{self._url}/sell_item?item={item.id}&quantity={quantity}&price={price}", headers = self._headers, json = {
-            "digicode": digicode
-        })
+        elif res.status_code == 403:
+            raise errors.globals.PermissionError(_data['message'])
 
-        if res.status_code == 200:
-            return NSID(res.json()['sale_id'])
-        else:
-            res.raise_for_status()
+        elif res.status_code == 404:
+            raise errors.globals.NotFoundError(_data['message'])