Badges

.github/workflows/codeql-analysis.yml

@@ -0,0 +1,70 @@
+# For most projects, this workflow file will not need changing; you simply need
+# to commit it to your repository.
+#
+# You may wish to alter this file to override the set of languages analyzed,
+# or to provide custom queries or build logic.
+#
+# ******** NOTE ********
+# We have attempted to detect the languages in your repository. Please check
+# the `language` matrix defined below to confirm you have the correct set of
+# supported CodeQL languages.
+#
+name: "CodeQL"
+
+on:
+  push:
+    branches: [ development, master ]
+  pull_request:
+    # The branches below must be a subset of the branches above
+    branches: [ development ]
+  schedule:
+    - cron: '0 8 * * 1'
+
+jobs:
+  analyze:
+    name: Analyze
+    runs-on: ubuntu-latest
+    permissions:
+      actions: read
+      contents: read
+      security-events: write
+
+    strategy:
+      fail-fast: false
+      matrix:
+        language: [ 'go', 'python' ]
+        # CodeQL supports [ 'cpp', 'csharp', 'go', 'java', 'javascript', 'python', 'ruby' ]
+        # Learn more about CodeQL language support at https://git.io/codeql-language-support
+
+    steps:
+    - name: Checkout repository
+      uses: actions/checkout@v3
+
+    # Initializes the CodeQL tools for scanning.
+    - name: Initialize CodeQL
+      uses: github/codeql-action/init@v2
+      with:
+        languages: ${{ matrix.language }}
+        # If you wish to specify custom queries, you can do so here or in a config file.
+        # By default, queries listed here will override any specified in a config file.
+        # Prefix the list here with "+" to use these queries and those in the config file.
+        # queries: ./path/to/local/query, your-org/your-repo/queries@main
+
+    # Autobuild attempts to build any compiled languages  (C/C++, C#, or Java).
+    # If this step fails, then you should remove it and run the build manually (see below)
+    - name: Autobuild
+      uses: github/codeql-action/autobuild@v2
+
+    # ℹ️ Command-line programs to run using the OS shell.
+    # 📚 https://git.io/JvXDl
+
+    # ✏️ If the Autobuild fails above, remove it and uncomment the following three lines
+    #    and modify them (or add more) to build your code if your project
+    #    uses a compiled language
+
+    #- run: |
+    #   make bootstrap
+    #   make release
+
+    - name: Perform CodeQL Analysis
+      uses: github/codeql-action/analyze@v2

.gitignore

@@ -29,12 +29,15 @@ _ignored/
 .vscode/launch.json
 .vscode/extensions.json
 *.code-workspace
-
+*.gitconfig
 # VisualStudioCode Patch
 # Ignore all local history of files
 .history
 .ionide
 
 # MacOS
 .DS_Store
-.idea
+.idea
+
+samconfig.yaml
+scripts/badges/__pycache__/create.cpython-39.pyc

badges/dynamodb.py

@@ -0,0 +1,73 @@
+import boto3
+d_client = boto3.client('dynamodb')
+
+
+class ddb_ops():
+    """Get Item"""
+
+    def get_item(self, table, crowdaction_id):
+        self.table = table
+        self.crowdaction_id = crowdaction_id
+
+        res = d_client.get_item(
+            TableName=table,
+            Key={
+                'pk': {'S': 'act'},
+                'sk': {'S': crowdaction_id}
+            }
+        )
+        return res
+
+    """Query Items"""
+
+    def query(self, table, crowdaction_id):
+        self.table = table
+        self.crowdaction_id = crowdaction_id
+
+        res = d_client.query(
+            TableName=table,
+            IndexName='invertedIndex',
+            KeyConditionExpression="sk = :sk",
+            ExpressionAttributeValues={
+                ':sk':  {'S': f'prt#act#{crowdaction_id}'}
+            },
+        )
+        return res
+
+    """Update Items"""
+
+    def update(self, table, usr_id, reward, crowdaction_id):
+        self.table = table
+        self.usr_id = usr_id
+        self.reward = reward
+        self.crowdaction_id = crowdaction_id
+
+        print("update", table, usr_id, reward, crowdaction_id)
+
+        d_client.update_item(
+            TableName=table,
+            Key={
+                'userid': {
+                    'S': usr_id,
+                }
+            },
+            AttributeUpdates={
+                'reward': {
+                    'Value': {
+                        'L': [
+                            {
+                                "M": {
+                                    "award": {
+                                        "S": reward
+                                    },
+                                    "crowdactionID": {
+                                        "S": crowdaction_id
+                                    }
+                                }
+                            },
+                        ],
+                    },
+                    'Action': 'ADD'  # this operations still pending
+                }
+            },
+        )

badges/eventbus.py

@@ -0,0 +1,132 @@
+# This function should be responsible for point system calculation
+# as well as the event rule deletion from the bus once the crowdaction
+# terminates
+
+import json
+import logging
+import boto3
+import os
+from dynamodb import *
+
+e_client = boto3.client('events')
+l_client = boto3.client('lambda')
+
+ddb = ddb_ops()
+
+commit_dict = {}  # this may be global for now
+
+
+def compute_badge_award(points, reward_list):
+    """
+     There is an assumption about the order
+     of the reward_list. This is taken into
+     account a descending order
+    """
+    if int(points) >= int(reward_list[3]):
+        return "Diamond"
+    elif int(points) >= int(reward_list[2]):
+        return "Golden"
+    elif int(points) >= int(reward_list[1]):
+        return "Silver"
+    elif int(points) >= int(reward_list[0]):
+        return "Bronze"
+    else:
+        return "No reward"
+
+
+def tree_recursion(tree):
+    for i in range(0, len(tree)):
+        t = tree[i]['M']
+        commit_key = t['id']['S']
+        commit_points = t['points']['N']
+        commit_dict[commit_key] = commit_points
+        if 'requires' in t:
+            tree_recursion(t['requires']['L'])
+
+
+def lambda_handler(event, context):
+    badge_reward_list = []
+
+    target_name = 'lambda_cron_test_end_date'
+    single_table = 'collaction-dev-edreinoso-SingleTable-BAXICTFSQ4WV'
+    profile_table = 'collaction-dev-edreinoso-ProfileTable-XQEJJNBK6UUY'
+    crowdaction_id = event['resources'][0].split(
+        '/')[1].replace('_', '#')  # prod
+    print('Lambda Crontab!', crowdaction_id)
+
+    """
+      POINT CALCULATION LOGIC
+    """
+
+    # 1. fetch the badge scale for crowdaction ✅
+    badge_scale = ddb.get_item(single_table, crowdaction_id)
+
+    tree = badge_scale['Item']['commitment_options']['L']
+    for reward in badge_scale['Item']['badges']['L']:
+        badge_reward_list.append(reward['N'])
+    # print(badge_reward_list) # verfying the badge reward list
+
+    # 2. restructure the tree to a dictionary ✅
+    tree_recursion(tree)
+    print(commit_dict)  # verifying the dictionary convertion
+
+    # 3. go through all participants ✅
+    participant_list = ddb.query(single_table, crowdaction_id)
+    print(participant_list)
+
+    # 4. map user commitment level ✅
+    user_prt_list = []  # list required to store individual participations
+    for i in range(0, len(participant_list['Items'])):
+        prt_details = participant_list['Items'][i]
+        usr_id = prt_details['userID']['S']
+        prt_lvl = prt_details['commitments']['L']
+        usr_prt_counter = 0
+        for n in range(0, len(prt_lvl)):
+            usr_prt_counter += int(commit_dict[prt_lvl[n]['S']])
+        usr_obj = {
+            "userid": usr_id,
+            "prt": prt_lvl,
+            "points": usr_prt_counter
+        }
+        print(usr_obj)
+        # if prt_lvl in commit_dict: # would I be assuming that a user would always have a participation
+        usr_obj['badge'] = compute_badge_award(
+            usr_prt_counter, badge_reward_list)
+        user_prt_list.append(usr_obj)
+
+    print(user_prt_list)
+
+    # 5. award badge ✅
+    for usr in user_prt_list:
+        ddb.update(
+            profile_table, usr['userid'], usr['badge'], crowdaction_id)
+
+    """
+      CLEANING UP TARGETS AND EVENTS
+    """
+
+    crowdaction_id_e = crowdaction_id.replace('#', '_')
+
+    # 6. delete permission ✅
+    l_client.remove_permission(
+        FunctionName=target_name,
+        StatementId=crowdaction_id_e,
+    )
+
+    # 7. delete targets ✅
+    e_client.remove_targets(
+        Rule=crowdaction_id_e,
+        Ids=[
+            crowdaction_id_e,
+        ],
+    )
+
+    # 8. delete event ✅
+    e_client.delete_rule(
+        Name=crowdaction_id_e,
+    )
+
+    return {
+        'statusCode': 200,
+        'body': json.dumps('Crowdaction Ended!')
+    }

badges/trigger.py

@@ -0,0 +1,84 @@
+"""
+ This function should be responsible for keeping track of the end date
+ of the crowdaction, to record it in the event bus for later point
+ system calculation
+"""
+
+from datetime import datetime
+import logging
+import boto3
+import json
+import random
+import string
+
+e_client = boto3.client('events')
+l_client = boto3.client('lambda')
+
+
+def lambda_handler(event, context):
+    if(event['Records'][0]['eventName'] == 'INSERT'):
+        record = event['Records'][0]['dynamodb']['NewImage']
+
+        # TODO: test this!
+        # checking for records that are only for crowdactions
+        if (record['pk']['S'] != "act"):
+            return {
+                'statusCode': 200,
+                'body': json.dumps('Event is not crowdaction')
+            }
+
+        target_arn = 'arn:aws:lambda:eu-central-1:156764677614:function:lambda_cron_test_end_date'
+        target_name = 'lambda_cron_test_end_date'
+        action = 'lambda:InvokeFunction'
+
+        title = record['title']['S']
+        description = record['description']['S']
+        date_end = record['date_end']['S']
+        crowdaction_id = record['sk']['S'].replace('#', '_')
+        # may have to handle date exception
+        date_end_expr = datetime_to_cron(
+            datetime.strptime(date_end, "%Y-%m-%d %H:%M:%S"))
+
+        # PUT TARGET
+        e_client.put_rule(
+            Name=crowdaction_id,
+            ScheduleExpression=date_end_expr,
+            State='ENABLED',
+            Description='event rule for ' + crowdaction_id,
+        )
+
+        # PUT TARGET
+        e_client.put_targets(
+            Rule=crowdaction_id,
+            Targets=[
+                {
+                    'Id': crowdaction_id,
+                    'Arn': target_arn,
+                },
+            ]
+        )
+
+        # ADD PERMISSIONS
+        l_client.add_permission(
+            FunctionName=target_name,
+            StatementId=crowdaction_id,
+            Action=action,
+            Principal='events.amazonaws.com',
+            SourceArn='arn:aws:events:eu-central-1:156764677614:rule/'+crowdaction_id,
+        )
+
+        print('rule has been placed on the bus')
+
+    return {
+        'statusCode': 200,
+        'body': json.dumps('End day has been scheduled!')
+    }
+
+
+"""
+  Function that would convert datetime into cronjobs
+"""
+
+
+def datetime_to_cron(dt):
+    return f"cron({dt.minute} {dt.hour} {dt.day} {dt.month} ? {dt.year})"