databaseMethods.py

# Handles methods for the database
import csv
from re import search
from unicodedata import name
import uuid
from statisticMethods import calculateXP, sortUsersOnLeaderBoard
import datetime
from encryption import readKey, encrypt, decrypt
from sendEmail import sendEmail
from urllib.parse import quote
import hashlib

key = readKey()

def generateNewID (fileToRead) :
    highestID = 0

    # For every line in the file, if the ID is bigger than the highest ID, set the highestID to the ID found
    with open(fileToRead, 'r') as file:
        if file == "" :
            return 1
        else:
            for line in file:
                if len(line) != 1 :
                    # The first collum will be the ID
                    if int(line.split(",")[0]) > highestID:
                        highestID = int(line.split(",")[0])

    # The new user ID is 1 bigger than the highest ID used
    return highestID + 1

# Add a user to the database
def addUserToDatabase(username, password, email) :
    # Generate a unique user ID
    userID = generateNewID("database/users.csv")

    with open("database/users.csv", "a") as csvfile:
        csvwriter = csv.writer(csvfile) 
        csvwriter.writerow([userID, username, password, "0", "0", "0", email])
        csvfile.close()


# Find a user by their username(1st position in csv file starting from 0) or password (2nd position in csv file)
def searchUsers(searchTerm, collumn, useEncryption) :
    matchFound = False

    # For every line in users.csv
    with open("database/users.csv", "r") as csvfile:
        csvreader = csv.reader(csvfile)
        for line in csvreader:
            # If the collumn(th) position of the array line = searchTerm (If search term found)
            if (len(line) != 0) :
                print (decrypt(line[collumn], key))
                if useEncryption == True:
                    if (decrypt(line[collumn], key) == searchTerm) :
                        matchFound = True
                        csvfile.close()
                        # Return the line found
                        return line
                elif (line[collumn] == searchTerm) :
                    matchFound = True
                    csvfile.close()
                    # Return the line found
                    return line

    # If no match found
    if (matchFound == False) :
        csvfile.close()
        return "False"


# Find a chatroom detail by the chatroomName
def locateChatroomCollumn(searchTerm, collumn) :
    matchFound = False

    # For every line in users.csv
    with open("database/chatrooms.csv", "r") as csvfile:
        csvreader = csv.reader(csvfile)
        for line in csvreader:
            # If the collumn(th) position of the array line = searchTerm (If search term found)
            if (line[collumn] == searchTerm) :
                matchFound = True
                csvfile.close()
                # Return the line found
                return line

    # If no match found
    if (matchFound == False) :
        csvfile.close()
        return "False"

def createChatroom(name, language, username, chatroomType) :
    # Generate a unique chatroom ID
    chatroomID = generateNewID("database/chatrooms.csv")

    # Find the user's userID from their username - we can assume that the userID will be found since the username is passed from a cookie, only created if a user has successfully logged in and thus 
    # has their details uploaded to the users.csv file
    userID = searchUsers(username, 1, True)[0]

    #Add the user to the chatroomUsers.csv file
    with open("database/chatroomUsers.csv", "a") as csvfile:
        csvwriter = csv.writer(csvfile)
        csvwriter.writerow([userID, chatroomID])
        csvfile.close()

    # Add the database to the chatrooms.csv file:
    with open("database/chatrooms.csv", "a") as csvfile:
        csvwriter = csv.writer(csvfile)
        csvwriter.writerow([chatroomID, language, name, chatroomType])
        csvfile.close()

# Find the chatrooms which username has joined
def findChatroomsJoined(username) :
    chatroomsJoined = []
    ChatroomDetails = []

    #  Convert username to a userID
    userID = searchUsers(username, 1, True)[0]

    # Search chatroomUsers.csv to find all the chatrooms which userID has joined
    with open("database/chatroomUsers.csv", "r") as csvfile:
        # For every line in the csv file
        csvreader = csv.reader(csvfile)
        for line in csvreader:
            if (line[0] == userID) :
                # Append the database ID to databases joined
                chatroomsJoined.append(line[1])
        csvfile.close()

    # Find the name and language of every chatroom in chatroomsJoined
    with open("database/chatrooms.csv", "r") as csvfile:
        # For every line in the file:
        csvreader = csv.reader(csvfile)
        for line in csvreader:
            # Look at every chatroomID in chatroomsJoined
            for chatroom in range (0, len(chatroomsJoined)):
                # If the line in chatrooms.csv being viewed describes a database which the user has joined
                if (line[0] == chatroomsJoined[chatroom]) :
                    # Append the name and language of the chatroom to chatroom details
                    ChatroomDetails.append(line[1])
                    ChatroomDetails.append(line[2])
    
    return ChatroomDetails

def searchChatrooms() :
    # Get an array of all the chatrooms which have been created
    chatrooms = []

    # Open the file in read mode
    with open("database/chatrooms.csv", "r") as csvfile:
        csvreader = csv.reader(csvfile)
        # For each line in the file
        for line in csvreader :
            # Add the chatroom name
            chatrooms.append(line[2])
    return chatrooms

# Return a list of all the chatrooms which have not been joined by the user
def findPublicChatroomsNotJoinedByUser(username) :
    chatroomIDs = []
    chatroomNames = []
    chatroomsJoined = []

    #  Convert username to a userID
    userID = searchUsers(username, 1, True)[0]

    # Search chatroomUsers.csv to find all the chatrooms which userID has joined
    with open("database/chatroomUsers.csv", "r") as csvfile:
        # For every line in the csv file
        csvreader = csv.reader(csvfile)
        for line in csvreader:
            if (line[0] == userID):
                # Append the database ID to databases joined
                chatroomsJoined.append(line[1])
        csvfile.close()

    # Open the file in read mode
    # chatroomUsers.csv is stored as userID, chatroomID
    with open("database/chatrooms.csv", "r") as csvfile:
        csvreader = csv.reader(csvfile)
        # For each line in the file
        for line in csvreader :
            chatroomIsAlreadyAdded = False

            # If the chatroom has not already been added
            for i in range(0, len(chatroomIDs)) :
                if chatroomIDs[i] == line[0] :
                    chatroomIsAlreadyAdded = True

            if chatroomIsAlreadyAdded == False:
                # If it is not owned by the user
                chatroomAlreadyJoined = False
                for x in range(0, len(chatroomsJoined)) :
                    if line[0] == chatroomsJoined[x] :
                        chatroomAlreadyJoined = True
                
                if chatroomAlreadyJoined == False:
                    # Add the chatroom ID
                    if line[3] == "public" :
                        chatroomIDs.append(line[0])
                        chatroomNames.append(line[2])

    return chatroomNames

# Return a list of all the chatrooms which have not been joined by the user
def findPrivateChatroomsNotJoinedByUser(username) :
    chatroomIDs = []
    chatroomNames = []
    chatroomsJoined = []

    #  Convert username to a userID
    userID = searchUsers(username, 1, True)[0]

    # Search chatroomUsers.csv to find all the chatrooms which userID has joined
    with open("database/chatroomUsers.csv", "r") as csvfile:
        # For every line in the csv file
        csvreader = csv.reader(csvfile)
        for line in csvreader:
            if (line[0] == userID):
                # Append the database ID to databases joined
                chatroomsJoined.append(line[1])
        csvfile.close()

    # Open the file in read mode
    # chatroomUsers.csv is stored as userID, chatroomID
    with open("database/chatrooms.csv", "r") as csvfile:
        csvreader = csv.reader(csvfile)
        # For each line in the file
        for line in csvreader :
            chatroomIsAlreadyAdded = False

            # If the chatroom has not already been added
            for i in range(0, len(chatroomIDs)) :
                if chatroomIDs[i] == line[0] :
                    chatroomIsAlreadyAdded = True

            if chatroomIsAlreadyAdded == False:
                # If it is not owned by the user
                chatroomAlreadyJoined = False
                for x in range(0, len(chatroomsJoined)) :
                    if line[0] == chatroomsJoined[x] :
                        chatroomAlreadyJoined = True
                
                if chatroomAlreadyJoined == False:
                    # Add the chatroom ID
                    if line[3] == "private" :
                        chatroomIDs.append(line[0])
                        chatroomNames.append(line[2])

    return chatroomNames

def addUserToChatroom (username, chatroomName) :
    #  Convert username to the userID
    userID = searchUsers(username, 1, True)[0]

    # Convert chatroom name to the chatroomID
    chatroomID = locateChatroomCollumn(chatroomName, 2)[0]

    # Add the userID and chatroomID to the chatroomUsers.csv file
    with open("database/chatroomUsers.csv", "a") as csvfile:
        csvwriter = csv.writer(csvfile)
        csvwriter.writerow([userID, chatroomID])
        csvfile.close()

# Add an amount of xp to a user's profile
# note in users.csv, element 3 = total xp and element 4 is streak length, and element 5 is the xp for the given week
def addXPToUser(XP, user) :
    #  Convert username to a userID
    userID = searchUsers(user, 1, True)[0]
    userDetails = [[]]

    # For every line in users.csv
    with open("database/users.csv", "r") as csvfile:
        csvreader = csv.reader(csvfile)
        for line in csvreader:
            #If the line is not blank
            if (len(line) != 0) :
                # If the current line contains the information for user
                if (line[0] == userID) :
                    # Add XP to the current XP value
                    line[3] = str(int(line[3]) + XP)
                    # Also add xp to the weekly xp value
                    line[5] = str(int(line[5]) + XP)
                    userDetails.append(line)
                else :
                    userDetails.append(line)
    csvfile.close()

    # Replace users.csv with the new edited data in userDetails
    with open("database/users.csv", "w") as csvfile:
        csvwriter = csv.writer(csvfile)
        for i in range(0, len(userDetails)):
            csvwriter.writerow(userDetails[i])
    csvfile.close()

# Uploads a message to chatroommessages.csv
def uploadMessage(message, chatroomName, user) :
    # Convert chatroom name to the chatroomID
    chatroomID = locateChatroomCollumn(chatroomName, 2)[0]

    messagesList = [[]]
    i = 0

    xpGained = calculateXP(message)
    addXPToUser(xpGained, user)

    # Messages are in the format: chatroomID, message
    # Save the file to memerory
    with open("database/chatroomMessages.csv", "r") as csvfile:
        csvreader = csv.reader(csvfile)
        # For each line in the file
        for line in csvreader :
            # If line does not equal nothing
            if (len(line) != 0) :
                messagesList.append(line)
    csvfile.close()

    messagesList.append([chatroomID, message, encrypt(user, key)])

    # Replace chatroomMessages.csv with the data in messages
    with open("database/chatroomMessages.csv", "w") as csvfile:
        csvwriter = csv.writer(csvfile)
        for i in range(0, len(messagesList)):
            csvwriter.writerow(messagesList[i])
    csvfile.close()

def readChatroomMessages(chatroomName, numberOfMessages) :
    # Convert chatroom name to the chatroomID
    chatroomID = locateChatroomCollumn(chatroomName, 2)[0]

    messagesList = []

    # For every line in chatroomMessages.csv
    with open("database/chatroomMessages.csv", "r") as csvfile :
        csvreader = csv.reader(csvfile)
        for line in csvreader :
            # If line is not blank 
            if (len(line) != 0) :
                # If the current line stores the data for chatroomID
                if (line[0] == chatroomID) :
                    # Store the sender and message in line to message list
                    message = decrypt(line[1], key)
                    sender = decrypt(line[2], key)
                    messagesList.append(message + "#" + sender)

    # If there are less than or equal to 10 messages, return all of them
    # Otherwise, return the 10 most recent messages
    if len(messagesList) <= numberOfMessages :
        return messagesList
    else :
        return messagesList[-numberOfMessages:]


# Run when a messages is sent - increment the streak data for the user
def increaseStreak(user) :

    #  Convert username to a userID
    userID = searchUsers(user, 1, True)[0]

    userDetails = [[]]

    # Increase the streak
    # Open the users.csv file where element 3 = total xp and element 4 is streak length, and element 5 is the xp for the given week
    with open("database/users.csv", "r") as csvfile:
        csvreader = csv.reader(csvfile)
        # For every line in csvreader
        for line in csvreader:
            #If the line is not blank
            if (len(line) != 0) :
                # If the current line contains the information for user
                if (line[0] == userID) :
                    # Add XP to the current XP value
                    line[4] = str(int(line[4]) + 1)
                    userDetails.append(line)
                else :
                    userDetails.append(line)
    csvfile.close()

    # Replace the text in users.csv with the data in userDetails
    with open("database/users.csv", "w") as csvfile:
        csvwriter = csv.writer(csvfile)
        for i in range(0, len(userDetails)):
            # If the line is not blank
            print ("userdetails" + str(userDetails[i]))
            if (userDetails[i] != []) :
                # Add the line to users.csv
                csvwriter.writerow(userDetails[i])
    csvfile.close()


# Reset the streak back to zero
def resetStreak(user) :

    #  Convert username to a userID
    userID = searchUsers(user, 1, True)[0]

    userDetails = [[]]

    # Increase the streak
    # Open the users.csv file where element 3 = total xp and element 4 is streak length, and element 5 is the xp for the given week
    with open("database/users.csv", "r") as csvfile:
        csvreader = csv.reader(csvfile)
        # For every line in csvreader
        for line in csvreader:
            #If the line is not blank
            if (len(line) != 0) :
                # If the current line contains the information for user
                if (line[0] == userID) :
                    # Add XP to the current XP value
                    line[4] = "0"
                    userDetails.append(line)
                else :
                    userDetails.append(line)
    csvfile.close()

    # Replace the text in users.csv with the data in userDetails
    with open("database/users.csv", "w") as csvfile:
        csvwriter = csv.writer(csvfile)
        for i in range(0, len(userDetails)):
            # If the line is not blank
            print ("userdetails" + str(userDetails[i]))
            if (userDetails[i] != []) :
                # Add the line to users.csv
                csvwriter.writerow(userDetails[i])
    csvfile.close()

# Returns the user's streak
def findStreak(user) :
    #  Convert username to a userID
    userID = searchUsers(user, 1, True)[0]
    streak = 0

    # Open the users.csv file
    with open("database/users.csv", "r") as csvfile:
        csvreader = csv.reader(csvfile)
        # For every line in users.csv
        for line in csvreader:
            # If the line is not blank
            if (len(line) != 0) :
                # If the line contains the details for user
                if (line[0] == userID) :
                    # Save the user's streak
                    streak = line[4]
    csvfile.close()
    return streak

# Check if the weekly xp count needs to be reset. If so, reset if
def checkIfWeeklyXPNeedsReset(lastResetYear, lastResetMonth, lastResetDay, user) :
    #  Convert username to a userID
    userID = searchUsers(user, 1, True)[0]

    reset = False

    userDetails = [[]]

    # Convert the last reset year, month and day to datetime format
    lastReset = datetime.datetime(int(lastResetYear), int(lastResetMonth), int(lastResetDay))
    # Get the current date
    date = datetime.datetime.now()
    # Find how long ago the last streak was
    delta = date - lastReset

    # If the last reset was more that a week ago
    if (delta.days > 6) :
    # Open the users.csv file where element 3 = total xp and element 4 is streak length, and element 5 is the xp for the given week
        with open("database/users.csv", "r") as csvfile:
            csvreader = csv.reader(csvfile)
            # For every line in csvreader
            for line in csvreader:
                #If the line is not blank
                if (len(line) != 0) :
                    # If the current line contains the information for user
                    if (line[0] == userID) :
                        # Reset the streak
                        line[5] = "0"
                        userDetails.append(line)
                        reset = True
                    else :
                        userDetails.append(line)
        csvfile.close()

        # Replace the text in users.csv with the data in userDetails
        with open("database/users.csv", "w") as csvfile:
            csvwriter = csv.writer(csvfile)
            for i in range(0, len(userDetails)):
                # If the line is not blank
                print ("userdetails" + str(userDetails[i]))
                if (userDetails[i] != []) :
                    # Add the line to users.csv
                    csvwriter.writerow(userDetails[i])
        csvfile.close()

    return reset

# Return a list of users sorted by their weekly xp in the format: user, xp, user, xp...
def sortUsersByXP() :
    users = []
    usersXP = []

    # Fill users and usersXP with the relevant data
    # Open the users.csv file
    with open("database/users.csv", "r") as csvfile:
        csvreader = csv.reader(csvfile)
        
        # For every line in the file
        for line in csvreader:
            # If the line is not blank
            if (len(line) != 0) :
                # Store the username in users
                users.append(decrypt(line[1], key))
                # Store the user's xp in usersXP
                usersXP.append(line[5])

    # Using usersXP, sort users and usersXP in descending order and return th given array - in format user, xp, user, xp...
    return sortUsersOnLeaderBoard(users, usersXP)   

def findWeeklyXP (username) :
    # Convert username to the userID
    userID = searchUsers(username, 1, True)[0]


    with open("database/users.csv", "r") as csvfile:
        csvreader = csv.reader(csvfile)
        # For every line in the file
        for line in csvreader:
                if len(line) != 0:
                    if (line[0] == userID) :
                        return line[5]

        return "* weekly xp could not be calculated *"


def sendNotification(message, chatroom, user, url) :
    # Get the email addresses of all people in the chatroom
    # Except the user who sent the message
    # Then send them the email

    usersInTheChatroom = []
    userIDWHoSentMessage = ""
    chatroomID = ""
    emailAddresses = []

    # Get the userID of user
    userID = searchUsers(user, 1, True)[0]

    # Get the ID of the chatroom
    with open("database/chatrooms.csv", "r") as chatrooms:
        for line in chatrooms:
            # The chatroom may have "\n" added on the end - a newline
            if line.split(",")[2] == chatroom or line.split(",")[2] == chatroom + "\n":
                chatroomID = line.split(",")[0]

    # Find all the users who are in the chatroom except user
    with open("database/chatroomUsers.csv", "r") as chatroomUsers:
        for line in chatroomUsers:
            # Remove whitespace
            line = line.rstrip("\n")
            if line.split(",")[1] == chatroomID and line.split(",")[0] != userID:
                usersInTheChatroom.append(line.split(",")[0])
    
    # Find the email addresses of all these users
    with open("database/users.csv", "r") as users:
        for line in users:
            # Remove whitespace
            line = line.rstrip("\n")

            for chatroomUser in usersInTheChatroom :
                if line.split(",")[0] == chatroomUser:
                    emailAddresses.append(decrypt(line.split(",")[6], key))

    # Send the emails
    for address in emailAddresses:
        if address != "NULL" :
            body = """You have a new message in a chatroom!
Someone said, '""" + message + """'
                    
Want to view the message? Go to """ + url + "?chatroomName=" + quote(chatroom)
            sendEmail(address, "You have a new message", body)

def updateUserDetails(oldUsername, newUsername, password, email) :
    updatedFile = []
    # Look through every line in users.csv
    # If the old username is found, update the password and email address
    # If not, append the line to a csv file
    with open("database/users.csv", "r") as file:
        csvreader = csv.reader(file)
        for line in csvreader:
            # If the line contains whitespace
            if len(line) != 0:
                if decrypt(line[1], key) == oldUsername:
                    line[1] = newUsername
                    line[2] = password
                    line[6] = email

                # Save the data to the file array, turning it into a string seperated by a comma
                updatedFile.append(",".join(line))

    # Read updatedFile into the users.csv file, rewriting it
    with open("database/users.csv", "w") as file:
        for line in updatedFile:
            file.write(line + "\n")

# Create a new flashcard set
def createFlashcardSet(username, name, description) :
    # Generate a flashcard ID
    flashcardID = generateNewID("database/flashcards.csv")

    # Find the user ID
    userID = searchUsers(username, 1, True)[0]

    # Save flashcardID, userID to flashcardOwners.csv
    with open("database/flashcardsOwners.csv", "a") as csvfile:
        csvwriter = csv.writer(csvfile)
        csvwriter.writerow([flashcardID, userID])
        csvfile.close()

    # Save flashcardID, name, description to flashcards.csv
    with open("database/flashcards.csv", "a") as csvfile:
        csvwriter = csv.writer(csvfile)
        csvwriter.writerow([flashcardID, name, description])
        csvfile.close()

# Check if the user owns the flashcard set
def checkFlashcardSetOwnership(username, flashcardName) :
    # Find the user ID
    userID = searchUsers(username, 1, True)[0]

    # Find the flashcard ID
    flashcardID = ""
    with open("database/flashcards.csv", "r") as csvfile:
        csvreader = csv.reader(csvfile)
        for line in csvreader:
            if line[1] == flashcardName:
                flashcardID = line[0]
        csvfile.close()

    # See if userID owns flashcardID by searching flashcardsOwners.csv
    with open("database/flashcardsOwners.csv", "r") as csvfile:
        csvreader = csv.reader(csvfile)
        for line in csvreader:
            if line[0] == flashcardID and line[1] == userID:
                return True
        csvfile.close()

    return False

# Find the cards in a flashcard set
def findCardsInFlashcardSet(flashcardName) :
    flashcardTerms = []
    # Find the flashcard ID
    flashcardID = ""
    with open("database/flashcards.csv", "r") as csvfile:
        csvreader = csv.reader(csvfile)
        for line in csvreader:
            if line[1] == flashcardName:
                flashcardID = line[0]
        csvfile.close()

    # Find the cards in the flashcard set
    with open("database/flashcardTerms.csv", "r") as csvfile:
        csvreader = csv.reader(csvfile)
        for line in csvreader:
            if line[0] == flashcardID:
                flashcardTerms.append(line[1] + "#" + line[2])
        csvfile.close()

    return flashcardTerms

# Find the cards in an uploaded flashcard set
def findCardsInUploadedFlashcardSet(flashcardName) :
    flashcardTerms = []
    # Find the flashcard ID
    flashcardID = ""
    with open("database/uploadedFlashcards.csv", "r") as csvfile:
        csvreader = csv.reader(csvfile)
        for line in csvreader:
            if line[1] == flashcardName:
                flashcardID = line[0]
        csvfile.close()

    # Find the cards in the flashcard set
    with open("database/uploadedFlashcardTerms.csv", "r") as csvfile:
        csvreader = csv.reader(csvfile)
        for line in csvreader:
            if line[0] == flashcardID:
                flashcardTerms.append(line[1] + "#" + line[2])
        csvfile.close()

    return flashcardTerms

# Replace the cards in a flashcard set with the values given in the parameter
def replaceCardsInFlashcardSet(flashcardName, cards) :
    # Turn cards into an array - takes term1/definition1,term2,definition2
    cards = cards.split(",")


    cardsToRemove = []

    # Remove all items from array which have a value of ""
    for i in range(0, len(cards)) :
        if cards[i] == "" :
            cardsToRemove.append(i)

    for i in range(0, len(cardsToRemove)) :
        cards.pop(cardsToRemove[i])

    flashcards = []
    # Find the flashcard ID
    flashcardID = ""
    with open("database/flashcards.csv", "r") as csvfile:
        csvreader = csv.reader(csvfile)
        for line in csvreader:
            if line[1] == flashcardName:
                flashcardID = line[0]
        csvfile.close()

    # Find the cards in the flashcard set that do not have the ID of flashcardID
    with open("database/flashcardTerms.csv", "r") as csvfile:
        csvreader = csv.reader(csvfile)
        for line in csvreader:
            if line[0] != flashcardID:
                flashcards.append(line[0] + "," + line[1] + "," + line[2])
        csvfile.close()

    # Add the edited cards to the flashcards array
    for i in range(0, len(cards)):
        flashcards.append(flashcardID + "," + cards[i].split("/")[0] + "," + cards[i].split("/")[1])

    # Rewrite the flashcardTerms.csv file
    with open("database/flashcardTerms.csv", "w") as csvfile:
        for line in flashcards:
            csvfile.write(line + "\n")
        csvfile.close()

# Find flashcards owned by the username
def findFlashcardsOwnedByUser(username) :
    flashcardIDs = []
    flashcardNames = []
    # Get user ID from username
    userID = searchUsers(username, 1, True)[0]

    # Search flashcardsOwners.csv
    with open("database/flashcardsOwners.csv", "r") as csvfile:
        csvreader = csv.reader(csvfile)
        for line in csvreader:
            #  If the user ID is found, get the flashcard ID and add to flashcard ID array
            if line[1] == userID:
                flashcardIDs.append(line[0])
        csvfile.close()

    # Search flashcards.csv for the flashcard ID and add the flashcard name to an array
    with open("database/flashcards.csv", "r") as csvfile:
        csvreader = csv.reader(csvfile)
        for line in csvreader:
            if line[0] in flashcardIDs:
                flashcardNames.append(line[1])
        csvfile.close()

    return flashcardNames

# Upload a flashcard set
def uploadFlashcardSet(flashcardName) :
    # Create an ID for the uploaded flashcard set
    flashcardID = str(generateNewID("database/uploadedFlashcards.csv"))
    localFlashcardID = ""

    # Copy the flashcard data in flashcards.csv to uploadedFlashcards.csv
    # Find the description of the flashcard set
    description = ""
    with open("database/flashcards.csv", "r") as csvfile:
        csvreader = csv.reader(csvfile)
        for line in csvreader:
            if line[1] == flashcardName:
                description = line[2]
                localFlashcardID = line[0]
        csvfile.close()

    # Look at uploadedFlashcards.csv. If the name has not been used, append it 
    uploadedFlashcards = []
    nameUsed = False
    

    with open("database/uploadedFlashcards.csv", "r") as csvfile:
        csvreader = csv.reader(csvfile)
        for line in csvreader:
            if line[1] == flashcardName:
                # If the name has been used, just edit the description
                uploadedFlashcards.append(line[0] + "," + line[1] + "," + description)
                nameUsed = True
                flashcardID = line[0]
            else :
                uploadedFlashcards.append(line[0] + "," + line[1] + "," +line[2])
        csvfile.close()

    # If name has not been used, append the new set to the array
    if nameUsed == False:
        uploadedFlashcards.append(flashcardID + "," + flashcardName + "," + description)

    # Rewrite the uploadedFlashcards.csv file
    with open("database/uploadedFlashcards.csv", "w") as csvfile:
        for line in uploadedFlashcards:
            csvfile.write(line + "\n")
        csvfile.close()

    # Copy the flashcard data in flashcardTerms.csv to uploadedFlashcardTerms.csv
    # Get the flashcard terms belonging to the flashcard set
    terms = []

    with open("database/flashcardTerms.csv", "r") as csvfile:
        csvreader = csv.reader(csvfile)
        for line in csvreader:
            if line[0] == localFlashcardID:
                terms.append(line[1] + "," + line[2])
        csvfile.close()

    newFile = []

    # If the flashcard set has not been added before

    if nameUsed == False:
        # Add the flashcard terms to uploadedFlashcardTerms.csv
        with open("database/uploadedFlashcardTerms.csv", "a") as csvfile:
            writer = csv.writer(csvfile)
            for line in terms:
                writer.writerow([flashcardID, line.split(",")[0], line.split(",")[1]])
            csvfile.close()
            
    # If the flashcard set has been added before
    else :
        count = 0

        with open("database/uploadedFlashcardTerms.csv", "r") as csvfile:
            csvreader = csv.reader(csvfile)
            for line in csvreader:
                # If the data does not belong to the flashcard set, add it to the new file
                if line[0] != flashcardID:
                    newFile.append(line[0] + "," + line[1] + "," + line[2])
                else:
                    # If the data belongs to the flashcard set
                    newFile.append(line[0] + "," + terms[count])
                    count = count + 1
            csvfile.close()

        # If there are any more items in terms that haven't been added yet, add them
        if count < len(terms) :
            for i in range(count, len(terms)):
                newFile.append(flashcardID + "," + terms[i])
    
        # Rewrite uploadedFlashcardTerms.csv with the data in newFile
        with open("database/uploadedFlashcardTerms.csv", "w") as csvfile:
            for line in newFile:
                csvfile.write(line + "\n")
            csvfile.close()

# Find all the flashcard templates added and return an array of their names
def findFlashcardTemplates() :
    flashcardNames = []

    # Search uploadedFlashcards.csv and add the names to the array
    with open("database/uploadedFlashcards.csv", "r") as csvfile:
        csvreader = csv.reader(csvfile)
        for line in csvreader:
            flashcardNames.append(line[1])
        csvfile.close()

    return flashcardNames

# Find a name to save the flashcard set as when cloning it - recursive
def findNameForClonedFlashcardSet(templateName, number) :
    nameUsed = False
    nameToCheck = templateName + str(number)
    # Look at all the flashcards added
    with open("database/flashcards.csv", "r") as csvfile:
        csvreader = csv.reader(csvfile)
        for line in csvreader:
            # If the name is used, add one to the number and call the function again
            if line[1] == nameToCheck:
                nameUsed = True

                # Increment number or set it to 1 depending on its value
                if number == "" :
                    number = 1
                else:
                    number = number + 1
                return findNameForClonedFlashcardSet(templateName, number)
        csvfile.close()
    
    # If the name is not used, return it - this is the base condition
    if nameUsed == False:
        return templateName + str(number)

def cloneTemplate(templateName, username) :   
    # Find the ID and description of templateName
    ID = ""
    description = ""
    
    with open("database/uploadedFlashcards.csv", "r") as csvfile:
        csvreader = csv.reader(csvfile)
        for line in csvreader:
            if line[1] == templateName:
                ID = line[0]
                description = line[2]
        csvfile.close()

    # Find the userID
    userID = searchUsers(username, 1, True)[0]
     
    # Get the name of the new set
    name = findNameForClonedFlashcardSet(templateName, "")

    # Generate a new ID
    newID = str(generateNewID("database/flashcards.csv"))
    
    # Find the the terms of the set templateName
    terms = []
    with open("database/uploadedFlashcardTerms.csv", "r") as csvfile:
        csvreader = csv.reader(csvfile)
        for line in csvreader:
            if line[0] == ID:
                terms.append(line[1] + "#" + line[2])
        csvfile.close()

    # Add newID, name, description to database/flashcards.csv
    with open("database/flashcards.csv", "a") as csvfile:
        csvfile.write(newID + "," + name + "," + description + "\n")
        csvfile.close()

    # Add newID, term, definition, to database/flashcardTerms.csv
    with open("database/flashcardTerms.csv", "a") as csvfile:
        for term in terms:
            csvfile.write(newID + "," + term.split("#")[0] + "," + term.split("#")[1] + "\n")
        csvfile.close()

    # Add flashcardID. ownerID to database/flashcardOwners.csv
    with open("database/flashcardsOwners.csv", "a") as csvfile:
        csvfile.write(newID + "," + userID + "\n")
        csvfile.close()

    return name

# Get the flashcard description based on the name - works for flashcard templates and normal flashcards due to the fileToSearch parameter
def getFlashcardDescription(flashcardName, fileToSearch) :
    with open(fileToSearch, "r") as csvfile:
        csvreader = csv.reader(csvfile)
        for line in csvreader:
            if line[1] == flashcardName:
                return line[2]
            

# This will remove the flashcard as well as its uploaded backup
def deleteFlashcard(flashcardName) :
    flashcardID = ""
    # Get the ID of the flashcard
    with open("database/flashcards.csv", "r") as csvfile:
        csvreader = csv.reader(csvfile)
        for line in csvreader:
            if line[1] == flashcardName:
                flashcardID = line[0]
        csvfile.close()

    # Delete the flashcard from flashcards.csv
    # Read all the data in flashcards.csv into an array except the line to delete
    flashcards = []

    with open("database/flashcards.csv", "r") as csvfile:
        csvreader = csv.reader(csvfile)
        for line in csvreader:
            if line[0] != flashcardID:
                flashcards.append(line[0] + "," + line[1] + "," + line[2])
        csvfile.close()

    # Rewrite the data in the array to flashcards.csv
    with open("database/flashcards.csv", "w") as csvfile:
        for line in flashcards:
            csvfile.write(line + "\n")
        csvfile.close()

    # Delete the flashcard from flashcardTerms.csv
    # Read all the data in flashcardTerms.csv into an array except the line to delete
    flashcardTerms = []

    with open("database/flashcardTerms.csv", "r") as csvfile:
        csvreader = csv.reader(csvfile)
        for line in csvreader:
            if line[0] != flashcardID:
                flashcardTerms.append(line[0] + "," + line[1] + "," + line[2])
        csvfile.close()

    # Rewrite the data in the array to flashcardTerms.csv
    with open("database/flashcardTerms.csv", "w") as csvfile:
        for line in flashcardTerms:
            csvfile.write(line + "\n")
        csvfile.close()

    # Delete the flashcard from flashcardsOwners.csv
    # Read all the data in flashcardsOwners.csv into an array except the line to delete
    flashcardsOwners = []

    with open("database/flashcardsOwners.csv", "r") as csvfile:
        csvreader = csv.reader(csvfile)
        for line in csvreader:
            if line[0] != flashcardID:
                flashcardsOwners.append(line[0] + "," + line[1])
        csvfile.close()
    
    # Rewrite the data in the array to flashcardsOwners.csv
    with open("database/flashcardsOwners.csv", "w") as csvfile:
        for line in flashcardsOwners:
            csvfile.write(line + "\n")
        csvfile.close()

    # Find the ID of the uploadedFlashcard
    uploadedFlashcardID = ""
    # Get the ID of the flashcard
    with open("database/uploadedFlashcards.csv", "r") as csvfile:
        csvreader = csv.reader(csvfile)
        for line in csvreader:
            if line[1] == flashcardName:
                uploadedFlashcardID = line[0]
        csvfile.close()

    # Delete the flashcard from uploadedFlashcards.csv
    # Read all the data in uploadedFlashcards.csv into an array except the line to delete
    uploadedFlashcards = []

    with open("database/uploadedFlashcards.csv", "r") as csvfile:
        csvreader = csv.reader(csvfile)
        for line in csvreader:
            if line[0] != uploadedFlashcardID:
                uploadedFlashcards.append(line[0] + "," + line[1] + "," + line[2])
        csvfile.close()

    # Rewrite the data in the array to uploadedFlashcards.csv
    with open("database/uploadedFlashcards.csv", "w") as csvfile:
        for line in uploadedFlashcards:
            csvfile.write(line + "\n")
        csvfile.close()

    # Delete the flashcard from uploadedFlashcardTerms.csv
    # Read all the data in uploadedFlashcardTerms.csv into an array except the line to delete
    uploadedFlashcardTerms = []

    with open("database/uploadedFlashcardTerms.csv", "r") as csvfile:
        csvreader = csv.reader(csvfile)
        for line in csvreader:
            if line[0] != uploadedFlashcardID:
                uploadedFlashcardTerms.append(line[0] + "," + line[1] + "," + line[2])
        csvfile.close()

    # Rewrite the data in the array to uploadedFlashcardTerms.csv
    with open("database/uploadedFlashcardTerms.csv", "w") as csvfile:
        for line in uploadedFlashcardTerms:
            csvfile.write(line + "\n")
        csvfile.close()

def validateChatroomCode(code) :
    # Codes are a hashed version of the chatroom name
    # This script goes through every chatroom in database/chatrooms.csv
    # If the code matches the hashed chatroom name, return the chatroom name
    # If not, return INVALID

    with open("database/chatrooms.csv", "r") as csvfile:
        reader = csv.reader(csvfile)
        for line in reader:
            hashedChatroomName = hashlib.sha256(line[2].encode()).hexdigest()
            if hashedChatroomName == code:
                return line[2]
            
    return "INVALID"

def getChatroomLanguage(chatroomName) :
    # Find the language of a chatroom given its name
    with open("database/chatrooms.csv", "r") as csvfile:
        reader = csv.reader(csvfile)
        for line in reader:
            if line[2] == chatroomName:
                return line[1]
            
# Get all the users of a chatroom and their weekly XP
def getUsersAndWeeklyXPInChatroom(chatroomName) :
    pass
    # Find the ID of the chatroom
    chatroomID = ""

    with open("database/chatrooms.csv", "r") as csvfile:
        reader = csv.reader(csvfile)
        for line in reader:
            if line[2] == chatroomName:
                chatroomID = line[0]

    # Get the IDs of all the users in the chatroom
    chatroomUserIDs = []

    # Stored as userID, chatroomID
    with open("database/chatroomUsers.csv", "r") as csvfile:
        reader = csv.reader(csvfile)
        for line in reader:
            if line[1] == chatroomID:
                chatroomUserIDs.append(line[0])

    # Get the weekly XP and names of all the user IDs
    XPandNames = []

    with open("database/users.csv", "r") as csvfile:
        reader = csv.reader(csvfile)
        for line in reader:
            if line != []:
                if line[0] in chatroomUserIDs:
                    XPandNames.append(decrypt(line[1], key) + "#" + line[5])

    return XPandNames


def checkIfUserHasAlreadyJoinedChatroom(username, chatroomName) :
    chatroomsJoined = findChatroomsJoined(username)

    if chatroomName in chatroomsJoined:
        return "FAIL"

    return "PASS"


def deleteUserFromChatroom(username, chatroomName) :
    # Get the ID of the chatroom
    chatroomID = ""

    with open("database/chatrooms.csv", "r") as csvfile:
        reader = csv.reader(csvfile)
        for line in reader:
            if line[2] == chatroomName:
                chatroomID = line[0]
    
    # Get the ID of the username
    userID = searchUsers(username, 1, True)[0]

    # Read the edited version of chatroomUsers.csv into an array
    chatroomUsers = []

    with open("database/chatroomUsers.csv", "r") as csvfile:
        reader = csv.reader(csvfile)
        for line in reader:
            if line[0] != userID or line[1] != chatroomID:
                chatroomUsers.append(line[0] + "," + line[1])
    
    
    # Rewrite the csv file into the array
    with open("database/chatroomUsers.csv", "w") as csvfile:
        for line in chatroomUsers:
            csvfile.write(line + "\n")

# Get the date of last reset from streakDates.csv
def getDateOfLastReset(username) :
    # Get the ID of the username
    userID = searchUsers(username, 1, True)[0]

    # Get the date of last reset
    with open("database/streakDates.csv", "r") as csvfile:
        reader = csv.reader(csvfile)
        for line in reader:
            if line[0] == userID:
                return [line[1], line[2], line[3]]
    
    # If there is no date of last reset, return an empty array
    return ["", "", ""]

# Update the date of last reset
def updateDateOfLastReset(username) :
    # Get the ID of the username
    userID = searchUsers(username, 1, True)[0]

    # Read the data in streakDates.csv into an array, editing the date of last reset
    streakDates = []

    with open("database/streakDates.csv", "r") as csvfile:
        reader = csv.reader(csvfile)
        userIDinFile = False

        for line in reader:
            if line[0] == userID:
                line[1] = str(datetime.datetime.now().day)
                line[2] = str(datetime.datetime.now().month)
                line[3] = str(datetime.datetime.now().year)
                userIDinFile = True

            streakDates.append(line[0] + "," + line[1] + "," + line[2] + "," + line[3])
        
        # If the file is empty, add the data to the array
        if userIDinFile == False:
            tempLine = ["", "", "", ""]
            tempLine[1] = str(datetime.datetime.now().day)
            tempLine[2] = str(datetime.datetime.now().month)
            tempLine[3] = str(datetime.datetime.now().year)
            streakDates.append(userID + "," + tempLine[1] + "," + tempLine[2] + "," + tempLine[3])

    # Reread the array back into the streakDates.csv file
    with open("database/streakDates.csv", "w") as csvfile:
        for line in streakDates:
            csvfile.write(line + "\n")

# Reset the streak if needed
def resetStreakIfNeeded(username) :
    # Find the date of the last streak
    dateOfLastReset = getDateOfLastReset(username)
    year = dateOfLastReset[2]
    month = dateOfLastReset[1]
    day = dateOfLastReset[0]
                
    # If the date has been set
    try :
        lastStreak = datetime.datetime(int(year), int(month), int(day))
    except :
        # If the date has not been set
        lastStreak = datetime.datetime.now()

        # Update the streak by one day
        # Update the cookies to reflect the data for today
        updateDateOfLastReset(username)
                    
        # Actually increase the streak (this will have the effect of resetting it)
        increaseStreak(username)


    # Get the current date
    date = datetime.datetime.now()
    # Find how long ago the last streak was
    delta = date - lastStreak

    # If the streak needs to be reset
    if (delta.days > 1) :
        # If the streak was updated more than one day ago
        # Update the cookies to reflect the data for today
        updateDateOfLastReset(username)
        resetStreak(username)
                    
        increaseStreak(username)