openapi.json

{
  "openapi": "3.0.3",
  "info": {
    "title": "Ovatify",
    "description": "Ovatify is a music platform designed to offer a unique and personalized experience to music lovers. This project includes a web application, a mobile application, and a robust backend service to manage streaming, user interactions, and data handling.",
    "contact": {
      "email": "eonus@sabanciuniv.edu"
    },
    "license": {
      "name": "Apache 2.0",
      "url": "http://www.apache.org/licenses/LICENSE-2.0.html"
    },
    "version": "1.0.11"
  },
  "servers": [
    {
      "url": "https://ovatify-backend.fly.dev/"
    },
    {
      "url": "https://ovatify-backend-dev.fly.dev/"
    },
    {
      "url": "http://localhost:8000/"
    }
  ],
  "tags": [
    {
      "name": "User",
      "description": "Operations related to users"
    },
    {
      "name": "Song",
      "description": "Operations related to songs"
    },
    {
      "name": "Chart",
      "description": "Operations related to charts"
    },
    {
      "name": "Recommendation",
      "description": "Operations related to recommendations"
    },
    {
      "name": "Library",
      "description": "Operations related to user library"
    },
    {
      "name": "Friend",
      "description": "Operations related to users and their friends"
    },
    {
      "name": "Import/Export File",
      "description": "Operations related to exporting and importing files"
    },
    {
      "name": "FriendGroup",
      "description": "Operations related to friend groups"
    },
    {
      "name": "Tests",
      "description": "Test endpoints that will not be used in front, but good for testing purposes."
    },
    {
      "name": "Playlist",
      "description": "Endpoints related to playlists."
    }
  ],
  "paths": {
    "/songs/search-db/": {
      "get": {
        "tags": [
          "Song"
        ],
        "summary": "Search database for songs",
        "description": "Performs a search in the database based on the provided search string, filtering songs by name, albums, and artists.",
        "parameters": [
          {
            "name": "search_string",
            "in": "query",
            "description": "Search string to filter the songs",
            "required": true,
            "schema": {
              "type": "string"
            }
          }
        ],
        "responses": {
          "200": {
            "description": "Songs found",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object",
                  "properties": {
                    "message": {
                      "type": "string"
                    },
                    "songs_info": {
                      "type": "array",
                      "items": {
                        "type": "object",
                        "properties": {
                          "spotify_id": {
                            "type": "string"
                          },
                          "track_name": {
                            "type": "string"
                          },
                          "release_year": {
                            "type": "integer"
                          },
                          "album_name": {
                            "type": "array",
                            "items": {
                              "type": "string"
                            }
                          },
                          "artist": {
                            "type": "array",
                            "items": {
                              "type": "string"
                            }
                          },
                          "album_url": {
                            "type": "string",
                            "format": "url"
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          },
          "400": {
            "description": "Missing parameters or Invalid method"
          },
          "401": {
            "description": "Unauthorized - Authentication token is missing or invalid"
          }
        },
        "security": [
          {
            "bearerAuth": []
          }
        ]
      }
    },
    "/songs/get-song-by-id/": {
      "get": {
        "tags": [
          "Song"
        ],
        "summary": "Retrieve a song by its ID",
        "description": "Fetches detailed information about a song using its unique ID.",
        "security": [
          {
            "bearerAuth": []
          }
        ],
        "parameters": [
          {
            "name": "song_id",
            "in": "query",
            "description": "The unique identifier of the song",
            "required": true,
            "schema": {
              "type": "string"
            }
          }
        ],
        "responses": {
          "200": {
            "description": "Song found",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object",
                  "properties": {
                    "message": {
                      "type": "string"
                    },
                    "song_info": {
                      "$ref": "#/components/schemas/Song"
                    }
                  }
                }
              }
            }
          },
          "400": {
            "description": "Missing parameter or Invalid method"
          },
          "401": {
            "description": "Unauthorized - Authentication token is missing or invalid"
          },
          "404": {
            "description": "Song not found or User not found"
          }
        }
      }
    },
    "/songs/add-song/": {
      "post": {
        "tags": [
          "Song"
        ],
        "summary": "Add a new song to the database",
        "description": "Creates a new song record in the database using provided Spotify ID and additional data. It also handles the rating for the song.",
        "security": [
          {
            "bearerAuth": []
          }
        ],
        "requestBody": {
          "required": true,
          "content": {
            "application/json": {
              "schema": {
                "type": "object",
                "properties": {
                  "spotify_id": {
                    "type": "string",
                    "description": "Spotify ID of the song"
                  },
                  "rating": {
                    "type": "number",
                    "format": "float",
                    "description": "User's rating for the song"
                  }
                },
                "required": [
                  "spotify_id"
                ]
              }
            }
          }
        },
        "responses": {
          "200": {
            "description": "Rating & song added successfully or Rating added successfully"
          },
          "201": {
            "description": "Song added successfully"
          },
          "400": {
            "description": "Invalid method or Missing parameter or Spotify ID is required or You have already added this song, please update your rating via your library"
          },
          "401": {
            "description": "Unauthorized - Authentication token is missing or invalid"
          },
          "404": {
            "description": "User or Song not found"
          },
          "500": {
            "description": "A KeyError occurred or An unexpected error occurred"
          }
        }
      }
    },
    "/songs/search-spotify/": {
      "get": {
        "tags": [
          "Song"
        ],
        "summary": "Search for songs on Spotify",
        "description": "Performs a search on Spotify using a provided search string and retrieves a list of matching tracks.",
        "security": [
          {
            "bearerAuth": []
          }
        ],
        "parameters": [
          {
            "name": "search_string",
            "in": "query",
            "description": "The search string to query Spotify tracks",
            "required": true,
            "schema": {
              "type": "string"
            }
          }
        ],
        "responses": {
          "200": {
            "description": "Search successful",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object",
                  "properties": {
                    "message": {
                      "type": "string"
                    },
                    "results": {
                      "type": "array",
                      "items": {
                        "type": "object",
                        "properties": {
                          "track_name": {
                            "type": "string"
                          },
                          "album_name": {
                            "type": "string"
                          },
                          "artist": {
                            "type": "string"
                          },
                          "release_year": {
                            "type": "string"
                          },
                          "spotify_id": {
                            "type": "string"
                          },
                          "album_url": {
                            "type": "string",
                            "format": "url"
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          },
          "400": {
            "description": "Missing search string or Invalid method"
          },
          "401": {
            "description": "Unauthorized - Authentication token is missing or invalid"
          },
          "500": {
            "description": "KeyError occurred or An unexpected error occurred"
          }
        }
      }
    },
    "/songs/get-average-rating/": {
      "get": {
        "tags": [
          "Song"
        ],
        "summary": "Get the average rating of a song",
        "description": "Fetches the average rating for a specific song based on its ID.",
        "parameters": [
          {
            "name": "song_id",
            "in": "query",
            "description": "The unique identifier of the song",
            "required": true,
            "schema": {
              "type": "string"
            }
          }
        ],
        "responses": {
          "200": {
            "description": "Average rating retrieved successfully",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object",
                  "properties": {
                    "average_rating": {
                      "type": "number",
                      "format": "float"
                    }
                  }
                }
              }
            }
          },
          "400": {
            "description": "Missing song id"
          },
          "404": {
            "description": "Song not found or No ratings available for this song"
          },
          "500": {
            "description": "KeyError occurred or An unexpected error occurred"
          }
        }
      }
    },
    "/songs/get-genres/": {
      "get": {
        "tags": [
          "Song"
        ],
        "summary": "Retrieve a list of genres",
        "description": "Fetches a list of genres, with the option to specify the number of genres to return.",
        "security": [
          {
            "bearerAuth": []
          }
        ],
        "parameters": [
          {
            "name": "number_of_genres",
            "in": "query",
            "description": "The number of genres to return. Use -1 to return all genres.",
            "required": true,
            "schema": {
              "type": "integer"
            }
          }
        ],
        "responses": {
          "200": {
            "description": "List of genres retrieved successfully",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object",
                  "properties": {
                    "genres": {
                      "type": "array",
                      "items": {
                        "type": "object",
                        "properties": {
                          "id": {
                            "type": "integer"
                          },
                          "name": {
                            "type": "string"
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          },
          "400": {
            "description": "Missing number of genres or Invalid number of genres"
          },
          "401": {
            "description": "Unauthorized - Authentication token is missing or invalid"
          },
          "405": {
            "description": "Invalid method"
          },
          "500": {
            "description": "An unexpected error occurred"
          }
        }
      }
    },
    "/songs/get-songs-by-genre/": {
      "get": {
        "tags": [
          "Song"
        ],
        "summary": "Retrieve songs by genre",
        "description": "Fetches songs filtered by a specific genre, with an option to limit the number of songs returned.",
        "security": [
          {
            "bearerAuth": []
          }
        ],
        "parameters": [
          {
            "name": "number_of_songs",
            "in": "query",
            "description": "The number of songs to return. Use -1 to return all songs.",
            "required": true,
            "schema": {
              "type": "integer"
            }
          },
          {
            "name": "genre_name",
            "in": "query",
            "description": "The name of the genre to filter songs by",
            "required": true,
            "schema": {
              "type": "string"
            }
          }
        ],
        "responses": {
          "200": {
            "description": "List of songs retrieved successfully",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object",
                  "properties": {
                    "songs": {
                      "type": "array",
                      "items": {
                        "type": "object",
                        "properties": {
                          "id": {
                            "type": "string"
                          },
                          "name": {
                            "type": "string"
                          },
                          "release_year": {
                            "type": "integer"
                          },
                          "main_artist": {
                            "type": "string"
                          },
                          "img_url": {
                            "type": "string",
                            "format": "url"
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          },
          "400": {
            "description": "Missing or invalid number of songs or Missing genre name"
          },
          "401": {
            "description": "Unauthorized - Authentication token is missing or invalid"
          },
          "404": {
            "description": "User does not exist"
          },
          "500": {
            "description": "An unexpected error occurred"
          }
        }
      }
    },
    "/songs/get-song-genres/": {
      "get": {
        "tags": [
          "Song"
        ],
        "summary": "Retrieve genres of a specific song",
        "description": "Fetches genres associated with a specific song, identified by its song ID.",
        "security": [
          {
            "bearerAuth": []
          }
        ],
        "parameters": [
          {
            "name": "song_id",
            "in": "query",
            "description": "The unique identifier of the song",
            "required": true,
            "schema": {
              "type": "string"
            }
          }
        ],
        "responses": {
          "200": {
            "description": "Genres of the song retrieved successfully",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object",
                  "properties": {
                    "genres": {
                      "type": "array",
                      "items": {
                        "type": "object",
                        "properties": {
                          "id": {
                            "type": "integer"
                          },
                          "name": {
                            "type": "string"
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          },
          "400": {
            "description": "Missing song id"
          },
          "401": {
            "description": "Unauthorized - Authentication token is missing or invalid"
          },
          "404": {
            "description": "Song not found"
          },
          "500": {
            "description": "An unexpected error occurred"
          }
        }
      }
    },
    "/songs/get-random-genres/": {
      "get": {
        "tags": [
          "Song"
        ],
        "summary": "Retrieve a random list of genres",
        "description": "Fetches a random list of genres, with an option to specify the number of genres to return.",
        "security": [
          {
            "bearerAuth": []
          }
        ],
        "parameters": [
          {
            "name": "number_of_genres",
            "in": "query",
            "description": "The number of random genres to return. Defaults to 10 if not specified.",
            "required": false,
            "schema": {
              "type": "integer",
              "default": 10
            }
          }
        ],
        "responses": {
          "200": {
            "description": "Random genres retrieved successfully",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object",
                  "properties": {
                    "genres": {
                      "type": "array",
                      "items": {
                        "type": "object",
                        "properties": {
                          "id": {
                            "type": "integer"
                          },
                          "name": {
                            "type": "string"
                          },
                          "img_url": {
                            "type": "string",
                            "format": "url"
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          },
          "400": {
            "description": "Invalid number of genres"
          },
          "401": {
            "description": "Unauthorized - Authentication token is missing or invalid"
          },
          "404": {
            "description": "User does not exist"
          },
          "500": {
            "description": "An unexpected error occurred"
          }
        }
      }
    },
    "/songs/search-artists/": {
      "get": {
        "tags": [
          "Song"
        ],
        "summary": "Search for artists",
        "description": "Retrieve a list of artists based on the provided search text.",
        "security": [
          {
            "bearerAuth": []
          }
        ],
        "parameters": [
          {
            "name": "search_text",
            "in": "query",
            "description": "The text to search for artists. If not provided, returns a list of all artists.",
            "required": false,
            "schema": {
              "type": "string"
            }
          }
        ],
        "responses": {
          "200": {
            "description": "Artists found successfully",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object",
                  "properties": {
                    "message": {
                      "type": "string"
                    },
                    "artists_info": {
                      "type": "array",
                      "items": {
                        "type": "object",
                        "properties": {
                          "name": {
                            "type": "string"
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          },
          "400": {
            "description": "Invalid method or parameters"
          }
        }
      }
    },
    "/songs/search-genres/": {
      "get": {
        "tags": [
          "Song"
        ],
        "summary": "Search for genres",
        "description": "Retrieve a list of genres based on the provided search text.",
        "security": [
          {
            "bearerAuth": []
          }
        ],
        "parameters": [
          {
            "name": "search_text",
            "in": "query",
            "description": "The text to search for genres. If not provided, returns a list of all genres.",
            "required": false,
            "schema": {
              "type": "string"
            }
          }
        ],
        "responses": {
          "200": {
            "description": "Genres found successfully",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object",
                  "properties": {
                    "message": {
                      "type": "string"
                    },
                    "genres_info": {
                      "type": "array",
                      "items": {
                        "type": "object",
                        "properties": {
                          "name": {
                            "type": "string"
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          },
          "400": {
            "description": "Invalid method or parameters"
          }
        }
      }
    },
    "/songs/get-all-moods/": {
      "get": {
        "tags": [
          "Song"
        ],
        "summary": "Get all moods",
        "description": "Retrieve a list of all available moods.",
        "security": [
          {
            "bearerAuth": []
          }
        ],
        "parameters": [
        ],
        "responses": {
          "200": {
            "description": "All moods retrieved successfully",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object",
                  "properties": {
                    "message": {
                      "type": "string"
                    },
                    "moods": {
                      "type": "array",
                      "items": {
                        "type": "object",
                        "properties": {
                          "value": {
                            "type": "string"
                          },
                          "label": {
                            "type": "string"
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          },
          "400": {
            "description": "Invalid method or parameters"
          }
        }
      }
    },
    "/songs/get-all-tempos/": {
      "get": {
        "tags": [
          "Song"
        ],
        "summary": "Get all tempos",
        "description": "Retrieve a list of all available tempos.",
        "security": [
          {
            "bearerAuth": []
          }
        ],
        "parameters": [
        ],
        "responses": {
          "200": {
            "description": "All tempos retrieved successfully",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object",
                  "properties": {
                    "message": {
                      "type": "string"
                    },
                    "tempos": {
                      "type": "array",
                      "items": {
                        "type": "object",
                        "properties": {
                          "value": {
                            "type": "string"
                          },
                          "label": {
                            "type": "string"
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          },
          "400": {
            "description": "Invalid method or parameters"
          }
        }
      }
    },
    "/songs/get-banger-songs/": {
      "get": {
        "tags": [
          "Song"
        ],
        "summary": "Get a random Banger song",
        "description": "Retrieve a random Banger song based on specified filters.",
        "security": [
          {
            "bearerAuth": []
          }
        ],
        "parameters": [
          {
            "name": "artist",
            "in": "query",
            "description": "Filter by artist name.",
            "required": false,
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "genre",
            "in": "query",
            "description": "Filter by genre name.",
            "required": false,
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "mood",
            "in": "query",
            "description": "Filter by mood.",
            "required": false,
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "tempo",
            "in": "query",
            "description": "Filter by tempo.",
            "required": false,
            "schema": {
              "type": "string"
            }
          }
        ],
        "responses": {
          "200": {
            "description": "Song details retrieved successfully",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object",
                  "properties": {
                    "id": {
                      "type": "integer"
                    },
                    "name": {
                      "type": "string"
                    },
                    "release_year": {
                      "type": "integer"
                    },
                    "img_url": {
                      "type": "string",
                      "format": "uri"
                    },
                    "main_artist": {
                      "type": "string"
                    }
                  }
                }
              }
            }
          },
          "404": {
            "description": "No Banger songs found with the given filters"
          },
          "400": {
            "description": "Invalid method or parameters"
          }
        }
      }
    },
    
    "/users/create-user/": {
      "post": {
        "tags": [
          "User"
        ],
        "summary": "Create a new user",
        "description": "Creates a new user account using the provided email address.",
        "security": [
          {
            "bearerAuth": []
          }
        ],
        "requestBody": {
          "required": true,
          "content": {
            "application/json": {
              "schema": {
                "type": "object",
                "properties": {
                  "email": {
                    "type": "string",
                    "format": "email"
                  }
                },
                "required": [
                  "email"
                ]
              }
            }
          }
        },
        "responses": {
          "201": {
            "description": "User created successfully"
          },
          "400": {
            "description": "Missing email or user already exists"
          },
          "401": {
            "description": "Unauthorized - Authentication token is missing or invalid"
          },
          "500": {
            "description": "An unexpected error occurred"
          }
        }
      }
    },
    "/users/login/": {
      "put": {
        "tags": [
          "User"
        ],
        "summary": "Log in a user",
        "description": "Logs in a user and updates their last login time. The user is identified by the provided user ID.",
        "security": [
          {
            "bearerAuth": []
          }
        ],
        "responses": {
          "200": {
            "description": "User logged in successfully"
          },
          "401": {
            "description": "Unauthorized - Authentication token is missing or invalid"
          },
          "405": {
            "description": "Invalid method"
          },
          "500": {
            "description": "Database error"
          }
        }
      }
    },
    "/users/user-songs/": {
      "get": {
        "tags": [
          "User"
        ],
        "summary": "Retrieve songs rated by the user",
        "description": "Fetches a list of songs that the user has rated, identified by the user's ID.",
        "security": [
          {
            "bearerAuth": []
          }
        ],
        "responses": {
          "200": {
            "description": "List of user-rated songs retrieved successfully",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object",
                  "properties": {
                    "songs": {
                      "type": "array",
                      "items": {
                        "type": "object",
                        "properties": {
                          "id": {
                            "type": "string"
                          },
                          "name": {
                            "type": "string"
                          },
                          "release_year": {
                            "type": "integer"
                          },
                          "duration": {
                            "type": "number",
                            "format": "float"
                          },
                          "tempo": {
                            "type": "string"
                          },
                          "mood": {
                            "type": "string"
                          },
                          "recorded_environment": {
                            "type": "string"
                          },
                          "replay_count": {
                            "type": "integer"
                          },
                          "version": {
                            "type": "string"
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          },
          "404": {
            "description": "No song found"
          },
          "500": {
            "description": "An unexpected error occurred"
          }
        }
      }
    },
    "/users/add-song-rating/": {
      "post": {
        "tags": [
          "User"
        ],
        "summary": "Add a rating to a song",
        "description": "Allows a user to rate a song by specifying the song ID and the rating value.",
        "security": [
          {
            "bearerAuth": []
          }
        ],
        "requestBody": {
          "required": true,
          "content": {
            "application/json": {
              "schema": {
                "type": "object",
                "properties": {
                  "song_id": {
                    "type": "string",
                    "description": "The unique identifier of the song to be rated"
                  },
                  "rating": {
                    "type": "number",
                    "format": "float",
                    "description": "The rating value for the song"
                  }
                },
                "required": [
                  "song_id",
                  "rating"
                ]
              }
            }
          }
        },
        "responses": {
          "201": {
            "description": "User rating added successfully"
          },
          "400": {
            "description": "Missing parameter or User rating already exists or Invalid data format"
          },
          "401": {
            "description": "Unauthorized - Authentication token is missing or invalid"
          },
          "404": {
            "description": "User not found or Song not found or Integrity Error: Invalid user or song reference"
          },
          "500": {
            "description": "KeyError occurred or An unexpected error occurred"
          }
        }
      }
    },
    "/users/edit-song-rating/": {
      "put": {
        "tags": [
          "User"
        ],
        "summary": "Edit a user's rating for a song",
        "description": "Allows a user to update their rating for a specific song.",
        "security": [
          {
            "bearerAuth": []
          }
        ],
        "requestBody": {
          "required": true,
          "content": {
            "application/json": {
              "schema": {
                "type": "object",
                "properties": {
                  "song_id": {
                    "type": "string",
                    "description": "The unique identifier of the song whose rating is to be updated"
                  },
                  "rating": {
                    "type": "number",
                    "format": "float",
                    "description": "The new rating value for the song"
                  }
                },
                "required": [
                  "song_id",
                  "rating"
                ]
              }
            }
          }
        },
        "responses": {
          "201": {
            "description": "User rating updated successfully"
          },
          "400": {
            "description": "Missing parameter or Invalid method"
          },
          "401": {
            "description": "Unauthorized - Authentication token is missing or invalid"
          },
          "404": {
            "description": "User not found or Song not found or User rating not found"
          },
          "500": {
            "description": "KeyError occurred or An unexpected error occurred"
          }
        }
      }
    },
    "/users/delete-song-rating/": {
      "delete": {
        "tags": [
          "User"
        ],
        "summary": "Delete a user's rating for a song",
        "description": "Allows a user to delete their rating for a specific song.",
        "security": [
          {
            "bearerAuth": []
          }
        ],
        "parameters": [
          {
            "name": "song_id",
            "in": "query",
            "description": "The unique identifier of the song whose rating is to be deleted",
            "required": true,
            "schema": {
              "type": "string"
            }
          }
        ],
        "responses": {
          "204": {
            "description": "User rating deleted successfully"
          },
          "400": {
            "description": "Missing parameter or Invalid method"
          },
          "401": {
            "description": "Unauthorized - Authentication token is missing or invalid"
          },
          "500": {
            "description": "KeyError occurred or An unexpected error occurred"
          }
        }
      }
    },
    "/users/get-songs-by-genre/": {
      "get": {
        "tags": [
          "User"
        ],
        "summary": "Get songs by a specific genre for a user.",
        "parameters": [
          {
            "name": "number_of_songs",
            "in": "query",
            "description": "The number of songs to retrieve (default: 10).",
            "required": false,
            "schema": {
              "type": "integer",
              "default": 10
            }
          },
          {
            "name": "genre_name",
            "in": "query",
            "description": "The name of the genre to filter songs by.",
            "required": true,
            "schema": {
              "type": "string"
            }
          }
        ],
        "responses": {
          "200": {
            "description": "Successful response with a list of matching songs."
          },
          "400": {
            "description": "Invalid number of songs or missing genre name."
          },
          "404": {
            "description": "User not found."
          },
          "500": {
            "description": "Internal server error."
          }
        },
        "security": [
          {
            "bearerAuth": []
          }
        ]
      }
    },
    "/users/get-songs-by-artist/": {
      "get": {
        "tags": [
          "User"
        ],
        "summary": "Get songs by a specific artist for a user.",
        "parameters": [
          {
            "name": "number_of_songs",
            "in": "query",
            "description": "The number of songs to retrieve (default: 10).",
            "required": false,
            "schema": {
              "type": "integer",
              "default": 10
            }
          },
          {
            "name": "artist_name",
            "in": "query",
            "description": "The name of the artist to filter songs by.",
            "required": true,
            "schema": {
              "type": "string"
            }
          }
        ],
        "responses": {
          "200": {
            "description": "Successful response with a list of matching songs.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object",
                  "properties": {
                    "songs": {
                      "type": "array",
                      "items": {
                        "$ref": "#/components/schemas/Song"
                      }
                    }
                  }
                }
              }
            }
          },
          "400": {
            "description": "Invalid number of songs or missing artist name."
          },
          "404": {
            "description": "User not found."
          },
          "500": {
            "description": "Internal server error."
          }
        },
        "security": [
          {
            "bearerAuth": []
          }
        ]
      }
    },
    "/users/get-songs-by-tempo/": {
      "get": {
        "tags": [
          "User"
        ],
        "summary": "Get songs by a specific tempo for a user.",
        "parameters": [
          {
            "name": "number_of_songs",
            "in": "query",
            "description": "The number of songs to retrieve (default: 10).",
            "required": false,
            "schema": {
              "type": "integer",
              "default": 10
            }
          },
          {
            "name": "tempo_name",
            "in": "query",
            "description": "The name of the tempo to filter songs by, based on the Tempo enum.",
            "required": true,
            "schema": {
              "type": "string",
              "enum": [
                "Slow",
                "Medium",
                "Fast"
              ]
            }
          }
        ],
        "responses": {
          "200": {
            "description": "Successful response with a list of matching songs.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object",
                  "properties": {
                    "songs": {
                      "type": "array",
                      "items": {
                        "$ref": "#/components/schemas/Song"
                      }
                    }
                  }
                }
              }
            }
          },
          "400": {
            "description": "Invalid number of songs or missing tempo name."
          },
          "404": {
            "description": "User not found."
          },
          "500": {
            "description": "Internal server error."
          }
        },
        "security": [
          {
            "bearerAuth": []
          }
        ]
      }
    },
    "/users/get-songs-by-mood/": {
      "get": {
        "tags": [
          "User"
        ],
        "summary": "Get songs by a specific mood for a user.",
        "parameters": [
          {
            "name": "number_of_songs",
            "in": "query",
            "description": "The number of songs to retrieve (default: 10).",
            "required": false,
            "schema": {
              "type": "integer",
              "default": 10
            }
          },
          {
            "name": "mood_name",
            "in": "query",
            "description": "The name of the mood to filter songs by, based on the Mood enum.",
            "required": true,
            "schema": {
              "type": "string",
              "enum": [
                "Happy",
                "Sad",
                "Excited",
                "Relaxed"
              ]
            }
          }
        ],
        "responses": {
          "200": {
            "description": "Successful response with a list of matching songs.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object",
                  "properties": {
                    "songs": {
                      "type": "array",
                      "items": {
                        "$ref": "#/components/schemas/Song"
                      }
                    }
                  }
                }
              }
            }
          },
          "400": {
            "description": "Invalid number of songs or missing mood name."
          },
          "404": {
            "description": "User not found."
          },
          "500": {
            "description": "Internal server error."
          }
        },
        "security": [
          {
            "bearerAuth": []
          }
        ]
      }
    },
    "/users/get-recently-added-songs/": {
      "get": {
        "tags": [
          "User",
          "Library"
        ],
        "summary": "Get a list of songs recently added by a user.",
        "parameters": [
          {
            "name": "number_of_songs",
            "in": "query",
            "description": "The number of recently added songs to retrieve. If not specified, all recently added songs will be returned.",
            "required": false,
            "schema": {
              "type": "integer"
            }
          }
        ],
        "responses": {
          "200": {
            "description": "Successful response with a list of recently added songs.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object",
                  "properties": {
                    "songs": {
                      "type": "array",
                      "items": {
                        "type": "object",
                        "properties": {
                          "id": {
                            "type": "string",
                            "maxLength": 200
                          },
                          "name": {
                            "type": "string",
                            "maxLength": 200
                          },
                          "release_year": {
                            "type": "integer",
                            "format": "int32",
                            "nullable": true
                          },
                          "main_artist": {
                            "type": "string"
                          },
                          "img_url": {
                            "type": "string",
                            "format": "url",
                            "maxLength": 300,
                            "nullable": true
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          },
          "400": {
            "description": "Invalid number of songs."
          },
          "404": {
            "description": "User not found."
          },
          "500": {
            "description": "Internal server error."
          }
        },
        "security": [
          {
            "bearerAuth": []
          }
        ]
      }
    },
    "/users/get-favorite-songs/": {
      "get": {
        "tags": [
          "User",
          "Chart"
        ],
        "summary": "Get a list of favorite songs for a user.",
        "parameters": [
          {
            "name": "number_of_songs",
            "in": "query",
            "description": "The number of favorite songs to retrieve. If not specified, all favorite songs will be returned.",
            "required": false,
            "schema": {
              "type": "integer"
            }
          }
        ],
        "responses": {
          "200": {
            "description": "Successful response with a list of favorite songs.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object",
                  "properties": {
                    "songs": {
                      "type": "array",
                      "items": {
                        "type": "object",
                        "properties": {
                          "id": {
                            "type": "string",
                            "maxLength": 200
                          },
                          "name": {
                            "type": "string",
                            "maxLength": 200
                          },
                          "release_year": {
                            "type": "integer",
                            "format": "int32",
                            "nullable": true
                          },
                          "main_artist": {
                            "type": "string"
                          },
                          "img_url": {
                            "type": "string",
                            "format": "url",
                            "maxLength": 300,
                            "nullable": true
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          },
          "400": {
            "description": "Invalid number of songs."
          },
          "404": {
            "description": "User not found."
          },
          "500": {
            "description": "Internal server error."
          }
        },
        "security": [
          {
            "bearerAuth": []
          }
        ]
      }
    },
    "/users/get-favorite-genres/": {
      "get": {
        "tags": [
          "User",
          "Chart"
        ],
        "summary": "Get a list of favorite genres for a user based on their song ratings.",
        "parameters": [
          {
            "name": "number_of_songs",
            "in": "query",
            "description": "The number of songs to consider for determining favorite genres. If not specified, all rated songs will be considered.",
            "required": false,
            "schema": {
              "type": "integer"
            }
          },
          {
            "name": "limit",
            "in": "query",
            "description": "The maximum number of top genres to return. If not specified, 10 genres will be returned. You can configure this value to get a better visualization in the chart. For example, if you get too much genres for a given number of songs, and it looks ugly in the chart, you can limit the number of genres to be returned.",
            "required": false,
            "schema": {
              "type": "integer"
            }
          }
        ],
        "responses": {
          "200": {
            "description": "Successful response with a list of favorite genres.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object",
                  "additionalProperties": {
                    "type": "integer"
                  },
                  "example": {
                    "Pop": 5,
                    "Rock": 3,
                    "Jazz": 2
                  }
                }
              }
            }
          },
          "400": {
            "description": "Invalid parameters."
          },
          "404": {
            "description": "User not found."
          },
          "500": {
            "description": "Internal server error."
          }
        },
        "security": [
          {
            "bearerAuth": []
          }
        ]
      }
    },
    "/users/get-favorite-artists/": {
      "get": {
        "tags": [
          "User",
          "Chart"
        ],
        "summary": "Get a list of favorite artists for a user based on their song ratings.",
        "parameters": [
          {
            "name": "number_of_songs",
            "in": "query",
            "description": "The number of songs to consider for determining favorite artists. If not specified, all rated songs will be considered.",
            "required": false,
            "schema": {
              "type": "integer"
            }
          },
          {
            "name": "limit",
            "in": "query",
            "description": "The maximum number of top artists to return. If not specified, 10 artists will be returned. You can configure this value to get a better visualization in the chart. For example, if you get too much artists for a given number of songs, and it looks ugly in the chart, you can limit the number of artists to be returned.",
            "required": false,
            "schema": {
              "type": "integer"
            }
          }
        ],
        "responses": {
          "200": {
            "description": "Successful response with a list of favorite artists.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object",
                  "additionalProperties": {
                    "type": "integer"
                  },
                  "example": {
                    "Semicenk": 5,
                    "Ceza": 3,
                    "Adele": 2
                  }
                }
              }
            }
          },
          "400": {
            "description": "Invalid parameters."
          },
          "404": {
            "description": "User not found."
          },
          "500": {
            "description": "Internal server error."
          }
        },
        "security": [
          {
            "bearerAuth": []
          }
        ]
      }
    },
    "/users/get-favorite-moods/": {
      "get": {
        "tags": [
          "User",
          "Chart"
        ],
        "summary": "Get a list of favorite moods for a user based on their song ratings.",
        "parameters": [
          {
            "name": "number_of_songs",
            "in": "query",
            "description": "The number of songs to consider for determining favorite moods. If not specified, all rated songs will be considered.",
            "required": false,
            "schema": {
              "type": "integer"
            }
          }
        ],
        "responses": {
          "200": {
            "description": "Successful response with a list of favorite moods.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object",
                  "additionalProperties": {
                    "type": "integer"
                  },
                  "example": {
                    "Happy": 5,
                    "Sad": 3,
                    "Excited": 2,
                    "Relaxed": 1
                  }
                }
              }
            }
          },
          "400": {
            "description": "Invalid number of songs."
          },
          "404": {
            "description": "User not found."
          },
          "500": {
            "description": "Internal server error."
          }
        },
        "security": [
          {
            "bearerAuth": []
          }
        ]
      }
    },
    "/users/get-favorite-tempo/": {
      "get": {
        "tags": [
          "User",
          "Chart"
        ],
        "summary": "Get a list of favorite tempos for a user based on their song ratings.",
        "parameters": [
          {
            "name": "number_of_songs",
            "in": "query",
            "description": "The number of songs to consider for determining favorite tempos. If not specified, all rated songs will be considered.",
            "required": false,
            "schema": {
              "type": "integer"
            }
          }
        ],
        "responses": {
          "200": {
            "description": "Successful response with a list of favorite tempos.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object",
                  "additionalProperties": {
                    "type": "integer"
                  },
                  "example": {
                    "Slow": 4,
                    "Moderate": 6,
                    "Fast": 2
                  }
                }
              }
            }
          },
          "400": {
            "description": "Invalid number of songs."
          },
          "404": {
            "description": "User not found."
          },
          "500": {
            "description": "Internal server error."
          }
        },
        "security": [
          {
            "bearerAuth": []
          }
        ]
      }
    },
    "/users/get-all-recent/": {
      "get": {
        "tags": [
          "User",
          "Recommendation"
        ],
        "summary": "Get a list of the most recently added songs.",
        "parameters": [
          {
            "name": "number_of_songs",
            "in": "query",
            "description": "The number of recent songs to retrieve (default: 10).",
            "required": false,
            "schema": {
              "type": "integer",
              "default": 10
            }
          }
        ],
        "responses": {
          "200": {
            "description": "Successful response with a list of recent songs.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object",
                  "properties": {
                    "songs": {
                      "type": "array",
                      "items": {
                        "type": "object",
                        "properties": {
                          "id": {
                            "type": "string",
                            "maxLength": 200
                          },
                          "name": {
                            "type": "string",
                            "maxLength": 200
                          },
                          "release_year": {
                            "type": "integer",
                            "format": "int32",
                            "nullable": true
                          },
                          "main_artist": {
                            "type": "string"
                          },
                          "img_url": {
                            "type": "string",
                            "format": "url",
                            "maxLength": 300,
                            "nullable": true
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          },
          "400": {
            "description": "Invalid number of songs."
          },
          "404": {
            "description": "User not found."
          },
          "500": {
            "description": "Internal server error."
          }
        },
        "security": [
          {
            "bearerAuth": []
          }
        ]
      }
    },
    "/users/send-friend-request/": {
      "post": {
        "tags": [
          "User",
          "Friend"
        ],
        "summary": "Send a friend request to another user.",
        "requestBody": {
          "description": "Data needed to send a friend request.",
          "required": true,
          "content": {
            "application/json": {
              "schema": {
                "type": "object",
                "properties": {
                  "username": {
                    "type": "string",
                    "description": "The username of the receiver of the friend request."
                  }
                },
                "required": [
                  "username"
                ]
              }
            }
          }
        },
        "responses": {
          "200": {
            "description": "Friend request sent successfully.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object",
                  "properties": {
                    "message": {
                      "type": "string"
                    }
                  }
                }
              }
            }
          },
          "400": {
            "description": "Missing parameter, user is already a friend, cannot send a request to oneself, or there is already a pending request."
          },
          "404": {
            "description": "User or receiver not found."
          },
          "409": {
            "description": "Conflict with an existing pending friend request."
          },
          "500": {
            "description": "Internal server error."
          }
        },
        "security": [
          {
            "bearerAuth": []
          }
        ]
      }
    },
    "/users/get-all-incoming-requests/": {
      "get": {
        "tags": [
          "User",
          "Friend"
        ],
        "summary": "Retrieve all incoming friend requests for the user.",
        "responses": {
          "200": {
            "description": "Successful retrieval of incoming friend requests.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object",
                  "properties": {
                    "requests": {
                      "type": "array",
                      "items": {
                        "type": "object",
                        "properties": {
                          "id": {
                            "type": "string"
                          },
                          "name": {
                            "type": "string"
                          },
                          "img_url": {
                            "type": "string",
                            "format": "url",
                            "nullable": true
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          },
          "405": {
            "description": "Method Not Allowed."
          },
          "500": {
            "description": "Internal server error or database error."
          }
        },
        "security": [
          {
            "bearerAuth": []
          }
        ]
      }
    },
    "/users/get-incoming-request-count/": {
      "get": {
        "tags": [
          "User",
          "Friend"
        ],
        "summary": "Get the count of incoming friend requests for the user.",
        "responses": {
          "200": {
            "description": "Successful retrieval of the count of incoming friend requests.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object",
                  "properties": {
                    "count": {
                      "type": "integer",
                      "description": "The number of incoming friend requests."
                    }
                  }
                }
              }
            }
          },
          "405": {
            "description": "Method Not Allowed."
          },
          "500": {
            "description": "Internal server error or database error."
          }
        },
        "security": [
          {
            "bearerAuth": []
          }
        ]
      }
    },
    "/users/cancel-friend-request/": {
      "post": {
        "tags": [
          "User",
          "Friend"
        ],
        "summary": "Cancel an outgoing friend request to another user.",
        "requestBody": {
          "description": "Data needed to cancel a friend request.",
          "required": true,
          "content": {
            "application/json": {
              "schema": {
                "type": "object",
                "properties": {
                  "username": {
                    "type": "string",
                    "description": "The username of the receiver of the friend request to be canceled."
                  }
                },
                "required": [
                  "username"
                ]
              }
            }
          }
        },
        "responses": {
          "200": {
            "description": "Friend request canceled successfully.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object",
                  "properties": {
                    "message": {
                      "type": "string"
                    }
                  }
                }
              }
            }
          },
          "400": {
            "description": "Missing parameter or invalid request."
          },
          "404": {
            "description": "Receiver user not found or no pending request exists."
          },
          "500": {
            "description": "Internal server error."
          }
        },
        "security": [
          {
            "bearerAuth": []
          }
        ]
      }
    },
    "/users/remove-friend/": {
      "delete": {
        "tags": [
          "User",
          "Friend"
        ],
        "parameters": [
          {
            "name": "friend_username",
            "in": "query",
            "required": true,
            "schema": {
              "type": "string"
            },
            "description": "The username of the friend to be removed"
          }
        ],
        "summary": "Remove a friend",
        "operationId": "removeFriend",
        "responses": {
          "200": {
            "description": "Friend removed successfully",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object",
                  "properties": {
                    "detail": {
                      "type": "string"
                    }
                  }
                }
              }
            }
          },
          "400": {
            "description": "Invalid request or friendship does not exist",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object",
                  "properties": {
                    "error": {
                      "type": "string"
                    }
                  }
                }
              }
            }
          },
          "404": {
            "description": "User or friend does not exist",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object",
                  "properties": {
                    "detail": {
                      "type": "string"
                    }
                  }
                }
              }
            }
          }
        }
      }
    },
    "/users/add-friend/": {
      "post": {
        "tags": [
          "User",
          "Friend"
        ],
        "parameters": [
          {
            "name": "friend_id",
            "in": "query",
            "required": true,
            "schema": {
              "type": "integer"
            },
            "description": "The ID of the friend to be added"
          }
        ],
        "summary": "Add a friend",
        "operationId": "addFriend",
        "responses": {
          "200": {
            "description": "Friend added successfully",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object",
                  "properties": {
                    "detail": {
                      "type": "string"
                    }
                  }
                }
              }
            }
          },
          "400": {
            "description": "Invalid request or friendship already exists",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object",
                  "properties": {
                    "error": {
                      "type": "string"
                    }
                  }
                }
              }
            }
          },
          "404": {
            "description": "User or friend does not exist",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object",
                  "properties": {
                    "detail": {
                      "type": "string"
                    }
                  }
                }
              }
            }
          }
        }
      }
    },
    "/users/get-all-friends/": {
      "get": {
        "tags": [
          "User",
          "Friend"
        ],
        "summary": "Retrieve all friends of the user.",
        "responses": {
          "200": {
            "description": "Successful retrieval of all friends.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object",
                  "properties": {
                    "friends": {
                      "type": "array",
                      "items": {
                        "type": "object",
                        "properties": {
                          "id": {
                            "type": "string"
                          },
                          "name": {
                            "type": "string"
                          },
                          "img_url": {
                            "type": "string",
                            "format": "url",
                            "nullable": true
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          },
          "405": {
            "description": "Method Not Allowed."
          },
          "500": {
            "description": "Internal server error or database error."
          }
        },
        "security": [
          {
            "bearerAuth": []
          }
        ]
      }
    },
    "/users/edit-user-preferences/": {
      "put": {
        "tags": [
          "User"
        ],
        "summary": "Edit the preferences of a user.",
        "requestBody": {
          "description": "Data for updating user preferences.",
          "required": true,
          "content": {
            "application/json": {
              "schema": {
                "type": "object",
                "properties": {
                  "username": {
                    "type": "string",
                    "description": "New username of the user.",
                    "minLength": 6,
                    "maxLength": 16
                  },
                  "email": {
                    "type": "string",
                    "format": "email",
                    "description": "New email of the user."
                  },
                  "img_url": {
                    "type": "string",
                    "format": "url",
                    "description": "New image URL for the user's profile."
                  },
                  "data_processing_consent": {
                    "type": "boolean",
                    "description": "Consent for data processing."
                  },
                  "data_sharing_consent": {
                    "type": "boolean",
                    "description": "Consent for data sharing."
                  }
                }
              }
            }
          }
        },
        "responses": {
          "204": {
            "description": "Preferences updated successfully."
          },
          "400": {
            "description": "Invalid request data or no fields provided for update."
          },
          "404": {
            "description": "User not found."
          },
          "405": {
            "description": "Invalid request method."
          },
          "500": {
            "description": "Internal server error."
          }
        },
        "security": [
          {
            "bearerAuth": []
          }
        ]
      }
    },
    "/users/recommend-you-might-like/": {
      "get": {
        "tags": [
          "User",
          "Recommendation"
        ],
        "summary": "Get music recommendations for the user.",
        "parameters": [
          {
            "name": "count",
            "in": "query",
            "description": "The number of recommendations to retrieve (between 1 and 100).",
            "required": true,
            "schema": {
              "type": "integer",
              "minimum": 1,
              "maximum": 100
            }
          }
        ],
        "responses": {
          "200": {
            "description": "Successful retrieval of recommendations.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object",
                  "properties": {
                    "message": {
                      "type": "string"
                    },
                    "tracks_info": {
                      "type": "array",
                      "items": {
                        "type": "object",
                        "properties": {
                          "songs": {
                            "type": "array",
                            "items": {
                              "$ref": "#/components/schemas/Song"
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          },
          "400": {
            "description": "Invalid method or wrong parameter."
          },
          "404": {
            "description": "No songs found for the user or no recommendations can be made."
          },
          "500": {
            "description": "KeyError occurred or an unexpected error occurred."
          }
        },
        "security": [
          {
            "bearerAuth": []
          }
        ]
      }
    },
    "/users/get-user-profile/": {
      "get": {
        "tags": [
          "User"
        ],
        "summary": "Retrieve the profile information of a user.",
        "responses": {
          "200": {
            "description": "Successful retrieval of user profile.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object",
                  "properties": {
                    "id": {
                      "type": "string"
                    },
                    "name": {
                      "type": "string"
                    },
                    "img_url": {
                      "type": "string",
                      "format": "url",
                      "nullable": true
                    },
                    "preferences": {
                      "type": "object",
                      "properties": {
                        "data_processing": {
                          "type": "boolean"
                        },
                        "data_sharing": {
                          "type": "boolean"
                        }
                      }
                    }
                  }
                }
              }
            }
          },
          "404": {
            "description": "User not found."
          },
          "405": {
            "description": "Method not allowed."
          }
        },
        "security": [
          {
            "bearerAuth": []
          }
        ]
      }
    },
    "/users/get-recent-addition-counts/": {
      "get": {
        "tags": [
          "User",
          "Chart"
        ],
        "summary": "Get the count of songs added by the user over the last five days.",
        "responses": {
          "200": {
            "description": "Successful retrieval of song addition counts per day.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object",
                  "properties": {
                    "song_counts": {
                      "type": "array",
                      "items": {
                        "type": "object",
                        "properties": {
                          "date": {
                            "type": "string",
                            "format": "date"
                          },
                          "count": {
                            "type": "integer"
                          }
                        }
                      }
                    }
                  },
                  "example": {
                    "song_counts": [
                      {
                        "date": "01-01",
                        "count": 3
                      },
                      {
                        "date": "02-01",
                        "count": 2
                      },
                      {
                        "date": "03-01",
                        "count": 4
                      },
                      {
                        "date": "04-01",
                        "count": 1
                      },
                      {
                        "date": "05-01",
                        "count": 0
                      }
                    ]
                  }
                }
              }
            }
          },
          "404": {
            "description": "User does not exist."
          },
          "405": {
            "description": "Method Not Allowed."
          },
          "500": {
            "description": "Internal server error."
          }
        },
        "security": [
          {
            "bearerAuth": []
          }
        ]
      }
    },
    "/users/get-profile-stats/": {
      "get": {
        "tags": [
          "User"
        ],
        "summary": "Get statistical data about the user's profile.",
        "responses": {
          "200": {
            "description": "Successful retrieval of profile statistics.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object",
                  "properties": {
                    "rated_count": {
                      "type": "integer",
                      "description": "The total number of songs rated by the user."
                    },
                    "friend_count": {
                      "type": "integer",
                      "description": "The number of friends the user has."
                    },
                    "rating_average": {
                      "type": "number",
                      "format": "float",
                      "description": "The average rating given by the user."
                    }
                  }
                }
              }
            }
          },
          "404": {
            "description": "User does not exist."
          },
          "405": {
            "description": "Method Not Allowed."
          },
          "500": {
            "description": "Internal server error."
          }
        },
        "security": [
          {
            "bearerAuth": []
          }
        ]
      }
    },
    "/users/recommend-since-you-like/": {
      "get": {
        "tags": [
          "User",
          "Recommendation"
        ],
        "summary": "Get personalized music recommendations based on user's favorite genres and artists.",
        "parameters": [
          {
            "name": "count",
            "in": "query",
            "description": "The number of recommendations to retrieve (between 1 and 100).",
            "required": true,
            "schema": {
              "type": "integer",
              "minimum": 1,
              "maximum": 100
            }
          }
        ],
        "responses": {
          "200": {
            "description": "Successful retrieval of recommendations.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object",
                  "properties": {
                    "message": {
                      "type": "string"
                    },
                    "tracks_info": {
                      "type": "object",
                      "additionalProperties": {
                        "type": "array",
                        "items": {
                          "type": "object",
                          "properties": {
                            "songs": {
                              "type": "array",
                              "items": {
                                "$ref": "#/components/schemas/Song"
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          },
          "400": {
            "description": "Invalid method or wrong parameter."
          },
          "404": {
            "description": "No genre or artist found for the user, or no recommendations can be made."
          },
          "500": {
            "description": "KeyError occurred or an unexpected error occurred."
          }
        },
        "security": [
          {
            "bearerAuth": []
          }
        ]
      }
    },
    "/users/recommend-friend-mix/": {
      "get": {
        "tags": [
          "User",
          "Recommendation"
        ],
        "summary": "Get music recommendations based on the preferences of the user's friends.",
        "parameters": [
          {
            "name": "count",
            "in": "query",
            "description": "The number of recommendations to retrieve (between 1 and 100).",
            "required": true,
            "schema": {
              "type": "integer",
              "minimum": 1,
              "maximum": 100
            }
          }
        ],
        "responses": {
          "200": {
            "description": "Successful retrieval of recommendations based on friends' preferences.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object",
                  "properties": {
                    "message": {
                      "type": "string"
                    },
                    "tracks_info": {
                      "type": "array",
                      "items": {
                        "type": "object",
                        "properties": {}
                      }
                    }
                  }
                }
              }
            }
          },
          "400": {
            "description": "Invalid method or invalid count."
          },
          "404": {
            "description": "No friends found for the user, no songs found for friends, or no recommendations can be made."
          },
          "500": {
            "description": "KeyError occurred, user not found, or an unexpected error occurred."
          }
        },
        "security": [
          {
            "bearerAuth": []
          }
        ]
      }
    },
    "/users/recommend-friend-listen/": {
      "get": {
        "tags": [
          "User",
          "Recommendation"
        ],
        "summary": "Get song recommendations based on what the user's friends are listening to.",
        "parameters": [
          {
            "name": "count",
            "in": "query",
            "description": "The number of song recommendations to retrieve. Must be a positive number.",
            "required": true,
            "schema": {
              "type": "integer",
              "minimum": 1
            }
          }
        ],
        "responses": {
          "200": {
            "description": "Successful retrieval of recommendations based on friends' listening habits.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object",
                  "properties": {
                    "message": {
                      "type": "string"
                    },
                    "tracks_info": {
                      "type": "array",
                      "items": {
                        "type": "object",
                        "properties": {
                          "name": {
                            "type": "string"
                          },
                          "main_artist": {
                            "type": "array",
                            "items": {
                              "type": "string"
                            }
                          },
                          "release_year": {
                            "type": "integer"
                          },
                          "id": {
                            "type": "string"
                          },
                          "img_url": {
                            "type": "string",
                            "format": "url",
                            "nullable": true
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          },
          "400": {
            "description": "Invalid method or invalid count."
          },
          "404": {
            "description": "No friends or songs found for the user."
          },
          "500": {
            "description": "KeyError occurred or an unexpected error occurred."
          }
        },
        "security": [
          {
            "bearerAuth": []
          }
        ]
      }
    },
    "/users/export-by-genre/": {
      "get": {
        "tags": [
          "User",
          "Import/Export File"
        ],
        "summary": "Export song data filtered by a specific genre for the user.",
        "parameters": [
          {
            "name": "genre",
            "in": "query",
            "description": "The genre to filter songs by.",
            "required": true,
            "schema": {
              "type": "string"
            }
          }
        ],
        "responses": {
          "200": {
            "description": "Successful retrieval and export of songs data filtered by the specified genre.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "array",
                  "items": {
                    "type": "object",
                    "properties": {
                      "id": {
                        "type": "string"
                      },
                      "name": {
                        "type": "string"
                      }
                    }
                  }
                }
              }
            }
          },
          "400": {
            "description": "Missing filter, invalid input, or file operation error."
          },
          "404": {
            "description": "User, genre, or artist does not exist."
          },
          "500": {
            "description": "Internal server error or file operation error."
          }
        },
        "security": [
          {
            "bearerAuth": []
          }
        ]
      }
    },
    "/users/export-by-artist/": {
      "get": {
        "tags": [
          "User",
          "Import/Export File"
        ],
        "summary": "Export song data filtered by a specific artist for the user.",
        "parameters": [
          {
            "name": "artist",
            "in": "query",
            "description": "The artist to filter songs by.",
            "required": true,
            "schema": {
              "type": "string"
            }
          }
        ],
        "responses": {
          "200": {
            "description": "Successful retrieval and export of songs data filtered by the specified artist.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "array",
                  "items": {
                    "type": "object",
                    "properties": {
                      "id": {
                        "type": "string"
                      },
                      "name": {
                        "type": "string"
                      }
                    }
                  }
                }
              }
            }
          },
          "400": {
            "description": "Missing filter or invalid input."
          },
          "404": {
            "description": "User, genre, or artist does not exist."
          },
          "500": {
            "description": "Internal server error or file operation error."
          }
        },
        "security": [
          {
            "bearerAuth": []
          }
        ]
      }
    },
    "/users/get-library-artist-names/": {
      "get": {
        "tags": [
          "User",
          "Import/Export File"
        ],
        "summary": "Retrieve a list of artist names from the user's song library.",
        "responses": {
          "200": {
            "description": "Successful retrieval of artist names from the user's library.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object",
                  "properties": {
                    "artists": {
                      "type": "array",
                      "items": {
                        "type": "string"
                      }
                    }
                  }
                }
              }
            }
          },
          "404": {
            "description": "No artist is found for the user or the user does not exist."
          },
          "405": {
            "description": "Method Not Allowed."
          },
          "500": {
            "description": "Internal server error."
          }
        },
        "security": [
          {
            "bearerAuth": []
          }
        ]
      }
    },
    "/users/get-library-genre-names/": {
      "get": {
        "tags": [
          "User",
          "Import/Export File"
        ],
        "summary": "Retrieve a list of genre names from the user's song library.",
        "responses": {
          "200": {
            "description": "Successful retrieval of genre names from the user's library.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object",
                  "properties": {
                    "genres": {
                      "type": "array",
                      "items": {
                        "type": "string"
                      }
                    }
                  }
                }
              }
            }
          },
          "404": {
            "description": "No genre is found for the user or the user does not exist."
          },
          "405": {
            "description": "Method Not Allowed."
          },
          "500": {
            "description": "Internal server error."
          }
        },
        "security": [
          {
            "bearerAuth": []
          }
        ]
      }
    },
    "/users/upload-file/": {
      "post": {
        "tags": [
          "User",
          "Import/Export File"
        ],
        "summary": "Import song data for the user from a JSON file.",
        "requestBody": {
          "description": "JSON file containing song data to be imported.",
          "required": true,
          "content": {
            "multipart/form-data": {
              "schema": {
                "type": "object",
                "properties": {
                  "file": {
                    "type": "string",
                    "format": "binary",
                    "description": "The JSON file containing song data."
                  }
                },
                "required": [
                  "file"
                ]
              }
            }
          }
        },
        "responses": {
          "201": {
            "description": "Song data imported successfully.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object",
                  "properties": {
                    "items": {
                      "type": "array",
                      "items": {
                        "type": "object",
                        "properties": {
                          "message": {
                            "type": "string"
                          },
                          "error": {
                            "type": "string"
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          },
          "400": {
            "description": "No file provided or missing required fields in the file."
          },
          "404": {
            "description": "User not found."
          },
          "405": {
            "description": "Method Not Allowed."
          },
          "500": {
            "description": "Unexpected error occurred during file processing."
          }
        },
        "security": [
          {
            "bearerAuth": []
          }
        ]
      }
    },
    "/users/get-all-data-sharing-friends/": {
      "get": {
        "tags": [
          "User",
          "Friend"
        ],
        "summary": "Retrieve all friends of the user who have consented to data sharing.",
        "responses": {
          "200": {
            "description": "Successful retrieval of all friends with data sharing consent.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object",
                  "properties": {
                    "friends": {
                      "type": "array",
                      "items": {
                        "type": "object",
                        "properties": {
                          "id": {
                            "type": "string"
                          },
                          "name": {
                            "type": "string"
                          },
                          "img_url": {
                            "type": "string",
                            "format": "url",
                            "nullable": true
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          },
          "405": {
            "description": "Method Not Allowed."
          },
          "500": {
            "description": "Internal server error or database error."
          }
        },
        "security": [
          {
            "bearerAuth": []
          }
        ]
      }
    },
    "/users/get-friends-favorite-genres/": {
      "get": {
        "tags": [
          "User",
          "Friend",
          "Chart"
        ],
        "summary": "Retrieve the favorite music genres of a specific friend, considering their data sharing consent.",
        "parameters": [
          {
            "name": "friend_id",
            "in": "query",
            "description": "Unique identifier of the friend whose favorite genres are to be retrieved.",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "number_of_songs",
            "in": "query",
            "description": "The number of songs to consider for determining the friend's favorite genres. If not specified, all rated songs of the friend will be considered.",
            "required": false,
            "schema": {
              "type": "integer"
            }
          },
          {
            "name": "limit",
            "in": "query",
            "description": "The maximum number of top genres to return. If not specified, 10 genres will be returned. You can configure this value to get a better visualization in the chart. For example, if you get too much genres for a given number of songs, and it looks ugly in the chart, you can limit the number of genres to be returned.",
            "required": false,
            "schema": {
              "type": "integer"
            }
          }
        ],
        "responses": {
          "200": {
            "description": "Successful response with a list of the friend's favorite genres.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object",
                  "additionalProperties": {
                    "type": "integer"
                  },
                  "example": {
                    "Genre 1": 5,
                    "Genre 2": 3,
                    "Genre 3": 2
                  }
                }
              }
            }
          },
          "400": {
            "description": "Invalid parameters or user does not share data."
          },
          "404": {
            "description": "User not found."
          },
          "500": {
            "description": "Internal server error."
          }
        },
        "security": [
          {
            "bearerAuth": []
          }
        ]
      }
    },
    "/users/get-friends-favorite-artists/": {
      "get": {
        "tags": [
          "User",
          "Friend",
          "Chart"
        ],
        "summary": "Retrieve the favorite artists of a specific friend, considering their data sharing consent.",
        "parameters": [
          {
            "name": "friend_id",
            "in": "query",
            "description": "Unique identifier of the friend whose favorite artists are to be retrieved.",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "number_of_songs",
            "in": "query",
            "description": "The number of songs to consider for determining the friend's favorite artists. If not specified, all rated songs of the friend will be considered.",
            "required": false,
            "schema": {
              "type": "integer"
            }
          },
          {
            "name": "limit",
            "in": "query",
            "description": "The maximum number of top artists to return. If not specified, 10 artists will be returned. You can configure this value to get a better visualization in the chart. For example, if you get too much artists for a given number of songs, and it looks ugly in the chart, you can limit the number of artists to be returned.",
            "required": false,
            "schema": {
              "type": "integer"
            }
          }
        ],
        "responses": {
          "200": {
            "description": "Successful response with a list of the friend's favorite artists.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object",
                  "additionalProperties": {
                    "type": "integer"
                  },
                  "example": {
                    "Artist 1": 5,
                    "Artist 2": 3,
                    "Artist 3": 2
                  }
                }
              }
            }
          },
          "400": {
            "description": "Invalid parameters or user does not share data."
          },
          "404": {
            "description": "User not found."
          },
          "500": {
            "description": "Internal server error."
          }
        },
        "security": [
          {
            "bearerAuth": []
          }
        ]
      }
    },
    "/users/get-friends-favorite-moods/": {
      "get": {
        "tags": [
          "User",
          "Friend",
          "Chart"
        ],
        "summary": "Retrieve the favorite music moods of a specific friend, considering their data sharing consent.",
        "parameters": [
          {
            "name": "friend_id",
            "in": "query",
            "description": "Unique identifier of the friend whose favorite music moods are to be retrieved.",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "number_of_songs",
            "in": "query",
            "description": "The number of songs to consider for determining the friend's favorite music moods. If not specified, all rated songs of the friend will be considered.",
            "required": false,
            "schema": {
              "type": "integer"
            }
          }
        ],
        "responses": {
          "200": {
            "description": "Successful response with a list of the friend's favorite music moods.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object",
                  "additionalProperties": {
                    "type": "integer"
                  },
                  "example": {
                    "Excited": 5,
                    "Relaxed": 3,
                    "Happy": 2,
                    "Sad": 1
                  }
                }
              }
            }
          },
          "400": {
            "description": "Invalid parameters or user does not share data."
          },
          "404": {
            "description": "User not found."
          },
          "500": {
            "description": "Internal server error."
          }
        },
        "security": [
          {
            "bearerAuth": []
          }
        ]
      }
    },
    "/users/get-friends-favorite-tempos/": {
      "get": {
        "tags": [
          "User",
          "Friend",
          "Chart"
        ],
        "summary": "Retrieve the favorite music tempos of a specific friend, considering their data sharing consent.",
        "parameters": [
          {
            "name": "friend_id",
            "in": "query",
            "description": "Unique identifier of the friend whose favorite music tempos are to be retrieved.",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "number_of_songs",
            "in": "query",
            "description": "The number of songs to consider for determining the friend's favorite music tempos. If not specified, all rated songs of the friend will be considered.",
            "required": false,
            "schema": {
              "type": "integer"
            }
          }
        ],
        "responses": {
          "200": {
            "description": "Successful response with a list of the friend's favorite music tempos.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object",
                  "additionalProperties": {
                    "type": "integer"
                  },
                  "example": {
                    "Fast": 5,
                    "Medium": 3,
                    "Slow": 2
                  }
                }
              }
            }
          },
          "400": {
            "description": "Invalid parameters or user does not share data."
          },
          "404": {
            "description": "User not found."
          },
          "500": {
            "description": "Internal server error."
          }
        },
        "security": [
          {
            "bearerAuth": []
          }
        ]
      }
    },
    "/users/get-friends-recent-addition-counts/": {
      "get": {
        "tags": [
          "User",
          "Friend",
          "Chart"
        ],
        "summary": "Retrieve the count of songs added by a specific friend over the last five days, considering their data sharing consent.",
        "parameters": [
          {
            "name": "friend_id",
            "in": "query",
            "description": "Unique identifier of the friend whose recent song addition count is to be retrieved.",
            "required": true,
            "schema": {
              "type": "string"
            }
          }
        ],
        "responses": {
          "200": {
            "description": "Successful response with a count of songs added by the friend over the most recent five days.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object",
                  "properties": {
                    "song_counts": {
                      "type": "array",
                      "items": {
                        "type": "object",
                        "properties": {
                          "date": {
                            "type": "string",
                            "format": "date"
                          },
                          "count": {
                            "type": "integer"
                          }
                        }
                      }
                    }
                  },
                  "example": {
                    "song_counts": [
                      {
                        "date": "01-01",
                        "count": 3
                      },
                      {
                        "date": "02-01",
                        "count": 2
                      },
                      {
                        "date": "03-01",
                        "count": 4
                      },
                      {
                        "date": "04-01",
                        "count": 1
                      },
                      {
                        "date": "05-01",
                        "count": 0
                      }
                    ]
                  }
                }
              }
            }
          },
          "400": {
            "description": "Invalid parameters or user does not share data."
          },
          "404": {
            "description": "User not found."
          },
          "500": {
            "description": "Internal server error."
          }
        },
        "security": [
          {
            "bearerAuth": []
          }
        ]
      }
    },
    "/users/suggest-song/": {
      "post": {
        "tags": [
          "User",
          "Friend",
          "Recommendation"
        ],
        "summary": "Send a friend of yours a song that you would like recommend. Your friend will receive a notification based on the recommended song in his notification bar.",
        "requestBody": {
          "description": "Data needed to send a friend a song suggestion.",
          "required": true,
          "content": {
            "application/json": {
              "schema": {
                "type": "object",
                "properties": {
                  "receiver_user": {
                    "type": "string",
                    "description": "The username of the receiver of the song suggestion."
                  },
                  "song_id": {
                    "type": "string",
                    "description": "The ID of the song for the song suggestion."
                  }
                },
                "required": [
                  "sender_user",
                  "receiver_user",
                  "song_id"
                ]
              }
            }
          }
        },
        "responses": {
          "200": {
            "description": "Successful response with returning a message, indicating that it was sent.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object",
                  "properties": {
                    "message": {
                      "type": "string"
                    }
                  }
                }
              }
            }
          },
          "400": {
            "description": "Missing parameters, Invalid method or Sending a song to yourself."
          },
          "404": {
            "description": "User not found or Song not found."
          },
          "500": {
            "description": "Internal server error."
          }
        },
        "security": [
          {
            "bearerAuth": []
          }
        ]
      }
    },
    "/users/get-playlists/": {
      "get": {
        "tags": [
          "Playlist"
        ],
        "summary": "Retrieve playlists for a user",
        "description": "Fetches all playlists associated with a given user ID. The number of playlists retrieved can be specified.",
        "parameters": [
          {
            "name": "number_of_playlists",
            "in": "query",
            "default": "10",
            "required": false,
            "description": "The number of playlists to retrieve.",
            "schema": {
              "type": "integer"
            }
          }
        ],
        "responses": {
          "200": {
            "description": "List of playlists retrieved successfully",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object",
                  "properties": {
                    "items": {
                      "type": "array",
                      "items": {
                        "type": "object",
                        "properties": {
                          "id": {
                            "type": "integer"
                          },
                          "name": {
                            "type": "string"
                          },
                          "description": {
                            "type": "string"
                          },
                          "song_imgs": {
                            "type": "array",
                            "items": {
                              "type": "string",
                              "format": "url"
                            }
                          },
                          "user_id": {
                            "type": "integer",
                            "nullable": true
                          },
                          "friend_group_id": {
                            "type": "integer",
                            "nullable": true
                          }
                        }
                      }
                    },
                    "count": {
                      "type": "integer"
                    }
                  }
                }
              }
            }
          },
          "404": {
            "description": "User does not exist"
          },
          "500": {
            "description": "Unexpected error"
          }
        },
        "security": [
          {
            "bearerAuth": []
          }
        ]
      }
    },
    "/users/get-playlist-by-id/": {
      "get": {
        "tags": [
          "Playlist"
        ],
        "summary": "Retrieve a specific playlist for a user by its ID",
        "description": "Fetches detailed information about a specific playlist using its unique ID.",
        "parameters": [
          {
            "name": "playlist_id",
            "in": "query",
            "required": true,
            "description": "The unique identifier of the playlist to be retrieved",
            "schema": {
              "type": "string"
            }
          }
        ],
        "responses": {
          "200": {
            "description": "Playlist retrieved successfully",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object",
                  "properties": {
                    "playlist": {
                      "type": "object",
                      "properties": {
                        "id": {
                          "type": "integer"
                        },
                        "name": {
                          "type": "string"
                        },
                        "description": {
                          "type": "string"
                        },
                        "songs": {
                          "type": "array",
                          "items": {
                            "type": "object",
                            "properties": {
                              "id": {
                                "type": "string"
                              },
                              "name": {
                                "type": "string"
                              },
                              "release_year": {
                                "type": "integer"
                              },
                              "img_url": {
                                "type": "string",
                                "format": "url"
                              },
                              "main_artist": {
                                "type": "string"
                              }
                            }
                          }
                        },
                        "user_id": {
                          "type": "integer",
                          "nullable": true
                        },
                        "friend_group_id": {
                          "type": "integer",
                          "nullable": true
                        }
                      }
                    }
                  }
                }
              }
            }
          },
          "400": {
            "description": "Missing parameters"
          },
          "404": {
            "description": "Playlist does not exist"
          },
          "500": {
            "description": "Unexpected error"
          }
        },
        "security": [
          {
            "bearerAuth": []
          }
        ]
      }
    },
    "/users/create-empty-playlist/": {
      "post": {
        "tags": [
          "Playlist"
        ],
        "summary": "Create a new empty playlist",
        "description": "Creates a new empty playlist for the user. Description and name are optional, if not provided a default name and description will be generated.",
        "parameters": [],
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "type": "object",
                "properties": {
                  "name": {
                    "type": "string",
                    "description": "The name of the new playlist. If not provided, a default name will be generated."
                  },
                  "description": {
                    "type": "string",
                    "description": "A description for the new playlist. If not provided, defaults to an empty string.",
                    "nullable": true,
                    "default": ""
                  }
                }
              }
            }
          }
        },
        "responses": {
          "201": {
            "description": "Playlist created successfully"
          },
          "400": {
            "description": "Missing parameters"
          },
          "404": {
            "description": "User does not exist"
          },
          "405": {
            "description": "Method not allowed"
          },
          "500": {
            "description": "Unexpected error"
          }
        },
        "security": [
          {
            "bearerAuth": []
          }
        ]
      }
    },
    "/users/add-song-to-playlist/": {
      "post": {
        "tags": [
          "Playlist"
        ],
        "summary": "Add a song to a playlist",
        "description": "Adds a specific song to a specified playlist based on their unique identifiers.",
        "parameters": [],
        "requestBody": {
          "required": true,
          "content": {
            "application/json": {
              "schema": {
                "type": "object",
                "properties": {
                  "playlist_id": {
                    "type": "string",
                    "description": "The unique identifier of the playlist"
                  },
                  "song_id": {
                    "type": "string",
                    "description": "The unique identifier of the song"
                  }
                },
                "required": [
                  "playlist_id",
                  "song_id"
                ]
              }
            }
          }
        },
        "responses": {
          "200": {
            "description": "Song added to playlist successfully"
          },
          "400": {
            "description": "Missing parameters"
          },
          "404": {
            "description": "Playlist or Song does not exist"
          },
          "500": {
            "description": "Unexpected error"
          }
        },
        "security": [
          {
            "bearerAuth": []
          }
        ]
      }
    },
    "/users/edit-playlist/": {
      "put": {
        "tags": [
          "Playlist"
        ],
        "summary": "Edit a playlist",
        "description": "Updates the details of an existing playlist, identified by its unique ID. Allows editing the playlist name and description.",
        "parameters": [],
        "requestBody": {
          "required": true,
          "content": {
            "application/json": {
              "schema": {
                "type": "object",
                "properties": {
                  "playlist_id": {
                    "type": "string",
                    "description": "The unique identifier of the playlist"
                  },
                  "name": {
                    "type": "string",
                    "description": "The new name of the playlist"
                  },
                  "description": {
                    "type": "string",
                    "description": "The new description of the playlist"
                  }
                },
                "required": [
                  "playlist_id"
                ]
              }
            }
          }
        },
        "responses": {
          "200": {
            "description": "Playlist edited successfully"
          },
          "400": {
            "description": "Missing parameters"
          },
          "404": {
            "description": "Playlist does not exist"
          },
          "405": {
            "description": "Method not allowed"
          },
          "500": {
            "description": "Unexpected error"
          }
        },
        "security": [
          {
            "bearerAuth": []
          }
        ]
      }
    },
    "/users/remove-song-from-playlist/": {
      "delete": {
        "tags": [
          "Playlist"
        ],
        "summary": "Remove a song from a playlist",
        "description": "Removes a specific song from a specified playlist, identified by their unique IDs.",
        "parameters": [
          {
            "name": "playlist_id",
            "in": "query",
            "required": true,
            "description": "The unique identifier of the playlist",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "song_id",
            "in": "query",
            "required": true,
            "description": "The unique identifier of the song",
            "schema": {
              "type": "string"
            }
          }
        ],
        "responses": {
          "200": {
            "description": "Song removed from playlist successfully"
          },
          "400": {
            "description": "Missing parameters"
          },
          "404": {
            "description": "Playlist or Song does not exist"
          },
          "405": {
            "description": "Method not allowed"
          },
          "500": {
            "description": "Unexpected error"
          }
        },
        "security": [
          {
            "bearerAuth": []
          }
        ]
      }
    },
    "/users/delete-playlist/": {
      "delete": {
        "tags": [
          "Playlist"
        ],
        "summary": "Delete a playlist",
        "description": "Deletes a specified playlist, identified by its unique ID.",
        "parameters": [
          {
            "name": "playlist_id",
            "in": "query",
            "required": true,
            "description": "The unique identifier of the playlist to be deleted",
            "schema": {
              "type": "string"
            }
          }
        ],
        "responses": {
          "200": {
            "description": "Playlist deleted successfully"
          },
          "400": {
            "description": "Missing parameters"
          },
          "404": {
            "description": "Playlist does not exist"
          },
          "405": {
            "description": "Method not allowed"
          },
          "500": {
            "description": "Unexpected error"
          }
        },
        "security": [
          {
            "bearerAuth": []
          }
        ]
      }
    },
    "/users/save-playlist/": {
      "post": {
        "tags": [
          "Playlist"
        ],
        "summary": "Save a playlist",
        "description": "Create and save a playlist with the provided details and songs.",
        "security": [
          {
            "bearerAuth": []
          }
        ],
        "parameters": [
        ],
        "requestBody": {
          "required": true,
          "content": {
            "application/json": {
              "schema": {
                "type": "object",
                "properties": {
                  "name": {
                    "type": "string"
                  },
                  "description": {
                    "type": "string"
                  },
                  "songs": {
                    "type": "array",
                    "items": {
                      "type": "integer"
                    }
                  }
                },
                "required": ["name", "description"]
              }
            }
          }
        },
        "responses": {
          "201": {
            "description": "Playlist created successfully",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object",
                  "properties": {
                    "playlist_id": {
                      "type": "integer"
                    }
                  }
                }
              }
            }
          },
          "400": {
            "description": "Invalid JSON format"
          },
          "404": {
            "description": "User not found or one or more songs not found"
          },
          "405": {
            "description": "Invalid request method"
          },
          "500": {
            "description": "An unexpected error occurred"
          }
        }
      }
    },
    
    "/users/get-global-all-friend-groups/": {
      "get": {
        "tags": [
          "Tests"
        ],
        "summary": "Retrieve all friend groups globally",
        "operationId": "getGlobalAllFriendGroups",
        "security": [
          {
            "bearerAuth": []
          }
        ],
        "responses": {
          "200": {
            "description": "A list of all friend groups",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object",
                  "properties": {
                    "friend_groups": {
                      "type": "array",
                      "items": {
                        "$ref": "#/components/schemas/FriendGroupSimple"
                      }
                    }
                  }
                }
              }
            }
          },
          "500": {
            "description": "Internal Server Error",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            }
          }
        }
      }
    },
    "/users/create-friend-group/": {
      "post": {
        "tags": [
          "FriendGroup"
        ],
        "summary": "Create a new friend group",
        "operationId": "createFriendGroup",
        "security": [
          {
            "bearerAuth": []
          }
        ],
        "requestBody": {
          "description": "Data for creating a new friend group, Note: Only name field is required, description field is not required",
          "required": true,
          "content": {
            "application/json": {
              "schema": {
                "type": "object",
                "properties": {
                  "name": {
                    "type": "string"
                  },
                  "description": {
                    "type": "string",
                    "default": ""
                  }
                },
                "required": [
                  "name"
                ]
              }
            }
          }
        },
        "responses": {
          "201": {
            "description": "Friend group created successfully, returns the newly created friend group's id with a message field indicating that the friend group created successfully",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object",
                  "properties": {
                    "message": {
                      "type": "string"
                    },
                    "id": {
                      "type": "string"
                    }
                  }
                }
              }
            }
          },
          "400": {
            "description": "Bad Request - When the required field name for the friend group is not provided.",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            }
          },
          "404": {
            "description": "User not found",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            }
          },
          "500": {
            "description": "Internal Server Error",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            }
          }
        }
      }
    },
    "/users/get-friend-group-by-id/": {
      "get": {
        "tags": [
          "FriendGroup"
        ],
        "summary": "Retrieve a friend group by its ID",
        "operationId": "getFriendGroupById",
        "security": [
          {
            "bearerAuth": []
          }
        ],
        "parameters": [
          {
            "name": "group_id",
            "in": "query",
            "description": "The ID of the friend group to retrieve",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "extended",
            "in": "query",
            "description": "Flag to determine if extended information is required. If provided with any value(even dummy value works), the response provided in 200 status code will be returned. If not provided, members field from the 200 response will disappear and remaining fields will be returned.",
            "required": false,
            "schema": {
              "type": "string"
            }
          }
        ],
        "responses": {
          "200": {
            "description": "Details of the friend group",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object",
                  "properties": {
                    "friend_group": {
                      "$ref": "#/components/schemas/FriendGroupExtended"
                    }
                  }
                }
              }
            }
          },
          "400": {
            "description": "Bad Request - If the id for friend group is not provided.",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            }
          },
          "404": {
            "description": "Friend group not found",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            }
          },
          "500": {
            "description": "Internal Server Error",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            }
          }
        }
      }
    },
    "/users/add-friend-to-group/": {
      "put": {
        "tags": [
          "FriendGroup"
        ],
        "summary": "Add a friend to a friend group. Please note that only the admin of a friend group can add new people to it.",
        "operationId": "addFriendToGroup",
        "security": [
          {
            "bearerAuth": []
          }
        ],
        "requestBody": {
          "description": "Data needed to add a friend to the group",
          "required": true,
          "content": {
            "application/json": {
              "schema": {
                "type": "object",
                "properties": {
                  "group_id": {
                    "type": "integer",
                    "description": "The ID of the friend group"
                  },
                  "friend_name": {
                    "type": "string",
                    "description": "The username of the friend to add"
                  }
                },
                "required": [
                  "group_id",
                  "friend_name"
                ]
              }
            }
          }
        },
        "responses": {
          "200": {
            "description": "Friend successfully added to the group",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object",
                  "properties": {
                    "message": {
                      "type": "string"
                    }
                  }
                }
              }
            }
          },
          "400": {
            "description": "Bad Request - Missing or invalid parameters, or the admin tries to add itself to the friend group, or the user is already in the friend group.",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            }
          },
          "401": {
            "description": "Unauthorized - If the user is not admin, he/she is not authorized to add friends to this group",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            }
          },
          "404": {
            "description": "Not Found - Either friend group or friend does not exist",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            }
          },
          "500": {
            "description": "Internal Server Error",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            }
          }
        }
      }
    },
    "/users/remove-friend-from-group/": {
      "put": {
        "tags": [
          "FriendGroup"
        ],
        "summary": "Remove a friend from a friend group. Please note that only the admin of a friend group can add new people to it.",
        "operationId": "removeFriendFromGroup",
        "security": [
          {
            "bearerAuth": []
          }
        ],
        "requestBody": {
          "description": "Data needed to remove a friend from the group",
          "required": true,
          "content": {
            "application/json": {
              "schema": {
                "type": "object",
                "properties": {
                  "group_id": {
                    "type": "integer",
                    "description": "The ID of the friend group"
                  },
                  "friend_name": {
                    "type": "string",
                    "description": "The username of the friend to remove"
                  }
                },
                "required": [
                  "group_id",
                  "friend_name"
                ]
              }
            }
          }
        },
        "responses": {
          "200": {
            "description": "Friend successfully removed from the group",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object",
                  "properties": {
                    "message": {
                      "type": "string"
                    }
                  }
                }
              }
            }
          },
          "400": {
            "description": "Bad Request - Missing or invalid parameters, or the admin tries to remove itself to the friend group, or the user is not in the friend group.",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            }
          },
          "401": {
            "description": "Unauthorized - If the user is not admin, he/she is not authorized to remove friends from this group",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            }
          },
          "404": {
            "description": "Not Found - Either friend group or friend does not exist",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            }
          },
          "500": {
            "description": "Internal Server Error",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            }
          }
        }
      }
    },
    "/users/edit-friend-group/": {
      "put": {
        "tags": ["FriendGroup"],
        "summary": "Edit the name and description of a friend group. Please note that only the admin of a friend group can edit it.",
        "description": "This endpoint allows a user to edit the details of a friend group. Only the creator of the friend group can edit its details.",
        "operationId": "editFriendGroup",
        "security": [
          {
            "bearerAuth": []
          }
        ],

        "requestBody": {
          "required": true,
          "content": {
            "application/json": {
              "schema": {
                "type": "object",
                "properties": {
                  "group_id": {
                    "type": "integer",
                    "description": "The unique identifier of the group to be edited"
                  },
                  "name": {
                    "type": "string",
                    "description": "The new name of the friend group"
                  },
                  "description": {
                    "type": "string",
                    "description": "The new description of the friend group"
                  }
                }
              }
            }
          }
        },
        "responses": {
          "200": {
            "description": "OK - Friend group edited successfully",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object",
                  "properties": {
                    "message": {
                      "type": "string",
                      "example": "Friend group edited successfully"
                    }
                  }
                }
              }
            }
          },
          "400": {
            "description": "Bad Request - Missing or invalid group ID",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            }
          },
          "401": {
            "description": "Unauthorized - If the user is not the creator, he/she is not authorized to edit this friend group",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            }
          },
          "404": {
            "description": "Not Found - Friend group or user with the given ID does not exist",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            }
          },
          "500": {
            "description": "Internal Server Error",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            }
          }
        }
      }
    },
    "/users/delete-friend-group/": {
      "delete": {
        "tags": [
          "FriendGroup"
        ],
        "summary": "Delete a friend group. Please note that only the admin of a friend group can delete it.",
        "operationId": "deleteFriendGroup",
        "security": [
          {
            "bearerAuth": []
          }
        ],
        "parameters": [
          {
            "name": "group_id",
            "in": "query",
            "required": true,
            "description": "The unique identifier of the group to be deleted",
            "schema": {
              "type": "string"
            }
          }
        ],
        "responses": {
          "204": {
            "description": "No Content - Friend group deleted successfully"
          },
          "400": {
            "description": "Bad Request - Missing or invalid group ID",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            }
          },
          "401": {
            "description": "Unauthorized - If the user is not admin, he/she is not authorized to delete this friend group",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            }
          },
          "404": {
            "description": "Not Found - Friend group or user with the given ID does not exist",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            }
          },
          "500": {
            "description": "Internal Server Error",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            }
          }
        }
      }
    },
    "/users/get-all-friend-groups-of-user/": {
      "get": {
        "tags": [
          "FriendGroup"
        ],
        "summary": "Get all friend groups of a user",
        "operationId": "getAllFriendGroupsOfUser",
        "security": [
          {
            "bearerAuth": []
          }
        ],
        "parameters": [
          {
            "name": "extended",
            "in": "query",
            "description": "Flag to determine if extended information is required. If provided with any value(even dummy value works), the response with the member field provided in 200 status code will be returned. If not provided, members field will disappear and remaining fields will be returned Both are represented in the 200 response example, first JSON object in it is when extended flag is not provided, second one is when extended flag is provided.",
            "required": false,
            "schema": {
              "type": "string"
            }
          }
        ],
        "responses": {
          "200": {
            "description": "List of all friend groups of the user",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object",
                  "properties": {
                    "friend_groups": {
                      "type": "array",
                      "items": {
                        "oneOf": [
                          {
                            "$ref": "#/components/schemas/FriendGroupSimple"
                          },
                          {
                            "$ref": "#/components/schemas/FriendGroupExtended"
                          }
                        ]
                      }
                    }
                  }
                }
              }
            }
          },
          "404": {
            "description": "Not Found - User does not exist",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            }
          },
          "500": {
            "description": "Internal Server Error",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            }
          }
        }
      }
    },
    "/users/get-playlists-of-group/": {
      "get": {
        "tags": [
          "FriendGroup"
        ],
        "summary": "Get playlists of a friend group.",
        "operationId": "getPlaylistsOfGroup",
        "security": [
          {
            "bearerAuth": []
          }
        ],
        "parameters": [
          {
            "name": "group_id",
            "in": "query",
            "description": "The ID of the friend group whose playlists are being retrieved",
            "required": true,
            "schema": {
              "type": "integer"
            }
          }
        ],
        "responses": {
          "200": {
            "description": "List of playlists retrieved successfully",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object",
                  "properties": {
                    "items": {
                      "type": "array",
                      "items": {
                        "type": "object",
                        "properties": {
                          "id": {
                            "type": "integer"
                          },
                          "name": {
                            "type": "string"
                          },
                          "description": {
                            "type": "string"
                          },
                          "song_imgs": {
                            "type": "array",
                            "items": {
                              "type": "string",
                              "format": "url"
                            }
                          },
                          "user_id": {
                            "type": "integer",
                            "nullable": true
                          },
                          "friend_group_id": {
                            "type": "integer",
                            "nullable": true
                          }
                        }
                      }
                    },
                    "count": {
                      "type": "integer"
                    }
                  }
                }
              }
            }
          },
          "400": {
            "description": "Bad Request - Missing or invalid group ID",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            }
          },
          "404": {
            "description": "Not Found - Friend group does not exist",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            }
          },
          "500": {
            "description": "Internal Server Error",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            }
          }
        }
      }
    },
    "/users/create-empty-playlist-in-group/": {
      "post": {
        "tags": [
          "FriendGroup"
        ],
        "summary": "Create an empty playlist in a friend group. To create a playlist, the user that issues this request must be a member of the group for which the id is provided in the request body.",
        "operationId": "createEmptyPlaylistInGroup",
        "security": [
          {
            "bearerAuth": []
          }
        ],
        "requestBody": {
          "description": "Data needed to create a new empty playlist in a friend group. playlist_description is NOT required.",
          "required": true,
          "content": {
            "application/json": {
              "schema": {
                "type": "object",
                "properties": {
                  "playlist_name": {
                    "type": "string",
                    "description": "The name of the new playlist"
                  },
                  "playlist_description": {
                    "type": "string",
                    "description": "A brief description of the new playlist",
                    "default": ""
                  },
                  "group_id": {
                    "type": "integer",
                    "description": "The ID of the friend group where the playlist will be created"
                  }
                },
                "required": [
                  "playlist_name",
                  "group_id"
                ]
              }
            }
          }
        },
        "responses": {
          "201": {
            "description": "Playlist created successfully",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object",
                  "properties": {
                    "message": {
                      "type": "string"
                    },
                    "playlist": {
                      "$ref": "#/components/schemas/Playlist"
                    }
                  },
                  "example": {
                    "message": "Playlist created successfully",
                    "playlist": {
                      "id": 123,
                      "name": "Chill Vibes",
                      "description": "A playlist for relaxing evenings",
                      "songs": [],
                      "user_id": null,
                      "friend_group_id": 789
                    }
                  }
                }
              }
            }
          },
          "400": {
            "description": "Bad Request - Missing or invalid parameters",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            }
          },
          "401": {
            "description": "Unauthorized - User not authorized to create a playlist in this group (user is not a member of the group, so he/she cannot create a playlist in the group.)",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            }
          },
          "404": {
            "description": "Not Found - Either the user or friend group does not exist",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            }
          },
          "500": {
            "description": "Internal Server Error",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            }
          }
        }
      }
    },
    "/users/delete-playlist-from-group/": {
      "delete": {
        "tags": [
          "FriendGroup"
        ],
        "summary": "Delete a playlist from a friend group.To delete a playlist, the user that issues this request must be a member of the group for which the id is provided in the request body.",
        "operationId": "deletePlaylistFromGroup",
        "security": [
          {
            "bearerAuth": []
          }
        ],
        "parameters": [
          {
            "name": "playlist_id",
            "in": "query",
            "required": true,
            "description": "The unique identifier of the playlist to be deleted",
            "schema": {
              "type": "string"
            }
          }
        ],
        "responses": {
          "204": {
            "description": "No Content - Playlist deleted successfully"
          },
          "400": {
            "description": "Bad Request - Missing or invalid playlist ID",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            }
          },
          "401": {
            "description": "Unauthorized - User not authorized to delete this playlist (user is not a member of the group, so he/she cannot delete a playlist in the group.)",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            }
          },
          "404": {
            "description": "Not Found - Playlist, user, or friend group does not exist",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            }
          },
          "500": {
            "description": "Internal Server Error",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            }
          }
        }
      }
    },
    "/users/get-suggestions/": {
      "get": {
        "tags": [
          "User",
          "Recommendation",
          "Friend"
        ],
        "summary": "Get a list of the suggestions made to an user.",
        "responses": {
          "200": {
            "description": "Successful response with a list of notifications.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object",
                  "properties": {
                    "items": {
                      "type": "array",
                      "items": {
                        "type": "object",
                        "properties": {
                          "id": {
                            "type": "string",
                            "maxLength": 200
                          },
                          "suggester_name": {
                            "type": "string",
                            "maxLength": 200
                          },
                          "suggester_img_url": {
                            "type": "string",
                            "format": "url"
                          },
                          "song_id": {
                            "type": "string",
                            "maxLength": 300
                          },
                          "song_img_url": {
                            "type": "string",
                            "format": "url",
                            "maxLength": 300
                          },
                          "song_name": {
                            "type": "string",
                            "maxLength": 300
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          },
          "400": {
            "description": "Invalid method, Missing parameters."
          },
          "404": {
            "description": "User not found."
          },
          "500": {
            "description": "Internal server error."
          }
        },
        "security": [
          {
            "bearerAuth": []
          }
        ]
      }
    },
    "/users/get-suggestion-count/": {
      "get": {
        "tags": [
          "User",
          "Recommendation",
          "Friend"
        ],
        "summary": "Get the number of the suggestions made to an user that is unread by the user.",
        "responses": {
          "200": {
            "description": "Successful response with a list of notifications.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object",
                  "properties": {
                    "count": {
                      "type": "integer"
                    }
                  }
                }
              }
            }
          },
          "400": {
            "description": "Invalid method, Missing parameters."
          },
          "404": {
            "description": "User not found."
          },
          "500": {
            "description": "Internal server error."
          }
        },
        "security": [
          {
            "bearerAuth": []
          }
        ]
      }
    },
    "/users/set-suggestion-seen/": {
      "put": {
        "tags": [
          "User",
          "Recommendation",
          "Friend"
        ],
        "summary": "Mark a list of the suggestions made to an user as seen by the user.",
        "responses": {
          "200": {
            "description": "Successful response with a message.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object",
                  "properties": {
                    "message": {
                      "type": "string",
                      "example": "Suggestions are marked as seen"
                    }
                  }
                }
              }
            }
          },
          "400": {
            "description": "Invalid method, Missing parameters."
          },
          "404": {
            "description": "User not found."
          },
          "500": {
            "description": "Internal server error."
          }
        },
        "security": [
          {
            "bearerAuth": []
          }
        ]
      }
    },
    "/users/delete-suggestion/": {
      "delete": {
        "tags": [
          "User",
          "Recommendation",
          "Friend"
        ],
        "summary": "Delete a suggestion that was made to a user.",
        "parameters": [
          {
            "name": "suggestion_id",
            "in": "query",
            "description": "The ID of the suggestion notification",
            "required": true,
            "schema": {
              "type": "string"
            }
          }
        ],
        "responses": {
          "200": {
            "description": "Successful response with a message.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object",
                  "properties": {
                    "message": {
                      "type": "string",
                      "example": "Suggestion deleted successfully"
                    }
                  }
                }
              }
            }
          },
          "400": {
            "description": "Invalid method, Missing parameters."
          },
          "404": {
            "description": "Suggestion not found."
          },
          "500": {
            "description": "Internal server error."
          }
        },
        "security": [
          {
            "bearerAuth": []
          }
        ]
      }
    }
  },
  "components": {
    "schemas": {
      "User": {
        "type": "object",
        "properties": {
          "id": {
            "type": "string",
            "maxLength": 200
          },
          "username": {
            "type": "string",
            "maxLength": 150,
            "uniqueItems": true
          },
          "email": {
            "type": "string",
            "format": "email",
            "uniqueItems": true
          },
          "img_url": {
            "type": "string",
            "format": "url",
            "maxLength": 300,
            "nullable": true
          },
          "date_joined": {
            "type": "string",
            "format": "date-time"
          },
          "last_login": {
            "type": "string",
            "format": "date-time"
          },
          "user_preferences": {
            "$ref": "#/components/schemas/UserPreferences"
          },
          "friends": {
            "type": "array",
            "items": {
              "$ref": "#/components/schemas/User"
            }
          }
        }
      },
      "UserPreferences": {
        "type": "object",
        "properties": {
          "id": {
            "type": "integer"
          },
          "user": {
            "$ref": "#/components/schemas/User"
          },
          "data_processing_consent": {
            "type": "boolean",
            "default": true
          },
          "data_sharing_consent": {
            "type": "boolean",
            "default": true
          }
        }
      },
      "Friend": {
        "type": "object",
        "properties": {
          "user": {
            "$ref": "#/components/schemas/User"
          },
          "friend": {
            "$ref": "#/components/schemas/User"
          }
        },
        "uniqueItems": true
      },
      "FriendGroup": {
        "type": "object",
        "properties": {
          "name": {
            "type": "string",
            "maxLength": 200
          },
          "description": {
            "type": "string",
            "maxLength": 500,
            "nullable": true
          },
          "img_url": {
            "type": "string",
            "format": "url",
            "maxLength": 300,
            "nullable": true
          },
          "friends": {
            "type": "array",
            "items": {
              "$ref": "#/components/schemas/User"
            }
          }
        }
      },
      "FriendRequest": {
        "type": "object",
        "properties": {
          "sender": {
            "$ref": "#/components/schemas/User"
          },
          "receiver": {
            "$ref": "#/components/schemas/User"
          },
          "status": {
            "type": "string",
            "enum": [
              "A",
              "R",
              "P"
            ],
            "default": "P",
            "description": "Friend request status: Accepted (A), Rejected (R), Pending (P)"
          }
        },
        "uniqueItems": true
      },
      "Song": {
        "type": "object",
        "properties": {
          "id": {
            "type": "string",
            "maxLength": 200
          },
          "name": {
            "type": "string",
            "maxLength": 200
          },
          "genres": {
            "type": "array",
            "items": {
              "$ref": "#/components/schemas/Genre"
            }
          },
          "artists": {
            "type": "array",
            "items": {
              "$ref": "#/components/schemas/Artist"
            }
          },
          "albums": {
            "type": "array",
            "items": {
              "$ref": "#/components/schemas/Album"
            }
          },
          "instruments": {
            "type": "array",
            "items": {
              "$ref": "#/components/schemas/Instrument"
            }
          },
          "release_year": {
            "type": "integer",
            "format": "int32",
            "nullable": true
          },
          "duration": {
            "type": "string",
            "format": "duration"
          },
          "tempo": {
            "type": "string",
            "enum": [
              "S",
              "M",
              "F"
            ]
          },
          "mood": {
            "type": "string",
            "enum": [
              "H",
              "SA",
              "E",
              "R"
            ]
          },
          "recorded_environment": {
            "type": "string",
            "enum": [
              "I",
              "O",
              "S",
              "L"
            ]
          },
          "replay_count": {
            "type": "integer",
            "format": "int32",
            "default": 0
          },
          "version": {
            "type": "string",
            "maxLength": 50,
            "nullable": true
          },
          "img_url": {
            "type": "string",
            "format": "url",
            "maxLength": 300,
            "nullable": true
          }
        }
      },
      "Playlist": {
        "type": "object",
        "properties": {
          "id": {
            "type": "integer",
            "format": "int64",
            "description": "Primary key identifier for the Playlist"
          },
          "name": {
            "type": "string",
            "maxLength": 100,
            "description": "Name of the playlist"
          },
          "description": {
            "type": "string",
            "description": "Description of the playlist"
          },
          "songs": {
            "type": "array",
            "description": "A list of songs in the playlist.",
            "items": {
              "$ref": "#/components/schemas/SongMinimum"
            }
          },
          "user_id": {
            "type": "integer",
            "format": "int64",
            "description": "User ID of the playlist owner"
          },
          "friend_group_id": {
            "type": "integer",
            "format": "int64",
            "nullable": true,
            "description": "Friend group ID associated with the playlist"
          }
        },
        "required": [
          "id",
          "name"
        ]
      },
      "UserSongRating": {
        "type": "object",
        "properties": {
          "id": {
            "type": "integer"
          },
          "user": {
            "$ref": "#/components/schemas/User"
          },
          "song": {
            "$ref": "#/components/schemas/Song"
          },
          "rating": {
            "type": "number",
            "format": "decimal"
          }
        }
      },
      "Genre": {
        "type": "object",
        "properties": {
          "id": {
            "type": "integer"
          },
          "name": {
            "type": "string",
            "maxLength": 100
          },
          "img_url": {
            "type": "string",
            "format": "url",
            "maxLength": 300,
            "nullable": true
          }
        }
      },
      "GenreSong": {
        "type": "object",
        "properties": {
          "genre": {
            "$ref": "#/components/schemas/Genre"
          },
          "song": {
            "$ref": "#/components/schemas/Song"
          }
        },
        "uniqueItems": true
      },
      "Album": {
        "type": "object",
        "properties": {
          "id": {
            "type": "string",
            "maxLength": 300
          },
          "name": {
            "type": "string",
            "maxLength": 200
          },
          "release_year": {
            "type": "integer",
            "format": "int32",
            "nullable": true
          },
          "img_url": {
            "type": "string",
            "format": "url",
            "maxLength": 300,
            "nullable": true
          }
        }
      },
      "AlbumSong": {
        "type": "object",
        "properties": {
          "album": {
            "$ref": "#/components/schemas/Album"
          },
          "song": {
            "$ref": "#/components/schemas/Song"
          }
        },
        "uniqueItems": true
      },
      "Artist": {
        "type": "object",
        "properties": {
          "id": {
            "type": "string",
            "maxLength": 300
          },
          "name": {
            "type": "string",
            "maxLength": 200
          },
          "bio": {
            "type": "string"
          },
          "img_url": {
            "type": "string",
            "format": "url",
            "maxLength": 300,
            "nullable": true
          }
        }
      },
      "ArtistSong": {
        "type": "object",
        "properties": {
          "song": {
            "$ref": "#/components/schemas/Song"
          },
          "artist": {
            "$ref": "#/components/schemas/Artist"
          }
        },
        "uniqueItems": true
      },
      "Instrument": {
        "type": "object",
        "properties": {
          "id": {
            "type": "integer"
          },
          "type": {
            "type": "string",
            "maxLength": 100
          },
          "name": {
            "type": "string",
            "maxLength": 100
          }
        }
      },
      "InstrumentSong": {
        "type": "object",
        "properties": {
          "instrument": {
            "$ref": "#/components/schemas/Instrument"
          },
          "song": {
            "$ref": "#/components/schemas/Song"
          }
        },
        "uniqueItems": true
      },
      "FriendGroupSimple": {
        "type": "object",
        "properties": {
          "id": {
            "type": "integer"
          },
          "name": {
            "type": "string"
          },
          "description": {
            "type": "string"
          },
          "img_url": {
            "type": "string",
            "format": "uri"
          },
          "admin": {
            "type": "string"
          }
        }
      },
      "FriendGroupExtended": {
        "allOf": [
          {
            "$ref": "#/components/schemas/FriendGroupSimple"
          },
          {
            "type": "object",
            "properties": {
              "members": {
                "type": "array",
                "items": {
                  "type": "object",
                  "properties": {
                    "id": {
                      "type": "integer"
                    },
                    "username": {
                      "type": "string"
                    },
                    "img_url": {
                      "type": "string",
                      "format": "uri"
                    }
                  }
                }
              }
            }
          }
        ]
      },
      "Error": {
        "type": "object",
        "properties": {
          "error": {
            "type": "string"
          }
        }
      },
      "SongMinimum": {
        "type": "object",
        "properties": {
          "id": {
            "type": "integer",
            "description": "The unique identifier of the song."
          },
          "name": {
            "type": "string",
            "description": "The name of the song."
          },
          "release_year": {
            "type": "integer",
            "description": "The release year of the song."
          },
          "img_url": {
            "type": "string",
            "format": "uri",
            "description": "The URL of the song's image."
          },
          "main_artist": {
            "type": "string",
            "nullable": true,
            "description": "The name of the main artist of the song."
          }
        }
      }
    },
    "requestBodies": {
      "Pet": {
        "description": "Pet object that needs to be added to the store",
        "content": {
          "application/json": {},
          "application/xml": {}
        }
      }
    },
    "securitySchemes": {
      "bearerAuth": {
        "type": "http",
        "scheme": "bearer",
        "bearerFormat": "JWT"
      }
    }
  }
}