Add user points system

Author: klercke

.vscode/.ropeproject/config.py

@@ -0,0 +1,114 @@
+# The default ``config.py``
+# flake8: noqa
+
+
+def set_prefs(prefs):
+    """This function is called before opening the project"""
+
+    # Specify which files and folders to ignore in the project.
+    # Changes to ignored resources are not added to the history and
+    # VCSs.  Also they are not returned in `Project.get_files()`.
+    # Note that ``?`` and ``*`` match all characters but slashes.
+    # '*.pyc': matches 'test.pyc' and 'pkg/test.pyc'
+    # 'mod*.pyc': matches 'test/mod1.pyc' but not 'mod/1.pyc'
+    # '.svn': matches 'pkg/.svn' and all of its children
+    # 'build/*.o': matches 'build/lib.o' but not 'build/sub/lib.o'
+    # 'build//*.o': matches 'build/lib.o' and 'build/sub/lib.o'
+    prefs['ignored_resources'] = ['*.pyc', '*~', '.ropeproject',
+                                  '.hg', '.svn', '_svn', '.git', '.tox']
+
+    # Specifies which files should be considered python files.  It is
+    # useful when you have scripts inside your project.  Only files
+    # ending with ``.py`` are considered to be python files by
+    # default.
+    # prefs['python_files'] = ['*.py']
+
+    # Custom source folders:  By default rope searches the project
+    # for finding source folders (folders that should be searched
+    # for finding modules).  You can add paths to that list.  Note
+    # that rope guesses project source folders correctly most of the
+    # time; use this if you have any problems.
+    # The folders should be relative to project root and use '/' for
+    # separating folders regardless of the platform rope is running on.
+    # 'src/my_source_folder' for instance.
+    # prefs.add('source_folders', 'src')
+
+    # You can extend python path for looking up modules
+    # prefs.add('python_path', '~/python/')
+
+    # Should rope save object information or not.
+    prefs['save_objectdb'] = True
+    prefs['compress_objectdb'] = False
+
+    # If `True`, rope analyzes each module when it is being saved.
+    prefs['automatic_soa'] = True
+    # The depth of calls to follow in static object analysis
+    prefs['soa_followed_calls'] = 0
+
+    # If `False` when running modules or unit tests "dynamic object
+    # analysis" is turned off.  This makes them much faster.
+    prefs['perform_doa'] = True
+
+    # Rope can check the validity of its object DB when running.
+    prefs['validate_objectdb'] = True
+
+    # How many undos to hold?
+    prefs['max_history_items'] = 32
+
+    # Shows whether to save history across sessions.
+    prefs['save_history'] = True
+    prefs['compress_history'] = False
+
+    # Set the number spaces used for indenting.  According to
+    # :PEP:`8`, it is best to use 4 spaces.  Since most of rope's
+    # unit-tests use 4 spaces it is more reliable, too.
+    prefs['indent_size'] = 4
+
+    # Builtin and c-extension modules that are allowed to be imported
+    # and inspected by rope.
+    prefs['extension_modules'] = []
+
+    # Add all standard c-extensions to extension_modules list.
+    prefs['import_dynload_stdmods'] = True
+
+    # If `True` modules with syntax errors are considered to be empty.
+    # The default value is `False`; When `False` syntax errors raise
+    # `rope.base.exceptions.ModuleSyntaxError` exception.
+    prefs['ignore_syntax_errors'] = False
+
+    # If `True`, rope ignores unresolvable imports.  Otherwise, they
+    # appear in the importing namespace.
+    prefs['ignore_bad_imports'] = False
+
+    # If `True`, rope will insert new module imports as
+    # `from <package> import <module>` by default.
+    prefs['prefer_module_from_imports'] = False
+
+    # If `True`, rope will transform a comma list of imports into
+    # multiple separate import statements when organizing
+    # imports.
+    prefs['split_imports'] = False
+
+    # If `True`, rope will remove all top-level import statements and
+    # reinsert them at the top of the module when making changes.
+    prefs['pull_imports_to_top'] = True
+
+    # If `True`, rope will sort imports alphabetically by module name instead
+    # of alphabetically by import statement, with from imports after normal
+    # imports.
+    prefs['sort_imports_alphabetically'] = False
+
+    # Location of implementation of
+    # rope.base.oi.type_hinting.interfaces.ITypeHintingFactory In general
+    # case, you don't have to change this value, unless you're an rope expert.
+    # Change this value to inject you own implementations of interfaces
+    # listed in module rope.base.oi.type_hinting.providers.interfaces
+    # For example, you can add you own providers for Django Models, or disable
+    # the search type-hinting in a class hierarchy, etc.
+    prefs['type_hinting_factory'] = (
+        'rope.base.oi.type_hinting.factory.default_type_hinting_factory')
+
+
+def project_opened(project):
+    """This function is called after opening the project"""
+    # Do whatever you like here!

.vscode/.ropeproject/objectdb

@@ -36,17 +36,27 @@ def __str__(self):
         return f"{self.username}{{UUID: {self.uuid}, Score: {self.score}, AllowModerator: {self.allowmoderator}, RankExempt: {self.rankexempt}}}"
 
 
-    def changeScore(self, delta):
-        self.score += delta
+    def change_score(self, delta):
+        if (self.score + delta > 0 and self.score + delta < 250):
+            self.score += delta
+        write_database()
         return self.score
 
 
-def addUser(uuid, username, score=0, allowmoderator=True, rankexempt=False):
+def change_all_scores(delta):
+    for user in USERS.values():
+        if (user.score + delta > 0 and user.score + delta < 250):
+            user.score += delta
+    
+    write_database()
+
+
+def add_user(uuid, username, score=0, allowmoderator=True, rankexempt=False):
     newUser = User(uuid, username, score, allowmoderator, rankexempt)
     USERS[uuid] = newUser
 
 
-def writeDatabase():
+def write_database():
     with open('data/users.csv', mode='w', encoding='utf-8') as dataFile:
         fieldnames = ['uuid', 'username', 'score', 'allowmoderator', 'rankexempt']
         writer = csv.DictWriter(dataFile, fieldnames=fieldnames, lineterminator = '\n')
@@ -61,23 +71,23 @@ def writeDatabase():
                 'rankexempt': user.rankexempt})
 
 
-def readDatabase():
-    with open('data/users.csv', mode='r') as dataFile:
+def read_database():
+    with open('data/users.csv', mode='r', encoding='utf-8') as dataFile:
         dataFile = csv.DictReader(dataFile)
         for row in dataFile:
             user = User(int(row['uuid']), row['username'], int(row['score']), bool(row['allowmoderator']), (row['rankexempt']))
             USERS[int(row['uuid'])] = user
 
 
-def printDatabase():
+def print_database():
     for user in USERS.values():
             print(user)
 
 
 def main():
-    readDatabase()
-    printDatabase()
-    writeDatabase()
+    read_database()
+    print_database()
+    write_database()
 
 
 if __name__ == "__main__":

__pycache__/activity.cpython-37.pyc

@@ -30,26 +30,18 @@
 #####################################
 
 
-# Load bot token from .env
-load_dotenv()
-TOKEN = os.getenv('DISCORD_TOKEN')
+#################################
+                                #
+POINTS_PER_MESSAGE = 2          #
+POINTS_PER_MINUTE_TALKING = 1   #
+POINT_DECAY_PER_HOUR = 1        #
+                                #
+#################################
+
 
 # Initialize bot object to use the COMMAND_PREFIX defined above
 bot = commands.Bot(command_prefix=COMMAND_PREFIX)
 
-# Generate timestamp of startup
-timestamp = time.strftime('%Y%m%d-%H%M%S')
-
-# Configure logging
-logging.basicConfig(
-    level = LOG_LEVEL, 
-    format = '%(asctime)s: [%(levelname)s] - %(message)s',
-    datefmt = '%Y-%m-%d %H:%M:%S', 
-    handlers = [
-        logging.FileHandler(f"logs/{timestamp}.log", mode = "w"), 
-        logging.StreamHandler()
-    ]
-)
 
 @bot.event
 async def on_connect():
@@ -75,10 +67,10 @@ async def on_ready():
         label = guild.name + " (" + str(guild.id) + ")"
         logging.info(label)
 
-    activity.readDatabase()
+    activity.read_database()
 
     for guild in bot.guilds:
-        addAllUsersFromGuildToDatabase(guild)
+        add_all_users_from_guild_to_database(guild)
 
 
 @bot.event
@@ -89,6 +81,7 @@ async def on_disconnect():
 
     logging.warning('Lost connection to Discord.')
 
+
 @bot.event
 async def on_guild_join(guild):
     """
@@ -119,10 +112,9 @@ async def on_member_join(member):
     else:
         welcome_message = f"Welcome to {member.guild.name}, {member.name}!"
 
-    await member.dm_channel.send(welcome_message)
-
-
+    add_user_to_database(member.id, member.name)
 
+    await member.dm_channel.send(welcome_message)
 
 
 @bot.event
@@ -143,14 +135,17 @@ async def on_message(message):
     Allows the bot to respond to user messages rather than commands
     """
 
-    if message.author == bot.user:
+    if message.author.bot:
         """
         Tells the bot to ignore its own messages
         """
 
-        return 
+        return
 
-    elif 'happy birthday' in message.content.lower():
+    else:
+        change_user_score(message.author.id, POINTS_PER_MESSAGE)
+
+    if 'happy birthday' in message.content.lower():
         """
         Lets the bot say happy birthday whenever a user says it
         """
@@ -184,38 +179,111 @@ async def on_message(message):
     await bot.process_commands(message)
 
 
-async def run_once_per_day():
+@bot.command(name="score", help="Displays your current server score.")
+async def check_user_score(ctx):
+    uuid = ctx.message.author.id
+    score = get_user_score(uuid)
+
+    # Take away the points the user gets for running the command
+    change_user_score(uuid, -POINTS_PER_MESSAGE)
+
+    await ctx.message.channel.send(f"Score for <@{uuid}>: {score}")
+
+
+async def run_once_every_day():
     """
     Runs a block of code every day sometime between 00:00 and 01:00 local time.
     """
 
-    await bot.wait_until_ready()
-
     if (int(time.strftime('%H', time.localtime())) < 1):
         # This code will run if it is the correct time
         logging.info("Running nightly operations.")
     else:
         logging.debug("Attempted to run daily event out of defined hours.")
 
-    # Check every hour
+
+async def run_once_every_minute():
+    """
+    Runs a block of code every minute
+    """
+
+    await asyncio.sleep(60)
+
+    # Give every user in a voice channel points
+    for guild in bot.guilds:
+        for channel in guild.voice_channels:
+            for user in channel.members:
+                change_user_score(user.id, POINTS_PER_MINUTE_TALKING)
+
+
+async def run_once_every_hour():
+    """
+    Runs a block of code every hour
+    """
+
     await asyncio.sleep(3600)
 
+    # Call the once-each-day function so it can do its check
+    await run_once_every_day()
+
+    activity.change_all_scores(-POINT_DECAY_PER_HOUR)
+
+
+def change_user_score(uuid, delta):
+    if (uuid in activity.USERS.keys()):
+        activity.USERS[uuid].change_score(delta)
+    else:
+        logging.error(f"Attempted to change score of user {uuid} when user is not in database.")
+
 
-def addAllUsersFromGuildToDatabase(guild):
+def get_user_score(uuid):
+    if (uuid in activity.USERS.keys()):
+        return activity.USERS[uuid].score
+    else:
+        logging.error(f"Attempted to get score of user {uuid} when user is not in database.")
+
+
+def add_all_users_from_guild_to_database(guild):
     for user in guild.members:
         if (not user.bot):
-            addUserToDatabase(user.id, user.name)
+            add_user_to_database(user.id, user.name)
 
-    activity.writeDatabase()
+    activity.write_database()
 
 
-def addUserToDatabase(uuid, name, score=0, allowmoderator=True, rankexempt=False):
+def add_user_to_database(uuid, name, score=0, allowmoderator=True, rankexempt=False):
     if (not uuid in activity.USERS.keys()):
-                activity.addUser(uuid, name, score, allowmoderator, rankexempt)
+                activity.add_user(uuid, name, score, allowmoderator, rankexempt)
                 logging.info(f"Registered new user {name} ({uuid}) to database.")
 
-    activity.writeDatabase()
+    activity.write_database()
+
+
+
+
+def main():
+    # Load bot token from .env
+    load_dotenv()
+    TOKEN = os.getenv('DISCORD_TOKEN')
+
+    # Generate timestamp of startup
+    timestamp = time.strftime('%Y%m%d-%H%M%S')
+
+    # Configure logging
+    logging.basicConfig(
+        level = LOG_LEVEL, 
+        format = '%(asctime)s: [%(levelname)s] - %(message)s',
+        datefmt = '%Y-%m-%d %H:%M:%S', 
+        handlers = [
+            logging.FileHandler(f"logs/{timestamp}.log", mode = "w"), 
+            logging.StreamHandler()
+        ]
+    )
+
+    bot.loop.create_task(run_once_every_minute())
+    bot.loop.create_task(run_once_every_hour())
 
+    bot.run(TOKEN)
 
-bot.loop.create_task(run_once_per_day())
-bot.run(TOKEN)
+if __name__ == "__main__":
+    main()