NanoNish · Oct 11, 2023 · Oct 18, 2023 · Oct 20, 2023 · Oct 28, 2023 · Oct 28, 2023
diff --git a/.DS_Store b/.DS_Store
diff --git a/.gitignore b/.gitignore
@@ -1,2 +1,3 @@
 .env
 **/__pycache__
+.venv
diff --git a/bro/.DS_Store b/bro/.DS_Store
diff --git a/bro/patterns.py b/bro/patterns.py
@@ -1,6 +1,39 @@
 from . import views
 
 patterns = [
-    ("^yo\s", views.yo),
-    ("^bro\s", views.bro),
+    (r"bro <@(.{11})> has (\w+)" , views.bro_keys_claim),
+    (r"^bro info keys$", views.bro_keys),
+    (r"^bro who has keys$", views.bro_keys),
+    (r"bro info <@(.{11})>" , views.user_info),
+    (r"^bro scores$", views.bro_score_message),
+
+
+
+
+    (r"<@(.{11})> \+\+|<@(.{11})>\+\+|<@(.{11})>--|<@(.{11})> --" , views.handle_user_score),
+    (r"bro score (\w+)$", views.batchScore),
+
+    (r"bro ping", views.bro_ping),
+    (r"bro test test1", views.testing_message),
+
+    (r"(good night|goodnight|cya|bye|nighty night)", views.bye),
+
+    (r"bro who is <@(.{11})>", views.getRole),
+    (r'bro <@(.{11})> is (\w+)', views.setRole),
+    # (r'bro <@(.{11})> is (\w+)', views.setRole)
+
+    (r"bro birthday <@(.{11})>", views.birthday),
+    (r'bro help', views.help)
+
+
+
+    (r"<@(\w+)>\s*(\+\+|\-\-)" , views.bro_user_scores),
+    (r"bro animate me (.+)" , views.google_animate_query),
+    (r"bro image me (.+)" , views.google_image_query),
+    (r"bro map me (.+)" , views.google_map_query),
+    (r"bro quote (.+)|bro quote" , views.bro_quote),
+    (r"bro toss" , views.bro_toss) ,
+    (r"bro dice" , views.bro_dice),
+    (r".*lab is (open|closed)*" , views.bro_lab_status),
+    (r".*is lab (open|closed)*" , views.bro_isLab_status)
 ]
diff --git a/bro/schemas.js b/bro/schemas.js
@@ -0,0 +1,79 @@
+key =  {
+    "key1": {
+        "key_name": "key1",
+        "owner":"str",
+    },
+    "key2": {
+        "key_name": "key1",
+        "owner":"str",
+    },
+    "key3": {
+        "key_name": "key1",
+        "owner":"str",
+    },
+    "key4": {
+        "key_name": "key1",
+        "owner":"str",
+    },
+}
+
+
+
+userDB = {
+    "U24984573945":{
+            "slackMemberId": "U24984573945",
+            "displayName":"rain",
+
+            "name": "Amey Khandalkar",
+
+            "phoneNo":"123456",
+            "emailId" : "hello@gmail.com",
+            "dob" : "01/01/2000",
+            "Year" : "2nd",
+            "Branch": "MnC",
+            "enrollmentNo" : "22323004",
+            "roomNo" : "roomno",
+            "slackUserId": "slackuserid",
+            "homeAddress":"ghar",
+
+            "score" : "21",
+            "roles" : ["role1", "role2"]
+            // "membershipStatus": "active"
+    },
+    "U24984573945":{
+        "slackMemberId": "U24984573945",
+        "displayName":"rain",
+
+        "name": "Amey Khandalkar",
+
+        "phoneNo":"123456",
+        "emailId" : "hello@gmail.com",
+        "dob" : "01/01/2000",
+        "Year" : "2nd",
+        "Branch": "MnC",
+        "enrollmentNo" : "22323004",
+        "roomNo" : "roomno",
+        "slackUserId": "slackuserid",
+        "homeAddress":"ghar",
+
+        "score" : "21",
+        "roles" : ["role1", "role2"]
+        // "membershipStatus": "active"
+    },
+}
+
+batches = {
+    "4y":[
+        "U24984573945",
+        "U24984573945"
+    ],
+    "3y": [
+
+    ]
+}
+
+
+
+
+
+
diff --git a/bro/scripts/api_scripts/bro_quotes.py b/bro/scripts/api_scripts/bro_quotes.py
@@ -0,0 +1,27 @@
+import requests
+import os
+
+
+API_KEY = os.environ.get('NINJAS_API_KEY')
+print(API_KEY)
+
+def handle_quote(message):
+    parts = message.split()
+    if parts[0] == "bro" and parts[1] == "quote":
+        category = " ".join(parts[2:])
+        print(f"Query: {category}")
+    else:
+        category = ""
+
+    api_url = 'https://api.api-ninjas.com/v1/quotes?category={}'.format(category)
+    response = requests.get(api_url, headers={'X-Api-Key': API_KEY})
+
+    if response.status_code == requests.codes.ok:
+        print(response.text)
+        data = response.json()
+        print(data)
+        return data[0]['quote']
+    else:
+        print("Error:", response.status_code, response.text)
+
+
diff --git a/bro/scripts/api_scripts/random.py b/bro/scripts/api_scripts/random.py
@@ -0,0 +1,13 @@
+import random
+
+def random_toss(message):
+    list1 = ["Head" , "Tail"]
+
+    return random.choice(list1)
+
+def random_dice(message):
+    list2 = ["1" , "2" , "3" , "4" , "5"  , "6"]
+
+
+    return random.choice(list2)
+
diff --git a/bro/scripts/batchScore/batchScore.py b/bro/scripts/batchScore/batchScore.py
@@ -0,0 +1,32 @@
+from ...services import redisService
+
+redisStore = redisService.RedSis()
+redisStore.redisInit()
+
+utilDict = {
+    "1y" : "1st",
+    "2y" : "2nd",
+    "3y" : "3rd",
+    "4y" : "4th"
+}
+
+
+def getBatchScore(message, batch):
+    batch = utilDict[batch]
+    userDB = redisStore.getValue('userDBtest1')
+    batches = redisStore.getValue('batchesData')
+    msg = ''   
+    print(batch)
+    if(batches.get(batch, False)):
+        print("------")
+        users = batches[batch]
+        for user in users:
+            print(user)
+            score = userDB[user]["score"]
+            msg += f'<@{user}> : {score}\n'
+        return msg
+    return f'No score info yet X_x'
+
+
+
+
diff --git a/bro/scripts/birthday/birthday.py b/bro/scripts/birthday/birthday.py
@@ -0,0 +1,13 @@
+from ...services import redisService
+
+redisStore = redisService.RedSis()
+redisStore.redisInit()
+
+def getBirthday(userId):
+    userDB = redisStore.getValue('userDBtest1')
+    if(userDB.get(userId, False)):
+        if(userDB[userId].get('dob', False)):
+            dob = userDB[userId]['dob']
+            return f'Wish <@{userId}> on {dob}!'
+
+    return f'<@{userId}> who? Can\' recognise them :/'
diff --git a/bro/scripts/bye/bye.py b/bro/scripts/bye/bye.py
@@ -0,0 +1,39 @@
+import random
+
+
+ways_to_say_good_night = [
+  "Good night, baby.",
+  "Night hot stuff.",
+  "Like I'm going to let you get any sleep",
+  "LOOK...the moon is calling you, SEE...the stars are shining for you, HEAR... my heart saying good night.",
+  "Sleep tight, don't let the bed bugs bite",
+  "I'll be here, all alone, waiting"
+  "So long, and thanks for all the fish.",
+  "Finally",
+  "À voir!",
+  "Don't let the back door hit ya where the good Lord split ya",
+  "May your feet never fall off and grow back as cactuses",
+  "TTYL",
+  "C U L8R",
+  "Fine, then go!",
+  "Cheers",
+  "Uh, I can hear the voices calling me...see ya",
+  "In a while, crocodile",
+  "SHOO! SHOO!",
+  "No more of you.",
+  "Avada Kedavra",
+  "Ok. Tata. Byebye",
+  "Connection: close",
+  "End Of Line",
+  "Farewell! God knows when we shall meet again.",
+  "You are the weakest link - goodbye!",
+  "आप  इस  राउंड  के  कमज़ोर  कड़ी  हैं. आप जा सकते हैं. नमस्ते",
+  "If I leave here tomorrow, will you still remember me?",
+  "Don't leave me here!",
+  "If you say so.",
+  "Connection closed by remote host",
+  "You are fired."
+]
+
+def goodNight(message):
+    return random.choice(ways_to_say_good_night)
diff --git a/bro/scripts/dummy.py b/bro/scripts/dummy.py
@@ -0,0 +1,2 @@
+
+
diff --git a/bro/scripts/google/google_cse.py b/bro/scripts/google/google_cse.py
@@ -0,0 +1,61 @@
+
+import requests
+import os
+import re
+
+API_KEY = os.environ.get("GOOGLE_API_KEY")
+CX = os.environ.get("GOOGLE_CSE_ID")
+print(API_KEY , CX)
+
+def handle_google_image_query(message):
+    parts = message.split()
+    if len(parts) > 3 and parts[0] == "bro" and parts[1] == "image" and parts[2] == "me":
+        query = " ".join(parts[3:])
+        print(f"Query: {query}")
+    else:
+        print("Invalid format")
+
+
+    try:
+        response =  requests.get(f"https://www.googleapis.com/customsearch/v1?key={API_KEY}&cx={CX}&q={query}&searchType=image")
+        data = response.json()
+        print(data["items"][0]["link"])
+        if "items" in data and len(data["items"]) > 0:
+            return data["items"][0]["link"]
+        else:
+            return None
+
+    except Exception as e:
+        print(e)
+        return None
+
+
+def handle_google_animate_query(message):
+    parts = message.split()
+    if len(parts) > 3 and parts[0] == "bro" and parts[1] == "animate" and parts[2] == "me":
+        query = " ".join(parts[3:])
+        print(f"Query: {query}")
+    else:
+        print("Invalid format")
+
+
+    try:
+        response =  requests.get(f"https://www.googleapis.com/customsearch/v1?key={API_KEY}&cx={CX}&q={query}&searchType=image&fileType=gif")
+        data = response.json()
+        print(data["items"][0]["link"])
+        if "items" in data and len(data["items"]) > 0:
+            return data["items"][0]["link"]
+        else:
+            return None
+
+    except Exception as e:
+        print(e)
+        return None
+
+
+
+
+
+
+
+#async def handle_google_animate_query(message):
diff --git a/bro/scripts/google/google_maps.py b/bro/scripts/google/google_maps.py
@@ -0,0 +1,18 @@
+import os
+
+API_KEY = os.environ.get("GOOGLE_API_KEY")
+
+def handle_google_map_query(message):
+    parts = message.split()
+    if len(parts) > 3 and parts[0] == "bro" and parts[1] == "map" and parts[2] == "me":
+            query = " ".join(parts[3:])
+            print(f"Query: {query}")
+    else:
+            print("Invalid format")
+
+    map_zoom = '14'
+    map_size = '600x400'
+    map_url = f"https://maps.googleapis.com/maps/api/staticmap?center={query}&zoom={map_zoom}&size={map_size}&key={API_KEY}"
+
+    print(map_url)
+    return map_url
diff --git a/sisbot/core/services/redis.py → bro/scripts/google/services.py b/sisbot/core/services/redis.py → bro/scripts/google/services.py
diff --git a/bro/scripts/help.py b/bro/scripts/help.py
@@ -0,0 +1,27 @@
+def help(message):
+    helpTxt = f'here are all the commands:\n' 'bro @<user> has <key_name> : assigns key to an user\n' 'bro info keys / bro who has keys : current possessions of keys\n' 'bro scores : display everone\' score\nbro score <year> : scores of a year\n' 'bro ping : bro pong\n' 'bro who is @<user> : roles of the given user\nbro <@user> is <role> : assigns a role to an user\n' 'bro birthday @<user> : Gives the DOB of given user' 
+
+
+    return helpTxt    
+
+
+
+# (r"bro <@(.{11})> has (\w+)" , views.bro_keys_claim),
+# (r"^bro info keys$", views.bro_keys),
+# (r"^bro who has keys$", views.bro_keys),
+
+# (r"^bro scores$", views.bro_score_message),
+# (r"<@(.{11})> \+\+|<@(.{11})>\+\+|<@(.{11})>--|<@(.{11})> --" , views.handle_user_score),
+
+# (r"bro ping", views.bro_ping),
+# (r"bro test test1", views.testing_message),
+
+# (r"(good night|goodnight|cya|bye|nighty night)", views.bye),
+
+# (r"bro who is <@(.{11})>", views.getRole),
+# (r'bro <@(.{11})> is (\w+)', views.setRole),
+# # (r'bro <@(.{11})> is (\w+)', views.setRole)
+
+# (r"bro score (\w+)$", views.batchScore),
+
+# (r"bro birthday <@(.{11})>", views.birthday)
diff --git a/bro/scripts/info/info.py b/bro/scripts/info/info.py
@@ -0,0 +1,15 @@
+from . import services
+from ...services import dB
+
+def handle_user_info(message):
+    user = services.extract_user(message)
+    user_data = dB.load_user_data()
+    print(user)
+    user_info = user_data[user]
+    print(user_info)
+    result = ""
+    for key, value in user_info.items():
+        print(f"{key} : {value},\n")
+        result += f"{key} : {value},\n"
+
+    return result
diff --git a/bro/scripts/info/services.py b/bro/scripts/info/services.py
@@ -0,0 +1,12 @@
+import re
+
+
+def extract_user(message):
+    pattern = '<@(.{11})>'
+    list = message.split()
+    test_user = list[2]
+    match = re.search(pattern , test_user)
+    user = match.group(1)
+
+    return user
+
diff --git a/bro/scripts/keys/keys.py b/bro/scripts/keys/keys.py
@@ -0,0 +1,91 @@
+from . import services
+from . import services
+
+
+
+def handle_key_claim(message):
+    keys_data = services.load_keys_data()
+
+    user_id, key_name = services.extract_user_and_key(message)
+    print(user_id, key_name)
+
+    if user_id and key_name:
+        keyNames = ""
+        for key , value in keys_data.items():
+            keyNames += value["key_name"] + ",\n"
+            if(value["key_name"] == key_name):
+                value["owner"] = user_id
+                services.save_keys_data(keys_data)
+                print("yaha tak")
+                return f"{user_id} now has {key_name}."
+        return f"key name not vallid, here are the valid key:\n{keyNames}"    
+
+
+
+
+def handle_bro_keys_message(message):
+    keys_data = services.load_keys_data()
+
+    result = ""
+
+    for key, value in keys_data.items():
+        key_name = value["key_name"]
+        owner = value["owner"]
+        result += f"*{key_name}* : {owner}\n"
+
+    return result
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+    """blocks = [
+        {
+        "type": "section",
+        "block_id": "key_ownership",
+        "text": {
+            "type": "mrkdwn",
+            "text": "*Key Ownership* :key:"
+        }
+    },
+    {
+        "type": "divider"
+    }
+    ]
+    """
+
+    """blocks.append(
+            {
+                "type": "section",
+                "text": {
+                    "type": "mrkdwn",
+                    "text": f"*{key}*: <@{owner}>"
+                }
+            }
+        )
+
+    # Created a view with blocks
+    view_data = {
+    "type": "modal",
+    "callback_id": "key_ownership_modal",
+    "title": {
+        "type": "plain_text",
+        "text": "Key Handling"
+    },
+    "blocks": blocks
+}
+
+   return view_data
+"""
+
+
diff --git a/bro/scripts/keys/schema.py b/bro/scripts/keys/schema.py
@@ -0,0 +1,44 @@
+keys_data_schema = {
+    "keys": {
+        "type": dict,
+        "schema": {
+            "owner": {
+                "type": str,
+                "nullable": False
+            }
+        }
+    }
+}
+
+#finl schema
+keys_data = {
+    "key1": {
+        "key_name": "key1",
+        "owner": None,
+    },
+    "key2": {
+        "key_name": "key2",
+        "owner": None,
+    },
+    "key3": {
+        "key_name": "key3",
+        "owner": None,
+    },
+    "key4": {
+        "key_name": "key4",
+        "owner": None,
+    },
+}
+
+
+
+
+
+key = {
+    "key1": str,
+    "key2": str,
+    "key3": str,
+    "key4": str,
+    "key5": str,
+    "key6": str
+}
diff --git a/bro/scripts/keys/services.py b/bro/scripts/keys/services.py
@@ -0,0 +1,33 @@
+from ...services import redisService
+from . import schema
+
+
+#Initializing Refis Client
+
+redis_client = redisService.RedSis()
+redis_client.redisInit()
+
+
+# Function to load key ownership data from a YAML file
+def load_keys_data():
+    keys_data = redis_client.getValue("keys_data")
+
+    if keys_data is None:
+        keys_data = {"keys": {}}
+
+    return keys_data
+
+
+# Function to save key ownership data to a YAML file
+def save_keys_data(keys_data):    
+    redis_client.setValue("keys_data", keys_data)
+
+
+
+
+# Function to extract user ID and key name from a message
+def extract_user_and_key(message):
+    parts = message.split()
+    user_id = parts[1]
+    key_name = parts[3]
+    return user_id.strip(), key_name.strip()
diff --git a/bro/scripts/lab/lab.py b/bro/scripts/lab/lab.py
@@ -0,0 +1,66 @@
+from  ...services import dB
+import re
+from ...services import redisService
+
+redis_client = redisService.RedSis()
+redis_client.redisInit()
+
+
+def handle_lab_status(message):
+    pattern = r"\blab is (open|closed)\b"
+    match = re.search(pattern, message)
+    test = match.group()
+    #print(test)
+    txt = test.split()
+    text = txt[2]
+    #print(text)
+
+    lab_status = dB.laod_lab_status()
+    print(lab_status)
+    response = ""
+    if text == 'open':
+        if(lab_status['status'] == 'open'):
+           response = f"hahaha lab is already {lab_status['status']}"
+        else:
+            lab_status['status'] = 'open'
+            response = f"Okay, Lab is {lab_status['status']}"
+    elif text == 'closed':
+        if(lab_status['status'] == 'closed'):
+           response = f"hahaha lab is already {lab_status['status']}"
+        else:
+            lab_status['status'] = 'closed'
+            response = f"Okay, Lab is {lab_status['status']}"
+
+    dB.save_lab_status(lab_status)    
+    print(lab_status)
+    return response
+
+
+
+def handle_isLab_status(message):
+    print('hi')
+    pattern = r"\bis lab (open|closed)\b"
+    match = re.search(pattern, message)
+    test = match.group()
+    print(test)
+    #print(test)
+    txt = test.split()
+    text = txt[2]
+    print(text)
+
+    response = ""
+    lab_status = dB.laod_lab_status()
+
+    if text == 'open':
+        if(lab_status['status'] == 'open'):
+           response = f"Yes, the lab is open"
+        else:
+            response = f"No, the lab is closed"
+    elif text == 'closed':
+        if(lab_status['status'] == 'closed'):
+           response = f"Yes, the lab is closed"
+        else:
+            lab_status['status'] = 'closed'
+            response = f"No, the Lab is open"
+
+    return response
diff --git a/bro/scripts/roles/roles.py b/bro/scripts/roles/roles.py
@@ -0,0 +1,58 @@
+from ...services import redisService
+
+
+
+redisStore = redisService.RedSis()
+redisStore.redisInit()
+
+def handleDeleteRole(userId, notRole):
+    userDB = redisStore.getValue('userDBtest1')
+    if(userDB.get(userId, False)):
+        userRoles = userDB[userId]['roles']
+        if(notRole.lower() in userRoles):
+            userRoles.remove(notRole.lower())
+            userDB[userId]['roles'] = userRoles
+            redisStore.setValue('userDBtest1', userDB)
+            return f'<@{userId}> is no longer {notRole}'
+        role = 'not '+ notRole
+        userRoles.append(role.lower())
+        userDB[userId]['roles'] = userRoles
+        redisStore.setValue('userDBtest1', userDB)
+        return f'OK! <@{userId}> is {role}' 
+
+
+
+
+
+def handleSetRole(userId, role):
+    userDB = redisStore.getValue('userDBtest1')
+    if(userDB.get(userId, False)):
+        userRoles = userDB[userId]['roles']
+        if(role.lower() in userRoles):
+            return f'<@{userId}> is already {role}'
+        userRoles.append(role.lower())
+        userDB[userId]['roles'] = userRoles
+        redisStore.setValue('userDBtest1', userDB)
+        # print(userDB[userId]['roles'])
+        # print(redisStore.getValue('userDBtest1')[userId]['roles'])
+        return f'OK! <@{userId}> is {role}' 
+    else:
+        return f'<@{userId}> ?? never heard of them :(' 
+
+
+
+def handleGetRole(userId):
+    userDB = redisStore.getValue('userDBtest1')
+    userEntity = userDB[userId]
+    userRoles = userEntity['roles']
+    print(userRoles)
+
+    roleScript = ''
+
+    for role in userRoles:
+        roleScript += role + ', '
+
+    roleScript = roleScript[:-2] + '.'
+
+    return f'<@{userId}> is {roleScript}'
+
diff --git a/bro/scripts/scores/schema.py b/bro/scripts/scores/schema.py
@@ -0,0 +1,15 @@
+scores_data_schema = {
+    "users": {
+        "type": dict,
+        "schema": {
+            "name": {
+                "type": str,
+                "nullable": False
+            },
+            "score": {
+                "type": int,
+                "nullable": False
+            }
+        }
+    }
+}
diff --git a/bro/scripts/scores/scores.py b/bro/scripts/scores/scores.py
@@ -0,0 +1,127 @@
+import os
+from slack_bolt import App
+from ...services import dB
+from . import services
+from collections import defaultdict
+import re
+# Function to initialize user scores data from a YAML file
+
+def handle_user_score(message):
+    user_data = dB.load_user_data()
+
+    print('hi')
+    user_operators = defaultdict(list)
+    pattern = r'<@(\w+)>\s*(\+\+|\-\-)'
+
+    matches = re.finditer(pattern , message)
+
+    for match in matches:
+        user , operator = match.groups()
+        print(user_data[user]['score'])
+        user_operators[user].append(operator)  
+    print(user_operators)
+
+
+    compliments = {
+        "++": "Great job! Your score increased by 1.",
+        "--": "Oops! Your score decreased by 1."
+    }
+
+    print(user_operators.items())
+
+    compliment_messages = []
+
+    for user, operators in user_operators.items():
+        print(user)
+        for operator in operators:
+            print(operator)
+            if operator == '++':
+                user_data[user]['score'] = str(int(user_data[user]['score']) + 1)
+                compliment_messages.append(f"{compliments['++']}. <@{user}> your score is now {user_data[user]['score']}")
+            elif operator == '--':
+                user_data[user]['score'] = str(int(user_data[user]['score']) - 1)
+                compliment_messages.append(f"{compliments['--']}. <@{user}> your score is now {user_data[user]['score']}")
+
+
+    dB.save_user_data(user_data)
+
+    compliment_message = '\n'.join(compliment_messages)
+
+    return compliment_message
+
+
+
+    '''user, operator = services.extract_user_and_operator(message)
+    user 
+    print(f"{user} , {operator}")
+
+    user_data = dB.load_user_data()
+    user_info = user_data[user]
+    print(user_data)
+
+    if user and operator and user_info:
+        if(operator == '++'):
+            user_info["score"] = str( int(user_info['score']) + 1)
+            compliment = compliment = "Great job! "
+        elif(operator == '--'):
+            user_info['score'] = str( int(user_info['score']) - 1)
+            compliment = "Oops! Your score decreased by 1."
+        
+    else:
+        return f"<@{user}>??? who the fuck are  you"        
+
+        # Save the updated data to the YAML file
+    dB.save_user_data(user_data)
+    print(user_data)
+
+    return f"<@{user}>\'s score is now {user_info['score']}.{compliment}"
+
+'''
+def handle_bro_scores_message(message):
+
+    user_data = dB.load_user_data()
+    user_scores_message = "User Scores:\n"
+    for user, data in user_data.items():
+        if(data['Year'] != 'Alumni'):
+            user_scores_message += f"<@{user}>: {data['score']}\n"
+
+    return user_scores_message
+
+
+
+
+    '''blocks = [
+        {
+            "type": "section",
+            "block_id": "user_scores",
+            "text": {
+                "type": "mrkdwn",
+                "text": "SCORECARD"
+            }
+        },
+        {
+            "type": "divider"
+        }
+    ]
+        blocks.append(
+            {
+                "type": "section",
+                "text": {
+                    "type": "mrkdwn",
+                    "text": f"*{name} - {score}*"
+                }
+            }
+        )
+
+    # Create a view with the blocks
+    view_data = {
+        "type": "modal",
+        "callback_id": "user_scores_modal",
+        "title": {
+            "type": "plain_text",
+            "text": "User Scores"
+        },
+        "blocks": blocks
+    }
+    
+    return view_data'''
diff --git a/bro/scripts/scores/services.py b/bro/scripts/scores/services.py
@@ -0,0 +1,21 @@
+from ...services import redisService
+import re
+from .schema import scores_data_schema
+
+
+redis_client = redisService.RedSis()
+redis_client.redisInit()
+
+
+def extract_user_and_operator(message):
+    pattern = '<@(.{11})>(\+\+)|<@(.{11})>.(\+\+)|<@(.{11})>(\-\-)|<@(.{11})>.(\-\-)'
+    lister = re.findall(pattern , message)
+    user = lister[0][0] or lister[0][2] or lister[0][4] or lister[0][6]
+    operator = lister[0][1] or lister[0][3] or lister[0][5] or lister[0][7]
+
+    # print(lister)
+    # print(user)
+
+
+
+    return user , operator
diff --git a/bro/services/.DS_Store b/bro/services/.DS_Store
diff --git a/bro/services/cron.py b/bro/services/cron.py
@@ -0,0 +1,13 @@
+import schedule
+import time
+import datetime
+
+def your_function():
+    print("Your function is running at exactly .")
+
+# Schedule the function to run at 00:05 AM every day
+schedule.every().day.at("17:41").do(your_function)
+
+def broCron():
+    schedule.run_pending()
+    print('chck')
diff --git a/bro/services/dB.py b/bro/services/dB.py
@@ -0,0 +1,31 @@
+from . import redisService
+
+redis_client = redisService.RedSis()
+redis_client.redisInit()
+
+def load_user_data():
+
+    user_data = redis_client.getValue("userDBtest1")
+
+    if user_data is None:
+        user_data = None
+
+
+    return user_data
+
+# Function to save user scores data to Redis
+def save_user_data(user_data):
+
+    redis_client.setValue("userDBtest1", user_data)
+
+def laod_lab_status():
+    lab_status = redis_client.getValue("test_lab_status")
+
+    if lab_status is None:
+        lab_status = None
+
+    return lab_status
+
+
+def save_lab_status(lab_status):
+    redis_client.setValue("test_lab_status" , lab_status)
diff --git a/bro/services/redisService.py b/bro/services/redisService.py
@@ -0,0 +1,124 @@
+import redis
+import os
+from dotenv import load_dotenv
+import json
+import csv
+
+
+load_dotenv()
+
+class RedSis:
+  r=0
+
+  def redisInit(self):
+    try:
+      self.r = redis.Redis(
+        host=os.environ.get("REDIS_HOST"),
+        port=os.environ.get("REDIS_PORT"),
+        password=os.environ.get("REDIS_PASSWORD")
+      )
+      #could be better connections depending on the bot using the store
+      # print("[REDIS] Connection successful")
+    except:
+      print("[REDIS] Connection Failed")
+
+  def setValue(self, key:str, value):
+    try:
+      if(isinstance(value,dict)):
+        value_json = json.dumps(value)
+        self.r.set(key, value_json)
+        return
+      self.r.set('key', 'value')
+    except Exception as e:
+      print(f"[REDIS] error in setting the value [{key}] : {str(e)}")
+
+
+  def getValue(self, key):
+    try:
+        data_json = self.r.get(key)
+        if data_json is not None:
+            data = json.loads(data_json.decode('utf-8'))
+            return data
+        else:
+            return None
+    except Exception as e:
+        print(f"Error in getting data: {str(e)}")
+        return None
+
+def main():
+  lol = RedSis()
+  lol.redisInit()
+  lol.setValue('hell', 'hi')
+  print(lol.getValue('hell'))
+  lol.setValue('hell', 'new')
+  print(lol.getValue('hell'))
+
+
+if __name__ == "__main__":
+    main()
+'''
+redis_client = RedSis()
+redis_client.redisInit()
+lab_status = {
+   "status" : "open",
+}
+redis_client.setValue("test_lab_status" , lab_status)
+status = redis_client.getValue("test_lab_status")
+print(status)'''
+
+
+
+
+if __name__ == "__main__":
+   pass
+
+
+"""
+def process_csv_and_store_data():
+    individuals = {}
+    
+    with open('data.csv', 'r') as csv_file:
+        csv_reader = csv.DictReader(csv_file)
+        for row in csv_reader:
+            
+            
+
+            individual_data = {
+                "Name": row['Name'],
+                "Phone No": row['Phone No'],
+                "Email Id": row["Email Id"],
+                "DOB": row['DOB'],
+                "Year": row['Year'],
+                "Branch": row['Branch'],
+                "Enrollment Number": row['Enrollment Number'],
+                "Room No": row['Room No'],
+                "GITHUB ID": row['GITHUB ID'],
+                "FB ID": row['FB ID'],
+                "SLACK USER ID": row['SLACK USER ID'],
+                "membership_status": row["membership_status"],
+                "Home Address": row['Home Address'],
+            }
+            
+            individuals[individual_data['Email Id']] = individual_data
+
+
+    
+    redis_client.setValue('all_individuals', individuals)
+
+    #data = redis_client.getValue('all_individuals')
+    test = redis_client.getValue('all_individuals')
+    data = test['agarwalpratham1812@gmail.com']
+    data1 = data['Name']
+    return data1
+
+
+all_data = process_csv_and_store_data()
+
+print(all_data)"""
+
+
+
+
+
+
+
diff --git a/bro/views.py b/bro/views.py
@@ -1,8 +1,134 @@
-def yo():
+
+from .scripts.keys.keys import handle_key_claim , handle_bro_keys_message
+from .scripts.scores.scores import handle_bro_scores_message, handle_user_score
+<<<<<<< HEAD
+from .scripts.bye.bye import goodNight
+from .scripts.roles.roles import handleSetRole,handleGetRole, handleDeleteRole
+from .scripts.batchScore.batchScore import getBatchScore
+from .scripts.birthday.birthday import getBirthday
+from .scripts.help import help
+import re
+from datetime import datetime
+
+
+
+=======
+from .scripts.info.info import handle_user_info
+from .scripts.google.google_cse import handle_google_image_query,handle_google_animate_query
+from .scripts.google import google_maps
+from .scripts.api_scripts import bro_quotes
+from .scripts.api_scripts import random
+from .scripts.lab.lab import handle_lab_status, handle_isLab_status
+>>>>>>> 7884ed8e9c1a3d7d73a4b724cc0939001ba2504e
+
+def yo(message):
     print("bro.views.yo()")
     return "yo"
 
 
-def bro():
+def bro(message):
     print("bro.views.bro()")
     return "bro"
+
+def bye(message):
+    return goodNight(message)
+
+
+def bro_keys_claim(message):
+    return handle_key_claim(message)
+
+
+def bro_keys(message): 
+    return handle_bro_keys_message(message)
+
+def bro_user_scores(message):
+    return handle_user_score(message)
+
+def bro_score_message(message):
+    return handle_bro_scores_message(message)
+
+def bro_ping(message):
+    return "pong"
+
+def testing_message(message):
+    print(message)
+    return "test-ed"
+
+
+def setRole(message):
+    pattern = r'@([\w .\-_]+)'
+    userId = re.findall(pattern, message)[0]
+    role = message.split(" is ")[1]
+    if 'not' in role:
+        notRole = role.replace('not ', '')
+        return handleDeleteRole(userId, notRole)
+
+    return handleSetRole(userId, role)
+
+
+def getRole(message):
+    pattern = r'@([\w .\-_]+)'
+    userId = re.findall(pattern, message)[0]
+
+    return handleGetRole(userId)
+
+def batchScore(message):
+    pattern1 = r'b(\d\d)'
+    pattern2 = r'[\d]y'
+    batch = re.findall(pattern1, message)
+    currentYear = (int(datetime.now().year)) %100
+    if(batch):
+        batch = int(re.findall(pattern1, message)[0])
+        if(batch>=currentYear and batch<=currentYear+3):
+            batch = str(4 - (batch - currentYear)) + 'y'
+            return getBatchScore(message,batch)
+        elif(batch<currentYear):
+            return f'Not worth scores anymore ;)'
+        else:
+            return f'They\'re not here yet!'
+    else:
+        batchNo = int (re.findall(pattern2, message)[0].replace('y',''))
+        batch = re.findall(pattern2, message)[0]
+        if(batchNo>4):
+            return f'Not worth scores anymore ;)'
+        print(batch)
+        return getBatchScore(message, batch)
+
+
+    # if(batch == 'b26' or batch == '4y'):
+    #     return batchScore(message, 'b26')
+
+def birthday(message):
+    pattern = r'@([\w .\-_]+)'
+    userId = re.findall(pattern, message)[0]
+
+    return getBirthday(userId)
+
+def gethelp(message):
+    return help(message)
+def user_info(message):
+    return handle_user_info(message)
+
+def google_image_query(message):
+    return handle_google_image_query(message)
+
+def google_animate_query(message):
+   return handle_google_animate_query(message)
+
+def google_map_query(message):
+    return google_maps.handle_google_map_query(message)
+
+def bro_quote(message):
+    return bro_quotes.handle_quote(message)
+
+def bro_toss(message):
+    return random.random_toss(message)
+
+def bro_dice(message):
+    return random.random_dice(message)
+
+def bro_lab_status(message):
+    return handle_lab_status(message)
+
+def bro_isLab_status(message):
+    return handle_isLab_status(message)
diff --git a/data.csv b/data.csv
diff --git a/ex.py b/ex.py
@@ -0,0 +1,5 @@
+from datetime import datetime
+
+year = datetime.datetime.now().year
+
+print("Current Year:", year)
diff --git a/poetry.lock b/poetry.lock
diff --git a/pyproject.toml b/pyproject.toml
@@ -8,6 +8,12 @@ readme = "README.md"
 [tool.poetry.dependencies]
 python = "^3.10"
 slack-bolt = "^1.18.0"
+pyyml = "^0.0.2"
+python-dotenv = "^1.0.0"
+redis = "^5.0.1"
+certifi = "^2023.7.22"
+axios = "^0.4.0"
+
 
 
 [tool.poetry.group.dev.dependencies]

diff --git a/sis/patterns.py b/sis/patterns.py
@@ -2,6 +2,5 @@
 from . import views
 
 patterns = [
-    (r"^bro\s", views.hi),
-    (r"^sis\s", views.sis),
+
 ]
diff --git a/sisbot/app.py b/sisbot/app.py
@@ -3,7 +3,13 @@
 from slack_bolt import App
 from routing.routing import init, route
 
+import csv
+from core.services import redis_service
+
+
 load_dotenv()
+os.environ.setdefault('APPS', '.conf.settings.APPS')
+
 
 app = App(
     token=os.environ.get("SLACK_BOT_TOKEN"),
@@ -12,14 +18,142 @@
 
 # Initialize routing
 init()
+'''
+def populate():
+    realNameToSlackId = {}
+    userDB = {}
+    
+    redisStore = redis_service.RedSis()
+    redisStore.redisInit()
+    
+    listed = app.client.users_list()
+    memberList = listed["members"]
+    
+    for member in memberList:
+        if(member.get('real_name', False)):
+            realNameToSlackId[member["real_name"]] = {
+                "id" : member["id"],
+                "displayName" : member["profile"]['display_name']
+            }
+        
+     with open('data.csv', 'r') as file:
+        csv_reader = csv.DictReader(file)
+        
+        for row in csv_reader:
+            # print(f'{row["Name"]} : if condition: {realNameToSlackId.get(row["Name"], False)}')
+            if(realNameToSlackId.get(row["Name"], False)):
+                userId = realNameToSlackId[row["Name"]]['id']
+                displayName = realNameToSlackId[row["Name"]]['displayName']
+                
+                userDB[userId] = {
+                    "displayName": displayName,
+                
+                    "name": row["Name"],
+                
+                    "phoneNo":row['Phone No'],
+                    "emailId" : row['Email Id'],
+                    "dob" : row["DOB(dd/mm/yyyy)"],
+                    "Year" : row['Year'],
+                    "Branch": row['Branch'],
+                    "enrollmentNo" : row['Enrollment Number'],
+                    "roomNo" : row['Room No'],
+                    "gitHubId" : row['GITHUB ID'],
+                    "slackUserId": row['SLACK USER ID'],
+                    
+                    "score" : "0",
+                    "roles" : []
+                }    
+    redisStore.setValue("userDBtest1",userDB)
+    #print(redisStore.getValue("userDBtest1"))
+
+    redisStore.setValue('nameToUserId' , realNameToSlackId)
+   # print(redisStore.getValue('nameToUserId'))
+
+populate()
+
+'''
+
+
+
+
+
+def populate():
+    realNameToSlackId = {}
+    userDB = {}
+    batches = {}
+
+    redisStore = redis_service.RedSis()
+    redisStore.redisInit()
+
+    listed = app.client.users_list()
+    memberList = listed["members"]
+
+    for member in memberList:
+        if(member.get('real_name', False)):
+            realNameToSlackId[member["real_name"]] = {
+                "id" : member["id"],
+                "displayName" : member["profile"]['display_name']
+            }
+        #add email func
+    with open('data.csv', 'r') as file:
+        csv_reader = csv.DictReader(file)
+
+        for row in csv_reader:
+            # print(f'{row["Name"]} : if condition: {realNameToSlackId.get(row["Name"], False)}')
+            if(realNameToSlackId.get(row["Name"], False)):
+                userId = realNameToSlackId[row["Name"]]['id']
+                displayName = realNameToSlackId[row["Name"]]['displayName']
+
+                if not (batches.get(row['Year'], False)):
+                    batches[row['Year']] = []
+
+                batches[row['Year']].append(userId)
+
+
+
+                userDB[userId] = {
+                    "displayName": displayName,
+
+                    "name": row["Name"],
+
+                    "phoneNo":row['Phone No'],
+                    "emailId" : row['Email Id'],
+                    "dob" : row["DOB(dd/mm/yyyy)"],
+                    "Year" : row['Year'],
+                    "Branch": row['Branch'],
+                    "enrollmentNo" : row['Enrollment Number'],
+                    "roomNo" : row['Room No'],
+                    "gitHubId" : row['GITHUB ID'],
+                    "slackUserId": row['SLACK USER ID'],
+
+                    "score" : "0",
+                    "roles" : []
+                }    
+
+    ############################## ~~data populated in db
+    # redisStore.setValue("userDBtest1",userDB)
+    # print(redisStore.getValue("userDBtest1"))
+    # redisStore.setValue("nameToUserId",realNameToSlackId)
+    # print(redisStore.getValue("nameToUserId"))
+    # redisStore.setValue("batchesData",batches)
+    # print(redisStore.getValue("batchesData"))
+
+
+# populate()
+
+
+
 
 
 @app.message()
 def message_hello(message, say):
+    sender = message['user']
+    channelId = message['channel']
     response = route(message["text"])
     if response != None and response != "":
         say(response)
 
 
+
 if __name__ == "__main__":
-    app.start(port=int(os.environ.get("PORT", 3000)))
+    app.start(port=int(os.environ.get("PORT", 3000)))
diff --git a/sisbot/conf/settings.py b/sisbot/conf/settings.py
@@ -1,4 +1,5 @@
 from pathlib import Path
+import os
 
 BASE_DIR = Path(__file__).resolve().parent.parent.parent
 

diff --git a/sisbot/core/services/data.csv b/sisbot/core/services/data.csv
diff --git a/sisbot/core/services/redis_service.py b/sisbot/core/services/redis_service.py
@@ -0,0 +1,97 @@
+import redis
+import os
+from dotenv import load_dotenv
+import json
+import csv
+
+load_dotenv()
+
+class RedSis:
+  r=0
+
+  def redisInit(self):
+    try:
+      self.r = redis.Redis(
+        host=os.environ.get("REDIS_HOST"),
+        port=os.environ.get("REDIS_PORT"),
+        password=os.environ.get("REDIS_PASSWORD")
+      )
+      #could be better connections depending on the bot using the store
+      # print("[REDIS] Connection successful")
+    except:
+      print("[REDIS] Connection Failed")
+
+  def setValue(self, key:str, value):
+    try:
+      if(isinstance(value,dict)):
+        value_json = json.dumps(value)
+        self.r.set(key, value_json)
+        return
+
+      self.r.set(key, value)
+    except:
+      print(f"[REDIS] error in setting the value [{key}]")
+
+  def getValue(self, key):
+    try:
+            data_json = self.r.get(key)
+            if data_json is not None:
+                data = json.loads(data_json.decode('utf-8'))
+                return data
+            else:
+                return None
+    except Exception as e:
+            print(f"Error in getting data: {str(e)}")
+            return None
+
+
+
+
+# # lol.setValue("keys_data", keys_data)
+# print(lol.getValue("keys_data"))
+
+
+# with open('data.csv', 'r') as file:
+#     csv_reader = csv.reader(file)
+#     header = next(csv_reader)
+
+#     for row in csv_reader:
+#         member = {
+#             "slackMemberId": "",
+#             "displayName":"",
+
+#             "name": row[0],
+
+#             "phoneNo":row[1],
+#             "emailId" : row[2],
+#             "dob" : row[3],
+#             "Year" : row[4],
+#             "Branch": row[5],
+#             "enrollmentNo" : row[6],
+#             "roomNo" : row[7],
+#             "githubId": row[8],
+#             "fbId": row[9],
+#             "homeAddress":row[12],
+
+#             "score" : "",
+#             "roles" : []
+#         }
+#         # print(row)
+#         members.append(member)
+
+
+# userDb = {
+#   "members":members
+# }
+
+
+
+
+def main():
+  # lol.setValue("userDBtest", user_db)
+  lol = RedSis()
+
+
+
+if __name__ == "__main__":
+    main()
diff --git a/sisbot/routing/routing.py b/sisbot/routing/routing.py
@@ -2,6 +2,7 @@
 import re
 from importlib import import_module
 
+
 allowed_patterns = []
 
 
@@ -10,7 +11,10 @@ def init():
 
 
 def load_apps():
-    apps = list(os.environ.get("APPS").split(","))
+    apps = [
+        "sis" , 
+        "bro"
+            ]
     # apps = ["bro", "sis"]
     for app in apps:
         mod = import_module(f"{app}.patterns")
@@ -24,9 +28,13 @@ def route(message: str):
         if re.match(pattern[0], message):
             print(f"Matched {pattern[0]}")
             # Not returning here so that allpatterns are matched
-            response = pattern[1]()
+            response = pattern[1](message)
     return response
 
 
 if __name__ == "__main__":
     load_apps()
+
+
+
+