probo/pkg/server/api/console/v1/task_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"
	"go.probo.inc/probo/pkg/validator"
)

// CreateTask is the resolver for the createTask field.
func (r *mutationResolver) CreateTask(ctx context.Context, input types.CreateTaskInput) (*types.CreateTaskPayload, error) {
	if err := r.authorize(ctx, input.OrganizationID, probo.ActionTaskCreate); err != nil {
		return nil, err
	}

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

	task, err := prb.Tasks.Create(
		ctx,
		probo.CreateTaskRequest{
			MeasureID:      input.MeasureID,
			OrganizationID: input.OrganizationID,
			Name:           input.Name,
			Description:    input.Description,
			Priority:       input.Priority,
			TimeEstimate:   input.TimeEstimate,
			AssignedToID:   input.AssignedToID,
			Deadline:       input.Deadline,
		},
	)
	if err != nil {
		if errors.Is(err, coredata.ErrResourceAlreadyExists) {
			return nil, gqlutils.Conflict(ctx, err)
		}

		if validationErrors, ok := errors.AsType[validator.ValidationErrors](err); ok {
			return nil, gqlutils.InvalidValidationErrors(ctx, validationErrors)
		}
		r.logger.ErrorCtx(ctx, "cannot create task", log.Error(err))
		return nil, gqlutils.Internal(ctx)
	}

	return &types.CreateTaskPayload{
		TaskEdge: types.NewTaskEdge(task, coredata.TaskOrderFieldCreatedAt),
	}, nil
}

// UpdateTask is the resolver for the updateTask field.
func (r *mutationResolver) UpdateTask(ctx context.Context, input types.UpdateTaskInput) (*types.UpdateTaskPayload, error) {
	if err := r.authorize(ctx, input.TaskID, probo.ActionTaskUpdate); err != nil {
		return nil, err
	}

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

	task, err := prb.Tasks.Update(
		ctx,
		probo.UpdateTaskRequest{
			TaskID:       input.TaskID,
			Name:         input.Name,
			Description:  gqlutils.UnwrapOmittable(input.Description),
			State:        input.State,
			Priority:     input.Priority,
			Rank:         input.Rank,
			TimeEstimate: gqlutils.UnwrapOmittable(input.TimeEstimate),
			Deadline:     gqlutils.UnwrapOmittable(input.Deadline),
			AssignedToID: gqlutils.UnwrapOmittable(input.AssignedToID),
			MeasureID:    gqlutils.UnwrapOmittable(input.MeasureID),
		},
	)
	if err != nil {
		if validationErrors, ok := errors.AsType[validator.ValidationErrors](err); ok {
			return nil, gqlutils.InvalidValidationErrors(ctx, validationErrors)
		}
		r.logger.ErrorCtx(ctx, "cannot update task", log.Error(err))
		return nil, gqlutils.Internal(ctx)
	}

	return &types.UpdateTaskPayload{
		Task: types.NewTask(task),
	}, nil
}

// DeleteTask is the resolver for the deleteTask field.
func (r *mutationResolver) DeleteTask(ctx context.Context, input types.DeleteTaskInput) (*types.DeleteTaskPayload, error) {
	if err := r.authorize(ctx, input.TaskID, probo.ActionTaskDelete); err != nil {
		return nil, err
	}

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

	err := prb.Tasks.Delete(ctx, input.TaskID)
	if err != nil {
		r.logger.ErrorCtx(ctx, "cannot delete task", log.Error(err))
		return nil, gqlutils.Internal(ctx)
	}

	return &types.DeleteTaskPayload{
		DeletedTaskID: input.TaskID,
	}, nil
}

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

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

	loaders := dataloader.FromContext(ctx)

	assignee, err := loaders.Profile.Load(ctx, obj.AssignedTo.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 assigned to", log.Error(err))
		return nil, gqlutils.Internal(ctx)
	}

	return types.NewProfile(assignee), nil
}

// Organization is the resolver for the organization field.
func (r *taskResolver) Organization(ctx context.Context, obj *types.Task) (*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
}

// Measure is the resolver for the measure field.
func (r *taskResolver) Measure(ctx context.Context, obj *types.Task) (*types.Measure, error) {
	if err := r.authorize(ctx, obj.ID, probo.ActionMeasureGet); err != nil {
		return nil, err
	}

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

	loaders := dataloader.FromContext(ctx)

	measure, err := loaders.Measure.Load(ctx, obj.Measure.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 measure", log.Error(err))
		return nil, gqlutils.Internal(ctx)
	}

	return types.NewMeasure(measure), nil
}

// Evidences is the resolver for the evidences field.
func (r *taskResolver) Evidences(ctx context.Context, obj *types.Task, first *int, after *page.CursorKey, last *int, before *page.CursorKey, orderBy *types.EvidenceOrderBy) (*types.EvidenceConnection, error) {
	if err := r.authorize(ctx, obj.ID, probo.ActionEvidenceList); err != nil {
		return nil, err
	}

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

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

	cursor := types.NewCursor(first, after, last, before, pageOrderBy)
	page, err := prb.Evidences.ListForTaskID(ctx, obj.ID, cursor)
	if err != nil {
		r.logger.ErrorCtx(ctx, "cannot list task evidences", log.Error(err))
		return nil, gqlutils.Internal(ctx)
	}

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

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

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

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

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

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

// Task returns schema.TaskResolver implementation.
func (r *Resolver) Task() schema.TaskResolver { return &taskResolver{r} }

// TaskConnection returns schema.TaskConnectionResolver implementation.
func (r *Resolver) TaskConnection() schema.TaskConnectionResolver { return &taskConnectionResolver{r} }

type taskResolver struct{ *Resolver }
type taskConnectionResolver struct{ *Resolver }