Initial structure for discordbot addition

webapp/titanembeds/database/__init__.py

@@ -0,0 +1,9 @@
+from flask_sqlalchemy import SQLAlchemy
+
+db = SQLAlchemy()
+
+from guilds import Guilds
+from unauthenticated_users import UnauthenticatedUsers
+from unauthenticated_bans import UnauthenticatedBans
+from authenticated_users import AuthenticatedUsers
+from keyvalue_properties import KeyValueProperties, set_keyvalproperty, get_keyvalproperty, getexpir_keyvalproperty, setexpir_keyvalproperty, ifexists_keyvalproperty, delete_keyvalproperty

webapp/titanembeds/database/authenticated_users.py

@@ -0,0 +1,20 @@
+from titanembeds.database import db
+import datetime
+import time
+
+class AuthenticatedUsers(db.Model):
+    __tablename__ = "authenticated_users"
+    id = db.Column(db.Integer, primary_key=True)    # Auto increment id
+    guild_id = db.Column(db.String(255))            # Guild pretaining to the authenticated user
+    client_id = db.Column(db.String(255))           # Client ID of the authenticated user
+    last_timestamp = db.Column(db.TIMESTAMP)        # The timestamp of when the user has last sent the heartbeat
+
+    def __init__(self, guild_id, client_id):
+        self.guild_id = guild_id
+        self.client_id = client_id
+        self.last_timestamp = datetime.datetime.fromtimestamp(time.time()).strftime('%Y-%m-%d %H:%M:%S')
+
+    def bumpTimestamp(self):
+        self.last_timestamp = datetime.datetime.fromtimestamp(time.time()).strftime('%Y-%m-%d %H:%M:%S')
+        db.session.commit()
+        return self.last_timestamp

webapp/titanembeds/database/custom_redislite.py

@@ -0,0 +1,35 @@
+import urlparse
+from limits.storage import Storage
+from redislite import Redis
+import time
+
+class LimitsRedisLite(Storage): # For Python Limits
+    STORAGE_SCHEME = "redislite"
+    def __init__(self, uri, **options):
+        self.redis_instance = Redis(urlparse.urlparse(uri).netloc)
+
+    def check(self):
+        return True
+
+    def get_expiry(self, key):
+        return (self.redis_instance.ttl(key) or 0) + time.time()
+
+    def incr(self, key, expiry, elastic_expiry=False):
+        if not self.redis_instance.exists(key):
+            self.redis_instance.set(key, 1, ex=expiry)
+        else:
+            oldexp = oldexp = self.get_expiry(key) - time.time()
+            if oldexp <= 0:
+                self.redis_instance.delete(key)
+                return self.incr(key, expiry, elastic_expiry)
+            self.redis_instance.set(key, int(self.redis_instance.get(key))+1, ex=int(round(oldexp)))
+        return int(self.get(key))
+
+    def get(self, key):
+        value = self.redis_instance.get(key)
+        if value:
+            return int(value)
+        return 0
+
+    def reset(self):
+        return self.redis_instance.flushdb()

webapp/titanembeds/database/guilds.py

@@ -0,0 +1,19 @@
+from titanembeds.database import db
+
+class Guilds(db.Model):
+    __tablename__ = "guilds"
+    id = db.Column(db.Integer, primary_key=True)    # Auto incremented id
+    guild_id = db.Column(db.String(255))            # Discord guild id
+    unauth_users = db.Column(db.Boolean())          # If allowed unauth users
+
+    def __init__(self, guild_id):
+        self.guild_id = guild_id
+        self.unauth_users = True # defaults to true
+
+    def __repr__(self):
+        return '<Guilds {0} {1}>'.format(self.id, self.guild_id)
+
+    def set_unauthUsersBool(self, value):
+        self.unauth_users = value
+        db.session.commit()
+        return self.unauth_users

webapp/titanembeds/database/keyvalue_properties.py

@@ -0,0 +1,98 @@
+from titanembeds.database import db
+from datetime import datetime, timedelta
+from limits.storage import Storage
+import time
+
+def set_keyvalproperty(key, value, expiration=None):
+    q = db.session.query(KeyValueProperties).filter(KeyValueProperties.key == key)
+    if q.count() == 0:
+        db.session.add(KeyValueProperties(key=key, value=value, expiration=expiration))
+    else:
+        if expiration is not None:
+            converted_expr = datetime.fromtimestamp(time.time() + expiration)
+        else:
+            converted_expr = None
+        firstobj = q.first()
+        firstobj.value = value
+        firstobj.expiration = converted_expr
+    db.session.commit()
+
+def get_keyvalproperty(key):
+    q = db.session.query(KeyValueProperties).filter(KeyValueProperties.key == key)
+    now = datetime.now()
+    if q.count() > 0 and (q.first().expiration is None or q.first().expiration > now):
+        return q.first().value
+    return None
+
+def getexpir_keyvalproperty(key):
+    q = db.session.query(KeyValueProperties).filter(KeyValueProperties.key == key)
+    now = datetime.now()
+    if q.count() > 0 and (q.first().expiration is not None and q.first().expiration > now):
+        return int(q.first().expiration.strftime('%s'))
+    return 0
+
+def setexpir_keyvalproperty(key, expiration=None):
+    q = db.session.query(KeyValueProperties).filter(KeyValueProperties.key == key)
+    if q.count() > 0:
+        if expiration:
+            q.first().expiration = datetime.now()
+        else:
+            q.first().expiration = None
+        db.session.commit()
+
+def ifexists_keyvalproperty(key):
+    q = db.session.query(KeyValueProperties).filter(KeyValueProperties.key == key)
+    return q.count() > 0
+
+def delete_keyvalproperty(key):
+    q = db.session.query(KeyValueProperties).filter(KeyValueProperties.key == key).first()
+    if q:
+        db.session.delete(q)
+        db.session.commit()
+
+class KeyValueProperties(db.Model):
+    __tablename__ = "keyvalue_properties"
+    id = db.Column(db.Integer, primary_key=True)    # Auto incremented id
+    key = db.Column(db.String(255))                 # Property Key
+    value = db.Column(db.Text())                    # Property value
+    expiration = db.Column(db.TIMESTAMP)            # Suggested Expiration for value (None = no expire) in secs
+
+    def __init__(self, key, value, expiration=None):
+        self.key = key
+        self.value = value
+        if expiration:
+            self.expiration = datetime.now() + timedelta(seconds = expiration)
+        else:
+            self.expiration = None
+
+
+class LimitsKeyValueProperties(Storage): # For Python Limits
+    STORAGE_SCHEME = "keyvalprops"
+    def __init__(self, uri, **options):
+        pass
+
+    def check(self):
+        return True
+
+    def get_expiry(self, key):
+        return getexpir_keyvalproperty(key) + time.time()
+
+    def incr(self, key, expiry, elastic_expiry=False):
+        if not ifexists_keyvalproperty(key):
+            set_keyvalproperty(key, 1, expiration=expiry)
+        else:
+            oldexp = getexpir_keyvalproperty(key) - time.time()
+            if oldexp <= 0:
+                delete_keyvalproperty(key)
+                return self.incr(key, expiry, elastic_expiry)
+            set_keyvalproperty(key, int(get_keyvalproperty(key))+1, expiration=int(round(oldexp)))
+        return int(self.get(key))
+
+    def get(self, key):
+        value = get_keyvalproperty(key)
+        if value:
+            return int(value)
+        return 0
+
+    def reset(self):
+        return False

webapp/titanembeds/database/unauthenticated_bans.py

@@ -0,0 +1,33 @@
+from titanembeds.database import db
+import datetime
+import time
+
+class UnauthenticatedBans(db.Model):
+    __tablename__ = "unauthenticated_bans"
+    id = db.Column(db.Integer, primary_key=True)    # Auto increment id
+    guild_id = db.Column(db.String(255))            # Guild pretaining to the unauthenticated user
+    ip_address = db.Column(db.String(255))          # The IP Address of the user
+    last_username = db.Column(db.String(255))       # The username when they got banned
+    last_discriminator = db.Column(db.Integer)      # The discrim when they got banned
+    timestamp = db.Column(db.TIMESTAMP)             # The timestamp of when the user got banned
+    reason = db.Column(db.Text())                   # The reason of the ban set by the guild moderators
+    lifter_id = db.Column(db.String(255))           # Discord Client ID of the user who lifted the ban
+    placer_id = db.Column(db.String(255))           # The id of who placed the ban
+
+    def __init__(self, guild_id, ip_address, last_username, last_discriminator, reason, placer_id):
+        self.guild_id = guild_id
+        self.ip_address = ip_address
+        self.last_username = last_username
+        self.last_discriminator = last_discriminator
+        self.timestamp = datetime.datetime.fromtimestamp(time.time()).strftime('%Y-%m-%d %H:%M:%S')
+        self.reason = reason
+        self.lifter_id = None
+        self.placer_id = placer_id
+
+    def liftBan(self, lifter_id):
+        self.lifter_id = lifter_id
+        db.session.commit()
+        return self.lifter_id
+
+    def __repr__(self):
+        return '<UnauthenticatedBans {0} {1} {2} {3} {4} {5}'.format(self.id, self.guild_id, self.ip_address, self.last_username, self.last_discriminator, self.timestamp)

webapp/titanembeds/database/unauthenticated_users.py

@@ -0,0 +1,46 @@
+from titanembeds.database import db
+import datetime
+import time
+import random
+import string
+
+class UnauthenticatedUsers(db.Model):
+    __tablename__ = "unauthenticated_users"
+    id = db.Column(db.Integer, primary_key=True)    # Auto increment id
+    guild_id = db.Column(db.String(255))            # Guild pretaining to the unauthenticated user
+    username = db.Column(db.String(255))            # The username of the user
+    discriminator = db.Column(db.Integer)           # The discriminator to distinguish unauth users with each other
+    user_key = db.Column(db.Text())                 # The secret key used to identify the user holder
+    ip_address = db.Column(db.String(255))          # The IP Address of the user
+    last_timestamp = db.Column(db.TIMESTAMP)        # The timestamp of when the user has last sent the heartbeat
+    revoked = db.Column(db.Boolean())               # If the user's key has been revoked and a new one is required to be generated
+
+    def __init__(self, guild_id, username, discriminator, ip_address):
+        self.guild_id = guild_id
+        self.username = username
+        self.discriminator = discriminator
+        self.user_key = "".join(random.choice(string.ascii_letters) for _ in range(0, 32))
+        self.ip_address = ip_address
+        self.last_timestamp = datetime.datetime.fromtimestamp(time.time()).strftime('%Y-%m-%d %H:%M:%S')
+        self.revoked = False
+
+    def __repr__(self):
+        return '<UnauthenticatedUsers {0} {1} {2} {3} {4} {5} {6} {7}>'.format(self.id, self.guild_id, self.username, self.discriminator, self.user_key, self.ip_address, self.last_timestamp, self.revoked)
+
+    def isRevoked(self):
+        return self.revoked
+
+    def changeUsername(self, username):
+        self.username = username
+        db.session.commit()
+        return self.username
+
+    def revokeUser(self):
+        self.revoked = True
+        db.session.commit()
+        return self.revoked
+
+    def bumpTimestamp(self):
+        self.last_timestamp = datetime.datetime.fromtimestamp(time.time()).strftime('%Y-%m-%d %H:%M:%S')
+        db.session.commit()
+        return self.last_timestamp