648 lines
19 KiB
Go
648 lines
19 KiB
Go
package article
|
|
|
|
import (
|
|
"RenewCMS/api/pkg/apperr"
|
|
"RenewCMS/api/pkg/claims"
|
|
validator "RenewCMS/api/pkg/validator"
|
|
domain "RenewCMS/internal/domain/article"
|
|
"RenewCMS/internal/domain/author"
|
|
"RenewCMS/internal/domain/image"
|
|
"RenewCMS/internal/domain/site"
|
|
"RenewCMS/internal/infrastructure/useCases"
|
|
"encoding/json"
|
|
"errors"
|
|
"fmt"
|
|
"io"
|
|
"log"
|
|
"net/http"
|
|
"net/url"
|
|
"slices"
|
|
"strconv"
|
|
"strings"
|
|
"time"
|
|
|
|
"github.com/go-chi/chi/v5"
|
|
playground "github.com/go-playground/validator/v10"
|
|
)
|
|
|
|
type Handler struct {
|
|
CreateUseCase *useCases.CreateArticleUseCase
|
|
GetUseCase *useCases.GetArticleUseCase
|
|
ListUseCase *useCases.ListArticlesUseCase
|
|
DeleteUseCase *useCases.DeleteArticleUseCase
|
|
UpdateUseCase *useCases.UpdateArticleUseCase
|
|
GetUserUseCase *useCases.GetUserUseCase
|
|
}
|
|
|
|
type PostArticle struct {
|
|
Title string `json:"title" validate:"required,min=3,max=200"`
|
|
Body string `json:"body"`
|
|
}
|
|
|
|
func NewHandler(create *useCases.CreateArticleUseCase, get *useCases.GetArticleUseCase, list *useCases.ListArticlesUseCase, delete *useCases.DeleteArticleUseCase, update *useCases.UpdateArticleUseCase, getUser *useCases.GetUserUseCase) *Handler {
|
|
return &Handler{
|
|
CreateUseCase: create,
|
|
GetUseCase: get,
|
|
ListUseCase: list,
|
|
DeleteUseCase: delete,
|
|
UpdateUseCase: update,
|
|
GetUserUseCase: getUser,
|
|
}
|
|
}
|
|
|
|
type baseArticleResponse struct {
|
|
ID uint32 `json:"id"`
|
|
Title string `json:"title"`
|
|
Body json.RawMessage `json:"body"`
|
|
BodyFormat domain.BodyFormat `json:"body_format"`
|
|
IsOnline bool `json:"is_online"`
|
|
SiteID uint32 `json:"site_id"`
|
|
Authors []author.Byline `json:"authors"`
|
|
CreatedAt time.Time `json:"created_at"`
|
|
UpdatedAt time.Time `json:"updated_at"`
|
|
}
|
|
|
|
type articleResponse struct {
|
|
baseArticleResponse
|
|
Slug string `json:"slug"`
|
|
Excerpt string `json:"excerpt"`
|
|
SEOTitle string `json:"seo_title"`
|
|
SEODescription string `json:"seo_description"`
|
|
CoverImageID *uint32 `json:"cover_image_id"`
|
|
CoverImageAlt string `json:"cover_image_alt"`
|
|
SocialTitle string `json:"social_title"`
|
|
SocialDescription string `json:"social_description"`
|
|
SocialImageID *uint32 `json:"social_image_id"`
|
|
CanonicalURL string `json:"canonical_url"`
|
|
Noindex bool `json:"noindex"`
|
|
SEODismissed []string `json:"seo_dismissed"`
|
|
}
|
|
|
|
type listItemResponse struct {
|
|
baseArticleResponse
|
|
Excerpt string `json:"excerpt"`
|
|
Slug string `json:"slug"`
|
|
SEOStatus string `json:"seo_status"`
|
|
SEOSuggestions int `json:"seo_suggestions"`
|
|
}
|
|
|
|
func toBaseResponse(article domain.Article, format domain.BodyFormat) (baseArticleResponse, error) {
|
|
body := json.RawMessage(article.Body)
|
|
if format != domain.BodyFormatJSON {
|
|
encoded, err := json.Marshal(article.Body)
|
|
if err != nil {
|
|
return baseArticleResponse{}, err
|
|
}
|
|
body = encoded
|
|
}
|
|
authors := article.Authors
|
|
if authors == nil {
|
|
authors = []author.Byline{}
|
|
}
|
|
return baseArticleResponse{
|
|
ID: article.ID,
|
|
Title: article.Title,
|
|
Body: body,
|
|
BodyFormat: format,
|
|
IsOnline: article.IsOnline,
|
|
SiteID: article.SiteID,
|
|
Authors: authors,
|
|
CreatedAt: article.CreatedAt,
|
|
UpdatedAt: article.UpdatedAt,
|
|
}, nil
|
|
}
|
|
|
|
func toArticleResponse(article domain.Article, format domain.BodyFormat) (articleResponse, error) {
|
|
base, err := toBaseResponse(article, format)
|
|
if err != nil {
|
|
return articleResponse{}, err
|
|
}
|
|
dismissed := article.SEODismissed
|
|
if dismissed == nil {
|
|
dismissed = []string{}
|
|
}
|
|
return articleResponse{
|
|
baseArticleResponse: base,
|
|
Slug: article.Slug,
|
|
Excerpt: article.Excerpt,
|
|
SEOTitle: article.SEOTitle,
|
|
SEODescription: article.SEODescription,
|
|
CoverImageID: article.CoverImageID,
|
|
CoverImageAlt: article.CoverImageAlt,
|
|
SocialTitle: article.SocialTitle,
|
|
SocialDescription: article.SocialDescription,
|
|
SocialImageID: article.SocialImageID,
|
|
CanonicalURL: article.CanonicalURL,
|
|
Noindex: article.Noindex,
|
|
SEODismissed: dismissed,
|
|
}, nil
|
|
}
|
|
|
|
func toListItemResponse(article domain.Article, summary domain.SEOSummary, format domain.BodyFormat) (listItemResponse, error) {
|
|
base, err := toBaseResponse(article, format)
|
|
if err != nil {
|
|
return listItemResponse{}, err
|
|
}
|
|
return listItemResponse{baseArticleResponse: base, Excerpt: article.Excerpt, Slug: article.Slug, SEOStatus: summary.Status, SEOSuggestions: summary.Suggestions}, nil
|
|
}
|
|
|
|
func encodeArticle(article domain.Article, format domain.BodyFormat) ([]byte, error) {
|
|
response, err := toArticleResponse(article, format)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return json.Marshal(response)
|
|
}
|
|
|
|
func parseBodyFormat(w http.ResponseWriter, r *http.Request) (domain.BodyFormat, bool) {
|
|
format, err := domain.ParseBodyFormat(r.URL.Query().Get("format"))
|
|
if err != nil {
|
|
http.Error(w, apperr.ArticleBodyFormatErrorMessage, http.StatusBadRequest)
|
|
return "", false
|
|
}
|
|
return format, true
|
|
}
|
|
|
|
func parseArticleId(r *http.Request) (uint32, error) {
|
|
id, err := strconv.ParseUint(chi.URLParam(r, "id"), 10, 32)
|
|
return uint32(id), err
|
|
}
|
|
|
|
func (h *Handler) GetArticle(w http.ResponseWriter, r *http.Request) {
|
|
id, err := parseArticleId(r)
|
|
if err != nil {
|
|
http.Error(w, apperr.IdUint32ErrorMessage, http.StatusBadRequest)
|
|
return
|
|
}
|
|
|
|
format, ok := parseBodyFormat(w, r)
|
|
if !ok {
|
|
return
|
|
}
|
|
|
|
var article domain.Article
|
|
if h.callerIsVerified(r) {
|
|
article, err = h.GetUseCase.GetArticle(id, format)
|
|
} else {
|
|
article, err = h.GetUseCase.GetOnlineArticle(id, format)
|
|
}
|
|
if err != nil {
|
|
if errors.Is(err, domain.ErrArticleNotFound) {
|
|
http.Error(w, apperr.ArticleNotFoundErrorMessage, http.StatusNotFound)
|
|
return
|
|
}
|
|
http.Error(w, "Internal server error", http.StatusInternalServerError)
|
|
return
|
|
}
|
|
|
|
articleJson, err := encodeArticle(article, format)
|
|
if err != nil {
|
|
http.Error(w, "Failed to encode response", http.StatusInternalServerError)
|
|
return
|
|
}
|
|
|
|
if _, err := w.Write(articleJson); err != nil {
|
|
fmt.Printf("Failed to write response: %v", err)
|
|
}
|
|
}
|
|
|
|
func (h *Handler) PostArticle(w http.ResponseWriter, r *http.Request) {
|
|
format, ok := parseBodyFormat(w, r)
|
|
if !ok {
|
|
return
|
|
}
|
|
|
|
var localArticle PostArticle
|
|
if err := json.NewDecoder(r.Body).Decode(&localArticle); err != nil {
|
|
http.Error(w, apperr.BodyErrorMessage, http.StatusBadRequest)
|
|
return
|
|
}
|
|
|
|
if err := validator.Validate.Struct(localArticle); err != nil {
|
|
http.Error(w, err.Error(), http.StatusBadRequest)
|
|
return
|
|
}
|
|
|
|
creatorId, _ := claims.UserId(r)
|
|
createdArticle, err := h.CreateUseCase.CreateArticle(r.Context(), useCases.CreateArticleCommand{
|
|
Title: localArticle.Title,
|
|
Body: localArticle.Body,
|
|
Format: format,
|
|
CreatedBy: creatorId,
|
|
})
|
|
if err != nil {
|
|
if errors.Is(err, domain.ErrInvalidTitle) {
|
|
http.Error(w, apperr.ArticleTitleErrorMessage, http.StatusBadRequest)
|
|
return
|
|
}
|
|
if !writeKnownArticleError(w, err) {
|
|
http.Error(w, "Failed to create article", http.StatusInternalServerError)
|
|
}
|
|
return
|
|
}
|
|
|
|
writeArticleJsonResponse(w, http.StatusCreated, createdArticle, format)
|
|
}
|
|
|
|
func writeArticleErrorResponse(w http.ResponseWriter, err error) {
|
|
if !writeKnownArticleError(w, err) {
|
|
http.Error(w, "Internal server error", http.StatusInternalServerError)
|
|
}
|
|
}
|
|
|
|
func writeKnownArticleError(w http.ResponseWriter, err error) bool {
|
|
if errors.Is(err, domain.ErrArticleNotFound) {
|
|
http.Error(w, apperr.ArticleNotFoundErrorMessage, http.StatusNotFound)
|
|
return true
|
|
}
|
|
if errors.Is(err, site.ErrSiteNotFound) {
|
|
http.Error(w, apperr.SiteNotFoundErrorMessage, http.StatusNotFound)
|
|
return true
|
|
}
|
|
if errors.Is(err, author.ErrAuthorNotFound) {
|
|
http.Error(w, apperr.AuthorNotFoundErrorMessage, http.StatusNotFound)
|
|
return true
|
|
}
|
|
if errors.Is(err, domain.ErrSlugTaken) {
|
|
writeSlugTaken(w, err)
|
|
return true
|
|
}
|
|
if errors.Is(err, domain.ErrInvalidSlug) {
|
|
http.Error(w, apperr.InvalidSlugErrorMessage, http.StatusBadRequest)
|
|
return true
|
|
}
|
|
if errors.Is(err, domain.ErrInvalidCanonicalURL) {
|
|
http.Error(w, apperr.InvalidURLErrorMessage, http.StatusUnprocessableEntity)
|
|
return true
|
|
}
|
|
if errors.Is(err, image.ErrImageNotFound) {
|
|
http.Error(w, apperr.ArticleImageNotFoundErrorMessage, http.StatusBadRequest)
|
|
return true
|
|
}
|
|
return false
|
|
}
|
|
|
|
func writeSlugTaken(w http.ResponseWriter, err error) {
|
|
var conflict *domain.SlugTakenError
|
|
if errors.As(err, &conflict) && conflict.Suggestion != "" {
|
|
w.Header().Set(apperr.SlugSuggestionHeader, conflict.Suggestion)
|
|
}
|
|
http.Error(w, apperr.ArticleSlugTakenErrorMessage, http.StatusConflict)
|
|
}
|
|
|
|
func writeValidationError(w http.ResponseWriter, err error) {
|
|
var failures playground.ValidationErrors
|
|
if errors.As(err, &failures) {
|
|
for _, failure := range failures {
|
|
if failure.Tag() == validator.ArticleSlugTag {
|
|
http.Error(w, apperr.InvalidSlugErrorMessage, http.StatusBadRequest)
|
|
return
|
|
}
|
|
}
|
|
}
|
|
http.Error(w, err.Error(), http.StatusBadRequest)
|
|
}
|
|
|
|
func writeArticleJsonResponse(w http.ResponseWriter, status int, article domain.Article, format domain.BodyFormat) {
|
|
articleJson, err := encodeArticle(article, format)
|
|
if err != nil {
|
|
http.Error(w, "Failed to encode response", http.StatusInternalServerError)
|
|
return
|
|
}
|
|
|
|
if status != http.StatusOK {
|
|
w.WriteHeader(status)
|
|
}
|
|
if _, err := w.Write(articleJson); err != nil {
|
|
log.Printf("Failed to write response: %v", err)
|
|
}
|
|
}
|
|
|
|
func (h *Handler) setIsOnline(w http.ResponseWriter, r *http.Request, isOnline bool) {
|
|
id, err := parseArticleId(r)
|
|
if err != nil {
|
|
http.Error(w, apperr.IdUint32ErrorMessage, http.StatusBadRequest)
|
|
return
|
|
}
|
|
|
|
format, ok := parseBodyFormat(w, r)
|
|
if !ok {
|
|
return
|
|
}
|
|
|
|
updatedArticle, err := h.UpdateUseCase.UpdateIsOnline(r.Context(), id, isOnline, format)
|
|
if err != nil {
|
|
writeArticleErrorResponse(w, err)
|
|
return
|
|
}
|
|
|
|
writeArticleJsonResponse(w, http.StatusOK, updatedArticle, format)
|
|
}
|
|
|
|
type optionalImageID struct {
|
|
Set bool
|
|
Value *uint32 `validate:"omitempty,gte=1"`
|
|
}
|
|
|
|
func (o *optionalImageID) UnmarshalJSON(data []byte) error {
|
|
o.Set = true
|
|
if string(data) == "null" {
|
|
o.Value = nil
|
|
return nil
|
|
}
|
|
var value uint32
|
|
if err := json.Unmarshal(data, &value); err != nil {
|
|
return err
|
|
}
|
|
o.Value = &value
|
|
return nil
|
|
}
|
|
|
|
func (o optionalImageID) toNullable() domain.Nullable[uint32] {
|
|
return domain.Nullable[uint32]{Set: o.Set, Value: o.Value}
|
|
}
|
|
|
|
type UpdateArticleBody struct {
|
|
Body *string `json:"body"`
|
|
SiteID *uint32 `json:"site_id" validate:"omitempty,gte=1"`
|
|
AuthorIDs *[]uint32 `json:"author_ids" validate:"omitempty,dive,gte=1"`
|
|
Slug *string `json:"slug" validate:"omitempty,articleslug"`
|
|
Excerpt *string `json:"excerpt" validate:"omitempty,max=300"`
|
|
SEOTitle *string `json:"seo_title" validate:"omitempty,max=120"`
|
|
SEODescription *string `json:"seo_description" validate:"omitempty,max=320"`
|
|
CoverImageID optionalImageID `json:"cover_image_id"`
|
|
CoverImageAlt *string `json:"cover_image_alt" validate:"omitempty,max=200"`
|
|
SocialTitle *string `json:"social_title" validate:"omitempty,max=120"`
|
|
SocialDescription *string `json:"social_description" validate:"omitempty,max=320"`
|
|
SocialImageID optionalImageID `json:"social_image_id"`
|
|
CanonicalURL *string `json:"canonical_url" validate:"omitempty,max=2048"`
|
|
Noindex *bool `json:"noindex"`
|
|
SEODismissed *[]string `json:"seo_dismissed" validate:"omitempty,dive,oneof=title_long title_empty desc_short desc_long cover_alt cover_none slug_long no_au no_h body_alt short"`
|
|
}
|
|
|
|
var nonNullableArticleFields = []string{"body", "site_id", "author_ids", "slug", "excerpt", "seo_title", "seo_description", "cover_image_alt", "social_title", "social_description", "canonical_url", "noindex", "seo_dismissed"}
|
|
|
|
var nullableArticleFields = []string{"cover_image_id", "social_image_id"}
|
|
|
|
func hasDuplicates(ids []uint32) bool {
|
|
seen := make(map[uint32]bool, len(ids))
|
|
for _, id := range ids {
|
|
if seen[id] {
|
|
return true
|
|
}
|
|
seen[id] = true
|
|
}
|
|
return false
|
|
}
|
|
|
|
func countKnownFields(fields map[string]json.RawMessage, nonNullable []string) (int, bool) {
|
|
known := 0
|
|
for name, value := range fields {
|
|
switch {
|
|
case slices.Contains(nonNullable, name):
|
|
if string(value) == "null" {
|
|
return 0, false
|
|
}
|
|
known++
|
|
case slices.Contains(nullableArticleFields, name):
|
|
known++
|
|
}
|
|
}
|
|
return known, true
|
|
}
|
|
|
|
func readUpdateArticleBody(r *http.Request) (UpdateArticleBody, bool) {
|
|
raw, err := io.ReadAll(r.Body)
|
|
if err != nil {
|
|
return UpdateArticleBody{}, false
|
|
}
|
|
var fields map[string]json.RawMessage
|
|
if err := json.Unmarshal(raw, &fields); err != nil {
|
|
return UpdateArticleBody{}, false
|
|
}
|
|
known, ok := countKnownFields(fields, nonNullableArticleFields)
|
|
if !ok || known == 0 {
|
|
return UpdateArticleBody{}, false
|
|
}
|
|
var request UpdateArticleBody
|
|
if err := json.Unmarshal(raw, &request); err != nil {
|
|
return UpdateArticleBody{}, false
|
|
}
|
|
if request.AuthorIDs != nil && hasDuplicates(*request.AuthorIDs) {
|
|
return UpdateArticleBody{}, false
|
|
}
|
|
return request, true
|
|
}
|
|
|
|
func (h *Handler) UpdateArticleBody(w http.ResponseWriter, r *http.Request) {
|
|
id, err := parseArticleId(r)
|
|
if err != nil {
|
|
http.Error(w, apperr.IdUint32ErrorMessage, http.StatusBadRequest)
|
|
return
|
|
}
|
|
|
|
format, ok := parseBodyFormat(w, r)
|
|
if !ok {
|
|
return
|
|
}
|
|
|
|
request, ok := readUpdateArticleBody(r)
|
|
if !ok {
|
|
http.Error(w, apperr.BodyErrorMessage, http.StatusBadRequest)
|
|
return
|
|
}
|
|
|
|
if err := validator.Validate.Struct(request); err != nil {
|
|
writeValidationError(w, err)
|
|
return
|
|
}
|
|
|
|
updatedArticle, err := h.UpdateUseCase.Update(r.Context(), id, useCases.UpdateArticleCommand{
|
|
Body: request.Body,
|
|
SiteID: request.SiteID,
|
|
AuthorIDs: request.AuthorIDs,
|
|
Slug: request.Slug,
|
|
Excerpt: request.Excerpt,
|
|
SEOTitle: request.SEOTitle,
|
|
SEODescription: request.SEODescription,
|
|
CoverImageID: request.CoverImageID.toNullable(),
|
|
CoverImageAlt: request.CoverImageAlt,
|
|
SocialTitle: request.SocialTitle,
|
|
SocialDescription: request.SocialDescription,
|
|
SocialImageID: request.SocialImageID.toNullable(),
|
|
CanonicalURL: request.CanonicalURL,
|
|
Noindex: request.Noindex,
|
|
SEODismissed: request.SEODismissed,
|
|
Format: format,
|
|
})
|
|
if err != nil {
|
|
writeArticleErrorResponse(w, err)
|
|
return
|
|
}
|
|
|
|
writeArticleJsonResponse(w, http.StatusOK, updatedArticle, format)
|
|
}
|
|
|
|
func (h *Handler) PublishArticle(w http.ResponseWriter, r *http.Request) {
|
|
h.setIsOnline(w, r, true)
|
|
}
|
|
|
|
func (h *Handler) UnpublishArticle(w http.ResponseWriter, r *http.Request) {
|
|
h.setIsOnline(w, r, false)
|
|
}
|
|
|
|
func (h *Handler) callerIsVerified(r *http.Request) bool {
|
|
return isVerifiedCaller(r, h.GetUserUseCase)
|
|
}
|
|
|
|
func isVerifiedCaller(r *http.Request, getUser *useCases.GetUserUseCase) bool {
|
|
userId, ok := claims.UserId(r)
|
|
if !ok {
|
|
return false
|
|
}
|
|
|
|
currentUser, err := getUser.GetUser(userId)
|
|
if err != nil {
|
|
return false
|
|
}
|
|
|
|
return currentUser.IsVerified
|
|
}
|
|
|
|
const (
|
|
defaultListPage = 1
|
|
defaultListSize = 25
|
|
)
|
|
|
|
type listQuery struct {
|
|
Page int `validate:"gte=1"`
|
|
Size int `validate:"oneof=5 25 50 100"`
|
|
Q string `validate:"max=200"`
|
|
Status string `validate:"omitempty,oneof=online draft"`
|
|
Site *string `validate:"omitempty,min=1"`
|
|
SEO string `validate:"omitempty,oneof=ready suggestions hidden"`
|
|
Sort string `validate:"oneof=title:asc title:desc status:asc status:desc created_at:asc created_at:desc updated_at:asc updated_at:desc"`
|
|
}
|
|
|
|
const defaultListSort = "updated_at:desc"
|
|
|
|
func parseSort(value string) domain.Sort {
|
|
field, direction, _ := strings.Cut(value, ":")
|
|
return domain.Sort{Field: domain.SortField(field), Direction: domain.SortDirection(direction)}
|
|
}
|
|
|
|
type listResponse struct {
|
|
Items []listItemResponse `json:"items"`
|
|
Total int `json:"total"`
|
|
Page int `json:"page"`
|
|
Size int `json:"size"`
|
|
Counts domain.Counts `json:"counts"`
|
|
}
|
|
|
|
func intQueryParam(values url.Values, name string, fallback int) (int, error) {
|
|
if !values.Has(name) {
|
|
return fallback, nil
|
|
}
|
|
return strconv.Atoi(values.Get(name))
|
|
}
|
|
|
|
func readListQuery(values url.Values) (listQuery, error) {
|
|
page, err := intQueryParam(values, "page", defaultListPage)
|
|
if err != nil {
|
|
return listQuery{}, err
|
|
}
|
|
size, err := intQueryParam(values, "size", defaultListSize)
|
|
if err != nil {
|
|
return listQuery{}, err
|
|
}
|
|
status := values.Get("status")
|
|
if values.Has("status") && status == "" {
|
|
return listQuery{}, errors.New("empty status")
|
|
}
|
|
sortValue := defaultListSort
|
|
if values.Has("sort") {
|
|
sortValue = values.Get("sort")
|
|
}
|
|
var siteKey *string
|
|
if values.Has("site") {
|
|
key := values.Get("site")
|
|
if key == "" {
|
|
return listQuery{}, errors.New("empty site")
|
|
}
|
|
siteKey = &key
|
|
}
|
|
seoStatus := values.Get("seo")
|
|
if values.Has("seo") && seoStatus == "" {
|
|
return listQuery{}, errors.New("empty seo")
|
|
}
|
|
return listQuery{Page: page, Size: size, Q: values.Get("q"), Status: status, Sort: sortValue, Site: siteKey, SEO: seoStatus}, nil
|
|
}
|
|
|
|
func (h *Handler) ListArticles(w http.ResponseWriter, r *http.Request) {
|
|
format, ok := parseBodyFormat(w, r)
|
|
if !ok {
|
|
return
|
|
}
|
|
|
|
query, err := readListQuery(r.URL.Query())
|
|
if err != nil || validator.Validate.Struct(query) != nil {
|
|
http.Error(w, apperr.BodyErrorMessage, http.StatusBadRequest)
|
|
return
|
|
}
|
|
|
|
page, err := h.ListUseCase.ListArticlesPage(useCases.ListArticlesCommand{
|
|
Format: format,
|
|
Verified: h.callerIsVerified(r),
|
|
Page: query.Page,
|
|
Size: query.Size,
|
|
Q: query.Q,
|
|
Status: query.Status,
|
|
Sort: parseSort(query.Sort),
|
|
SiteKey: query.Site,
|
|
SEO: query.SEO,
|
|
})
|
|
if err != nil {
|
|
http.Error(w, "Failed to retrieve articles", http.StatusInternalServerError)
|
|
return
|
|
}
|
|
|
|
responses := make([]listItemResponse, 0, len(page.Items))
|
|
for _, article := range page.Items {
|
|
response, err := toListItemResponse(article, page.SEO[article.ID], format)
|
|
if err != nil {
|
|
http.Error(w, "Failed to encode response", http.StatusInternalServerError)
|
|
return
|
|
}
|
|
responses = append(responses, response)
|
|
}
|
|
|
|
articlesJson, err := json.Marshal(listResponse{Items: responses, Total: page.Total, Page: page.Page, Size: page.Size, Counts: page.Counts})
|
|
if err != nil {
|
|
http.Error(w, "Failed to encode response", http.StatusInternalServerError)
|
|
return
|
|
}
|
|
|
|
if _, err := w.Write(articlesJson); err != nil {
|
|
log.Printf("Failed to write response: %v", err)
|
|
}
|
|
}
|
|
|
|
func (h *Handler) DeleteArticle(w http.ResponseWriter, r *http.Request) {
|
|
id, err := parseArticleId(r)
|
|
if err != nil {
|
|
http.Error(w, apperr.IdUint32ErrorMessage, http.StatusBadRequest)
|
|
return
|
|
}
|
|
|
|
if err := h.DeleteUseCase.DeleteArticle(r.Context(), id); err != nil {
|
|
if errors.Is(err, domain.ErrArticleNotFound) {
|
|
http.Error(w, apperr.ArticleNotFoundErrorMessage, http.StatusNotFound)
|
|
return
|
|
}
|
|
http.Error(w, "Failed to delete article", http.StatusInternalServerError)
|
|
return
|
|
}
|
|
|
|
w.WriteHeader(http.StatusNoContent)
|
|
}
|