You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
2093 lines
70 KiB
2093 lines
70 KiB
# coding: utf8
|
|
import simplematrixbotlib as botlib
|
|
|
|
import random
|
|
import re
|
|
import copy
|
|
import configparser
|
|
|
|
import signal
|
|
import sys
|
|
import pickle
|
|
import threading
|
|
import asyncio
|
|
import nio
|
|
|
|
from datetime import datetime,timedelta
|
|
import requests
|
|
from oauthlib.oauth2 import BackendApplicationClient
|
|
from requests_oauthlib import OAuth2Session
|
|
from requests.auth import HTTPBasicAuth
|
|
import html2text
|
|
import json
|
|
|
|
# Var
|
|
bot = None
|
|
PREFIX = '!'
|
|
USERNAME = ""
|
|
RTE_ID = None # Bot's RTE ID
|
|
RTE_SECRET = None # Bot's RTE SECRET
|
|
|
|
#ecowatt_url = 'https://digital.iservices.rte-france.com/open_api/ecowatt/v4/sandbox/signals'
|
|
ecowatt_url = 'https://digital.iservices.rte-france.com/open_api/ecowatt/v4/signals'
|
|
commune_url = 'https://geo.api.gouv.fr/communes?<TYPE>=<NOM>&fields=nom,code,codesPostaux,population&format=json'
|
|
eau_url = 'https://hubeau.eaufrance.fr/api/vbeta/qualite_eau_potable/resultats_dis?<TYPE>=<NOM>&size=5'
|
|
|
|
wattobj = None
|
|
|
|
# Listes et dictionnaires
|
|
admins = [] # Admins du bot
|
|
modos = {} # Moderateurs des salons
|
|
modules = {} # Modules activés par salon
|
|
prive = {} # Les espaces de message privés du bot avec les utilisateurs
|
|
liste_mod = [] # Modules disponibles
|
|
citations = {} #addquote
|
|
bieres = {} # Boissons a offrir
|
|
salons = {} # liste de salons recommandés
|
|
welcome = {} # Messages d'accueil des salons
|
|
clock = {} # horloges pbta
|
|
paquets = {} # paquets de cartes des salons
|
|
stats = {} # Statistiques sur les messages
|
|
|
|
cartes_base = ["As de carreau", "2 de carreau", "3 de carreau", "4 de carreau", "5 de carreau", "6 de carreau", \
|
|
"7 de carreau", "8 de carreau", "9 de carreau", "10 de carreau", "Valet de carreau", "Dame de carreau", \
|
|
"Roi de carreau", "As de coeur", "2 de coeur", "3 de coeur", "4 de coeur", "5 de coeur", "6 de coeur", \
|
|
"7 de coeur", "8 de coeur", "9 de coeur", "10 de coeur", "Valet de coeur", "Dame de coeur", "Roi de coeur", \
|
|
"As de pique", "2 de pique", "3 de pique", "4 de pique", "5 de pique", "6 de pique", "7 de pique", "8 de pique", \
|
|
"9 de pique", "10 de pique", "Valet de pique", "Dame de pique", "Roi de pique", "As de trefle", "2 de trefle", \
|
|
"3 de trefle", "4 de trefle", "5 de trefle", "6 de trefle", "7 de trefle", "8 de trefle", "9 de trefle", \
|
|
"10 de trefle", "Valet de trefle", "Dame de trefle", "Roi de trefle", "Joker rouge", "Joker noir"]
|
|
|
|
|
|
# Connexion du bot
|
|
config = configparser.ConfigParser()
|
|
config.read('asmodee.ini')
|
|
USERNAME = "" # Bot's username
|
|
PASSWORD = "" # Bot's password
|
|
SERVER = "" # Matrix server URL
|
|
mods = ["roll", "quote", "biere", "stats", "liste", "horloge", "carte", "card", "cristal", "welcome", "salut", "jdr", "gens", "va", "salon", "kick", "mails", "titre", "invidious"]
|
|
|
|
if ('AUTH' in config):
|
|
USERNAME = config['AUTH']['username'] # Bot's username
|
|
PASSWORD = config['AUTH']['password'] # Bot's password
|
|
SERVER = config['AUTH']['server'] # Matrix server URL
|
|
admins = config['AUTH']['admin'].split(",") # Admins du bot @admin1:host.tld,@admin2:host.tld,...
|
|
else:
|
|
print("Probleme de lecture de configuration asmodee.ini")
|
|
|
|
# Create an instance of the MatrixBotAPI
|
|
creds = botlib.Creds(SERVER, USERNAME, PASSWORD)
|
|
bot = botlib.Bot(creds)
|
|
|
|
# Chargement des données persistantes
|
|
def horloge_read():
|
|
global clock
|
|
try:
|
|
with open("horloge", "rb") as fichier:
|
|
loader = pickle.Unpickler(fichier)
|
|
clock = loader.load()
|
|
except:
|
|
clock = {}
|
|
|
|
def citations_read():
|
|
global citations
|
|
try:
|
|
with open("citations", "rb") as fichier:
|
|
loader = pickle.Unpickler(fichier)
|
|
citations = loader.load()
|
|
except:
|
|
citations = {}
|
|
|
|
|
|
def bieres_read():
|
|
global bieres
|
|
try:
|
|
with open("bieres", "rb") as fichier:
|
|
loader = pickle.Unpickler(fichier)
|
|
bieres = loader.load()
|
|
except:
|
|
bieres = {}
|
|
|
|
def salons_read():
|
|
global salons
|
|
try:
|
|
with open("salons", "rb") as fichier:
|
|
loader = pickle.Unpickler(fichier)
|
|
salons = loader.load()
|
|
except:
|
|
salons = {}
|
|
|
|
def welcome_read():
|
|
global welcome
|
|
try:
|
|
with open("welcome", "rb") as fichier:
|
|
loader = pickle.Unpickler(fichier)
|
|
welcome = loader.load()
|
|
except:
|
|
welcome = {}
|
|
|
|
def modos_read():
|
|
global modos
|
|
try:
|
|
with open("moderateurs", "rb") as fichier:
|
|
loader = pickle.Unpickler(fichier)
|
|
modos = loader.load()
|
|
except:
|
|
modos = {}
|
|
|
|
def modules_read():
|
|
global modules
|
|
try:
|
|
with open("modules", "rb") as fichier:
|
|
loader = pickle.Unpickler(fichier)
|
|
modules = loader.load()
|
|
except:
|
|
modules = {}
|
|
|
|
def prive_read():
|
|
global prive
|
|
try:
|
|
with open("prive", "rb") as fichier:
|
|
loader = pickle.Unpickler(fichier)
|
|
prive = loader.load()
|
|
except:
|
|
prive = {}
|
|
|
|
def paquets_read():
|
|
global cartes
|
|
try:
|
|
with open("paquets", "rb") as fichier:
|
|
loader = pickle.Unpickler(fichier)
|
|
paquets = loader.load()
|
|
except:
|
|
paquets = {}
|
|
|
|
def stats_read():
|
|
global stats
|
|
try:
|
|
with open("stats", "rb") as fichier:
|
|
loader = pickle.Unpickler(fichier)
|
|
stats = loader.load()
|
|
except:
|
|
stats = {}
|
|
|
|
def save_obj(room=None, message=None):
|
|
with open("moderateurs", "wb") as fichier:
|
|
saver = pickle.Pickler(fichier)
|
|
saver.dump(modos)
|
|
with open("modules", "wb") as fichier:
|
|
saver = pickle.Pickler(fichier)
|
|
saver.dump(modules)
|
|
with open("prive", "wb") as fichier:
|
|
saver = pickle.Pickler(fichier)
|
|
saver.dump(prive)
|
|
if ('horloge' in liste_mod):
|
|
with open("horloge", "wb") as fichier:
|
|
saver = pickle.Pickler(fichier)
|
|
saver.dump(clock)
|
|
if ('quote' in liste_mod):
|
|
#with open("quotes", "wb") as fichier:
|
|
# saver = pickle.Pickler(fichier)
|
|
# saver.dump(quotes)
|
|
with open("citations", "wb") as fichier:
|
|
saver = pickle.Pickler(fichier)
|
|
saver.dump(citations)
|
|
if ('biere' in liste_mod):
|
|
with open("bieres", "wb") as fichier:
|
|
saver = pickle.Pickler(fichier)
|
|
saver.dump(bieres)
|
|
if ('salon' in liste_mod):
|
|
with open("salons", "wb") as fichier:
|
|
saver = pickle.Pickler(fichier)
|
|
saver.dump(salons)
|
|
if ('welcome' in liste_mod):
|
|
with open("welcome", "wb") as fichier:
|
|
saver = pickle.Pickler(fichier)
|
|
saver.dump(welcome)
|
|
if ('cartes' in liste_mod):
|
|
with open("paquets", "wb") as fichier:
|
|
saver = pickle.Pickler(fichier)
|
|
saver.dump(paquets)
|
|
if ('stats' in liste_mod):
|
|
with open("stats", "wb") as fichier:
|
|
saver = pickle.Pickler(fichier)
|
|
saver.dump(stats)
|
|
|
|
def signal_handler(signal, frame): # Sauvegarder les données persistantes avant sortie
|
|
save_obj(None,None)
|
|
sys.exit(0)
|
|
|
|
class Wattobject: # Cache du service ecowatt
|
|
def __init__(self):
|
|
self.jour = 19000101
|
|
self.heure = 0
|
|
self.signals = None
|
|
|
|
class Userstats: #Pour garder des stats sur les users
|
|
def __init__(self,room,user,nick):
|
|
self.room = room
|
|
self.user = user
|
|
self.nick = nick.strip() if nick and nick != None else ""
|
|
self.date = 0
|
|
self.mess = 0
|
|
self.char = 0
|
|
|
|
class Parser: #Pour parser la ligne de commande
|
|
def __init__(self, str, nick, room):
|
|
self._str = str.strip()
|
|
self._nick = nick
|
|
self._old = ""
|
|
self._mtch = ""
|
|
self._room = room
|
|
self._arg = {}
|
|
self._option = [False,False,False,0,0,0,0,0,False,0,0,False]
|
|
|
|
@property
|
|
def str(self):
|
|
return self._str
|
|
|
|
@str.setter
|
|
def str(self, str):
|
|
self._str = str
|
|
|
|
@property
|
|
def nick(self):
|
|
return self._nick
|
|
|
|
@nick.setter
|
|
def nick(self, nick):
|
|
self._nick = nick
|
|
|
|
@property
|
|
def old(self):
|
|
return self._old
|
|
|
|
@old.setter
|
|
def old(self, old):
|
|
self._old = old
|
|
|
|
@property
|
|
def mtch(self):
|
|
return self._mtch
|
|
|
|
@mtch.setter
|
|
def mtch(self, mtch):
|
|
self._mtch = mtch
|
|
|
|
@property
|
|
def room(self):
|
|
return self._room
|
|
|
|
@room.setter
|
|
def room(self, room):
|
|
self._room = room
|
|
|
|
@property
|
|
def arg(self):
|
|
return self._arg
|
|
|
|
@arg.setter
|
|
def arg(self, arg):
|
|
self._arg = arg
|
|
|
|
@property
|
|
def option(self):
|
|
return self._option
|
|
|
|
@option.setter
|
|
def option(self, option):
|
|
self._option = option
|
|
|
|
def space(self):
|
|
if (re.match("^\s", self._str) or re.match("^$", self._str)):
|
|
return True
|
|
else:
|
|
return False
|
|
|
|
def restaure(self):
|
|
self._str += self._mtch
|
|
self._old
|
|
|
|
def eat(self,mtch,opt):
|
|
pattern=r"^(\s*)(" + mtch + r")(.*)"
|
|
if (re.match(pattern,self._str)):
|
|
if (opt == 1):
|
|
self._mtch = re.sub(pattern,r"\2",self._str)
|
|
self._old += re.sub(pattern,r"\1\2",self._str)
|
|
self._str = re.sub(pattern,r"\3",self._str)
|
|
return True
|
|
return False
|
|
|
|
def roll(result,type,explosif,nb,f,noadd,ars,relance,mitige): # Lancement d'un dé
|
|
# verif type et contenu params?
|
|
roll = 0
|
|
new = 0
|
|
moins = 0
|
|
if (ars):
|
|
roll = 1
|
|
if (type > 1):
|
|
tmp = 1
|
|
while (ars and tmp == 1):
|
|
roll *= 2
|
|
tmp = random.randrange(1,type+1)
|
|
roll = ((roll//2)*tmp)
|
|
else:
|
|
tmp = random.randrange(1,type+1)
|
|
roll += int(tmp)
|
|
#print("roll " + str(roll))
|
|
while (explosif and tmp == type):
|
|
tmp = random.randrange(1,type+1)
|
|
roll += int(tmp)
|
|
if (relance != 0 and relance != 1 and relance <= roll):
|
|
new = 1
|
|
if (mitige != 0 and mitige >= roll):
|
|
moins = 1
|
|
result += (' ' if nb>0 else '') + str(roll)
|
|
if (f != 0 and roll < f):
|
|
roll = 0
|
|
elif (f != 0 and roll >= f and noadd):
|
|
tmp = int(roll//type)
|
|
roll = tmp + ((roll - tmp*type) >= 1 if f else 0)
|
|
roll -= moins
|
|
#print("fin roll " + str(result) + " " + str(roll) + " " + str(new))
|
|
return (result,roll,new)
|
|
|
|
def rolls(result,jet,type,nb,explosif,noadd,wild,f,g,ars,relance,mitige,z): # Lancement d'un groupe de dés
|
|
y = 0
|
|
total = 0
|
|
allresult = []
|
|
if (nb > 100):
|
|
nb = 100
|
|
tmp=(type and nb)
|
|
if (tmp):
|
|
jet += str(nb)+"d"+str(type)
|
|
#print(jet)
|
|
for i in range(nb):
|
|
new = 0
|
|
# Star Wars
|
|
if (z == True and i == 0):
|
|
result, res1, new = roll(result,type,True,nb,f,noadd,ars,relance,mitige)
|
|
allresult.append(res1)
|
|
if (res1 == 1):
|
|
y = 1
|
|
# Autre
|
|
else:
|
|
result, res1, new = roll(result,type,explosif,nb,f,noadd,ars,relance,mitige)
|
|
allresult.append(res1)
|
|
# Tant qu'il faut relancer
|
|
while (new == 1):
|
|
result, res1, new = roll(result,type,explosif,nb,f,noadd,ars,relance,mitige)
|
|
allresult.append(res1)
|
|
# Wild die de Savage Worlds
|
|
if (wild != 0):
|
|
jet += "w" + str(wild)
|
|
result, res1, new = roll(result,wild,wild!=1,nb if nb else 0,f,noadd,ars,relance,mitige)
|
|
allresult.append(res1)
|
|
result += 'w'
|
|
#print(allresult)
|
|
allresult.sort(reverse=True)
|
|
# 1 au de joker de Star Wars
|
|
if (y == 1):
|
|
del allresult[-1]
|
|
del allresult[0]
|
|
for i in range((len(allresult)) if (g == 0 and ((f != 0 and noadd) or not noadd)) else (0 if (noadd and f == 0) else g)):
|
|
if (g == 0 or len(allresult) >= g):
|
|
total += allresult[i] if allresult[i] else 0
|
|
if (noadd and f == 0):
|
|
total += max(allresult)
|
|
#print("total : " + str(total))
|
|
jet += (("g" + str(g)) if g != 0 else "#g") if g != parser.option[5] else (("g" + str(g)) if g != 0 else "")
|
|
jet += (("f" + str(f)) if f != 0 else "#f") if f != parser.option[4] else (("f" + str(f)) if f != 0 else "")
|
|
jet += (("r" + str(relance)) if relance != 0 else "#r") if relance != parser.option[9] else (("r" + str(relance)) if relance != 0 else "")
|
|
jet += (("m" + str(mitige)) if mitige != 0 else "#m") if mitige != parser.option[9] else (("m" + str(mitige)) if mitige != 0 else "")
|
|
if (tmp):
|
|
jet += ("e" if explosif == True else "#e") if explosif != parser.option[0] else ""
|
|
jet += ("n" if noadd == True else "#n") if noadd != parser.option[1] else ""
|
|
jet += ("a" if ars == True else "#a") if ars != parser.option[8] else ""
|
|
#print("fin rolls : " + str(result) + "|" + str(total) + "|" + str(jet))
|
|
return (result,total,jet)
|
|
|
|
async def entryPoint(room, message): # Analyse des commandes ":", point d'entrée pour les jets de dés
|
|
global modules
|
|
try:
|
|
rmod = modules[room.room_id, 'roll']
|
|
except:
|
|
modules[room.room_id, 'roll'] = False
|
|
if (modules[room.room_id, 'roll']):
|
|
global parser
|
|
text = getMessage(message)
|
|
user = getUser(message)
|
|
nick = getNick(room,message)
|
|
parser = Parser(text,nick,room)
|
|
|
|
if (parser.eat(":roll",1)):
|
|
parser.option = [False,False,False,0,0,0,0,0,False,0,0,False]
|
|
await rollXPoint()
|
|
elif (parser.eat(":dom",1)):
|
|
parser.option = [True,False,True,0,0,0,4,4,False,0,0,False]
|
|
await rollXPoint()
|
|
elif (parser.eat(":sw",1)):
|
|
parser.option = [True,True,True,0,0,0,4,4,False,0,0,False]
|
|
await rollXPoint()
|
|
elif (parser.eat(":ars",1)):
|
|
parser.option = [False,True,True,0,0,0,0,0,True,0,0,False]
|
|
await rollXPoint()
|
|
elif (parser.eat(":des",1)):
|
|
parser.option = [False,True,True,0,10,0,0,0,False,0,0,False]
|
|
await rollXPoint()
|
|
elif (parser.eat(":wod",1)):
|
|
parser.option = [False,True,True,0,8,0,0,0,False,10,0,False]
|
|
await rollXPoint()
|
|
elif (parser.eat(":adv",1)):
|
|
parser.option = [False,True,False,0,5,0,0,0,False,0,0,False]
|
|
await rollXPoint()
|
|
elif (parser.eat(":owod",1)):
|
|
parser.option = [False,True,True,0,6,0,0,0,False,10,1,False]
|
|
await rollXPoint()
|
|
elif (parser.eat(":star",1)):
|
|
parser.option = [False,False,True,0,0,0,0,0,False,0,0,True]
|
|
await rollXPoint()
|
|
elif (parser.eat(":fate",1)):
|
|
text = text[5:] + " 4d3-8"
|
|
parser = Parser(text,nick,room)
|
|
parser.option = [False,False,False,0,0,0,0,0,False,0,0,False]
|
|
await rollXPoint()
|
|
else:
|
|
parser.arg["error"] = True
|
|
|
|
if (not parser.arg.get("error",None) and not parser.eat("$",0)):
|
|
parser.arg["noerror"] = True
|
|
await msg(room,"Je n'ai pas compris " + text,user)
|
|
|
|
|
|
def rollOptionPoint(): # Parse des options
|
|
global parser
|
|
while (True):
|
|
if (parser.eat("[Ee]",1)):
|
|
parser.option[0] = True
|
|
elif (parser.eat("#[Ee]",1)):
|
|
parser.option[0] = False
|
|
elif (parser.eat("[Nn]",1)):
|
|
parser.option[1] = True
|
|
elif (parser.eat("#[Nn]",1)):
|
|
parser.option[1] = False
|
|
elif (parser.eat("[Vv]",1)):
|
|
parser.option[2] = True
|
|
elif (parser.eat("#[Vv]",1)):
|
|
parser.option[2] = False
|
|
elif (parser.eat("[Ww]",1)):
|
|
if (parser.space()):
|
|
parser.option[3] = 6
|
|
elif (parser.eat(r"\d+",1)):
|
|
parser.option[3] = int(parser.mtch)
|
|
else:
|
|
parser.option[3] = 6
|
|
elif (parser.eat("#[Ww]",1)):
|
|
parser.option[3] = 0
|
|
elif (parser.eat("[Ff]",1)):
|
|
if (parser.space()):
|
|
parser.option[4] = 6
|
|
elif (parser.eat(r"\d+",1)):
|
|
parser.option[4] = int(parser.mtch)
|
|
else:
|
|
parser.option[4] = 6
|
|
elif (parser.eat("#[Ff]",1)):
|
|
parser.option[4] = 0
|
|
elif (parser.eat("[Gg]",1)):
|
|
if (parser.space()):
|
|
parser.option[5] = 6
|
|
elif (parser.eat(r"\d+",1)):
|
|
parser.option[5] = int(parser.mtch)
|
|
else:
|
|
parser.option[5] = 6
|
|
elif (parser.eat("#[Gg]",1)):
|
|
parser.option[5] = 0
|
|
elif (parser.eat("[Ss]",1)):
|
|
if (parser.space()):
|
|
parser.option[6] = 4
|
|
elif (parser.eat(r"\d+",1)):
|
|
parser.option[6] = int(parser.mtch)
|
|
else:
|
|
parser.option[6] = 4
|
|
if (parser.eat("[/]",1)):
|
|
if (parser.space()):
|
|
parser.option[7] = 4
|
|
elif (parser.eat(r"\d+",1)):
|
|
parser.option[7] = int(parser.mtch)
|
|
else:
|
|
parser.option[7] = 4
|
|
else:
|
|
parser.option[7] = 4
|
|
elif (parser.eat("#[Ss]",1)):
|
|
parser.option[6] = 0
|
|
parser.option[7] = 0
|
|
elif (parser.eat("[Aa]",1)):
|
|
parser.option[8] = True
|
|
elif (parser.eat("#[Aa]",1)):
|
|
parser.option[8] = False
|
|
elif (parser.eat("[Rr]",1)):
|
|
if (parser.space()):
|
|
parser.option[9] = 10
|
|
elif (parser.eat(r"\d+",1)):
|
|
parser.option[9] = int(parser.mtch)
|
|
else:
|
|
parser.option[9] = 10
|
|
elif (parser.eat("#[Rr]",1)):
|
|
parser.option[9] = 0
|
|
elif (parser.eat("[Mm]",1)):
|
|
if (parser.space()):
|
|
parser.option[10] = 1
|
|
elif (parser.eat(r"\d+",1)):
|
|
parser.option[10] = int(parser.mtch)
|
|
else:
|
|
parser.option[10] = 1
|
|
elif (parser.eat("#[Mm]",1)):
|
|
parser.option[10] = 0
|
|
elif (parser.eat("[Zz]",1)):
|
|
parser.option[11] = True
|
|
elif (parser.eat("#[Zz]",1)):
|
|
parser.option[11] = False
|
|
else:
|
|
break
|
|
|
|
def dupli(orig): # Duplication d'un parser
|
|
salon = orig.room
|
|
orig.room = None
|
|
nouv = copy.deepcopy(orig)
|
|
nouv.option = [orig.option[0],orig.option[1],orig.option[2],orig.option[3],orig.option[4],orig.option[5],orig.option[6],orig.option[7],orig.option[8],orig.option[9],orig.option[10],orig.option[11]]
|
|
orig.room = salon
|
|
nouv.room = salon
|
|
return nouv
|
|
|
|
async def rollXPoint(): # Parser le nombre de lancers de dés identiques
|
|
global parser
|
|
await rollPlusMoinsPoint()
|
|
if (parser.eat("[xX]",1)):
|
|
if (parser.eat(r"\d+",1)):
|
|
tmp = dupli(parser)
|
|
str = parser.arg["jet"]
|
|
xtime = int(parser.mtch)-1
|
|
xtime = xtime if (xtime < 11) else 10
|
|
for _ in range(xtime):
|
|
parser = dupli(parser)
|
|
parser.str = str
|
|
#print (parser.str)
|
|
await rollPlusMoinsPoint()
|
|
parser = tmp
|
|
else:
|
|
parser.arg["error"] = True
|
|
|
|
|
|
async def rollPlusMoinsPoint(): # Gérer les bloc du jet séparés par les + et -, afficher le résultat
|
|
global parser
|
|
parser.arg["roll_sig"] = True
|
|
parser.arg["error"] = None
|
|
result = ""
|
|
res1 = ""
|
|
res2 = ""
|
|
jet = ""
|
|
rollOptionPoint()
|
|
#print(parser.option)
|
|
exp,noa,ver,will,f,g,s,d,ars,r,m,z = parser.option
|
|
rollEntityPoint()
|
|
#print("de " + str(parser.arg.get("roll_nb",None)) + "|" + str(parser.arg.get("roll_typ",None)))
|
|
if (not parser.arg["error"]):
|
|
if (not parser.arg.get("roll_sig",True)):
|
|
jet += "-"
|
|
result += "-"
|
|
if (parser.arg.get("roll_typ",None) or parser.arg.get("roll_wil",None)):
|
|
result += "("
|
|
exp2,noa2,ver2,will2,f2,g2,s2,d2,ars2,r2,m2,z2 = parser.option
|
|
parser.option = [exp,noa,ver,will,f,g,s,d,ars,r,m,z]
|
|
result, res1, jet = rolls(result,jet,parser.arg.get("roll_typ",None),parser.arg.get("roll_nb",None),exp2,noa2,will2,f2,g2,ars2,r2,m2,z2)
|
|
result += " = " + str(res1) + ")"
|
|
else:
|
|
jet += str(parser.arg.get("roll_nb",None))
|
|
result += str(parser.arg.get("roll_nb",None))
|
|
res1 = parser.arg["roll_nb"]
|
|
#print("prem " + result + " " +str(res1))
|
|
if (not parser.arg.get("roll_sig",True)):
|
|
res1 = -res1
|
|
while (parser.eat("[+-]",1)):
|
|
parser.arg["roll_sig"] = True
|
|
if (parser.mtch == "-"):
|
|
parser.arg["roll_sig"] = not parser.arg.get("roll_sig",True)
|
|
rollEntityPoint()
|
|
if (not parser.arg.get("error",None)):
|
|
jet += " +" if parser.arg.get("roll_sig",True) else " -"
|
|
result += " + " if parser.arg.get("roll_sig",True) else " - "
|
|
if (parser.arg.get("roll_typ",None) or parser.arg.get("roll_wil",None)):
|
|
result += "("
|
|
exp2,noa2,ver2,will2,f2,g2,s2,d2,ars2,r2,m2,z2 = parser.option
|
|
parser.option = [exp,noa,ver,will,f,g,s,d,ars,r,m,z]
|
|
result, res2, jet = rolls(result,jet,parser.arg.get("roll_typ",None),parser.arg.get("roll_nb",None),exp2,noa2,will2,f2,g2,ars2,r2,m2,z2)
|
|
result += " = " + str(res2) + ")"
|
|
else:
|
|
jet += str(parser.arg.get("roll_nb",None))
|
|
result += str(parser.arg.get("roll_nb",None))
|
|
res2 = parser.arg.get("roll_nb",None)
|
|
res1 += res2 if parser.arg.get("roll_sig",None) else -res2
|
|
#print("deux " + result + " " +str(res1))
|
|
if (res1):
|
|
if (ver):
|
|
result = jet + " = (" + result + ") = " + str(res1)
|
|
else:
|
|
result = jet + " = " + str(res1)
|
|
if (d <= 0):
|
|
d=1
|
|
tmp = (res1 - s) // d + 1
|
|
result += ("/" + ("0" if (tmp < 0) else str(tmp))) if (s != 0) else ""
|
|
parser.arg["jet"] = jet
|
|
await msg(parser.room,parser.nick + " rolls " + ("e" if exp else "") + ("n" if noa else "") + ("v" if ver else "") + ("a" if ars else "") + ("s"+str(s)+"/"+str(d) if (s != 0) else "") + (" " if (exp or noa or ver or s != 0) else "") + result, "dice")
|
|
elif (not parser.arg.get("noerror",False)):
|
|
await msg(parser.room,"match = " + parser.mtch + "\nstr = " + parser.str, "dice")
|
|
await msg(parser.room,"Rien compris. Essayez '!help' pour obtenir de l'aide.", "dice")
|
|
|
|
|
|
def rollEntityPoint(): # Parser les séparateurs de bloc + et -
|
|
global parser
|
|
if (parser.eat("[-+]", 1)):
|
|
if (parser.mtch == "-"):
|
|
parser.arg["roll_sig"] = not parser.arg.get("roll_sig",True)
|
|
rollOptionPoint()
|
|
rollNbPoint()
|
|
|
|
|
|
def rollNbPoint(): # Parser le nombre de dés
|
|
global parser
|
|
parser.arg["roll_nb"] = None
|
|
if (parser.eat(r"\d+",1)):
|
|
parser.arg["roll_nb"] = int(parser.mtch)
|
|
#print("nb " + str(parser.arg.get("roll_nb",1)))
|
|
rollDPoint()
|
|
|
|
|
|
def rollDPoint(): # Parser le mot clé identifiant un dé
|
|
global parser
|
|
if (parser.eat("[dD]",1)):
|
|
if (not parser.arg.get("roll_nb",False)):
|
|
parser.arg["roll_nb"] = 1
|
|
parser.arg["roll_bon"] = 0
|
|
rollTypePoint()
|
|
elif (parser.arg.get("roll_nb",False)):
|
|
parser.arg["roll_typ"] = None
|
|
else:
|
|
parser.arg["error"] = True
|
|
|
|
|
|
def rollTypePoint(): # Parser le nombre de faces du dé
|
|
global parser
|
|
if (parser.space()):
|
|
parser.arg["roll_typ"] = 6
|
|
elif (parser.eat(r"\d+",1)):
|
|
parser.arg["roll_typ"] = int(parser.mtch)
|
|
if (parser.mtch == "1"):
|
|
parser.option[0] = False
|
|
else:
|
|
parser.arg["roll_typ"] = 6
|
|
rollOptionPoint()
|
|
if (not parser.arg.get("roll_nb",False)):
|
|
parser.arg["error"] = True
|
|
|
|
def getMessage(message):
|
|
try:
|
|
return(str(message).split(":",2)[2].strip())
|
|
except:
|
|
return(str(message))
|
|
|
|
def getUser(message):
|
|
match = re.search(r"^(@\w+:[^ :]+)", str(message))
|
|
if match:
|
|
return str(match.group())
|
|
else:
|
|
return "personne"
|
|
|
|
def getNick(room, message): # Obtenir le DisplayName à partir du mxid.
|
|
sender = getUser(message)
|
|
nick = None
|
|
try:
|
|
nick = room.user_name(sender).split(' ')[0]
|
|
except:
|
|
nick = room.user_name(sender)
|
|
return(nick)
|
|
|
|
async def msg(room,mess,sender,content=False):
|
|
try:
|
|
try:
|
|
lmod = modos.get(room.room_id)
|
|
if (sender not in admins and lmod != None and sender not in lmod):
|
|
mess = mess.replace('@room', 'tout le monde')
|
|
except:
|
|
try:
|
|
mess = mess.replace('@room', 'tout le monde')
|
|
except:
|
|
print(mess)
|
|
print("id : " + str(room.room_id) + " message : " + str(mess))
|
|
if (content):
|
|
await bot.api.send_markdown_message(room.room_id, mess)
|
|
else:
|
|
await bot.api.send_text_message(room.room_id, mess)
|
|
except:
|
|
print("Impossible d'envoyer le message")
|
|
|
|
async def modo(room,message): # Definition d'un moderateur
|
|
global modos
|
|
sender = getUser(message)
|
|
texte = getMessage(message)
|
|
print("texte : " + texte + " sender : " + sender)
|
|
lmod = []
|
|
try:
|
|
lmod = modos.get(room.room_id)
|
|
except:
|
|
lmod = []
|
|
if (sender in admins or sender in lmod or sender == bot.client.user_id):
|
|
args = texte.split()
|
|
args.pop(0)
|
|
if (len(args) > 1 and args[0] == "add"):
|
|
args.pop(0)
|
|
candidat = " ".join(args)
|
|
if (not candidat in lmod):
|
|
lmod.append(candidat)
|
|
modos[room.room_id] = lmod
|
|
await msg(room,candidat + " devient moderateur.",sender)
|
|
else:
|
|
await msg(room,candidat + " est déjà moderateur.",sender)
|
|
elif (len(args) > 1 and args[0] == "del"):
|
|
args.pop(0)
|
|
candidat = " ".join(args)
|
|
if (candidat in lmod):
|
|
place = lmod.index(candidat)
|
|
del lmod[place]
|
|
modos[room.room_id] = lmod
|
|
await msg(room,candidat + " n'est plus moderateur.",sender)
|
|
else:
|
|
await msg(room,candidat + " n'est pas moderateur.",sender)
|
|
else:
|
|
await msg(room,"\n".join(lmod),sender)
|
|
else:
|
|
await msg(room,"Vous n'êtes pas autorisés à définir les modérateurs.",sender)
|
|
|
|
async def module(room,message): # Definition des modules d'un salon
|
|
lmod = []
|
|
sender = getUser(message)
|
|
texte = getMessage(message)
|
|
try:
|
|
lmod = modos.get(room.room_id)
|
|
except:
|
|
lmod = []
|
|
if (sender in admins or sender in lmod or sender == bot.client.user_id):
|
|
global modules
|
|
args = texte.split()
|
|
args.pop(0)
|
|
if (len(args) == 2 and args[0] == "add"):
|
|
args.pop(0)
|
|
rmod = args[0]
|
|
if (rmod in liste_mod):
|
|
modules[room.room_id, rmod] = True
|
|
await msg(room,"Module : " + rmod + " activé.",sender)
|
|
else:
|
|
await msg(room,"Module : " + rmod + " inconnu.",sender)
|
|
elif (len(args) == 2 and args[0] == "del"):
|
|
args.pop(0)
|
|
rmod = args[0]
|
|
if (rmod in liste_mod):
|
|
modules[room.room_id, rmod] = False
|
|
await msg(room,"Module : " + rmod + " désactivé.",sender)
|
|
else:
|
|
await msg(room,"Module : " + rmod + " inconnu.",sender)
|
|
else:
|
|
# Lister les modules actifs du salon
|
|
rmod = ""
|
|
for cle,valeur in modules.items():
|
|
if (cle[0] == room.room_id and valeur == True):
|
|
rmod = rmod + cle[1] + ", "
|
|
if (len(rmod) > 1):
|
|
rmod = rmod[:-2]
|
|
await msg(room,"Modules actuels : " + rmod,sender)
|
|
# Lister les modules disponibles
|
|
dmod = ""
|
|
for val in liste_mod:
|
|
dmod = dmod + val + ", "
|
|
if (len(dmod) > 1):
|
|
dmod = dmod[:-2]
|
|
await msg(room,"Modules disponibles : " + dmod,sender)
|
|
else:
|
|
await msg(room,"Vous n'êtes pas autorisés à définir les modules du salon.",sender)
|
|
|
|
async def liste(room, message): # Afficher un élement aléatoire d'une liste fournie
|
|
global modules
|
|
try:
|
|
rmod = modules[room.room_id, 'liste']
|
|
except:
|
|
modules[room.room_id, 'liste'] = False
|
|
if (modules[room.room_id, 'liste']):
|
|
res = []
|
|
nick = getNick(room,message)
|
|
|
|
args = getMessage(message).split()
|
|
args.pop(0)
|
|
try:
|
|
nb = int(args[len(args)-1])
|
|
args.pop(len(args)-1)
|
|
except:
|
|
nb = 1
|
|
args = ' '.join(args)
|
|
list = args.split('/')
|
|
if (nb <= len(list)):
|
|
for i in range(nb):
|
|
id = random.randrange(0,len(list))
|
|
res.append(list.pop(id))
|
|
await msg(room,nick + " obtient :\n" + '\n'.join(res),nick)
|
|
else:
|
|
await msg(room,"Utilisation : !liste <options/de/la/liste> [nombre d elements]",nick)
|
|
|
|
async def aff_hor(room, hor, valeur): # affichage des horloges
|
|
if (int(valeur) == 0):
|
|
await msg(room,hor + " : " + chr(128320) + "\n", "horloge")
|
|
elif (int(valeur) == 1):
|
|
await msg(room,hor + " : " + chr(128338) + "\n", "horloge")
|
|
elif (int(valeur) == 2):
|
|
await msg(room,hor + " : " + chr(128341) + "\n", "horloge")
|
|
elif (int(valeur) == 3):
|
|
await msg(room,hor + " : " + chr(128344) + "\n", "horloge")
|
|
elif (int(valeur) == 4):
|
|
await msg(room,hor + " : " + chr(128345) + "\n", "horloge")
|
|
elif (int(valeur) == 5):
|
|
await msg(room,hor + " : " + chr(128346) + "\n", "horloge")
|
|
elif (int(valeur) == 6):
|
|
await msg(room,hor + " : " + chr(128347) + "\n", "horloge")
|
|
else:
|
|
await msg(room,hor + " : " + str(valeur) + " \n", "horloge")
|
|
|
|
async def horloge(room, message): # Gestion des horloges PBTA
|
|
global modules
|
|
try:
|
|
rmod = modules[room.room_id, 'horloge']
|
|
except:
|
|
modules[room.room_id, 'horloge'] = False
|
|
if (modules[room.room_id, 'horloge']):
|
|
global clock
|
|
nick = getNick(room,message)
|
|
|
|
args = getMessage(message).split()
|
|
args.pop(0)
|
|
if (len(args) == 0):
|
|
# Liste des horloges du salon
|
|
for cle,valeur in clock.items():
|
|
if (cle[0] == room.room_id):
|
|
await aff_hor(room, cle[1], valeur)
|
|
elif (len(args) >= 2 and args[len(args)-1].isnumeric()):
|
|
# Place le niveau de l'horloge entre 0 et 6
|
|
nv = int(args[len(args)-1])
|
|
clock[room.room_id, ' '.join(args[0:-1])] = nv
|
|
elif (len(args) >= 2 and (args[len(args)-1][:1] == "+" or args[len(args)-1][:1] == "-")):
|
|
nv = 0
|
|
hor = ' '.join(args[0:-1])
|
|
if ((room.room_id, hor) in clock):
|
|
nv = clock[room.room_id, hor]
|
|
val = 0
|
|
if (args[len(args)-1][1:].isnumeric()):
|
|
val = int(args[len(args)-1][1:])
|
|
if (args[len(args)-1][:1] == "+"):
|
|
nv = nv + val
|
|
if (nv > 6):
|
|
nv = 6
|
|
else:
|
|
nv = nv - val
|
|
if (nv < 0):
|
|
nv = 0
|
|
clock[room.room_id, hor] = nv
|
|
await aff_hor(room, hor, nv)
|
|
elif (len(args) >= 2 and args[0] == "del"):
|
|
# Supprime une horloge
|
|
args.pop(0)
|
|
del clock[room.room_id, ' '.join(args)]
|
|
else:
|
|
await msg(room,"Utilisation : \n- !horloge : Affiche les horloges. \n- !horloge <nom> <niveau> : Place ou crée l'horloge au niveau spécifié.\n- !horloge del <nom> : Supprime l'horloge.",getUser(message))
|
|
|
|
async def reponses(room, phrases, content=False): # Afficher une réponse aléatoire dans la liste
|
|
i = random.randrange(0,len(phrases))
|
|
await msg(room,phrases[i],"reponses",content)
|
|
|
|
async def verifPMRoom(room, message): # Pour obtenir ou créer un salon pour les messages privés avec l'utilisateur
|
|
global prive
|
|
nick = ""
|
|
sender = ""
|
|
sender = getUser(message)
|
|
nick = getNick(room, message)
|
|
client_id = bot.creds.username.split(':')[0].split('@')[1]
|
|
client_host = bot.creds.username.split(':')[1]
|
|
room_nick = client_id + "_" + nick
|
|
bot_nick = getNick(room, message)
|
|
salon = None
|
|
room_id = prive.get(sender)
|
|
if (room_id):
|
|
await bot.async_client.room_invite(room_id=room_id, user_id=sender)
|
|
new_salon = nio.rooms.MatrixRoom(room_id, client_id)
|
|
new_salon.name=bot_nick
|
|
new_salon.topic="Informations d'Asmodee"
|
|
new_salon.is_direct=True
|
|
return(new_salon)
|
|
else:
|
|
salon = await bot.async_client.room_create(alias=room_nick, name=bot_nick, topic="Informations d'Asmodee",is_direct=True,invite=[sender])
|
|
if isinstance(salon, nio.responses.RoomCreateError):
|
|
print("Impossible de creer : " + room_nick + " pour " + sender)
|
|
return(room)
|
|
else:
|
|
prive[sender]=salon.room_id
|
|
return(salon)
|
|
#TODO : room_delete_alias(access_token, room_alias)
|
|
|
|
async def biere(room,message): # Gestion des boissons
|
|
global modules
|
|
try:
|
|
rmod = modules[room.room_id, 'biere']
|
|
except:
|
|
modules[room.room_id, 'biere'] = False
|
|
power = 0
|
|
if (modules[room.room_id, 'biere']):
|
|
sender = getUser(message)
|
|
mess = getMessage(message)
|
|
lmod = modos.get(room.room_id)
|
|
if (sender in admins or sender in lmod):
|
|
power = 1
|
|
global bieres
|
|
args = mess.split()
|
|
args.pop(0)
|
|
breuvages = {}
|
|
give = False
|
|
elu = ""
|
|
envoyeur = getNick(room, message)
|
|
|
|
try:
|
|
breuvages = bieres[room.room_id]
|
|
except:
|
|
breuvages = {}
|
|
|
|
if (len(args) > 1 and args[0] == "give"):
|
|
give = True
|
|
args.pop(0)
|
|
submit = " ".join(args).split(":")
|
|
elu = submit[0]
|
|
if (power == 0):
|
|
elu = elu.replace('@room', 'tout le monde')
|
|
try:
|
|
args = submit[1].split()
|
|
except:
|
|
args = ""
|
|
if (len(args) > 2 and args[0] == "add"):
|
|
#ajoute une biere
|
|
args.pop(0)
|
|
submit = " ".join(args).split(":")
|
|
if (len(submit) > 1):
|
|
# Ajout de la citation
|
|
nick = submit[0].strip()
|
|
nick = nick.replace('@room', 'tous')
|
|
submit.pop(0)
|
|
citation = ":".join(submit)
|
|
citation = citation.replace('@room', 'tout le monde')
|
|
tps = datetime.now().microsecond
|
|
breuvages[nick,tps] = citation
|
|
bieres[room.room_id] = breuvages
|
|
await msg(room,"Ajout du breuvage " + nick + ":" + citation,sender)
|
|
else:
|
|
# message d'aide
|
|
await msg(room,"!biere add <nick>:<citation>",sender)
|
|
elif (len(args) > 0 and args[0] == "list"):
|
|
# liste les quotes
|
|
args.pop(0)
|
|
salon = await verifPMRoom(room,message)
|
|
print(salon)
|
|
if (len(args) == 0):
|
|
# Liste les breuvages du salon
|
|
reponse = "Voici les reponses du salon " + room.room_id + "\n"
|
|
alias = None
|
|
if room.name:
|
|
alias = room.name
|
|
elif room.canonical_alias:
|
|
alias = room.canonical_alias
|
|
elif room.names:
|
|
alias = room.names[0]
|
|
else:
|
|
alias = ""
|
|
reponse = reponse + "(alias : " + alias + ")\n"
|
|
for cle,valeur in breuvages.items():
|
|
reponse = reponse + cle[0] + " / " + str(cle[1]) + " : " + valeur + "\n"
|
|
if (len(reponse) > 500):
|
|
await msg(salon,reponse,sender)
|
|
reponse = ""
|
|
await msg(salon,reponse,sender)
|
|
elif (args[0] == "all"):
|
|
# tous les breuvages de tous les salons
|
|
reponse = "Les breuvages de tous les salons : " + "\n"
|
|
await msg(salon,reponse,sender)
|
|
for rid,fame in bieres.items():
|
|
reponse = "Voici les reponses du salon " + rid + "\n"
|
|
for cle,valeur in fame.items():
|
|
reponse = reponse + cle[0] + " / " + str(cle[1]) + " : " + valeur + "\n"
|
|
if (len(reponse) > 500):
|
|
await msg(salon,reponse,sender)
|
|
reponse = ""
|
|
await msg(salon,reponse,sender)
|
|
else:
|
|
# les breuvages du pseudo spécifié
|
|
nick = " ".join(args)
|
|
reponse = "Voici les reponses du breuvage " + nick + "\n"
|
|
for cle,valeur in breuvages.items():
|
|
if (cle[0] == nick):
|
|
reponse = reponse + cle[0] + " / " + str(cle[1]) + " : " + valeur + "\n"
|
|
await msg(salon,reponse,sender)
|
|
elif (len(args) > 1 and args[0] == "del"):
|
|
salon = await verifPMRoom(room,message)
|
|
lmod = modos.get(room.room_id)
|
|
if (sender in admins):
|
|
id = args[1]
|
|
reponse = "Voici le breuvage supprimé : \n"
|
|
for rid,fame in bieres.items():
|
|
for cle,valeur in fame.items():
|
|
if (str(cle[1]) == id):
|
|
del fame[cle[0],cle[1]]
|
|
reponse = reponse + rid + " / " + cle[0] + " / " + str(cle[1]) + " : " + valeur + "\n"
|
|
break
|
|
await msg(salon,reponse,sender)
|
|
elif (sender in lmod):
|
|
id = args[1]
|
|
reponse = "Voici le breuvage supprimé : \n"
|
|
rid = room.room_id
|
|
fame = bieres[rid]
|
|
for cle,valeur in fame.items():
|
|
if (str(cle[1]) == id):
|
|
del fame[cle[0],cle[1]]
|
|
reponse = reponse + rid + " / " + cle[0] + " / " + str(cle[1]) + " : " + valeur + "\n"
|
|
break
|
|
await msg(salon,reponse,sender)
|
|
else:
|
|
await msg(salon,"Vous n'êtes pas autorisés à supprimer des breuvages.",sender)
|
|
elif (len(args) > 0):
|
|
# cite une reponse d'un breuvage precis
|
|
nick = " ".join(args)
|
|
phrases = []
|
|
for cle,valeur in breuvages.items():
|
|
if (cle[0] == nick):
|
|
if (give):
|
|
phrases.append(valeur + " pour " + elu + " de la part de " + envoyeur)
|
|
else:
|
|
phrases.append(valeur + " pour " + envoyeur)
|
|
if (len(phrases) > 0 ):
|
|
await reponses(room,phrases)
|
|
else:
|
|
await msg(room,"Je n'ai pas de " + nick + " en stock!",sender)
|
|
else:
|
|
# cite une réponse d'un breuvage aleatoire
|
|
phrases = []
|
|
for cle,valeur in breuvages.items():
|
|
if (give):
|
|
phrases.append(valeur + " pour " + elu + " de la part de " + envoyeur)
|
|
else:
|
|
phrases.append(valeur + " pour " + envoyeur)
|
|
if (len(phrases) > 0 ):
|
|
await reponses(room,phrases)
|
|
else:
|
|
await msg(room,"Je n'ai pas de breuvages pour ce salon",sender)
|
|
|
|
async def boissons(room,message): # Gestion des alias de boissons
|
|
global modules
|
|
try:
|
|
rmod = modules[room.room_id, 'biere']
|
|
except:
|
|
modules[room.room_id, 'biere'] = False
|
|
if (modules[room.room_id, 'biere']):
|
|
sender = getUser(message)
|
|
mess = getMessage(message)
|
|
boisson = ""
|
|
elu = ""
|
|
|
|
args = mess.split()
|
|
try:
|
|
boisson = args[0][1:]
|
|
except:
|
|
boisson = ""
|
|
args.pop(0)
|
|
|
|
if (len(args) > 0):
|
|
elu = " ".join(args)
|
|
|
|
if (len(elu) > 0 and len(boisson) > 0):
|
|
mess = "!biere give " + elu + ":" + boisson
|
|
elif (len(elu) > 0):
|
|
mess = "!biere give " + elu
|
|
elif (len(boisson) > 0):
|
|
mess = "!biere " + boisson
|
|
else:
|
|
mess = "!biere"
|
|
message = sender + " : " + mess
|
|
await biere(room,message)
|
|
|
|
async def salon(room,message): # Gestion des listes de salons recommandes
|
|
global modules
|
|
try:
|
|
rmod = modules[room.room_id, 'salon']
|
|
except:
|
|
modules[room.room_id, 'salon'] = False
|
|
if (modules[room.room_id, 'salon']):
|
|
sender = getUser(message)
|
|
mess = getMessage(message)
|
|
global salons
|
|
args = mess.split()
|
|
args.pop(0)
|
|
famous = {}
|
|
try:
|
|
famous = salons[room.room_id]
|
|
except:
|
|
famous = {}
|
|
|
|
if (len(args) > 3 and args[0] == "add"):
|
|
#ajoute un salon recommande
|
|
ref = ""
|
|
desc = ""
|
|
args.pop(0)
|
|
if (args[0] == "desc"):
|
|
args.pop(0)
|
|
ref = "desc"
|
|
desc = " ".join(args)
|
|
else:
|
|
ref = args[0]
|
|
args.pop(0)
|
|
desc = " ".join(args)
|
|
famous[ref] = desc
|
|
salons[room.room_id] = famous
|
|
await msg(room,"Ajout du salon " + ref + " : " + desc,sender)
|
|
elif (len(args) > 1 and args[0] == "del"):
|
|
salon = await verifPMRoom(room,message)
|
|
lmod = modos.get(room.room_id)
|
|
if (sender in admins):
|
|
id = args[1]
|
|
reponse = "Voici le salon supprimé : \n"
|
|
rid = room.room_id
|
|
fame = salons[rid]
|
|
for cle,valeur in fame.items():
|
|
if (str(cle) == id):
|
|
del fame[cle]
|
|
reponse = reponse + rid + " / " + cle + " : " + valeur + "\n"
|
|
break
|
|
await msg(room,reponse,sender)
|
|
elif (sender in lmod):
|
|
id = args[1]
|
|
reponse = "Voici le salon supprimé : \n"
|
|
rid = room.room_id
|
|
fame = salons[rid]
|
|
for cle,valeur in fame.items():
|
|
if (str(cle) == id):
|
|
del fame[cle]
|
|
reponse = reponse + rid + " / " + cle + " : " + valeur + "\n"
|
|
break
|
|
await msg(room,reponse,sender)
|
|
else:
|
|
await msg(salon,"Vous n'êtes pas autorisés à supprimer des salons.",sender)
|
|
elif (len(args) > 0):
|
|
# cite un salon precis
|
|
ref = args[0]
|
|
trouve = 0
|
|
for cle,valeur in famous.items():
|
|
if (cle == ref):
|
|
await msg(salon,cle + " : " + valeur,sender)
|
|
trouve = 1
|
|
break
|
|
if (trouve == 0):
|
|
await msg(room,"Je n'ai pas de salons nomme " + ref,sender)
|
|
else:
|
|
# cite tous les salons
|
|
reponse = ""
|
|
trouve = 0
|
|
if ("desc" in famous):
|
|
reponse = reponse + famous["desc"] + "\n"
|
|
for cle,valeur in famous.items():
|
|
if (cle != "desc"):
|
|
reponse = reponse + cle + " : " + valeur + "\n"
|
|
trouve = 1
|
|
if (trouve == 0):
|
|
await msg(room,"Je n'ai pas de salons recommandes pour ce salon",sender)
|
|
else:
|
|
await msg(room,reponse,sender)
|
|
|
|
async def accueil(room,message): # Mettre un message d'accueil
|
|
global modules
|
|
try:
|
|
rmod = modules[room.room_id, 'welcome']
|
|
except:
|
|
modules[room.room_id, 'welcome'] = False
|
|
if (modules[room.room_id, 'welcome']):
|
|
sender = getUser(message)
|
|
mess = getMessage(message)
|
|
lmod = modos.get(room.room_id)
|
|
if (sender in admins or sender in lmod):
|
|
global welcome
|
|
args = mess.split()
|
|
args.pop(0)
|
|
reponse = " ".join(args)
|
|
if (len(args) > 0):
|
|
welcome[room.room_id] = reponse
|
|
await msg(room,"Le message d'accueil est désormais : " + reponse,sender)
|
|
|
|
else:
|
|
await msg(salon,"Vous n'êtes pas autorisés à modifier le message d'accueil.",sender)
|
|
|
|
async def bienvenue(room,message): # Affichage d'un message d'accueil aux nouveaux venus
|
|
global modules
|
|
try:
|
|
rmod = modules[room.room_id, 'welcome']
|
|
except:
|
|
modules[room.room_id, 'welcome'] = False
|
|
if (modules[room.room_id, 'welcome']):
|
|
sender = message.sender
|
|
nick = room.user_name(message.state_key) if room.user_name(message.state_key) else message.state_key
|
|
membership = message.membership
|
|
prev_member = message.prev_membership
|
|
|
|
if room.name:
|
|
alias = room.name
|
|
elif room.canonical_alias:
|
|
alias = room.canonical_alias
|
|
elif room.names:
|
|
alias = room.names[0]
|
|
else:
|
|
alias = ""
|
|
reponse = ""
|
|
try:
|
|
reponse = welcome[room.room_id]
|
|
except:
|
|
reponse = ""
|
|
if (membership == "join" and prev_member != "join"):
|
|
await msg(room,"Bienvenue sur " + alias + ", " + nick + ". " + reponse,sender)
|
|
elif (membership == "leave" and prev_member != "leave"):
|
|
await msg(room,"Au revoir " + nick + "!",sender)
|
|
else:
|
|
try:
|
|
print("current: " + membership + " prev: " + prev_member)
|
|
except:
|
|
print(message)
|
|
|
|
async def titre(room, message): # cherche le titre d'une page
|
|
global modules
|
|
try:
|
|
rmod = modules[room.room_id, 'titre']
|
|
except:
|
|
modules[room.room_id, 'titre'] = False
|
|
if (modules[room.room_id, 'titre']):
|
|
args = getMessage(message).split()
|
|
sender = getUser(message)
|
|
args.pop(0)
|
|
try:
|
|
invidious = modules[room.room_id, 'invidious']
|
|
except:
|
|
invidious = False
|
|
try:
|
|
url=args[0]
|
|
print(url)
|
|
if (re.search(r"^.*://",url) is None):
|
|
url = "http://" + url
|
|
r = requests.get(url)
|
|
res = re.search(r"<title>(.*)</title>",r.text)
|
|
if (res is not None):
|
|
await msg(room,html2text.html2text(str(re.sub("</?title>", "", res.group()))),sender)
|
|
else:
|
|
await msg(room,"Titre non trouvé",sender)
|
|
if (re.search(r"http[s]?://(www\.)?youtube\.",url) is not None and invidious is False):
|
|
res = re.sub(r"^.*\?v=(\w+).*$", r"\1", url, 0, re.MULTILINE)
|
|
await msg(room,str("https://invidious.fdn.fr/watch?v=" + res),sender)
|
|
except:
|
|
await msg(room,"URL invalide",sender)
|
|
|
|
async def addquote(room,message): # enregistrer les citations mode reponses matrix
|
|
global modules
|
|
try:
|
|
rmod = modules[room.room_id, 'quote']
|
|
except:
|
|
modules[room.room_id, 'quote'] = False
|
|
if (modules[room.room_id, 'quote']):
|
|
global citations
|
|
|
|
content = getMessage(message)
|
|
sender = getUser(message)
|
|
if len(content) > 42:
|
|
# Récupération de l'auteur
|
|
auteur = "Un nain connu"
|
|
match = re.search(r"<(@\w+:\w+.\w+)>", content)
|
|
if match:
|
|
auteur = match.group(1)
|
|
nick = room.user_name(auteur)
|
|
|
|
# Enlève la commande de la citation
|
|
try:
|
|
content = content.replace("\n!addquote", " ")
|
|
content = content.replace("\n!", "\n")
|
|
content = content.replace("<p>!addquote</p>\n", "")
|
|
content = content.replace("<p>!", "<p>")
|
|
content = content.replace("<"+auteur+">",nick+" <"+auteur+">")
|
|
except:
|
|
print("erreur content " + content)
|
|
|
|
# Id
|
|
tps = datetime.now().microsecond
|
|
|
|
# récupérations des citations du salon
|
|
famous = {}
|
|
try:
|
|
famous = citations[room.room_id]
|
|
except:
|
|
famous = {}
|
|
|
|
# enregistrement de la citation
|
|
famous[auteur,tps] = content
|
|
citations[room.room_id] = famous
|
|
await bot.api.send_markdown_message(room_id=room.room_id,message="Ajout de la citation de " + nick + ":\n" + content)
|
|
|
|
async def showquote(room, message): # afficher les citations mode reponse matrix
|
|
global modules
|
|
try:
|
|
rmod = modules[room.room_id, 'quote']
|
|
except:
|
|
modules[room.room_id, 'quote'] = False
|
|
if (modules[room.room_id, 'quote']):
|
|
args = getMessage(message).split()
|
|
sender = getUser(message)
|
|
args.pop(0)
|
|
famous = {}
|
|
try:
|
|
famous = citations[room.room_id]
|
|
except:
|
|
famous = {}
|
|
|
|
if (len(args) == 1):
|
|
# cite une quote d'une personne precise
|
|
nick = args[0]
|
|
phrases = []
|
|
for cle,valeur in famous.items():
|
|
if (cle[0] == nick):
|
|
phrases.append(valeur)
|
|
if (len(phrases) > 0 ):
|
|
await reponses(room,phrases,True)
|
|
else:
|
|
await msg(room,"Je n'ai pas de citations pour " + nick,sender)
|
|
else:
|
|
# cite une quote aleatoire
|
|
phrases = []
|
|
for cle,valeur in famous.items():
|
|
phrases.append(valeur)
|
|
if (len(phrases) > 0 ):
|
|
await reponses(room,phrases,True)
|
|
else:
|
|
await msg(room,"Je n'ai pas de citations pour ce salon",sender)
|
|
|
|
async def card(room, message): # Tirer une carte du paquet sans la retirer
|
|
global modules
|
|
try:
|
|
rmod = modules[room.room_id, 'card']
|
|
except:
|
|
modules[room.room_id, 'card'] = False
|
|
if (modules[room.room_id, 'card']):
|
|
reponse = cartes_base[random.randrange(0,len(cartes_base))]
|
|
await msg(room,reponse,getUser(message))
|
|
|
|
async def carte(room, message): # Tirer une carte du paquet en la retirant ensuite
|
|
global modules
|
|
try:
|
|
rmod = modules[room.room_id, 'carte']
|
|
except:
|
|
modules[room.room_id, 'carte'] = False
|
|
if (modules[room.room_id, 'carte']):
|
|
global paquets
|
|
sender = getUser(message)
|
|
cartes = paquets.get(room.room_id)
|
|
if (cartes is None):
|
|
cartes = list(cartes_base)
|
|
args = getMessage(message).split()
|
|
if (len(args) > 1):
|
|
cartes=list(cartes_base)
|
|
await msg(room,"Le paquet est melange",sender)
|
|
else:
|
|
if (len(cartes) < 1):
|
|
cartes=list(cartes_base)
|
|
await msg(room,"Le paquet est melange",sender)
|
|
i = random.randrange(0,len(cartes))
|
|
await msg(room,cartes[i],sender)
|
|
cartes.pop(i)
|
|
paquets[room.room_id]=cartes
|
|
|
|
#async def last(room, message): # dernière connexion d'un utilisateur
|
|
# global modules
|
|
# try:
|
|
# rmod = modules[room.room_id, 'stats']
|
|
# except:
|
|
# modules[room.room_id, 'stats'] = False
|
|
# if (modules[room.room_id, 'stats']):
|
|
# args = getMessage(message).split()
|
|
# sender = getUser(message)
|
|
# args.pop(0)
|
|
# print("analyse args " + str(args))
|
|
# if (len(args) == 1):
|
|
# try:
|
|
# print("into try")
|
|
# target = room.users.get(args[0])
|
|
# print("get target")
|
|
# if (target):
|
|
# ago = target.last_active_ago
|
|
# await msg(room,"d" + str(ago),sender)
|
|
# else:
|
|
# await msg(room,args[0] + " non trouvé.",sender)
|
|
# except:
|
|
# print(args[0])
|
|
# else:
|
|
# await msg(room,"!last <mxid>",sender)
|
|
|
|
async def last(room,message): # Regarde la dernière fois que quelqu'un a écrit un message
|
|
global modules
|
|
try:
|
|
rmod = modules[room.room_id, 'stats']
|
|
except:
|
|
modules[room.room_id, 'stats'] = False
|
|
if (modules[room.room_id, 'stats']):
|
|
global stats
|
|
args = getMessage(message).split()
|
|
sender = getUser(message)
|
|
usrstats = None
|
|
args.pop(0)
|
|
pers = ""
|
|
if (len(args) >= 1 and args[0] == "all"):
|
|
max_sign = "+"
|
|
max_duree = 0
|
|
if (len(args) > 1):
|
|
max_sign = args[1][0]
|
|
max_duree = int(args[1][1:])
|
|
ref_duree = datetime.now() - timedelta(days=max_duree)
|
|
salon = await verifPMRoom(room,message)
|
|
all_usr = {}
|
|
reponse = "Les gens ayant posté à " + max_sign + " de " + str(max_duree) + " jours :\n"
|
|
for cle,valeur in stats.items():
|
|
if (cle[0] == room.room_id):
|
|
usrstats = stats[room.room_id,cle[1]]
|
|
if ((usrstats.user in all_usr and all_usr[usrstats.user].date < usrstats.date) or not usrstats.user in all_usr):
|
|
all_usr[usrstats.user] = usrstats
|
|
for user,usrstats in all_usr.items():
|
|
if ((max_sign == "+" and usrstats.date < ref_duree) or ((max_sign == "-" and usrstats.date > ref_duree))):
|
|
reponse += "- " + usrstats.nick + "(" + user + ")" + " le " + usrstats.date.strftime("%Y-%m-%d %H:%M:%S") + ")\n"
|
|
await msg(salon, reponse,sender)
|
|
elif (len(args) >= 1 and args[0] == "inactifs"):
|
|
max_sign = "+"
|
|
max_duree = 0
|
|
max_mess = 0
|
|
if (len(args) > 2):
|
|
max_sign = args[1][0]
|
|
max_duree = int(args[1][1:])
|
|
max_mess = int(args[2])
|
|
ref_duree = datetime.now() - timedelta(days=max_duree)
|
|
salon = await verifPMRoom(room,message)
|
|
all_usr = {}
|
|
reponse = "Les gens ayant posté à " + max_sign + " de " + str(max_duree) + " jours et n'ayant pas plus de " + str(max_mess) + " messages :\n"
|
|
for cle,valeur in stats.items():
|
|
if (cle[0] == room.room_id):
|
|
usrstats = stats[room.room_id,cle[1]]
|
|
if ((usrstats.user in all_usr and all_usr[usrstats.user].date < usrstats.date) or not usrstats.user in all_usr):
|
|
all_usr[usrstats.user] = usrstats
|
|
for user,usrstats in all_usr.items():
|
|
if (((max_sign == "+" and usrstats.date < ref_duree) or ((max_sign == "-" and usrstats.date > ref_duree))) and usrstats.mess <= max_mess):
|
|
reponse += "- " + usrstats.nick + "(" + user + ")" + " le " + usrstats.date.strftime("%Y-%m-%d %H:%M:%S") + ")\n"
|
|
await msg(salon, reponse, sender)
|
|
else:
|
|
if (len(args) == 0):
|
|
await msg(room,"!last <mxid>",sender)
|
|
else:
|
|
pers=" ".join(args)
|
|
id_pers=None
|
|
try:
|
|
usrstats = stats[room.room_id,pers]
|
|
except:
|
|
try:
|
|
for cle,valeur in room.users.items():
|
|
if (valeur.display_name == pers):
|
|
id_pers = valeur.user_id
|
|
try:
|
|
usrstats = stats[room.room_id, cle]
|
|
except:
|
|
usrstats = None
|
|
if (usrstats is not None):
|
|
break
|
|
except:
|
|
print(pers + " non reconnu")
|
|
if (usrstats is not None):
|
|
target = room.users.get(usrstats.user)
|
|
if (target and target.last_active_ago is not None):
|
|
ago = datetime.fromtimestamp(datetime.now().timestamp() - target.last_active_ago/1000)
|
|
await msg(room,"J'ai vu " + usrstats.nick + " pour la dernière fois le : " + ago.strftime("%Y-%m-%d %H:%M:%S") + ". Et il a posté pour la dernière fois le : " + usrstats.date.strftime("%Y-%m-%d %H:%M:%S"),sender)
|
|
else:
|
|
await msg(room,"J'ai vu " + usrstats.nick + " poster pour la dernière fois le " + usrstats.date.strftime("%Y-%m-%d %H:%M:%S"),sender)
|
|
else:
|
|
target = None
|
|
if (id_pers is not None):
|
|
target = room.users.get(id_pers)
|
|
else:
|
|
target = room.users.get(pers)
|
|
if (target and target.last_active_ago is not None):
|
|
ago = datetime.fromtimestamp(datetime.now().timestamp() - target.last_active_ago/1000)
|
|
await msg(room,"Dernière présence de " + pers + " : " + ago.strftime("%Y-%m-%d %H:%M:%S"),sender)
|
|
else:
|
|
await msg(room,pers + " : Personne non reconnue",sender)
|
|
|
|
def statistiques(room,message): # Enregistrement des statistiques
|
|
global modules
|
|
try:
|
|
rmod = modules[room.room_id, 'stats']
|
|
except:
|
|
modules[room.room_id, 'stats'] = False
|
|
if (modules[room.room_id, 'stats']):
|
|
global stats
|
|
nick = getNick(room, message)
|
|
user = getUser(message)
|
|
mess = getMessage(message)
|
|
usrstats = None
|
|
|
|
try:
|
|
usrstats = stats[room.room_id,user]
|
|
except:
|
|
usrstats = Userstats(room.room_id,user,nick)
|
|
|
|
# date de la phrase
|
|
date = datetime.now()
|
|
usrstats.date = date
|
|
|
|
# recup nb phrases +1, 1 sinon
|
|
usrstats.mess = usrstats.mess + 1
|
|
|
|
# recup nb lettres +lettres phrase, lettres phrases sinon
|
|
usrstats.char = usrstats.char + len(mess)
|
|
|
|
# insertion des objets
|
|
stats[room.room_id,user] = usrstats
|
|
|
|
async def actif(room,message): # Stats d'activité d'une personne
|
|
global modules
|
|
try:
|
|
rmod = modules[room.room_id, 'stats']
|
|
except:
|
|
modules[room.room_id, 'stats'] = False
|
|
if (modules[room.room_id, 'stats']):
|
|
global stats
|
|
args = getMessage(message).split()
|
|
sender = getUser(message)
|
|
args.pop(0)
|
|
if (len(args) > 0 and args[0] == "list"):
|
|
salon = await verifPMRoom(room,message)
|
|
room_act = []
|
|
for cle,valeur in stats.items():
|
|
if (cle[0] == room.room_id):
|
|
room_act.append(valeur)
|
|
room_act.sort(key=lambda us: us.mess, reverse=True)
|
|
reponse="Voici le tableau des plus gros posteurs!\n"
|
|
for us in room_act:
|
|
reponse = reponse + us.nick + " : " + str(us.mess) + "\n"
|
|
await msg(salon,reponse,sender)
|
|
else:
|
|
pers = ""
|
|
usrstats = None
|
|
if (len(args) == 0):
|
|
pers = getUser(message)
|
|
else:
|
|
pers=" ".join(args)
|
|
print(pers)
|
|
try:
|
|
usrstats = stats[room.room_id,pers]
|
|
except:
|
|
for cle,valeur in room.users.items():
|
|
if (valeur.display_name == pers):
|
|
try:
|
|
usrstats = stats[room.room_id, cle]
|
|
except:
|
|
usrstats = None
|
|
if (usrstats is not None):
|
|
break
|
|
if(usrstats):
|
|
try:
|
|
moy = "{:10.2f}".format(usrstats.char / usrstats.mess)
|
|
await msg(room,usrstats.nick + " a posté " + str(usrstats.mess) + " messages avec une moyenne de " + moy + " caractères par message",sender)
|
|
except:
|
|
print("erreur usrstats")
|
|
else:
|
|
await msg(room,pers + " : Personne non reconnue\n",sender)
|
|
|
|
def getNiveau(niveau):
|
|
if (niveau == 1):
|
|
return("vert")
|
|
elif (niveau == 2):
|
|
return("orange")
|
|
elif (niveau == 3):
|
|
return("rouge")
|
|
else:
|
|
return("Inconnu")
|
|
|
|
async def ecowatt(room, message):
|
|
global modules
|
|
try:
|
|
rmod = modules[room.room_id, 'ecowatt']
|
|
except:
|
|
modules[room.room_id, 'ecowatt'] = False
|
|
if (modules[room.room_id, 'ecowatt']):
|
|
args = getMessage(message).split()
|
|
sender = getUser(message)
|
|
jn = int(datetime.today().strftime("%Y%m%d"))
|
|
hn = int(datetime.today().strftime("%H"))
|
|
signals = None
|
|
global wattobj
|
|
if (wattobj.jour < jn or (wattobj.jour == jn and wattobj.heure + 1 < hn)):
|
|
try:
|
|
oauth = rte_token()
|
|
result = oauth.get(ecowatt_url)
|
|
watt = json.loads(result.text)
|
|
except Exception as e:
|
|
print(e)
|
|
await msg(room, "Veuillez attendre 15 minutes", sender)
|
|
return
|
|
sign = watt["signals"]
|
|
signals = sorted(sign, key=lambda signal: signal["jour"][0:10])
|
|
wattobj.jour = jn
|
|
wattobj.heure = hn
|
|
wattobj.signals = signals
|
|
else:
|
|
signals = wattobj.signals
|
|
args.pop(0)
|
|
mess = ""
|
|
if (len(args) > 0 and args[0] == "details"):
|
|
i=False
|
|
for jour in signals:
|
|
if (jour["dvalue"] > 1):
|
|
if (i):
|
|
mess = mess + "\n"
|
|
i=True
|
|
mess = mess + jour["jour"][0:10] + " : " + jour["message"]
|
|
heures = sorted(jour["values"], key=lambda h: h["pas"])
|
|
for heure in heures:
|
|
if (heure["hvalue"] > 1):
|
|
alerte = getNiveau(heure["hvalue"])
|
|
mess = mess + "\n" + str(heure["pas"]) + "h : niveau " + alerte
|
|
if (len(mess) < 10):
|
|
mess = "Aucune alerte sur le réseau RTE dans les trois prochains jours."
|
|
elif (len(args) > 0 and args[0].isnumeric()):
|
|
j = int(args[0])
|
|
if (len(signals) > j):
|
|
jour = signals[j]
|
|
alerte = getNiveau(jour["dvalue"])
|
|
mess = mess + "La météo RTE du " + jour["jour"][0:10] + " est de niveau " + alerte + " (" + jour["message"] + ")\n"
|
|
else:
|
|
for jour in signals:
|
|
alerte = getNiveau(jour["dvalue"])
|
|
mess = mess + "La météo RTE du " + jour["jour"][0:10] + " est de niveau " + alerte + " (" + jour["message"] + ")\n"
|
|
await msg(room, mess, sender)
|
|
|
|
async def commune(room, message):
|
|
global modules
|
|
try:
|
|
rmod = modules[room.room_id, 'commune']
|
|
except:
|
|
modules[room.room_id, 'commune'] = False
|
|
if (modules[room.room_id, 'commune']):
|
|
args = getMessage(message).split()
|
|
sender = getUser(message)
|
|
args.pop(0)
|
|
mess = ""
|
|
if (len(args) > 0):
|
|
ville = " ".join(args)
|
|
cette_commune = None
|
|
if (ville.isnumeric()):
|
|
cette_commune = commune_url.replace("<NOM>", ville).replace("<TYPE>", "codePostal")
|
|
else:
|
|
cette_commune = commune_url.replace("<NOM>", ville).replace("<TYPE>", "nom")
|
|
oauth = rte_token()
|
|
result = oauth.get(cette_commune)
|
|
villes = json.loads(result.text)
|
|
if (len(villes) > 0):
|
|
try:
|
|
cites = sorted(villes, key=lambda v: str(v["population"]).zfill(10), reverse=True)
|
|
cite = cites[0]
|
|
codePoste = cite["codesPostaux"][0]
|
|
pop = cite["population"]
|
|
insee = cite["code"]
|
|
nom = cite["nom"]
|
|
await msg(room, nom + ". CP : " + codePoste + ". Code INSEE : " + insee + ". Population : " + str(pop), sender)
|
|
except:
|
|
await msg(room, str(villes), sender)
|
|
else:
|
|
await msg(room, "Commune non trouvée", sender)
|
|
else:
|
|
await msg(room, "!commune <nom de la commune OU code postal de la commune>", sender)
|
|
|
|
async def eau(room, message):
|
|
global modules
|
|
try:
|
|
rmod = modules[room.room_id, 'eau']
|
|
except:
|
|
modules[room.room_id, 'eau'] = False
|
|
if (modules[room.room_id, 'eau']):
|
|
args = getMessage(message).split()
|
|
sender = getUser(message)
|
|
args.pop(0)
|
|
mess = ""
|
|
if (len(args) > 0):
|
|
ville = " ".join(args)
|
|
cette_commune = None
|
|
if (ville.isnumeric()):
|
|
cette_commune = eau_url.replace("<NOM>", ville).replace("<TYPE>", "code_commune")
|
|
else:
|
|
cette_commune = eau_url.replace("<NOM>", ville).replace("<TYPE>", "nom_commune")
|
|
oauth = rte_token()
|
|
result = oauth.get(cette_commune)
|
|
eaux = None
|
|
try:
|
|
eaux = json.loads(result.text)
|
|
except:
|
|
eaux = None
|
|
if (eaux is not None):
|
|
if (len(eaux["data"]) > 0):
|
|
try:
|
|
f = True
|
|
for eau in eaux["data"]:
|
|
if (f):
|
|
nom = eau["nom_commune"]
|
|
distrib = eau["nom_distributeur"]
|
|
concl = eau["conclusion_conformite_prelevement"]
|
|
await msg(room, "Prélèvement à " + nom + " réseau " + distrib + ". " + concl, sender)
|
|
f = False
|
|
date = eau["date_prelevement"][0:10]
|
|
res = eau["resultat_alphanumerique"]
|
|
unite = str(eau["libelle_unite"])
|
|
if (unite == "SANS OBJET"):
|
|
unite = ""
|
|
limite = "(" + str(eau["limite_qualite_parametre"]) + ")"
|
|
if (limite == "(None)"):
|
|
limite = ""
|
|
param = eau["libelle_parametre"] + " " + limite
|
|
await msg(room, "Résultat du " + date + " : " + res + unite + " / " + param + ".", sender)
|
|
except:
|
|
await msg(room, str(eaux), sender)
|
|
else:
|
|
await msg(room, "Commune non trouvée", sender)
|
|
else:
|
|
await msg(room, "Rapport d'eaux non trouvé", sender)
|
|
else:
|
|
await msg(room, "!eau <nom de la commune OU code INSEE de la commune>", sender)
|
|
|
|
async def help(room, message): # Aide en message privé
|
|
await help_center(room,message,"help",True)
|
|
|
|
async def aide(room, message): # Aide dans le salon
|
|
await help_center(room,message,"aide",False)
|
|
async def help_center(room,message,name,private): # Aide sur les commandes disponibles
|
|
args = getMessage(message).split()
|
|
args.pop(0)
|
|
salon = room
|
|
sender = getUser(message)
|
|
if (private):
|
|
salon = await verifPMRoom(room,message)
|
|
if (len(args) > 0):
|
|
if (re.search("roll", args[0])):
|
|
await msg(salon,":roll <options> <des> (+-modifs ou des)\n\n- exemple :roll vr4g3 6d6 - \#g\#r3d6 +2 x3 : lance avec les details 6d6 en relancant les des avec un resultat de 4+ et en gardant les trois meilleurs, puis en retranchant 3d6 sans relancer les 4+ et en gardant tout, enfin ajouter 2. L'operation sera executee trois fois.\n\n- v : details (verbose) du jet\n- n : no add, chaque de est traite separement\n- e : explosif, si un de fait le maximum, on le relance et on additionne\n- z : Star Zars, le premier de est explosif. Mais s'il sort un 1, on retire ce 1 et la plus grande valeur des autres des\n- f<nb> : difficulte a atteindre par de avec option n\n- g<nb> : nombre de des conserves\n- r<nb> : relance si le de a obtenu au moins ce nombre\n- m<nb> : Enleve un succes si ce nombre ou moins est atteint\n- s<nb/nb> : seuil a atteindre et niveaux de reussites\n- w<nb> : lance un wild die avec les autres.",sender, False)
|
|
elif (re.search("sw", args[0])):
|
|
await msg(salon,"- :sw <options> <des> : Lance les des en mode Savage Worlds\nVerbose/Noadd/Explosif/Seuil 4/Niveau de reussite 4/Wild Die d6.",sender, False)
|
|
elif (re.search("dom", args[0])):
|
|
await msg(salon,"- :dom <options> <des> : Lance les dommages en mode Savage Worlds\nVerbose/Explosif/seuil 4/Niveau de reussite 4.",sender, False)
|
|
elif (re.search("owod", args[0])):
|
|
await msg(salon,"- :owod <options> <des> : Lance les des en mode Ancien Monde des Tenebres\nVerbose/Noadd/Difficulte 6/Relance les 10/Les 1 enleve un succes.",sender, False)
|
|
elif (re.search("wod", args[0])):
|
|
await msg(salon,"- :wod <options> <des> : Lance les des en mode Nouveau Monde des Tenebres\nVerbose/Noadd/Difficulte 8/Relance les 10.",sender, False)
|
|
elif (re.search("ars", args[0])):
|
|
await msg(salon,"- :ars <options> <des> : Lance les des en mode Ars Magicka : de de tension\nVerbose/Noadd/Sur un 1, on relance et on double.",sender, False)
|
|
elif (re.search("des", args[0])):
|
|
await msg(salon,"- :des <options> <des> : Lance des des de desastre\nVerbose/Noadd/Difficulte 10.",sender, False)
|
|
elif (re.search("star", args[0])):
|
|
await msg(salon,"- :star <options> <des> : Lance des des en mode star wars. Le premier de est explosif. Mais s'il sort un 1, on retire ce 1 et la plus grande valeur des autres des.",sender, False)
|
|
elif (re.search("carte", args[0])):
|
|
await msg(salon,"- !carte : Tire une carte et la retire du paquet\n- !carte m : remelange le paquet.",sender, False)
|
|
elif (re.search("card", args[0])):
|
|
await msg(salon,"- !card : tire une carte sans la retirer du paquet.",sender, False)
|
|
elif (re.search("liste", args[0])):
|
|
await msg(salon,"- !liste <options/de/la/liste> [Nombre d'elements souhaites] : retourne ce nombre d'elements de la liste.",sender, False)
|
|
elif (re.search("horloge", args[0])):
|
|
await msg(salon,"- !horloge : Affiche les horloges\n- !horloge <Nom de l'horloge> <niveau> : Crée ou modifie une horloge en lui mettant un niveau (normalement de 0 à 6)\n- !horloge del <Nom de l'horloge> : Supprime cette horloge.",sender, False)
|
|
elif (re.search("last", args[0])):
|
|
await msg(salon,"- !last : Date de son dernier post\n- !last <Personne> : Date du dernier post de la personne\n- !last inactifs <[+-]nombre de jours> <nombre max de message> : liste de personnes (en privé) ayant posté depuis + ou - le nombre de jours spécifiés et ayant au maximum le nombre de messages spécifiés.\n",sender, False)
|
|
elif (re.search("actif", args[0])):
|
|
await msg(salon,"- !actif : Nombre de ses messages et taille moyenne de ceux ci\n- !actif <Personne> : Nombre des messages de cette personne et taille moyenne de ceux ci\n",sender, False)
|
|
elif (re.search("quote", args[0])):
|
|
await msg(salon,"- !quote : Affiche une citation du salon au hasard\n- !quote <Personne> : Affiche une citation d'une personne du salon au hasard\n- !addquote après une réponse matrix : Enregistre une citation",sender, False)
|
|
elif (re.search("biere", args[0])):
|
|
await msg(salon,"- !biere : Fournit une boisson du salon au hasard\n- !biere <Nom de breuvage> : Fournit une boisson spécifique du salon\n- !biere give <Personne>[:Nom du Breuvage] : Offre une boisson (spécifique en option) à la personne spécifiée\n- !biere add <Nom du breuvage>:<Phrase> : Enregistre une phrase pour ce breuvage\n- !biere list [Nom de Breuvage] : Affiche les phrases des breuvages du salon ou celles d'un breuvage spécifique du salon en message privé\n- !biere list all : Affiche toutes les citations de tous breuvages de tous les salons en message privé\n- !biere del <id> : Supprime la phrase avec l'id spécifié",sender, False)
|
|
elif (re.search("accueil", args[0])):
|
|
await msg(salon,"- !accueil <message> : Modifie le message d'accueil avec message. Il sera affiché à tout nouvel arrivant précédé de la mention 'Bienvenue sur le salon XXX, YYY.'",sender, False)
|
|
elif (re.search("kick", args[0])):
|
|
await msg(salon,"- !kick <@mxid> [@mxid] ... : kick les users listés",sender, False)
|
|
elif (re.search("titre", args[0])):
|
|
await msg(salon,"- !titre <url> : retourne le titre de la page",sender, False)
|
|
elif (re.search("mails", args[0]) or re.search("mail", args[0])):
|
|
await msg(salon,"- !mail add <email> : s'abonner aux messages du salon par mail.\n -!mail del <email> : se désabonner aux messages du salon par mail.",sender, False)
|
|
elif (re.search("modo", args[0])):
|
|
await msg(salon,"- !modo : Affiche la liste des modérateurs (ils peuvent gérer le message d'accueil, supprimer des citations ou des boissons, ajouter/retirer des modules, ajouter/retirer des modérateurs)\n- !modo add <mxid> : Ajoute une personne comme modérateur du salon\n- !modo del <mxid> : Retire une personne des modérateurs.",sender, False)
|
|
elif (re.search("module", args[0])):
|
|
await msg(salon,"- !module : Affiche la liste des modules actifs sur le salon ainsi que celle des modules disponibles\n- !module add <module> : Active un module sur le salon\n- !module del <module> : Désactive un module sur le salon.",sender, False)
|
|
elif (re.search("cristal", args[0])):
|
|
await msg(salon,"- !cristal : Réponds à une question posée commençant par Est-ce, Combien, Pourquoi, Quand, Comment, Où et se terminant par un point d'interrogation.",sender, False)
|
|
elif (re.search("ecowatt", args[0])):
|
|
await msg(salon,"- !ecowatt : Météo RTE des prochains jours.\n- !ecowatt 0-3 : Météo RTE d'une journée entre J et J+3.\n- !ecowatt details : Météo RTE des prochains jours, chaque heure orange ou rouge spécifiquement.",sender, False)
|
|
else:
|
|
await msg(salon,"A venir",sender, False)
|
|
else:
|
|
rid = room.room_id
|
|
message = "Commandes disponibles:"
|
|
for cle,valeur in modules.items():
|
|
if (cle[0] == rid and cle[1] == "card" and valeur):
|
|
message += "\n- !card"
|
|
if (cle[0] == rid and cle[1] == "carte" and valeur):
|
|
message += "\n- !carte"
|
|
if (cle[0] == rid and cle[1] == "liste" and valeur):
|
|
message += "\n- !liste <options/de/la/liste> [Nombre d'elements souhaites]"
|
|
if (cle[0] == rid and cle[1] == "horloge" and valeur):
|
|
message += "\n- !horloge : gestion des horloges PBTA"
|
|
if (cle[0] == rid and cle[1] == "stats" and valeur):
|
|
message += "\n- !last : Date de dernier post\n- !actif : Nombre de message et taille moyenne de ceux ci"
|
|
if (cle[0] == rid and cle[1] == "quote" and valeur):
|
|
message += "\n- !quote : citations du salon"
|
|
if (cle[0] == rid and cle[1] == "biere" and valeur):
|
|
message += "\n- !biere : breuvages du salon"
|
|
if (cle[0] == rid and cle[1] == "cristal" and valeur):
|
|
message += "\n- !cristal : Posez une question à la boule de cristal"
|
|
if (cle[0] == rid and cle[1] == "welcome" and valeur):
|
|
message += "\n- !accueil <message> : Modifie le message d'accueil"
|
|
if (cle[0] == rid and cle[1] == "kick" and valeur):
|
|
message += "\n- !kick <@mxid> [@mxid] ... : kick les users listés"
|
|
if (cle[0] == rid and cle[1] == "titre" and valeur):
|
|
message += "\n- !titre <url> : retourne le titre de la page en paramètre si celle ci possède une balise titre"
|
|
if (cle[0] == rid and cle[1] == "mails" and valeur):
|
|
message += "\n- !mail : s'abonner aux messages du salon par mail."
|
|
if (cle[0] == rid and cle[1] == "ecowatt" and valeur):
|
|
message += "\n- !ecowatt : Météo des prochains jours du réseau électrique RTE."
|
|
if (cle[0] == rid and cle[1] == "roll" and valeur):
|
|
message += "\n- :roll <options> <des>\n- :sw <options> <des>\n- :dom <options> <des>\n- :wod <options> <des>\n- :owod <options> <des>\n- :ars <options> <des>\n- :des <options> <des>\n- :star <options> <des>"
|
|
message += "\n- !modo : Gère les modérateurs du salon\n- !module : Gère les modules actifs sur le salon\n\n- Pour plus de details, tapez !" + name + " <commande>\n\nRetrouvez Asmodee sur https://git.ombreport.info/nemesis/asmodee_matrix"
|
|
await msg(salon,message,sender, False)
|
|
|
|
@bot.listener.on_message_event
|
|
async def callCommune(room, message):
|
|
match = botlib.MessageMatch(room, message, bot, PREFIX)
|
|
if match.is_not_from_this_bot() and match.prefix() and match.command("commune"):
|
|
await commune(room, message)
|
|
|
|
@bot.listener.on_message_event
|
|
async def callEau(room, message):
|
|
match = botlib.MessageMatch(room, message, bot, PREFIX)
|
|
if match.is_not_from_this_bot() and match.prefix() and match.command("eau"):
|
|
await eau(room, message)
|
|
|
|
@bot.listener.on_message_event
|
|
async def callEcowatt(room, message):
|
|
match = botlib.MessageMatch(room, message, bot, PREFIX)
|
|
if match.is_not_from_this_bot() and match.prefix() and match.command("ecowatt"):
|
|
await ecowatt(room, message)
|
|
|
|
@bot.listener.on_message_event
|
|
async def callActif(room, message):
|
|
match = botlib.MessageMatch(room, message, bot, PREFIX)
|
|
if match.is_not_from_this_bot() and match.prefix() and match.command("actif"):
|
|
await actif(room, message)
|
|
|
|
@bot.listener.on_message_event
|
|
async def callLast(room, message):
|
|
match = botlib.MessageMatch(room, message, bot, PREFIX)
|
|
if match.is_not_from_this_bot() and match.prefix() and match.command("last"):
|
|
await last(room, message)
|
|
|
|
@bot.listener.on_message_event
|
|
async def callSave(room, message):
|
|
match = botlib.MessageMatch(room, message, bot, PREFIX)
|
|
if match.is_not_from_this_bot() and match.prefix() and match.command("save"):
|
|
save_obj(room, message)
|
|
|
|
@bot.listener.on_message_event
|
|
async def callCard(room, message):
|
|
match = botlib.MessageMatch(room, message, bot, PREFIX)
|
|
if match.is_not_from_this_bot() and match.prefix() and match.command("card"):
|
|
await card(room, message)
|
|
|
|
@bot.listener.on_message_event
|
|
async def callCarte(room, message):
|
|
match = botlib.MessageMatch(room, message, bot, PREFIX)
|
|
if match.is_not_from_this_bot() and match.prefix() and match.command("carte"):
|
|
await carte(room, message)
|
|
|
|
@bot.listener.on_message_event
|
|
async def callHelp(room, message):
|
|
match = botlib.MessageMatch(room, message, bot, PREFIX)
|
|
if match.is_not_from_this_bot() and match.prefix() and match.command("help"):
|
|
await help(room, message)
|
|
|
|
@bot.listener.on_message_event
|
|
async def callAide(room, message):
|
|
match = botlib.MessageMatch(room, message, bot, PREFIX)
|
|
if match.is_not_from_this_bot() and match.prefix() and match.command("aide"):
|
|
await aide(room, message)
|
|
|
|
@bot.listener.on_message_event
|
|
async def callShowquote(room, message):
|
|
match = botlib.MessageMatch(room, message, bot, PREFIX)
|
|
if match.is_not_from_this_bot() and match.prefix() and match.command("quote"):
|
|
await showquote(room, message)
|
|
|
|
@bot.listener.on_message_event
|
|
async def callAddquote(room, message):
|
|
match = botlib.MessageMatch(room, message, bot)
|
|
if match.is_not_from_this_bot() and match.contains("!addquote"):
|
|
await addquote(room, message)
|
|
|
|
@bot.listener.on_message_event
|
|
async def callTitre(room, message):
|
|
match = botlib.MessageMatch(room, message, bot, PREFIX)
|
|
if match.is_not_from_this_bot() and match.prefix() and match.command("titre"):
|
|
await titre(room, message)
|
|
|
|
@bot.listener.on_custom_event(nio.RoomMemberEvent)
|
|
async def callBienvenue(room, message):
|
|
match = botlib.MessageMatch(room, message, bot)
|
|
if match.is_not_from_this_bot():
|
|
await bienvenue(room, message)
|
|
|
|
@bot.listener.on_message_event
|
|
async def callAccueil(room, message):
|
|
match = botlib.MessageMatch(room, message, bot, PREFIX)
|
|
if match.is_not_from_this_bot() and match.prefix() and match.command("accueil"):
|
|
await accueil(room, message)
|
|
|
|
@bot.listener.on_message_event
|
|
async def callSalon(room, message):
|
|
match = botlib.MessageMatch(room, message, bot, PREFIX)
|
|
if match.is_not_from_this_bot() and match.prefix() and match.command("salon"):
|
|
await salon(room, message)
|
|
|
|
@bot.listener.on_message_event
|
|
async def callBoisson(room, message):
|
|
match = botlib.MessageMatch(room, message, bot, "%")
|
|
if match.is_not_from_this_bot() and match.prefix():
|
|
await boissons(room, message)
|
|
|
|
@bot.listener.on_message_event
|
|
async def callBiere(room, message):
|
|
match = botlib.MessageMatch(room, message, bot, PREFIX)
|
|
if match.is_not_from_this_bot() and match.prefix() and match.command("biere"):
|
|
await biere(room, message)
|
|
|
|
@bot.listener.on_message_event
|
|
async def callHor(room, message):
|
|
match = botlib.MessageMatch(room, message, bot, PREFIX)
|
|
if match.is_not_from_this_bot() and match.prefix() and match.command("horloge"):
|
|
await horloge(room, message)
|
|
|
|
@bot.listener.on_message_event
|
|
async def callListe(room, message):
|
|
match = botlib.MessageMatch(room, message, bot, PREFIX)
|
|
if match.is_not_from_this_bot() and match.prefix() and match.command("liste"):
|
|
await liste(room, message)
|
|
|
|
@bot.listener.on_message_event
|
|
async def callRoll(room, message):
|
|
match = botlib.MessageMatch(room, message, bot, ":")
|
|
if match.is_not_from_this_bot() and match.prefix():
|
|
await entryPoint(room, message)
|
|
|
|
@bot.listener.on_message_event
|
|
async def callModule(room, message):
|
|
match = botlib.MessageMatch(room, message, bot, PREFIX)
|
|
if match.is_not_from_this_bot() and match.prefix() and match.command("module"):
|
|
await module(room, message)
|
|
|
|
@bot.listener.on_message_event
|
|
async def callModo(room, message):
|
|
match = botlib.MessageMatch(room, message, bot, PREFIX)
|
|
if match.is_not_from_this_bot() and match.prefix() and match.command("modo"):
|
|
await modo(room, message)
|
|
|
|
@bot.listener.on_message_event
|
|
async def echo(room, message):
|
|
match = botlib.MessageMatch(room, message, bot, PREFIX)
|
|
if match.is_not_from_this_bot() and match.prefix() and match.command("echo"):
|
|
print(message)
|
|
await bot.api.send_text_message(
|
|
room.room_id, " ".join(arg for arg in match.args())
|
|
)
|
|
@bot.listener.on_message_event
|
|
async def callStats(room, message):
|
|
match = botlib.MessageMatch(room, message, bot)
|
|
if match.is_not_from_this_bot():
|
|
statistiques(room, message)
|
|
|
|
def rte_token():
|
|
auth = HTTPBasicAuth(RTE_ID, RTE_SECRET)
|
|
client = BackendApplicationClient(client_id=RTE_ID)
|
|
oauth = OAuth2Session(client=client)
|
|
token = oauth.fetch_token(token_url='https://digital.iservices.rte-france.com/token/oauth/', auth=auth)
|
|
return(oauth)
|
|
|
|
def main():
|
|
config = configparser.ConfigParser()
|
|
config.read('asmodee.ini')
|
|
USERNAME = "" # Bot's username
|
|
PASSWORD = "" # Bot's password
|
|
SERVER = "" # Matrix server URL
|
|
mods = ["roll", "quote", "biere", "stats", "liste", "horloge", "carte", "card", "cristal", "welcome", "salut", "jdr", "gens", "va", "salon", "kick", "mails", "titre", "invididious", "ecowatt", "commune"]
|
|
global admins
|
|
if ('AUTH' in config):
|
|
USERNAME = config['AUTH']['username'] # Bot's username
|
|
PASSWORD = config['AUTH']['password'] # Bot's password
|
|
SERVER = config['AUTH']['server'] # Matrix server URL
|
|
admins = config['AUTH']['admin'].split(",") # Admins du bot @admin1:host.tld,@admin2:host.tld,...
|
|
else:
|
|
print("Probleme de lecture de configuration asmodee.ini (AUTH)")
|
|
|
|
if ('RTE' in config):
|
|
global RTE_ID
|
|
global RTE_SECRET
|
|
global wattobj
|
|
RTE_ID = config['RTE']['client_id'] # Bot's username
|
|
RTE_SECRET = config['RTE']['client_secret'] # Bot's password
|
|
wattobj = Wattobject()
|
|
else:
|
|
RTE_ID = None
|
|
RTE_SECRET = None
|
|
print("Probleme de lecture de configuration asmodee.ini (RTE)")
|
|
|
|
global liste_mod
|
|
if ('MOD' in config):
|
|
try:
|
|
liste_mod = config['MOD']['liste'].split(',') # Liste des modules
|
|
except:
|
|
liste_mod = mods
|
|
else:
|
|
liste_mod = mods
|
|
|
|
if (threading.current_thread().__class__.__name__ == '_MainThread'):
|
|
print("main thread")
|
|
signal.signal(signal.SIGINT, signal_handler)
|
|
|
|
modules_read()
|
|
modos_read()
|
|
prive_read()
|
|
if ('horloge' in liste_mod):
|
|
horloge_read()
|
|
if ('quote' in liste_mod):
|
|
#quotes_read()
|
|
citations_read()
|
|
if ('biere' in liste_mod):
|
|
bieres_read()
|
|
if ('salon' in liste_mod):
|
|
salons_read()
|
|
if ('welcome' in liste_mod):
|
|
welcome_read()
|
|
|
|
if __name__ == "__main__":
|
|
main()
|
|
|
|
bot.run()
|
|
|