nsarchive 3.0.0a7__py3-none-any.whl → 3.0.0b1__py3-none-any.whl

nsarchive/{cls → models}/entities.py

@@ -8,14 +8,12 @@ from .base import NSID
 
 from .. import utils
 
-default_headers = {}
-
 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)
 
@@ -31,7 +29,9 @@ class PositionPermissions:
     """
 
     def __init__(self) -> None:
+        self.aliases = Permission() # APPEND = faire une requête au nom d'une autre entité, MANAGE = /, EDIT = /, READ = /
         self.bots = Permission() # APPEND = /, MANAGE = proposer d'héberger un bot, EDIT = changer les paramètres d'un bot, READ = /
+        self.candidacies = Permission() # APPEND = se présenter à une élection, MANAGE = gérer les candidatures d'une élection, EDIT = modifier une candidature, READ = /
         self.constitution = Permission() # APPEND = /, MANAGE = /, EDIT = modifier la constitution, READ = /
         self.database = Permission() # APPEND = créer des sous-bases de données, MANAGE = gérer la base de données, EDIT = modifier les éléments, READ = avoir accès à toutes les données sans exception
         self.inventories = Permission("a---") # APPEND = ouvrir un ou plusieurs comptes/inventaires, MANAGE = voir les infos globales concernant les comptes en banque ou inventaires, EDIT = gérer des comptes en banque (ou inventaires), READ = voir les infos d'un compte en banque ou inventaire
@@ -45,6 +45,7 @@ class PositionPermissions:
         self.organizations = Permission("---r") # APPEND = créer une nouvelle organisation, MANAGE = exécuter des actions administratives sur les organisations, EDIT = modifier des organisations, READ = voir le profil de n'importe quelle organisation
         self.reports = Permission() # APPEND = déposer plainte, MANAGE = accépter ou refuser une plainte, EDIT = /, READ = accéder à des infos supplémentaires pour une plainte
         self.sales = Permission("---r") # APPEND = vendre, MANAGE = gérer les ventes, EDIT = modifier des ventes, READ = accéder au marketplace
+        self.sanctions = Permission() # APPEND = sanctionner un membre, MANAGE = gérer les sanctions d'un membre, EDIT = modifier une sanction, READ = accéder au casier d'un membre
         self.state_budgets = Permission() # APPEND = débloquer un nouveau budget, MANAGE = gérer les budjets, EDIT = gérer les sommes pour chaque budjet, READ = accéder aux infos concernant les budgets
         self.votes = Permission() # APPEND = déclencher un vote, MANAGE = fermer un vote, EDIT = /, READ = lire les propriétés d'un vote avant sa fermeture
 
@@ -62,21 +63,28 @@ class Position:
     Position légale d'une entité
 
     ## Attributs
-    - name: `str`\n
-        Titre de la position
     - id: `str`\n
         Identifiant de la position
+    - name: `str`\n
+        Titre de la position
+    - is_global_scope: `str`\n
+        Permet de savoir si la position a des permissions en dehors de sa zone
     - permissions: `.PositionPermissions`\n
         Permissions accordées à l'utilisateur
+    - manager_permissions: `.PositionPermissions`\n
+        Permissions nécessaires pour gérer la position
     """
 
-    def __init__(self, id: str = 'inconnu') -> None:
-        self.name: str = "Inconnue"
+    def __init__(self, id: str = 'member') -> None:
+        self._url: str = ""
+        self._headers: dict = {}
+
         self.id = id
+        self.name: str = "Membre"
+        self.is_global_scope: bool = True
         self.permissions: PositionPermissions = PositionPermissions()
         self.manager_permissions: PositionPermissions = PositionPermissions()
 
-        self._url: str = ""
 
     def __repr__(self):
         return self.id
@@ -84,16 +92,20 @@ class Position:
     def update_permisions(self, **permissions: str):
         query = "&".join(f"{k}={ urllib.parse.quote(v) }" for k, v in permissions.items())
 
-        res = requests.post(f"{self._url}/update_permissions?{query}", headers = default_headers)
+        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()
 
-    def _load(self, _data: dict):
+    def _load(self, _data: dict, url: str, headers: dict) -> None:
+        self._url = url + '/model/positions/' + _data['id']
+        self._headers = headers
+
         self.id = _data['id']
         self.name = _data['name']
+        self.is_global_scope = _data['is_global_scope']
         self.permissions.merge(_data['permissions'])
         self.manager_permissions.merge(_data['manager_permissions'])
 
@@ -103,31 +115,51 @@ class Entity:
 
     ## Attributs
     - id: `NSID`\n
-        Identifiant de l'entité
+        Identifiant NSID
     - name: `str`\n
-        Nom d'usage de l'entité
-    - registerDate: `int`\n
-        Date d'enregistrement de l'entité
+        Nom d'usage
+    - register_date: `int`\n
+        Date d'enregistrement
+    - zone: `int`:\n
+        Zone civile
     - position: `.Position`\n
-        Position légale de l'entité
+        Position civile
     - additional: `dict`\n
-        Infos supplémentaires exploitables par les bots
+        Infos supplémentaires exploitables par différents services
     """
 
     def __init__(self, id: NSID) -> None:
-        self._url = "" # URL de l'entité pour une requête GET
+        self._url: str = "" # URL de l'entité pour une requête
+        self._headers: dict = {}
 
         self.id: NSID = NSID(id) # ID hexadécimal de l'entité
         self.name: str = "Entité Inconnue"
-        self.registerDate: int = 0
+        self.register_date: int = 0
+        self.zone: int = 20 # 10 = Serveur test, 20 = Serveur principal, 30 = Serveur de patientage
         self.position: Position = Position()
         self.additional: dict = {}
 
+    def _load(self, _data: dict, url: str, headers: dict):
+        self._url = url + '/model/' + _data['_class'] + '/' + _data['id']
+        self._headers = headers
+
+        self.id = NSID(_data['id'])
+        self.name = _data['name']
+        self.register_date = _data['register_date']
+        self.zone = _data['zone']
+        self.position._load(_data['position'], url, headers)
+
+        for  key, value in _data.get('additional', {}).items():
+            if isinstance(value, str) and value.startswith('\n'):
+                self.additional[key] = int(value[1:])
+            else:
+                self.additional[key] = value
+
     def set_name(self, new_name: str) -> None:
         if len(new_name) > 32:
             raise ValueError(f"Name length mustn't exceed 32 characters.")
 
-        res = requests.post(f"{self._url}/rename?name={new_name}", headers = default_headers)
+        res = requests.post(f"{self._url}/rename?name={new_name}", headers = self._headers)
 
         if res.status_code == 200:
             self.name = new_name
@@ -135,7 +167,7 @@ class Entity:
             res.raise_for_status()
 
     def set_position(self, position: Position) -> None:
-        res = requests.post(f"{self._url}/change_position?position={position.id}", headers = default_headers)
+        res = requests.post(f"{self._url}/change_position?position={position.id}", headers = self._headers)
 
         if res.status_code == 200:
             self.position = position
@@ -158,16 +190,15 @@ class Entity:
 
         query = "&".join(f"{k}={ urllib.parse.quote(v) }" for k, v in params.items())
 
-        res = requests.post(f"{self._url}/add_link?{query}", headers = default_headers)
+        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()
 
     def unlink(self, key: str) -> None:
-        res = requests.post(f"{self._url}/remove_link?link={urllib.parse.quote(key)}", headers = default_headers)
+        res = requests.post(f"{self._url}/remove_link?link={urllib.parse.quote(key)}", headers = self._headers)
 
         if res.status_code == 200:
             del self.additional[key]
@@ -195,7 +226,22 @@ class User(Entity):
         self.boosts: dict[str, int] = {}
         self.votes: list[NSID] = []
 
-    def _load(self, _data: dict):
+    def _load(self, _data: dict, url: str, headers: dict):
+        self._url = url + '/model/individuals/' + _data['id']
+        self._headers = headers
+
+        self.id = NSID(_data['id'])
+        self.name = _data['name']
+        self.register_date = _data['register_date']
+        self.zone = _data['zone']
+        self.position._load(_data['position'], url, headers)
+
+        for  key, value in _data.get('additional', {}).items():
+            if isinstance(value, str) and value.startswith('\n'):
+                self.additional[key] = int(value[1:])
+            else:
+                self.additional[key] = value
+
         self.xp = _data['xp']
         self.boosts = _data['boosts']
 
@@ -210,7 +256,7 @@ class User(Entity):
 
     def add_xp(self, amount: int) -> None:
         boost = 0 if 0 in self.boosts.values() or amount <= 0 else max(list(self.boosts.values()) + [ 1 ])
-        res = requests.post(f"{self._url}/add_xp?amount={amount * boost}", headers = default_headers)
+        res = requests.post(f"{self._url}/add_xp?amount={amount * boost}", headers = self._headers)
 
         if res.status_code == 200:
             self.xp += amount * boost
@@ -218,7 +264,7 @@ class User(Entity):
             res.raise_for_status()
 
     def edit_boost(self, name: str, multiplier: int = -1) -> None:
-        res = requests.post(f"{self._url}/edit_boost?boost={name}&multiplier={multiplier}", headers = default_headers)
+        res = requests.post(f"{self._url}/edit_boost?boost={name}&multiplier={multiplier}", headers = self._headers)
 
         if res.status_code == 200:
             if multiplier >= 0:
@@ -228,14 +274,32 @@ class User(Entity):
         else:
             res.raise_for_status()
 
-class MemberPermissions:
+    def get_groups(self) -> list[Entity]:
+        res = requests.get(f"{self._url}/groups", headers = self._headers)
+
+        if res.status_code == 200:
+            data = res.json()
+            groups = []
+
+            for grp in data:
+                if grp is None: continue
+
+                group = Organization(grp["id"])
+                group._load(grp, self.url, self._headers)
+
+                groups.append(group)
+
+            return groups
+        else:
+            return []
+
+class GroupPermissions:
     """
-    Permissions d'un utilisateur à l'échelle d'un groupe
+    Permissions d'un membre à l'échelle d'un groupe
     """
 
     def __init__(self) -> None:
         self.manage_organization = False # Renommer l'organisation, changer le logo
-        self.manage_shares = False # Revaloriser les actions
         self.manage_roles = False # Changer les rôles des membres
         self.manage_members = False # Virer quelqu'un d'une entreprise, l'y inviter
 
@@ -248,41 +312,13 @@ class GroupMember:
     Membre au sein d'une entité collective
 
     ## Attributs
-    - permission_level: `dict[str, int]`\n
-        Niveau d'accréditation du membre (0 = salarié, 4 = administrateur)
+    - permissions: `.GroupPermissions`\n
+        Permissions du membre au sein du groupe
     """
 
     def __init__(self, id: NSID) -> None:
         self.id = id
-        self.permission_level: dict = { # Échelle de permissions selon le groupe de travail
-            "general": 0 
-        }
-
-    def group_permissions(self, team: str = "general") -> MemberPermissions:
-        p = MemberPermissions()
-        team_perms = self.permission_level[team]
-
-        if team_perms >= 1: # Responsable
-            p.manage_members = True
-
-        if team_perms >= 2: # Superviseur
-            p.manage_roles = True
-
-        if team_perms >= 3: # Chef d'équipe
-            pass
-
-        if team_perms >= 4: # Directeur
-            p.manage_shares = True
-            p.manage_organization = True
-
-        return p
-
-class GroupInvite:
-    def __init__(self, id: NSID):
-        self.id: NSID = id
-        self.team: str = "general"
-        self.level: str = 0
-        self._expires: int = round(time.time()) + 604800
+        self.permissions: GroupPermissions = GroupPermissions()
 
 class Organization(Entity):
     """
@@ -310,10 +346,33 @@ class Organization(Entity):
 
         self.certifications: dict = {}
         self.members: list[GroupMember] = []
-        self.invites: dict[GroupInvite] = []
 
-    def _load(self, _data: dict):
-        self.avatar_url = self._url + '/avatar'
+    def _load(self, _data: dict, url: str, headers: dict):
+        self._url = url + '/model/organizations/' + _data['id']
+        self._headers = headers
+
+        self.id = NSID(_data['id'])
+        self.name = _data['name']
+        self.register_date = _data['register_date']
+        self.zone = _data['zone']
+        self.position._load(_data['position'], url, headers)
+
+        for  key, value in _data.get('additional', {}).items():
+            if isinstance(value, str) and value.startswith('\n'):
+                self.additional[key] = int(value[1:])
+            else:
+                self.additional[key] = value
+
+        _owner = _data['owner']
+
+        if _owner['_class'] == 'individuals':
+            self.owner = User(_owner['id'])
+        elif _owner['_class'] == 'organizations':
+            self.owner = Organization(_owner['id'])
+        else:
+            self.owner = Entity(_owner['id'])
+
+        self.owner._load(_owner, url, headers)
 
         for _member in _data['members']:
             member = GroupMember(_member['id'])
@@ -324,7 +383,7 @@ class Organization(Entity):
         self.certifications = _data['certifications']
 
     def add_certification(self, certification: str, __expires: int = 2419200) -> None:
-        res = requests.post(f"{self._url}/add_certification?name={certification}&duration={__expires}", headers = default_headers)
+        res = requests.post(f"{self._url}/add_certification?name={certification}&duration={__expires}", headers = self._headers)
 
         if res.status_code == 200:
             self.certifications[certification] = int(round(time.time()) + __expires)
@@ -335,39 +394,46 @@ class Organization(Entity):
         return certification in self.certifications.keys()
 
     def remove_certification(self, certification: str) -> None:
-        res = requests.post(f"{self._url}/remove_certification?name={certification}", headers = default_headers)
+        res = requests.post(f"{self._url}/remove_certification?name={certification}", headers = self._headers)
 
         if res.status_code == 200:
             del self.certifications[certification]
         else:
             res.raise_for_status()
 
-    def invite_member(self, member: NSID, level: int = 0, team: str = "general") -> None:
+    def add_member(self, member: NSID, permissions: GroupPermissions = GroupPermissions()) -> None:
         if not isinstance(member, NSID):
             raise TypeError("L'entrée membre doit être de type NSID")
 
-        res = requests.post(f"{self._url}/invite_member?id={member}&level={level}&team={team}", headers = default_headers)
+        res = requests.post(f"{self._url}/add_member?id={member}", headers = self._headers, json = {
+            "permissions": permissions.__dict__
+        })
 
         if res.status_code == 200:
-            invite = GroupInvite(member)
-            invite.team = team
-            invite.level = level
+            member = GroupMember(member)
+            member.permissions = permissions
 
-            self.invites.append(invite)
+            self.members.append(member)
         else:
             res.raise_for_status()
 
     def remove_member(self, member: GroupMember) -> None:
+        requests.post(f"{self._url}/remove_member?id={member.id}", headers = self._headers)
+
         for _member in self.members:
             if _member.id == member.id:
                 self.members.remove(_member)
 
-    def remove(self, member: GroupMember) -> None:
-        self.remove_member(member)
-
     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
+
     def get_members_by_attr(self, attribute: str = "id") -> list[str]:
         return [ member.__getattribute__(attribute) for member in self.members ]
 

nsarchive/models/justice.py

@@ -0,0 +1,108 @@
+import requests
+import time
+
+from .base import NSID
+
+class Report:
+    def __init__(self, id: NSID):
+        self._url: str = ""
+        self._headers: dict = {}
+
+        self.id: NSID = id
+        self.author: NSID = NSID('0')
+        self.target: NSID = NSID('0')
+        self.date: int = round(time.time())
+        self.status: int = 0 # 0: En attente, 1: Accepté, 2: Rejeté
+        self.reason: str = None # Raison proposée par le bot
+        self.details:str = None # Description des faits
+
+    def _load(self, _data: dict, url: str, headers: str) -> None:
+        self._url = url
+        self._headers = headers
+
+        self.id = NSID(_data['id'])
+        self.author = NSID(_data['author'])
+        self.target = NSID(_data['target'])
+        self.date = _data['date']
+        self.status = _data['status']
+        self.reason = _data.get('reason', None)
+        self.details = _data.get('details', None)
+
+    def update(self, status: str | int):
+        __statuses = [
+            'pending',
+            'accepted',
+            'rejected'
+        ]
+
+        if status not in __statuses:
+            if isinstance(status, int) and 0 <= status <= 2:
+                status = __statuses[status]
+
+            else:
+                raise ValueError(f"Invalid status: {status}. Must be one of {__statuses} or an integer between 0 and 2.")
+
+        res = requests.post(f"{self._url}/update?status={status}", headers = self._headers)
+
+        if res.status_code == 200:
+            self.status = status
+        else:
+            res.raise_for_status()
+
+class Sanction:
+    def __init__(self, id: NSID):
+        self._url: str = ""
+        self._headers: dict = {}
+
+        self.id: NSID = id
+        self.target: NSID = NSID('0')
+        self.type: str = None
+        self.date: int = round(time.time())
+        self.duration: int = 0
+        self.title: str = None
+        self.lawsuit: NSID = NSID('0')
+
+    def _load(self, _data: dict, url: str, headers: dict) -> None:
+        self._url = url
+        self._headers = headers
+
+        self.id = NSID(_data['id'])
+        self.target = NSID(_data['target'])
+        self.type = _data['type']
+        self.date = _data['date']
+        self.duration = _data['duration']
+        self.title = _data['title']
+        self.lawsuit = NSID(_data['lawsuit'])
+
+class Lawsuit:
+    def __init__(self, id: NSID):
+        self._url: str = ""
+        self._headers: dict = {}
+
+        self.id: NSID = id
+        self.target: NSID = NSID('0')
+        self.judge: NSID = NSID('0')
+        self.title: str = None
+        self.date: int = round(time.time())
+        self.report: NSID = NSID('0')
+        self.is_private: bool = False
+        self.is_open: bool = False
+
+    def _load(self, _data: dict, url: str, headers: dict) -> None:
+        self._url = url
+        self._headers = headers
+
+        self._url = url
+        self._headers = headers
+
+        self.id = NSID(_data['id'])
+        self.target = NSID(_data['target'])
+        self.judge = NSID(_data['judge'])
+        self.title = _data.get('title')
+        self.date = _data.get('date', round(time.time()))
+
+        report = _data.get('report')
+        self.report = NSID(report) if report else NSID('0')
+
+        self.is_private = bool(_data.get('private', 0))
+        self.is_open = _data.get('status', 0) == 0

nsarchive/models/republic.py

@@ -0,0 +1,128 @@
+import json
+import requests
+import time
+
+from .base import NSID
+
+# Votes
+
+class VoteOption:
+    """
+    Option disponible lors d'un vote
+
+    ## Attributs
+    - id: `str`\n
+        Identifiant de l'option
+    - title: `str`\n
+        Label de l'option
+    - count: `int`\n
+        Nombre de sympathisants pour cette option
+    """
+
+    def __init__(self, title: str, count: int = 0):
+        self.title: str = title
+        self.count: int = count
+
+    def __repr__(self) -> dict:
+        return json.dumps({
+            'title': self.title,
+            'count': self.count
+        })
+
+    def _load(self, _data: dict):
+        self.title = str(_data['title'])
+        self.count = int(_data['count'])
+
+class Vote:
+    """
+    Classe de référence pour les différents votes du serveur
+
+    ## Attributs
+    - id: `NSID`\n
+        Identifiant du vote
+    - title: `str`\n
+        Titre du vote
+    - options: dict[str, .VoteOption]\n
+        Liste des choix disponibles
+    - author: `NSID`\n
+        Identifiant de l'auteur du vote
+    - startDate: `int`\n
+        Date de début du vote
+    - endDate: `int`\n
+        Date limite pour voter
+    """
+
+    def __init__(self, id: NSID = None) -> None:
+        self._url: str
+        self._headers: dict
+
+        self.id: NSID = id if id else NSID(0)
+        self.title: str = ''
+        self.author: NSID = NSID(0)
+
+        self.startDate: int = round(time.time())
+        self.endDate: int = 0
+
+        self.options: dict[str, VoteOption] = {}
+
+    def _load(self, _data: dict, url: str, headers: dict) -> None:
+        self._url = url
+        self._headers = headers
+
+        self.id = NSID(_data['id'])
+        self.title = _data['title']
+        self.author = _data['author']
+
+        self.startDate = _data['start']
+        self.endDate = _data['end']
+
+        self.options = {}
+
+        for _opt_id, opt in _data['options'].items():
+            option = VoteOption(*tuple(opt.values()))
+
+            self.options[_opt_id] = option
+
+    def get(self, id: str) -> VoteOption:
+        if id in self.options.keys():
+            return self.options[id]
+        else:
+            raise ValueError(f"Option {id} not found in vote {self.id}")
+
+    def add_vote(self, id: str):
+        """
+        Ajoute un vote à l'option spécifiée
+        """
+
+        res = requests.post(f"{self._url}/vote?option={id}", headers = self._headers)
+
+        if res.status_code == 200:
+            self.get(id).count += 1
+        else:
+            res.raise_for_status()
+
+    def close(self):
+        """
+        Ferme le vote
+        """
+
+        res = requests.post(f"{self._url}/close", headers = self._headers)
+
+        if res.status_code == 200:
+            self.endDate = round(time.time())
+        else:
+            res.raise_for_status()
+
+class LawsuitVote(Vote):
+    """
+    Vote à trois positions pour un procès
+    """
+
+    def __init__(self, id: NSID, title: str) -> None:
+        super().__init__(id, title)
+
+        self.options = [
+            VoteOption('guilty', 'Coupable'),
+            VoteOption('innocent', 'Innocent'),
+            VoteOption('blank', 'Pas d\'avis'),
+        ]

nsarchive/models/scale.py

@@ -0,0 +1,23 @@
+class Scale:
+    def __init__(self):
+        self.democratie: float = 0.0
+        self.coertition: float = 0.0
+        self.liberte: float = 0.0
+        self.integration: float = 0.0
+        self.revolution: float = 0.0
+
+    def _load(self, _data: dict):
+        self.democratie = _data.get('DEM', 0.0)
+        self.coertition = _data.get('SRV', 0.0)
+        self.liberte = _data.get('LIB', 0.0)
+        self.integration = _data.get('INT', 0.0)
+        self.revolution = _data.get('REV', 0.0)
+
+    def _to_dict(self) -> dict:
+        return {
+            'DEM': self.democratie,
+            'SRV': self.coertition,
+            'LIB': self.liberte,
+            'INT': self.integration,
+            'REV': self.revolution
+        }