Add patch v0.1.1

Author: 2Cubed

cactus.py

@@ -11,8 +11,6 @@
 from asyncio import get_event_loop, gather, async
 
 from traceback import format_exc
-from time import sleep
-import os
 
 from models import Base, engine
 
@@ -68,19 +66,6 @@ def check_db(self):
     def load_config(self, filename):
         """Load configuration."""
 
-        if os.path.exists('config.json'):
-            self.logger.info("Config file was found. Loading...")
-            with open(filename) as config:
-                self.config = load(config)
-                self.channel_data = self.login(**self.config)
-                self.username = self.channel_data['username']
-        else:
-            self.logger.error("Config file was not found. Creating...")
-            os.system('cp config-template.json config.json')
-            self.logger.info(
-                "Config created. Please enter information, and restart.")
-            exit(0)
-
         if exists(filename):
             self.logger.info("Config file was found. Loading...")
             with open(filename) as config:
@@ -148,5 +133,27 @@ def run(self, *args, **kwargs):
                     self.logger.info("CactusBot deactivated.")
                     exit()
 
-cactus = Cactus(debug=True, autorestart=False)
-cactus.run()
+    def _run(self, *args, **kwargs):
+        """Bot execution code."""
+
+        if self.load_config(filename=self.config_file):
+            auth = {n: self.config[n] for n in ("username", "password")}
+            self.bot_data = self.login(**auth)
+            self.username = self.bot_data["username"]
+            self.bot_id = self.bot_data["id"]
+            self.logger.info("Authenticated as: {}.".format(self.username))
+
+        self.started = True
+
+        self.channel = self.config["channel"]
+        self.channel_data = self.get_channel(self.channel)
+
+        self.logger.info("Channel {ch} (id {id}) is {status}.".format(
+            ch=self.channel_data["token"], id=self.channel_data["id"],
+            status=["offline", "online"][self.channel_data["online"]]
+        ))
+
+
+if __name__ == "__main__":
+    cactus = Cactus(debug="info", autorestart=False)
+    cactus.run()

messages.py

@@ -46,7 +46,7 @@ def message_handler(self, data):
                 "command": CommandCommand,
                 "quote": QuoteCommand,
                 "cube": CubeCommand,
-                "social": SocialCommand,
+                "social": SocialCommand
             }
             if args[0][1:] in commands:
                 yield from self.send_message(

models.py

@@ -210,6 +210,7 @@ def add_points(self, username, amount):
                 amount=amount
             )
             session.add(c)
+            session.commit()
         else:
             # Todo add the user.
             pass
@@ -250,3 +251,12 @@ def reset_points(self, username):
             # TODO: Throw an error and tell the user that sent this bad things
             pass
         session.commit()
+
+
+class Schedule(Base):
+    __tablename__ = "scheduled"
+
+    id = Column(Integer, unique=True, primary_key=True)
+    text = Column(String)
+    interval = Column(Integer)
+    last_ran = Column(DateTime)

user.py

@@ -10,20 +10,20 @@ class User:
 
     def __init__(self, debug="WARNING", **kwargs):
         self._init_logger(debug)
-        print(self.authKey())
+        self.session = Session()
 
     def _init_logger(self, level):
         """Initialize logger."""
 
         self.logger = get_logger('CactusBot')
 
-        level = level.upper()
-
         if level is True:
             level = "DEBUG"
         elif level is False:
             level = "WARNING"
 
+        level = level.upper()
+
         levels = ("CRITICAL", "ERROR", "WARNING", "INFO", "DEBUG", "NOTSET")
         if level in levels:
             level_num = __import__("logging").__getattribute__(level)
@@ -64,37 +64,69 @@ def request(self, req, url, **kwargs):
         else:
             self.logger.debug("Invalid request: {}".format(req))
 
-    def authKey(self):
-        """Get the required authKey from Beam"""
-        return self.request("GET", "/chats/join")
-
     def login(self, username, password, code=''):
         """Authenticate and login with Beam."""
-        return self.request("GET", "/users/login", locals())
+        l = locals()
+        packet = {n: l[n] for n in ("username", "password", "code")}
+        return self.request("POST", "/users/login", data=packet)
 
     def get_channel(self, id, **p):
         """Get channel data by username."""
-        channel = self.request("GET", "/channels/{id}".format(id=id))
-        return channel
+        return self.request("GET", "/channels/{id}".format(id=id), params=p)
+
+    def get_chat(self, id):
+        """Get chat server data."""
+        return self.request("GET", "/chats/{id}".format(id=id))
+
+    def connect(self, channel_id, bot_id):
+        """Connect to a Beam chat through a websocket."""
+
+        chat = self.get_chat(channel_id)
+        server = chat["endpoints"][0]
+        authkey = chat["authkey"]
+
+        self.logger.debug("Connecting to: {server}".format(server=server))
+
+        self.websocket = yield from connect(server)
+
+        response = yield from self.send_message(
+            (channel_id, bot_id, authkey), method="auth"
+        )
+
+        response = loads(response)
+
+        if response["data"]["authenticated"]:
+            self.logger.debug(response)
+            return self.websocket
+        return False
+
+    def send_message(self, arguments, method="msg"):
+        """Send a message to a Beam chat through a websocket."""
+
+        if isinstance(arguments, str):
+            arguments = (arguments,)
 
-    def send_chat(self, id, message):
-        """
-        Send a message for a certain chat
-        Arguments:
-        - id: Channel ID to send message to
-        - message: Chat message to send
-        """
-        # Packet to send to Beam
-        # packet = {t pu}
+        msg_packet = {
+            "type": "method",
+            "method": method,
+            "arguments": arguments,
+            "id": self.message_id
+        }
 
+        yield from self.websocket.send(dumps(msg_packet))
+        self.message_id += 1
 
-class Chatter:
+        return (yield from self.websocket.recv())
 
-    def ban(username):
-        pass
+    def remove_message(self, channel_id, message_id):
+        """Remove a message from chat."""
+        return self.request("DELETE", "/chats/{id}/message/{message}".format(
+            id=channel_id, message=message_id))
 
-    def purge(username):
-        pass
+    def read_chat(self, handle=None):
+        while True:
+            response = loads((yield from self.websocket.recv()))
+            self.logger.debug(response)
 
-    def timeout(username, time):
-        pass
+            if handle:
+                handle(response)