API performance improvements

ras/api/modules/crud.py

@@ -18,69 +18,88 @@ conn = engine.connect()
 
 @api_view(['GET'])
 def getAllBooks(request):
-    if(request.headers.get('Authorization')):
+    try:
-        isLoggedIn = isAuthorized(request.headers.get('Authorization'));
+        authorization_token = request.headers.get('Authorization')
+        isLoggedIn = isAuthorized(authorization_token)
 
-        if(isLoggedIn):
+        if not authorization_token:
-            books = getBooksData(request.headers.get('userid'))
+            return JsonResponse({'error': 'No authorization token'}, safe=False)
 
-            data = books.apply(lambda row: {
+        if not isLoggedIn:
-                "id": row['id'], 
-                "name": row['name'], 
-                "author": row['author'], 
-                "genre": row['genre'], 
-                "readed": row['readed'], 
-                "rating": row['rating']
-            }, axis=1).tolist()
-            
-            return Response(data)
-        else:
-            return JsonResponse({'error': 'No user detected'}, safe=False)
-    else:
             return JsonResponse({'error': 'Unauthorized'}, safe=False)
         
+        books = getBooksData(request.headers.get('userid'))
+        data = books.to_dict(orient='records')
+        return Response(data)
+    
+    except Exception as e:
+        return JsonResponse({'error': 'An error occurred: {}'.format(str(e))}, safe=False)
+
 # -------------------------------
 # Add a book into the database
 # -------------------------------
 
 @api_view(['POST'])
 def addBook(request):
-    if(request.headers.get('Authorization')):
+    try:
-        isLoggedIn = isAuthorized(request.headers.get('Authorization'));
+        authorization_token = request.headers.get('Authorization')
+        isLoggedIn = isAuthorized(authorization_token)
 
-        if(isLoggedIn):
+        if not authorization_token:
-            userid = request.headers.get('userid')
+            return JsonResponse({'error': 'No authorization token'}, safe=False)
-            book = request.body
-            book = json.loads(book)
 
-            conn.execute(text("INSERT INTO api_books (userid, name, author, genre, readed, rating) VALUES ('" + str(userid) + "', '" + str(book['name']) + "', '" + str(book['author']) + "', '" + str(book['genre']) + "', '" + str(book['readed']) + "', " + str(book['rating']) + ")"))
+        if not isLoggedIn:
-            return JsonResponse("OK", safe=False)
-        else:
-            return JsonResponse({'error': 'No user detected'}, safe=False)
-    else:
             return JsonResponse({'error': 'Unauthorized'}, safe=False)
         
+        userid = request.headers.get('userid')
+        book_data = json.loads(request.body)
+        query = text("INSERT INTO api_books (userid, name, author, genre, readed, rating) VALUES (:userid, :name, :author, :genre, :readed, :rating)")
+        conn.execute(query, {
+            'userid': userid,
+            'name': book_data['name'],
+            'author': book_data['author'],
+            'genre': book_data['genre'],
+            'readed': book_data['readed'],
+            'rating': book_data['rating']
+        })
+
+        return JsonResponse("OK", safe=False)
+        
+    except Exception as e:
+        return JsonResponse({'error': 'An error occurred: {}'.format(str(e))}, safe=False)
+
 # -------------------------------
 # Update a book in the database
 # -------------------------------
 
 @api_view(['PUT'])
 def updateBook(request):
-    if(request.headers.get('Authorization')):
+    try:
-        isLoggedIn = isAuthorized(request.headers.get('Authorization'));
+        authorization_token = request.headers.get('Authorization')
+        isLoggedIn = isAuthorized(authorization_token)
 
-        if(isLoggedIn):
+        if not authorization_token:
-            book = request.POST.get('book')
+            return JsonResponse({'error': 'No authorization token'}, safe=False)
-            book = json.loads(book)
-            bookid = request.headers.get('bookid')
 
-            conn.execute(text("UPDATE api_books set name='" + str(book['name']) + "', author='" + str(book['author']) + "', genre='" + str(book['genre']) + "', readed='" + str(book['readed']) + "', rating='" + str(book['rating']) + "' WHERE id=" + str(bookid)))
+        if not isLoggedIn:
-            return JsonResponse("OK", safe=False)
-        else:
-            return JsonResponse({'error': 'No user detected'}, safe=False)
-    else:
             return JsonResponse({'error': 'Unauthorized'}, safe=False)
         
+        book_data = json.loads(request.POST.get('book'))
+        bookid = request.headers.get('bookid')
+        query = text("UPDATE api_books SET name=:name, author=:author, genre=:genre, readed=:readed, rating=:rating WHERE id=:bookid")
+        conn.execute(query, {
+            'name': book_data['name'],
+            'author': book_data['author'],
+            'genre': book_data['genre'],
+            'readed': book_data['readed'],
+            'rating': book_data['rating'],
+            'bookid': bookid
+        })
+
+        return JsonResponse("OK", safe=False)
+        
+    except Exception as e:
+        return JsonResponse({'error': 'An error occurred: {}'.format(str(e))}, safe=False)
 
 # -------------------------------
 # Delete a book in the database
@@ -88,15 +107,23 @@ def updateBook(request):
 
 @api_view(['DELETE'])
 def deleteBook(request):
-    if(request.headers.get('Authorization')):
+    try:
-        isLoggedIn = isAuthorized(request.headers.get('Authorization'));
+        authorization_token = request.headers.get('Authorization')
+        isLoggedIn = isAuthorized(authorization_token)
 
-        if(isLoggedIn):
+        if not authorization_token:
-            bookid = request.headers.get('bookid')
+            return JsonResponse({'error': 'No authorization token'}, safe=False)
 
-            conn.execute(text("DELETE FROM api_books WHERE id = " + str(bookid)))
+        if not isLoggedIn:
-            return JsonResponse("OK", safe=False)
-        else:
-            return JsonResponse({'error': 'No user detected'}, safe=False)
-    else:
             return JsonResponse({'error': 'Unauthorized'}, safe=False)
+        
+        bookid = request.headers.get('bookid')
+        query = text("DELETE FROM api_books WHERE id=:bookid")
+        conn.execute(query, {
+            'bookid': bookid
+        })
+
+        return JsonResponse("OK", safe=False)
+        
+    except Exception as e:
+        return JsonResponse({'error': 'An error occurred: {}'.format(str(e))}, safe=False)

ras/api/modules/pandas.py

@@ -11,20 +11,25 @@ from .functions import isAuthorized, getBooksData, filterData
 
 @api_view(['GET'])
 def getYears(request):
-    if(request.headers.get('Authorization')):
+    try:
-        isLoggedIn = isAuthorized(request.headers.get('Authorization'));
+        authorization_token = request.headers.get('Authorization')
+        isLoggedIn = isAuthorized(authorization_token)
+
+        if not authorization_token:
+            return JsonResponse({'error': 'No authorization token'}, safe=False)
+
+        if not isLoggedIn:
+            return JsonResponse({'error': 'Unauthorized'}, safe=False)
     
-        if(isLoggedIn):
         df = filterData(getBooksData(request.headers.get('userid')))
         df['readed'] = pd.to_datetime(df['readed'], errors='coerce')
         df['year']= df['readed'].dt.year
         years = df.groupby('year')['year'].count().reset_index(name="count")
 
         return Response(years['year'])
-        else:
+
-            return JsonResponse({'error': 'Unauthorized'}, safe=False)
+    except Exception as e:
-    else:
+        return JsonResponse({'error': 'An error occurred: {}'.format(str(e))}, safe=False)
-        return JsonResponse({'error': 'No authorization token'}, safe=False)
 
 # ------------------------------------------------------------------
 # Get books of selected year and filter it per month and per genre
@@ -32,56 +37,55 @@ def getYears(request):
 
 @api_view(['GET'])
 def books_per_genre_per_month(request):
-    if(request.headers.get('Authorization')):
+    try:
-        isLoggedIn = isAuthorized(request.headers.get('Authorization'));
+        authorization_token = request.headers.get('Authorization')
+        isLoggedIn = isAuthorized(authorization_token)
 
-        if(isLoggedIn):
+        if not authorization_token:
-            if request.META.get('HTTP_YEAR'):
-                df = filterData(getBooksData(request.headers.get('userid')), request.META.get('HTTP_YEAR'))
-                booksPerMonth = df.groupby(['genre','readed'])['genre'].count().reset_index(name="count")  
-                booksPerMonth = booksPerMonth.sort_values(by=['genre', 'readed', 'count'], ascending=False)
-                
-                data = booksPerMonth.apply(lambda row: {
-                    'genre': row['genre'], 
-                    'readed': row['readed'], 
-                    'count': row['count']
-                }, axis=1).tolist()
-
-                return Response(data)
-            else:
-                return JsonResponse({'error': 'No year in header'}, safe=False)
-        else:
-            return JsonResponse({'error': 'Unauthorized'}, safe=False)
-    else:
             return JsonResponse({'error': 'No authorization token'}, safe=False)
 
+        if not isLoggedIn:
+            return JsonResponse({'error': 'Unauthorized'}, safe=False)
+        
+        if not request.META.get('HTTP_YEAR'):
+            return JsonResponse({'error': 'No year in header'}, safe=False)
+        
+        df = filterData(getBooksData(request.headers.get('userid')), request.META.get('HTTP_YEAR'))
+        booksPerMonth = df.groupby(['genre', 'readed']).size().reset_index(name='count')
+        booksPerMonth = booksPerMonth.sort_values(by=['genre', 'readed', 'count'], ascending=False)
+        data = booksPerMonth.to_dict(orient='records')
+        return Response(data)
+
+    except Exception as e:
+        return JsonResponse({'error': 'An error occurred: {}'.format(str(e))}, safe=False)
+    
 # ---------------------------------------------
 # Get genres of selected year with percentages
 # ---------------------------------------------
 
 @api_view(['GET'])
 def countGenres(request):
-    if(request.headers.get('Authorization')):
+    try:
-        isLoggedIn = isAuthorized(request.headers.get('Authorization'));
+        authorization_token = request.headers.get('Authorization')
+        isLoggedIn = isAuthorized(authorization_token)
+
+        if not authorization_token:
+            return JsonResponse({'error': 'No authorization token'}, safe=False)
+
+        if not isLoggedIn:
+            return JsonResponse({'error': 'Unauthorized'}, safe=False)
+        
+        if not request.META.get('HTTP_YEAR'):
+            return JsonResponse({'error': 'No year in header'}, safe=False)
         
-        if(isLoggedIn):
-            if request.META.get('HTTP_YEAR'):
         df = filterData(getBooksData(request.headers.get('userid')), request.META.get('HTTP_YEAR'))
         genres = df.groupby('genre')['genre'].count().reset_index(name="count")
         genres = genres.sort_values(by='count', ascending=False)
-                
+        data = [{"genre": genre, "count": int(count)} for genre, count in zip(genres['genre'], genres['count'])]
-                data = genres.apply(lambda row: {
-                    'genre': row['genre'], 
-                    'count': int(row['count'])
-                }, axis=1).tolist()
-                
         return Response(data)
-            else:
+
-                return JsonResponse({'error': 'No year in header'}, safe=False)
+    except Exception as e:
-        else:
+        return JsonResponse({'error': 'An error occurred: {}'.format(str(e))}, safe=False)
-            return JsonResponse({'error': 'Unauthorized'}, safe=False)
-    else:
-        return JsonResponse({'error': 'No authorization token'}, safe=False)
         
 # ----------------
 # Get year stats
@@ -89,31 +93,35 @@ def countGenres(request):
     
 @api_view(['GET'])
 def getStats(request):
-    if(request.headers.get('Authorization')):
+    try:
-        isLoggedIn = isAuthorized(request.headers.get('Authorization'));
+        authorization_token = request.headers.get('Authorization')
+        isLoggedIn = isAuthorized(authorization_token)
+
+        if not authorization_token:
+            return JsonResponse({'error': 'No authorization token'}, safe=False)
+
+        if not isLoggedIn:
+            return JsonResponse({'error': 'Unauthorized'}, safe=False)
+        
+        if not request.META.get('HTTP_YEAR'):
+            return JsonResponse({'error': 'No year in header'}, safe=False)
         
-        if(isLoggedIn):
-            if request.META.get('HTTP_YEAR'):
-                data = []
         df = filterData(getBooksData(request.headers.get('userid')), request.META.get('HTTP_YEAR'))
         df = df.dropna()
         statsTotalBooks = df['name'].count()
         statsTotalGenres = df['genre'].nunique()
-                avgratingsperyear = round((df['rating'].sum() / df['rating'].count()), 0)
+        avgratingsperyear = round(df['rating'].mean(), 0)
 
-                data.append({
+        data = {
             'totalbooks': statsTotalBooks,
             'totalgenres': statsTotalGenres,
             'avgyearrating': avgratingsperyear
-                })
+        }
 
-                return Response(data[0])
+        return Response(data)
-            else:
+
-                return JsonResponse({'error': 'No year in header'}, safe=False)
+    except Exception as e:
-        else:
+        return JsonResponse({'error': 'An error occurred: {}'.format(str(e))}, safe=False)
-            return JsonResponse({'error': 'Unauthorized'}, safe=False)
-    else:
-        return JsonResponse({'error': 'No authorization token'}, safe=False)
 
 # ------------------------------------------------
 # Get books of selected year and group by ratings
@@ -121,27 +129,26 @@ def getStats(request):
     
 @api_view(['GET'])
 def avg_ratings_per_month(request):
-    if(request.headers.get('Authorization')):
+    try:
-        isLoggedIn = isAuthorized(request.headers.get('Authorization'));
+        authorization_token = request.headers.get('Authorization')
+        isLoggedIn = isAuthorized(authorization_token)
 
-        if(isLoggedIn):
+        if not authorization_token:
-            if request.META.get('HTTP_YEAR'):
-                df = filterData(getBooksData(request.headers.get('userid')), request.META.get('HTTP_YEAR'))
-                avgratingspermonth = df.groupby('readed')['rating'].mean().reset_index(name="rating")
-                
-                data = avgratingspermonth.apply(lambda row: {
-                    'date': row['readed'], 
-                    'rating': int(row['rating'])
-                }, axis=1).tolist()
-                
-                return Response(data)
-            else:
-                return JsonResponse({'error': 'No year in header'}, safe=False)
-        else:
-            return JsonResponse({'error': 'Unauthorized'}, safe=False)
-    else:
             return JsonResponse({'error': 'No authorization token'}, safe=False)
 
+        if not isLoggedIn:
+            return JsonResponse({'error': 'Unauthorized'}, safe=False)
+        
+        if not request.META.get('HTTP_YEAR'):
+            return JsonResponse({'error': 'No year in header'}, safe=False)
+        
+        df = filterData(getBooksData(request.headers.get('userid')), request.META.get('HTTP_YEAR'))
+        avgratingspermonth = df.groupby('readed')['rating'].mean().reset_index(name="rating")
+        data = [{"date": date, "rating": int(rating)} for date, rating in zip(avgratingspermonth['readed'], avgratingspermonth['rating'])]
+        return Response(data)
+    
+    except Exception as e:
+        return JsonResponse({'error': 'An error occurred: {}'.format(str(e))}, safe=False)
 
 # -----------------------------
 # Get ratings of selected year
@@ -149,24 +156,24 @@ def avg_ratings_per_month(request):
 
 @api_view(['GET'])
 def countRatings(request):
-    if(request.headers.get('Authorization')):
+    try:
-        isLoggedIn = isAuthorized(request.headers.get('Authorization'));
+        authorization_token = request.headers.get('Authorization')
+        isLoggedIn = isAuthorized(authorization_token)
+
+        if not authorization_token:
+            return JsonResponse({'error': 'No authorization token'}, safe=False)
+
+        if not isLoggedIn:
+            return JsonResponse({'error': 'Unauthorized'}, safe=False)
+        
+        if not request.META.get('HTTP_YEAR'):
+            return JsonResponse({'error': 'No year in header'}, safe=False)
         
-        if(isLoggedIn):
-            if request.META.get('HTTP_YEAR'):
         df = filterData(getBooksData(request.headers.get('userid')), request.META.get('HTTP_YEAR'))
         countratings = df.groupby('rating')['rating'].count().reset_index(name="count")
         countratings = countratings.sort_values(by='rating', ascending=False)
-                
+        data = [{"rating": int(rating), "count": int(count)} for rating, count in zip(countratings['rating'], countratings['count'])]
-                data = countratings.apply(lambda row: {
-                    'rating': int(row['rating']), 
-                    'count': int(row['count'])
-                }, axis=1).tolist()
-                
         return Response(data)
-            else:
+
-                return JsonResponse({'error': 'No year in header'}, safe=False)
+    except Exception as e:
-        else:
+        return JsonResponse({'error': 'An error occurred: {}'.format(str(e))}, safe=False)
-            return JsonResponse({'error': 'Unauthorized'}, safe=False)
-    else:
-        return JsonResponse({'error': 'No authorization token'}, safe=False)