Merge pull request #118 from madeofpendletonwool/0.4.1

0.4.1 - Version Bump

Author: madeofpendletonwool

api_functions/functions.py

@@ -13,32 +13,28 @@ def generate_session_token():
 
 
 def call_clean_expired_sessions(url, headers):
-    # print(f'in clean expired call {headers}')
+    # print('clean expired call {headers}')
     response = requests.post(url + "/clean_expired_sessions/", headers=headers)
     if response.status_code == 200:
-        print('Response good!')
-        # print(response.json())
+        print(response.json())
     else:
         print("Error calling clean_expired_sessions:", response.status_code)
 
 
 def call_verify_key(url, headers):
     response = requests.get(url + "/verify_key", headers=headers)
     if response.status_code == 200:
-        print('Response good!')
         return {"status": "success"}
     else:
         print("Error calling verify_key:", response.status_code)
         return {"status": "error", "code": response.status_code}
 
 
 def call_get_key(url, username, password):
-    print('test')
     from requests.auth import HTTPBasicAuth
     try:
         response = requests.get(url + "/get_key", auth=HTTPBasicAuth(username, password))
         if response.status_code == 200:
-            print('Response good!')
             return response.json()  # Assumes the API key is returned in JSON response
         else:
             print("Error calling verify_key:", response.status_code)
@@ -49,14 +45,12 @@ def call_get_key(url, username, password):
 
 
 def call_get_user(url, headers):
-    print('test')
     from requests.auth import HTTPBasicAuth
     try:
         response = requests.get(url + "/get_user", headers=headers)
         print(f'Response status code: {response.status_code}')
         print(f'Response text: {response.text}')  # Add this to debug the response content
         if response.status_code == 200:
-            print('Response good!')
             return response.json()  # Assumes the API key is returned in JSON response
         else:
             print("Error calling verify_key:", response.status_code)
@@ -180,6 +174,40 @@ def call_return_episodes(url, headers, user_id):
         print("Error details:", response.text)
         return None
 
+def call_podcast_episodes(url, headers, user_id, podcast_id):
+    data = {
+        "user_id": str(user_id),
+        "podcast_id": str(podcast_id)
+    }
+    response = requests.get(url + f"/podcast_episodes", headers=headers, data=data)
+    if response.status_code == 200:
+        episodes = response.json()["episodes"]
+        if episodes:
+            return episodes
+        else:
+            return None
+    else:
+        print("Error fetching episodes:", response.status_code)
+        print("Error details:", response.text)
+        return None
+
+def call_get_podcast_id(url, headers, user_id, podcast_feed):
+    data = {
+        "user_id": str(user_id),
+        "podcast_feed": str(podcast_feed)
+    }
+    response = requests.get(url + f"/podcast_episodes", headers=headers, data=data)
+    if response.status_code == 200:
+        episodes = response.json()["episodes"]
+        if episodes:
+            return episodes
+        else:
+            return None
+    else:
+        print("Error fetching episodes:", response.status_code)
+        print("Error details:", response.text)
+        return None
+
 
 def call_check_episode_playback(url, headers, user_id, episode_title, episode_url):
     payload = {
@@ -399,8 +427,10 @@ def call_get_user_episode_count(url, headers, user_id):
     response = requests.get(url + f"/get_user_episode_count?user_id={user_id}", headers=headers)
     if response.status_code == 200:
         episode_count = response.json()
+        print(f'ya counts: {episode_count}')
         return episode_count
     else:
+        print("error")
         print("Error getting user episode count:", response.status_code)
         return None
 
@@ -582,8 +612,8 @@ def call_set_password(url, headers, user_id, salt, hash_pw):
 
 
 def call_set_email(url, headers, user_id, email):
-    data = {"user_id": self.user_id, "new_email": self.email}
-    response = requests.put(app_api.url + "/user/set_email", headers=app_api.headers, json=data)
+    data = {"user_id": user_id, "new_email": email}
+    response = requests.put(url + "/user/set_email", headers=headers, json=data)
     if response.status_code != 200:
         print("Error updating email:", response.status_code)
 

clients/clientapi.py

@@ -469,6 +469,59 @@ async def api_return_episodes(user_id: int, cnx=Depends(get_database_connection)
                             detail="You can only return episodes of your own!")
 
 
+class PodcastData(BaseModel):
+    podcast_id: int
+    user_id: int
+@app.post("/api/data/podcast_episodes")
+async def api_podcast_episodes(data: PodcastData, cnx=Depends(get_database_connection), api_key: str = Depends(get_api_key_from_header)):
+    is_valid_key = database_functions.functions.verify_api_key(cnx, api_key)
+    if not is_valid_key:
+        raise HTTPException(status_code=403,
+                            detail="Your API key is either invalid or does not have correct permission")
+
+    # Check if the provided API key is the web key
+    is_web_key = api_key == base_webkey.web_key
+
+    key_id = database_functions.functions.id_from_api_key(cnx, api_key)
+
+    # Allow the action if the API key belongs to the user, or it's the web API key
+    if key_id == data.user_id or is_web_key:
+        episodes = database_functions.functions.return_podcast_episodes(database_type, cnx, data.user_id, data.podcast_id)
+        if episodes is None:
+            episodes = []  # Return an empty list instead of raising an exception
+        return {"episodes": episodes}
+    else:
+        raise HTTPException(status_code=403,
+                            detail="You can only return episodes of your own!")
+
+class PodcastIDData(BaseModel):
+    podcast_feed: str
+    user_id: int
+@app.get("/api/data/get_podcast_id")
+async def api_podcast_id(data: PodcastData, cnx=Depends(get_database_connection),
+                              api_key: str = Depends(get_api_key_from_header)):
+    is_valid_key = database_functions.functions.verify_api_key(cnx, api_key)
+    if not is_valid_key:
+        raise HTTPException(status_code=403,
+                            detail="Your API key is either invalid or does not have correct permission")
+
+    # Check if the provided API key is the web key
+    is_web_key = api_key == base_webkey.web_key
+
+    key_id = database_functions.functions.id_from_api_key(cnx, api_key)
+
+    # Allow the action if the API key belongs to the user, or it's the web API key
+    if key_id == user_id or is_web_key:
+        episodes = database_functions.functions.get_podcast_id(database_type, cnx, data.user_id, data.podcast_feed)
+        if episodes is None:
+            episodes = []  # Return an empty list instead of raising an exception
+        return {"episodes": episodes}
+    else:
+        raise HTTPException(status_code=403,
+                            detail="You can only return pocast ids of your own podcasts!")
+
+
+
 @app.post("/api/data/check_episode_playback")
 async def api_check_episode_playback(
         user_id: int = Form(...),
@@ -858,6 +911,7 @@ async def api_get_user_episode_count(user_id: int, cnx=Depends(get_database_conn
     is_valid_key = database_functions.functions.verify_api_key(cnx, api_key)
 
     if not is_valid_key:
+        logging.error(f"not valid key")
         raise HTTPException(status_code=403,
                             detail="Your API key is either invalid or does not have correct permission")
 
@@ -870,11 +924,13 @@ async def api_get_user_episode_count(user_id: int, cnx=Depends(get_database_conn
         if user_id != user_id_from_api_key:
             raise HTTPException(status_code=status.HTTP_403_FORBIDDEN,
                                 detail="You are not authorized to access these user details")
-        episode_count = database_functions.functions.get_user_episode_count(cnx, user_id)
-        if episode_count:
-            return episode_count
-        else:
-            raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="User not found")
+    episode_count = database_functions.functions.get_user_episode_count(cnx, user_id)
+    if episode_count:
+        print(episode_count)
+        logging.error(f"here's count: {episode_count}")
+        return episode_count
+    else:
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="User not found")
 
 
 @app.get("/api/data/get_user_info")

clients/linux-app/api_functions/functions.py

@@ -180,6 +180,40 @@ def call_return_episodes(url, headers, user_id):
         print("Error details:", response.text)
         return None
 
+def call_podcast_episodes(url, headers, user_id, podcast_id):
+    data = {
+        "user_id": str(user_id),
+        "podcast_id": str(podcast_id)
+    }
+    response = requests.get(url + f"/podcast_episodes", headers=headers, data=data)
+    if response.status_code == 200:
+        episodes = response.json()["episodes"]
+        if episodes:
+            return episodes
+        else:
+            return None
+    else:
+        print("Error fetching episodes:", response.status_code)
+        print("Error details:", response.text)
+        return None
+
+def call_get_podcast_id(url, headers, user_id, podcast_feed):
+    data = {
+        "user_id": str(user_id),
+        "podcast_feed": str(podcast_feed)
+    }
+    response = requests.get(url + f"/podcast_episodes", headers=headers, data=data)
+    if response.status_code == 200:
+        episodes = response.json()["episodes"]
+        if episodes:
+            return episodes
+        else:
+            return None
+    else:
+        print("Error fetching episodes:", response.status_code)
+        print("Error details:", response.text)
+        return None
+
 
 def call_check_episode_playback(url, headers, user_id, episode_title, episode_url):
     payload = {
@@ -399,8 +433,10 @@ def call_get_user_episode_count(url, headers, user_id):
     response = requests.get(url + f"/get_user_episode_count?user_id={user_id}", headers=headers)
     if response.status_code == 200:
         episode_count = response.json()
+        print(f'ya counts: {episode_count}')
         return episode_count
     else:
+        print("error")
         print("Error getting user episode count:", response.status_code)
         return None
 

clients/linux-app/pinepods.py

@@ -1513,8 +1513,7 @@ def view_pop(e):
         page.go(top_view.route)
 
     def open_poddisplay(e):
-        pr_instance.touch_stack()
-        page.update()
+        print('open poddisplay')
         page.go("/poddisplay")
 
     def open_settings(e):
@@ -3353,6 +3352,8 @@ def stop_monitoring(self):
                                                                         active_user.user_id, clicked_podcast.name)
             # Creating attributes for page layout
             # First Podcast Info
+            pr_instance.touch_stack()
+            page.update()
             display_pod_art_no = secrets.SystemRandom().randint(1, 12)
             display_pod_art_fallback = os.path.join('/pinepods', "images", "logo_random", f"{display_pod_art_no}.jpeg")
             display_pod_art_url = clicked_podcast.artwork if clicked_podcast.artwork else display_pod_art_fallback
@@ -3888,7 +3889,6 @@ def map_search_result(result, source):
 
             user_ep_count = api_functions.functions.call_get_user_episode_count(app_api.url, app_api.headers,
                                                                                 active_user.user_id)
-
             user_title = ft.Text(f"Stats for {active_user.fullname}:", size=20, weight="bold")
             date_display = ft.Text(f'{active_user.username} created on {stats_created_date}', size=16)
             pods_played_display = ft.Text(f'{stats_pods_played} Podcasts listened to', size=16)

completed_todos.md

@@ -2,6 +2,12 @@
 
 This is the list of previous todos that are now completed
 
+Version 0.4.1
+
+- [x] Fixed issue where get_user_episode_count wasn't displaying episode numbers. There was a syntax error in the api call
+- [x] Added /api/data/podcast_episodes and /api/data/get_podcast_id api calls. These are needed for Pinepods Firewood
+
+
 Version 0.4
 
 - [x] Unlock api creation for standard users - The API has been completely re-written to follow along the permissions that users actually have. Meaning users can easily request their own api keys and sign into the client with admin consent

database_functions/functions.py

@@ -301,6 +301,53 @@ def return_episodes(database_type, cnx, user_id):
 
     return rows
 
+def return_podcast_episodes(database_type, cnx, user_id, podcast_id):
+    if database_type == "postgresql":
+        cursor = cnx.cursor(cursor_factory=RealDictCursor)
+    else:  # Assuming MariaDB/MySQL if not PostgreSQL
+        cursor = cnx.cursor(dictionary=True)
+
+    query = (f"SELECT Podcasts.PodcastID, Podcasts.PodcastName, Episodes.EpisodeID, Episodes.EpisodeTitle, Episodes.EpisodePubDate, "
+             f"Episodes.EpisodeDescription, Episodes.EpisodeArtwork, Episodes.EpisodeURL, Episodes.EpisodeDuration, "
+             f"UserEpisodeHistory.ListenDuration "
+             f"FROM Episodes "
+             f"INNER JOIN Podcasts ON Episodes.PodcastID = Podcasts.PodcastID "
+             f"LEFT JOIN UserEpisodeHistory ON Episodes.EpisodeID = UserEpisodeHistory.EpisodeID AND UserEpisodeHistory.UserID = %s "
+             f"WHERE Podcasts.PodcastID = %s "
+             f"AND Podcasts.UserID = %s "
+             f"ORDER BY Episodes.EpisodePubDate DESC")
+
+    cursor.execute(query, (user_id, podcast_id, user_id))
+    rows = cursor.fetchall()
+
+    cursor.close()
+
+    if not rows:
+        return None
+
+    return rows
+
+def get_podcast_id(database_type, cnx, user_id, podcast_feed):
+    if database_type == "postgresql":
+        cursor = cnx.cursor(cursor_factory=RealDictCursor)
+    else:  # Assuming MariaDB/MySQL if not PostgreSQL
+        cursor = cnx.cursor(dictionary=True)
+
+    # Adjusted query to select only the PodcastID based on FeedURL and UserID
+    query = (f"SELECT PodcastID "
+             f"FROM Podcasts "
+             f"WHERE FeedURL = %s AND UserID = %s")
+
+    cursor.execute(query, (podcast_feed, user_id))
+    row = cursor.fetchone()  # Fetching only one row as we expect a single result
+
+    cursor.close()
+
+    if not row:
+        return None
+
+    return row['PodcastID']  # Assuming the column name is 'PodcastID'
+
 
 def delete_podcast(cnx, url, title, user_id):
     cursor = cnx.cursor()
@@ -376,7 +423,7 @@ def return_pods(database_type, cnx, user_id):
     else:  # Assuming MariaDB/MySQL if not PostgreSQL
         cursor = cnx.cursor(dictionary=True)
 
-    query = ("SELECT PodcastName, ArtworkURL, Description, EpisodeCount, WebsiteURL, FeedURL, Author, Categories "
+    query = ("SELECT PodcastID, PodcastName, ArtworkURL, Description, EpisodeCount, WebsiteURL, FeedURL, Author, Categories "
              "FROM Podcasts "
              "WHERE UserID = %s")
 
@@ -2475,4 +2522,4 @@ def restore_server(cnx, database_pass, server_restore_data):
             if process.returncode != 0:
                 raise Exception(f"Restoration failed with error: {stderr.decode()}")
 
-    return "Restoration completed successfully!"
+    return "Restoration completed successfully!"