-
Notifications
You must be signed in to change notification settings - Fork 38
/
uploads.go
86 lines (75 loc) · 3.16 KB
/
uploads.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
package ghcapi
import (
"github.com/go-openapi/runtime"
"github.com/go-openapi/runtime/middleware"
"github.com/gofrs/uuid"
"go.uber.org/zap"
"github.com/transcom/mymove/pkg/appcontext"
"github.com/transcom/mymove/pkg/apperror"
uploadop "github.com/transcom/mymove/pkg/gen/ghcapi/ghcoperations/uploads"
"github.com/transcom/mymove/pkg/handlers"
"github.com/transcom/mymove/pkg/handlers/ghcapi/internal/payloads"
"github.com/transcom/mymove/pkg/models"
uploaderpkg "github.com/transcom/mymove/pkg/uploader"
)
type CreateUploadHandler struct {
handlers.HandlerConfig
}
func (h CreateUploadHandler) Handle(params uploadop.CreateUploadParams) middleware.Responder {
return h.AuditableAppContextFromRequestWithErrors(params.HTTPRequest,
func(appCtx appcontext.AppContext) (middleware.Responder, error) {
rollbackErr := apperror.NewBadDataError("error creating upload")
file, ok := params.File.(*runtime.File)
if !ok {
appCtx.Logger().Error("This should always be a runtime.File, something has changed in go-swagger.")
return uploadop.NewCreateUploadInternalServerError(), rollbackErr
}
appCtx.Logger().Info(
"File uploader and size",
zap.String("userID", appCtx.Session().UserID.String()),
zap.String("serviceMemberID", appCtx.Session().ServiceMemberID.String()),
zap.String("officeUserID", appCtx.Session().OfficeUserID.String()),
zap.String("AdminUserID", appCtx.Session().AdminUserID.String()),
zap.Int64("size", file.Header.Size),
)
var docID *uuid.UUID
if params.DocumentID != nil {
documentID, err := uuid.FromString(params.DocumentID.String())
if err != nil {
appCtx.Logger().Info("Badly formed UUID for document", zap.String("document_id", params.DocumentID.String()), zap.Error(err))
return uploadop.NewCreateUploadBadRequest(), rollbackErr
}
// Fetch document to ensure user has access to it
document, docErr := models.FetchDocument(appCtx.DB(), appCtx.Session(), documentID, true)
if docErr != nil {
return handlers.ResponseForError(appCtx.Logger(), docErr), rollbackErr
}
docID = &document.ID
}
newUserUpload, url, verrs, createErr := uploaderpkg.CreateUserUploadForDocumentWrapper(
appCtx,
appCtx.Session().UserID,
h.FileStorer(),
file,
file.Header.Filename,
uploaderpkg.MaxCustomerUserUploadFileSizeLimit,
uploaderpkg.AllowedTypesServiceMember,
docID,
)
if verrs.HasAny() || createErr != nil {
appCtx.Logger().Error("failed to create new user upload", zap.Error(createErr), zap.String("verrs", verrs.Error()))
switch createErr.(type) {
case uploaderpkg.ErrTooLarge:
return uploadop.NewCreateUploadRequestEntityTooLarge(), rollbackErr
case uploaderpkg.ErrFile:
return uploadop.NewCreateUploadInternalServerError(), rollbackErr
case uploaderpkg.ErrFailedToInitUploader:
return uploadop.NewCreateUploadInternalServerError(), rollbackErr
default:
return handlers.ResponseForVErrors(appCtx.Logger(), verrs, createErr), rollbackErr
}
}
uploadPayload := payloads.PayloadForUploadModel(h.FileStorer(), newUserUpload.Upload, url)
return uploadop.NewCreateUploadCreated().WithPayload(uploadPayload), nil
})
}