forked from longtao.wu/droboticflow
497 lines
20 KiB
Go
497 lines
20 KiB
Go
package api
|
|
|
|
import (
|
|
"fmt"
|
|
"net/http"
|
|
"strings"
|
|
"time"
|
|
|
|
"droboticflow/internal/domain"
|
|
|
|
"github.com/go-chi/chi/v5"
|
|
)
|
|
|
|
const (
|
|
uploadSessionDirectThresholdBytes int64 = 100 * 1024 * 1024
|
|
uploadSessionActiveRetention = 7 * 24 * time.Hour
|
|
uploadSessionCompletedRetention = 30 * 24 * time.Hour
|
|
)
|
|
|
|
type objectStorageUploadSessionCreateInput struct {
|
|
Bucket string `json:"bucket"`
|
|
Prefix string `json:"prefix,omitempty"`
|
|
ConflictPolicy string `json:"conflictPolicy,omitempty"`
|
|
Items []objectStorageUploadSessionCreateItemInput `json:"items"`
|
|
}
|
|
|
|
type objectStorageUploadSessionCreateItemInput struct {
|
|
RelativePath string `json:"relativePath"`
|
|
Kind string `json:"kind"`
|
|
SizeBytes int64 `json:"sizeBytes,omitempty"`
|
|
ContentType string `json:"contentType,omitempty"`
|
|
LastModified int64 `json:"lastModified,omitempty"`
|
|
}
|
|
|
|
type objectStorageUploadSessionPartInput struct {
|
|
PartNumber int `json:"partNumber"`
|
|
ETag string `json:"eTag"`
|
|
UploadedBytes int64 `json:"uploadedBytes"`
|
|
}
|
|
|
|
type objectStorageUploadSessionPartURLInput struct {
|
|
PartNumber int `json:"partNumber"`
|
|
}
|
|
|
|
func uploadSessionExpiry(status domain.ObjectStorageUploadSessionStatus, now time.Time) string {
|
|
if status == domain.ObjectStorageUploadSessionCompleted || status == domain.ObjectStorageUploadSessionCancelled {
|
|
return now.Add(uploadSessionCompletedRetention).UTC().Format(time.RFC3339Nano)
|
|
}
|
|
return now.Add(uploadSessionActiveRetention).UTC().Format(time.RFC3339Nano)
|
|
}
|
|
|
|
func (server *server) ensureUploadSessionAccess(writer http.ResponseWriter, request *http.Request, session *domain.ObjectStorageUploadSessionRecord) (*authenticatedPrincipal, bool) {
|
|
principal, ok := currentPrincipal(request)
|
|
if !ok || principal == nil {
|
|
renderJSON(writer, http.StatusUnauthorized, map[string]string{"error": "login is required"})
|
|
return nil, false
|
|
}
|
|
if session == nil {
|
|
renderJSON(writer, http.StatusNotFound, map[string]string{"error": "upload session not found"})
|
|
return nil, false
|
|
}
|
|
if !server.ensureTenantAccess(writer, request, session.OrganizationID, "Upload session") {
|
|
return nil, false
|
|
}
|
|
if !isOrganizationAdmin(principal) && session.UserID != principal.User.ID {
|
|
renderJSON(writer, http.StatusForbidden, map[string]string{"error": "upload session access is restricted to its creator"})
|
|
return nil, false
|
|
}
|
|
return principal, true
|
|
}
|
|
|
|
func uploadSessionResponse(session domain.ObjectStorageUploadSessionRecord) domain.ObjectStorageUploadSessionSummary {
|
|
return domain.SummarizeObjectStorageUploadSession(session)
|
|
}
|
|
|
|
func uploadSessionRefreshStatus(session *domain.ObjectStorageUploadSessionRecord) {
|
|
if session == nil || session.Status == domain.ObjectStorageUploadSessionPaused || session.Status == domain.ObjectStorageUploadSessionCancelled {
|
|
return
|
|
}
|
|
allResolved := true
|
|
hasFailure := false
|
|
for _, item := range session.Items {
|
|
if item.Status == domain.ObjectStorageUploadItemFailed {
|
|
hasFailure = true
|
|
}
|
|
if item.Status != domain.ObjectStorageUploadItemSuccess && item.Status != domain.ObjectStorageUploadItemSkipped && item.Status != domain.ObjectStorageUploadItemCancelled {
|
|
allResolved = false
|
|
}
|
|
}
|
|
if allResolved && !hasFailure {
|
|
session.Status = domain.ObjectStorageUploadSessionCompleted
|
|
session.CompletedAt = nowISO()
|
|
} else if hasFailure {
|
|
session.Status = domain.ObjectStorageUploadSessionFailed
|
|
} else {
|
|
session.Status = domain.ObjectStorageUploadSessionRunning
|
|
}
|
|
}
|
|
|
|
func uploadSessionItem(session *domain.ObjectStorageUploadSessionRecord, itemID string) (*domain.ObjectStorageUploadItemRecord, int) {
|
|
if session == nil {
|
|
return nil, -1
|
|
}
|
|
for index := range session.Items {
|
|
if session.Items[index].ID == itemID {
|
|
return &session.Items[index], index
|
|
}
|
|
}
|
|
return nil, -1
|
|
}
|
|
|
|
func (server *server) saveUploadSession(request *http.Request, session *domain.ObjectStorageUploadSessionRecord) error {
|
|
if session == nil {
|
|
return fmt.Errorf("upload session is required")
|
|
}
|
|
session.Version++
|
|
session.UpdatedAt = nowISO()
|
|
session.ExpiresAt = uploadSessionExpiry(session.Status, time.Now())
|
|
return server.store.UpsertObjectStorageUploadSession(request.Context(), *session)
|
|
}
|
|
|
|
func (server *server) handleObjectStorageUploadSessionsList(writer http.ResponseWriter, request *http.Request) {
|
|
principal, ok := currentPrincipal(request)
|
|
if !ok || principal == nil {
|
|
renderJSON(writer, http.StatusUnauthorized, map[string]string{"error": "login is required"})
|
|
return
|
|
}
|
|
userID := principal.User.ID
|
|
if isOrganizationAdmin(principal) && strings.EqualFold(strings.TrimSpace(request.URL.Query().Get("all")), "true") {
|
|
userID = ""
|
|
}
|
|
items, err := server.store.ListObjectStorageUploadSessions(request.Context(), server.requestOrganizationID(request), userID)
|
|
if err != nil {
|
|
renderError(writer, http.StatusInternalServerError, err)
|
|
return
|
|
}
|
|
summaries := make([]domain.ObjectStorageUploadSessionSummary, 0, len(items))
|
|
for _, item := range items {
|
|
summaries = append(summaries, uploadSessionResponse(item))
|
|
}
|
|
renderJSON(writer, http.StatusOK, map[string]any{"items": summaries})
|
|
}
|
|
|
|
func (server *server) handleObjectStorageUploadSessionGet(writer http.ResponseWriter, request *http.Request) {
|
|
session, err := server.store.GetObjectStorageUploadSession(request.Context(), chi.URLParam(request, "sessionId"))
|
|
if err != nil {
|
|
renderError(writer, http.StatusInternalServerError, err)
|
|
return
|
|
}
|
|
if _, ok := server.ensureUploadSessionAccess(writer, request, session); !ok {
|
|
return
|
|
}
|
|
renderJSON(writer, http.StatusOK, uploadSessionResponse(*session))
|
|
}
|
|
|
|
func (server *server) handleObjectStorageUploadSessionCreate(writer http.ResponseWriter, request *http.Request) {
|
|
principal, ok := currentPrincipal(request)
|
|
if !ok || principal == nil {
|
|
renderJSON(writer, http.StatusUnauthorized, map[string]string{"error": "login is required"})
|
|
return
|
|
}
|
|
var payload objectStorageUploadSessionCreateInput
|
|
if !decodeJSON(writer, request, &payload) {
|
|
return
|
|
}
|
|
batchInput := domain.ObjectStorageBatchUploadPrepareInput{Bucket: payload.Bucket, Prefix: payload.Prefix, ConflictPolicy: payload.ConflictPolicy, Items: make([]domain.ObjectStorageBatchUploadItemInput, 0, len(payload.Items))}
|
|
for _, item := range payload.Items {
|
|
batchInput.Items = append(batchInput.Items, domain.ObjectStorageBatchUploadItemInput{RelativePath: item.RelativePath, Kind: item.Kind, SizeBytes: item.SizeBytes, ContentType: item.ContentType})
|
|
}
|
|
prepared, prefix, policy, issue := prepareObjectStorageBatchItems(batchInput)
|
|
if issue != nil {
|
|
renderValidationError(writer, *issue)
|
|
return
|
|
}
|
|
connectionID := strings.TrimSpace(request.URL.Query().Get("connectionId"))
|
|
browser, connection, cleanup, err := server.resolveObjectStorageBrowser(request.Context(), connectionID)
|
|
if cleanup != nil {
|
|
defer cleanup()
|
|
}
|
|
if err != nil {
|
|
renderError(writer, http.StatusInternalServerError, err)
|
|
return
|
|
}
|
|
if browser == nil || connection == nil {
|
|
renderValidationError(writer, validationIssue{Field: "connectionId", Message: "connectionId is required"})
|
|
return
|
|
}
|
|
bucket, err := resolveObjectStorageBucket(connection, payload.Bucket)
|
|
if err != nil || bucket == "" {
|
|
renderValidationError(writer, validationIssue{Field: "bucket", Message: "bucket is required"})
|
|
return
|
|
}
|
|
if err := inspectObjectStorageBatchConflicts(request.Context(), browser, bucket, prepared); err != nil {
|
|
renderObjectStorageWriteError(writer, err)
|
|
return
|
|
}
|
|
plan := finalizeObjectStorageBatchPlan(prepared, policy)
|
|
now := time.Now()
|
|
session := domain.ObjectStorageUploadSessionRecord{ID: domain.NewID("upload-session"), OrganizationID: server.requestOrganizationID(request), UserID: principal.User.ID, ConnectionID: connectionID, Bucket: bucket, Prefix: prefix, ConflictPolicy: policy, Status: domain.ObjectStorageUploadSessionPrepared, Version: 1, CreatedAt: now.UTC().Format(time.RFC3339Nano), ExpiresAt: uploadSessionExpiry(domain.ObjectStorageUploadSessionPrepared, now)}
|
|
for index, item := range plan.Items {
|
|
input := payload.Items[index]
|
|
status := domain.ObjectStorageUploadItemPending
|
|
if item.Action == "skip" {
|
|
status = domain.ObjectStorageUploadItemSkipped
|
|
}
|
|
if item.Action == "conflict" {
|
|
status = domain.ObjectStorageUploadItemFailed
|
|
}
|
|
session.Items = append(session.Items, domain.ObjectStorageUploadItemRecord{ID: domain.NewID("upload-item"), RelativePath: item.RelativePath, Key: item.Key, Kind: item.Kind, ContentType: item.ContentType, SizeBytes: item.SizeBytes, LastModified: input.LastModified, Action: item.Action, Status: status, Error: item.Message, UpdatedAt: session.CreatedAt})
|
|
}
|
|
uploadSessionRefreshStatus(&session)
|
|
if len(session.Items) > 0 && session.Status == domain.ObjectStorageUploadSessionCompleted {
|
|
session.CompletedAt = session.CreatedAt
|
|
}
|
|
if err := server.store.UpsertObjectStorageUploadSession(request.Context(), session); err != nil {
|
|
renderError(writer, http.StatusInternalServerError, err)
|
|
return
|
|
}
|
|
renderJSON(writer, http.StatusCreated, uploadSessionResponse(session))
|
|
}
|
|
|
|
func (server *server) mutateObjectStorageUploadSession(writer http.ResponseWriter, request *http.Request, target domain.ObjectStorageUploadSessionStatus) {
|
|
session, err := server.store.GetObjectStorageUploadSession(request.Context(), chi.URLParam(request, "sessionId"))
|
|
if err != nil {
|
|
renderError(writer, http.StatusInternalServerError, err)
|
|
return
|
|
}
|
|
if _, ok := server.ensureUploadSessionAccess(writer, request, session); !ok {
|
|
return
|
|
}
|
|
if target == domain.ObjectStorageUploadSessionCancelled {
|
|
browser, _, cleanup, resolveErr := server.resolveObjectStorageBrowser(request.Context(), session.ConnectionID)
|
|
if cleanup != nil {
|
|
defer cleanup()
|
|
}
|
|
if resolveErr != nil {
|
|
renderError(writer, http.StatusInternalServerError, resolveErr)
|
|
return
|
|
}
|
|
for index := range session.Items {
|
|
item := &session.Items[index]
|
|
if item.Status == domain.ObjectStorageUploadItemSuccess || item.Status == domain.ObjectStorageUploadItemSkipped {
|
|
continue
|
|
}
|
|
if browser != nil && item.UploadID != "" {
|
|
_ = browser.AbortMultipartUpload(request.Context(), session.Bucket, item.Key, item.UploadID)
|
|
}
|
|
item.Status = domain.ObjectStorageUploadItemCancelled
|
|
item.UpdatedAt = nowISO()
|
|
}
|
|
session.CancelledAt = nowISO()
|
|
}
|
|
if target == domain.ObjectStorageUploadSessionRunning && session.Status != domain.ObjectStorageUploadSessionPaused && session.Status != domain.ObjectStorageUploadSessionFailed && session.Status != domain.ObjectStorageUploadSessionPrepared {
|
|
renderJSON(writer, http.StatusConflict, map[string]string{"error": "upload session cannot be resumed from its current state"})
|
|
return
|
|
}
|
|
session.Status = target
|
|
if err := server.saveUploadSession(request, session); err != nil {
|
|
renderError(writer, http.StatusInternalServerError, err)
|
|
return
|
|
}
|
|
renderJSON(writer, http.StatusOK, uploadSessionResponse(*session))
|
|
}
|
|
|
|
func (server *server) handleObjectStorageUploadSessionPause(writer http.ResponseWriter, request *http.Request) {
|
|
server.mutateObjectStorageUploadSession(writer, request, domain.ObjectStorageUploadSessionPaused)
|
|
}
|
|
func (server *server) handleObjectStorageUploadSessionResume(writer http.ResponseWriter, request *http.Request) {
|
|
server.mutateObjectStorageUploadSession(writer, request, domain.ObjectStorageUploadSessionRunning)
|
|
}
|
|
func (server *server) handleObjectStorageUploadSessionCancel(writer http.ResponseWriter, request *http.Request) {
|
|
server.mutateObjectStorageUploadSession(writer, request, domain.ObjectStorageUploadSessionCancelled)
|
|
}
|
|
|
|
func (server *server) loadUploadSessionItem(writer http.ResponseWriter, request *http.Request) (*domain.ObjectStorageUploadSessionRecord, *domain.ObjectStorageUploadItemRecord, bool) {
|
|
session, err := server.store.GetObjectStorageUploadSession(request.Context(), chi.URLParam(request, "sessionId"))
|
|
if err != nil {
|
|
renderError(writer, http.StatusInternalServerError, err)
|
|
return nil, nil, false
|
|
}
|
|
if _, ok := server.ensureUploadSessionAccess(writer, request, session); !ok {
|
|
return nil, nil, false
|
|
}
|
|
item, _ := uploadSessionItem(session, chi.URLParam(request, "itemId"))
|
|
if item == nil {
|
|
renderJSON(writer, http.StatusNotFound, map[string]string{"error": "upload item not found"})
|
|
return nil, nil, false
|
|
}
|
|
return session, item, true
|
|
}
|
|
|
|
func (server *server) handleObjectStorageUploadSessionItemStart(writer http.ResponseWriter, request *http.Request) {
|
|
session, item, ok := server.loadUploadSessionItem(writer, request)
|
|
if !ok {
|
|
return
|
|
}
|
|
if session.Status == domain.ObjectStorageUploadSessionPaused || session.Status == domain.ObjectStorageUploadSessionCancelled || session.Status == domain.ObjectStorageUploadSessionCompleted {
|
|
renderJSON(writer, http.StatusConflict, map[string]string{"error": "upload session is not runnable"})
|
|
return
|
|
}
|
|
if item.Status == domain.ObjectStorageUploadItemSkipped || item.Status == domain.ObjectStorageUploadItemSuccess {
|
|
renderJSON(writer, http.StatusOK, uploadSessionResponse(*session))
|
|
return
|
|
}
|
|
browser, _, cleanup, err := server.resolveObjectStorageBrowser(request.Context(), session.ConnectionID)
|
|
if cleanup != nil {
|
|
defer cleanup()
|
|
}
|
|
if err != nil || browser == nil {
|
|
if err != nil {
|
|
renderError(writer, http.StatusInternalServerError, err)
|
|
} else {
|
|
renderJSON(writer, http.StatusBadRequest, map[string]string{"error": "storage connection unavailable"})
|
|
}
|
|
return
|
|
}
|
|
if item.Kind == "directory" {
|
|
result, putErr := browser.PutObject(request.Context(), session.Bucket, item.Key, []byte{}, "application/x-directory")
|
|
if putErr != nil {
|
|
renderObjectStorageWriteError(writer, putErr)
|
|
return
|
|
}
|
|
item.Status, item.UploadedBytes, item.ETag, item.UpdatedAt = domain.ObjectStorageUploadItemSuccess, 0, result.ETag, nowISO()
|
|
uploadSessionRefreshStatus(session)
|
|
if err := server.saveUploadSession(request, session); err != nil {
|
|
renderError(writer, http.StatusInternalServerError, err)
|
|
return
|
|
}
|
|
renderJSON(writer, http.StatusOK, uploadSessionResponse(*session))
|
|
return
|
|
}
|
|
session.Status = domain.ObjectStorageUploadSessionRunning
|
|
item.Status, item.Error, item.UpdatedAt = domain.ObjectStorageUploadItemUploading, "", nowISO()
|
|
if item.SizeBytes >= uploadSessionDirectThresholdBytes {
|
|
if item.UploadID == "" {
|
|
initiated, initiateErr := browser.InitiateMultipartUpload(request.Context(), session.Bucket, item.Key, item.ContentType, objectStoragePresignDefaultExpires)
|
|
if initiateErr != nil {
|
|
renderObjectStorageWriteError(writer, initiateErr)
|
|
return
|
|
}
|
|
item.UploadID, item.Mode = initiated.UploadID, "multipart"
|
|
}
|
|
if err := server.saveUploadSession(request, session); err != nil {
|
|
renderError(writer, http.StatusInternalServerError, err)
|
|
return
|
|
}
|
|
renderJSON(writer, http.StatusOK, map[string]any{"session": uploadSessionResponse(*session), "mode": "multipart", "uploadId": item.UploadID})
|
|
return
|
|
}
|
|
presigned, presignErr := browser.PresignPutObject(request.Context(), session.Bucket, item.Key, item.ContentType, objectStoragePresignDefaultExpires)
|
|
if presignErr != nil {
|
|
renderObjectStorageWriteError(writer, presignErr)
|
|
return
|
|
}
|
|
item.Mode = "direct"
|
|
if err := server.saveUploadSession(request, session); err != nil {
|
|
renderError(writer, http.StatusInternalServerError, err)
|
|
return
|
|
}
|
|
renderJSON(writer, http.StatusOK, map[string]any{"session": uploadSessionResponse(*session), "mode": "direct", "upload": presigned})
|
|
}
|
|
|
|
func (server *server) handleObjectStorageUploadSessionPartURL(writer http.ResponseWriter, request *http.Request) {
|
|
session, item, ok := server.loadUploadSessionItem(writer, request)
|
|
if !ok {
|
|
return
|
|
}
|
|
if session.Status != domain.ObjectStorageUploadSessionRunning || item.UploadID == "" {
|
|
renderJSON(writer, http.StatusConflict, map[string]string{"error": "multipart upload is not running"})
|
|
return
|
|
}
|
|
var payload objectStorageUploadSessionPartURLInput
|
|
if !decodeJSON(writer, request, &payload) {
|
|
return
|
|
}
|
|
if payload.PartNumber < 1 || payload.PartNumber > 10000 {
|
|
renderValidationError(writer, validationIssue{Field: "partNumber", Message: "partNumber must be between 1 and 10000"})
|
|
return
|
|
}
|
|
browser, _, cleanup, err := server.resolveObjectStorageBrowser(request.Context(), session.ConnectionID)
|
|
if cleanup != nil {
|
|
defer cleanup()
|
|
}
|
|
if err != nil || browser == nil {
|
|
if err != nil {
|
|
renderError(writer, http.StatusInternalServerError, err)
|
|
} else {
|
|
renderJSON(writer, http.StatusBadRequest, map[string]string{"error": "storage connection unavailable"})
|
|
}
|
|
return
|
|
}
|
|
result, err := browser.PresignMultipartUploadPart(request.Context(), session.Bucket, item.Key, item.UploadID, payload.PartNumber, objectStoragePresignDefaultExpires)
|
|
if err != nil {
|
|
renderObjectStorageWriteError(writer, err)
|
|
return
|
|
}
|
|
renderJSON(writer, http.StatusOK, result)
|
|
}
|
|
|
|
func (server *server) handleObjectStorageUploadSessionPartComplete(writer http.ResponseWriter, request *http.Request) {
|
|
session, item, ok := server.loadUploadSessionItem(writer, request)
|
|
if !ok {
|
|
return
|
|
}
|
|
var payload objectStorageUploadSessionPartInput
|
|
if !decodeJSON(writer, request, &payload) {
|
|
return
|
|
}
|
|
parts := append([]domain.ObjectStorageMultipartUploadPart(nil), item.UploadedParts...)
|
|
parts = append(parts, domain.ObjectStorageMultipartUploadPart{PartNumber: payload.PartNumber, ETag: strings.Trim(payload.ETag, `"`)})
|
|
normalized, err := normalizeObjectStorageMultipartParts(parts)
|
|
if err != nil {
|
|
renderValidationError(writer, validationIssue{Field: "part", Message: err.Error()})
|
|
return
|
|
}
|
|
item.UploadedParts = normalized
|
|
if payload.UploadedBytes > item.UploadedBytes {
|
|
item.UploadedBytes = payload.UploadedBytes
|
|
}
|
|
item.UpdatedAt = nowISO()
|
|
if err := server.saveUploadSession(request, session); err != nil {
|
|
renderError(writer, http.StatusInternalServerError, err)
|
|
return
|
|
}
|
|
renderJSON(writer, http.StatusOK, uploadSessionResponse(*session))
|
|
}
|
|
|
|
func (server *server) handleObjectStorageUploadSessionItemComplete(writer http.ResponseWriter, request *http.Request) {
|
|
session, item, ok := server.loadUploadSessionItem(writer, request)
|
|
if !ok {
|
|
return
|
|
}
|
|
browser, _, cleanup, err := server.resolveObjectStorageBrowser(request.Context(), session.ConnectionID)
|
|
if cleanup != nil {
|
|
defer cleanup()
|
|
}
|
|
if err != nil || browser == nil {
|
|
if err != nil {
|
|
renderError(writer, http.StatusInternalServerError, err)
|
|
} else {
|
|
renderJSON(writer, http.StatusBadRequest, map[string]string{"error": "storage connection unavailable"})
|
|
}
|
|
return
|
|
}
|
|
if item.Mode == "multipart" {
|
|
parts, partsErr := normalizeObjectStorageMultipartParts(item.UploadedParts)
|
|
if partsErr != nil {
|
|
renderValidationError(writer, validationIssue{Field: "parts", Message: partsErr.Error()})
|
|
return
|
|
}
|
|
result, completeErr := browser.CompleteMultipartUpload(request.Context(), session.Bucket, item.Key, item.UploadID, parts)
|
|
if completeErr != nil {
|
|
renderObjectStorageWriteError(writer, completeErr)
|
|
return
|
|
}
|
|
item.ETag = result.ETag
|
|
} else {
|
|
result, summaryErr := browser.GetObjectSummary(request.Context(), session.Bucket, item.Key)
|
|
if summaryErr != nil {
|
|
renderObjectStorageWriteError(writer, summaryErr)
|
|
return
|
|
}
|
|
if result.SizeBytes != item.SizeBytes {
|
|
renderJSON(writer, http.StatusConflict, map[string]string{"error": "uploaded object size does not match the selected file"})
|
|
return
|
|
}
|
|
item.ETag = result.ETag
|
|
}
|
|
item.Status, item.UploadedBytes, item.Error, item.UpdatedAt = domain.ObjectStorageUploadItemSuccess, item.SizeBytes, "", nowISO()
|
|
uploadSessionRefreshStatus(session)
|
|
if err := server.saveUploadSession(request, session); err != nil {
|
|
renderError(writer, http.StatusInternalServerError, err)
|
|
return
|
|
}
|
|
renderJSON(writer, http.StatusOK, uploadSessionResponse(*session))
|
|
}
|
|
|
|
func (server *server) handleObjectStorageUploadSessionItemFailure(writer http.ResponseWriter, request *http.Request) {
|
|
session, item, ok := server.loadUploadSessionItem(writer, request)
|
|
if !ok {
|
|
return
|
|
}
|
|
var payload struct {
|
|
Error string `json:"error"`
|
|
}
|
|
if !decodeJSON(writer, request, &payload) {
|
|
return
|
|
}
|
|
item.Status, item.Error, item.UpdatedAt = domain.ObjectStorageUploadItemFailed, strings.TrimSpace(payload.Error), nowISO()
|
|
uploadSessionRefreshStatus(session)
|
|
if err := server.saveUploadSession(request, session); err != nil {
|
|
renderError(writer, http.StatusInternalServerError, err)
|
|
return
|
|
}
|
|
renderJSON(writer, http.StatusOK, uploadSessionResponse(*session))
|
|
}
|