/
documents.go
106 lines (85 loc) · 3.35 KB
/
documents.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
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
package internalapi
import (
"github.com/go-openapi/runtime/middleware"
"github.com/gofrs/uuid"
"go.uber.org/zap"
documentop "github.com/transcom/mymove/pkg/gen/internalapi/internaloperations/documents"
"github.com/transcom/mymove/pkg/gen/internalmessages"
"github.com/transcom/mymove/pkg/handlers"
"github.com/transcom/mymove/pkg/models"
"github.com/transcom/mymove/pkg/storage"
)
func payloadForDocumentModel(storer storage.FileStorer, document models.Document) (*internalmessages.DocumentPayload, error) {
uploads := make([]*internalmessages.UploadPayload, len(document.Uploads))
for i, upload := range document.Uploads {
url, err := storer.PresignedURL(upload.StorageKey, upload.ContentType)
if err != nil {
return nil, err
}
uploadPayload := payloadForUploadModel(upload, url)
uploads[i] = uploadPayload
}
documentPayload := &internalmessages.DocumentPayload{
ID: handlers.FmtUUID(document.ID),
ServiceMemberID: handlers.FmtUUID(document.ServiceMemberID),
Uploads: uploads,
}
return documentPayload, nil
}
// CreateDocumentHandler creates a new document via POST /documents/
type CreateDocumentHandler struct {
handlers.HandlerContext
}
// Handle creates a new Document from a request payload
func (h CreateDocumentHandler) Handle(params documentop.CreateDocumentParams) middleware.Responder {
ctx := params.HTTPRequest.Context()
session, logger := h.SessionAndLoggerFromRequest(params.HTTPRequest)
serviceMemberID, err := uuid.FromString(params.DocumentPayload.ServiceMemberID.String())
if err != nil {
return handlers.ResponseForError(logger, err)
}
// Fetch to check auth
serviceMember, err := models.FetchServiceMemberForUser(ctx, h.DB(), session, serviceMemberID)
if err != nil {
return handlers.ResponseForError(logger, err)
}
newDocument := models.Document{
ServiceMemberID: serviceMember.ID,
}
verrs, err := h.DB().ValidateAndCreate(&newDocument)
if err != nil {
logger.Info("DB Insertion", zap.Error(err))
return documentop.NewCreateDocumentInternalServerError()
} else if verrs.HasAny() {
logger.Error("Could not save document", zap.String("errors", verrs.Error()))
return documentop.NewCreateDocumentBadRequest()
}
logger.Info("created a document with id", zap.Any("new_document_id", newDocument.ID))
documentPayload, err := payloadForDocumentModel(h.FileStorer(), newDocument)
if err != nil {
return handlers.ResponseForError(logger, err)
}
return documentop.NewCreateDocumentCreated().WithPayload(documentPayload)
}
// ShowDocumentHandler shows a document via GETT /documents/:document_id
type ShowDocumentHandler struct {
handlers.HandlerContext
}
// Handle creates a new Document from a request payload
func (h ShowDocumentHandler) Handle(params documentop.ShowDocumentParams) middleware.Responder {
ctx := params.HTTPRequest.Context()
session, logger := h.SessionAndLoggerFromRequest(params.HTTPRequest)
documentID, err := uuid.FromString(params.DocumentID.String())
if err != nil {
return handlers.ResponseForError(logger, err)
}
document, err := models.FetchDocument(ctx, h.DB(), session, documentID, false)
if err != nil {
return handlers.ResponseForError(logger, err)
}
documentPayload, err := payloadForDocumentModel(h.FileStorer(), document)
if err != nil {
return handlers.ResponseForError(logger, err)
}
return documentop.NewShowDocumentOK().WithPayload(documentPayload)
}