477 lines
12 KiB
Go
477 lines
12 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/site"
|
|
"RenewCMS/internal/infrastructure/useCases"
|
|
"encoding/json"
|
|
"errors"
|
|
"fmt"
|
|
"io"
|
|
"log"
|
|
"net/http"
|
|
"net/url"
|
|
"strconv"
|
|
"strings"
|
|
"time"
|
|
|
|
"github.com/go-chi/chi/v5"
|
|
)
|
|
|
|
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 articleResponse 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"`
|
|
}
|
|
|
|
func toArticleResponse(article domain.Article, format domain.BodyFormat) (articleResponse, error) {
|
|
body := json.RawMessage(article.Body)
|
|
if format != domain.BodyFormatJSON {
|
|
encoded, err := json.Marshal(article.Body)
|
|
if err != nil {
|
|
return articleResponse{}, err
|
|
}
|
|
body = encoded
|
|
}
|
|
authors := article.Authors
|
|
if authors == nil {
|
|
authors = []author.Byline{}
|
|
}
|
|
return articleResponse{
|
|
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 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
|
|
}
|
|
http.Error(w, "Failed to create article", http.StatusInternalServerError)
|
|
return
|
|
}
|
|
|
|
writeArticleJsonResponse(w, http.StatusCreated, createdArticle, format)
|
|
}
|
|
|
|
func writeArticleErrorResponse(w http.ResponseWriter, err error) {
|
|
if errors.Is(err, domain.ErrArticleNotFound) {
|
|
http.Error(w, apperr.ArticleNotFoundErrorMessage, http.StatusNotFound)
|
|
return
|
|
}
|
|
if errors.Is(err, site.ErrSiteNotFound) {
|
|
http.Error(w, apperr.SiteNotFoundErrorMessage, http.StatusNotFound)
|
|
return
|
|
}
|
|
if errors.Is(err, author.ErrAuthorNotFound) {
|
|
http.Error(w, apperr.AuthorNotFoundErrorMessage, http.StatusNotFound)
|
|
return
|
|
}
|
|
http.Error(w, "Internal server error", http.StatusInternalServerError)
|
|
}
|
|
|
|
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 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"`
|
|
}
|
|
|
|
var updatableArticleFields = []string{"body", "site_id", "author_ids"}
|
|
|
|
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 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 := 0
|
|
for _, name := range updatableArticleFields {
|
|
value, present := fields[name]
|
|
if !present {
|
|
continue
|
|
}
|
|
if string(value) == "null" {
|
|
return UpdateArticleBody{}, false
|
|
}
|
|
known++
|
|
}
|
|
if 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 {
|
|
http.Error(w, err.Error(), http.StatusBadRequest)
|
|
return
|
|
}
|
|
|
|
updatedArticle, err := h.UpdateUseCase.Update(r.Context(), id, useCases.UpdateArticleCommand{
|
|
Body: request.Body,
|
|
SiteID: request.SiteID,
|
|
AuthorIDs: request.AuthorIDs,
|
|
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 {
|
|
userId, ok := claims.UserId(r)
|
|
if !ok {
|
|
return false
|
|
}
|
|
|
|
currentUser, err := h.GetUserUseCase.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"`
|
|
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 []articleResponse `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
|
|
}
|
|
return listQuery{Page: page, Size: size, Q: values.Get("q"), Status: status, Sort: sortValue, Site: siteKey}, 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,
|
|
})
|
|
if err != nil {
|
|
http.Error(w, "Failed to retrieve articles", http.StatusInternalServerError)
|
|
return
|
|
}
|
|
|
|
responses := make([]articleResponse, 0, len(page.Items))
|
|
for _, article := range page.Items {
|
|
response, err := toArticleResponse(article, 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)
|
|
}
|