You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
700 lines
27 KiB
Python
700 lines
27 KiB
Python
import functools
|
|
from json import JSONDecodeError, dumps, loads
|
|
from string import digits
|
|
|
|
from klein import Klein
|
|
from twisted.web.server import Request
|
|
|
|
import main
|
|
from modules import chankeep, helpers, provision, regproc, userinfo
|
|
from modules.network import Network
|
|
from utils.logging.log import warn
|
|
|
|
|
|
def login_required(func):
|
|
@functools.wraps(func)
|
|
def wrapper(self, *args, **kwargs):
|
|
if isinstance(args[0], Request):
|
|
request = args[0]
|
|
apikey = request.getHeader("ApiKey")
|
|
token = request.getHeader("Token")
|
|
if not apikey:
|
|
return "No API key provided"
|
|
if not token:
|
|
return "No token provided"
|
|
if apikey not in main.tokens:
|
|
return "No such API key"
|
|
config_token = main.tokens[apikey]
|
|
if not token == config_token["hello"]:
|
|
return "Invalid token"
|
|
counter = config_token["counter"]
|
|
request.setHeader("Counter", counter)
|
|
return func(self, *args, **kwargs)
|
|
|
|
return wrapper
|
|
|
|
|
|
class API(object):
|
|
"""
|
|
Our API webapp.
|
|
"""
|
|
|
|
app = Klein()
|
|
|
|
@app.route("/", methods=["GET"])
|
|
@login_required
|
|
def hello(self, request):
|
|
return "Hello"
|
|
|
|
@app.route("/who/<query>/", methods=["POST"])
|
|
@login_required
|
|
def who(self, request, query):
|
|
try:
|
|
data = loads(request.content.read())
|
|
except JSONDecodeError:
|
|
return "Invalid JSON"
|
|
if "query" not in data:
|
|
return "No query provided"
|
|
result = userinfo.getWho(data["query"])
|
|
# Expand the generator
|
|
return dumps({k: [x for x in v] for k, v in result.items()})
|
|
|
|
@app.route("/chans/", methods=["POST"])
|
|
@login_required
|
|
def chans(self, request):
|
|
try:
|
|
data = loads(request.content.read())
|
|
except JSONDecodeError:
|
|
return "Invalid JSON"
|
|
if "net" not in data:
|
|
return "No net provided"
|
|
if "query" not in data:
|
|
return "No query provided"
|
|
if not data["query"]:
|
|
warn(f"No query provided: for chans {data}")
|
|
return dumps({})
|
|
result = userinfo.getChansSingle(data["net"], data["query"])
|
|
if not result:
|
|
return dumps({})
|
|
return dumps({"chans": [x for x in result]})
|
|
|
|
@app.route("/users/", methods=["POST"])
|
|
@login_required
|
|
def users(self, request):
|
|
try:
|
|
data = loads(request.content.read())
|
|
except JSONDecodeError:
|
|
return "Invalid JSON"
|
|
if "net" not in data:
|
|
return "No net provided"
|
|
if "query" not in data:
|
|
return "No query provided"
|
|
if not data["query"]:
|
|
warn(f"No query provided for users: {data}")
|
|
return dumps({})
|
|
result = userinfo.getUsersSingle(data["net"], data["query"])
|
|
if not result:
|
|
return dumps({})
|
|
return dumps({"users": [x for x in result]})
|
|
|
|
@app.route("/online/", methods=["POST"])
|
|
@login_required
|
|
def online(self, request):
|
|
try:
|
|
data = loads(request.content.read())
|
|
except JSONDecodeError:
|
|
return "Invalid JSON"
|
|
if "net" not in data:
|
|
return "No net provided"
|
|
if "query" not in data:
|
|
return "No users provided"
|
|
if not data["query"]:
|
|
warn(f"No users provided: for online {data}")
|
|
return dumps({})
|
|
net = data["net"]
|
|
usermap = {}
|
|
for user in data["query"]:
|
|
channels = userinfo.getChansSingle(net, [user])
|
|
if channels:
|
|
usermap[user] = True
|
|
else:
|
|
usermap[user] = False
|
|
|
|
return dumps(usermap)
|
|
|
|
@app.route("/num_users/", methods=["POST"])
|
|
@login_required
|
|
def num_users(self, request):
|
|
try:
|
|
data = loads(request.content.read())
|
|
except JSONDecodeError:
|
|
return "Invalid JSON"
|
|
if "net" not in data:
|
|
return "No net provided"
|
|
if "query" not in data:
|
|
return "No users provided"
|
|
if not data["query"]:
|
|
warn(f"No chans provided: for num_users {data}")
|
|
return dumps({})
|
|
net = data["net"]
|
|
results = userinfo.getUserNum(net, data["query"])
|
|
|
|
return dumps(results)
|
|
|
|
@app.route("/num_chans/", methods=["POST"])
|
|
@login_required
|
|
def num_chans(self, request):
|
|
try:
|
|
data = loads(request.content.read())
|
|
except JSONDecodeError:
|
|
return "Invalid JSON"
|
|
if "net" not in data:
|
|
return "No net provided"
|
|
if "query" not in data:
|
|
return "No users provided"
|
|
if not data["query"]:
|
|
warn(f"No users provided: for num_chans {data}")
|
|
return dumps({})
|
|
net = data["net"]
|
|
results = userinfo.getChanNum(net, data["query"])
|
|
|
|
return dumps(results)
|
|
|
|
@app.route("/irc/stats/", methods=["POST"])
|
|
@login_required
|
|
def irc_stats(self, request):
|
|
stats = {}
|
|
numChannels = 0
|
|
numWhoEntries = 0
|
|
for i in main.IRCPool.keys():
|
|
numChannels += len(main.IRCPool[i].channels)
|
|
numWhoEntries += userinfo.getNumTotalWhoEntries()
|
|
numRelays = 0
|
|
for net in main.network.keys():
|
|
numRelays += len(main.network[net].relays)
|
|
stats["servers_total_total"] = numRelays
|
|
stats["servers_total_unique"] = len(main.network.keys())
|
|
stats["servers_online_total"] = len(main.IRCPool.keys())
|
|
stats["servers_online_unique"] = len(main.liveNets())
|
|
stats["channels"] = numChannels
|
|
stats["records"] = numWhoEntries
|
|
stats["eventrate"] = main.lastMinuteSample
|
|
return dumps(stats)
|
|
|
|
@app.route("/irc/networks/", methods=["POST"])
|
|
@login_required
|
|
def irc_networks(self, request):
|
|
networks = {}
|
|
for net in main.network.keys():
|
|
networks[net] = {
|
|
"active": chankeep.allRelaysActive(net),
|
|
"relays": len(main.network[net].relays),
|
|
"channels": userinfo.getTotalChanNum(net),
|
|
"records": userinfo.getNumWhoEntries(net),
|
|
}
|
|
return dumps(networks)
|
|
|
|
@app.route("/irc/auth/", methods=["POST"])
|
|
@login_required
|
|
def irc_network_recheckauth(self, request):
|
|
try:
|
|
data = loads(request.content.read())
|
|
except JSONDecodeError:
|
|
return "Invalid JSON"
|
|
if "func" not in data:
|
|
return dumps({"success": False, "reason": "no function specified."})
|
|
func = data["func"]
|
|
|
|
if "net" not in data:
|
|
return dumps({"success": False, "reason": "no net specified."})
|
|
net = data["net"]
|
|
if not net or net == "None":
|
|
nets = main.network.keys()
|
|
else:
|
|
if net not in main.network.keys():
|
|
return dumps({"success": False, "reason": "no such net."})
|
|
nets = [net]
|
|
for net_name in nets:
|
|
conns = helpers.get_connected_relays(net_name)
|
|
if not conns:
|
|
return dumps({"success": False, "reason": f"failed to get instances for {net_name}."})
|
|
if func == "recheckauth":
|
|
for conn in conns:
|
|
conn.regPing(reset=True)
|
|
elif func == "resetauth":
|
|
for conn in conns:
|
|
conn.authenticated = False
|
|
conn.regPing(reset=True)
|
|
elif func == "register":
|
|
for conn in conns:
|
|
regproc.registerAccount(conn.net, conn.num)
|
|
return dumps({"success": True})
|
|
|
|
@app.route("/irc/network/<net>/", methods=["POST"])
|
|
@login_required
|
|
def irc_network(self, request, net):
|
|
if net not in main.network.keys():
|
|
return dumps({"success": False, "reason": "no such net."})
|
|
inst = main.network[net]
|
|
network = {}
|
|
network["net"] = inst.net
|
|
network["auth"] = inst.auth
|
|
network["host"] = inst.host
|
|
network["last"] = inst.last
|
|
network["port"] = inst.port
|
|
network["security"] = inst.security
|
|
network["relays"] = len(inst.relays)
|
|
network["chanlimit"] = inst.chanlimit
|
|
network["channels"] = userinfo.getTotalChanNum(net)
|
|
network["records"] = userinfo.getNumWhoEntries(net)
|
|
return dumps(network)
|
|
|
|
@app.route("/irc/network/<net>/", methods=["DELETE"])
|
|
@login_required
|
|
def irc_network_delete(self, request, net):
|
|
if net not in main.network.keys():
|
|
return dumps({"success": False, "reason": "no such net."})
|
|
main.network[net].seppuku()
|
|
del main.network[net]
|
|
main.saveConf("network")
|
|
return dumps({"success": True})
|
|
|
|
@app.route("/irc/network/<net>/edit/", methods=["POST"])
|
|
@login_required
|
|
def irc_network_edit(self, request, net):
|
|
try:
|
|
data = loads(request.content.read())
|
|
except JSONDecodeError:
|
|
return "Invalid JSON"
|
|
if net not in main.network.keys():
|
|
return dumps({"success": False, "reason": "no such net."})
|
|
inst = main.network[net]
|
|
for item in data:
|
|
if item == "auth":
|
|
auth = data[item][0]
|
|
if auth not in ["sasl", "ns", "none"]:
|
|
return dumps({"success": False, "reason": "invalid auth."})
|
|
elif item == "host":
|
|
host = data[item][0]
|
|
elif item == "last":
|
|
last = data[item][0]
|
|
if not last.isdigit():
|
|
return dumps({"success": False, "reason": "invalid last: not a number."})
|
|
elif item == "port":
|
|
port = data[item][0]
|
|
if not port.isdigit():
|
|
return dumps({"success": False, "reason": "invalid port: not a number."})
|
|
port = int(port)
|
|
elif item == "chanlimit":
|
|
chanlimit = data[item][0]
|
|
if chanlimit == "None":
|
|
chanlimit = None
|
|
elif not chanlimit.isdigit():
|
|
return dumps({"success": False, "reason": "invalid chanlimit: not a number."})
|
|
else:
|
|
chanlimit = int(chanlimit)
|
|
online_relays = helpers.get_connected_relays(net)
|
|
for r in online_relays:
|
|
r.chanlimit = chanlimit
|
|
elif item == "security":
|
|
security = data[item][0]
|
|
if security not in ["ssl", "plain"]:
|
|
return dumps({"success": False, "reason": "invalid security."})
|
|
inst.auth = auth
|
|
inst.host = host
|
|
inst.last = last
|
|
inst.port = port
|
|
inst.security = security
|
|
inst.chanlimit = chanlimit
|
|
main.saveConf("network")
|
|
|
|
return dumps({"success": True})
|
|
|
|
@app.route("/irc/network/create/", methods=["PUT"])
|
|
@login_required
|
|
def irc_network_create(self, request):
|
|
try:
|
|
data = loads(request.content.read())
|
|
except JSONDecodeError:
|
|
return "Invalid JSON"
|
|
fields = ["net", "auth", "host", "port", "security"]
|
|
if not set(fields).issubset(set(data)):
|
|
return dumps({"success": False, "reason": "not enough fields."})
|
|
for item in data:
|
|
if item == "net":
|
|
net = data[item]
|
|
if net in main.network.keys():
|
|
return dumps({"success": False, "reason": "network already exists."})
|
|
if set(net).intersection(set(digits)):
|
|
return dumps({"success": False, "reason": "network name cannot contain numbers."})
|
|
elif item == "auth":
|
|
auth = data[item]
|
|
if auth not in ["sasl", "ns", "none"]:
|
|
return dumps({"success": False, "reason": "invalid auth."})
|
|
elif item == "host":
|
|
host = data[item]
|
|
elif item == "port":
|
|
port = data[item]
|
|
if not port.isdigit():
|
|
return dumps({"success": False, "reason": "invalid port: not a number."})
|
|
port = int(port)
|
|
elif item == "security":
|
|
security = data[item]
|
|
if security not in ["ssl", "plain"]:
|
|
return dumps({"success": False, "reason": "invalid security."})
|
|
main.network[net] = Network(net, host, int(port), security, auth)
|
|
main.saveConf("network")
|
|
|
|
return dumps({"success": True})
|
|
|
|
@app.route("/irc/network/<net>/relays/", methods=["POST"])
|
|
@login_required
|
|
def irc_network_relays(self, request, net):
|
|
if net not in main.network.keys():
|
|
return dumps({"success": False, "reason": "no such net."})
|
|
relays_inst = main.network[net].relays
|
|
relays = []
|
|
for num in relays_inst.keys():
|
|
to_append = relays_inst[num]
|
|
name = f"{net}{num}"
|
|
if name in main.IRCPool.keys():
|
|
to_append["chans"] = len(main.IRCPool[name].channels)
|
|
to_append["nick"] = main.IRCPool[name].nickname
|
|
to_append["conn"] = main.IRCPool[name].isconnected
|
|
to_append["limit"] = main.IRCPool[name].chanlimit
|
|
to_append["authed"] = main.IRCPool[name].authenticated
|
|
else:
|
|
to_append["chans"] = 0
|
|
to_append["nick"] = None
|
|
to_append["conn"] = False
|
|
to_append["limit"] = None
|
|
to_append["authed"] = None
|
|
relays.append(to_append)
|
|
return dumps({"relays": relays})
|
|
|
|
@app.route("/irc/network/<net>/<num>/", methods=["POST"])
|
|
@login_required
|
|
def irc_network_relay(self, request, net, num):
|
|
try:
|
|
data = loads(request.content.read())
|
|
except JSONDecodeError:
|
|
return "Invalid JSON"
|
|
if net not in main.network.keys():
|
|
return dumps({"success": False, "reason": "no such net."})
|
|
if not num.isdigit():
|
|
return dumps({"success": False, "reason": "invalid num: not a number."})
|
|
num = int(num)
|
|
net_inst = main.network[net]
|
|
if num not in net_inst.relays:
|
|
return dumps({"success": False, "reason": "network has no such relay."})
|
|
if "status" in data:
|
|
if not type(data["status"]) == int:
|
|
return dumps({"success": False, "reason": "invalid type for enabled."})
|
|
enabled = data["status"]
|
|
if enabled:
|
|
net_inst.enable_relay(num)
|
|
else:
|
|
net_inst.disable_relay(num)
|
|
main.saveConf("network")
|
|
return dumps({"success": True})
|
|
|
|
@app.route("/irc/network/<net>/<num>/", methods=["PUT"])
|
|
@login_required
|
|
def irc_network_relay_add(self, request, net, num):
|
|
if net not in main.network.keys():
|
|
return dumps({"success": False, "reason": "no such net."})
|
|
if not num.isdigit():
|
|
return dumps({"success": False, "reason": "invalid num: not a number."})
|
|
num = int(num)
|
|
net_inst = main.network[net]
|
|
if num in net_inst.relays:
|
|
return dumps({"success": False, "reason": "network already has this relay."})
|
|
id, alias = net_inst.add_relay(num)
|
|
main.saveConf("network")
|
|
return dumps({"success": True, "id": id, "alias": alias})
|
|
|
|
@app.route("/irc/network/<net>/", methods=["PUT"])
|
|
@login_required
|
|
def irc_network_relay_add_next(self, request, net):
|
|
if net not in main.network.keys():
|
|
return dumps({"success": False, "reason": "no such net."})
|
|
net_inst = main.network[net]
|
|
id, alias = net_inst.add_relay()
|
|
main.saveConf("network")
|
|
return dumps({"success": True, "id": id, "alias": alias})
|
|
|
|
@app.route("/irc/network/<net>/<num>/", methods=["DELETE"])
|
|
@login_required
|
|
def irc_network_relay_del(self, request, net, num):
|
|
if net not in main.network.keys():
|
|
return dumps({"success": False, "reason": "no such net."})
|
|
if not num.isdigit():
|
|
return dumps({"success": False, "reason": "invalid num: not a number."})
|
|
num = int(num)
|
|
net_inst = main.network[net]
|
|
if num not in net_inst.relays:
|
|
return dumps({"success": False, "reason": "network does not have this relay."})
|
|
net_inst.delete_relay(num)
|
|
main.saveConf("network")
|
|
return dumps({"success": True})
|
|
|
|
@app.route("/irc/network/<net>/<num>/provision/", methods=["POST"])
|
|
@login_required
|
|
def irc_network_relay_provision(self, request, net, num):
|
|
if net not in main.network.keys():
|
|
return dumps({"success": False, "reason": "no such net."})
|
|
if not num.isdigit():
|
|
return dumps({"success": False, "reason": "invalid num: not a number."})
|
|
num = int(num)
|
|
net_inst = main.network[net]
|
|
if num not in net_inst.relays:
|
|
return dumps({"success": False, "reason": "network does not have this relay."})
|
|
provision.provisionRelay(num, net)
|
|
return dumps({"success": True})
|
|
|
|
@app.route("/irc/network/<net>/channels/", methods=["POST"])
|
|
@login_required
|
|
def irc_network_channels(self, request, net):
|
|
if net not in main.network.keys():
|
|
return dumps({"success": False, "reason": "no such net."})
|
|
relays_inst = main.network[net].relays
|
|
channels = []
|
|
for num in relays_inst.keys():
|
|
name = f"{net}{num}"
|
|
if name in main.IRCPool.keys():
|
|
net_chans = main.IRCPool[name].channels
|
|
channels_annotated = userinfo.getUserNum(net, net_chans)
|
|
for channel in net_chans:
|
|
channel_inst = {"name": channel, "users": channels_annotated[channel], "num": num}
|
|
channels.append(channel_inst)
|
|
# channels[channel] = channels_annotated[channel]
|
|
|
|
return dumps({"channels": channels})
|
|
|
|
# API version
|
|
@app.route("/irc/network/<net>/channel/", methods=["DELETE"])
|
|
@login_required
|
|
def irc_network_channel_part_api(self, request, net):
|
|
try:
|
|
data = loads(request.content.read())
|
|
except JSONDecodeError:
|
|
return "Invalid JSON"
|
|
if "channel" not in data:
|
|
return dumps({"success": False, "reason": "no channel specified."})
|
|
channel = data["channel"]
|
|
if net not in main.network.keys():
|
|
return dumps({"success": False, "reason": "no such net."})
|
|
parted = chankeep.partSingle(net, channel)
|
|
if not parted:
|
|
dumps({"success": False, "reason": "no channels matched."})
|
|
return dumps({"success": True, "relays": parted})
|
|
|
|
# API version
|
|
@app.route("/irc/network/<net>/channel/", methods=["PUT"])
|
|
@login_required
|
|
def irc_network_channel_join_api(self, request, net):
|
|
try:
|
|
data = loads(request.content.read())
|
|
except JSONDecodeError:
|
|
return "Invalid JSON"
|
|
if "channel" not in data:
|
|
return dumps({"success": False, "reason": "no channel specified."})
|
|
channel = data["channel"]
|
|
if net not in main.network.keys():
|
|
return dumps({"success": False, "reason": "no such net."})
|
|
joined = chankeep.joinSingle(net, channel)
|
|
if not joined:
|
|
return dumps({"success": False, "reason": "could not allocate channel to relay."})
|
|
return dumps({"success": True, "relays": joined})
|
|
|
|
@app.route("/irc/network/<net>/channel/<channel>/", methods=["PUT"])
|
|
@login_required
|
|
def irc_network_channel_join(self, request, net, channel):
|
|
if net not in main.network.keys():
|
|
return dumps({"success": False, "reason": "no such net."})
|
|
joined = chankeep.joinSingle(net, channel)
|
|
if not joined:
|
|
return dumps({"success": False, "reason": "could not allocate channel to relay."})
|
|
return dumps({"success": True, "relays": joined})
|
|
|
|
@app.route("/aliases/", methods=["GET"])
|
|
@login_required
|
|
def aliases(self, request):
|
|
alias_list = []
|
|
for num, alias in main.alias.items():
|
|
alias_dup = dict(alias)
|
|
alias_dup["num"] = num
|
|
alias_list.append(alias_dup)
|
|
|
|
return dumps({"aliases": alias_list})
|
|
|
|
@app.route("/aliases/", methods=["POST"])
|
|
@login_required
|
|
def aliases_update(self, request):
|
|
try:
|
|
data = loads(request.content.read())
|
|
except JSONDecodeError:
|
|
return "Invalid JSON"
|
|
for alias, fields in data.items():
|
|
if not alias.isdigit():
|
|
return dumps({"success": False, "reason": "alias not a number."})
|
|
alias = int(alias)
|
|
if alias not in main.alias.keys():
|
|
return dumps({"success": False, "reason": "alias does not exist."})
|
|
if fields:
|
|
for field in fields:
|
|
if field in main.alias[alias]:
|
|
main.alias[alias][field] = fields[field]
|
|
if "emails" in fields:
|
|
if not fields["emails"]:
|
|
main.alias[alias]["emails"] = []
|
|
main.saveConf("alias")
|
|
|
|
return dumps({"success": True})
|
|
|
|
@app.route("/irc/auto/<net>/", methods=["POST"])
|
|
@login_required
|
|
def irc_auto_network(self, request, net):
|
|
if net not in main.network.keys():
|
|
return dumps({"success": False, "reason": "no such net."})
|
|
if 1 in main.network[net].relays.keys():
|
|
return dumps({"success": False, "reason": f"first relay exists on {net}"})
|
|
num, alias = main.network[net].add_relay(1)
|
|
provision.provisionRelay(num, net)
|
|
main.saveConf("network")
|
|
|
|
return dumps({"success": True, "message": f"created relay {num} with alias {alias} on {net}"})
|
|
|
|
@app.route("/irc/list/<net>/", methods=["POST"])
|
|
@login_required
|
|
def irc_list_network(self, request, net):
|
|
if net not in main.network.keys():
|
|
return dumps({"success": False, "reason": "no such net."})
|
|
first_relay = helpers.get_first_relay(net)
|
|
if not first_relay:
|
|
return dumps({"success": False, "reason": f"could not get first relay for {net}"})
|
|
first_relay.list()
|
|
return dumps({"success": True, "message": f"requested list with instance {first_relay.num} of {net}"})
|
|
|
|
@app.route("/irc/list/<net>/", methods=["GET"])
|
|
@login_required
|
|
def get_irc_list_info(self, request, net):
|
|
if net not in main.network.keys():
|
|
return dumps({"success": False, "reason": "no such net."})
|
|
listinfo = chankeep.getListInfo(net)
|
|
return dumps({"success": True, "listinfo": listinfo})
|
|
|
|
@app.route("/irc/msg/<net>/<num>/", methods=["PUT"])
|
|
@login_required
|
|
def irc_send_message(self, request, net, num):
|
|
try:
|
|
data = loads(request.content.read())
|
|
except JSONDecodeError:
|
|
return "Invalid JSON"
|
|
if "msg" not in data:
|
|
return dumps({"success": False, "reason": "no msg."})
|
|
if "channel" not in data:
|
|
return dumps({"success": False, "reason": "no msg."})
|
|
msg = data["msg"]
|
|
channel = data["channel"]
|
|
if net not in main.network.keys():
|
|
return dumps({"success": False, "reason": "no such net."})
|
|
if not num.isdigit():
|
|
return dumps({"success": False, "reason": "invalid num: not a number."})
|
|
num = int(num)
|
|
if num not in main.network[net].relays.keys():
|
|
return dumps({"success": False, "reason": f"no relay {num} on {net}"})
|
|
name = f"{net}{num}"
|
|
if name not in main.IRCPool.keys():
|
|
return dumps({"success": False, "reason": f"relay {num} not on {net}"})
|
|
# We are in a query
|
|
in_query = False
|
|
if "nick" in data:
|
|
nick = data["nick"]
|
|
if nick == channel:
|
|
in_query = True
|
|
else:
|
|
nick = None
|
|
if channel == main.IRCPool[name].nickname or nick == channel:
|
|
in_query = True
|
|
if not nick:
|
|
return dumps({"success": False, "reason": "no nick specified to query"})
|
|
else:
|
|
main.IRCPool[name].sendmsg(nick, msg, in_query=in_query)
|
|
else:
|
|
main.IRCPool[name].sendmsg(channel, msg, in_query=in_query)
|
|
return dumps({"success": True, "message": f"sent message to {channel} on {name}"})
|
|
|
|
@app.route("/irc/nick/<net>/<num>/", methods=["GET"])
|
|
@login_required
|
|
def irc_get_nick(self, request, net, num):
|
|
if net not in main.network.keys():
|
|
return dumps({"success": False, "reason": "no such net."})
|
|
if not num.isdigit():
|
|
return dumps({"success": False, "reason": "invalid num: not a number."})
|
|
num = int(num)
|
|
if num not in main.network[net].relays.keys():
|
|
return dumps({"success": False, "reason": f"no relay {num} on {net}"})
|
|
name = f"{net}{num}"
|
|
if name not in main.IRCPool.keys():
|
|
return dumps({"success": False, "reason": f"relay {num} not on {net}"})
|
|
return dumps({"nickname": main.IRCPool[name].nickname})
|
|
|
|
@app.route("/irc/reg/<net>/", methods=["GET"])
|
|
@login_required
|
|
def irc_get_unreg_net(self, request, net):
|
|
if net not in main.network.keys():
|
|
return dumps({"success": False, "reason": "no such net."})
|
|
unreg = regproc.get_unregistered_relays(net)
|
|
return dumps({"success": True, "unreg": unreg})
|
|
|
|
@app.route("/irc/reg/", methods=["GET"])
|
|
@login_required
|
|
def irc_get_unreg(self, request):
|
|
unreg = regproc.get_unregistered_relays()
|
|
return dumps({"success": True, "unreg": unreg})
|
|
|
|
@app.route("/irc/reg/", methods=["PUT"])
|
|
@login_required
|
|
def irc_confirm_accounts(self, request):
|
|
try:
|
|
data = loads(request.content.read())
|
|
except JSONDecodeError:
|
|
return "Invalid JSON"
|
|
for item, token in data.items():
|
|
if "|" not in item:
|
|
return dumps({"success": False, "reason": f"malformed item: {item}"})
|
|
spl = item.split("|")
|
|
if not len(spl) == 2:
|
|
return dumps({"success": False, "reason": f"malformed item: {item}"})
|
|
net, num = spl
|
|
if not num.isdigit():
|
|
return dumps({"success": False, "reason": "invalid num: not a number."})
|
|
num = int(num)
|
|
if token:
|
|
regproc.confirmAccount(net, num, token)
|
|
return dumps({"success": True})
|
|
|
|
@app.route("/irc/network/<net>/<num>/auth/", methods=["POST"])
|
|
@login_required
|
|
def irc_enable_auth(self, request, net, num):
|
|
if net not in main.network.keys():
|
|
return dumps({"success": False, "reason": "no such net."})
|
|
if not num.isdigit():
|
|
return dumps({"success": False, "reason": "invalid num: not a number."})
|
|
num = int(num)
|
|
if num not in main.network[net].relays.keys():
|
|
return dumps({"success": False, "reason": f"no relay {num} on {net}"})
|
|
regproc.enableAuthentication(net, num, jump=False, run_now=True)
|
|
return dumps({"success": True})
|
|
|
|
@app.route("/irc/sinst/<net>/", methods=["GET"])
|
|
@login_required
|
|
def irc_get_authentity(self, request, net):
|
|
if net not in main.network.keys():
|
|
return dumps({"success": False, "reason": "no such net."})
|
|
auth = regproc.selectInst(net)
|
|
if not auth:
|
|
return dumps({"success": False, "reason": "error getting results."})
|
|
return dumps({"success": True, "sinst": auth})
|