lyrics

new-release.go (5282B)

---

 package server
 
 import (
 	"context"
 	"errors"
 	"fmt"
 	"lyrics/internal/db"
 	"lyrics/internal/domain"
 	"lyrics/internal/server/htmx"
 	newrelease "lyrics/internal/server/ui/views/new-release"
 	"net/http"
 	"time"
 )
 
 type NewReleaseForm struct {
 	Title                string               `schema:"release-title"`
 	Type                 domain.ReleaseType   `schema:"type"`
 	LatinTitle           string               `schema:"latin-title"`
 	ArtistID             []domain.ArtistID    `schema:"artist-id"`
 	ReleaseDate          string               `schema:"release-date"`
 	MusicBrainzReleaseID domain.MusicBrainzID `schema:"musicbrainz-release-id"`
 }
 
 func parseNewReleaseForm(form NewReleaseForm) (domain.NewRelease, error) {
 	var release domain.NewRelease
 
 	// type
 	if form.Type == "" {
 		return release, errors.New("Type must not be empty")
 	}
 	if _, ok := domain.ReleaseTypes[form.Type]; !ok {
 		return release, errors.New("Invalid type selected")
 	}
 
 	// title
 	if !domain.NoTrailingOrLeadingSpaceRegex.MatchString(form.Title) {
 		return release, errors.New("Title name must not be empty or have leading/trailing whitespace")
 	}
 
 	// artists
 	if len(form.ArtistID) == 0 {
 		return release, errors.New("At least one artist is required")
 	}
 
 	artists := make([]domain.NewReleaseArtist, 0, len(form.ArtistID))
 	seenArtists := make(map[int64]struct{}, len(form.ArtistID))
 
 	for i, id := range form.ArtistID {
 		if id < 0 {
 			return release, errors.New("Invalid artist selection")
 		}
 		if _, exists := seenArtists[int64(id)]; exists {
 			return release, errors.New("An artist cannot be added more than once")
 		}
 		seenArtists[int64(id)] = struct{}{}
 
 		artists = append(artists, domain.NewReleaseArtist{
 			ArtistID:  id,
 			Role:      domain.RolePrimary,
 			SortOrder: i,
 		})
 	}
 
 	// latin title
 	var latinTitle *string
 	if form.LatinTitle != "" {
 		if !domain.NoTrailingOrLeadingSpaceRegex.MatchString(form.LatinTitle) {
 			return release, errors.New("Latin title must not be empty or have leading/trailing whitespace")
 		}
 		if !domain.IsValidSortNameRegex.MatchString(form.LatinTitle) {
 			return release, errors.New("Latin title contains invalid characters")
 		}
 		latinTitle = &form.LatinTitle
 	}
 
 	// release date
 	releaseDate, err := time.Parse("2006-01-02", form.ReleaseDate)
 	if err != nil {
 		return release, 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 release, fmt.Errorf("Release date must be between %s and %s",
 			minDate.Format("2006-01-02"), maxDate.Format("2006-01-02"))
 	}
 
 	// musicbrainz release id
 	var musicbrainzReleaseID *domain.MusicBrainzID
 	if form.MusicBrainzReleaseID != "" {
 		if !domain.MusicBrainzIDIsValid(string(form.MusicBrainzReleaseID)) {
 			return release, fmt.Errorf("'%s' must be a valid MusicBrainz ID", form.MusicBrainzReleaseID)
 		}
 		musicbrainzReleaseID = &form.MusicBrainzReleaseID
 	}
 
 	release = domain.NewRelease{
 		MusicBrainzReleaseID: musicbrainzReleaseID,
 		Title:                form.Title,
 		LatinTitle:           latinTitle,
 		ReleaseDate:          releaseDate,
 		Artists:              artists,
 		Type:                 form.Type,
 	}
 
 	return release, nil
 }
 
 func (ss *ServerState) NewRelease(w http.ResponseWriter, r *http.Request) {
 	logger := ss.logger.With("handler", "NewRelease")
 
 	switch r.Method {
 	case http.MethodGet:
 		err := newrelease.NewRelease(newrelease.NewReleaseParams{}).Render(r.Context(), w)
 		if err != nil {
 			if errors.Is(err, context.Canceled) {
 				return
 			}
 
 			logger.Error("failed to render new release 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 release.")
 			return
 		}
 
 		var newReleaseForm NewReleaseForm
 		err = decoder.Decode(&newReleaseForm, r.PostForm)
 		if err != nil {
 			logger.Error("failed to decode http form", "err", err)
 			htmx.HxError(w, http.StatusBadRequest, err.Error())
 			return
 		}
 
 		newRelease, err := parseNewReleaseForm(newReleaseForm)
 		if err != nil {
 			logger.Error("failed to parse new release form", "err", err)
 			htmx.HxError(w, http.StatusBadRequest, err.Error())
 			return
 		}
 
 		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
 		}
 
 		_, err = db.InsertRelease(tx, newRelease)
 		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", newRelease)
 
 		htmx.HxRedirect(w, http.StatusOK, "/")
 	}
 }