[백동열] Good-Night-2nd-Hackathon-Backend 제출

api/handler/movie_handler.go

@@ -0,0 +1,104 @@
+package handler
+
+import (
+	"backend/models"
+	"backend/repository"
+	"backend/services"
+	"encoding/json"
+	"fmt"
+	"github.com/gorilla/mux"
+	"net/http"
+	"strconv"
+)
+
+var movieService *services.MovieService
+
+func InitializeMovieHandler(repo repository.MovieRepository) {
+	movieService = services.NewMovieService(repo)
+}
+
+func CreateMovieHandler(w http.ResponseWriter, r *http.Request) {
+	fmt.Println("CreateMovieHandler called")
+
+	if movieService == nil {
+		http.Error(w, "Server error", http.StatusInternalServerError)
+		return
+	}
+
+	movie := &models.Movie{}
+
+	if err := json.NewDecoder(r.Body).Decode(movie); err != nil {
+		http.Error(w, err.Error(), http.StatusBadRequest)
+		return
+	}
+
+	if err := movieService.CreateMovie(movie); err != nil {
+		fmt.Println("Error creating movie:", err)
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+	w.Header().Set("Content-Type", "application/json")
+	json.NewEncoder(w).Encode(movie)
+}
+
+func GetMovieByIDHandler(w http.ResponseWriter, r *http.Request) {
+	vars := mux.Vars(r)
+	id, err := strconv.Atoi(vars["id"])
+	if err != nil {
+		http.Error(w, "Invalid movie ID", http.StatusBadRequest)
+		return
+	}
+
+	movie, err := movieService.GetByID(id)
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+	json.NewEncoder(w).Encode(movie)
+}
+
+func GetAllMoviesHandler(w http.ResponseWriter, r *http.Request) {
+	movies, err := movieService.GetAll()
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+	json.NewEncoder(w).Encode(movies)
+}
+
+func UpdateMovieHandler(w http.ResponseWriter, r *http.Request) {
+	movie := &models.Movie{}
+	if err := json.NewDecoder(r.Body).Decode(movie); err != nil {
+		http.Error(w, err.Error(), http.StatusBadRequest)
+		return
+	}
+
+	if err := movieService.UpdateMovie(movie); err != nil {
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+	json.NewEncoder(w).Encode(movie)
+}
+
+func DeleteMovieHandler(w http.ResponseWriter, r *http.Request) {
+	vars := mux.Vars(r)
+	id, err := strconv.Atoi(vars["id"])
+	if err != nil {
+		http.Error(w, "Invalid movie ID", http.StatusBadRequest)
+		return
+	}
+
+	if err := movieService.DeleteMovie(id); err != nil {
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+
+	w.WriteHeader(http.StatusOK)
+	w.Write([]byte("Movie deleted successfully"))
+}

api/handler/review_handler.go

@@ -0,0 +1,68 @@
+package handler
+
+import (
+	"backend/models"
+	"backend/repository"
+	"backend/services"
+	"encoding/json"
+	"fmt"
+	"github.com/gorilla/mux"
+	"net/http"
+	"strconv"
+)
+
+var reviewService *services.ReviewService
+
+func InitializeReviewHandler(repo repository.ReviewRepository) {
+	reviewService = services.NewReviewService(repo)
+}
+
+func CreateReviewHandler(w http.ResponseWriter, r *http.Request) {
+	fmt.Println("CreateReviewHandler called")
+
+	if reviewService == nil {
+		http.Error(w, "Server error", http.StatusInternalServerError)
+		return
+	}
+
+	review := &models.Review{}
+
+	if err := json.NewDecoder(r.Body).Decode(review); err != nil {
+		http.Error(w, err.Error(), http.StatusBadRequest)
+		return
+	}
+
+	if err := reviewService.CreateReview(review); err != nil {
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+	json.NewEncoder(w).Encode(review)
+}
+
+func GetAllReviewByMovieIdHandler(w http.ResponseWriter, r *http.Request) {
+	fmt.Println("GetAllByMovieIdHandler called")
+
+	vars := mux.Vars(r)
+	movieIDStr, ok := vars["id"]
+	if !ok {
+		http.Error(w, "Movie ID is required", http.StatusBadRequest)
+		return
+	}
+
+	movieId, err := strconv.Atoi(movieIDStr)
+	if err != nil {
+		http.Error(w, "Invalid Movie ID", http.StatusBadRequest)
+		return
+	}
+
+	reviews, err := reviewService.GetAllByMovieId(movieId)
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+	json.NewEncoder(w).Encode(reviews)
+}

go.mod

@@ -0,0 +1,5 @@
+module backend
+
+go 1.21.0
+
+require github.com/gorilla/mux v1.8.0

go.sum

@@ -0,0 +1,2 @@
+github.com/gorilla/mux v1.8.0 h1:i40aqfkR1h2SlN9hojwV5ZA91wcXFOvkdNIeFDP5koI=
+github.com/gorilla/mux v1.8.0/go.mod h1:DVbg23sWSpFRCP0SfiEN6jmj59UnW/n46BH5rLB71So=

main.go

@@ -0,0 +1,38 @@
+package main
+
+import (
+	"backend/api/handler"
+	"backend/repository"
+	"github.com/gorilla/mux"
+	"net/http"
+)
+
+func main() {
+	// MovieRepository의 실제 구현체를 초기화한다. (예: MySQL을 사용하는 경우)
+	movieRepo := repository.NewInMemoryMovieRepository()
+	reviewRepo := repository.NewInMemoryReviewRepository()
+
+	// 핸들러를 초기화한다.
+	handler.InitializeMovieHandler(movieRepo)
+	handler.InitializeReviewHandler(reviewRepo)
+
+	// Method 처리를 위해 라우터를 설정한다
+	r := mux.NewRouter()
+
+	// movies 핸들러를 서버에 바인딩한다.
+	r.HandleFunc("/movies", handler.CreateMovieHandler).Methods("POST")
+	r.HandleFunc("/movies/{id:[0-9]+}", handler.GetMovieByIDHandler).Methods("GET")
+	r.HandleFunc("/movies", handler.GetAllMoviesHandler).Methods("GET")
+	r.HandleFunc("/movies", handler.UpdateMovieHandler).Methods("PUT")
+	r.HandleFunc("/movies/{id:[0-9]+}", handler.DeleteMovieHandler).Methods("DELETE")
+
+	// review 핸들러를 서버에 바인딩한다.
+	r.HandleFunc("/reviews", handler.CreateReviewHandler).Methods("POST")
+	r.HandleFunc("/reviews/{id:[0-9]+}", handler.GetAllReviewByMovieIdHandler).Methods("GET")
+
+	// 기본값 핸들링
+	http.Handle("/", r)
+
+	// 서버 시작
+	http.ListenAndServe(":8080", nil)
+}

models/movie.go

@@ -0,0 +1,15 @@
+package models
+
+import "time"
+
+type Movie struct {
+	ID           int
+	Title        string
+	Genre        string
+	ReleaseDate  time.Time
+	EndDate      time.Time
+	IsNowShowing bool
+	CreatedAt    time.Time
+	UpdatedAt    time.Time
+	IsDeleted    bool
+}

models/review.go

@@ -0,0 +1,11 @@
+package models
+
+import "time"
+
+type Review struct {
+	ID        int
+	MovieID   int
+	Rating    float64
+	Content   string
+	CreatedAt time.Time
+}

repository/movie_repository.go

@@ -0,0 +1,13 @@
+package repository
+
+import "backend/models"
+
+type MovieRepository interface {
+	Create(movie *models.Movie) error
+	Delete(id int) error
+	Update(movie *models.Movie) error
+	GetByID(id int) (*models.Movie, error)
+	GetAll() ([]*models.Movie, error)
+}
+
+var _ MovieRepository = &InMemoryMovieRepository{}

repository/movie_repository_in_memory.go

@@ -0,0 +1,58 @@
+package repository
+
+import (
+	"backend/models"
+	"errors"
+)
+
+type InMemoryMovieRepository struct {
+	movies []*models.Movie
+	nextID int
+}
+
+func NewInMemoryMovieRepository() MovieRepository {
+	return &InMemoryMovieRepository{
+		movies: make([]*models.Movie, 0),
+		nextID: 1,
+	}
+}
+
+func (repo *InMemoryMovieRepository) Create(movie *models.Movie) error {
+	movie.ID = repo.nextID
+	repo.movies = append(repo.movies, movie)
+	repo.nextID++
+	return nil
+}
+
+func (repo *InMemoryMovieRepository) Delete(id int) error {
+	for index, movie := range repo.movies {
+		if movie.ID == id {
+			repo.movies = append(repo.movies[:index], repo.movies[index+1:]...)
+			return nil
+		}
+	}
+	return errors.New("movie not found")
+}
+
+func (repo *InMemoryMovieRepository) Update(movie *models.Movie) error {
+	for index, m := range repo.movies {
+		if m.ID == movie.ID {
+			repo.movies[index] = movie
+			return nil
+		}
+	}
+	return errors.New("movie not found")
+}
+
+func (repo *InMemoryMovieRepository) GetByID(id int) (*models.Movie, error) {
+	for _, movie := range repo.movies {
+		if movie.ID == id {
+			return movie, nil
+		}
+	}
+	return nil, errors.New("movie not found")
+}
+
+func (repo InMemoryMovieRepository) GetAll() ([]*models.Movie, error) {
+	return repo.movies, nil
+}

repository/review_repository.go

@@ -0,0 +1,10 @@
+package repository
+
+import "backend/models"
+
+type ReviewRepository interface {
+	CreateReview(review *models.Review) error
+	GetAllByMovieID(movieID int) ([]*models.Review, error)
+}
+
+var _ ReviewRepository = &InMemoryReviewRepository{}

repository/review_repository_in_memory.go

@@ -0,0 +1,46 @@
+package repository
+
+import (
+	"backend/models"
+	"errors"
+	"sync"
+)
+
+type InMemoryReviewRepository struct {
+	reviews []*models.Review
+	mu      sync.RWMutex
+	nextID  int
+}
+
+func NewInMemoryReviewRepository() *InMemoryReviewRepository {
+	return &InMemoryReviewRepository{
+		reviews: make([]*models.Review, 0),
+		nextID:  1,
+	}
+}
+
+func (repo *InMemoryReviewRepository) CreateReview(review *models.Review) error {
+	repo.mu.Lock()
+	defer repo.mu.Unlock()
+
+	review.ID = repo.nextID
+	repo.reviews = append(repo.reviews, review)
+	repo.nextID++
+	return nil
+}
+
+func (repo *InMemoryReviewRepository) GetAllByMovieID(movieID int) ([]*models.Review, error) {
+	repo.mu.RLock()
+	defer repo.mu.RUnlock()
+
+	var movieReviews []*models.Review
+	for _, review := range repo.reviews {
+		if review.MovieID == movieID {
+			movieReviews = append(movieReviews, review)
+		}
+	}
+	if len(movieReviews) == 0 {
+		return nil, errors.New("no review found for the movie")
+	}
+	return movieReviews, nil
+}