probo/pkg/server/api/console/v1/processing_activity_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.90

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/page"
	"go.probo.inc/probo/pkg/probo"
	"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"
)

// CreateProcessingActivity is the resolver for the createProcessingActivity field.
func (r *mutationResolver) CreateProcessingActivity(ctx context.Context, input types.CreateProcessingActivityInput) (*types.CreateProcessingActivityPayload, error) {
	if err := r.authorize(ctx, input.OrganizationID, probo.ActionProcessingActivityCreate); err != nil {
		return nil, err
	}

	prb := r.ProboService(ctx, input.OrganizationID.TenantID())

	req := probo.CreateProcessingActivityRequest{
		OrganizationID:                       input.OrganizationID,
		Name:                                 input.Name,
		Purpose:                              input.Purpose,
		DataSubjectCategory:                  input.DataSubjectCategory,
		PersonalDataCategory:                 input.PersonalDataCategory,
		SpecialOrCriminalData:                input.SpecialOrCriminalData,
		LawfulBasis:                          input.LawfulBasis,
		Recipients:                           input.Recipients,
		Location:                             input.Location,
		InternationalTransfers:               input.InternationalTransfers,
		TransferSafeguard:                    input.TransferSafeguards,
		RetentionPeriod:                      input.RetentionPeriod,
		SecurityMeasures:                     input.SecurityMeasures,
		DataProtectionImpactAssessmentNeeded: input.DataProtectionImpactAssessmentNeeded,
		TransferImpactAssessmentNeeded:       input.TransferImpactAssessmentNeeded,
		LastReviewDate:                       input.LastReviewDate,
		NextReviewDate:                       input.NextReviewDate,
		Role:                                 input.Role,
		DataProtectionOfficerID:              input.DataProtectionOfficerID,
		VendorIDs:                            input.VendorIds,
	}

	activity, err := prb.ProcessingActivities.Create(ctx, &req)
	if err != nil {
		r.logger.ErrorCtx(ctx, "cannot create processing activity", log.Error(err))
		return nil, gqlutils.Internal(ctx)
	}

	return &types.CreateProcessingActivityPayload{
		ProcessingActivityEdge: types.NewProcessingActivityEdge(activity, coredata.ProcessingActivityOrderFieldCreatedAt),
	}, nil
}

// UpdateProcessingActivity is the resolver for the updateProcessingActivity field.
func (r *mutationResolver) UpdateProcessingActivity(ctx context.Context, input types.UpdateProcessingActivityInput) (*types.UpdateProcessingActivityPayload, error) {
	if err := r.authorize(ctx, input.ID, probo.ActionProcessingActivityUpdate); err != nil {
		return nil, err
	}

	prb := r.ProboService(ctx, input.ID.TenantID())

	req := probo.UpdateProcessingActivityRequest{
		ID:                                   input.ID,
		Name:                                 input.Name,
		Purpose:                              gqlutils.UnwrapOmittable(input.Purpose),
		DataSubjectCategory:                  gqlutils.UnwrapOmittable(input.DataSubjectCategory),
		PersonalDataCategory:                 gqlutils.UnwrapOmittable(input.PersonalDataCategory),
		SpecialOrCriminalData:                input.SpecialOrCriminalData,
		LawfulBasis:                          input.LawfulBasis,
		Recipients:                           gqlutils.UnwrapOmittable(input.Recipients),
		Location:                             gqlutils.UnwrapOmittable(input.Location),
		InternationalTransfers:               input.InternationalTransfers,
		TransferSafeguard:                    gqlutils.UnwrapOmittable(input.TransferSafeguards),
		RetentionPeriod:                      gqlutils.UnwrapOmittable(input.RetentionPeriod),
		SecurityMeasures:                     gqlutils.UnwrapOmittable(input.SecurityMeasures),
		DataProtectionImpactAssessmentNeeded: input.DataProtectionImpactAssessmentNeeded,
		TransferImpactAssessmentNeeded:       input.TransferImpactAssessmentNeeded,
		LastReviewDate:                       gqlutils.UnwrapOmittable(input.LastReviewDate),
		NextReviewDate:                       gqlutils.UnwrapOmittable(input.NextReviewDate),
		Role:                                 input.Role,
		DataProtectionOfficerID:              gqlutils.UnwrapOmittable(input.DataProtectionOfficerID),
		VendorIDs:                            &input.VendorIds,
	}

	activity, err := prb.ProcessingActivities.Update(ctx, &req)
	if err != nil {
		r.logger.ErrorCtx(ctx, "cannot update processing activity", log.Error(err))
		return nil, gqlutils.Internal(ctx)
	}

	return &types.UpdateProcessingActivityPayload{
		ProcessingActivity: types.NewProcessingActivity(activity),
	}, nil
}

// DeleteProcessingActivity is the resolver for the deleteProcessingActivity field.
func (r *mutationResolver) DeleteProcessingActivity(ctx context.Context, input types.DeleteProcessingActivityInput) (*types.DeleteProcessingActivityPayload, error) {
	if err := r.authorize(ctx, input.ProcessingActivityID, probo.ActionProcessingActivityDelete); err != nil {
		return nil, err
	}

	prb := r.ProboService(ctx, input.ProcessingActivityID.TenantID())

	err := prb.ProcessingActivities.Delete(ctx, input.ProcessingActivityID)
	if err != nil {
		r.logger.ErrorCtx(ctx, "cannot delete processing activity", log.Error(err))
		return nil, gqlutils.Internal(ctx)
	}

	return &types.DeleteProcessingActivityPayload{
		DeletedProcessingActivityID: input.ProcessingActivityID,
	}, nil
}

// PublishProcessingActivityList is the resolver for the publishProcessingActivityList field.
func (r *mutationResolver) PublishProcessingActivityList(ctx context.Context, input types.PublishProcessingActivityListInput) (*types.PublishProcessingActivityListPayload, error) {
	if err := r.authorize(ctx, input.OrganizationID, probo.ActionProcessingActivityPublish); err != nil {
		return nil, err
	}

	prb := r.ProboService(ctx, input.OrganizationID.TenantID())

	document, documentVersion, err := prb.GeneratedDocuments.PublishProcessingActivityList(ctx, input.OrganizationID, input.ApproverIds, input.Minor)
	if err != nil {
		if errors.Is(err, coredata.ErrResourceAlreadyExists) {
			return nil, gqlutils.Conflict(ctx, err)
		}
		if errMinor, ok := errors.AsType[*probo.ErrCannotPublishMinorWithoutMajor](err); ok {
			return nil, gqlutils.Invalid(ctx, errMinor)
		}
		r.logger.ErrorCtx(ctx, "cannot publish processing activity list", log.Error(err))
		return nil, gqlutils.Internal(ctx)
	}

	return &types.PublishProcessingActivityListPayload{
		DocumentEdge:        types.NewDocumentEdge(document, coredata.DocumentOrderFieldCreatedAt),
		DocumentVersionEdge: types.NewDocumentVersionEdge(documentVersion, coredata.DocumentVersionOrderFieldCreatedAt),
	}, nil
}

// Organization is the resolver for the organization field.
func (r *processingActivityResolver) Organization(ctx context.Context, obj *types.ProcessingActivity) (*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 get organization", log.Error(err))
		return nil, gqlutils.Internal(ctx)
	}

	return types.NewOrganization(organization), nil
}

// DataProtectionOfficer is the resolver for the dataProtectionOfficer field.
func (r *processingActivityResolver) DataProtectionOfficer(ctx context.Context, obj *types.ProcessingActivity) (*types.Profile, error) {
	if err := r.authorize(ctx, obj.ID, iam.ActionMembershipProfileGet); err != nil {
		return nil, err
	}

	if obj.DataProtectionOfficer == nil {
		return nil, nil
	}

	loaders := dataloader.FromContext(ctx)

	dpo, err := loaders.Profile.Load(ctx, obj.DataProtectionOfficer.ID)
	if err != nil {
		if errors.Is(err, dataloadgen.ErrNotFound) {
			return nil, gqlutils.NotFound(ctx, err)
		}

		r.logger.ErrorCtx(ctx, "cannot get data protection officer", log.Error(err))
		return nil, gqlutils.Internal(ctx)
	}

	return types.NewProfile(dpo), nil
}

// Vendors is the resolver for the vendors field.
func (r *processingActivityResolver) Vendors(ctx context.Context, obj *types.ProcessingActivity, first *int, after *page.CursorKey, last *int, before *page.CursorKey, orderBy *types.VendorOrderBy) (*types.VendorConnection, error) {
	if err := r.authorize(ctx, obj.ID, probo.ActionVendorList); err != nil {
		return nil, err
	}

	prb := r.ProboService(ctx, obj.ID.TenantID())

	pageOrderBy := page.OrderBy[coredata.VendorOrderField]{
		Field:     coredata.VendorOrderFieldCreatedAt,
		Direction: page.OrderDirectionDesc,
	}
	if orderBy != nil {
		pageOrderBy = page.OrderBy[coredata.VendorOrderField]{
			Field:     orderBy.Field,
			Direction: orderBy.Direction,
		}
	}

	cursor := types.NewCursor(first, after, last, before, pageOrderBy)

	page, err := prb.Vendors.ListForProcessingActivityID(ctx, obj.ID, cursor)
	if err != nil {
		r.logger.ErrorCtx(ctx, "cannot list processing activity vendors", log.Error(err))
		return nil, gqlutils.Internal(ctx)
	}

	return types.NewVendorConnection(page, r, obj.ID), nil
}

// DataProtectionImpactAssessment is the resolver for the dataProtectionImpactAssessment field.
func (r *processingActivityResolver) DataProtectionImpactAssessment(ctx context.Context, obj *types.ProcessingActivity) (*types.DataProtectionImpactAssessment, error) {
	if err := r.authorize(ctx, obj.ID, probo.ActionDataProtectionImpactAssessmentGet); err != nil {
		return nil, err
	}

	prb := r.ProboService(ctx, obj.ID.TenantID())

	dpia, err := prb.DataProtectionImpactAssessments.GetByProcessingActivityID(ctx, obj.ID)
	if err != nil {
		if errors.Is(err, coredata.ErrResourceNotFound) {
			return nil, nil
		}
		r.logger.ErrorCtx(ctx, "cannot get processing activity dpia", log.Error(err))
		return nil, gqlutils.Internal(ctx)
	}

	return types.NewDataProtectionImpactAssessment(dpia), nil
}

// TransferImpactAssessment is the resolver for the transferImpactAssessment field.
func (r *processingActivityResolver) TransferImpactAssessment(ctx context.Context, obj *types.ProcessingActivity) (*types.TransferImpactAssessment, error) {
	if err := r.authorize(ctx, obj.ID, probo.ActionTransferImpactAssessmentGet); err != nil {
		return nil, err
	}

	prb := r.ProboService(ctx, obj.ID.TenantID())

	tia, err := prb.TransferImpactAssessments.GetByProcessingActivityID(ctx, obj.ID)
	if err != nil {
		if errors.Is(err, coredata.ErrResourceNotFound) {
			return nil, nil
		}
		r.logger.ErrorCtx(ctx, "cannot get processing activity tia", log.Error(err))
		return nil, gqlutils.Internal(ctx)
	}

	return types.NewTransferImpactAssessment(tia), nil
}

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

// TotalCount is the resolver for the totalCount field.
func (r *processingActivityConnectionResolver) TotalCount(ctx context.Context, obj *types.ProcessingActivityConnection) (int, error) {
	if err := r.authorize(ctx, obj.ParentID, probo.ActionProcessingActivityList); err != nil {
		return 0, err
	}

	prb := r.ProboService(ctx, obj.ParentID.TenantID())

	switch obj.Resolver.(type) {
	case *organizationResolver:
		count, err := prb.ProcessingActivities.CountForOrganizationID(ctx, obj.ParentID)
		if err != nil {
			r.logger.ErrorCtx(ctx, "cannot count organization processing activities", log.Error(err))
			return 0, gqlutils.Internal(ctx)
		}
		return count, nil
	}

	r.logger.ErrorCtx(ctx, "unsupported resolver")
	return 0, gqlutils.Internal(ctx)
}

// ProcessingActivity returns schema.ProcessingActivityResolver implementation.
func (r *Resolver) ProcessingActivity() schema.ProcessingActivityResolver {
	return &processingActivityResolver{r}
}

// ProcessingActivityConnection returns schema.ProcessingActivityConnectionResolver implementation.
func (r *Resolver) ProcessingActivityConnection() schema.ProcessingActivityConnectionResolver {
	return &processingActivityConnectionResolver{r}
}

type processingActivityResolver struct{ *Resolver }
type processingActivityConnectionResolver struct{ *Resolver }