lyrics

edit-release.go (7342B)

---

 package server
 
 import (
 	"context"
 	"errors"
 	"fmt"
 	"lyrics/internal/db"
 	"lyrics/internal/domain"
 	"lyrics/internal/server/htmx"
 	"lyrics/internal/server/routes"
 	editrelease "lyrics/internal/server/ui/views/edit-release"
 	"net/http"
 	"strconv"
 	"time"
 )
 
 type EditReleaseForm struct {
 	Title                string               `schema:"release-title"`
 	Type                 domain.ReleaseType   `schema:"type"`
 	LatinTitle           string               `schema:"latin-title"`
 	ArtistID             []domain.ArtistID    `schema:"artist-id"`
 	SongID               []domain.SongID      `schema:"song-id"`
 	TrackNumber          []int                `schema:"track-number"`
 	ReleaseDate          string               `schema:"release-date"`
 	MusicBrainzReleaseID domain.MusicBrainzID `schema:"musicbrainz-release-id"`
 }
 
 func parseEditReleaseForm(form EditReleaseForm) (domain.EditRelease, error) {
 	var release domain.EditRelease
 
 	// 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
 	}
 
 	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"))
 	}
 
 	if len(form.SongID) != len(form.TrackNumber) {
 		return release, errors.New("Song ID and track number counts do not match")
 	}
 
 	songs := make([]domain.EditReleaseSong, 0, len(form.SongID))
 	seenTracknumbers := make(map[int]domain.SongID, len(form.SongID))
 	seenSongs := make(map[domain.SongID]int, len(form.SongID))
 
 	for i := 0; i < len(form.SongID); i++ {
 		songID := form.SongID[i]
 		trackNumber := form.TrackNumber[i]
 
 		if songID < 0 {
 			return release, errors.New("Invalid song selection")
 		}
 
 		if trackNumber < 1 {
 			return release, errors.New("Track number can not be less that 1")
 		}
 
 		if _, exists := seenTracknumbers[trackNumber]; exists {
 			return release, errors.New("Songs may not share the same track number")
 		}
 
 		if _, exists := seenSongs[songID]; exists {
 			return release, errors.New("A song cannot be added more than once")
 		}
 
 		seenTracknumbers[trackNumber] = songID
 		seenSongs[songID] = trackNumber
 
 		songs = append(songs, domain.EditReleaseSong{
 			SongID:      songID,
 			TrackNumber: trackNumber,
 		})
 	}
 
 	// 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.EditRelease{
 		MusicBrainzReleaseID: musicbrainzReleaseID,
 		Title:                form.Title,
 		LatinTitle:           latinTitle,
 		ReleaseDate:          releaseDate,
 		Artists:              artists,
 		Songs:                songs,
 		Type:                 form.Type,
 	}
 
 	return release, nil
 }
 
 func (ss *ServerState) EditRelease(w http.ResponseWriter, r *http.Request) {
 	logger := ss.logger.With("handler", "EditRelease")
 
 	idStr := r.PathValue("id")
 	id, err := strconv.Atoi(idStr)
 	if err != nil {
 		logger.Error("failed to convert release id to integer", "id", idStr, "err", err)
 		htmx.HxError(w, http.StatusBadRequest, err.Error())
 		return
 	}
 
 	slug := r.PathValue("slug")
 	logger = logger.With("id", id, "slug", slug)
 
 	switch r.Method {
 	case http.MethodGet:
 		release, err := db.Release(ss.db, domain.ReleaseID(id))
 		if err != nil {
 			logger.Error("failed to get release", "err", err)
 			htmx.HxError(w, http.StatusInternalServerError, fmt.Sprintf("failed to query for release '%s'", slug))
 			return
 		}
 
 		err = editrelease.EditRelease(editrelease.EditReleaseParams{
 			Release: release,
 		}).Render(r.Context(), w)
 		if err != nil {
 			if errors.Is(err, context.Canceled) {
 				return
 			}
 
 			logger.Error("failed to render edit 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 edit release.")
 			return
 		}
 
 		var editReleaseForm EditReleaseForm
 		err = decoder.Decode(&editReleaseForm, r.PostForm)
 		if err != nil {
 			logger.Error("failed to decode http form", "err", err)
 			htmx.HxError(w, http.StatusBadRequest, err.Error())
 			return
 		}
 
 		updatedRelease, err := parseEditReleaseForm(editReleaseForm)
 		if err != nil {
 			logger.Error("failed to parse edited release form", "err", err)
 			htmx.HxError(w, http.StatusBadRequest, err.Error())
 			return
 		}
 		updatedRelease.ID = domain.ReleaseID(id)
 
 		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 edit release.")
 			return
 		}
 
 		err = db.UpdateRelease(tx, updatedRelease)
 		if err != nil {
 			if rollbackErr := tx.Rollback(); rollbackErr != nil {
 				logger.Error("failed to rollback db transaction", "err", rollbackErr)
 			}
 			logger.Error("failed to save edited release into db", "err", err)
 			htmx.HxError(w, http.StatusInternalServerError, "Failed to edit release.")
 			return
 		}
 
 		if err := tx.Commit(); err != nil {
 			logger.Error("failed to commit db transaction", "err", err)
 			htmx.HxError(w, http.StatusInternalServerError, "Failed to edit release.")
 			return
 		}
 
 		logger.Info("edited release", "release", updatedRelease)
 
 		release := domain.Release{
 			ID:         updatedRelease.ID,
 			Title:      updatedRelease.Title,
 			LatinTitle: updatedRelease.LatinTitle,
 		}
 
 		htmx.HxRedirect(w, http.StatusOK, routes.Release(release))
 	}
 }