[Fix] as per the new DB structure

Author: VedantKhairnar

.gitignore

@@ -1,5 +1,5 @@
 dmp_2/__pycache__/*
 .env
 env/*
-
+venv
 __pycache__/*

app.py

@@ -127,88 +127,99 @@ def get_issues():
               type: string
     """
     try:
-        dmp_issue =SupabaseInterface().get_instance().client.table('dmp_issues').select('*').execute().data
+        # Fetch all issues with their details
+        dmp_issues = SupabaseInterface().get_instance().client.table('dmp_issues').select('*').execute().data
 
-        updated_issues = []
-
-        for i in dmp_issue:
-          val = SupabaseInterface().get_instance().client.table('dmp_issue_updates').select('*').eq('dmp_issue_url',i['repo_url']).execute().data 
-          if val!=[]:
-            i['issues'] = val[0] #append first obj ie all are reder same issue
-            i['org_id'] = val[0]['org_id']
-            i['org_name'] = val[0]['org_name'] 
-            
-            updated_issues.append(i)
-          
-        # Create a defaultdict of lists
+        # Create a defaultdict of lists to group issues by 'org_id'
         grouped_data = defaultdict(list)
-        # Group data by 'org_name'
-        for item in updated_issues:
-            grouped_data[item['org_name']].append(item)
+        for issue in dmp_issues:
+            # Fetch organization details for the issue
+            org_details = SupabaseInterface().get_instance().client.table('dmp_orgs').select('*').eq('id', issue['org_id']).execute().data
+            if org_details:
+                issue['org_name'] = org_details[0]['name']
+            
+            grouped_data[issue['org_id']].append(issue)
 
+        # Prepare response in the required format
         response = []
-        for org_name, items in grouped_data.items():
+        for org_id, items in grouped_data.items():
             issues = [
                 {
-                    "html_url": item['issues']['html_issue_url'],
-                    "id": item['issues']['comment_id'],
-                    "issue_number": item['issues']['issue_number'],
-                    "name": item['issues']['title']
+                    "id": item['issue_number'],
+                    "name": item['title']
                 }
                 for item in items
             ]
 
             response.append({
-                "issues": issues,
-                "org_id": items[0]['org_id'],
-                "org_name": org_name
+                "org_id": org_id,
+                "org_name": items[0]['org_name'],  # Assuming all items in the group have the same org_name
+                "issues": issues
             })
 
-        return jsonify(response)
+        return jsonify({"issues": response})
 
     except Exception as e:
         error_traceback = traceback.format_exc()
-        return jsonify({'error': str(e), 'traceback': error_traceback}), 200
-      
+        return jsonify({'error': str(e), 'traceback': error_traceback}), 500
+
 @app.route('/issues/<owner>', methods=['GET'])
 @cross_origin(supports_credentials=True)
 @require_secret_key
 def get_issues_by_owner(owner):
     """
-    Fetch issues by owner.
+    Fetch organization details by owner's GitHub URL.
     ---
     parameters:
       - name: owner
         in: path
         type: string
         required: true
-        description: The owner of the issues
+        description: The owner of the GitHub URL (e.g., organization owner)
     responses:
       200:
-        description: Issues fetched successfully
+        description: Organization details fetched successfully
         schema:
-          type: array
-          items:
-            type: object
+          type: object
+          properties:
+            name:
+              type: string
+              description: Name of the organization
+            description:
+              type: string
+              description: Description of the organization
+      404:
+        description: Organization not found
+        schema:
+          type: object
+          properties:
+            error:
+              type: string
+              description: Error message
       500:
-        description: Error fetching issues
+        description: Error fetching organization details
         schema:
           type: object
           properties:
             error:
               type: string
+              description: Error message
     """
     try:
-        response = SupabaseInterface().get_instance().client.table('dmp_issue_updates').select('*').eq('org_name', owner).order('comment_updated_at', desc=True).execute()
+        # Construct the GitHub URL based on the owner parameter
+        org_link = f"https://github.com/{owner}"
+        
+        # Fetch organization details from dmp_orgs table
+        response = SupabaseInterface().get_instance().client.table('dmp_orgs').select('name', 'description').eq('link', org_link).execute()
+        
         if not response.data:
-            return jsonify({'error': "No data found"}), 200
-        data = response.data[0]
-        return jsonify({"name": data['org_name'], "description": data['org_description']})
+            return jsonify({'error': "Organization not found"}), 404
+        
+        return jsonify(response.data)
 
     except Exception as e:
         error_traceback = traceback.format_exc()
-        return jsonify({'error': str(e), 'traceback': error_traceback}), 200
-      
+        return jsonify({'error': str(e), 'traceback': error_traceback}), 500
 
 
 @app.route('/issues/<owner>/<issue>', methods=['GET'])

v2_app.py

@@ -4,38 +4,46 @@
 from utils import require_secret_key
 from db import SupabaseInterface
 from utils import determine_week
-from v2_utils import calculate_overall_progress, define_mentors_data, week_data_formatter
+from v2_utils import calculate_overall_progress, define_link_data, week_data_formatter
 
 v2 = Blueprint('v2', __name__)
 
 
 @v2.route('/issues/<owner>/<issue>', methods=['GET'])
 @require_secret_key
 def get_issues_by_owner_id_v2(owner, issue):
-    try:         
+    try:                 
         SUPABASE_DB = SupabaseInterface().get_instance()
-        response = SUPABASE_DB.client.table('dmp_issue_updates').select('*').eq('owner', owner).eq('issue_number', issue).execute()
+        # Fetch issue updates based on owner and issue number
+
+        url = f"https://github.com/{owner}"
+        dmp_issue_id = SUPABASE_DB.client.table('dmp_issues').select('*').like('issue_url', f'%{url}%').eq('issue_number', issue).execute()
+        if not dmp_issue_id.data:
+          return jsonify({'error': "No data found"}), 500
+        
+        dmp_issue_id = dmp_issue_id.data[0]        
+        response = SUPABASE_DB.client.table('dmp_issue_updates').select('*').eq('dmp_id', dmp_issue_id['id']).execute()
+
         if not response.data:
-            return jsonify({'error': "No data found"}), 200
+            return jsonify({'error': "No data found"}), 500
+
         data = response.data
 
         final_data = []
         w_learn_url,w_goal_url,avg,cont_details,plain_text_body,plain_text_wurl = None,None,None,None,None,None
-        
+
         for val in data:
-            issue_url = "https://api.github.com/repos/{}/{}/issues/comments".format(val['owner'],val['repo'])
+            # issue_url = "https://api.github.com/repos/{}/{}/issues/comments".format(val['owner'],val['repo'])
             # week_avg ,cont_name,cont_id,w_goal,w_learn,weekby_avgs,org_link = find_week_avg(issue_url)
             # mentors_data = find_mentors(val['issue_url']) if val['issue_url'] else {'mentors': [], 'mentor_usernames': []}
 
             if val['body_text']:
                 if "Weekly Goals" in val['body_text'] and not w_goal_url:
                     w_goal_url = val['body_text']
                     plain_text_body = markdown2.markdown(val['body_text'])
-                        
                     tasks = re.findall(r'\[(x| )\]', plain_text_body)
                     total_tasks = len(tasks)
                     completed_tasks = tasks.count('x')
-                    
                     avg = round((completed_tasks/total_tasks)*100) if total_tasks!=0 else 0
 
                 if "Weekly Learnings" in val['body_text'] and not w_learn_url:
@@ -46,28 +54,27 @@ def get_issues_by_owner_id_v2(owner, issue):
             # mentors = mentors_data['mentors']
             # ment_usernames = mentors_data['mentor_usernames']
             if not cont_details:
-                cont_details = SUPABASE_DB.client.table('dmp_issues').select('*').eq('repo_url',val['dmp_issue_url']).execute().data 
-        
-        
+                cont_details = dmp_issue_id['contributor_username']
         week_data = week_data_formatter(plain_text_body,"Goals")
+        
         res = {
             "name": owner,
-            "description": val['description'],
-            "mentor": define_mentors_data(val['mentor_name']),
-            "mentor_id": val['mentor_id'] ,
-            "contributor":define_mentors_data(cont_details[0]['contributor_name']),
+            "description": dmp_issue_id['description'],
+            "mentor": define_link_data(dmp_issue_id['mentor_username']),
+            "mentor_id": dmp_issue_id['mentor_username'] ,
+            "contributor":define_link_data(cont_details),
             # "contributor_id": cont_details[0]['contributor_id'],
-            "org": define_mentors_data(val['owner'])[0] if val['owner'] else [],
+            "org": define_link_data(dmp_issue_id['mentor_username'])[0] if dmp_issue_id['mentor_username'] else [],
             "weekly_goals_html": w_goal_url,
             "weekly_learnings_html": w_learn_url,
             "overall_progress":calculate_overall_progress(week_data,12),
-            "issue_url":val['html_issue_url'],
+            "issue_url":dmp_issue_id['issue_url'],
             "pr_details":None,
             "weekly_goals":week_data,
-            "weekly_learns":week_data_formatter(plain_text_wurl,"Learnings")
+            "weekly_learnings":week_data_formatter(plain_text_wurl,"Learnings")
         }
 
-        pr_Data = SUPABASE_DB.client.table('dmp_pr_updates').select('*').eq('repo', val['repo']).eq('issue_number_title',issue).execute()
+        pr_Data = SUPABASE_DB.client.table('dmp_pr_updates').select('*').eq('dmp_id', dmp_issue_id['id']).eq('title',issue).execute()
         transformed = {"pr_details": []}
         if pr_Data.data:
             for pr in pr_Data.data:
@@ -80,13 +87,7 @@ def get_issues_by_owner_id_v2(owner, issue):
                 })
 
         res['pr_details'] = transformed['pr_details']
-        
-        # Adding each week as a separate key
-        # for week in weekby_avgs:
-        #   res.update(week)
-            
-        # final_data.append(res)
-        
+                
         return jsonify(res),200
 
     except Exception as e:

v2_utils.py

@@ -1,93 +1,72 @@
 import logging,re,markdown2
 
 # Func to create name and link for all mentors and contributors
-def define_mentors_data(mentors):
+def define_link_data(usernames):
     try:
         res = []
-        
-        if type(mentors) == list:
-            for ment in mentors:
+        if type(usernames) == list:
+            for username in usernames:
                 val = {}
-                val['name'] = ment
-                val['link'] = "https://github.com/" + ment
+                val['name'] = username
+                val['link'] = "https://github.com/" + username
                 res.append(val)
-        if type(mentors) == str:
+        if type(usernames) == str:
+            if usernames[0]=="@":
+                usernames = usernames[1:]
             val = {}
-            val['name'] = mentors
-            val['link'] = "https://github.com/" + mentors
+            val['name'] = usernames
+            val['link'] = "https://github.com/" + usernames
             res.append(val)
 
         return res
 
     except Exception as e:
-        logging.info(f"{e}---define_mentors")
+        logging.info(f"{e}---define_link_data")
         return []
 
 
-        
-def week_data_formatter(html_content,type):
+  
+def week_data_formatter(html_content, type):
+    
     try:
-        # Find all weeks
-        week_matches = re.findall(r'<h2>(Week \d+)</h2>', html_content)
-        tasks_per_week = re.findall(r'<h2>Week \d+</h2>\s*<ul>(.*?)</ul>', html_content, re.DOTALL)
-        
+        # Use regex to find week titles (e.g., Week 1, Week 2) and their corresponding task lists
+        week_matches = re.findall(r'(Week \d+)', html_content)
+        tasks_per_week = re.split(r'Week \d+', html_content)[1:]  # Split the content by weeks and skip the first empty split
+
         weekly_updates = []
-        total_tasks = 0
-        
+
         if type == "Learnings":
             for i, week in enumerate(week_matches):
-                
-                try:
-                    task_list_html = tasks_per_week[i]
-                except Exception as e:
-                    task_list_html = ""
-                    
+                task_list_html = tasks_per_week[i] if i < len(tasks_per_week) else ""
                 weekly_updates.append({
-                    'week': i+1,
-                    'content':task_list_html
+                    'week': i + 1,
+                    'content': task_list_html.strip()
                 })
-
             return weekly_updates
-        
-        else:            
+
+        else:
             for i, week in enumerate(week_matches):
-                try:
-                    task_list_html = tasks_per_week[i]
-                except Exception as e:
-                    task_list_html = ""
+                task_list_html = tasks_per_week[i] if i < len(tasks_per_week) else ""
 
-                tasks = re.findall(r'\[(x| )\] (.*?)</li>', task_list_html, re.DOTALL)
+                # Adjust regex to capture tasks regardless of the tags around them
+                tasks = re.findall(r'\[(x|X| )\]\s*(.*?)</?li>', task_list_html, re.DOTALL)
 
                 total_tasks = len(tasks)
-                completed_tasks = sum(1 for task in tasks if task[0] == 'x')
-                task_list = [{"content":i[1],"checked":True if i[0]=='x' else False} for i in tasks]
-
+                completed_tasks = sum(1 for task in tasks if task[0] in ['x', 'X'])
+                task_list = [{"content": task[1].strip(), "checked": task[0] in ['x', 'X']} for task in tasks]
 
                 avg = round((completed_tasks / total_tasks) * 100) if total_tasks != 0 else 0
 
                 weekly_updates.append({
-                    'week': i+1,
-                    # 'total_tasks': total_tasks,
-                    # 'completed_tasks': completed_tasks,
+                    'week': i + 1,
                     'progress': avg,
-                    'tasks':task_list
+                    'tasks': task_list
                 })
-                
-            
-
-            response = {
-                'number_of_weeks': len(week_matches),
-                'weekly_updates': weekly_updates
-            }
-            
-            #FIND OVERALL PROGRESS
-            
-          
 
             return weekly_updates
-           
-        
+
     except Exception as e:
+        print(f"Error: {e}")
         return []
 
 
@@ -98,7 +77,7 @@ def calculate_overall_progress(weekly_updates, default_weeks=12):
 
         # Sum the progress of each provided week
         for week in weekly_updates:
-            total_progress += week['progress']
+            total_progress += week.get('progress', 0)
 
         # Add zero progress for the remaining weeks to reach the default weeks
         total_weeks = default_weeks
@@ -110,5 +89,6 @@ def calculate_overall_progress(weekly_updates, default_weeks=12):
 
         return round(overall_progress, 2)
     except Exception as e:
+        print(f"Error: {e}")
         return 0