Initiating the bots repository

README.md

@@ -0,0 +1,3 @@
+# bots
+
+All our bots.

logbot/README.md

@@ -0,0 +1,15 @@
+# logbot
+
+A small XMPP bot written in Python (using the slixmpp library) that logs all images and messages with the mentioning of *@bot* to an HTML page, to allow collaborative log writing over time.
+
+To run it: 
+
+	$ python3 logbot.py
+
+Dependencies: 
+
+	$ sudo pip3 install slixmpp beautifulsoup4
+
+---
+
+That's all for now!

logbot/logbot.py

@@ -0,0 +1,218 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+# To run this bot:
+# $ python3 logbot.py
+# The output folder of this bot currently is: /var/www/logs/digital-autonomy
+
+import logging
+from getpass import getpass
+from argparse import ArgumentParser
+
+import slixmpp
+import ssl, os, requests, urllib
+
+class MUCBot(slixmpp.ClientXMPP):
+	"""
+	A simple Slixmpp bot that will save images
+	and messages that are marked with @bot to a folder.
+	"""
+
+	def __init__(self, jid, password, room, nick, output):
+		slixmpp.ClientXMPP.__init__(self, jid, password)
+
+		self.room = room
+		self.nick = nick
+		self.output = output
+
+		# The session_start event will be triggered when
+		# the bot establishes its connection with the server
+		# and the XML logs are ready for use. We want to
+		# listen for this event so that we we can initialize
+		# our roster.
+		self.add_event_handler("session_start", self.start)
+
+		# The groupchat_message event is triggered whenever a message
+		# stanza is received from any chat room. If you also also
+		# register a handler for the 'message' event, MUC messages
+		# will be processed by both handlers.
+		self.add_event_handler("groupchat_message", self.muc_message)
+
+
+	def start(self, event):
+		self.get_roster()
+		self.send_presence()
+
+		# https://xmpp.org/extensions/xep-0045.html
+		self.plugin['xep_0045'].join_muc(self.room,
+										 self.nick,
+										 # If a room password is needed, use:
+										 # password=the_room_password,
+										 wait=True)
+
+		# Send a message to the room
+		self.send_message(mto=self.room, mbody='Hello! Logbot here. I\'m here to log all the images that are send to this group. You can also log text messages, by including @bot in your message. Happy logging! PS. you can access the logs at https://vvvvvvaria.org/logs/', mtype='groupchat')
+
+	def muc_message(self, msg):
+		# Some inspection commands
+		#print('Message: {}'.format(msg))
+
+		# Always check that a message is not the bot itself, otherwise you will create an infinite loop responding to your own messages.
+		if msg['mucnick'] != self.nick:
+
+			# Check if output folder exists
+			if not os.path.exists(self.output):
+				os.mkdir(self.output)
+
+			# Check if an OOB URL is included in the stanza (which is how an image is sent)
+			# (OOB object - https://xmpp.org/extensions/xep-0066.html#x-oob)
+			if len(msg['oob']['url']) > 0:
+
+				# Send a reply
+				self.send_message(mto=self.room,
+								  mbody="Super, our log is growing. Your image is added!",
+								  mtype='groupchat')
+
+				# Save the image to the output folder
+				url = msg['oob']['url'] # grep the url in the message
+				filename = os.path.basename(url) # grep the filename in the url
+				output_path = os.path.join(self.output, filename)
+				u = urllib.request.urlopen(url) # read the image data
+				f = open(output_path, 'wb') # open the output file
+				f.write(u.read()) # write image to file
+				f.close() # close the output file
+
+				# Add the image to the log
+				img = '<img class="image" src="{}">'.format(filename)
+				log = 'log.html'
+				log_path = os.path.join(self.output, log)
+				f = open(log_path, 'a+')
+				f.write(img+'\n')
+				f.close()
+
+
+			# Include messages in the log (only when '@bot' is used in the message)
+			if '@bot' in msg['body']:
+
+				# reply from the bot
+				self.send_message(mto=self.room,
+								  mbody="Noted! And added to the log. Thanks {}!".format(msg['mucnick']),
+								  mtype='groupchat')
+
+				# Add the message to the log!
+				message = '<p class="message">{}</p>'.format(msg['body'].replace('@bot',''))
+				log = 'log.html'
+				log_path = os.path.join(self.output, log)
+				f = open(log_path, 'a+')
+				f.write(message+'\n')
+				f.close()
+
+				if '/book' in msg['body']: # Check if this is a book ...
+
+					self.send_message(mto=self.room,
+									  mbody="Oh a book, that's cool! Thanks {}!".format(msg['mucnick']),
+									  mtype='groupchat')
+
+					# Start of book feature
+					from bs4 import BeautifulSoup
+					import re
+
+					book = msg['body'].replace('@bot', '').replace('/book', '')
+					book = re.sub(' +', ' ', book) # remove double spaces
+					book = book.lstrip().rstrip() # remove spaces at the beginning and at the end
+					book = book.replace(' ', '+').lower() # turn space into + and lowercase
+
+					page_link = 'https://www.worldcat.org/search?q={}&qt=results_page'.format(book)
+
+					page_response = requests.get(page_link, timeout=5)
+
+					page_content = BeautifulSoup(page_response.content, "html.parser")
+
+					try:
+						book_title = page_content.findAll("div", {"class": "name"})[0].text
+						book_author = page_content.findAll("div", {"class": "author"})[0].text
+						book_publisher = page_content.findAll("div", {"class": "publisher"})[0].text
+
+						response = '<b>BOOK</b>: ' + book_title + ' ' + book_author + ' ' + book_publisher
+
+						book_found = True
+
+					except IndexError:
+
+						book_found = False
+
+					if book_found:
+
+						# Add message to log
+						message = '<b>BOOK</b>: ' + book_title + ' ' + book_author + ' ' + book_publisher
+						log = 'log.html'
+						log_path = os.path.join(self.output, log)
+						f = open(log_path, 'a+')
+						f.write(message+'\n')
+						f.close()
+
+						self.send_message(mto=self.room, mbody='Hope this was the book you were looking for: ' + book_title + ' ' + book_author + ' ' + book_publisher, mtype='groupchat')
+
+					else:
+
+						self.send_message(mto=self.room, mbody='Sorry, no book found!', mtype='groupchat')
+
+
+
+
+if __name__ == '__main__':
+	# Setup the command line arguments.
+	parser = ArgumentParser()
+
+	# output verbosity options.
+	parser.add_argument("-q", "--quiet", help="set logging to ERROR",
+						action="store_const", dest="loglevel",
+						const=logging.ERROR, default=logging.INFO)
+	parser.add_argument("-d", "--debug", help="set logging to DEBUG",
+						action="store_const", dest="loglevel",
+						const=logging.DEBUG, default=logging.INFO)
+
+	# JID and password options.
+	parser.add_argument("-j", "--jid", dest="jid",
+						help="JID to use")
+	parser.add_argument("-p", "--password", dest="password",
+						help="password to use")
+	parser.add_argument("-r", "--room", dest="room",
+						help="MUC room to join")
+	parser.add_argument("-n", "--nick", dest="nick",
+						help="MUC nickname")
+
+	# output folder for images
+	parser.add_argument("-o", "--output", dest="output",
+						help="output folder, this is where the files are stored",
+						type=str)
+
+	args = parser.parse_args()
+
+	# Setup logging.
+	logging.basicConfig(level=args.loglevel,
+						format='%(levelname)-8s %(message)s')
+
+	if args.jid is None:
+		args.jid = input("XMPP address: ")
+	if args.password is None:
+		args.password = getpass("Password: ")
+	if args.room is None:
+		args.room = input("MUC room: ")
+	if args.nick is None:
+		args.nick = input("MUC nickname: ")
+	if args.output is None:
+		args.output = input("Output folder: ")
+
+	# Setup the MUCBot and register plugins. Note that while plugins may
+	# have interdependencies, the order in which you register them does
+	# not matter.
+	xmpp = MUCBot(args.jid, args.password, args.room, args.nick, args.output)
+	xmpp.register_plugin('xep_0030') # Service Discovery
+	xmpp.register_plugin('xep_0045') # Multi-User Chat
+	xmpp.register_plugin('xep_0199') # XMPP Ping
+	xmpp.register_plugin('xep_0066') # Process URI's (files, images)
+
+	# Connect to the XMPP server and start processing XMPP stanzas.
+	xmpp.connect()
+	xmpp.process()

xmpp.streambot/README.md

@@ -0,0 +1,38 @@
+# xmpp.streambot
+
+This is the home of Varia's xmpp.streambot!
+
+When the streambot is listening ... it saves all images that are sent to the muc members@muc.vvvvvvaria.org and streams them to [vvvvvvaria.org/stream/](https://vvvvvvaria.org/stream/).
+
+*archivist.py* was written by Ruben van der Ven during Relearn 2017.
+
+*streambot.py* is based on *archivist.py*. It is a custom Varia bot that will communicate one day with our Pelican plugins-custom/stream plugin. :)
+
+
+# run streambot on the server
+
+To start the streambot: 
+
+	sudo systemctl start streambot.service
+
+To check its status:
+
+	sudo systemctl status streambot.service
+
+To stop it: 
+
+	sudo systemctl stop streambot.service
+
+Error logs go to:
+
+	sudo journalctl -xe
+
+
+# git hooks (disabled at the moment)
+
+There are git-hooks enabled that will stop and (re)start streambot on every commit. 
+
+**pre-receive**: streambot is stopped
+
+**post-update**: the repository is updated with a pull, streambot is started
+

xmpp.streambot/streambot.py

@@ -0,0 +1,258 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+"""
+	Slixmpp: The Slick XMPP Library
+	Copyright (C) 2010  Nathanael C. Fritz
+	This file is part of Slixmpp.
+
+	See the file LICENSE for copying permission.
+"""
+
+# Code source: https://git.poez.io/slixmpp/tree/examples/muc.py
+
+# To run this script (local):
+# $ python3 streambot.py -j streambot@vvvvvvaria.org -p slowstreaming -r test@muc.vvvvvvaria.org -n streambot -o ./stream/
+
+
+import logging
+from getpass import getpass
+from argparse import ArgumentParser
+
+import slixmpp
+
+import ssl, os, requests, urllib
+
+#we will reactivate
+class MUCBot(slixmpp.ClientXMPP):
+
+	"""
+	A simple Slixmpp bot that will greets those
+	who enter the room, and acknowledge any messages
+	that mentions the bot's nickname.
+	"""
+
+	def __init__(self, jid, password, room, nick, output):
+		slixmpp.ClientXMPP.__init__(self, jid, password)
+
+		self.room = room
+		self.nick = nick
+		self.datadir = output
+
+		# The session_start event will be triggered when
+		# the bot establishes its connection with the server
+		# and the XML streams are ready for use. We want to
+		# listen for this event so that we we can initialize
+		# our roster.
+		self.add_event_handler("session_start", self.start)
+
+		# The groupchat_message event is triggered whenever a message
+		# stanza is received from any chat room. If you also also
+		# register a handler for the 'message' event, MUC messages
+		# will be processed by both handlers.
+		self.add_event_handler("groupchat_message", self.muc_message)
+
+		# The groupchat_presence event is triggered whenever a
+		# presence stanza is received from any chat room, including
+		# any presences you send yourself. To limit event handling
+		# to a single room, use the events muc::room@server::presence,
+		# muc::room@server::got_online, or muc::room@server::got_offline.
+		# self.add_event_handler("muc::{}::got_online".format(self.room), self.muc_online)
+
+
+	def start(self, event):
+		"""
+		Process the session_start event.
+
+		Typical actions for the session_start event are
+		requesting the roster and broadcasting an initial
+		presence stanza.
+
+		Arguments:
+			event -- An empty dictionary. The session_start
+					 event does not provide any additional
+					 data.
+		"""
+		self.get_roster()
+		self.send_presence()
+		self.plugin['xep_0045'].join_muc(self.room,
+										 self.nick,
+										 # If a room password is needed, use:
+										 # password=the_room_password,
+										 wait=True)
+
+		self.register_plugin('xep_0066') # To send URI's (files, images)
+								# Needed to work with images
+								# This makes slixmpp understand an OOB object - https://xmpp.org/extensions/xep-0066.html#x-oob
+
+	def muc_message(self, msg):
+		"""
+		Process incoming message stanzas from any chat room. Be aware
+		that if you also have any handlers for the 'message' event,
+		message stanzas may be processed by both handlers, so check
+		the 'type' attribute when using a 'message' event handler.
+
+		Whenever the bot's nickname is mentioned, respond to
+		the message.
+
+		IMPORTANT: Always check that a message is not from yourself,
+				   otherwise you will create an infinite loop responding
+				   to your own messages.
+
+		This handler will reply to messages that mention
+		the bot's nickname.
+
+		Arguments:
+			msg -- The received message stanza. See the documentation
+				   for stanza objects and the Message stanza to see
+				   how it may be used.
+		"""
+
+		# some inspection commands
+		# print('\nMessage:{}'.format(msg))
+		# print('\nMessage TYPE:{}'.format(msg['type']))
+		# print('\nMessage body:{}'.format(msg['body']))
+		# print('\nMessage OOB:{}'.format(msg['oob']))
+		# print('\nMessage OOB URL:{}'.format(msg['oob']['url']))
+		# print('\nMessage MUCK NICK:{}'.format(msg['mucnick']))
+
+		# Always check that a message is not the bot itself, otherwise you will create an infinite loop responding to your own messages.
+		if msg['mucnick'] != self.nick:
+
+			# publish images
+			if len(msg['oob']['url']) > 0:
+
+				# reply from the bot
+				self.send_message(mto=msg['from'].bare,
+								  mbody="I'll stream that image further, {}.".format(msg['mucnick']),
+								  mtype='groupchat')
+				
+				# save image to folder
+				url = msg['oob']['url']
+				filename = os.path.basename(url)
+				targetDir = self.datadir
+
+				if not os.path.exists(targetDir):
+					os.mkdir(targetDir, '0755')
+
+				targetFile = os.path.join(targetDir, filename)
+
+				# needed to disable certificate validation, when we work in a local network:
+				# ctx = ssl.create_default_context()
+				# ctx.check_hostname = False
+				# ctx.verify_mode = ssl.CERT_NONE
+
+				# write image to file
+				# u = urllib.request.urlopen(url, context=ctx) # use this line when SSL needs to be disabled
+				u = urllib.request.urlopen(url)
+				f = open(targetFile, 'wb')
+				f.write(u.read())
+				f.close()
+
+				# add image to the stream markdown log
+				stream_update = '![An image sent over XMPP]({})'.format(targetFile)
+
+				filename = 'stream.md'
+				targetFile = os.path.join(targetDir, filename)
+				
+				f = open(targetFile, 'a+')
+				f.write(stream_update+'\n\n')
+				f.close()
+
+			# publish regular messages (only when '#publish' is used in the message)
+			if '#stream' in msg['body']:
+
+				# reply from the bot
+				self.send_message(mto=msg['from'].bare,
+								  mbody="I'll stream that further, {}.".format(msg['mucnick']),
+								  mtype='groupchat')
+
+				# add message to the stream markdown log
+				stream_update = msg['body']
+
+				targetDir = self.datadir
+				if not os.path.exists(targetDir):
+					os.mkdir(targetDir, '0755')
+
+				filename = 'stream.md'
+				targetFile = os.path.join(targetDir, filename)
+
+				f = open(targetFile, 'a+')
+				f.write(stream_update+'\n\n')
+				f.close()
+
+
+	# def muc_online(self, presence):
+	# 	"""
+	# 	Process a presence stanza from a chat room. In this case,
+	# 	presences from users that have just come online are
+	# 	handled by sending a welcome message that includes
+	# 	the user's nickname and role in the room.
+
+	# 	Arguments:
+	# 		presence -- The received presence stanza. See the
+	# 					documentation for the Presence stanza
+	# 					to see how else it may be used.
+	# 	"""
+	# 	if presence['muc']['nick'] != self.nick and presence['muc']['nick'] != '':
+	# 		self.send_message(mto=presence['from'].bare,
+	# 						  mbody="Hello, {} {}".format(presence['muc']['role'], presence['muc']['nick']),
+	# 						  mtype='groupchat')
+
+
+if __name__ == '__main__':
+	# Setup the command line arguments.
+	parser = ArgumentParser()
+
+	# Output verbosity options.
+	parser.add_argument("-q", "--quiet", help="set logging to ERROR",
+						action="store_const", dest="loglevel",
+						const=logging.ERROR, default=logging.INFO)
+	parser.add_argument("-d", "--debug", help="set logging to DEBUG",
+						action="store_const", dest="loglevel",
+						const=logging.DEBUG, default=logging.INFO)
+
+	# JID and password options.
+	parser.add_argument("-j", "--jid", dest="jid",
+						help="JID to use")
+	parser.add_argument("-p", "--password", dest="password",
+						help="password to use")
+	parser.add_argument("-r", "--room", dest="room",
+						help="MUC room to join")
+	parser.add_argument("-n", "--nick", dest="nick",
+						help="MUC nickname")
+
+	# Output directory for images
+	parser.add_argument("-o", "--output", dest="output", 
+						help="Output folder, this is where the material is stored", 
+						default="./stream/", type=str)
+
+	args = parser.parse_args()
+
+	# Setup logging.
+	logging.basicConfig(level=args.loglevel,
+						format='%(levelname)-8s %(message)s')
+
+	if args.jid is None:
+		args.jid = input("Username: ")
+	if args.password is None:
+		args.password = getpass("Password: ")
+	if args.room is None:
+		args.room = input("MUC room: ")
+	if args.nick is None:
+		args.nick = input("MUC nickname: ")
+	if args.output is None:
+		args.output = input("Directory where the material can be stored: ")
+
+	# Setup the MUCBot and register plugins. Note that while plugins may
+	# have interdependencies, the order in which you register them does
+	# not matter.
+	xmpp = MUCBot(args.jid, args.password, args.room, args.nick, args.output)
+	xmpp.register_plugin('xep_0030') # Service Discovery
+	xmpp.register_plugin('xep_0045') # Multi-User Chat
+	xmpp.register_plugin('xep_0199') # XMPP Ping
+
+	# Connect to the XMPP server and start processing XMPP stanzas.
+	xmpp.connect()
+	xmpp.process()
+

xmpp.streambot/streambot.sleekxmpp.py

@@ -0,0 +1,132 @@
+import logging
+
+import argparse
+from sleekxmpp import ClientXMPP
+from sleekxmpp.exceptions import IqError, IqTimeout
+import os, subprocess
+import urllib.request
+import datetime
+import ssl
+from PIL import Image
+from pprint import pprint
+
+# python3 streambot.py -j streambot@vvvvvvaria.org -p ******* -m test@muc.vvvvvvaria.org -o ./stream/
+
+# rewrite script to work with slixmpp >>> https://slixmpp.readthedocs.io/getting_started/muc.html
+
+parser = argparse.ArgumentParser()
+parser.add_argument("-j", "--jid", help="jabber identifier", type=str, required=True)
+parser.add_argument("-p", "--password", help="password", type=str, required=True)
+parser.add_argument("-m", "--muc", help="destination muc", type=str, required=True)
+parser.add_argument("-n", "--nick", help="nickname of the bot", default="streambot", type=str)
+parser.add_argument("-o", "--output", help="output folder", default="./stream/", type=str)
+args = parser.parse_args()
+
+# This was a useful tutorial: http://sleekxmpp.com/getting_started/echobot.html#echobot
+
+class ArchivistBot(ClientXMPP):
+
+	def __init__(self, jid, password, room, nick, output):
+		ClientXMPP.__init__(self, jid, password)
+
+		self.datadir = output
+		self.room = room
+		self.nick = nick
+
+		self.add_event_handler("session_start", self.session_start) 
+		self.add_event_handler("message", self.archive_msg) # by using 'message' instead of 'groupchat_message' every message received can be archived (also personal msgs)
+		
+		# self.add_event_handler("groupchat_message", self.archive_msg2)
+
+		self.register_plugin('xep_0045')
+		self.register_plugin('xep_0030')
+		self.register_plugin('xep_0084')
+		self.register_plugin('xep_0096') # Transfer files..
+		self.register_plugin('xep_0066') # Transfer files..
+
+	def session_start(self, event):
+		roster = self.get_roster()
+		print('\nRoster:', roster)
+
+		self.send_presence()
+
+		self.plugin['xep_0045'].joinMUC(self.room, self.nick) # MUC plugin
+
+		with open('avatar.png', 'rb') as avatar_file:
+			avatar = avatar_file.read()
+		avatar_id = self['xep_0084'].generate_id(avatar)
+		info = {
+			'id': avatar_id,
+			'type': 'image/png',
+			'bytes': len(avatar)
+			}
+		self['xep_0084'].publish_avatar(avatar)
+		self['xep_0084'].publish_avatar_metadata(items=[info])
+
+		# XEP-0153: vCard-Based Avatars
+		# Not working ATM
+
+		self['xep_0153'].set_avatar(avatar=avatar, mtype='image/png')
+
+	def archive_msg(self, msg):
+		print('\nMessage:{}'.format(msg))
+		print('\nMessage TYPE:{}'.format(msg['type']))
+		print('\nMessage OOB:{}'.format(msg['oob']))
+		print('\nMessage OOB URL:{}'.format(msg['oob']['url']))
+		print('\nMessage MUCK NICK:{}'.format(msg['mucnick']))
+
+		# Always check that a message is not the bot itself, otherwise you will create an infinite loop responding to your own messages.
+		if msg['mucnick'] != self.nick:
+
+			if msg['type'] in ('groupchat', 'normal'):
+
+				# only works if messages are not encrypted
+				if len(msg['oob']['url']) > 0:
+
+					# logging.getLogger().debug("received OOB from %s with %s" % (self.nick, msg['oob']['url']))
+
+					filename = os.path.basename(msg['oob']['url'])
+					targetDir = self.datadir
+					if not os.path.exists(targetDir):
+						os.mkdir(targetDir, '0755')
+
+					targetFile = os.path.join(targetDir, filename)
+					print('\n targetFile', targetFile)
+
+					#needed to disable certificate validation:
+					ctx = ssl.create_default_context()
+					ctx.check_hostname = False
+					ctx.verify_mode = ssl.CERT_NONE
+
+					# save image to file
+					# urllib.request.urlretrieve(msg['oob']['url'], targetFile, context=ctx)
+					# with urllib.request.urlopen(msg['oob']['url'], context=ctx) as u, \
+						# open(targetFile, 'w+') as f:
+							# f.write(u.read())
+							# f.close()
+					
+					# Download the file from `url` and save it locally under `file_name`:
+					with urllib.request.urlopen(msg['oob']['url']) as response:
+						data = response.read() # a `bytes` object
+						f = open(targetFile, 'wb')
+						f.write(data)
+					logging.getLogger().debug("saved to %s" % targetFile)
+
+					# subprocess.call(["make","publish"], cwd="/srv/gitea/clones/varia.website/")
+
+				msg.reply("Thanks for sending! I will store that for you." % msg).send() # works! also for omemo messages, but it cannot decrypt them.
+
+
+
+if __name__ == '__main__':
+	# Ideally use optparse or argparse to get JID,
+	# password, and log level.
+
+	logging.basicConfig(level=logging.DEBUG, format='%(levelname)-8s %(message)s')
+	
+	client = ArchivistBot(args.jid, args.password, args.muc, args.nick, args.output)
+
+	if client.connect():
+		client.process(block=True)
+	else:
+		logging.getLogger().error("Can't connect.")