convertion query to ORM

sasi2312 · sasi2312 · commit ac775c384959 · 2024-08-06T15:08:17.000+05:30
diff --git a/app.py b/app.py
@@ -3,16 +3,24 @@
 from collections import defaultdict
 from flasgger import Swagger
 import re,os,traceback
-from query import PostgresQuery
+from query import PostgresQuery,PostgresORM
 from utils import *
 from flask_cors import CORS,cross_origin
 from v2_app import v2
+from flask_sqlalchemy import SQLAlchemy
+from models import db
+
 
 
 app = Flask(__name__)
 CORS(app,supports_credentials=True)
 
 
+app.config['SQLALCHEMY_DATABASE_URI'] = SupabaseInterface.get_postgres_uri()
+app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
+
+db.init_app(app)
+
 Swagger(app)
 
 GITHUB_TOKEN =os.getenv('GITHUB_TOKEN')
@@ -128,9 +136,16 @@ def get_issues():
               type: string
     """
     try:
-      # Fetch all issues with their details       
+      # Fetch all issues with their details            
+      data = PostgresORM.get_issue_query()
+      response = []
       
-      response = PostgresQuery.get_issue_query()
+      for result in data:
+        response.append({
+            'org_id': result.org_id,
+            'org_name': result.org_name,
+            'issues': result.issues
+        })
                                   
       return jsonify({"issues": response})
       
@@ -183,12 +198,13 @@ def get_issues_by_owner(owner):
     try:
                
         # Fetch organization details from dmp_orgs table
-        response = PostgresQuery.get_issue_owner(owner)
-        
+        response = PostgresORM.get_issue_owner(owner)       
         if not response:
             return jsonify({'error': "Organization not found"}), 404
-        
-        return jsonify(response)
+          
+        orgs_dict = [org.to_dict() for org in response]
+
+        return jsonify(orgs_dict)
       
     except Exception as e:
         error_traceback = traceback.format_exc()
diff --git a/db.py b/db.py
@@ -56,6 +56,14 @@ def get_postgres_connection():
         )
         return conn
     
+    def get_postgres_uri():
+        DB_HOST = os.getenv('POSTGRES_DB_HOST')
+        DB_NAME = os.getenv('POSTGRES_DB_NAME')
+        DB_USER = os.getenv('POSTGRES_DB_USER')
+        DB_PASS = os.getenv('POSTGRES_DB_PASS')
+        
+        return f'postgresql://{DB_USER}:{DB_PASS}@{DB_HOST}/{DB_NAME}'
+    
     def postgres_query(query,params=None):        
         conn = SupabaseInterface.get_postgres_connection()
 
diff --git a/models.py b/models.py
@@ -0,0 +1,141 @@
+from flask import Flask
+from flask_sqlalchemy import SQLAlchemy
+from datetime import datetime
+
+db = SQLAlchemy()
+
+class DmpOrg(db.Model):
+    __tablename__ = 'dmp_orgs'
+
+    id = db.Column(db.Integer, primary_key=True, autoincrement=True)
+    created_at = db.Column(db.DateTime, default=datetime.utcnow, nullable=False)
+    name = db.Column(db.String, nullable=False)
+    description = db.Column(db.Text, nullable=True)
+    link = db.Column(db.String, nullable=False)
+    repo_owner = db.Column(db.String, nullable=False)
+
+    # Relationship to DmpIssueUpdate
+    issues = db.relationship('DmpIssueUpdate', backref='organization', lazy=True)
+    
+    # Updated relationship name to avoid conflict
+    dmp_issues = db.relationship('DmpIssue', backref='organization', lazy=True)
+    
+    def __repr__(self):
+        return f"<DmpOrg(id={self.id}, name={self.name})>"
+    
+    def to_dict(self):
+        return {
+            'id': self.id,
+            'created_at': self.created_at.isoformat(),
+            'name': self.name,
+            'description': self.description,
+            'link': self.link,
+            'repo_owner': self.repo_owner
+        }
+
+class DmpIssue(db.Model):
+    __tablename__ = 'dmp_issues'
+
+    id = db.Column(db.Integer, primary_key=True, autoincrement=True)
+    issue_url = db.Column(db.String, nullable=False)
+    issue_number = db.Column(db.Integer, nullable=False)
+    mentor_username = db.Column(db.String, nullable=True)
+    contributor_username = db.Column(db.String, nullable=True)
+    title = db.Column(db.String, nullable=False)
+    org_id = db.Column(db.Integer, db.ForeignKey('dmp_orgs.id'), nullable=False)
+    description = db.Column(db.Text, nullable=True)
+    repo = db.Column(db.String, nullable=True)
+    
+    
+    # Relationship to Prupdates
+    pr_updates = db.relationship('Prupdates', backref='pr_details', lazy=True)
+
+    def __repr__(self):
+        return f"<DmpIssue(id={self.id}, title={self.title})>"
+    
+    def to_dict(self):
+        return {
+            'id': self.id,
+            'issue_url': self.issue_url,
+            'issue_number': self.issue_number,
+            'mentor_username': self.mentor_username,
+            'contributor_username': self.contributor_username,
+            'title': self.title,
+            'org_id': self.org_id,
+            'description': self.description,
+            'repo': self.repo
+        }
+
+class DmpIssueUpdate(db.Model):
+    __tablename__ = 'dmp_issue_updates'
+
+    created_at = db.Column(db.DateTime, default=datetime.utcnow, nullable=False)
+    body_text = db.Column(db.Text, nullable=False)
+    comment_link = db.Column(db.String, nullable=False)
+    comment_id = db.Column(db.BigInteger, primary_key=True, nullable=False)
+    comment_api = db.Column(db.String, nullable=False)
+    comment_updated_at = db.Column(db.DateTime, nullable=False)
+    dmp_id = db.Column(db.Integer, db.ForeignKey('dmp_orgs.id'), nullable=False)
+    created_by = db.Column(db.String, nullable=False)
+
+    def __repr__(self):
+        return f"<DmpIssueUpdate(comment_id={self.comment_id}, dmp_id={self.dmp_id})>"
+    
+    def to_dict(self):
+        return {
+            'created_at': self.created_at.isoformat(),
+            'body_text': self.body_text,
+            'comment_link': self.comment_link,
+            'comment_id': self.comment_id,
+            'comment_api': self.comment_api,
+            'comment_updated_at': self.comment_updated_at.isoformat(),
+            'dmp_id': self.dmp_id,
+            'created_by': self.created_by
+        }
+
+class Prupdates(db.Model):
+    __tablename__ = 'dmp_pr_updates'
+
+    created_at = db.Column(db.DateTime, nullable=False, default=datetime.utcnow)
+    pr_id = db.Column(db.Integer, nullable=False,primary_key=True)
+    status = db.Column(db.String, nullable=False)
+    title = db.Column(db.String, nullable=False)
+    pr_updated_at = db.Column(db.DateTime, nullable=False, default=datetime.utcnow)
+    merged_at = db.Column(db.DateTime)
+    closed_at = db.Column(db.DateTime)
+    dmp_id = db.Column(db.Integer, db.ForeignKey('dmp_issues.id'), nullable=False)  # ForeignKey relationship
+    link = db.Column(db.String, nullable=False)
+
+    def __repr__(self):
+            return f'<PullRequest {self.pr_id} - {self.title}>'
+
+    def to_dict(self):
+        return {
+            'created_at': self.created_at.isoformat(),
+            'pr_id': self.pr_id,
+            'status': self.status,
+            'title': self.title,
+            'pr_updated_at': self.pr_updated_at.isoformat(),
+            'merged_at': self.merged_at.isoformat() if self.merged_at else None,
+            'closed_at': self.closed_at.isoformat() if self.closed_at else None,
+            'dmp_id': self.dmp_id,
+            'link': self.link
+        }
+
+class DmpWeekUpdate(db.Model):
+    __tablename__ = 'dmp_week_updates'
+
+    id = db.Column(db.Integer, primary_key=True, autoincrement=True)
+    issue_url = db.Column(db.String, nullable=False)
+    week = db.Column(db.Integer, nullable=False)
+    total_task = db.Column(db.Integer, nullable=False)
+    completed_task = db.Column(db.Integer, nullable=False)
+    progress = db.Column(db.Integer, nullable=False)
+    task_data = db.Column(db.Text, nullable=False)
+    dmp_id = db.Column(db.Integer, nullable=False)
+
+    def __repr__(self):
+        return f"<DmpWeekUpdate(id={self.id}, week={self.week}, dmp_id={self.dmp_id})>"
+
+# if __name__ == '__main__':
+#     db.create_all()
diff --git a/query.py b/query.py
@@ -1,4 +1,6 @@
 from db import SupabaseInterface
+from models import *
+from sqlalchemy import func
 
 class PostgresQuery:
 
@@ -75,4 +77,56 @@ def get_pr_data(dmp_issue_id):
         """
         data = SupabaseInterface.postgres_query(query,(dmp_issue_id,))
         return data
+    
+    
+
+class PostgresORM:
+
+    def get_issue_query():
+        results = (
+            db.session.query(
+                DmpOrg.id.label('org_id'),
+                DmpOrg.name.label('org_name'),
+                func.json_agg(
+                    func.json_build_object(
+                        'id', DmpIssue.id,
+                        'name', DmpIssue.title
+                    )
+                ).label('issues')
+            )
+            .outerjoin(DmpIssue, DmpOrg.id == DmpIssue.org_id)
+            .group_by(DmpOrg.id)
+            .order_by(DmpOrg.id)
+            .all()
+        )
+        
+        return results
+        
+    def get_issue_owner(name):        
+        response = DmpOrg.query.filter_by(name=name).all()
+        return response
+    
+    def get_actual_owner_query(owner):
+        results = DmpOrg.query.filter(DmpOrg.name.like(f'%{owner}%')).all()
+        results = [val.to_dict() for val in results]
+        return results
+    
+     
+    def get_dmp_issues(issue_id):        
+        results = DmpIssue.query.filter_by(id=issue_id).all()
+        results = [val.to_dict() for val in results]
+        return results
+        
+        
+    def get_dmp_issue_updates(dmp_issue_id):        
+        results = DmpIssueUpdate.query.filter_by(dmp_id=dmp_issue_id).all()
+        results = [val.to_dict() for val in results]
+        return results
+        
+    
+    def get_pr_data(dmp_issue_id):       
+        pr_updates = Prupdates.query.filter_by(dmp_id=dmp_issue_id).all()
+        pr_updates_dict = [pr_update.to_dict() for pr_update in pr_updates]
+        return pr_updates_dict
+        
                 
diff --git a/v2_app.py b/v2_app.py
@@ -5,7 +5,7 @@
 from db import SupabaseInterface
 from utils import determine_week
 from v2_utils import calculate_overall_progress, define_link_data, week_data_formatter
-from query import PostgresQuery
+from query import PostgresQuery,PostgresORM
 
 
 v2 = Blueprint('v2', __name__)
@@ -20,19 +20,19 @@ def get_issues_by_owner_id_v2(owner, issue):
         
         url = f"https://github.com/{owner}"        
         
-        actual_owner = PostgresQuery.get_actual_owner_query(owner)
+        actual_owner = PostgresORM.get_actual_owner_query(owner)
         repo_owner =actual_owner[0]['repo_owner'] if actual_owner else ""
         #create url with repo owner
         url = f"https://github.com/{repo_owner}" if repo_owner else None
         
-        dmp_issue_id = PostgresQuery.get_dmp_issues(issue)
+        dmp_issue_id = PostgresORM.get_dmp_issues(issue)
         if not dmp_issue_id:
           print(f"url....{url}....{issue}")
           return jsonify({'error': "No data found in dmp_issue"}), 500
         
         dmp_issue_id = dmp_issue_id[0]        
 
-        response = PostgresQuery.get_dmp_issue_updates(dmp_issue_id['id'])
+        response = PostgresORM.get_dmp_issue_updates(dmp_issue_id['id'])    
         if not response:
             print(f"dmp_issue_id....{response}....{dmp_issue_id}")
             return jsonify({'error': "No data found in dmp_issue_updates"}), 500
@@ -85,7 +85,7 @@ def get_issues_by_owner_id_v2(owner, issue):
         }
         
         
-        pr_Data = PostgresQuery.get_pr_data(dmp_issue_id['id'])
+        pr_Data = PostgresORM.get_pr_data(dmp_issue_id['id'])        
         transformed = {"pr_details": []}
         if pr_Data:
             for pr in pr_Data:
