lyrics

new-song.go (8103B)

---

 package server
 
 import (
 	"context"
 	"errors"
 	"fmt"
 	"lyrics/internal/db"
 	"lyrics/internal/domain"
 	"lyrics/internal/server/htmx"
 	newsong "lyrics/internal/server/ui/views/new-song"
 	"net/http"
 	"time"
 )
 
 type NewSongForm struct {
 	ArtistID               []domain.ArtistID    `schema:"artist-id"`
 	Title                  string               `schema:"song-title"`
 	LatinTitle             string               `schema:"latin-title"`
 	ReleaseID              []domain.ReleaseID   `schema:"release-id"`
 	Genres                 []string             `schema:"genres"`
 	Lyrics                 string               `schema:"lyrics"`
 	FeaturingID            []domain.ArtistID    `schema:"featuring-id"`
 	ReleaseDate            string               `schema:"release-date"`
 	MusicBrainzRecordingID domain.MusicBrainzID `schema:"musicbrainz-recording-id"`
 	CreateAsSingle         bool                 `schema:"create-as-single"`
 }
 
 func parseNewSongForm(form NewSongForm) (domain.NewSong, error) {
 	var song domain.NewSong
 
 	// artists
 	if len(form.ArtistID) == 0 {
 		return song, errors.New("At least one artist is required")
 	}
 
 	artists := make([]domain.NewSongArtist, 0, len(form.ArtistID)+len(form.FeaturingID))
 	seenArtists := make(map[int64]struct{}, len(form.ArtistID)+len(form.FeaturingID))
 
 	for i, id := range form.ArtistID {
 		if id < 0 {
 			return song, errors.New("Invalid artist selection")
 		}
 		if _, exists := seenArtists[int64(id)]; exists {
 			return song, errors.New("An artist cannot be added more than once")
 		}
 		seenArtists[int64(id)] = struct{}{}
 
 		artists = append(artists, domain.NewSongArtist{
 			ArtistID:  id,
 			Role:      domain.RolePrimary,
 			SortOrder: i,
 		})
 	}
 
 	// featuring
 	for i, id := range form.FeaturingID {
 		if id < 0 {
 			return song, errors.New("Invalid artist selection")
 		}
 		if _, exists := seenArtists[int64(id)]; exists {
 			return song, errors.New("An artist cannot be added more than once")
 		}
 		seenArtists[int64(id)] = struct{}{}
 
 		artists = append(artists, domain.NewSongArtist{
 			ArtistID:  id,
 			Role:      domain.RoleFeatured,
 			SortOrder: i,
 		})
 	}
 
 	// title
 	if !domain.NoTrailingOrLeadingSpaceRegex.MatchString(form.Title) {
 		return song, errors.New("Title must not be empty or have leading/trailing whitespace")
 	}
 
 	// latin title
 	var latinTitle *string
 	if form.LatinTitle != "" {
 		if !domain.NoTrailingOrLeadingSpaceRegex.MatchString(form.LatinTitle) {
 			return song, errors.New("Latin title must not be empty or have leading/trailing whitespace")
 		}
 		if !domain.IsValidSortNameRegex.MatchString(form.LatinTitle) {
 			return song, errors.New("Latin title contains invalid characters")
 		}
 		latinTitle = &form.LatinTitle
 	}
 
 	// genres
 	if len(form.Genres) == 0 {
 		return song, errors.New("At least one genre is required")
 	}
 	genres := make([]domain.Genre, 0, len(form.Genres))
 	for _, g := range form.Genres {
 		genre := domain.Genre(g)
 		if _, ok := domain.ValidGenres[genre]; !ok {
 			return song, fmt.Errorf("Unknown genre: %q", g)
 		}
 		genres = append(genres, genre)
 	}
 
 	// release date
 	releaseDate, err := time.Parse("2006-01-02", form.ReleaseDate)
 	if err != nil {
 		return song, fmt.Errorf("Invalid release date: %w", err)
 	}
 	minDate := time.Date(1000, 1, 1, 0, 0, 0, 0, time.UTC)
 	maxDate := time.Now().AddDate(3, 0, 0)
 	if releaseDate.Before(minDate) || releaseDate.After(maxDate) {
 		return song, fmt.Errorf("Release date must be between %s and %s",
 			minDate.Format("2006-01-02"), maxDate.Format("2006-01-02"))
 	}
 
 	// releases
 	releases := make([]domain.NewSongRelease, 0, len(form.ReleaseID))
 	if !form.CreateAsSingle {
 		seenReleases := make(map[int64]struct{}, len(form.ReleaseID))
 		for _, id := range form.ReleaseID {
 			if id < 0 {
 				return song, errors.New("Invalid release selection")
 			}
 			if _, exists := seenReleases[int64(id)]; exists {
 				return song, errors.New("A release cannot be added more than once")
 			}
 			seenReleases[int64(id)] = struct{}{}
 
 			releases = append(releases, domain.NewSongRelease{
 				ReleaseID: id,
 			})
 		}
 	}
 
 	// musicbrainz recording id
 	var musicbrainzRecordingID *domain.MusicBrainzID
 	if form.MusicBrainzRecordingID != "" {
 		if !domain.MusicBrainzIDIsValid(string(form.MusicBrainzRecordingID)) {
 			return song, fmt.Errorf("'%s' must be a valid MusicBrainz ID", form.MusicBrainzRecordingID)
 		}
 		musicbrainzRecordingID = &form.MusicBrainzRecordingID
 	}
 
 	song = domain.NewSong{
 		Title:                  form.Title,
 		LatinTitle:             latinTitle,
 		Lyrics:                 form.Lyrics,
 		ReleaseDate:            releaseDate,
 		Genres:                 genres,
 		Releases:               releases,
 		Artists:                artists,
 		MusicBrainzRecordingID: musicbrainzRecordingID,
 	}
 
 	return song, nil
 }
 
 func (ss *ServerState) NewSong(w http.ResponseWriter, r *http.Request) {
 	logger := ss.logger.With("handler", "NewSong")
 
 	switch r.Method {
 	case http.MethodGet:
 		err := newsong.NewSong(newsong.NewSongParams{}).Render(r.Context(), w)
 		if err != nil {
 			if errors.Is(err, context.Canceled) {
 				return
 			}
 
 			logger.Error("failed to render new song page", "err", err)
 			http.Error(w, "Internal Server Error", http.StatusInternalServerError)
 			return
 		}
 	case http.MethodPost:
 		err := r.ParseForm()
 		if err != nil {
 			logger.Error("failed to parse http form", "err", err)
 			htmx.HxError(w, http.StatusBadRequest, "Failed to add song.")
 			return
 		}
 
 		var newSongForm NewSongForm
 		err = decoder.Decode(&newSongForm, r.PostForm)
 		if err != nil {
 			logger.Error("failed to decode http form", "err", err)
 			htmx.HxError(w, http.StatusBadRequest, err.Error())
 			return
 		}
 
 		newSong, err := parseNewSongForm(newSongForm)
 		if err != nil {
 			logger.Error("failed to parse new song form", "err", err)
 			htmx.HxError(w, http.StatusBadRequest, err.Error())
 			return
 		}
 
 		if newSongForm.CreateAsSingle {
 			releaseArtists := make([]domain.NewReleaseArtist, 0, len(newSong.Artists))
 			for _, artist := range newSong.Artists {
 				releaseArtists = append(releaseArtists, domain.NewReleaseArtist(artist))
 			}
 
 			single := domain.NewRelease{
 				Title:       newSong.Title,
 				LatinTitle:  newSong.LatinTitle,
 				ReleaseDate: newSong.ReleaseDate,
 				Artists:     releaseArtists,
 				Type:        domain.ReleaseTypeSingle,
 			}
 
 			tx, err := ss.db.BeginTx(r.Context(), nil)
 			if err != nil {
 				logger.Error("failed to begin db transaction", "err", err)
 				htmx.HxError(w, http.StatusInternalServerError, "Failed to add release.")
 				return
 			}
 
 			id, err := db.InsertRelease(tx, single)
 			if err != nil {
 				if rollbackErr := tx.Rollback(); rollbackErr != nil {
 					logger.Error("failed to rollback db transaction", "err", rollbackErr)
 				}
 				logger.Error("failed to save new release into db", "err", err)
 				htmx.HxError(w, http.StatusInternalServerError, "Failed to add release.")
 				return
 			}
 
 			if err := tx.Commit(); err != nil {
 				logger.Error("failed to commit db transaction", "err", err)
 				htmx.HxError(w, http.StatusInternalServerError, "Failed to add release.")
 				return
 			}
 
 			logger.Info("added release", "release", single)
 
 			newSong.Releases = append(newSong.Releases, domain.NewSongRelease{
 				ReleaseID:   id,
 				TrackNumber: 1,
 			})
 		}
 
 		tx, err := ss.db.BeginTx(r.Context(), nil)
 		if err != nil {
 			logger.Error("failed to begin db transaction", "err", err)
 			htmx.HxError(w, http.StatusInternalServerError, "Failed to add song.")
 			return
 		}
 
 		err = db.InsertSong(tx, newSong)
 		if err != nil {
 			if rollbackErr := tx.Rollback(); rollbackErr != nil {
 				logger.Error("failed to rollback db transaction", "err", rollbackErr)
 			}
 			logger.Error("failed to save new song into db", "err", err)
 			htmx.HxError(w, http.StatusInternalServerError, "Failed to add song.")
 			return
 		}
 
 		if err := tx.Commit(); err != nil {
 			logger.Error("failed to commit db transaction", "err", err)
 			htmx.HxError(w, http.StatusInternalServerError, "Failed to add song.")
 			return
 		}
 
 		logger.Info("added song", "song", newSong)
 
 		htmx.HxRedirect(w, http.StatusOK, "/")
 	}
 }