326 lines
9.1 KiB
Go
326 lines
9.1 KiB
Go
package media
|
|
|
|
import (
|
|
"RenewCMS/api/pkg/apperr"
|
|
"RenewCMS/api/pkg/claims"
|
|
"RenewCMS/api/pkg/upload"
|
|
validator "RenewCMS/api/pkg/validator"
|
|
domainImage "RenewCMS/internal/domain/image"
|
|
"RenewCMS/internal/infrastructure/useCases"
|
|
"encoding/json"
|
|
"errors"
|
|
"net/http"
|
|
"net/url"
|
|
"strconv"
|
|
"strings"
|
|
"time"
|
|
|
|
"github.com/go-chi/chi/v5"
|
|
)
|
|
|
|
type Handler struct {
|
|
CreateUseCase *useCases.CreateImageUseCase
|
|
ListUseCase *useCases.ListMediaUseCase
|
|
RenameUseCase *useCases.RenameMediaUseCase
|
|
DeleteUseCase *useCases.DeleteMediaUseCase
|
|
MergeUseCase *useCases.MergeMediaUseCase
|
|
UsageUseCase *useCases.GetMediaUsageUseCase
|
|
PurgeSettingsUseCase *useCases.GetPurgeSettingsUseCase
|
|
UpdatePurgeSettingsUseCase *useCases.UpdatePurgeSettingsUseCase
|
|
PreviewPurgeUseCase *useCases.PreviewPurgeUseCase
|
|
RunPurgeUseCase *useCases.RunPurgeUseCase
|
|
}
|
|
|
|
type RenameRequest struct {
|
|
Filename string `json:"filename" validate:"required"`
|
|
}
|
|
|
|
type MergeRequest struct {
|
|
KeepID uint32 `json:"keep_id" validate:"required,gt=0"`
|
|
MergeIDs []uint32 `json:"merge_ids" validate:"required,min=1,dive,gt=0"`
|
|
}
|
|
|
|
type mediaItemResponse struct {
|
|
ID uint32 `json:"id"`
|
|
Filename string `json:"filename"`
|
|
URL string `json:"url"`
|
|
Size int64 `json:"size"`
|
|
ContentType string `json:"content_type"`
|
|
Width *int `json:"width"`
|
|
Height *int `json:"height"`
|
|
SHA256 string `json:"sha256"`
|
|
UploadedBy string `json:"uploaded_by"`
|
|
CreatedAt time.Time `json:"created_at"`
|
|
UsedIn int `json:"used_in"`
|
|
Duplicate bool `json:"duplicate"`
|
|
}
|
|
|
|
type countsResponse struct {
|
|
All int `json:"all"`
|
|
Unused int `json:"unused"`
|
|
Duplicates int `json:"duplicates"`
|
|
}
|
|
|
|
type listResponse struct {
|
|
Items []mediaItemResponse `json:"items"`
|
|
NextCursor *string `json:"next_cursor"`
|
|
Counts countsResponse `json:"counts"`
|
|
}
|
|
|
|
type usageResponse struct {
|
|
ID uint32 `json:"id"`
|
|
Title string `json:"title"`
|
|
Published bool `json:"published"`
|
|
}
|
|
|
|
type mergeResponse struct {
|
|
ArticlesUpdated int `json:"articles_updated"`
|
|
Merged int `json:"merged"`
|
|
}
|
|
|
|
func NewHandler(create *useCases.CreateImageUseCase, list *useCases.ListMediaUseCase, rename *useCases.RenameMediaUseCase, deleteUseCase *useCases.DeleteMediaUseCase, merge *useCases.MergeMediaUseCase, usage *useCases.GetMediaUsageUseCase, purgeSettings *useCases.GetPurgeSettingsUseCase, updatePurgeSettings *useCases.UpdatePurgeSettingsUseCase, previewPurge *useCases.PreviewPurgeUseCase, runPurge *useCases.RunPurgeUseCase) *Handler {
|
|
return &Handler{
|
|
CreateUseCase: create,
|
|
ListUseCase: list,
|
|
RenameUseCase: rename,
|
|
DeleteUseCase: deleteUseCase,
|
|
MergeUseCase: merge,
|
|
UsageUseCase: usage,
|
|
PurgeSettingsUseCase: purgeSettings,
|
|
UpdatePurgeSettingsUseCase: updatePurgeSettings,
|
|
PreviewPurgeUseCase: previewPurge,
|
|
RunPurgeUseCase: runPurge,
|
|
}
|
|
}
|
|
|
|
func writeInternalServerError(w http.ResponseWriter) {
|
|
http.Error(w, "Internal server error", http.StatusInternalServerError)
|
|
}
|
|
|
|
func writeJSON(w http.ResponseWriter, status int, payload any) {
|
|
body, err := json.Marshal(payload)
|
|
if err != nil {
|
|
writeInternalServerError(w)
|
|
return
|
|
}
|
|
w.WriteHeader(status)
|
|
_, _ = w.Write(body)
|
|
}
|
|
|
|
func writeImageError(w http.ResponseWriter, err error) {
|
|
if errors.Is(err, domainImage.ErrImageNotFound) {
|
|
http.Error(w, apperr.ImageNotFoundErrorMessage, http.StatusNotFound)
|
|
return
|
|
}
|
|
writeInternalServerError(w)
|
|
}
|
|
|
|
func parseImageId(w http.ResponseWriter, r *http.Request) (uint32, bool) {
|
|
id, err := strconv.ParseUint(chi.URLParam(r, "id"), 10, 32)
|
|
if err != nil {
|
|
http.Error(w, apperr.IdUint32ErrorMessage, http.StatusBadRequest)
|
|
return 0, false
|
|
}
|
|
return uint32(id), true
|
|
}
|
|
|
|
func dimension(value int) *int {
|
|
if value == 0 {
|
|
return nil
|
|
}
|
|
return &value
|
|
}
|
|
|
|
func toResponse(item useCases.MediaItem) mediaItemResponse {
|
|
return mediaItemResponse{
|
|
ID: item.Image.ID,
|
|
Filename: item.Image.Filename,
|
|
URL: item.Image.Path,
|
|
Size: item.Image.Size,
|
|
ContentType: item.Image.ContentType,
|
|
Width: dimension(item.Image.Width),
|
|
Height: dimension(item.Image.Height),
|
|
SHA256: item.Image.SHA256,
|
|
UploadedBy: item.UploadedBy,
|
|
CreatedAt: item.Image.CreatedAt,
|
|
UsedIn: item.UsedIn,
|
|
Duplicate: item.Duplicate,
|
|
}
|
|
}
|
|
|
|
func parseListQuery(r *http.Request) (domainImage.ListQuery, error) {
|
|
values, err := url.ParseQuery(r.URL.RawQuery)
|
|
if err != nil {
|
|
return domainImage.ListQuery{}, domainImage.ErrInvalidQuery
|
|
}
|
|
|
|
query := domainImage.NewListQuery()
|
|
query.Search = values.Get("q")
|
|
query.Hash = strings.ToLower(values.Get("hash"))
|
|
query.Cursor = values.Get("cursor")
|
|
if values.Has("filter") {
|
|
query.Filter = domainImage.Filter(values.Get("filter"))
|
|
}
|
|
if values.Has("sort") {
|
|
query.Sort = domainImage.Sort(values.Get("sort"))
|
|
}
|
|
if values.Has("limit") {
|
|
limit, err := strconv.Atoi(values.Get("limit"))
|
|
if err != nil {
|
|
return domainImage.ListQuery{}, domainImage.ErrInvalidQuery
|
|
}
|
|
query.Limit = limit
|
|
}
|
|
return query, nil
|
|
}
|
|
|
|
func (h *Handler) List(w http.ResponseWriter, r *http.Request) {
|
|
query, err := parseListQuery(r)
|
|
if err != nil {
|
|
http.Error(w, apperr.MediaQueryErrorMessage, http.StatusBadRequest)
|
|
return
|
|
}
|
|
|
|
page, err := h.ListUseCase.List(query)
|
|
if err != nil {
|
|
if errors.Is(err, domainImage.ErrInvalidQuery) {
|
|
http.Error(w, apperr.MediaQueryErrorMessage, http.StatusBadRequest)
|
|
return
|
|
}
|
|
writeInternalServerError(w)
|
|
return
|
|
}
|
|
|
|
items := make([]mediaItemResponse, 0, len(page.Items))
|
|
for _, item := range page.Items {
|
|
items = append(items, toResponse(item))
|
|
}
|
|
response := listResponse{
|
|
Items: items,
|
|
Counts: countsResponse{All: page.Counts.All, Unused: page.Counts.Unused, Duplicates: page.Counts.Duplicates},
|
|
}
|
|
if page.NextCursor != "" {
|
|
response.NextCursor = &page.NextCursor
|
|
}
|
|
writeJSON(w, http.StatusOK, response)
|
|
}
|
|
|
|
func (h *Handler) Upload(w http.ResponseWriter, r *http.Request) {
|
|
userId, _ := claims.UserId(r)
|
|
input, closeFile, ok := upload.ReadImageInput(w, r, userId)
|
|
if !ok {
|
|
return
|
|
}
|
|
defer closeFile()
|
|
|
|
created, err := h.CreateUseCase.CreateImage(r.Context(), input)
|
|
if err != nil {
|
|
upload.WriteCreateError(w, err)
|
|
return
|
|
}
|
|
|
|
h.writeItem(w, http.StatusCreated, created)
|
|
}
|
|
|
|
func (h *Handler) writeItem(w http.ResponseWriter, status int, img domainImage.Image) {
|
|
item, err := h.ListUseCase.Describe(img)
|
|
if err != nil {
|
|
writeInternalServerError(w)
|
|
return
|
|
}
|
|
writeJSON(w, status, toResponse(item))
|
|
}
|
|
|
|
func (h *Handler) Rename(w http.ResponseWriter, r *http.Request) {
|
|
id, ok := parseImageId(w, r)
|
|
if !ok {
|
|
return
|
|
}
|
|
|
|
var request RenameRequest
|
|
if err := json.NewDecoder(r.Body).Decode(&request); err != nil {
|
|
http.Error(w, apperr.BodyErrorMessage, http.StatusBadRequest)
|
|
return
|
|
}
|
|
if err := validator.Validate.Struct(request); err != nil {
|
|
http.Error(w, apperr.MediaFilenameErrorMessage, http.StatusBadRequest)
|
|
return
|
|
}
|
|
|
|
renamed, err := h.RenameUseCase.Rename(r.Context(), id, request.Filename)
|
|
if err != nil {
|
|
if errors.Is(err, domainImage.ErrInvalidFilename) {
|
|
http.Error(w, apperr.MediaFilenameErrorMessage, http.StatusBadRequest)
|
|
return
|
|
}
|
|
writeImageError(w, err)
|
|
return
|
|
}
|
|
|
|
h.writeItem(w, http.StatusOK, renamed)
|
|
}
|
|
|
|
func (h *Handler) Delete(w http.ResponseWriter, r *http.Request) {
|
|
id, ok := parseImageId(w, r)
|
|
if !ok {
|
|
return
|
|
}
|
|
|
|
if err := h.DeleteUseCase.Delete(r.Context(), id); err != nil {
|
|
writeImageError(w, err)
|
|
return
|
|
}
|
|
|
|
w.WriteHeader(http.StatusNoContent)
|
|
}
|
|
|
|
func (h *Handler) Usage(w http.ResponseWriter, r *http.Request) {
|
|
id, ok := parseImageId(w, r)
|
|
if !ok {
|
|
return
|
|
}
|
|
|
|
articles, err := h.UsageUseCase.Usage(id)
|
|
if err != nil {
|
|
writeImageError(w, err)
|
|
return
|
|
}
|
|
|
|
response := make([]usageResponse, 0, len(articles))
|
|
for _, a := range articles {
|
|
response = append(response, usageResponse{ID: a.ID, Title: a.Title, Published: a.IsOnline})
|
|
}
|
|
writeJSON(w, http.StatusOK, response)
|
|
}
|
|
|
|
func (h *Handler) Merge(w http.ResponseWriter, r *http.Request) {
|
|
var request MergeRequest
|
|
if err := json.NewDecoder(r.Body).Decode(&request); err != nil {
|
|
http.Error(w, apperr.MediaMergeRequestErrorMessage, http.StatusBadRequest)
|
|
return
|
|
}
|
|
if err := validator.Validate.Struct(request); err != nil {
|
|
http.Error(w, apperr.MediaMergeRequestErrorMessage, http.StatusBadRequest)
|
|
return
|
|
}
|
|
|
|
result, err := h.MergeUseCase.Merge(r.Context(), request.KeepID, request.MergeIDs)
|
|
if err != nil {
|
|
writeMergeError(w, err)
|
|
return
|
|
}
|
|
|
|
writeJSON(w, http.StatusOK, mergeResponse{ArticlesUpdated: result.ArticlesUpdated, Merged: result.Merged})
|
|
}
|
|
|
|
func writeMergeError(w http.ResponseWriter, err error) {
|
|
switch {
|
|
case errors.Is(err, domainImage.ErrInvalidMergeRequest):
|
|
http.Error(w, apperr.MediaMergeRequestErrorMessage, http.StatusBadRequest)
|
|
case errors.Is(err, domainImage.ErrMergeCopyMissing), errors.Is(err, domainImage.ErrMergeHashMismatch):
|
|
http.Error(w, apperr.MediaMergeConflictErrorMessage, http.StatusConflict)
|
|
default:
|
|
writeImageError(w, err)
|
|
}
|
|
}
|