probo/pkg/server/api/console/v1/audit_log_resolvers.go

package console_v1

// This file will be automatically regenerated based on the schema, any resolver
// implementations
// will be copied through when generating and any unknown code will be moved to the end.
// Code generated by github.com/99designs/gqlgen version v0.17.94

import (
	"context"
	"errors"

	"github.com/vikstrous/dataloadgen"
	"go.gearno.de/kit/log"
	"go.probo.inc/probo/pkg/coredata"
	"go.probo.inc/probo/pkg/iam"
	"go.probo.inc/probo/pkg/probo"
	"go.probo.inc/probo/pkg/server/api/authn"
	"go.probo.inc/probo/pkg/server/api/console/v1/dataloader"
	"go.probo.inc/probo/pkg/server/api/console/v1/schema"
	"go.probo.inc/probo/pkg/server/api/console/v1/types"
	"go.probo.inc/probo/pkg/server/gqlutils"
)

// Organization is the resolver for the organization field.
func (r *auditLogEntryResolver) Organization(ctx context.Context, obj *types.AuditLogEntry) (*types.Organization, error) {
	if _, err := r.authorize(ctx, obj.ID, probo.ActionOrganizationGet); err != nil {
		return nil, err
	}

	loaders := dataloader.FromContext(ctx)

	organization, err := loaders.Organization.Load(ctx, obj.Organization.ID)
	if err != nil {
		if errors.Is(err, coredata.ErrResourceNotFound) || errors.Is(err, dataloadgen.ErrNotFound) {
			return nil, gqlutils.NotFound(ctx, err)
		}

		r.logger.ErrorCtx(ctx, "cannot load organization", log.Error(err))

		return nil, gqlutils.Internal(ctx)
	}

	return types.NewOrganization(organization), nil
}

// Permission is the resolver for the permission field.
func (r *auditLogEntryResolver) Permission(ctx context.Context, obj *types.AuditLogEntry, action string) (bool, error) {
	return r.Resolver.Permission(ctx, obj, action)
}

// TotalCount is the resolver for the totalCount field.
func (r *auditLogEntryConnectionResolver) TotalCount(ctx context.Context, obj *types.AuditLogEntryConnection) (int, error) {
	if _, err := r.authorize(ctx, obj.ParentID, iam.ActionAuditLogEntryList); err != nil {
		return 0, err
	}

	filter := coredata.NewAuditLogEntryFilter()
	if obj.Filter != nil {
		filter = obj.Filter
	}

	count, err := r.iam.OrganizationService.CountAuditLogEntries(ctx, obj.ParentID, filter)
	if err != nil {
		r.logger.ErrorCtx(ctx, "cannot count audit log entries", log.Error(err))
		return 0, gqlutils.Internal(ctx)
	}

	return count, nil
}

// RequestAuditLogExport is the resolver for the requestAuditLogExport field.
func (r *mutationResolver) RequestAuditLogExport(ctx context.Context, input types.RequestAuditLogExportInput) (*types.RequestAuditLogExportPayload, error) {
	scope, err := r.authorize(ctx, input.OrganizationID, iam.ActionAuditLogExport)
	if err != nil {
		return nil, err
	}

	identity := authn.IdentityFromContext(ctx)

	logExport, err := r.iam.OrganizationService.RequestLogExport(
		ctx,
		scope,
		iam.RequestLogExportRequest{
			OrganizationID: input.OrganizationID,
			Type:           coredata.ExportJobTypeAuditLog,
			FromTime:       input.FromTime,
			ToTime:         input.ToTime,
			RecipientEmail: identity.EmailAddress,
			RecipientName:  identity.FullName,
		},
	)
	if err != nil {
		if _, ok := errors.AsType[*iam.ErrInvalidLogExportTimeRange](err); ok {
			return nil, gqlutils.Invalid(ctx, err)
		}

		r.logger.ErrorCtx(ctx, "cannot request audit log export", log.Error(err))

		return nil, gqlutils.Internal(ctx)
	}

	return &types.RequestAuditLogExportPayload{
		ExportJobID: logExport.ID,
	}, nil
}

// AuditLogEntry returns schema.AuditLogEntryResolver implementation.
func (r *Resolver) AuditLogEntry() schema.AuditLogEntryResolver { return &auditLogEntryResolver{r} }

// AuditLogEntryConnection returns schema.AuditLogEntryConnectionResolver implementation.
func (r *Resolver) AuditLogEntryConnection() schema.AuditLogEntryConnectionResolver {
	return &auditLogEntryConnectionResolver{r}
}

type (
	auditLogEntryResolver           struct{ *Resolver }
	auditLogEntryConnectionResolver struct{ *Resolver }
)