Merge pull request #97 from go-park-mail-ru/NM-95

Nm 95

internal/db/postgres/migrations/20241213224512_create_favorite_artist.sql

@@ -0,0 +1,37 @@
+-- +goose Up
+-- +goose StatementBegin
+CREATE TABLE IF NOT EXISTS "favorite_artist" (
+  id INT PRIMARY KEY GENERATED ALWAYS AS IDENTITY,
+  user_id UUID REFERENCES "user" (id) ON DELETE CASCADE,
+  artist_id INT NOT NULL REFERENCES "artist" (id) ON DELETE CASCADE,
+  created_at TIMESTAMPTZ DEFAULT NOW(),
+  updated_at TIMESTAMPTZ DEFAULT NOW()
+);
+
+CREATE TABLE IF NOT EXISTS "favorite_album" (
+  id INT PRIMARY KEY GENERATED ALWAYS AS IDENTITY,
+  user_id UUID REFERENCES "user" (id) ON DELETE CASCADE,
+  album_id INT NOT NULL REFERENCES "album" (id) ON DELETE CASCADE,
+  created_at TIMESTAMPTZ DEFAULT NOW(),
+  updated_at TIMESTAMPTZ DEFAULT NOW()
+);
+
+CREATE TABLE IF NOT EXISTS "favorite_playlist" (
+  id INT PRIMARY KEY GENERATED ALWAYS AS IDENTITY,
+  user_id UUID REFERENCES "user" (id) ON DELETE CASCADE,
+  playlist_id INT NOT NULL REFERENCES "playlist" (id) ON DELETE CASCADE,
+  created_at TIMESTAMPTZ DEFAULT NOW(),
+  updated_at TIMESTAMPTZ DEFAULT NOW()
+);
+
+CREATE UNIQUE INDEX favorite_artist_unique ON favorite_artist (user_id, artist_id);
+CREATE UNIQUE INDEX favorite_album_unique ON favorite_album (user_id, album_id);
+CREATE UNIQUE INDEX favorite_playlist_unique ON favorite_playlist (user_id, playlist_id);
+-- +goose StatementEnd
+
+-- +goose Down
+-- +goose StatementBegin
+DROP TABLE IF EXISTS "favorite_playlist" CASCADE;
+DROP TABLE IF EXISTS "favorite_album" CASCADE;
+DROP TABLE IF EXISTS "favorite_artist" CASCADE;
+-- +goose StatementEnd

microservices/album/delivery.go

@@ -7,4 +7,8 @@ type Handlers interface {
 	ViewAlbum(response http.ResponseWriter, request *http.Request)
 	GetAll(response http.ResponseWriter, request *http.Request)
 	GetAllByArtistID(response http.ResponseWriter, request *http.Request)
+	AddFavoriteAlbum(response http.ResponseWriter, request *http.Request)
+	DeleteFavoriteAlbum(response http.ResponseWriter, request *http.Request)
+	IsFavoriteAlbum(response http.ResponseWriter, request *http.Request)
+	GetFavoriteAlbums(response http.ResponseWriter, request *http.Request)
 }

microservices/album/delivery/http/handlers.go

@@ -6,6 +6,8 @@ import (
 	"net/http"
 	"strconv"
 
+	uuid "github.com/google/uuid"
+
 	"github.com/go-park-mail-ru/2024_2_NovaCode/internal/utils"
 	"github.com/go-park-mail-ru/2024_2_NovaCode/microservices/album"
 	"github.com/go-park-mail-ru/2024_2_NovaCode/pkg/logger"
@@ -165,3 +167,118 @@ func (handlers *albumHandlers) GetAllByArtistID(response http.ResponseWriter, re
 
 	response.WriteHeader(http.StatusOK)
 }
+
+func (handlers *albumHandlers) AddFavoriteAlbum(response http.ResponseWriter, request *http.Request) {
+	requestID := request.Context().Value(utils.RequestIDKey{})
+	vars := mux.Vars(request)
+	albumID, err := strconv.ParseUint(vars["albumID"], 10, 64)
+	if err != nil {
+		handlers.logger.Error(fmt.Sprintf("Invalid album ID: %v", err), requestID)
+		utils.JSONError(response, http.StatusBadRequest, fmt.Sprintf("Invalid album ID: %v", err))
+		return
+	}
+
+	userID, ok := request.Context().Value(utils.UserIDKey{}).(uuid.UUID)
+	if !ok {
+		handlers.logger.Error("User id not found in context", requestID)
+		utils.JSONError(response, http.StatusBadRequest, "User id not found")
+		return
+	}
+
+	if err := handlers.usecase.AddFavoriteAlbum(request.Context(), userID, albumID); err != nil {
+		handlers.logger.Error("Can't add album to favorite", requestID)
+		utils.JSONError(response, http.StatusInternalServerError, "Can't add album to favorite")
+		return
+	}
+
+	response.WriteHeader(http.StatusOK)
+}
+
+func (handlers *albumHandlers) DeleteFavoriteAlbum(response http.ResponseWriter, request *http.Request) {
+	requestID := request.Context().Value(utils.RequestIDKey{})
+	vars := mux.Vars(request)
+	albumID, err := strconv.ParseUint(vars["albumID"], 10, 64)
+	if err != nil {
+		handlers.logger.Error(fmt.Sprintf("Invalid album ID: %v", err), requestID)
+		utils.JSONError(response, http.StatusBadRequest, fmt.Sprintf("Invalid album ID: %v", err))
+		return
+	}
+
+	userID, ok := request.Context().Value(utils.UserIDKey{}).(uuid.UUID)
+	if !ok {
+		handlers.logger.Error("User id not found in context", requestID)
+		utils.JSONError(response, http.StatusBadRequest, "User id not found")
+		return
+	}
+
+	if err := handlers.usecase.DeleteFavoriteAlbum(request.Context(), userID, albumID); err != nil {
+		handlers.logger.Error("Can't delete album from favorite", requestID)
+		utils.JSONError(response, http.StatusInternalServerError, "Can't delete album from favorite")
+		return
+	}
+
+	response.WriteHeader(http.StatusOK)
+}
+
+func (handlers *albumHandlers) IsFavoriteAlbum(response http.ResponseWriter, request *http.Request) {
+	requestID := request.Context().Value(utils.RequestIDKey{})
+	vars := mux.Vars(request)
+	albumID, err := strconv.ParseUint(vars["albumID"], 10, 64)
+	if err != nil {
+		handlers.logger.Error(fmt.Sprintf("Invalid album ID: %v", err), requestID)
+		utils.JSONError(response, http.StatusBadRequest, fmt.Sprintf("Invalid album ID: %v", err))
+		return
+	}
+
+	userID, ok := request.Context().Value(utils.UserIDKey{}).(uuid.UUID)
+	if !ok {
+		handlers.logger.Error("User id not found in context", requestID)
+		utils.JSONError(response, http.StatusBadRequest, "User id not found")
+		return
+	}
+
+	exists, err := handlers.usecase.IsFavoriteAlbum(request.Context(), userID, albumID)
+	if err != nil {
+		handlers.logger.Error("Can't check is album in favorite", requestID)
+		utils.JSONError(response, http.StatusInternalServerError, "Can't check is album in favorite")
+		return
+	}
+
+	response.Header().Set("Content-Type", "application/json")
+	if err := json.NewEncoder(response).Encode(map[string]bool{"exists": exists}); err != nil {
+		handlers.logger.Error(fmt.Sprintf("Failed to encode: %v", err), requestID)
+		utils.JSONError(response, http.StatusInternalServerError, fmt.Sprintf("Failed to encode: %v", err))
+		return
+	}
+
+	response.WriteHeader(http.StatusOK)
+}
+
+func (handlers *albumHandlers) GetFavoriteAlbums(response http.ResponseWriter, request *http.Request) {
+	requestID := request.Context().Value(utils.RequestIDKey{})
+	userID, ok := request.Context().Value(utils.UserIDKey{}).(uuid.UUID)
+	if !ok {
+		handlers.logger.Error("User id not found in context", requestID)
+		utils.JSONError(response, http.StatusBadRequest, "User id not found")
+		return
+	}
+
+	albums, err := handlers.usecase.GetFavoriteAlbums(request.Context(), userID)
+	if err != nil {
+		handlers.logger.Error(fmt.Sprintf("Failed to get favorite albums: %v", err), requestID)
+		utils.JSONError(response, http.StatusInternalServerError, fmt.Sprintf("Failed to get favorite albums: %v", err))
+		return
+	} else if len(albums) == 0 {
+		utils.JSONError(response, http.StatusNotFound, "No favorite albums were found")
+		return
+	}
+
+	response.Header().Set("Content-Type", "application/json")
+	if err := json.NewEncoder(response).Encode(albums); err != nil {
+		handlers.logger.Error(fmt.Sprintf("Failed to encode albums: %v", err), requestID)
+		utils.JSONError(response, http.StatusInternalServerError, fmt.Sprintf("Failed to encode albums: %v", err))
+		return
+	}
+
+	response.WriteHeader(http.StatusOK)
+}