cesium messaging jaklis
This commit is contained in:
parent
b9ede3d0bc
commit
07ef6ce428
|
@ -1,3 +1,4 @@
|
|||
DUNIKEY="/home/pi/.zen/secret.dunikey" # Chemin du fichier de trousseau Ḡ1 de l'émetteur, au format PubSec
|
||||
DUNIKEY="/.zen/secret.dunikey" # Chemin du fichier de trousseau Ḡ1 de l'émetteur, au format PubSec
|
||||
#POD="https://g1.data.duniter.fr" # Noeud Cecium+ utilisé pour l'envoi du message
|
||||
#POD="https://g1.data.le-sou.org" # Adresse du pod Cesium de secours
|
||||
POD="https://data.gchange.fr" # Noeud Gchange utilisé pour l'envoi du message
|
||||
|
|
|
@ -0,0 +1,147 @@
|
|||
#!/usr/bin/env python3
|
||||
|
||||
import argparse, sys, os, random, string, getpass
|
||||
from os.path import join, dirname
|
||||
from shutil import copyfile
|
||||
from dotenv import load_dotenv
|
||||
from duniterpy.key import SigningKey
|
||||
from lib.cesium import ReadFromCesium, SendToCesium, DeleteFromCesium, Profiles
|
||||
from lib.likes import ReadLikes, SendLikes, UnLikes
|
||||
|
||||
VERSION = "0.0.1"
|
||||
|
||||
# Get variables environment
|
||||
if not os.path.isfile('.env'):
|
||||
copyfile(".env.template", ".env")
|
||||
dotenv_path = join(dirname(__file__), '.env')
|
||||
load_dotenv(dotenv_path)
|
||||
|
||||
# Parse arguments
|
||||
parser = argparse.ArgumentParser()
|
||||
parser.add_argument('-v', '--version', action='store_true', help="Affiche la version actuelle du programme")
|
||||
|
||||
subparsers = parser.add_subparsers()
|
||||
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+")
|
||||
like_cmd = subparsers.add_parser('like', help="Voir les likes d'un profile / Liker un profile (option -s NOTE)")
|
||||
unlike_cmd = subparsers.add_parser('unlike', help="Supprimer un like")
|
||||
|
||||
if len(sys.argv) <= 1 or not sys.argv[1] in ('read','send','delete','set','get','erase','like','unlike','-v','--version'):
|
||||
sys.stderr.write("Veuillez indiquer une commande valide:\n\n")
|
||||
parser.print_help()
|
||||
sys.exit(1)
|
||||
|
||||
# Messages management
|
||||
read_cmd.add_argument('-n', '--number',type=int, default=3, help="Affiche les NUMBER derniers messages")
|
||||
read_cmd.add_argument('-o', '--outbox', action='store_true', help="Lit les messages envoyés")
|
||||
|
||||
send_cmd.add_argument('-d', '--destinataire', required=True, help="Destinataire du message")
|
||||
send_cmd.add_argument('-t', '--titre', help="Titre du message à envoyer")
|
||||
send_cmd.add_argument('-m', '--message', help="Message à envoyer")
|
||||
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")
|
||||
|
||||
delete_cmd.add_argument('-i', '--id', action='append', nargs='+', required=True, help="ID(s) du/des message(s) à supprimer")
|
||||
delete_cmd.add_argument('-o', '--outbox', action='store_true', help="Suppression d'un message envoyé")
|
||||
|
||||
# Profiles management
|
||||
setProfile_cmd.add_argument('-n', '--name', help="Nom du profile")
|
||||
setProfile_cmd.add_argument('-d', '--description', help="Description du profile")
|
||||
setProfile_cmd.add_argument('-v', '--ville', help="Ville du profile")
|
||||
setProfile_cmd.add_argument('-a', '--adresse', help="Adresse du profile")
|
||||
setProfile_cmd.add_argument('-pos', '--position', nargs=2, help="Points géographiques (lat + lon)")
|
||||
setProfile_cmd.add_argument('-s', '--site', help="Site web du profile")
|
||||
|
||||
getProfile_cmd.add_argument('-p', '--profile', help="Nom du profile")
|
||||
|
||||
# Likes management
|
||||
like_cmd.add_argument('-p', '--profile', help="Profile cible")
|
||||
like_cmd.add_argument('-s', '--stars', type=int, help="Nombre d'étoile")
|
||||
unlike_cmd.add_argument('-p', '--profile', help="Profile à déliker")
|
||||
|
||||
args = parser.parse_args()
|
||||
|
||||
if args.version:
|
||||
print(VERSION)
|
||||
sys.exit(0)
|
||||
|
||||
def createTmpDunikey():
|
||||
# Generate pseudo-random nonce
|
||||
nonce=[]
|
||||
for i in range(32):
|
||||
nonce.append(random.choice(string.ascii_letters + string.digits))
|
||||
nonce = ''.join(nonce)
|
||||
keyPath = "/tmp/secret.dunikey-" + nonce
|
||||
|
||||
key = SigningKey.from_credentials(getpass.getpass("Identifiant: "), getpass.getpass("Mot de passe: "), None)
|
||||
key.save_pubsec_file(keyPath)
|
||||
|
||||
return keyPath
|
||||
|
||||
pod = os.getenv('POD')
|
||||
if not pod:
|
||||
pod="https://g1.data.le-sou.org"
|
||||
|
||||
dunikey = os.getenv('DUNIKEY')
|
||||
if not dunikey:
|
||||
keyPath = createTmpDunikey()
|
||||
dunikey = keyPath
|
||||
else:
|
||||
keyPath = False
|
||||
if not os.path.isfile(dunikey):
|
||||
HOME = os.getenv("HOME")
|
||||
dunikey = HOME + os.getenv('DUNIKEY')
|
||||
|
||||
|
||||
# Build cesiumMessaging class
|
||||
if sys.argv[1] == "read":
|
||||
messages = ReadFromCesium(dunikey, pod)
|
||||
messages.read(args.number, args.outbox)
|
||||
elif sys.argv[1] == "send":
|
||||
if args.fichier:
|
||||
with open(args.fichier, 'r') as f:
|
||||
titre = f.readline()
|
||||
msg = ''.join(f.read().splitlines(True)[0:])
|
||||
elif args.titre and args.message:
|
||||
titre = args.titre
|
||||
msg = args.message
|
||||
else:
|
||||
titre = input("Indiquez le titre du message: ")
|
||||
msg = input("Indiquez le contenu du message: ")
|
||||
|
||||
messages = SendToCesium(dunikey, pod, args.destinataire, args.outbox)
|
||||
messages.send(titre, msg)
|
||||
|
||||
elif sys.argv[1] == "delete":
|
||||
messages = DeleteFromCesium(dunikey, pod, args.outbox)
|
||||
messages.delete(args.id[0])
|
||||
|
||||
# Build cesium+ profiles class
|
||||
elif sys.argv[1] in ('set','get','erase'):
|
||||
cesium = Profiles(dunikey, pod)
|
||||
if sys.argv[1] == "set":
|
||||
cesium.set(args.name, args.description, args.ville, args.adresse, args.position, args.site)
|
||||
elif sys.argv[1] == "get":
|
||||
cesium.get(args.profile)
|
||||
elif sys.argv[1] == "erase":
|
||||
cesium.erase()
|
||||
|
||||
# Build cesium+ likes class
|
||||
elif sys.argv[1] == "like":
|
||||
if args.stars or args.stars == 0:
|
||||
gchange = SendLikes(dunikey, pod)
|
||||
gchange.like(args.stars, args.profile)
|
||||
else:
|
||||
gchange = ReadLikes(dunikey, pod)
|
||||
gchange.readLikes(args.profile)
|
||||
elif sys.argv[1] == "unlike":
|
||||
gchange = UnLikes(dunikey, pod)
|
||||
gchange.unLike(args.profile)
|
||||
|
||||
|
||||
if keyPath:
|
||||
os.remove(keyPath)
|
Binary file not shown.
Binary file not shown.
|
@ -0,0 +1,463 @@
|
|||
#!/usr/bin/env python3
|
||||
|
||||
import os, sys, ast, requests, json, base58, base64, time, string, random, re
|
||||
from lib.natools import fmt, sign, get_privkey, box_decrypt, box_encrypt
|
||||
from time import sleep
|
||||
from hashlib import sha256
|
||||
from datetime import datetime
|
||||
from termcolor import colored
|
||||
|
||||
PUBKEY_REGEX = "(?![OIl])[1-9A-Za-z]{42,45}"
|
||||
|
||||
def pp_json(json_thing, sort=True, indents=4):
|
||||
# Print beautifull JSON
|
||||
if type(json_thing) is str:
|
||||
print(json.dumps(json.loads(json_thing), sort_keys=sort, indent=indents))
|
||||
else:
|
||||
print(json.dumps(json_thing, sort_keys=sort, indent=indents))
|
||||
return None
|
||||
|
||||
class ReadFromCesium:
|
||||
def __init__(self, dunikey, pod):
|
||||
# Get my pubkey from my private key
|
||||
try:
|
||||
self.dunikey = dunikey
|
||||
if not dunikey:
|
||||
raise ValueError("Dunikey is empty")
|
||||
except:
|
||||
sys.stderr.write("Please fill the path to your private key (PubSec)\n")
|
||||
sys.exit(1)
|
||||
|
||||
self.recipient = get_privkey(dunikey, "pubsec").pubkey
|
||||
self.pod = pod
|
||||
|
||||
if not re.match(PUBKEY_REGEX, self.recipient) or len(self.recipient) > 45:
|
||||
sys.stderr.write("La clé publique n'est pas au bon format.\n")
|
||||
sys.exit(1)
|
||||
|
||||
# Configure JSON document to send
|
||||
def configDoc(self, nbrMsg, outbox):
|
||||
boxType = "issuer" if outbox else "recipient"
|
||||
|
||||
data = {}
|
||||
data['sort'] = { "time": "desc" }
|
||||
data['from'] = 0
|
||||
data['size'] = nbrMsg
|
||||
data['_source'] = ['issuer','recipient','title','content','time','nonce','read_signature']
|
||||
data['query'] = {}
|
||||
data['query']['bool'] = {}
|
||||
data['query']['bool']['filter'] = {}
|
||||
data['query']['bool']['filter']['term'] = {}
|
||||
data['query']['bool']['filter']['term'][boxType] = self.recipient
|
||||
|
||||
document = json.dumps(data)
|
||||
return document
|
||||
|
||||
def sendDocument(self, nbrMsg, outbox):
|
||||
boxType = "outbox" if outbox else "inbox"
|
||||
|
||||
document = self.configDoc(nbrMsg, outbox)
|
||||
headers = {
|
||||
'Content-type': 'application/json',
|
||||
}
|
||||
|
||||
# Send JSON document and get JSON result
|
||||
result = requests.post('{0}/message/{1}/_search'.format(self.pod, boxType), headers=headers, data=document)
|
||||
if result.status_code == 200:
|
||||
return result.json()["hits"]
|
||||
else:
|
||||
sys.stderr.write("Echec de l'envoi du document de lecture des messages...\n" + result.text)
|
||||
|
||||
# Parse JSON result and display messages
|
||||
def readMessages(self, msgJSON, nbrMsg, outbox):
|
||||
def decrypt(msg):
|
||||
msg64 = base64.b64decode(msg)
|
||||
return box_decrypt(msg64, get_privkey(self.dunikey, "pubsec"), self.issuer, nonce).decode()
|
||||
|
||||
# Get terminal size
|
||||
rows = int(os.popen('stty size', 'r').read().split()[1])
|
||||
|
||||
totalMsg = msgJSON["total"]
|
||||
if nbrMsg > totalMsg:
|
||||
nbrMsg = totalMsg
|
||||
|
||||
if totalMsg == 0:
|
||||
print(colored("Aucun message à afficher.", 'yellow'))
|
||||
return True
|
||||
else:
|
||||
infoTotal = " Nombre de messages: " + str(nbrMsg) + "/" + str(totalMsg) + " "
|
||||
print(colored(infoTotal.center(rows, '#'), "yellow"))
|
||||
for hits in msgJSON["hits"]:
|
||||
self.idMsg = hits["_id"]
|
||||
msgSrc = hits["_source"]
|
||||
self.issuer = msgSrc["issuer"]
|
||||
nonce = msgSrc["nonce"]
|
||||
nonce = base58.b58decode(nonce)
|
||||
self.dateS = msgSrc["time"]
|
||||
date = datetime.fromtimestamp(self.dateS).strftime(", le %d/%m/%Y à %H:%M ")
|
||||
if outbox:
|
||||
startHeader = " À " + msgSrc["recipient"]
|
||||
else:
|
||||
startHeader = " De " + self.issuer
|
||||
headerMsg = startHeader + date + "(ID: {})".format(self.idMsg) + " "
|
||||
|
||||
print('-'.center(rows, '-'))
|
||||
print(colored(headerMsg, "blue").center(rows+9, '-'))
|
||||
print('-'.center(rows, '-'))
|
||||
try:
|
||||
self.title = decrypt(msgSrc["title"])
|
||||
self.content = decrypt(msgSrc["content"])
|
||||
except Exception as e:
|
||||
sys.stderr.write(colored(str(e), 'red') + '\n')
|
||||
pp_json(hits)
|
||||
continue
|
||||
print('\033[1m' + self.title + '\033[0m')
|
||||
print(self.content)
|
||||
|
||||
print(colored(infoTotal.center(rows, '#'), "yellow"))
|
||||
|
||||
|
||||
def read(self, nbrMsg, outbox):
|
||||
jsonMsg = self.sendDocument(nbrMsg, outbox)
|
||||
self.readMessages(jsonMsg, nbrMsg, outbox)
|
||||
|
||||
|
||||
|
||||
|
||||
#################### Sending class ####################
|
||||
|
||||
|
||||
|
||||
|
||||
class SendToCesium:
|
||||
def __init__(self, dunikey, pod, recipient, outbox):
|
||||
# Get my pubkey from my private key
|
||||
try:
|
||||
self.dunikey = dunikey
|
||||
if not dunikey:
|
||||
raise ValueError("Dunikey is empty")
|
||||
except:
|
||||
sys.stderr.write("Please fill the path to your private key (PubSec)\n")
|
||||
sys.exit(1)
|
||||
|
||||
self.issuer = get_privkey(dunikey, "pubsec").pubkey
|
||||
self.pod = pod
|
||||
self.recipient = recipient
|
||||
self.outbox = outbox
|
||||
|
||||
# Generate pseudo-random nonce
|
||||
nonce=[]
|
||||
for i in range(32):
|
||||
nonce.append(random.choice(string.ascii_letters + string.digits))
|
||||
self.nonce = base64.b64decode(''.join(nonce))
|
||||
|
||||
if not re.match(PUBKEY_REGEX, recipient) or len(recipient) > 45:
|
||||
sys.stderr.write("La clé publique n'est pas au bon format.\n")
|
||||
sys.exit(1)
|
||||
|
||||
|
||||
def encryptMsg(self, msg):
|
||||
return fmt["64"](box_encrypt(msg.encode(), get_privkey(self.dunikey, "pubsec"), self.recipient, self.nonce)).decode()
|
||||
|
||||
def configDoc(self, title, msg):
|
||||
b58nonce = base58.b58encode(self.nonce).decode()
|
||||
|
||||
# Get current timestamp
|
||||
timeSent = int(time.time())
|
||||
|
||||
# Generate custom JSON
|
||||
data = {}
|
||||
data['issuer'] = self.issuer
|
||||
data['recipient'] = self.recipient
|
||||
data['title'] = title
|
||||
data['content'] = msg
|
||||
data['time'] = timeSent
|
||||
data['nonce'] = b58nonce
|
||||
data['version'] = 2
|
||||
document = json.dumps(data)
|
||||
|
||||
# Generate hash of document
|
||||
hashDoc = sha256(document.encode()).hexdigest().upper()
|
||||
|
||||
# Generate signature of document
|
||||
signature = fmt["64"](sign(hashDoc.encode(), get_privkey(self.dunikey, "pubsec"))[:-len(hashDoc.encode())]).decode()
|
||||
|
||||
# Build final document
|
||||
finalDoc = '{' + '"hash":"{0}","signature":"{1}",'.format(hashDoc, signature) + document[1:]
|
||||
|
||||
return finalDoc
|
||||
|
||||
|
||||
def sendDocument(self, document):
|
||||
boxType = "outbox" if self.outbox else "inbox"
|
||||
|
||||
headers = {
|
||||
'Content-type': 'application/json',
|
||||
}
|
||||
|
||||
# Send JSON document and get result
|
||||
try:
|
||||
result = requests.post('{0}/message/{1}?pubkey={2}'.format(self.pod, boxType, self.recipient), headers=headers, data=document)
|
||||
except Exception as e:
|
||||
sys.stderr.write("Impossible d'envoyer le message:\n" + str(e))
|
||||
sys.exit(1)
|
||||
else:
|
||||
if result.status_code == 200:
|
||||
print(colored("Message envoyé avec succès !", "green"))
|
||||
print("ID: " + result.text)
|
||||
return result
|
||||
else:
|
||||
sys.stderr.write("Erreur inconnue:" + '\n')
|
||||
print(str(pp_json(result.text)) + '\n')
|
||||
|
||||
def send(self, title, msg):
|
||||
finalDoc = self.configDoc(self.encryptMsg(title), self.encryptMsg(msg)) # Configure JSON document to send
|
||||
self.sendDocument(finalDoc) # Send final signed document
|
||||
|
||||
|
||||
|
||||
|
||||
#################### Deleting class ####################
|
||||
|
||||
|
||||
|
||||
|
||||
class DeleteFromCesium:
|
||||
def __init__(self, dunikey, pod, outbox):
|
||||
# Get my pubkey from my private key
|
||||
try:
|
||||
self.dunikey = dunikey
|
||||
if not dunikey:
|
||||
raise ValueError("Dunikey is empty")
|
||||
except:
|
||||
sys.stderr.write("Please fill the path to your private key (PubSec)\n")
|
||||
sys.exit(1)
|
||||
|
||||
self.issuer = get_privkey(dunikey, "pubsec").pubkey
|
||||
self.pod = pod
|
||||
self.outbox = outbox
|
||||
|
||||
|
||||
def configDoc(self, idMsg):
|
||||
# Get current timestamp
|
||||
timeSent = int(time.time())
|
||||
|
||||
boxType = "outbox" if self.outbox else "inbox"
|
||||
|
||||
# Generate document to customize
|
||||
data = {}
|
||||
data['version'] = 2
|
||||
data['index'] = "message"
|
||||
data['type'] = boxType
|
||||
data['id'] = idMsg
|
||||
data['issuer'] = self.issuer
|
||||
data['time'] = timeSent
|
||||
document = json.dumps(data)
|
||||
|
||||
# Generate hash of document
|
||||
hashDoc = sha256(document.encode()).hexdigest().upper()
|
||||
|
||||
# Generate signature of document
|
||||
signature = fmt["64"](sign(hashDoc.encode(), get_privkey(self.dunikey, "pubsec"))[:-len(hashDoc.encode())]).decode()
|
||||
|
||||
# Build final document
|
||||
data = {}
|
||||
data['hash'] = hashDoc
|
||||
data['signature'] = signature
|
||||
signJSON = json.dumps(data)
|
||||
finalJSON = {**json.loads(signJSON), **json.loads(document)}
|
||||
finalDoc = json.dumps(finalJSON)
|
||||
|
||||
return finalDoc
|
||||
|
||||
def sendDocument(self, document, idMsg):
|
||||
headers = {
|
||||
'Content-type': 'application/json',
|
||||
}
|
||||
|
||||
# Send JSON document and get result
|
||||
try:
|
||||
result = requests.post('{0}/history/delete'.format(self.pod), headers=headers, data=document)
|
||||
if result.status_code == 404:
|
||||
raise ValueError("Message introuvable")
|
||||
elif result.status_code == 403:
|
||||
raise ValueError("Vous n'êtes pas l'auteur de ce message.")
|
||||
except Exception as e:
|
||||
sys.stderr.write(colored("Impossible de supprimer le message {0}:\n".format(idMsg), 'red') + str(e) + "\n")
|
||||
return False
|
||||
else:
|
||||
if result.status_code == 200:
|
||||
print(colored("Message {0} supprimé avec succès !".format(idMsg), "green"))
|
||||
return result
|
||||
else:
|
||||
sys.stderr.write("Erreur inconnue.")
|
||||
|
||||
def delete(self, idsMsgList):
|
||||
for idMsg in idsMsgList:
|
||||
finalDoc = self.configDoc(idMsg)
|
||||
self.sendDocument(finalDoc, idMsg)
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
#################### Profile class ####################
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
class Profiles:
|
||||
def __init__(self, dunikey, pod):
|
||||
# Get my pubkey from my private key
|
||||
try:
|
||||
self.dunikey = dunikey
|
||||
if not dunikey:
|
||||
raise ValueError("Dunikey is empty")
|
||||
except:
|
||||
sys.stderr.write("Please fill the path to your private key (PubSec)\n")
|
||||
sys.exit(1)
|
||||
|
||||
self.pubkey = get_privkey(dunikey, "pubsec").pubkey
|
||||
self.pod = pod
|
||||
|
||||
if not re.match(PUBKEY_REGEX, self.pubkey) or len(self.pubkey) > 45:
|
||||
sys.stderr.write("La clé publique n'est pas au bon format.\n")
|
||||
sys.exit(1)
|
||||
|
||||
# Configure JSON document SET to send
|
||||
def configDocSet(self, name, description, city, address, pos, socials):
|
||||
timeSent = int(time.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
|
||||
data['time'] = timeSent
|
||||
data['issuer'] = self.pubkey
|
||||
data['version'] = 2
|
||||
data['tags'] = []
|
||||
|
||||
document = json.dumps(data)
|
||||
|
||||
# Generate hash of document
|
||||
hashDoc = sha256(document.encode()).hexdigest().upper()
|
||||
|
||||
# Generate signature of document
|
||||
signature = fmt["64"](sign(hashDoc.encode(), get_privkey(self.dunikey, "pubsec"))[:-len(hashDoc.encode())]).decode()
|
||||
|
||||
# Build final document
|
||||
data = {}
|
||||
data['hash'] = hashDoc
|
||||
data['signature'] = signature
|
||||
signJSON = json.dumps(data)
|
||||
finalJSON = {**json.loads(signJSON), **json.loads(document)}
|
||||
finalDoc = json.dumps(finalJSON)
|
||||
|
||||
return finalDoc
|
||||
|
||||
# Configure JSON document GET to send
|
||||
def configDocGet(self, profile, scope='title'):
|
||||
|
||||
data = {
|
||||
"query": {
|
||||
"bool": {
|
||||
"should":[
|
||||
{
|
||||
"match":{
|
||||
scope:{
|
||||
"query": profile,"boost":2
|
||||
}
|
||||
}
|
||||
},{
|
||||
"prefix": {scope: profile}
|
||||
}
|
||||
]
|
||||
}
|
||||
},"highlight": {
|
||||
"fields": {
|
||||
"title":{},
|
||||
"tags":{}
|
||||
}
|
||||
},"from":0,
|
||||
"size":100,
|
||||
"_source":["title","avatar._content_type","description","city","address","socials.url","creationTime","membersCount","type"],
|
||||
"indices_boost":{"user":100,"page":1,"group":0.01
|
||||
}
|
||||
}
|
||||
|
||||
document = json.dumps(data)
|
||||
|
||||
return 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)
|
||||
|
||||
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}
|
||||
else:
|
||||
final = 'Profile vide'
|
||||
|
||||
return json.dumps(final, indent=2)
|
||||
|
||||
|
||||
def set(self, name=None, description=None, ville=None, adresse=None, position=None, site=None):
|
||||
document = self.configDocSet(name, description, ville, adresse, position, site)
|
||||
result = self.sendDocument(document,'set')
|
||||
|
||||
print(result)
|
||||
return result
|
||||
|
||||
def get(self, profile=None):
|
||||
if not profile:
|
||||
profile = self.pubkey
|
||||
if not re.match(PUBKEY_REGEX, profile) or len(profile) > 45:
|
||||
scope = 'title'
|
||||
else:
|
||||
scope = '_id'
|
||||
|
||||
document = self.configDocGet(profile, scope)
|
||||
resultJSON = self.sendDocument(document, 'get')
|
||||
result = self.parseJSON(resultJSON)
|
||||
|
||||
print(result)
|
||||
return result
|
||||
|
||||
def erase(self):
|
||||
document = self.configDocSet(None, None, None, None, None, None)
|
||||
result = self.sendDocument(document,'set')
|
||||
|
||||
print(result)
|
||||
return result
|
|
@ -0,0 +1,324 @@
|
|||
#!/usr/bin/env python3
|
||||
|
||||
import os, sys, ast, requests, json, base58, base64, time, string, random, re
|
||||
from lib.natools import fmt, sign, get_privkey, box_decrypt, box_encrypt
|
||||
from time import sleep
|
||||
from hashlib import sha256
|
||||
from datetime import datetime
|
||||
from termcolor import colored
|
||||
|
||||
PUBKEY_REGEX = "(?![OIl])[1-9A-Za-z]{42,45}"
|
||||
|
||||
class ReadLikes:
|
||||
def __init__(self, dunikey, pod):
|
||||
# Get my pubkey from my private key
|
||||
try:
|
||||
self.dunikey = dunikey
|
||||
if not dunikey:
|
||||
raise ValueError("Dunikey is empty")
|
||||
except:
|
||||
sys.stderr.write("Please fill the path to your private key (PubSec)\n")
|
||||
sys.exit(1)
|
||||
|
||||
self.issuer = get_privkey(dunikey, "pubsec").pubkey
|
||||
self.pod = pod
|
||||
|
||||
if not re.match(PUBKEY_REGEX, self.issuer) or len(self.issuer) > 45:
|
||||
sys.stderr.write("La clé publique n'est pas au bon format.\n")
|
||||
sys.exit(1)
|
||||
|
||||
# Configure JSON document to send
|
||||
def configDoc(self, profile):
|
||||
if not profile: profile = self.issuer
|
||||
# elif len(profile) < 42:
|
||||
# print(len(profile))
|
||||
# gProfile = requests.get('{0}/user/profile/{1}'.format(self.pod, issuer))
|
||||
# gProfile = json.loads(gProfile.text)['_source']
|
||||
# pseudo = gProfile['title']
|
||||
|
||||
data = {}
|
||||
data['query'] = {}
|
||||
data['query']['bool'] = {}
|
||||
data['query']['bool']['filter'] = [
|
||||
{'term': {'index': 'user'}},
|
||||
{'term': {'type': 'profile'}},
|
||||
{'term': {'id': profile}},
|
||||
{'term': {'kind': 'STAR'}}
|
||||
]
|
||||
# data['query']['bool']['should'] = {'term':{'issuer': self.issuer}}
|
||||
data['size'] = 5000
|
||||
data['_source'] = ['issuer','level']
|
||||
data['aggs'] = {
|
||||
'level_sum': {
|
||||
'sum': {
|
||||
'field': 'level'
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return json.dumps(data)
|
||||
|
||||
def sendDocument(self, document):
|
||||
|
||||
headers = {
|
||||
'Content-type': 'application/json',
|
||||
}
|
||||
|
||||
# Send JSON document and get JSON result
|
||||
result = requests.post('{0}/like/record/_search'.format(self.pod), 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 de lecture des messages...\n" + result.text + '\n')
|
||||
|
||||
def parseResult(self, result):
|
||||
result = json.loads(result)
|
||||
totalLikes = result['hits']['total']
|
||||
totalValue = result['aggregations']['level_sum']['value']
|
||||
if totalLikes:
|
||||
score = totalValue/totalLikes
|
||||
else:
|
||||
score = 0
|
||||
raw = result['hits']['hits']
|
||||
finalPrint = {}
|
||||
finalPrint['likes'] = []
|
||||
for i in raw:
|
||||
issuer = i['_source']['issuer']
|
||||
gProfile = self.getProfile(issuer)
|
||||
pseudo = gProfile['title']
|
||||
payTo = gProfile['pubkey']
|
||||
id = i['_id']
|
||||
level = i['_source']['level']
|
||||
if issuer == self.issuer:
|
||||
finalPrint['yours'] = { 'id' : id, 'pseudo' : pseudo, 'level' : level }
|
||||
else:
|
||||
finalPrint['likes'].append({ 'issuer' : issuer, 'pseudo' : pseudo, 'payTo' : payTo, 'level' : level })
|
||||
finalPrint['score'] = score
|
||||
|
||||
return json.dumps(finalPrint)
|
||||
|
||||
def getProfile(self, profile):
|
||||
headers = {
|
||||
'Content-type': 'application/json',
|
||||
}
|
||||
|
||||
data = {}
|
||||
data['query'] = {}
|
||||
data['query']['bool'] = {}
|
||||
data['query']['bool']['filter'] = [
|
||||
{'term': {'_index': 'user'}},
|
||||
{'term': {'_type': 'profile'}},
|
||||
{'term': {'_id': profile}}
|
||||
]
|
||||
data['_source'] = ['title','pubkey']
|
||||
|
||||
data = json.dumps(data)
|
||||
|
||||
result = requests.post('{0}/user/profile/_search'.format(self.pod), headers=headers, data=data)
|
||||
result = json.loads(result.text)['hits']['hits'][0]['_source']
|
||||
|
||||
return result
|
||||
|
||||
def readLikes(self, profile=False):
|
||||
document = self.configDoc(profile)
|
||||
result = self.sendDocument(document)
|
||||
result = self.parseResult(result)
|
||||
|
||||
print(result)
|
||||
return result
|
||||
|
||||
|
||||
|
||||
|
||||
#################### Like class ####################
|
||||
|
||||
|
||||
|
||||
|
||||
class SendLikes:
|
||||
def __init__(self, dunikey, pod):
|
||||
# Get my pubkey from my private key
|
||||
try:
|
||||
self.dunikey = dunikey
|
||||
if not dunikey:
|
||||
raise ValueError("Dunikey is empty")
|
||||
except:
|
||||
sys.stderr.write("Please fill the path to your private key (PubSec)\n")
|
||||
sys.exit(1)
|
||||
|
||||
self.issuer = get_privkey(dunikey, "pubsec").pubkey
|
||||
self.pod = pod
|
||||
|
||||
if not re.match(PUBKEY_REGEX, self.issuer) or len(self.issuer) > 45:
|
||||
sys.stderr.write("La clé publique n'est pas au bon format.\n")
|
||||
sys.exit(1)
|
||||
|
||||
# Configure JSON document to send
|
||||
def configDoc(self, profile, likes):
|
||||
if not profile: profile = self.issuer
|
||||
if likes not in range(0, 6):
|
||||
sys.stderr.write(colored('Votre like doit être compris entre 0 et 5.\n', 'red'))
|
||||
return False
|
||||
|
||||
|
||||
timeSent = int(time.time())
|
||||
|
||||
data = {}
|
||||
data['version'] = 2
|
||||
data['index'] = "user"
|
||||
data['type'] = "profile"
|
||||
data['id'] = profile
|
||||
data['kind'] = "STAR"
|
||||
data['level'] = likes
|
||||
data['time'] = timeSent
|
||||
data['issuer'] = self.issuer
|
||||
|
||||
document = json.dumps(data)
|
||||
|
||||
# Generate hash of document
|
||||
hashDoc = sha256(document.encode()).hexdigest().upper()
|
||||
|
||||
# Generate signature of document
|
||||
signature = fmt["64"](sign(hashDoc.encode(), get_privkey(self.dunikey, "pubsec"))[:-len(hashDoc.encode())]).decode()
|
||||
|
||||
# Build final document
|
||||
data = {}
|
||||
data['hash'] = hashDoc
|
||||
data['signature'] = signature
|
||||
signJSON = json.dumps(data)
|
||||
finalJSON = {**json.loads(signJSON), **json.loads(document)}
|
||||
finalDoc = json.dumps(finalJSON)
|
||||
|
||||
return finalDoc
|
||||
|
||||
def sendDocument(self, document, pubkey):
|
||||
|
||||
headers = {
|
||||
'Content-type': 'application/json',
|
||||
}
|
||||
|
||||
# Send JSON document and get JSON result
|
||||
result = requests.post('{0}/user/profile/:id/_like'.format(self.pod), headers=headers, data=document)
|
||||
|
||||
if result.status_code == 200:
|
||||
print(colored("Profile liké avec succès !", 'green'))
|
||||
return result.text
|
||||
elif result.status_code == 400:
|
||||
resultJson = json.loads(result.text)
|
||||
if 'DuplicatedDocumentException' in resultJson['error']:
|
||||
rmLike = UnLikes(self.dunikey, self.pod)
|
||||
rmLike.unLike(pubkey, True)
|
||||
sleep(0.5)
|
||||
self.sendDocument(document, pubkey)
|
||||
return resultJson['error']
|
||||
else:
|
||||
sys.stderr.write("Echec de l'envoi du document de lecture des messages...\n" + resultJson['error'] + '\n')
|
||||
else:
|
||||
resultJson = json.loads(result.text)
|
||||
sys.stderr.write("Echec de l'envoi du document de lecture des messages...\n" + resultJson['error'] + '\n')
|
||||
|
||||
|
||||
|
||||
|
||||
def like(self, stars, profile=False):
|
||||
document = self.configDoc(profile, stars)
|
||||
if document:
|
||||
self.sendDocument(document, profile)
|
||||
|
||||
|
||||
|
||||
|
||||
#################### Unlike class ####################
|
||||
|
||||
|
||||
|
||||
|
||||
class UnLikes:
|
||||
def __init__(self, dunikey, pod):
|
||||
# Get my pubkey from my private key
|
||||
try:
|
||||
self.dunikey = dunikey
|
||||
if not dunikey:
|
||||
raise ValueError("Dunikey is empty")
|
||||
except:
|
||||
sys.stderr.write("Please fill the path to your private key (PubSec)\n")
|
||||
sys.exit(1)
|
||||
|
||||
self.issuer = get_privkey(dunikey, "pubsec").pubkey
|
||||
self.pod = pod
|
||||
|
||||
if not re.match(PUBKEY_REGEX, self.issuer) or len(self.issuer) > 45:
|
||||
sys.stderr.write("La clé publique n'est pas au bon format.\n")
|
||||
sys.exit(1)
|
||||
|
||||
# Check if you liked this profile
|
||||
def checkLike(self, pubkey):
|
||||
|
||||
readProfileLikes = ReadLikes(self.dunikey, self.pod)
|
||||
document = readProfileLikes.configDoc(pubkey)
|
||||
result = readProfileLikes.sendDocument(document)
|
||||
result = readProfileLikes.parseResult(result)
|
||||
result = json.loads(result)
|
||||
|
||||
if 'yours' in result:
|
||||
myLike = result['yours']['id']
|
||||
return myLike
|
||||
else:
|
||||
sys.stderr.write("Vous n'avez pas liké ce profile\n")
|
||||
return False
|
||||
|
||||
# Configure JSON document to send
|
||||
def configDoc(self, idLike):
|
||||
timeSent = int(time.time())
|
||||
|
||||
data = {}
|
||||
data['version'] = 2
|
||||
data['index'] = "like"
|
||||
data['type'] = "record"
|
||||
data['id'] = idLike
|
||||
data['issuer'] = self.issuer
|
||||
data['time'] = timeSent
|
||||
|
||||
document = json.dumps(data)
|
||||
|
||||
# Generate hash of document
|
||||
hashDoc = sha256(document.encode()).hexdigest().upper()
|
||||
|
||||
# Generate signature of document
|
||||
signature = fmt["64"](sign(hashDoc.encode(), get_privkey(self.dunikey, "pubsec"))[:-len(hashDoc.encode())]).decode()
|
||||
|
||||
# Build final document
|
||||
data = {}
|
||||
data['hash'] = hashDoc
|
||||
data['signature'] = signature
|
||||
signJSON = json.dumps(data)
|
||||
finalJSON = {**json.loads(signJSON), **json.loads(document)}
|
||||
finalDoc = json.dumps(finalJSON)
|
||||
|
||||
return finalDoc
|
||||
|
||||
def sendDocument(self, document, silent):
|
||||
|
||||
headers = {
|
||||
'Content-type': 'application/json',
|
||||
}
|
||||
|
||||
# Send JSON document and get JSON result
|
||||
result = requests.post('{0}/history/delete'.format(self.pod), headers=headers, data=document)
|
||||
|
||||
if result.status_code == 200:
|
||||
if not silent:
|
||||
print(colored("Like supprimé avec succès !", 'green'))
|
||||
return result.text
|
||||
else:
|
||||
sys.stderr.write("Echec de l'envoi du document de lecture des messages...\n" + result.text + '\n')
|
||||
|
||||
|
||||
def unLike(self, pubkey, silent=False):
|
||||
idLike = self.checkLike(pubkey)
|
||||
if idLike:
|
||||
document = self.configDoc(idLike)
|
||||
self.sendDocument(document, silent)
|
||||
|
|
@ -1,3 +1,4 @@
|
|||
DUNIKEY="/home/pi/.zen/secret.dunikey" # Chemin du fichier de trousseau Ḡ1 de l'émetteur, au format PubSec
|
||||
POD="https://g1.data.duniter.fr" # Noeud Cecium+ utilisé pour l'envoi du message
|
||||
#pod="https://data.gchange.fr" # Noeud Gchange utilisé pour l'envoi du message
|
||||
DUNIKEY="/.zen/secret.dunikey" # Chemin du fichier de trousseau Ḡ1 de l'émetteur, au format PubSec
|
||||
#POD="https://g1.data.duniter.fr" # Noeud Cecium+ utilisé pour l'envoi du message
|
||||
#POD="https://g1.data.le-sou.org" # Adresse du pod Cesium de secours
|
||||
POD="https://data.gchange.fr" # Noeud Gchange utilisé pour l'envoi du message
|
||||
|
|
Loading…
Reference in New Issue