From f758b0dbd4f68eb90c5ec6ce08e7f4fec1fbd458 Mon Sep 17 00:00:00 2001 From: Bryan Frimin Date: Thu, 10 Jul 2025 12:12:44 +0200 Subject: [PATCH] Add bulk publish document version Signed-off-by: Bryan Frimin --- pkg/probo/document_service.go | 149 ++++--- pkg/server/api/console/v1/schema.graphql | 13 + pkg/server/api/console/v1/schema/schema.go | 365 ++++++++++++++++++ pkg/server/api/console/v1/types/document.go | 10 + .../api/console/v1/types/document_version.go | 10 + pkg/server/api/console/v1/types/types.go | 10 + pkg/server/api/console/v1/v1_resolver.go | 28 ++ 7 files changed, 538 insertions(+), 47 deletions(-) diff --git a/pkg/probo/document_service.go b/pkg/probo/document_service.go index faccd64d3..de6e8c8ee 100644 --- a/pkg/probo/document_service.go +++ b/pkg/probo/document_service.go @@ -139,61 +139,26 @@ func (s DocumentService) GenerateChangelog( return changelog, nil } -func (s *DocumentService) PublishVersion( +func (s *DocumentService) BulkPublishVersions( ctx context.Context, - documentID gid.GID, + documentIds []gid.GID, publishedBy gid.GID, - changelog *string, -) (*coredata.Document, *coredata.DocumentVersion, error) { - document := &coredata.Document{} - documentVersion := &coredata.DocumentVersion{} - publishedVersion := &coredata.DocumentVersion{} - now := time.Now() + changelog string, +) ([]*coredata.DocumentVersion, []*coredata.Document, error) { + var publishedVersions []*coredata.DocumentVersion + var updatedDocuments []*coredata.Document err := s.svc.pg.WithTx( ctx, func(tx pg.Conn) error { - if err := document.LoadByID(ctx, tx, s.svc.scope, documentID); err != nil { - return fmt.Errorf("cannot load document %q: %w", documentID, err) - } - - if err := documentVersion.LoadLatestVersion(ctx, tx, s.svc.scope, documentID); err != nil { - return fmt.Errorf("cannot load current draft: %w", err) - } - - if documentVersion.Status != coredata.DocumentStatusDraft { - return fmt.Errorf("cannot publish version") - } - - if document.CurrentPublishedVersion != nil { - if err := publishedVersion.LoadByDocumentIDAndVersionNumber(ctx, tx, s.svc.scope, documentID, *document.CurrentPublishedVersion); err != nil { - return fmt.Errorf("cannot load published version: %w", err) + for _, documentID := range documentIds { + document, version, err := s.publishVersionInTx(ctx, tx, documentID, publishedBy, &changelog) + if err != nil { + return fmt.Errorf("cannot publish document %q: %w", documentID, err) } - if publishedVersion.Content == documentVersion.Content && - publishedVersion.Title == documentVersion.Title && - publishedVersion.OwnerID == documentVersion.OwnerID { - return fmt.Errorf("cannot publish version: no changes detected") - } - } - if changelog != nil { - documentVersion.Changelog = *changelog - } - - document.CurrentPublishedVersion = &documentVersion.VersionNumber - document.UpdatedAt = now - - documentVersion.Status = coredata.DocumentStatusPublished - documentVersion.PublishedAt = &now - documentVersion.PublishedBy = &publishedBy - documentVersion.UpdatedAt = now - - if err := document.Update(ctx, tx, s.svc.scope); err != nil { - return fmt.Errorf("cannot update document: %w", err) - } - - if err := documentVersion.Update(ctx, tx, s.svc.scope); err != nil { - return fmt.Errorf("cannot update document version: %w", err) + publishedVersions = append(publishedVersions, version) + updatedDocuments = append(updatedDocuments, document) } return nil @@ -204,6 +169,96 @@ func (s *DocumentService) PublishVersion( return nil, nil, err } + return publishedVersions, updatedDocuments, nil +} + +func (s *DocumentService) PublishVersion( + ctx context.Context, + documentID gid.GID, + publishedBy gid.GID, + changelog *string, +) (*coredata.Document, *coredata.DocumentVersion, error) { + var document *coredata.Document + var documentVersion *coredata.DocumentVersion + + err := s.svc.pg.WithTx( + ctx, + func(tx pg.Conn) error { + var err error + document, documentVersion, err = s.publishVersionInTx(ctx, tx, documentID, publishedBy, changelog) + return err + }, + ) + + if err != nil { + return nil, nil, err + } + + return document, documentVersion, nil +} + +func (s *DocumentService) publishVersionInTx( + ctx context.Context, + tx pg.Conn, + documentID gid.GID, + publishedBy gid.GID, + changelog *string, +) (*coredata.Document, *coredata.DocumentVersion, error) { + document := &coredata.Document{} + documentVersion := &coredata.DocumentVersion{} + publishedVersion := &coredata.DocumentVersion{} + people := &coredata.People{} + now := time.Now() + + if err := people.LoadByID(ctx, tx, s.svc.scope, publishedBy); err != nil { + return nil, nil, fmt.Errorf("cannot load people: %w", err) + } + + if err := document.LoadByID(ctx, tx, s.svc.scope, documentID); err != nil { + return nil, nil, fmt.Errorf("cannot load document %q: %w", documentID, err) + } + + if err := documentVersion.LoadLatestVersion(ctx, tx, s.svc.scope, documentID); err != nil { + return nil, nil, fmt.Errorf("cannot load current draft: %w", err) + } + + if documentVersion.Status != coredata.DocumentStatusDraft { + return nil, nil, fmt.Errorf("cannot publish version") + } + + if document.CurrentPublishedVersion != nil { + if err := publishedVersion.LoadByDocumentIDAndVersionNumber(ctx, tx, s.svc.scope, documentID, *document.CurrentPublishedVersion); err != nil { + return nil, nil, fmt.Errorf("cannot load published version: %w", err) + } + if publishedVersion.Content == documentVersion.Content && + publishedVersion.Title == documentVersion.Title && + publishedVersion.OwnerID == documentVersion.OwnerID { + return nil, nil, fmt.Errorf("cannot publish version: no changes detected") + } + } + + if changelog != nil { + documentVersion.Changelog = *changelog + } + + document.CurrentPublishedVersion = &documentVersion.VersionNumber + document.UpdatedAt = now + + documentVersion.Status = coredata.DocumentStatusPublished + documentVersion.PublishedAt = &now + if publishedBy != gid.Nil { + documentVersion.PublishedBy = &people.ID + } + documentVersion.UpdatedAt = now + + if err := document.Update(ctx, tx, s.svc.scope); err != nil { + return nil, nil, fmt.Errorf("cannot update document: %w", err) + } + + if err := documentVersion.Update(ctx, tx, s.svc.scope); err != nil { + return nil, nil, fmt.Errorf("cannot update document version: %w", err) + } + return document, documentVersion, nil } diff --git a/pkg/server/api/console/v1/schema.graphql b/pkg/server/api/console/v1/schema.graphql index 76b9cbd93..848d2269d 100644 --- a/pkg/server/api/console/v1/schema.graphql +++ b/pkg/server/api/console/v1/schema.graphql @@ -1384,6 +1384,9 @@ type Mutation { publishDocumentVersion( input: PublishDocumentVersionInput! ): PublishDocumentVersionPayload! + bulkPublishDocumentVersions( + input: BulkPublishDocumentVersionsInput! + ): BulkPublishDocumentVersionsPayload! generateDocumentChangelog( input: GenerateDocumentChangelogInput! ): GenerateDocumentChangelogPayload! @@ -2099,6 +2102,16 @@ type RequestSignaturePayload { documentVersionSignatureEdge: DocumentVersionSignatureEdge! } +input BulkPublishDocumentVersionsInput { + documentIds: [ID!]! + changelog: String! +} + +type BulkPublishDocumentVersionsPayload { + documentVersionEdges: [DocumentVersionEdge!]! + documentEdges: [DocumentEdge!]! +} + input PublishDocumentVersionInput { documentId: ID! changelog: String diff --git a/pkg/server/api/console/v1/schema/schema.go b/pkg/server/api/console/v1/schema/schema.go index 172acdf92..368d4b763 100644 --- a/pkg/server/api/console/v1/schema/schema.go +++ b/pkg/server/api/console/v1/schema/schema.go @@ -111,6 +111,11 @@ type ComplexityRoot struct { Task func(childComplexity int) int } + BulkPublishDocumentVersionsPayload struct { + DocumentEdges func(childComplexity int) int + DocumentVersionEdges func(childComplexity int) int + } + CancelSignatureRequestPayload struct { DeletedDocumentVersionSignatureID func(childComplexity int) int } @@ -508,6 +513,7 @@ type ComplexityRoot struct { Mutation struct { AssessVendor func(childComplexity int, input types.AssessVendorInput) int AssignTask func(childComplexity int, input types.AssignTaskInput) int + BulkPublishDocumentVersions func(childComplexity int, input types.BulkPublishDocumentVersionsInput) int CancelSignatureRequest func(childComplexity int, input types.CancelSignatureRequestInput) int ConfirmEmail func(childComplexity int, input types.ConfirmEmailInput) int CreateAsset func(childComplexity int, input types.CreateAssetInput) int @@ -1024,6 +1030,7 @@ type MutationResolver interface { UpdateDocument(ctx context.Context, input types.UpdateDocumentInput) (*types.UpdateDocumentPayload, error) DeleteDocument(ctx context.Context, input types.DeleteDocumentInput) (*types.DeleteDocumentPayload, error) PublishDocumentVersion(ctx context.Context, input types.PublishDocumentVersionInput) (*types.PublishDocumentVersionPayload, error) + BulkPublishDocumentVersions(ctx context.Context, input types.BulkPublishDocumentVersionsInput) (*types.BulkPublishDocumentVersionsPayload, error) GenerateDocumentChangelog(ctx context.Context, input types.GenerateDocumentChangelogInput) (*types.GenerateDocumentChangelogPayload, error) CreateDraftDocumentVersion(ctx context.Context, input types.CreateDraftDocumentVersionInput) (*types.CreateDraftDocumentVersionPayload, error) UpdateDocumentVersion(ctx context.Context, input types.UpdateDocumentVersionInput) (*types.UpdateDocumentVersionPayload, error) @@ -1259,6 +1266,20 @@ func (e *executableSchema) Complexity(ctx context.Context, typeName, field strin return e.complexity.AssignTaskPayload.Task(childComplexity), true + case "BulkPublishDocumentVersionsPayload.documentEdges": + if e.complexity.BulkPublishDocumentVersionsPayload.DocumentEdges == nil { + break + } + + return e.complexity.BulkPublishDocumentVersionsPayload.DocumentEdges(childComplexity), true + + case "BulkPublishDocumentVersionsPayload.documentVersionEdges": + if e.complexity.BulkPublishDocumentVersionsPayload.DocumentVersionEdges == nil { + break + } + + return e.complexity.BulkPublishDocumentVersionsPayload.DocumentVersionEdges(childComplexity), true + case "CancelSignatureRequestPayload.deletedDocumentVersionSignatureId": if e.complexity.CancelSignatureRequestPayload.DeletedDocumentVersionSignatureID == nil { break @@ -2605,6 +2626,18 @@ func (e *executableSchema) Complexity(ctx context.Context, typeName, field strin return e.complexity.Mutation.AssignTask(childComplexity, args["input"].(types.AssignTaskInput)), true + case "Mutation.bulkPublishDocumentVersions": + if e.complexity.Mutation.BulkPublishDocumentVersions == nil { + break + } + + args, err := ec.field_Mutation_bulkPublishDocumentVersions_args(ctx, rawArgs) + if err != nil { + return 0, false + } + + return e.complexity.Mutation.BulkPublishDocumentVersions(childComplexity, args["input"].(types.BulkPublishDocumentVersionsInput)), true + case "Mutation.cancelSignatureRequest": if e.complexity.Mutation.CancelSignatureRequest == nil { break @@ -4721,6 +4754,7 @@ func (e *executableSchema) Exec(ctx context.Context) graphql.ResponseHandler { ec.unmarshalInputAssessVendorInput, ec.unmarshalInputAssetOrder, ec.unmarshalInputAssignTaskInput, + ec.unmarshalInputBulkPublishDocumentVersionsInput, ec.unmarshalInputCancelSignatureRequestInput, ec.unmarshalInputConfirmEmailInput, ec.unmarshalInputConnectorOrder, @@ -6291,6 +6325,9 @@ type Mutation { publishDocumentVersion( input: PublishDocumentVersionInput! ): PublishDocumentVersionPayload! + bulkPublishDocumentVersions( + input: BulkPublishDocumentVersionsInput! + ): BulkPublishDocumentVersionsPayload! generateDocumentChangelog( input: GenerateDocumentChangelogInput! ): GenerateDocumentChangelogPayload! @@ -7006,6 +7043,16 @@ type RequestSignaturePayload { documentVersionSignatureEdge: DocumentVersionSignatureEdge! } +input BulkPublishDocumentVersionsInput { + documentIds: [ID!]! + changelog: String! +} + +type BulkPublishDocumentVersionsPayload { + documentVersionEdges: [DocumentVersionEdge!]! + documentEdges: [DocumentEdge!]! +} + input PublishDocumentVersionInput { documentId: ID! changelog: String @@ -8548,6 +8595,29 @@ func (ec *executionContext) field_Mutation_assignTask_argsInput( return zeroVal, nil } +func (ec *executionContext) field_Mutation_bulkPublishDocumentVersions_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) { + var err error + args := map[string]any{} + arg0, err := ec.field_Mutation_bulkPublishDocumentVersions_argsInput(ctx, rawArgs) + if err != nil { + return nil, err + } + args["input"] = arg0 + return args, nil +} +func (ec *executionContext) field_Mutation_bulkPublishDocumentVersions_argsInput( + ctx context.Context, + rawArgs map[string]any, +) (types.BulkPublishDocumentVersionsInput, error) { + ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("input")) + if tmp, ok := rawArgs["input"]; ok { + return ec.unmarshalNBulkPublishDocumentVersionsInput2githubᚗcomᚋgetproboᚋproboᚋpkgᚋserverᚋapiᚋconsoleᚋv1ᚋtypesᚐBulkPublishDocumentVersionsInput(ctx, tmp) + } + + var zeroVal types.BulkPublishDocumentVersionsInput + return zeroVal, nil +} + func (ec *executionContext) field_Mutation_cancelSignatureRequest_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) { var err error args := map[string]any{} @@ -13105,6 +13175,106 @@ func (ec *executionContext) fieldContext_AssignTaskPayload_task(_ context.Contex return fc, nil } +func (ec *executionContext) _BulkPublishDocumentVersionsPayload_documentVersionEdges(ctx context.Context, field graphql.CollectedField, obj *types.BulkPublishDocumentVersionsPayload) (ret graphql.Marshaler) { + fc, err := ec.fieldContext_BulkPublishDocumentVersionsPayload_documentVersionEdges(ctx, field) + if err != nil { + return graphql.Null + } + ctx = graphql.WithFieldContext(ctx, fc) + defer func() { + if r := recover(); r != nil { + ec.Error(ctx, ec.Recover(ctx, r)) + ret = graphql.Null + } + }() + resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) { + ctx = rctx // use context from middleware stack in children + return obj.DocumentVersionEdges, nil + }) + if err != nil { + ec.Error(ctx, err) + return graphql.Null + } + if resTmp == nil { + if !graphql.HasFieldError(ctx, fc) { + ec.Errorf(ctx, "must not be null") + } + return graphql.Null + } + res := resTmp.([]*types.DocumentVersionEdge) + fc.Result = res + return ec.marshalNDocumentVersionEdge2ᚕᚖgithubᚗcomᚋgetproboᚋproboᚋpkgᚋserverᚋapiᚋconsoleᚋv1ᚋtypesᚐDocumentVersionEdgeᚄ(ctx, field.Selections, res) +} + +func (ec *executionContext) fieldContext_BulkPublishDocumentVersionsPayload_documentVersionEdges(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "BulkPublishDocumentVersionsPayload", + Field: field, + IsMethod: false, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + switch field.Name { + case "cursor": + return ec.fieldContext_DocumentVersionEdge_cursor(ctx, field) + case "node": + return ec.fieldContext_DocumentVersionEdge_node(ctx, field) + } + return nil, fmt.Errorf("no field named %q was found under type DocumentVersionEdge", field.Name) + }, + } + return fc, nil +} + +func (ec *executionContext) _BulkPublishDocumentVersionsPayload_documentEdges(ctx context.Context, field graphql.CollectedField, obj *types.BulkPublishDocumentVersionsPayload) (ret graphql.Marshaler) { + fc, err := ec.fieldContext_BulkPublishDocumentVersionsPayload_documentEdges(ctx, field) + if err != nil { + return graphql.Null + } + ctx = graphql.WithFieldContext(ctx, fc) + defer func() { + if r := recover(); r != nil { + ec.Error(ctx, ec.Recover(ctx, r)) + ret = graphql.Null + } + }() + resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) { + ctx = rctx // use context from middleware stack in children + return obj.DocumentEdges, nil + }) + if err != nil { + ec.Error(ctx, err) + return graphql.Null + } + if resTmp == nil { + if !graphql.HasFieldError(ctx, fc) { + ec.Errorf(ctx, "must not be null") + } + return graphql.Null + } + res := resTmp.([]*types.DocumentEdge) + fc.Result = res + return ec.marshalNDocumentEdge2ᚕᚖgithubᚗcomᚋgetproboᚋproboᚋpkgᚋserverᚋapiᚋconsoleᚋv1ᚋtypesᚐDocumentEdgeᚄ(ctx, field.Selections, res) +} + +func (ec *executionContext) fieldContext_BulkPublishDocumentVersionsPayload_documentEdges(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "BulkPublishDocumentVersionsPayload", + Field: field, + IsMethod: false, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + switch field.Name { + case "cursor": + return ec.fieldContext_DocumentEdge_cursor(ctx, field) + case "node": + return ec.fieldContext_DocumentEdge_node(ctx, field) + } + return nil, fmt.Errorf("no field named %q was found under type DocumentEdge", field.Name) + }, + } + return fc, nil +} + func (ec *executionContext) _CancelSignatureRequestPayload_deletedDocumentVersionSignatureId(ctx context.Context, field graphql.CollectedField, obj *types.CancelSignatureRequestPayload) (ret graphql.Marshaler) { fc, err := ec.fieldContext_CancelSignatureRequestPayload_deletedDocumentVersionSignatureId(ctx, field) if err != nil { @@ -25071,6 +25241,67 @@ func (ec *executionContext) fieldContext_Mutation_publishDocumentVersion(ctx con return fc, nil } +func (ec *executionContext) _Mutation_bulkPublishDocumentVersions(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { + fc, err := ec.fieldContext_Mutation_bulkPublishDocumentVersions(ctx, field) + if err != nil { + return graphql.Null + } + ctx = graphql.WithFieldContext(ctx, fc) + defer func() { + if r := recover(); r != nil { + ec.Error(ctx, ec.Recover(ctx, r)) + ret = graphql.Null + } + }() + resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) { + ctx = rctx // use context from middleware stack in children + return ec.resolvers.Mutation().BulkPublishDocumentVersions(rctx, fc.Args["input"].(types.BulkPublishDocumentVersionsInput)) + }) + if err != nil { + ec.Error(ctx, err) + return graphql.Null + } + if resTmp == nil { + if !graphql.HasFieldError(ctx, fc) { + ec.Errorf(ctx, "must not be null") + } + return graphql.Null + } + res := resTmp.(*types.BulkPublishDocumentVersionsPayload) + fc.Result = res + return ec.marshalNBulkPublishDocumentVersionsPayload2ᚖgithubᚗcomᚋgetproboᚋproboᚋpkgᚋserverᚋapiᚋconsoleᚋv1ᚋtypesᚐBulkPublishDocumentVersionsPayload(ctx, field.Selections, res) +} + +func (ec *executionContext) fieldContext_Mutation_bulkPublishDocumentVersions(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "Mutation", + Field: field, + IsMethod: true, + IsResolver: true, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + switch field.Name { + case "documentVersionEdges": + return ec.fieldContext_BulkPublishDocumentVersionsPayload_documentVersionEdges(ctx, field) + case "documentEdges": + return ec.fieldContext_BulkPublishDocumentVersionsPayload_documentEdges(ctx, field) + } + return nil, fmt.Errorf("no field named %q was found under type BulkPublishDocumentVersionsPayload", field.Name) + }, + } + defer func() { + if r := recover(); r != nil { + err = ec.Recover(ctx, r) + ec.Error(ctx, err) + } + }() + ctx = graphql.WithFieldContext(ctx, fc) + if fc.Args, err = ec.field_Mutation_bulkPublishDocumentVersions_args(ctx, field.ArgumentMap(ec.Variables)); err != nil { + ec.Error(ctx, err) + return fc, err + } + return fc, nil +} + func (ec *executionContext) _Mutation_generateDocumentChangelog(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { fc, err := ec.fieldContext_Mutation_generateDocumentChangelog(ctx, field) if err != nil { @@ -37409,6 +37640,40 @@ func (ec *executionContext) unmarshalInputAssignTaskInput(ctx context.Context, o return it, nil } +func (ec *executionContext) unmarshalInputBulkPublishDocumentVersionsInput(ctx context.Context, obj any) (types.BulkPublishDocumentVersionsInput, error) { + var it types.BulkPublishDocumentVersionsInput + asMap := map[string]any{} + for k, v := range obj.(map[string]any) { + asMap[k] = v + } + + fieldsInOrder := [...]string{"documentIds", "changelog"} + for _, k := range fieldsInOrder { + v, ok := asMap[k] + if !ok { + continue + } + switch k { + case "documentIds": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("documentIds")) + data, err := ec.unmarshalNID2ᚕgithubᚗcomᚋgetproboᚋproboᚋpkgᚋgidᚐGIDᚄ(ctx, v) + if err != nil { + return it, err + } + it.DocumentIds = data + case "changelog": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("changelog")) + data, err := ec.unmarshalNString2string(ctx, v) + if err != nil { + return it, err + } + it.Changelog = data + } + } + + return it, nil +} + func (ec *executionContext) unmarshalInputCancelSignatureRequestInput(ctx context.Context, obj any) (types.CancelSignatureRequestInput, error) { var it types.CancelSignatureRequestInput asMap := map[string]any{} @@ -41622,6 +41887,50 @@ func (ec *executionContext) _AssignTaskPayload(ctx context.Context, sel ast.Sele return out } +var bulkPublishDocumentVersionsPayloadImplementors = []string{"BulkPublishDocumentVersionsPayload"} + +func (ec *executionContext) _BulkPublishDocumentVersionsPayload(ctx context.Context, sel ast.SelectionSet, obj *types.BulkPublishDocumentVersionsPayload) graphql.Marshaler { + fields := graphql.CollectFields(ec.OperationContext, sel, bulkPublishDocumentVersionsPayloadImplementors) + + out := graphql.NewFieldSet(fields) + deferred := make(map[string]*graphql.FieldSet) + for i, field := range fields { + switch field.Name { + case "__typename": + out.Values[i] = graphql.MarshalString("BulkPublishDocumentVersionsPayload") + case "documentVersionEdges": + out.Values[i] = ec._BulkPublishDocumentVersionsPayload_documentVersionEdges(ctx, field, obj) + if out.Values[i] == graphql.Null { + out.Invalids++ + } + case "documentEdges": + out.Values[i] = ec._BulkPublishDocumentVersionsPayload_documentEdges(ctx, field, obj) + if out.Values[i] == graphql.Null { + out.Invalids++ + } + default: + panic("unknown field " + strconv.Quote(field.Name)) + } + } + out.Dispatch(ctx) + if out.Invalids > 0 { + return graphql.Null + } + + atomic.AddInt32(&ec.deferred, int32(len(deferred))) + + for label, dfs := range deferred { + ec.processDeferredGroup(graphql.DeferredGroup{ + Label: label, + Path: graphql.GetPath(ctx), + FieldSet: dfs, + Context: ctx, + }) + } + + return out +} + var cancelSignatureRequestPayloadImplementors = []string{"CancelSignatureRequestPayload"} func (ec *executionContext) _CancelSignatureRequestPayload(ctx context.Context, sel ast.SelectionSet, obj *types.CancelSignatureRequestPayload) graphql.Marshaler { @@ -46281,6 +46590,13 @@ func (ec *executionContext) _Mutation(ctx context.Context, sel ast.SelectionSet) if out.Values[i] == graphql.Null { out.Invalids++ } + case "bulkPublishDocumentVersions": + out.Values[i] = ec.OperationContext.RootResolverMiddleware(innerCtx, func(ctx context.Context) (res graphql.Marshaler) { + return ec._Mutation_bulkPublishDocumentVersions(ctx, field) + }) + if out.Values[i] == graphql.Null { + out.Invalids++ + } case "generateDocumentChangelog": out.Values[i] = ec.OperationContext.RootResolverMiddleware(innerCtx, func(ctx context.Context) (res graphql.Marshaler) { return ec._Mutation_generateDocumentChangelog(ctx, field) @@ -50597,6 +50913,25 @@ func (ec *executionContext) marshalNBoolean2bool(ctx context.Context, sel ast.Se return res } +func (ec *executionContext) unmarshalNBulkPublishDocumentVersionsInput2githubᚗcomᚋgetproboᚋproboᚋpkgᚋserverᚋapiᚋconsoleᚋv1ᚋtypesᚐBulkPublishDocumentVersionsInput(ctx context.Context, v any) (types.BulkPublishDocumentVersionsInput, error) { + res, err := ec.unmarshalInputBulkPublishDocumentVersionsInput(ctx, v) + return res, graphql.ErrorOnPath(ctx, err) +} + +func (ec *executionContext) marshalNBulkPublishDocumentVersionsPayload2githubᚗcomᚋgetproboᚋproboᚋpkgᚋserverᚋapiᚋconsoleᚋv1ᚋtypesᚐBulkPublishDocumentVersionsPayload(ctx context.Context, sel ast.SelectionSet, v types.BulkPublishDocumentVersionsPayload) graphql.Marshaler { + return ec._BulkPublishDocumentVersionsPayload(ctx, sel, &v) +} + +func (ec *executionContext) marshalNBulkPublishDocumentVersionsPayload2ᚖgithubᚗcomᚋgetproboᚋproboᚋpkgᚋserverᚋapiᚋconsoleᚋv1ᚋtypesᚐBulkPublishDocumentVersionsPayload(ctx context.Context, sel ast.SelectionSet, v *types.BulkPublishDocumentVersionsPayload) graphql.Marshaler { + if v == nil { + if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) { + ec.Errorf(ctx, "the requested element is null which the schema does not allow") + } + return graphql.Null + } + return ec._BulkPublishDocumentVersionsPayload(ctx, sel, v) +} + func (ec *executionContext) unmarshalNBusinessImpact2githubᚗcomᚋgetproboᚋproboᚋpkgᚋcoredataᚐBusinessImpact(ctx context.Context, v any) (coredata.BusinessImpact, error) { tmp, err := graphql.UnmarshalString(v) res := unmarshalNBusinessImpact2githubᚗcomᚋgetproboᚋproboᚋpkgᚋcoredataᚐBusinessImpact[tmp] @@ -52526,6 +52861,36 @@ func (ec *executionContext) marshalNID2githubᚗcomᚋgetproboᚋproboᚋpkgᚋg return res } +func (ec *executionContext) unmarshalNID2ᚕgithubᚗcomᚋgetproboᚋproboᚋpkgᚋgidᚐGIDᚄ(ctx context.Context, v any) ([]gid.GID, error) { + var vSlice []any + vSlice = graphql.CoerceList(v) + var err error + res := make([]gid.GID, len(vSlice)) + for i := range vSlice { + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithIndex(i)) + res[i], err = ec.unmarshalNID2githubᚗcomᚋgetproboᚋproboᚋpkgᚋgidᚐGID(ctx, vSlice[i]) + if err != nil { + return nil, err + } + } + return res, nil +} + +func (ec *executionContext) marshalNID2ᚕgithubᚗcomᚋgetproboᚋproboᚋpkgᚋgidᚐGIDᚄ(ctx context.Context, sel ast.SelectionSet, v []gid.GID) graphql.Marshaler { + ret := make(graphql.Array, len(v)) + for i := range v { + ret[i] = ec.marshalNID2githubᚗcomᚋgetproboᚋproboᚋpkgᚋgidᚐGID(ctx, sel, v[i]) + } + + for _, e := range ret { + if e == graphql.Null { + return graphql.Null + } + } + + return ret +} + func (ec *executionContext) unmarshalNImportFrameworkInput2githubᚗcomᚋgetproboᚋproboᚋpkgᚋserverᚋapiᚋconsoleᚋv1ᚋtypesᚐImportFrameworkInput(ctx context.Context, v any) (types.ImportFrameworkInput, error) { res, err := ec.unmarshalInputImportFrameworkInput(ctx, v) return res, graphql.ErrorOnPath(ctx, err) diff --git a/pkg/server/api/console/v1/types/document.go b/pkg/server/api/console/v1/types/document.go index cb48e7d6d..dc4d0433a 100644 --- a/pkg/server/api/console/v1/types/document.go +++ b/pkg/server/api/console/v1/types/document.go @@ -56,6 +56,16 @@ func NewDocumentConnection( } } +func NewDocumentEdges(documents []*coredata.Document, orderBy coredata.DocumentOrderField) []*DocumentEdge { + edges := make([]*DocumentEdge, len(documents)) + + for i := range edges { + edges[i] = NewDocumentEdge(documents[i], orderBy) + } + + return edges +} + func NewDocumentEdge(document *coredata.Document, orderBy coredata.DocumentOrderField) *DocumentEdge { return &DocumentEdge{ Cursor: document.CursorKey(orderBy), diff --git a/pkg/server/api/console/v1/types/document_version.go b/pkg/server/api/console/v1/types/document_version.go index 8f1bf3f41..a6f9adf23 100644 --- a/pkg/server/api/console/v1/types/document_version.go +++ b/pkg/server/api/console/v1/types/document_version.go @@ -35,6 +35,16 @@ func NewDocumentVersionConnection(page *page.Page[*coredata.DocumentVersion, cor } } +func NewDocumentVersionEdges(documentVersions []*coredata.DocumentVersion, orderBy coredata.DocumentVersionOrderField) []*DocumentVersionEdge { + edges := make([]*DocumentVersionEdge, len(documentVersions)) + + for i := range edges { + edges[i] = NewDocumentVersionEdge(documentVersions[i], orderBy) + } + + return edges +} + func NewDocumentVersionEdge(documentVersion *coredata.DocumentVersion, orderBy coredata.DocumentVersionOrderField) *DocumentVersionEdge { return &DocumentVersionEdge{ Cursor: documentVersion.CursorKey(orderBy), diff --git a/pkg/server/api/console/v1/types/types.go b/pkg/server/api/console/v1/types/types.go index 517a9e1a5..30a7d2666 100644 --- a/pkg/server/api/console/v1/types/types.go +++ b/pkg/server/api/console/v1/types/types.go @@ -56,6 +56,16 @@ type AssignTaskPayload struct { Task *Task `json:"task"` } +type BulkPublishDocumentVersionsInput struct { + DocumentIds []gid.GID `json:"documentIds"` + Changelog string `json:"changelog"` +} + +type BulkPublishDocumentVersionsPayload struct { + DocumentVersionEdges []*DocumentVersionEdge `json:"documentVersionEdges"` + DocumentEdges []*DocumentEdge `json:"documentEdges"` +} + type CancelSignatureRequestInput struct { DocumentVersionSignatureID gid.GID `json:"documentVersionSignatureId"` } diff --git a/pkg/server/api/console/v1/v1_resolver.go b/pkg/server/api/console/v1/v1_resolver.go index bb6d6ce06..8d77519a5 100644 --- a/pkg/server/api/console/v1/v1_resolver.go +++ b/pkg/server/api/console/v1/v1_resolver.go @@ -1957,6 +1957,34 @@ func (r *mutationResolver) ExportDocumentVersionPDF(ctx context.Context, input t }, nil } +func (r *mutationResolver) BulkPublishDocumentVersions(ctx context.Context, input types.BulkPublishDocumentVersionsInput) (*types.BulkPublishDocumentVersionsPayload, error) { + if len(input.DocumentIds) == 0 { + return &types.BulkPublishDocumentVersionsPayload{ + DocumentVersionEdges: []*types.DocumentVersionEdge{}, + DocumentEdges: []*types.DocumentEdge{}, + }, nil + } + + prb := r.ProboService(ctx, input.DocumentIds[0].TenantID()) + + user := UserFromContext(ctx) + + people, err := prb.Peoples.GetByUserID(ctx, user.ID) + if err != nil { + panic(fmt.Errorf("cannot get people: %w", err)) + } + + documentVersions, documents, err := prb.Documents.BulkPublishVersions(ctx, input.DocumentIds, people.ID, input.Changelog) + if err != nil { + panic(fmt.Errorf("cannot bulk publish document versions: %w", err)) + } + + return &types.BulkPublishDocumentVersionsPayload{ + DocumentVersionEdges: types.NewDocumentVersionEdges(documentVersions, coredata.DocumentVersionOrderFieldCreatedAt), + DocumentEdges: types.NewDocumentEdges(documents, coredata.DocumentOrderFieldTitle), + }, nil +} + // CreateVendorRiskAssessment is the resolver for the createVendorRiskAssessment field. func (r *mutationResolver) CreateVendorRiskAssessment(ctx context.Context, input types.CreateVendorRiskAssessmentInput) (*types.CreateVendorRiskAssessmentPayload, error) { prb := r.ProboService(ctx, input.VendorID.TenantID())