Make published content multilingual

application/article/getArticle/request.go

@@ -0,0 +1,28 @@
+package getarticle
+
+import (
+	"github.com/gofrs/uuid/v5"
+	"github.com/khanzadimahdi/testproject/domain"
+)
+
+type Request struct {
+	CorrelationUUID string
+	LanguageCode    string
+}
+
+// Ensure Request implements domain.Validatable
+var _ domain.Validatable = &Request{}
+
+func (r *Request) Validate() domain.ValidationErrors {
+	validationErrors := make(domain.ValidationErrors)
+
+	if len(r.CorrelationUUID) == 0 {
+		validationErrors["correlation_uuid"] = "required_field"
+	} else {
+		if _, err := uuid.FromString(r.CorrelationUUID); err != nil {
+			validationErrors["correlation_uuid"] = "invalid_value"
+		}
+	}
+
+	return validationErrors
+}

application/article/getArticle/response.go

@@ -5,21 +5,26 @@ import (
 
 	"github.com/khanzadimahdi/testproject/application/element"
 	"github.com/khanzadimahdi/testproject/domain/article"
+	"github.com/khanzadimahdi/testproject/domain/language"
 	"github.com/khanzadimahdi/testproject/domain/user"
 )
 
 type Response struct {
-	UUID        string             `json:"uuid"`
-	Cover       string             `json:"cover"`
-	Video       string             `json:"video"`
-	Title       string             `json:"title"`
-	Excerpt     string             `json:"excerpt"`
-	Body        string             `json:"body"`
-	PublishedAt string             `json:"published_at"`
-	Author      authorResponse     `json:"author"`
-	Tags        []string           `json:"tags"`
-	ViewCount   uint               `json:"view_count"`
-	Elements    []element.Response `json:"elements"`
+	ValidationErrors map[string]string `json:"validation_errors,omitempty"`
+
+	CorrelationUUID    string             `json:"correlation_uuid"`
+	Cover              string             `json:"cover"`
+	Video              string             `json:"video"`
+	Title              string             `json:"title"`
+	Excerpt            string             `json:"excerpt"`
+	Body               string             `json:"body"`
+	PublishedAt        string             `json:"published_at"`
+	Author             authorResponse     `json:"author"`
+	Tags               []string           `json:"tags"`
+	ViewCount          uint               `json:"view_count"`
+	LanguageCode       languageResponse   `json:"language_code"`
+	AvailableLanguages []languageResponse `json:"available_languages"`
+	Elements           []element.Response `json:"elements"`
 }
 
 type authorResponse struct {
@@ -29,18 +34,31 @@ type authorResponse struct {
 	Username string `json:"username"`
 }
 
-func NewResponse(a article.Article, author user.User, elementsResponse []element.Response) *Response {
+type languageResponse struct {
+	Code string `json:"code"`
+	Name string `json:"name"`
+}
+
+func NewResponse(a article.Article, language language.Language, author user.User, availableLanguages []language.Language, elementsResponse []element.Response) *Response {
 	tags := make([]string, len(a.Tags))
 	copy(tags, a.Tags)
 
+	languages := make([]languageResponse, len(availableLanguages))
+	for i, l := range availableLanguages {
+		languages[i] = languageResponse{
+			Code: l.Code,
+			Name: l.Name,
+		}
+	}
+
 	return &Response{
-		UUID:        a.UUID,
-		Cover:       a.Cover,
-		Video:       a.Video,
-		Title:       a.Title,
-		Excerpt:     a.Excerpt,
-		Body:        a.Body,
-		PublishedAt: a.PublishedAt.Format(time.RFC3339),
+		CorrelationUUID: a.CorrelationUUID,
+		Cover:           a.Cover,
+		Video:           a.Video,
+		Title:           a.Title,
+		Excerpt:         a.Excerpt,
+		Body:            a.Body,
+		PublishedAt:     a.PublishedAt.Format(time.RFC3339),
 		Author: authorResponse{
 			UUID:     author.UUID,
 			Name:     author.Name,
@@ -49,6 +67,11 @@ func NewResponse(a article.Article, author user.User, elementsResponse []element
 		},
 		Tags:      tags,
 		ViewCount: a.ViewCount,
-		Elements:  elementsResponse,
+		LanguageCode: languageResponse{
+			Code: language.Code,
+			Name: language.Name,
+		},
+		AvailableLanguages: languages,
+		Elements:           elementsResponse,
 	}
 }

application/article/getArticle/usecase.go

@@ -5,6 +5,7 @@ import (
 	"fmt"
 
 	"github.com/khanzadimahdi/testproject/application/element"
+	"github.com/khanzadimahdi/testproject/application/language/resolver"
 	"github.com/khanzadimahdi/testproject/domain"
 	"github.com/khanzadimahdi/testproject/domain/article"
 	"github.com/khanzadimahdi/testproject/domain/user"
@@ -13,23 +14,50 @@ import (
 type UseCase struct {
 	articleRepository article.Repository
 	userRepository    user.Repository
+	languageResolver  resolver.Resolver
 	elementRetriever  *element.Retriever
+	validator         domain.Validator
 }
 
 func NewUseCase(
 	articleRepository article.Repository,
 	userRepository user.Repository,
+	languageResolver resolver.Resolver,
 	elementRetriever *element.Retriever,
+	validator domain.Validator,
 ) *UseCase {
 	return &UseCase{
 		articleRepository: articleRepository,
 		userRepository:    userRepository,
+		languageResolver:  languageResolver,
 		elementRetriever:  elementRetriever,
+		validator:         validator,
 	}
 }
 
-func (uc *UseCase) Execute(UUID string) (*Response, error) {
-	a, err := uc.articleRepository.GetOnePublished(UUID)
+func (uc *UseCase) Execute(request *Request) (*Response, error) {
+	if validationErrors := uc.validator.Validate(request); len(validationErrors) > 0 {
+		return &Response{
+			ValidationErrors: validationErrors,
+		}, nil
+	}
+
+	languageCode := request.LanguageCode
+	if len(languageCode) == 0 {
+		code, err := uc.languageResolver.DefaultCode()
+		if err != nil {
+			return nil, err
+		}
+
+		languageCode = code
+	}
+
+	l, err := uc.languageResolver.Resolve(languageCode)
+	if err != nil {
+		return nil, err
+	}
+
+	a, err := uc.articleRepository.GetOnePublished(request.CorrelationUUID, languageCode)
 	if err != nil {
 		return nil, err
 	}
@@ -39,15 +67,20 @@ func (uc *UseCase) Execute(UUID string) (*Response, error) {
 		return nil, err
 	}
 
-	elementsResponse, err := uc.elementRetriever.RetrieveByVenues([]string{
-		"articles/*",
-		fmt.Sprintf("articles/%s", UUID),
-	})
+	availableLanguages, err := uc.articleRepository.GetPublishedLanguages(a.CorrelationUUID)
+	if err != nil {
+		return nil, err
+	}
+
+	elementsResponse, err := uc.elementRetriever.RetrieveByVenues(
+		[]string{"articles/*", fmt.Sprintf("articles/%s", a.CorrelationUUID)},
+		languageCode,
+	)
 	if err != nil {
 		return nil, err
 	}
 
 	defer uc.articleRepository.IncreaseView(a.UUID, 1)
 
-	return NewResponse(a, author, elementsResponse), nil
+	return NewResponse(a, l, author, availableLanguages, elementsResponse), nil
 }