new sw show template

domain/domain.go

@@ -22,7 +22,7 @@ func NewDomain() Domain {
 	releaseRepository := &ReleaseRepository{db: DB}
 	fileRepository := NewFileRepository()
 
-	softwareService := NewSoftwareService(softwareRepository)
+	softwareService := NewSoftwareService(softwareRepository, releaseRepository)
 
 	tic80Updater := NewSoftwareUpdaterTIC80Service(
 		softwareRepository,

domain/repository.file.go

@@ -72,6 +72,7 @@ func (fr *FileRepository) UnzipFile(path, destPath string) error {
 
 	for _, f := range r.File {
 		path := filepath.Join(fullDestPath, f.Name)
+		fmt.Printf("ZIP: Extracting %s\n", path)
 
 		if f.FileInfo().IsDir() {
 			os.MkdirAll(path, 0755)

domain/repository.release.go

@@ -7,6 +7,7 @@ type ReleaseRepositoryInterface interface {
 	CreateIfNotExist(release *Release) error
 	FindLatestBySoftwareID(softwareID uint) (*Release, error)
 	FindBySoftwareIDAndVersion(softwareID uint, version string) (*Release, error)
+	ListBySoftwareID(softwareID uint) []Release
 }
 
 type ReleaseRepository struct {
@@ -40,3 +41,9 @@ func (r *ReleaseRepository) FindBySoftwareIDAndVersion(softwareID uint, version
 	err := r.db.Where("software_id = ? AND version = ?", softwareID, version).First(&release).Error
 	return &release, err
 }
+
+func (r *ReleaseRepository) ListBySoftwareID(softwareID uint) []Release {
+	var releases []Release
+	r.db.Where("software_id = ?", softwareID).Find(&releases)
+	return releases
+}

domain/service.software.go

@@ -1,24 +1,42 @@
 package domain
 
-import "sort"
+import (
+	"fmt"
+	"sort"
+)
 
 type SoftwareListDTO struct {
 	Software
 	LatestRelease *Release
 }
 
+type SoftwareShowData struct {
+	Software           *Software
+	Releases           []Release
+	LatestRelease      *Release
+	WebPlayableRelease *Release
+}
+
 type SoftwareServiceInterface interface {
 	List() ([]SoftwareListDTO, error)
 	GetByName(name string) (*Software, error)
 	GetLatestRelease(softwareID string) (*Release, error)
+	GetForShowByName(name string) (*SoftwareShowData, error)
 }
 
 type SoftwareService struct {
 	softeare_repository SoftwareRepositoryInterface
+	release_repository  ReleaseRepositoryInterface
 }
 
-func NewSoftwareService(softeare_repository SoftwareRepositoryInterface) *SoftwareService {
-	return &SoftwareService{softeare_repository: softeare_repository}
+func NewSoftwareService(
+	softeare_repository SoftwareRepositoryInterface,
+	release_repository ReleaseRepositoryInterface,
+) *SoftwareService {
+	return &SoftwareService{
+		softeare_repository: softeare_repository,
+		release_repository:  release_repository,
+	}
 }
 
 func (s *SoftwareService) List() ([]SoftwareListDTO, error) {
@@ -44,6 +62,42 @@ func (s *SoftwareService) List() ([]SoftwareListDTO, error) {
 
 func (s *SoftwareService) GetByName(name string) (*Software, error) {
 	return s.softeare_repository.GetByName(name)
+
+}
+
+func (s *SoftwareService) GetForShowByName(name string) (*SoftwareShowData, error) {
+	software, err := s.softeare_repository.GetByName(name)
+	if err != nil {
+		return nil, err
+	}
+	if software == nil {
+		return nil, fmt.Errorf("software not found")
+	}
+
+	releases := s.release_repository.ListBySoftwareID(software.ID)
+
+	var latest_release *Release
+	if len(releases) > 0 {
+		sort.Slice(releases, func(i, j int) bool {
+			return releases[i].CreatedAt.After(releases[j].CreatedAt)
+		})
+		latest_release = &releases[0]
+	}
+
+	var web_payable_release *Release
+	for _, release := range releases {
+		if release.HTMLFolderPath != "" {
+			web_payable_release = &release
+			break
+		}
+	}
+
+	return &SoftwareShowData{
+		Software:           software,
+		Releases:           releases,
+		LatestRelease:      latest_release,
+		WebPlayableRelease: web_payable_release,
+	}, nil
 }
 
 func (s *SoftwareService) GetLatestRelease(softwareID string) (*Release, error) {