.env.template

@@ -1,16 +1,10 @@
 # Chemin de la clé privé Ḡ1 de l'émetteur, au format PubSec
-# ex. DUNIKEY="/path/myprivateG1key.dunikey"
+DUNIKEY=
-DUNIKEY=""
 
 # Noeud Duniter
-DUNITER="https://g1.asycn.io"
+NODE=https://g1.librelois.fr/gva
-#DUNITER="https://duniter.pini.fr"
-#DUNITER="https://g1v1.p2p.legal"
 
 # Adresse du pod Cesium ou Gchange à utiliser
-ESNODE="https://g1.data.e-is.pro"
+POD=https://g1.data.le-sou.org
-#ESNODE="https://g1.data.presles.fr"
+#POD=https://g1.data.duniter.fr
-#ESNODE="https://g1.data.adn.life"
+#POD=https://data.gchange.fr
-#ESNODE=https://g1.data.le-sou.org
-#ESNODE=https://g1.data.duniter.fr
-#ESNODE=https://data.gchange.fr

.gitignore

@@ -1,5 +1,5 @@
 .env
+__pycache__
+
 *.dunikey
 not4U
-.vscode/settings.json
-__pycache__

.vscode/settings.json

@@ -1,7 +1,3 @@
 {
-    "python.pythonPath": "/usr/bin/python3.9",
+    "python.pythonPath": "/usr/bin/python3.9"
-    "[python]": {
-        "editor.defaultFormatter": "ms-python.black-formatter"
-    },
-    "python.formatting.provider": "none"
 }

README.md

@@ -13,7 +13,7 @@ Débrouillez-vous.
 
 ## Utilisation
 
-*Python 3.6 minimum*
+*Python 3.9 minimum*
 
 Renseignez optionnellement le fichier **.env** (Généré lors de la première tentative d'execution, ou à copier depuis .env.template).
 

jaklis.py

@@ -1,395 +1,191 @@
 #!/usr/bin/env python3
 
-import argparse
+import argparse, sys, os, getpass, string, random
-import sys
+from os.path import join, dirname
-import os
+from shutil import copyfile
-import string
-import random
 from dotenv import load_dotenv
 from duniterpy.key import SigningKey
-from pathlib import Path
-from lib.gva import GvaApi
-from lib.cesium import CesiumPlus
 
-__version__ = "0.1.1"
+__version__ = "0.0.4"
 
-MY_PATH = Path(__file__).resolve().parent
+MY_PATH = os.path.realpath(os.path.dirname(sys.argv[0])) + '/'
 
-# Set file paths
+# Get variables environment
-dotenv_file = MY_PATH / ".env"
+if not os.path.isfile(MY_PATH + '.env'):
-dotenv_template = MY_PATH / ".env.template"
+    copyfile(MY_PATH + ".env.template",MY_PATH +  ".env")
+dotenv_path = join(dirname(__file__),MY_PATH +  '.env')
+load_dotenv(dotenv_path)
 
-# Check and create dotenv file
+# Parse arguments
-if not dotenv_file.is_file():
+parser = argparse.ArgumentParser(description="Client CLI pour Cesium+ et Ḡchange")
-    dotenv_file.write_text(dotenv_template.read_text())
+parser.add_argument('-v', '--version', action='store_true', help="Affiche la version actuelle du programme")
+parser.add_argument('-k', '--key', help="Chemin vers mon trousseau de clé (PubSec)")
+parser.add_argument('-n', '--node', help="Adresse du noeud Cesium+, Gchange ou Duniter à utiliser")
 
-# Load environment variables
+subparsers = parser.add_subparsers(title="Commandes de jaklis", dest="cmd")
-load_dotenv(dotenv_file)
+read_cmd = subparsers.add_parser('read', help="Lecture des messages")
+send_cmd = subparsers.add_parser('send', help="Envoi d'un message")
+delete_cmd = subparsers.add_parser('delete', help="Supression d'un message")
+getProfile_cmd = subparsers.add_parser('get', help="Voir un profile Cesium+")
+setProfile_cmd = subparsers.add_parser('set', help="Configurer son profile Cesium+")
+eraseProfile_cmd = subparsers.add_parser('erase', help="Effacer son profile Cesium+")
+stars_cmd = subparsers.add_parser('stars', help="Voir les étoiles d'un profile / Noter un profile (option -s NOTE)")
+unstars_cmd = subparsers.add_parser('unstars', help="Supprimer un star")
+getoffer_cmd = subparsers.add_parser('getoffer', help="Obtenir les informations d'une annonce gchange")
+setoffer_cmd = subparsers.add_parser('setoffer', help="Créer une annonce gchange")
+deleteoffer_cmd = subparsers.add_parser('deleteoffer', help="Supprimer une annonce gchange")
+pay_cmd = subparsers.add_parser('pay', help="Payer en Ḡ1")
+history_cmd = subparsers.add_parser('history', help="Voir l'historique des transactions d'un compte Ḡ1")
+balance_cmd = subparsers.add_parser('balance', help="Voir le solde d'un compte Ḡ1")
+id_cmd = subparsers.add_parser('id', help="Voir l'identité d'une clé publique/username")
+id_balance_cmd = subparsers.add_parser('idBalance', help="Voir l'identité d'une clé publique/username et son solde")
+currentUd = subparsers.add_parser('currentUd', help="Affiche la montant actuel du dividende Universel")
 
-# Set global values (default parameters) regarding environment variables
+# Messages management
-node = os.getenv("DUNITER") + "/gva" or "https://g1v1.p2p.legal/gva"
+read_cmd.add_argument('-n', '--number',type=int, default=3, help="Affiche les NUMBER derniers messages")
-pod = os.getenv("ESNODE") or "https://g1.data.e-is.pro"
+read_cmd.add_argument('-j', '--json', action='store_true', help="Sort au format JSON")
-destPubkey = False
+read_cmd.add_argument('-o', '--outbox', action='store_true', help="Lit les messages envoyés")
 
-# define parser
+send_cmd.add_argument('-d', '--destinataire', required=True, help="Destinataire du message")
-parser = argparse.ArgumentParser(
+send_cmd.add_argument('-t', '--titre', help="Titre du message à envoyer")
-    description="CLI Client for Cesium+ and Ḡchange",
+send_cmd.add_argument('-m', '--message', help="Message à envoyer")
-    epilog="current node: '" + node + "', current pod: '" + pod + "'.",
+send_cmd.add_argument('-f', '--fichier', help="Envoyer le message contenu dans le fichier 'FICHIER'")
-)
+send_cmd.add_argument('-o', '--outbox', action='store_true', help="Envoi le message sur la boite d'envoi")
 
-# load global arguments
+delete_cmd.add_argument('-i', '--id', action='append', nargs='+', required=True, help="ID(s) du/des message(s) à supprimer")
-parser.add_argument(
+delete_cmd.add_argument('-o', '--outbox', action='store_true', help="Suppression d'un message envoyé")
-    "-v",
-    "--version",
-    action="store_true",
-    help="Display the current program version",
-)
-parser.add_argument("-k", "--key", help="Path to the keyfile (PubSec)")
-parser.add_argument(
-    "-n", "--node", help="Address of the Cesium+, Gchange, or Duniter node to use"
-)
 
-# Define commands with arguments
+# Profiles management
-commands = {
+setProfile_cmd.add_argument('-n', '--name', help="Nom du profile")
-    "read": {
+setProfile_cmd.add_argument('-d', '--description', help="Description du profile")
-        "help": "Read messages",
+setProfile_cmd.add_argument('-v', '--ville', help="Ville du profile")
-        "arguments": {
+setProfile_cmd.add_argument('-a', '--adresse', help="Adresse du profile")
-            ("n", "number"): {
+setProfile_cmd.add_argument('-pos', '--position', nargs=2, help="Points géographiques (lat + lon)")
-                "type": int,
+setProfile_cmd.add_argument('-s', '--site', help="Site web du profile")
-                "default": 3,
+setProfile_cmd.add_argument('-A', '--avatar', help="Chemin vers mon avatar en PNG")
-                "help": "Display the last NUMBER messages",
+
-            },
+getProfile_cmd.add_argument('-p', '--profile', help="Nom du profile")
-            ("j", "json"): {"action": "store_true", "help": "Output in JSON format"},
+getProfile_cmd.add_argument('-a', '--avatar', action='store_true', help="Récupérer également l'avatar au format raw base64")
-            ("o", "outbox"): {"action": "store_true", "help": "Read sent messages"},
+
-        },
+# Likes management
-        "type": "cesium",
+stars_cmd.add_argument('-p', '--profile', help="Profile cible")
-    },
+stars_cmd.add_argument('-n', '--number', type=int, help="Nombre d'étoile")
-    "send": {
+unstars_cmd.add_argument('-p', '--profile', help="Profile à dénoter")
-        "help": "Send a message",
+
-        "arguments": {
+# Offers management
-            ("d", "destinataire"): {
+getoffer_cmd.add_argument('-i', '--id', help="Annonce cible à récupérer")
-                "required": True,
+setoffer_cmd.add_argument('-t', '--title', help="Titre de l'annonce à créer")
-                "help": "Recipient of the message",
+setoffer_cmd.add_argument('-d', '--description', help="Description de l'annonce à créer")
-            },
+setoffer_cmd.add_argument('-c', '--category', help="Categorie de l'annonce à créer")
-            ("t", "titre"): {"help": "Title of the message to send"},
+setoffer_cmd.add_argument('-l', '--localisation', nargs=2, help="Localisation de l'annonce à créer (lat + lon)")
-            ("m", "message"): {"help": "Message to send"},
+setoffer_cmd.add_argument('-p', '--picture', help="Image de l'annonce à créer")
-            ("f", "fichier"): {"help": "Send the message from the 'FILE'"},
+setoffer_cmd.add_argument('-ci', '--city', help="Ville de l'annonce à créer")
-            ("o", "outbox"): {
+setoffer_cmd.add_argument('-pr', '--price', help="Prix de l'annonce à créer")
-                "action": "store_true",
+deleteoffer_cmd.add_argument('-i', '--id', help="Annonce cible à supprimer")
-                "help": "Send the message to the outbox",
+
-            },
+# GVA usage
-        },
+pay_cmd.add_argument('-p', '--pubkey', help="Destinataire du paiement")
-        "type": "cesium",
+pay_cmd.add_argument('-a', '--amount', type=float, help="Montant de la transaction")
-    },
+pay_cmd.add_argument('-c', '--comment',  default="", help="Commentaire de la transaction")
-    "delete": {
+pay_cmd.add_argument('-m', '--mempool', action='store_true', help="Utilise les sources en Mempool")
-        "help": "Delete a message",
+pay_cmd.add_argument('-v', '--verbose', action='store_true', help="Affiche le résultat JSON de la transaction")
-        "arguments": {
+
-            ("i", "id"): {
+history_cmd.add_argument('-p', '--pubkey', help="Clé publique du compte visé")
-                "action": "append",
+history_cmd.add_argument('-n', '--number',type=int, default=10, help="Affiche les NUMBER dernières transactions")
-                "nargs": "+",
+history_cmd.add_argument('-j', '--json',  action='store_true', help="Affiche le résultat en format JSON")
-                "required": True,
+history_cmd.add_argument('--nocolors',  action='store_true', help="Affiche le résultat en noir et blanc")
-                "help": "ID(s) of the message(s) to delete",
+
-            },
+balance_cmd.add_argument('-p', '--pubkey', help="Clé publique du compte visé")
-            ("o", "outbox"): {
+balance_cmd.add_argument('-m', '--mempool', action='store_true', help="Utilise les sources en Mempool")
-                "action": "store_true",
+id_cmd.add_argument('-p', '--pubkey', help="Clé publique du compte visé")
-                "help": "Delete a sent message",
+id_cmd.add_argument('-u', '--username', help="Username du compte visé")
-            },
+id_balance_cmd.add_argument('-p', '--pubkey', help="Pubkey du compte visé")
-        },
+currentUd.add_argument('-p', '--pubkey', help="Pubkey du compte visé")
-        "type": "cesium",
-    },
-    "get": {
-        "help": "View a Cesium+ profile",
-        "arguments": {
-            ("p", "profile"): {"help": "Profile name"},
-            ("a", "avatar"): {
-                "action": "store_true",
-                "help": "Also retrieve the avatar in raw base64 format",
-            },
-        },
-        "type": "cesium",
-    },
-    "page": {
-        "help": "View a Cesium+ page",
-        "arguments": {
-            ("p", "page"): {"help": "Page name"},
-            ("a", "avatar"): {
-                "action": "store_true",
-                "help": "Also retrieve the page's avatar in raw base64 format",
-            },
-        },
-        "type": "cesium",
-    },
-    "set": {
-        "help": "Configure your Cesium+ profile",
-        "arguments": {
-            ("n", "name"): {"help": "Profile name"},
-            ("d", "description"): {"help": "Profile description"},
-            ("v", "ville"): {"help": "Profile city"},
-            ("a", "adresse"): {"help": "Profile address"},
-            ("pos", "position"): {
-                "nargs": 2,
-                "help": "Geographical coordinates (lat + lon)",
-            },
-            ("s", "site"): {"help": "Profile website"},
-            ("A", "avatar"): {"help": "Path to profile avatar in PNG"},
-        },
-        "type": "cesium",
-    },
-    "erase": {
-        "help": "Erase your Cesium+ profile",
-        "arguments": {},
-        "type": "cesium",
-    },
-    "stars": {
-        "help": "View a profile's stars / Rate a profile (option -s RATING)",
-        "arguments": {
-            ("p", "profile"): {"help": "Target profile"},
-            ("n", "number"): {"type": int, "help": "Number of stars"},
-        },
-        "type": "cesium",
-    },
-    "unstars": {
-        "help": "Remove a star",
-        "arguments": {
-            ("p", "profile"): {"help": "Profile to unstar"},
-        },
-        "type": "cesium",
-    },
-    "getoffer": {
-        "help": "Get information about a Ḡchange listing",
-        "arguments": {
-            ("i", "id"): {"help": "Target listing to retrieve"},
-        },
-        "type": "cesium",
-    },
-    "setoffer": {
-        "help": "Create a Ḡchange listing",
-        "arguments": {
-            ("t", "title"): {"help": "Title of the listing to create"},
-            ("d", "description"): {"help": "Description of the listing to create"},
-            ("c", "category"): {"help": "Category of the listing to create"},
-            ("l", "location"): {
-                "nargs": 2,
-                "help": "Location of the listing to create (lat + lon)",
-            },
-            ("p", "picture"): {"help": "Image of the listing to create"},
-            ("ci", "city"): {"help": "City of the listing to create"},
-            ("pr", "price"): {"help": "Price of the listing to create"},
-        },
-        "type": "cesium",
-    },
-    "deleteoffer": {
-        "help": "Delete a Ḡchange listing",
-        "arguments": {
-            ("i", "id"): {"help": "Target listing to delete"},
-        },
-        "type": "cesium",
-    },
-    "geolocProfiles": {
-        "help": "Get JSON of all geolocated accounts",
-        "arguments": {},
-        "type": "cesium",
-    },
-    "pay": {
-        "help": "Pay in Ḡ1",
-        "arguments": {
-            ("p", "pubkey"): {"help": "Payment recipient"},
-            ("a", "amount"): {"type": float, "help": "Transaction amount"},
-            ("c", "comment"): {
-                "default": "",
-                "help": "Transaction comment",
-                "nargs": "*",
-            },
-            ("m", "mempool"): {
-                "action": "store_true",
-                "help": "Use mempool sources",
-            },
-            ("v", "verbose"): {
-                "action": "store_true",
-                "help": "Display the JSON result of the transaction",
-            },
-        },
-        "type": "gva",
-    },
-    "history": {
-        "help": "View Ḡ1 account transaction history",
-        "arguments": {
-            ("p", "pubkey"): {"help": "Public key of the target account"},
-            ("n", "number"): {
-                "type": int,
-                "default": 10,
-                "help": "Display the last NUMBER transactions",
-            },
-            ("j", "json"): {
-                "action": "store_true",
-                "help": "Display the result in JSON format",
-            },
-            ("nocolors"): {
-                "action": "store_true",
-                "help": "Display the result in black and white",
-            },
-        },
-        "type": "gva",
-    },
-    "balance": {
-        "help": "View Ḡ1 account balance",
-        "arguments": {
-            ("p", "pubkey"): {"help": "Public key of the target account"},
-            ("m", "mempool"): {
-                "action": "store_true",
-                "help": "Use mempool sources",
-            },
-        },
-        "type": "gva",
-    },
-    "id": {
-        "help": "View public key/username identity",
-        "arguments": {
-            ("p", "pubkey"): {"help": "Public key of the target account"},
-            ("u", "username"): {"help": "Username of the target account"},
-        },
-        "type": "gva",
-    },
-    "idBalance": {
-        "help": "View public key/username identity and balance",
-        "arguments": {
-            ("p", "pubkey"): {"help": "Public key of the target account"},
-        },
-        "type": "gva",
-    },
-    "currentUd": {
-        "help": "Display the current Universal Dividend amount",
-        "arguments": {
-            ("p", "pubkey"): {"help": "Public key of the target account"},
-        },
-        "type": "gva",
-    },
-    "listWallets": {
-        "help": "List all G1 wallets",
-        "arguments": {
-            ("m", "mbr"): {
-                "action": "store_true",
-                "help": "Display raw list of member pubkeys",
-            },
-            ("nm", "non_mbr"): {
-                "action": "store_true",
-                "help": "Display raw list of nonmember identity pubkeys",
-            },
-            ("l", "larf"): {
-                "action": "store_true",
-                "help": "Display raw list of nonmember pubkeys",
-            },
-            ("b", "brut"): {
-                "action": "store_true",
-                "help": "Display raw list of all pubkeys",
-            },
-        },
-        "type": "gva",
-    },
-}
 
-# Process commands and arguments
-subparsers = parser.add_subparsers(title="jaklis Commands", dest="cmd")
-for cmd, cmd_info in commands.items():
-    cmd_parser = subparsers.add_parser(cmd, help=cmd_info["help"])
-    for args, kwargs in cmd_info["arguments"].items():
-        if isinstance(args, str):
-            cmd_parser.add_argument("--" + args, **kwargs)
-        else:
-            short_arg, long_arg = args
-            cmd_parser.add_argument("-" + short_arg, "--" + long_arg, **kwargs)
 
 args = parser.parse_args()
-args_dict = vars(args)
 cmd = args.cmd
+
 if args.version:
-    print(__version__)
+  print(__version__)
-    sys.exit(0)
+  sys.exit(0)
 
 if not cmd:
     parser.print_help()
-    sys.exit(0)
+    sys.exit(1)
-
 
 def createTmpDunikey():
-    # Generate a pseudo-random nonce
+    # Generate pseudo-random nonce
-    nonce = "".join(
+    nonce=[]
-        random.choice(string.ascii_letters + string.digits) for _ in range(32)
+    for _ in range(32):
-    )
+        nonce.append(random.choice(string.ascii_letters + string.digits))
+    nonce = ''.join(nonce)
     keyPath = "/tmp/secret.dunikey-" + nonce
 
-    # Create a dummy key (replace with actual key creation logic)
+    key = SigningKey.from_credentials(getpass.getpass("Identifiant: "), getpass.getpass("Mot de passe: "), None)
-    key = SigningKey.from_credentials(
-        "sgse547yhd54xv6541srdh", "sfdgwdrhpkxdawsbszqpof1sdg65xc", None
-    )
     key.save_pubsec_file(keyPath)
-
+    
     return keyPath
 
+# Check if we need dunikey
+try:
+    pubkey = args.pubkey
+except:
+    pubkey = False
+try:
+    profile = args.profile
+except:
+    profile = False
 
-def get_arg_value(args, arg):
+if cmd in ('history','balance','get','id','idBalance') and (pubkey or profile):
+    noNeedDunikey = True
+    keyPath = False
     try:
-        return getattr(args, arg)
+        dunikey = args.pubkey
-    except AttributeError:
+    except:
-        return False
+        dunikey = args.profile
-
+else:
-
+    noNeedDunikey = False
-def get_dunikey(args):
     if args.key:
-        return args.key
+        dunikey = args.key
-    dunikey = os.getenv("DUNIKEY")
+        keyPath = False
-    if not dunikey:
+    else:
-        keyPath = createTmpDunikey()
+        dunikey = os.getenv('DUNIKEY')
-        dunikey = keyPath
+        if not dunikey:
+            keyPath = createTmpDunikey()
+            dunikey = keyPath
+        else:
+            keyPath = False
     if not os.path.isfile(dunikey):
         HOME = os.getenv("HOME")
         dunikey = HOME + dunikey
         if not os.path.isfile(dunikey):
-            sys.stderr.write("The keyfile {0} is not found.\n".format(dunikey))
+            sys.stderr.write('Le fichier de trousseau {0} est introuvable.\n'.format(dunikey))
             sys.exit(1)
-    return dunikey
 
 
-pubkey = get_arg_value(args, "pubkey")
+# Construct CesiumPlus object
-profile = get_arg_value(args, "profile")
+if cmd in ("read","send","delete","set","get","erase","stars","unstars","getoffer","setoffer","deleteoffer"):
+    from lib.cesium import CesiumPlus
 
-noNeedDunikey = cmd in (
+    if args.node:
-    "history",
+        pod = args.node
-    "balance",
+    else:
-    "page",
+        pod = os.getenv('POD')
-    "id",
+    if not pod:
-    "idBalance",
+        pod="https://g1.data.le-sou.org"
-    "listWallets",
-    "geolocProfiles",
-) and (pubkey or profile)
 
-if noNeedDunikey:
+    cesium = CesiumPlus(dunikey, pod, noNeedDunikey)
-    dunikey = pubkey if pubkey else profile
-else:
-    dunikey = get_dunikey(args)
-
-keyPath = False if dunikey else createTmpDunikey()
-
-
-def handle_cesium_commands(args, cmd, cesium):
-    # Get args of the command
-    cmd_args = (
-        list(zip(*list(commands[cmd]["arguments"].keys())))[1]
-        if len(commands[cmd]["arguments"].keys()) > 0
-        else []
-    )
-    cmd_args_dict = {arg: args_dict[arg] for arg in cmd_args if arg in args_dict}
-    cmd_args_values = list(cmd_args_dict.values())
 
     # Messaging
     if cmd == "read":
-        cesium.read(*cmd_args_values)
+        cesium.read(args.number, args.outbox, args.json)
     elif cmd == "send":
         if args.fichier:
-            with open(args.fichier, "r") as f:
+            with open(args.fichier, 'r') as f:
                 msgT = f.read()
-                titre = msgT.splitlines(True)[0].replace("\n", "")
+                titre = msgT.splitlines(True)[0].replace('\n', '')
-                msg = "".join(msgT.splitlines(True)[1:])
+                msg = ''.join(msgT.splitlines(True)[1:])
                 if args.titre:
                     titre = args.titre
                     msg = msgT
@@ -397,8 +193,8 @@ def handle_cesium_commands(args, cmd, cesium):
             titre = args.titre
             msg = args.message
         else:
-            titre = input("Enter the message title: ")
+            titre = input("Indiquez le titre du message: ")
-            msg = input("Enter the message content: ")
+            msg = input("Indiquez le contenu du message: ")
 
         cesium.send(titre, msg, args.destinataire, args.outbox)
 
@@ -407,15 +203,11 @@ def handle_cesium_commands(args, cmd, cesium):
 
     # Profiles
     elif cmd == "set":
-        cesium.set(**cmd_args_dict)
+        cesium.set(args.name, args.description, args.ville, args.adresse, args.position, args.site, args.avatar)
     elif cmd == "get":
-        cesium.get(**cmd_args_dict)
+        cesium.get(args.profile, args.avatar)
-    elif cmd == "page":
-        cesium.getPage(**cmd_args_dict)
     elif cmd == "erase":
         cesium.erase()
-    elif cmd == "geolocProfiles":
-        cesium.geolocProfiles(node)
 
     # Stars
     elif cmd == "stars":
@@ -430,22 +222,27 @@ def handle_cesium_commands(args, cmd, cesium):
     elif cmd == "getoffer":
         cesium.getOffer(args.id)
     elif cmd == "setoffer":
-        cesium.setOffer(**cmd_args_dict)
+        cesium.setOffer(args.title, args.description, args.city, args.localisation, args.category, args.price, args.picture)
     elif cmd == "deleteoffer":
-        cesium.deleteOffer(**cmd_args_dict)
+        cesium.deleteOffer(args.id)
+
+# Construct GVA object
+elif cmd in ("pay","history","balance","id","idBalance","currentUd"):
+    from lib.gva import GvaApi
+
+    if args.node:
+        node = args.node
     else:
-        raise ValueError(f"Unknown command: {cmd}")
+        node = os.getenv('NODE')
+    if not node:
+        node="https://g1.librelois.fr/gva"
 
+    if args.pubkey:
+        destPubkey = args.pubkey
+    else:
+        destPubkey = False
 
-def handle_gva_commands(args, cmd, gva):
+    gva = GvaApi(dunikey, node, destPubkey, noNeedDunikey)
-    # Get args of the command
-    cmd_args = (
-        list(zip(*list(commands[cmd]["arguments"].keys())))[1]
-        if len(commands[cmd]["arguments"].keys()) > 0
-        else []
-    )
-    cmd_args_dict = {arg: args_dict[arg] for arg in cmd_args if arg in args_dict}
-    # cmd_args_values = list(cmd_args_dict.values())
 
     if cmd == "pay":
         gva.pay(args.amount, args.comment, args.mempool, args.verbose)
@@ -454,37 +251,12 @@ def handle_gva_commands(args, cmd, gva):
     elif cmd == "balance":
         gva.balance(args.mempool)
     elif cmd == "id":
-        gva.id(**cmd_args_dict)
+        gva.id(args.pubkey, args.username)
     elif cmd == "idBalance":
-        gva.idBalance(**cmd_args_dict)
+        gva.idBalance(args.pubkey)
     elif cmd == "currentUd":
         gva.currentUd()
-    elif cmd == "listWallets":
-        gva.listWallets(args.brut, args.mbr, args.non_mbr, args.larf)
-    else:
-        raise ValueError(f"Unknown command: {cmd}")
 
 
-# Construct the CesiumPlus object
-if commands[cmd]["type"] == "cesium":
-    if args.node:
-        pod = args.node
-
-    cesium = CesiumPlus(dunikey, pod, noNeedDunikey)
-    handle_cesium_commands(args, cmd, cesium)
-
-# Construct the GvaApi object
-elif commands[cmd]["type"] == "gva":
-    if args.node:
-        node = args.node
-
-    if hasattr(args, "pubkey"):
-        destPubkey = args.pubkey
-
-    gva = GvaApi(dunikey, node, destPubkey, noNeedDunikey)
-    handle_gva_commands(args, cmd, gva)
-else:
-    raise ValueError(f"Unknown command: {cmd}")
-
 if keyPath:
     os.remove(keyPath)

lib/cesium.py

@@ -1,19 +1,16 @@
-import json
 import re, string, random, base64
 from lib.cesiumCommon import CesiumCommon, PUBKEY_REGEX
-from lib.geolocProfiles import GeolocProfiles
-from lib.getPages import Pages
 from lib.messaging import ReadFromCesium, SendToCesium, DeleteFromCesium
 from lib.profiles import Profiles
 from lib.stars import ReadLikes, SendLikes, UnLikes
 from lib.offers import Offers
 
-
 class CesiumPlus(CesiumCommon):
+
     #################### Messaging ####################
 
-    def read(self, nbrMsg, isJSON, outbox):
+    def read(self, nbrMsg, outbox, isJSON):
-        readCesium = ReadFromCesium(self.dunikey, self.pod)
+        readCesium = ReadFromCesium(self.dunikey,  self.pod)
         jsonMsg = readCesium.sendDocument(nbrMsg, outbox)
         if isJSON:
             jsonFormat = readCesium.jsonMessages(jsonMsg, nbrMsg, outbox)
@@ -26,18 +23,16 @@ class CesiumPlus(CesiumCommon):
         sendCesium.recipient = recipient
 
         # Generate pseudo-random nonce
-        nonce = []
+        nonce=[]
         for _ in range(32):
             nonce.append(random.choice(string.ascii_letters + string.digits))
-        sendCesium.nonce = base64.b64decode("".join(nonce))
+        sendCesium.nonce = base64.b64decode(''.join(nonce))
 
-        finalDoc = sendCesium.configDoc(
+        finalDoc = sendCesium.configDoc(sendCesium.encryptMsg(title), sendCesium.encryptMsg(msg))       # Configure JSON document to send
-            sendCesium.encryptMsg(title), sendCesium.encryptMsg(msg)
+        sendCesium.sendDocument(finalDoc, outbox)                                                       # Send final signed document
-        )  # Configure JSON document to send
-        sendCesium.sendDocument(finalDoc, outbox)  # Send final signed document
 
     def delete(self, idsMsgList, outbox):
-        deleteCesium = DeleteFromCesium(self.dunikey, self.pod)
+        deleteCesium = DeleteFromCesium(self.dunikey,  self.pod)
         # deleteCesium.issuer = recipient
         for idMsg in idsMsgList:
             finalDoc = deleteCesium.configDoc(idMsg, outbox)
@@ -45,74 +40,40 @@ class CesiumPlus(CesiumCommon):
 
     #################### Profiles ####################
 
-    def set(
+    def set(self, name=None, description=None, ville=None, adresse=None, position=None, site=None, avatar=None):
-        self,
+        setProfile = Profiles(self.dunikey,  self.pod)
-        name=None,
+        document = setProfile.configDocSet(name, description, ville, adresse, position, site, avatar)
-        description=None,
+        result = setProfile.sendDocument(document,'set')
-        ville=None,
-        adresse=None,
-        position=None,
-        site=None,
-        avatar=None,
-    ):
-        setProfile = Profiles(self.dunikey, self.pod)
-        document = setProfile.configDocSet(
-            name, description, ville, adresse, position, site, avatar
-        )
-        result = setProfile.sendDocument(document, "set")
 
         print(result)
         return result
-
+    
     def get(self, profile=None, avatar=None):
-        getProfile = Profiles(self.dunikey, self.pod, self.noNeedDunikey)
+        getProfile = Profiles(self.dunikey,  self.pod, self.noNeedDunikey)
         if not profile:
             profile = self.pubkey
         if not re.match(PUBKEY_REGEX, profile) or len(profile) > 45:
-            scope = "title"
+            scope = 'title'
         else:
-            scope = "_id"
+            scope = '_id'
-
+        
         document = getProfile.configDocGet(profile, scope, avatar)
-        resultJSON = getProfile.sendDocument(document, "get")
+        resultJSON = getProfile.sendDocument(document, 'get')
         result = getProfile.parseJSON(resultJSON)
 
         print(result)
 
-    def getPage(self, page=None, avatar=None):
-        getPage = Pages(self.dunikey, self.pod, self.noNeedDunikey)
-        if not page:
-            page = self.pubkey
-        if not re.match(PUBKEY_REGEX, page) or len(page) > 45:
-            scope = "title"
-        else:
-            scope = "_id"
-
-        document = getPage.configDocGet(page, scope, avatar)
-        resultJSON = getPage.sendDocument(document, "get")
-        result = getPage.parseJSON(resultJSON)
-
-        print(result)
-
     def erase(self):
-        eraseProfile = Profiles(self.dunikey, self.pod)
+        eraseProfile = Profiles(self.dunikey,  self.pod)
         document = eraseProfile.configDocErase()
-        result = eraseProfile.sendDocument(document, "erase")
+        result = eraseProfile.sendDocument(document,'erase')
 
         print(result)
 
-    def geolocProfiles(self, node):
-        geolocProfiles = GeolocProfiles(self.dunikey, self.pod)
-        cesiumProfiles = geolocProfiles.getCesiumProfiles()
-        gvaProfiles = geolocProfiles.getGVAProfiles(node)
-        result = geolocProfiles.formatProfiles(cesiumProfiles, json.loads(gvaProfiles))
-
-        print(json.dumps(result))
-
     #################### Likes ####################
 
     def readLikes(self, profile=False):
-        likes = ReadLikes(self.dunikey, self.pod, self.noNeedDunikey)
+        likes = ReadLikes(self.dunikey,  self.pod, self.noNeedDunikey)
         document = likes.configDoc(profile)
         result = likes.sendDocument(document)
         result = likes.parseResult(result)
@@ -120,13 +81,13 @@ class CesiumPlus(CesiumCommon):
         print(result)
 
     def like(self, stars, profile=False):
-        likes = SendLikes(self.dunikey, self.pod)
+        likes = SendLikes(self.dunikey,  self.pod)
         document = likes.configDoc(profile, stars)
         if document:
             likes.sendDocument(document, profile)
 
     def unLike(self, pubkey, silent=False):
-        likes = UnLikes(self.dunikey, self.pod)
+        likes = UnLikes(self.dunikey,  self.pod)
         idLike = likes.checkLike(pubkey)
         if idLike:
             document = likes.configDoc(idLike)
@@ -134,37 +95,26 @@ class CesiumPlus(CesiumCommon):
 
     #################### Offer ####################
 
-    def setOffer(
+    def setOffer(self, title=None, description=None, city=None, localisation=None, category=None, price=None, picture=None):
-        self,
+        setOffer = Offers(self.dunikey,  self.pod)
-        title=None,
+        document = setOffer.configDocSet(title, description, city, localisation, category, price, picture)
-        description=None,
+        result = setOffer.sendDocumentSet(document,'set')
-        city=None,
-        location=None,
-        category=None,
-        price=None,
-        picture=None,
-    ):
-        setOffer = Offers(self.dunikey, self.pod)
-        document = setOffer.configDocSet(
-            title, description, city, location, category, price, picture
-        )
-        result = setOffer.sendDocumentSet(document, "set")
 
         # print(result)
         return result
-
+    
     def getOffer(self, id, avatar=None):
-        getOffer = Offers(self.dunikey, self.pod, self.noNeedDunikey)
+        getOffer = Offers(self.dunikey,  self.pod, self.noNeedDunikey)
-
+        
-        resultJSON = getOffer.sendDocumentGet(id, "get")
+        resultJSON = getOffer.sendDocumentGet(id, 'get')
         # print(resultJSON)
         result = getOffer.parseJSON(resultJSON)
 
         print(result)
 
     def deleteOffer(self, id):
-        eraseOffer = Offers(self.dunikey, self.pod)
+        eraseOffer = Offers(self.dunikey,  self.pod)
         document = eraseOffer.configDocErase(id)
-        result = eraseOffer.sendDocumentSet(document, "delete", id)
+        result = eraseOffer.sendDocumentSet(document,'delete', id)
 
         print(result)

lib/geolocProfiles.py

@@ -1,112 +0,0 @@
-import requests
-from time import time
-from lib.cesiumCommon import CesiumCommon
-from lib.gvaWallets import ListWallets
-
-
-class GeolocProfiles(CesiumCommon):
-    def getCesiumProfiles(self):
-        # Send a POST request to the Cesium profiles API
-        response = requests.post(
-            "https://g1.data.e-is.pro/user/profile/_search?scroll=2m",
-            json={
-                "query": {
-                    "constant_score": {
-                        "filter": [
-                            {"exists": {"field": "geoPoint"}},
-                            {
-                                "geo_bounding_box": {
-                                    "geoPoint": {
-                                        "top_left": {"lat": 90, "lon": -180},
-                                        "bottom_right": {"lat": -90, "lon": 180},
-                                    }
-                                }
-                            },
-                        ]
-                    }
-                },
-                "_source": [
-                    "title",
-                    "avatar._content_type",
-                    "description",
-                    "city",
-                    "address",
-                    "socials.url",
-                    "creationTime",
-                    "membersCount",
-                    "type",
-                    "geoPoint",
-                ],
-                "size": 20000,
-            },
-        )
-
-        scroll_id = response.json()["_scroll_id"]
-        finalResult: dict | None = response.json()["hits"]["hits"]
-
-        while True:
-            # Send a scroll request to get the next page
-            response_scroll = requests.post(
-                "https://g1.data.e-is.pro/_search/scroll",
-                json={"scroll_id": scroll_id, "scroll": "2m"},
-            )
-
-            # Check if the response is empty (no results) or if there's an error
-            if (
-                not response_scroll.json()["hits"]["hits"]
-                or "error" in response_scroll.json()
-            ):
-                break
-            else:
-                finalResult.extend(response_scroll.json()["hits"]["hits"])
-
-            # Process the results here
-
-        # Delete the scroll context when done
-        requests.delete(
-            "https://g1.data.e-is.pro/_search/scroll", json={"scroll_id": [scroll_id]}
-        )
-
-        return finalResult
-
-    def getGVAProfiles(self, node):
-        # Retrieve GVA profiles using the ListWallets class
-        gva = ListWallets(node, map=True)
-        return gva.sendDoc()
-
-    def formatProfiles(self, cesiumProfiles, gvaProfiles):
-        walletsResult = []
-        for profile in cesiumProfiles:
-            source: dict = profile["_source"]
-            pubkey: dict = profile["_id"]
-
-            if pubkey not in gvaProfiles:
-                continue
-
-            # Extract necessary information from the profiles
-            id_info: dict = gvaProfiles[pubkey].get("id") or {}
-            isMember = id_info.get("isMember", False)
-            userId = id_info.get("username")
-            title = source.get("title")
-            city = source.get("city")
-            avatar = source.get("avatar")
-            socials = source.get("socials")
-            description = source.get("description")
-            address = source.get("address")
-
-            walletsResult.append(
-                {
-                    "pubkey": pubkey,
-                    **({"address": address} if address else {}),
-                    **({"city": city} if city else {}),
-                    **({"description": description} if description else {}),
-                    **({"avatar": avatar} if avatar else {}),
-                    **({"userId": userId} if userId else {}),
-                    "isMember": isMember,
-                    "geoPoint": source["geoPoint"],
-                    **({"socials": socials} if socials else {}),
-                    **({"title": title} if title else {}),
-                }
-            )
-
-        return {"wallets": walletsResult, "time": int(time())}

lib/getPages.py

@@ -1,125 +0,0 @@
-import sys, re, json, requests, base64
-from time import time
-from lib.cesiumCommon import CesiumCommon, PUBKEY_REGEX
-
-
-class Pages(CesiumCommon):
-    # Configure JSON document SET to send
-    def configDocSet(self, name, description, city, address, pos, socials, avatar):
-        timeSent = int(time())
-
-        data = {}
-        if name: data['title'] = name
-        if description: data['description'] = description
-        if address: data['address'] = address
-        if city: data['city'] = city
-        if pos: 
-            geoPoint = {}
-            geoPoint['lat'] = pos[0]
-            geoPoint['lon'] = pos[1]
-            data['geoPoint'] = geoPoint
-        if socials:
-            data['socials'] = []
-            data['socials'].append({})
-            data['socials'][0]['type'] = "web"
-            data['socials'][0]['url'] = socials
-        if avatar:
-            avatar = open(avatar, 'rb').read()
-            avatar = base64.b64encode(avatar).decode()
-            data['avatar'] = {}
-            data['avatar']['_content'] = avatar
-            data['avatar']['_content_type'] = "image/png"
-        data['time'] = timeSent
-        data['issuer'] = self.pubkey
-        data['version'] = 2
-        data['tags'] = []
-
-        document =  json.dumps(data)
-
-        return self.signDoc(document)
-
-   # Configure JSON document GET to send
-    def configDocGet(self, profile, scope='title', getAvatar=None):
-
-        if getAvatar:
-            avatar = "avatar"
-        else:
-            avatar = "avatar._content_type"
-
-        data = {
-                "query": {
-                "bool": {
-                    "should":[
-                        {
-                            "match":{
-                                scope:{
-                                    "query": profile,"boost":2
-                                }
-                            }
-                        },{
-                            "prefix": {scope: profile}
-                        }
-                    ]
-                }
-            },"highlight": {
-                    "fields": {
-                        "title":{},
-                        "tags":{}
-                    }
-                },"from":0,
-                "size":100,
-                "_source":["title", avatar,"description","city","address","socials.url","creationTime","membersCount","type","geoPoint"],
-                "indices_boost":{"user":100,"page":1,"group":0.01
-                }
-        }
-
-        document =  json.dumps(data)
-
-        return document
-
-    # Configure JSON document SET to send
-    def configDocErase(self):
-        timeSent = int(time())
-
-        data = {}
-        data['time'] = timeSent
-        data['id'] = self.pubkey
-        data['issuer'] = self.pubkey
-        data['version'] = 2
-        data['index'] = "user"
-        data['type'] = "profile"
-
-        document =  json.dumps(data)
-
-        return self.signDoc(document)
-
-    def sendDocument(self, document, type):
-
-        headers = {
-            'Content-type': 'application/json',
-        }
-
-        # Send JSON document and get JSON result
-        if type == 'set':
-            reqQuery = '{0}/user/profile?pubkey={1}/_update?pubkey={1}'.format(self.pod, self.pubkey)
-        elif type == 'get':
-            reqQuery = '{0}/user,page,group/profile,record/_search'.format(self.pod)
-        elif type == 'erase':
-            reqQuery = '{0}/history/delete'.format(self.pod)
-
-        result = requests.post(reqQuery, headers=headers, data=document)
-        if result.status_code == 200:
-            # print(result.text)
-            return result.text
-        else:
-            sys.stderr.write("Echec de l'envoi du document...\n" + result.text + '\n')
-
-    def parseJSON(self, doc):
-        doc = json.loads(doc)['hits']['hits']
-        if doc:
-            pubkey = { "pubkey": doc[0]['_id'] }
-            rest = doc[0]['_source']
-            final = {**pubkey, **rest}
-            return json.dumps(final, indent=2)
-        else:
-            return 'Profile vide'

lib/gva.py

@@ -1,5 +1,4 @@
 from lib.currentUd import currentUd
-from lib.gvaWallets import ListWallets
 import sys, re
 from lib.natools import get_privkey
 from lib.gvaPay import Transaction, PUBKEY_REGEX
@@ -39,7 +38,6 @@ class GvaApi():
     #################### Payments ####################
 
     def pay(self, amount, comment, mempool, verbose):
-        comment = " ".join(comment)
         gva = Transaction(self.dunikey, self.node, self.destPubkey, amount, comment, mempool, verbose)
         gva.genDoc()
         gva.checkTXDoc()
@@ -75,10 +73,4 @@ class GvaApi():
     def currentUd(self):
         gva = currentUd(self.node)
         result = gva.sendDoc()
-        print(result)
-        
-    def listWallets(self, brut, brutMbr, brutNonMbr, brutLarf):
-        gva = ListWallets(self.node, brut, brutMbr, brutNonMbr, brutLarf)
-        result = gva.sendDoc()
-        
         print(result)

lib/gvaHistory.py

@@ -43,11 +43,9 @@ class History:
                             node {
                                 currency
                                 issuers
-                                blockstamp
                                 outputs
                                 comment
                                 writtenTime
-                                hash
                             }
                         }
                     }
@@ -59,17 +57,13 @@ class History:
                         comment
                         outputs
                         receivedTime
-                        blockstamp
-                        hash
                     }
-                    sending {
+                    receiving {
                         currency
                         issuers
                         comment
                         outputs
                         receivedTime
-                        blockstamp
-                        hash
                     }
                 }
                 balance(script: $script) {
@@ -125,7 +119,6 @@ class History:
             trans[i] = []
             trans[i].append(direction)
             trans[i].append(transaction['writtenTime'])
-            
             if direction == 'SENT':
                 trans[i].append(outPubkey)
                 amount = int('-' + output.split(':')[0])
@@ -140,12 +133,12 @@ class History:
             trans[i].append(round(amount/self.UD, 2))
             trans[i].append(transaction['comment'])
             trans[i].append(base)
-            trans[i].append(transaction['blockstamp'])
-            trans[i].append(transaction['hash'])
             i += 1
 
         # Parse transactions in mempool
-        for direction, resBc in self.historyDoc['txsHistoryMp'].items():
+        for direction in self.historyDoc['txsHistoryMp']:
+            resBc = []
+            resBc = self.historyDoc['txsHistoryMp'][direction]
             for j, transaction in enumerate(resBc):
                 # print(transaction)
                 transaction = resBc[j]
@@ -154,11 +147,9 @@ class History:
                 # if direction == 'RECEIVING' or self.pubkey != outPubkey:
                 trans.append(i)
                 trans[i] = []
-                trans[i].append(direction.upper())
+                trans[i].append(direction)
-                trans[i].append(transaction['receivedTime'])
+                trans[i].append(int(time.time()))
-                
+                if direction == 'SENDING':
-                # trans[i].append(int(time.time()))
-                if direction.upper() == 'SENDING':
                     trans[i].append(outPubkey)
                     amount = int('-' + output.split(':')[0])
                 else:
@@ -172,8 +163,6 @@ class History:
                 trans[i].append(round(amount/self.UD, 2))
                 trans[i].append(transaction['comment'])
                 trans[i].append(base)
-                trans[i].append(transaction['blockstamp'])
-                trans[i].append(transaction['hash'])
                 i += 1
 
         # Order transactions by date
@@ -268,14 +257,11 @@ class History:
         for i, trans in enumerate(transList):
             dailyJSON.append(i)
             dailyJSON[i] = {}
-            dailyJSON[i]['status'] = trans[0].upper()
             dailyJSON[i]['date'] = trans[1]
             dailyJSON[i]['pubkey'] = trans[2]
             dailyJSON[i]['amount'] = trans[3]
             dailyJSON[i]['amountUD'] = trans[4]
             dailyJSON[i]['comment'] = trans[5]
-            dailyJSON[i]['blockstamp'] = trans[7]
-            dailyJSON[i]['hash'] = trans[8]
 
         dailyJSON = json.dumps(dailyJSON, indent=2)
         # If we want to write JSON to a file

lib/gvaWallets.py

@@ -1,100 +0,0 @@
-#!/usr/bin/env python3
-
-import sys
-import json
-from gql import gql, Client
-from gql.transport.aiohttp import AIOHTTPTransport
-from lib.natools import fmt, sign, get_privkey
-
-
-class ListWallets:
-    def __init__(
-        self, node=False, brut=False, mbr=False, nonMbr=False, larf=False, map=False
-    ):
-        # Initialize the ListWallets class with optional filters
-        self.mbr = mbr  # Filter for members
-        self.larf = larf  # Filter for non-empty identities
-        self.nonMbr = nonMbr  # Filter for non-members
-        self.brut = brut  # Output format flag (brut or JSON)
-        self.map = map  # Output format flag (map or list)
-
-        # Define Duniter GVA node
-        transport = AIOHTTPTransport(url=node)
-        self.client = Client(transport=transport, fetch_schema_from_transport=True)
-
-    def sendDoc(self):
-        # Define the GraphQL query to retrieve wallet information
-        queryBuild = gql(
-            """
-            {
-                wallets(pagination: { cursor: null, ord: ASC, pageSize: 0 }) {
-                    pageInfo {
-                        hasNextPage
-                        endCursor
-                    }
-                    edges {
-                        node {
-                            script
-                            balance {
-                                amount
-                                base
-                            }
-                            idty {
-                                isMember
-                                username
-                            }
-                        }
-                    }
-                }
-            }
-            """
-        )
-
-        try:
-            # Execute the GraphQL query
-            queryResult = self.client.execute(queryBuild)
-        except Exception as e:
-            # Handle any exceptions that occur during the query
-            sys.stderr.write("Failed to retrieve the list:\n" + str(e) + "\n")
-            sys.exit(1)
-
-        jsonBrut = queryResult["wallets"]["edges"]
-
-        walletList = []
-        walletMap = {}
-
-        for i, trans in enumerate(jsonBrut):
-            dataWork = trans["node"]
-            identity = dataWork["idty"]
-            is_member = identity and identity["isMember"]
-
-            # Apply filters based on member status and larf flag
-            member_filter = self.mbr and not is_member
-            non_member_filter = self.nonMbr and is_member
-            larf_filter = self.larf and identity
-            if member_filter or non_member_filter or larf_filter:
-                continue
-
-            wallet_data = {
-                "pubkey": dataWork["script"],
-                "balance": dataWork["balance"]["amount"] / 100,
-                "id": identity,
-            }
-
-            if self.map:
-                walletMap[dataWork["script"]] = wallet_data
-            else:
-                walletList.append(wallet_data)
-
-        if self.brut:
-            # Generate a list of formatted wallet names using list comprehension
-            names = [
-                wallet["pubkey"]
-                if not (self.mbr or self.nonMbr) or wallet["id"] is None
-                else f'{wallet["pubkey"]} {wallet["id"]["username"]}'
-                for wallet in walletList
-            ]
-            return "\n".join(names)
-        else:
-            # Return JSON data in either map or list format
-            return json.dumps(walletMap if self.map else walletList, indent=2)

lib/messaging.py

@@ -46,7 +46,6 @@ class ReadFromCesium(CesiumCommon):
     # Parse JSON result and display messages
     def readMessages(self, msgJSON, nbrMsg, outbox):
         def decrypt(msg):
-            if msg is None: return ''
             msg64 = base64.b64decode(msg)
             return box_decrypt(msg64, get_privkey(self.dunikey, "pubsec"), self.issuer, nonce).decode()
 
@@ -68,10 +67,7 @@ class ReadFromCesium(CesiumCommon):
                 msgSrc = hits["_source"]
                 self.issuer = msgSrc["issuer"]
                 nonce = msgSrc["nonce"]
-                try:
+                nonce = base58.b58decode(nonce)
-                    nonce = base58.b58decode(nonce)
-                except:
-                    nonce = base58.b58decode('5aZdSqKGHBqm2uMPwN6XnfiiJKRieb1Hh')
                 self.dateS = msgSrc["time"]
                 date = datetime.fromtimestamp(self.dateS).strftime(", le %d/%m/%Y à %H:%M  ")
                 if outbox:
@@ -98,7 +94,6 @@ class ReadFromCesium(CesiumCommon):
     # Parse JSON result and display messages
     def jsonMessages(self, msgJSON, nbrMsg, outbox):
         def decrypt(msg):
-            if msg is None: return ''
             msg64 = base64.b64decode(msg)
             return box_decrypt(msg64, get_privkey(self.dunikey, "pubsec"), self.issuer, nonce).decode()
 
@@ -118,10 +113,7 @@ class ReadFromCesium(CesiumCommon):
                 msgSrc = hits["_source"]
                 self.issuer = msgSrc["issuer"]
                 nonce = msgSrc["nonce"]
-                try:
+                nonce = base58.b58decode(nonce)
-                    nonce = base58.b58decode(nonce)
-                except:
-                    nonce = base58.b58decode('5aZdSqKGHBqm2uMPwN6XnfiiJKRieb1Hh')
                 self.date = msgSrc["time"]
 
                 if outbox:
@@ -131,18 +123,11 @@ class ReadFromCesium(CesiumCommon):
 
                 try:
                     self.title = decrypt(msgSrc["title"])
-                except Exception as e:
-                    self.title = "jaklis can't read that mother fucker"
-                    # sys.stderr.write(colored(str('Error decrypt message title: ' + str(e)), 'red') + '\n')
-                    # pp_json(hits)
-
-                try:
                     self.content = decrypt(msgSrc["content"])
                 except Exception as e:
-                    self.content = "jaklis can't read that mother fucker"
+                    sys.stderr.write(colored(str(e), 'red') + '\n')
-                    # sys.stderr.write(colored(str('Error decrypt message content: ' + str(e)), 'red') + '\n')
+                    pp_json(hits)
-                    # pp_json(hits)
+                    continue
-                    
 
                 data.append(i)
                 data[i] = {}
@@ -151,7 +136,6 @@ class ReadFromCesium(CesiumCommon):
                 data[i]['pubkey'] = pubkey
                 data[i]['title'] = self.title
                 data[i]['content'] = self.content
-                # print('toto')
 
             data = json.dumps(data, indent=2)
             return data

lib/offers.py

@@ -4,7 +4,7 @@ from lib.cesiumCommon import CesiumCommon, PUBKEY_REGEX
 
 class Offers(CesiumCommon):
     # Configure JSON document SET to send
-    def configDocSet(self, title, description, city, location, category, price: float, picture):
+    def configDocSet(self, title, description, city, localisation, category, price: float, picture):
         timeSent = int(time())
 
 # {"parent":"cat90","localizedNames":{"en":"Fruits & Vegetables","es-ES":"Frutas y Vegetales","fr-FR":"Fruits & Légumes"},"name":"Fruits & Légumes","id":"cat92"}
@@ -13,10 +13,10 @@ class Offers(CesiumCommon):
         if title: data['title'] = title
         if description: data['description'] = description
         if city: data['city'] = city
-        if location: 
+        if localisation: 
             geoPoint = {}
-            geoPoint['lat'] = location[0]
+            geoPoint['lat'] = localisation[0]
-            geoPoint['lon'] = location[1]
+            geoPoint['lon'] = localisation[1]
             data['geoPoint'] = geoPoint
         if picture:
             picture = open(picture, 'rb').read()

lib/profiles.py

@@ -1,4 +1,4 @@
-import sys, json, requests, base64
+import sys, re, json, requests, base64
 from time import time
 from lib.cesiumCommon import CesiumCommon, PUBKEY_REGEX
 
@@ -9,74 +9,71 @@ class Profiles(CesiumCommon):
         timeSent = int(time())
 
         data = {}
-        if name:
+        if name: data['title'] = name
-            data["title"] = name
+        if description: data['description'] = description
-        if description:
+        if address: data['address'] = address
-            data["description"] = description
+        if city: data['city'] = city
-        if address:
+        if pos: 
-            data["address"] = address
-        if city:
-            data["city"] = city
-        if pos:
             geoPoint = {}
-            geoPoint["lat"] = pos[0]
+            geoPoint['lat'] = pos[0]
-            geoPoint["lon"] = pos[1]
+            geoPoint['lon'] = pos[1]
-            data["geoPoint"] = geoPoint
+            data['geoPoint'] = geoPoint
         if socials:
-            data["socials"] = []
+            data['socials'] = []
-            data["socials"].append({})
+            data['socials'].append({})
-            data["socials"][0]["type"] = "web"
+            data['socials'][0]['type'] = "web"
-            data["socials"][0]["url"] = socials
+            data['socials'][0]['url'] = socials
         if avatar:
-            avatar = open(avatar, "rb").read()
+            avatar = open(avatar, 'rb').read()
             avatar = base64.b64encode(avatar).decode()
-            data["avatar"] = {}
+            data['avatar'] = {}
-            data["avatar"]["_content"] = avatar
+            data['avatar']['_content'] = avatar
-            data["avatar"]["_content_type"] = "image/png"
+            data['avatar']['_content_type'] = "image/png"
-        data["time"] = timeSent
+        data['time'] = timeSent
-        data["issuer"] = self.pubkey
+        data['issuer'] = self.pubkey
-        data["version"] = 2
+        data['version'] = 2
-        data["tags"] = []
+        data['tags'] = []
 
-        document = json.dumps(data)
+        document =  json.dumps(data)
 
         return self.signDoc(document)
 
-    # Configure JSON document GET to send
+   # Configure JSON document GET to send
-    def configDocGet(self, profile, scope="title", getAvatar=None):
+    def configDocGet(self, profile, scope='title', getAvatar=None):
+
         if getAvatar:
             avatar = "avatar"
         else:
             avatar = "avatar._content_type"
 
         data = {
-            "query": {
+                "query": {
                 "bool": {
-                    "should": [
+                    "should":[
-                        {"match": {scope: {"query": profile, "boost": 2}}},
+                        {
-                        {"prefix": {scope: profile}},
+                            "match":{
+                                scope:{
+                                    "query": profile,"boost":2
+                                }
+                            }
+                        },{
+                            "prefix": {scope: profile}
+                        }
                     ]
                 }
-            },
+            },"highlight": {
-            "highlight": {"fields": {"title": {}, "tags": {}}},
+                    "fields": {
-            "from": 0,
+                        "title":{},
-            "size": 100,
+                        "tags":{}
-            "_source": [
+                    }
-                "title",
+                },"from":0,
-                avatar,
+                "size":100,
-                "description",
+                "_source":["title", avatar,"description","city","address","socials.url","creationTime","membersCount","type","geoPoint"],
-                "city",
+                "indices_boost":{"user":100,"page":1,"group":0.01
-                "address",
+                }
-                "socials.url",
-                "creationTime",
-                "membersCount",
-                "type",
-                "geoPoint",
-            ],
-            "indices_boost": {"user": 100, "page": 1, "group": 0.01},
         }
 
-        document = json.dumps(data)
+        document =  json.dumps(data)
 
         return document
 
@@ -85,45 +82,44 @@ class Profiles(CesiumCommon):
         timeSent = int(time())
 
         data = {}
-        data["time"] = timeSent
+        data['time'] = timeSent
-        data["id"] = self.pubkey
+        data['id'] = self.pubkey
-        data["issuer"] = self.pubkey
+        data['issuer'] = self.pubkey
-        data["version"] = 2
+        data['version'] = 2
-        data["index"] = "user"
+        data['index'] = "user"
-        data["type"] = "profile"
+        data['type'] = "profile"
 
-        document = json.dumps(data)
+        document =  json.dumps(data)
 
         return self.signDoc(document)
 
     def sendDocument(self, document, type):
+
         headers = {
-            "Content-type": "application/json",
+            'Content-type': 'application/json',
         }
 
         # Send JSON document and get JSON result
-        if type == "set":
+        if type == 'set':
-            reqQuery = "{0}/user/profile?pubkey={1}/_update?pubkey={1}".format(
+            reqQuery = '{0}/user/profile?pubkey={1}/_update?pubkey={1}'.format(self.pod, self.pubkey)
-                self.pod, self.pubkey
+        elif type == 'get':
-            )
+            reqQuery = '{0}/user,page,group/profile,record/_search'.format(self.pod)
-        elif type == "get":
+        elif type == 'erase':
-            reqQuery = "{0}/user,page,group/profile,record/_search".format(self.pod)
+            reqQuery = '{0}/history/delete'.format(self.pod)
-        elif type == "erase":
-            reqQuery = "{0}/history/delete".format(self.pod)
 
         result = requests.post(reqQuery, headers=headers, data=document)
         if result.status_code == 200:
             # print(result.text)
             return result.text
         else:
-            sys.stderr.write("Echec de l'envoi du document...\n" + result.text + "\n")
+            sys.stderr.write("Echec de l'envoi du document...\n" + result.text + '\n')
 
     def parseJSON(self, doc):
-        doc = json.loads(doc)["hits"]["hits"]
+        doc = json.loads(doc)['hits']['hits']
         if doc:
-            pubkey = {"pubkey": doc[0]["_id"]}
+            pubkey = { "pubkey": doc[0]['_id'] }
-            rest = doc[0]["_source"]
+            rest = doc[0]['_source']
             final = {**pubkey, **rest}
             return json.dumps(final, indent=2)
         else:
-            return "Profile vide"
+            return 'Profile vide'

requirements.txt

@@ -1,8 +1,9 @@
 wheel
 base58
 pybase64
-duniterpy
+duniterpy==0.62.0
 termcolor
 python-dotenv
-gql
+gql==3.0.0a5
+#gql==2.0
 requests

setup.sh

@@ -1,7 +1,5 @@
 #!/bin/bash
 
-hasError=0
-
 for i in gcc python3-pip python3-setuptools libpq-dev python3-dev python3-wheel; do
 	if [ $(dpkg-query -W -f='${Status}' $i 2>/dev/null | grep -c "ok installed") -eq 0 ]; then
 		[[ ! $j ]] && sudo apt update
@@ -10,12 +8,5 @@ for i in gcc python3-pip python3-setuptools libpq-dev python3-dev python3-wheel;
 	fi
 done
 
-pip3 install -r requirements.txt || hasError=1
+pip3 install -r requirements.txt
 chmod u+x jaklis.py
-sudo ln -sf $(realpath jaklis.py) /usr/local/bin/jaklis || hasError=1
-
-if [[ hasError -eq 0 ]]; then
-	echo "Setup done. You can use 'jaklis' command, try it."
-else
-	echo "An error has occurred"
-fi