Add granular trust center access

Signed-off-by: Sacha Al Himdani <sacha@getprobo.com>
2025-09-25 14:48:40 +02:00
parent 60d1238534
commit 770a795cd3
27 changed files with 6650 additions and 806 deletions
--- a/pkg/server/api/trust/v1/v1_resolver.go
+++ b/pkg/server/api/trust/v1/v1_resolver.go
@@ -57,20 +57,90 @@ func (r *auditResolver) Report(ctx context.Context, obj *types.Audit) (*types.Re
 	return types.NewReport(report), nil
 }

-// CreateTrustCenterAccess is the resolver for the createTrustCenterAccess field.
-func (r *mutationResolver) CreateTrustCenterAccess(ctx context.Context, input types.CreateTrustCenterAccessInput) (*types.CreateTrustCenterAccessPayload, error) {
+// IsUserAuthorized is the resolver for the isUserAuthorized field.
+func (r *documentResolver) IsUserAuthorized(ctx context.Context, obj *types.Document) (bool, error) {
+	privateTrustService, err := r.PrivateTrustService(ctx, obj.ID.TenantID())
+	if err != nil {
+		return false, nil
+	}
+
+	userData := r.UserFromContext(ctx)
+	if userData != nil {
+		return true, nil
+	}
+
+	tokenData := TokenAccessFromContext(ctx)
+	if tokenData != nil {
+		documentAccess, err := privateTrustService.TrustCenterAccesses.LoadDocumentAccess(ctx, tokenData.TrustCenterID, tokenData.GetEmail(), obj.ID)
+		if err != nil {
+			return false, nil
+		}
+
+		return documentAccess.Active, nil
+	}
+
+	panic(fmt.Errorf("no user or token data found"))
+}
+
+// HasUserRequestedAccess is the resolver for the hasUserRequestedAccess field.
+func (r *documentResolver) HasUserRequestedAccess(ctx context.Context, obj *types.Document) (bool, error) {
+	privateTrustService, err := r.PrivateTrustService(ctx, obj.ID.TenantID())
+	if err != nil {
+		return false, nil
+	}
+
+	userData := r.UserFromContext(ctx)
+	if userData != nil {
+		return false, nil
+	}
+
+	tokenData := TokenAccessFromContext(ctx)
+	if tokenData != nil {
+		// Try to load document access - if it exists (regardless of active status), user has requested it
+		_, err := privateTrustService.TrustCenterAccesses.LoadDocumentAccess(ctx, tokenData.TrustCenterID, tokenData.GetEmail(), obj.ID)
+		if err != nil {
+			return false, nil // No access requested or error
+		}
+		return true, nil // Access exists (requested)
+	}
+
+	return false, nil
+}
+
+// RequestAllAccesses is the resolver for the requestAllAccesses field.
+func (r *mutationResolver) RequestAllAccesses(ctx context.Context, input types.RequestAllAccessesInput) (*types.RequestAccessesPayload, error) {
 	publicTrustService := r.PublicTrustService(ctx, input.TrustCenterID.TenantID())

-	access, err := publicTrustService.TrustCenterAccesses.Create(ctx, &trust.CreateTrustCenterAccessRequest{
+	userData := r.UserFromContext(ctx)
+	if userData != nil {
+		return nil, fmt.Errorf("session users cannot request trust center access")
+	}
+
+	email := input.Email
+	tokenData := TokenAccessFromContext(ctx)
+	if tokenData != nil {
+		if email != nil || input.Name != nil {
+			return nil, fmt.Errorf("email and name are not allowed for authenticated users")
+		}
+		emailValue := tokenData.GetEmail()
+		email = &emailValue
+	}
+	if email == nil {
+		return nil, fmt.Errorf("email is required for unauthenticated users")
+	}
+
+	access, err := publicTrustService.TrustCenterAccesses.Request(ctx, &trust.RequestTrustCenterAccessRequest{
 		TrustCenterID: input.TrustCenterID,
-		Email:         input.Email,
+		Email:         *email,
 		Name:          input.Name,
+		DocumentIDs:   nil,
+		ReportIDs:     nil,
 	})
 	if err != nil {
 		panic(fmt.Errorf("cannot create trust center access: %w", err))
 	}

-	return &types.CreateTrustCenterAccessPayload{
+	return &types.RequestAccessesPayload{
 		TrustCenterAccess: &types.TrustCenterAccess{
 			ID:        access.ID,
 			Email:     access.Email,
@@ -101,6 +171,15 @@ func (r *mutationResolver) ExportDocumentPDF(ctx context.Context, input types.Ex
 		if err != nil {
 			panic(fmt.Errorf("cannot check if user has accepted NDA: %w", err))
 		}
+
+		documentAccess, err := privateTrustService.TrustCenterAccesses.LoadDocumentAccess(ctx, tokenData.TrustCenterID, tokenData.GetEmail(), input.DocumentID)
+		if err != nil {
+			panic(fmt.Errorf("cannot check document access: %w", err))
+		}
+
+		if !documentAccess.Active {
+			return nil, fmt.Errorf("access denied: no permission to access this document")
+		}
 	}

 	if !hasAcceptedNDA {
@@ -144,6 +223,15 @@ func (r *mutationResolver) ExportReportPDF(ctx context.Context, input types.Expo
 		if err != nil {
 			panic(fmt.Errorf("cannot check if user has accepted NDA: %w", err))
 		}
+
+		reportAccess, err := privateTrustService.TrustCenterAccesses.LoadReportAccess(ctx, tokenData.TrustCenterID, tokenData.GetEmail(), input.ReportID)
+		if err != nil {
+			panic(fmt.Errorf("cannot check report access: %w", err))
+		}
+
+		if !reportAccess.Active {
+			return nil, fmt.Errorf("access denied: no permission to access this report")
+		}
 	}

 	if !hasAcceptedNDA {
@@ -188,6 +276,94 @@ func (r *mutationResolver) AcceptNonDisclosureAgreement(ctx context.Context, inp
 	return &types.AcceptNonDisclosureAgreementPayload{Success: true}, nil
 }

+// RequestDocumentAccess is the resolver for the requestDocumentAccess field.
+func (r *mutationResolver) RequestDocumentAccess(ctx context.Context, input types.RequestDocumentAccessInput) (*types.RequestAccessesPayload, error) {
+	publicTrustService := r.PublicTrustService(ctx, input.TrustCenterID.TenantID())
+
+	userData := r.UserFromContext(ctx)
+	if userData != nil {
+		return nil, fmt.Errorf("sessions users cannot request trust center access")
+	}
+
+	email := input.Email
+	tokenData := TokenAccessFromContext(ctx)
+	if tokenData != nil {
+		if email != nil || input.Name != nil {
+			return nil, fmt.Errorf("email and name are not allowed for authenticated users")
+		}
+		emailValue := tokenData.GetEmail()
+		email = &emailValue
+	}
+	if email == nil {
+		return nil, fmt.Errorf("email is required for unauthenticated users")
+	}
+
+	access, err := publicTrustService.TrustCenterAccesses.Request(ctx, &trust.RequestTrustCenterAccessRequest{
+		TrustCenterID: input.TrustCenterID,
+		Email:         *email,
+		Name:          input.Name,
+		DocumentIDs:   []gid.GID{input.DocumentID},
+		ReportIDs:     []gid.GID{},
+	})
+	if err != nil {
+		panic(fmt.Errorf("cannot request document access: %w", err))
+	}
+
+	return &types.RequestAccessesPayload{
+		TrustCenterAccess: &types.TrustCenterAccess{
+			ID:        access.ID,
+			Email:     access.Email,
+			Name:      access.Name,
+			CreatedAt: access.CreatedAt,
+			UpdatedAt: access.UpdatedAt,
+		},
+	}, nil
+}
+
+// RequestReportAccess is the resolver for the requestReportAccess field.
+func (r *mutationResolver) RequestReportAccess(ctx context.Context, input types.RequestReportAccessInput) (*types.RequestAccessesPayload, error) {
+	publicTrustService := r.PublicTrustService(ctx, input.TrustCenterID.TenantID())
+
+	userData := r.UserFromContext(ctx)
+	if userData != nil {
+		return nil, fmt.Errorf("session users cannot request trust center access")
+	}
+
+	email := input.Email
+	tokenData := TokenAccessFromContext(ctx)
+	if tokenData != nil {
+		if email != nil || input.Name != nil {
+			return nil, fmt.Errorf("email and name are not allowed for authenticated users")
+		}
+		emailValue := tokenData.GetEmail()
+		email = &emailValue
+	}
+	if email == nil {
+		return nil, fmt.Errorf("email is required for unauthenticated users")
+	}
+
+	access, err := publicTrustService.TrustCenterAccesses.Request(ctx, &trust.RequestTrustCenterAccessRequest{
+		TrustCenterID: input.TrustCenterID,
+		Email:         *email,
+		Name:          input.Name,
+		DocumentIDs:   []gid.GID{},
+		ReportIDs:     []gid.GID{input.ReportID},
+	})
+	if err != nil {
+		panic(fmt.Errorf("cannot request report access: %w", err))
+	}
+
+	return &types.RequestAccessesPayload{
+		TrustCenterAccess: &types.TrustCenterAccess{
+			ID:        access.ID,
+			Email:     access.Email,
+			Name:      access.Name,
+			CreatedAt: access.CreatedAt,
+			UpdatedAt: access.UpdatedAt,
+		},
+	}, nil
+}
+
 // LogoURL is the resolver for the logoUrl field.
 func (r *organizationResolver) LogoURL(ctx context.Context, obj *types.Organization) (*string, error) {
 	publicTrustService := r.PublicTrustService(ctx, obj.ID.TenantID())
@@ -290,6 +466,55 @@ func (r *queryResolver) TrustCenterBySlug(ctx context.Context, slug string) (*ty
 	return response, nil
 }

+// IsUserAuthorized is the resolver for the isUserAuthorized field.
+func (r *reportResolver) IsUserAuthorized(ctx context.Context, obj *types.Report) (bool, error) {
+	privateTrustService, err := r.PrivateTrustService(ctx, obj.ID.TenantID())
+	if err != nil {
+		return false, nil
+	}
+
+	userData := r.UserFromContext(ctx)
+	if userData != nil {
+		return true, nil
+	}
+
+	tokenData := TokenAccessFromContext(ctx)
+	if tokenData != nil {
+		reportAccess, err := privateTrustService.TrustCenterAccesses.LoadReportAccess(ctx, tokenData.TrustCenterID, tokenData.GetEmail(), obj.ID)
+		if err != nil {
+			return false, nil
+		}
+
+		return reportAccess.Active, nil
+	}
+
+	panic(fmt.Errorf("no user or token data found"))
+}
+
+// HasUserRequestedAccess is the resolver for the hasUserRequestedAccess field.
+func (r *reportResolver) HasUserRequestedAccess(ctx context.Context, obj *types.Report) (bool, error) {
+	privateTrustService, err := r.PrivateTrustService(ctx, obj.ID.TenantID())
+	if err != nil {
+		return false, nil
+	}
+
+	userData := r.UserFromContext(ctx)
+	if userData != nil {
+		return false, nil
+	}
+
+	tokenData := TokenAccessFromContext(ctx)
+	if tokenData != nil {
+		_, err := privateTrustService.TrustCenterAccesses.LoadReportAccess(ctx, tokenData.TrustCenterID, tokenData.GetEmail(), obj.ID)
+		if err != nil {
+			return false, nil
+		}
+		return true, nil
+	}
+
+	return false, nil
+}
+
 // NdaFileURL is the resolver for the ndaFileUrl field.
 func (r *trustCenterResolver) NdaFileURL(ctx context.Context, obj *types.TrustCenter) (*string, error) {
 	privateTrustService, err := r.PrivateTrustService(ctx, obj.ID.TenantID())
@@ -432,6 +657,9 @@ func (r *trustCenterReferenceResolver) LogoURL(ctx context.Context, obj *types.T
 // Audit returns schema.AuditResolver implementation.
 func (r *Resolver) Audit() schema.AuditResolver { return &auditResolver{r} }

+// Document returns schema.DocumentResolver implementation.
+func (r *Resolver) Document() schema.DocumentResolver { return &documentResolver{r} }
+
 // Mutation returns schema.MutationResolver implementation.
 func (r *Resolver) Mutation() schema.MutationResolver { return &mutationResolver{r} }

@@ -441,6 +669,9 @@ func (r *Resolver) Organization() schema.OrganizationResolver { return &organiza
 // Query returns schema.QueryResolver implementation.
 func (r *Resolver) Query() schema.QueryResolver { return &queryResolver{r} }

+// Report returns schema.ReportResolver implementation.
+func (r *Resolver) Report() schema.ReportResolver { return &reportResolver{r} }
+
 // TrustCenter returns schema.TrustCenterResolver implementation.
 func (r *Resolver) TrustCenter() schema.TrustCenterResolver { return &trustCenterResolver{r} }

@@ -450,8 +681,10 @@ func (r *Resolver) TrustCenterReference() schema.TrustCenterReferenceResolver {
 }

 type auditResolver struct{ *Resolver }
+type documentResolver struct{ *Resolver }
 type mutationResolver struct{ *Resolver }
 type organizationResolver struct{ *Resolver }
 type queryResolver struct{ *Resolver }
+type reportResolver struct{ *Resolver }
 type trustCenterResolver struct{ *Resolver }
 type trustCenterReferenceResolver struct{ *Resolver }