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

nsarchive/models/entities.py

@@ -1,19 +1,17 @@
 import requests
 import time
 import typing
-import urllib
-import warnings
 
 from .base import NSID
 
-from .. import utils
+from .. import errors
 
 class Permission:
     def __init__(self, initial: str = "----"):
-        self.append: bool
-        self.manage: bool
-        self.edit: bool
-        self.read: bool
+        self.append: bool = False
+        self.manage: bool = False
+        self.edit: bool = False
+        self.read: bool = False
 
         self.load(initial)
 
@@ -90,14 +88,33 @@ class Position:
         return self.id
 
     def update_permisions(self, **permissions: str):
-        query = "&".join(f"{k}={ urllib.parse.quote(v) }" for k, v in permissions.items())
+        query = "&".join(f"{k}={v}" for k, v in permissions.items())
 
         res = requests.post(f"{self._url}/update_permissions?{query}", headers = self._headers)
 
         if res.status_code == 200:
             self.permissions.merge(permissions)
-        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 _load(self, _data: dict, url: str, headers: dict) -> None:
         self._url = url + '/model/positions/' + _data['id']
@@ -163,11 +180,33 @@ class Entity:
 
         if res.status_code == 200:
             self.name = new_name
-        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'])
 
-    def set_position(self, position: Position) -> None:
-        res = requests.post(f"{self._url}/change_position?position={position.id}", headers = self._headers)
+        elif res.status_code == 403:
+            raise errors.globals.PermissionError(_data['message'])
+
+        elif res.status_code == 404:
+            raise errors.globals.NotFoundError(_data['message'])
+
+    def set_position(self, position: str | Position) -> None:
+        if isinstance(position, Position):
+            position: str = position.id
+
+        res = requests.post(f"{self._url}/change_position?position={position}", headers = self._headers)
 
         if res.status_code == 200:
             self.position = position
@@ -188,23 +227,60 @@ class Entity:
             "type": _class
         }
 
-        query = "&".join(f"{k}={ urllib.parse.quote(v) }" for k, v in params.items())
+        query = "&".join(f"{k}={v}" for k, v in params.items())
 
         res = requests.post(f"{self._url}/add_link?{query}", headers = self._headers)
 
         if res.status_code == 200:
             self.additional[key] = value
-        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 unlink(self, key: str) -> None:
-        res = requests.post(f"{self._url}/remove_link?link={urllib.parse.quote(key)}", headers = self._headers)
+        res = requests.post(f"{self._url}/remove_link?link={key}", headers = self._headers)
 
         if res.status_code == 200:
             del self.additional[key]
-        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'])
 
 class User(Entity):
     """
@@ -261,8 +337,27 @@ class User(Entity):
 
         if res.status_code == 200:
             self.xp += amount * boost
-        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 edit_boost(self, name: str, multiplier: int = -1) -> None:
         res = requests.post(f"{self._url}/edit_boost?boost={name}&multiplier={multiplier}", headers = self._headers)
@@ -272,8 +367,27 @@ class User(Entity):
                 self.boosts[name] = multiplier
             else:
                 del self.boosts[name]
-        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 get_groups(self) -> list[Entity]:
         res = requests.get(f"{self._url}/groups", headers = self._headers)
@@ -291,35 +405,107 @@ class User(Entity):
                 groups.append(group)
 
             return groups
-        else:
-            return []
+        elif 500 <= res.status_code < 600:
+            raise errors.globals.ServerDownError()
 
-class GroupPermissions:
-    """
-    Permissions d'un membre à l'échelle d'un groupe
-    """
+        _data = res.json()
 
-    def __init__(self) -> None:
-        self.manage_organization = False # Renommer l'organisation, changer le logo
-        self.manage_roles = False # Changer les rôles des membres
-        self.manage_members = False # Virer quelqu'un d'une entreprise, l'y inviter
+        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'])
 
-    def edit(self, **permissions: bool) -> None:
-        for perm in permissions.values():
-            self.__setattr__(*perm)
+        elif res.status_code == 403:
+            raise errors.globals.PermissionError(_data['message'])
+
+        elif res.status_code == 404:
+            raise errors.globals.NotFoundError(_data['message'])
 
 class GroupMember:
     """
     Membre au sein d'une entité collective
 
     ## Attributs
-    - permissions: `.GroupPermissions`\n
-        Permissions du membre au sein du groupe
+    - level: `int`\n
+        Niveau d'accréditation d'un membre au sein d'un groupe
+    - manager: `bool`\n
+        Permission ou non de modifier le groupe
     """
 
     def __init__(self, id: NSID) -> None:
+        self._group_url: str
+        self._headers: dict
+
         self.id = id
-        self.permissions: GroupPermissions = GroupPermissions()
+        self.level: int = 1 # Plus un level est haut, plus il a de pouvoir sur les autres membres
+        self.manager: bool = False
+
+    def _load(self, _data: dict, group_url: str, headers: dict):
+        self._group_url = group_url
+        self._headers = headers
+
+        self.level = _data['level']
+        self.manager = _data['manager']
+
+    def edit(self, level: int = None, manager: bool = None) -> None:
+        params = {
+            "member": self.id
+        }
+
+        if level is not None: params['level'] = level
+        if manager is not None: params['manager'] = str(manager).lower()
+
+        res = requests.post(f"{self._group_url}/edit_member", params = params, headers = self._headers)
+
+        if res.status_code == 200:
+            if level:
+                self.level = level
+            else:
+                return
+
+            if manager is not None:
+                self.manager = manager
+
+        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 promote(self, level: int = None):
+        if level is None:
+            level = self.level + 1
+
+        self.edit(level = level)
+
+    def demote(self, level: int = None):
+        if level is None:
+            level = self.level - 1
+
+        self.edit(level = level)
+
 
 class Organization(Entity):
     """
@@ -329,14 +515,12 @@ class Organization(Entity):
     - Tous les attributs de la classe `.Entity`
     - owner: `.Entity`\n
         Utilisateur ou entreprise propriétaire de l'entité collective
-    - avatar: `bytes`\n
-        Avatar/logo de l'entité collective
-    - certifications: `dict[str, int]`\n
+    - avatar_url: `str`\n
+        Url du logo de l'entité collective
+    - certifications: `dict[str, Any]`\n
         Liste des certifications et de leur date d'ajout
     - members: `list[.GroupMember]`\n
         Liste des membres de l'entreprise
-    - parts: `list[.Share]`\n
-        Liste des actions émises par l'entreprise
     """
 
     def __init__(self, id: NSID) -> None:
@@ -346,10 +530,11 @@ class Organization(Entity):
         self.avatar_url: str = self._url + '/avatar'
 
         self.certifications: dict = {}
-        self.members: list[GroupMember] = []
+        self.members: dict[NSID, GroupMember] = {}
 
     def _load(self, _data: dict, url: str, headers: dict):
         self._url = url + '/model/organizations/' + _data['id']
+        self.avatar_url = url + '/avatar'
         self._headers = headers
 
         self.id = NSID(_data['id'])
@@ -375,11 +560,11 @@ class Organization(Entity):
 
         self.owner._load(_owner, url, headers)
 
-        for _member in _data['members']:
-            member = GroupMember(_member['id'])
-            member.permission_level = _member['level']
+        for _id, _member in _data['members'].items():
+            member = GroupMember(_id)
+            member._load(_member, self._url, headers)
 
-            self.members.append(member)
+            self.members[member.id] = member
 
         self.certifications = _data['certifications']
 
@@ -388,8 +573,27 @@ class Organization(Entity):
 
         if res.status_code == 200:
             self.certifications[certification] = int(round(time.time()) + __expires)
-        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 has_certification(self, certification: str) -> bool:
         return certification in self.certifications.keys()
@@ -399,44 +603,76 @@ class Organization(Entity):
 
         if res.status_code == 200:
             del self.certifications[certification]
-        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.")
 
-    def add_member(self, member: NSID, permissions: GroupPermissions = GroupPermissions()) -> None:
+        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 add_member(self, member: NSID) -> GroupMember:
         if not isinstance(member, NSID):
             raise TypeError("L'entrée membre doit être de type NSID")
 
-        res = requests.post(f"{self._url}/add_member?id={member}", headers = self._headers, json = {
-            "permissions": permissions.__dict__
-        })
+        res = requests.post(f"{self._url}/add_member?member={member}", headers = self._headers, json = {})
 
         if res.status_code == 200:
             member = GroupMember(member)
-            member.permissions = permissions
+            member._group_url = self._url
+            member._headers = self._headers
 
-            self.members.append(member)
-        else:
-            res.raise_for_status()
+            self.members[member.id] = member
+            return member
+        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 remove_member(self, member: GroupMember) -> None:
-        requests.post(f"{self._url}/remove_member?id={member.id}", headers = self._headers)
+        member.demote(level = 0)
 
-        for _member in self.members:
-            if _member.id == member.id:
-                self.members.remove(_member)
+        del self.members[member.id]
 
     def set_owner(self, member: User) -> None:
         self.owner = member
 
     def get_member(self, id: NSID) -> GroupMember:
-        for member in self.members:
-            if member.id == id:
-                return member
-        else:
-            return
+        return self.members.get(id)
 
     def get_members_by_attr(self, attribute: str = "id") -> list[str]:
-        return [ member.__getattribute__(attribute) for member in self.members ]
+        return [ member.__getattribute__(attribute) for member in self.members.values() ]
 
     def save_avatar(self, data: bytes = None):
         pass

nsarchive/models/justice.py

@@ -3,6 +3,8 @@ import time
 
 from .base import NSID
 
+from .. import errors
+
 class Report:
     def __init__(self, id: NSID):
         self._url: str = ""
@@ -46,8 +48,27 @@ class Report:
 
         if res.status_code == 200:
             self.status = status
-        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'])
 
 class Sanction:
     def __init__(self, id: NSID):
@@ -60,7 +81,7 @@ class Sanction:
         self.date: int = round(time.time())
         self.duration: int = 0
         self.title: str = None
-        self.case: NSID = NSID('0')
+        self.lawsuit: NSID = NSID('0')
 
     def _load(self, _data: dict, url: str, headers: dict) -> None:
         self._url = url
@@ -72,7 +93,7 @@ class Sanction:
         self.date = _data['date']
         self.duration = _data['duration']
         self.title = _data['title']
-        self.case = NSID(_data['case'])
+        self.lawsuit = NSID(_data['lawsuit'])
 
 class Lawsuit:
     def __init__(self, id: NSID):