schema.resolvers.go

package graph

// 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

import (
	"context"
	"errors"
	"strconv"
	"time"

	"github.com/google/uuid"
	"github.com/guregu/null"
	"github.com/vektah/gqlparser/v2/gqlerror"
	"go.uber.org/zap"
	"golang.org/x/sync/errgroup"

	"github.com/cmsgov/easi-app/pkg/appcontext"
	"github.com/cmsgov/easi-app/pkg/apperrors"
	"github.com/cmsgov/easi-app/pkg/authentication"
	cedarcore "github.com/cmsgov/easi-app/pkg/cedar/core"
	"github.com/cmsgov/easi-app/pkg/email"
	"github.com/cmsgov/easi-app/pkg/flags"
	"github.com/cmsgov/easi-app/pkg/graph/generated"
	"github.com/cmsgov/easi-app/pkg/graph/model"
	"github.com/cmsgov/easi-app/pkg/graph/resolvers"
	"github.com/cmsgov/easi-app/pkg/models"
	"github.com/cmsgov/easi-app/pkg/services"
)

// AlternativeASolution is the resolver for the alternativeASolution field.
func (r *businessCaseResolver) AlternativeASolution(ctx context.Context, obj *models.BusinessCase) (*model.BusinessCaseSolution, error) {
	return &model.BusinessCaseSolution{
		AcquisitionApproach:     obj.AlternativeAAcquisitionApproach.Ptr(),
		Cons:                    obj.AlternativeACons.Ptr(),
		CostSavings:             obj.AlternativeACostSavings.Ptr(),
		HasUI:                   obj.AlternativeAHasUI.Ptr(),
		HostingCloudServiceType: obj.AlternativeAHostingCloudServiceType.Ptr(),
		HostingLocation:         obj.AlternativeAHostingLocation.Ptr(),
		HostingType:             obj.AlternativeAHostingType.Ptr(),
		Pros:                    obj.AlternativeAPros.Ptr(),
		SecurityIsApproved:      obj.AlternativeASecurityIsApproved.Ptr(),
		SecurityIsBeingReviewed: obj.AlternativeASecurityIsBeingReviewed.Ptr(),
		Summary:                 obj.AlternativeASummary.Ptr(),
		Title:                   obj.AlternativeATitle.Ptr(),
	}, nil
}

// AlternativeBSolution is the resolver for the alternativeBSolution field.
func (r *businessCaseResolver) AlternativeBSolution(ctx context.Context, obj *models.BusinessCase) (*model.BusinessCaseSolution, error) {
	return &model.BusinessCaseSolution{
		AcquisitionApproach:     obj.AlternativeBAcquisitionApproach.Ptr(),
		Cons:                    obj.AlternativeBCons.Ptr(),
		CostSavings:             obj.AlternativeBCostSavings.Ptr(),
		HasUI:                   obj.AlternativeBHasUI.Ptr(),
		HostingCloudServiceType: obj.AlternativeBHostingCloudServiceType.Ptr(),
		HostingLocation:         obj.AlternativeBHostingLocation.Ptr(),
		HostingType:             obj.AlternativeBHostingType.Ptr(),
		Pros:                    obj.AlternativeBPros.Ptr(),
		SecurityIsApproved:      obj.AlternativeBSecurityIsApproved.Ptr(),
		SecurityIsBeingReviewed: obj.AlternativeBSecurityIsBeingReviewed.Ptr(),
		Summary:                 obj.AlternativeBSummary.Ptr(),
		Title:                   obj.AlternativeBTitle.Ptr(),
	}, nil
}

// LifecycleCostLines is the resolver for the lifecycleCostLines field.
func (r *businessCaseResolver) LifecycleCostLines(ctx context.Context, obj *models.BusinessCase) ([]*models.EstimatedLifecycleCost, error) {
	lifeCycleCostLines := obj.LifecycleCostLines

	if len(lifeCycleCostLines) == 0 {
		return nil, nil
	}

	var costLines []*models.EstimatedLifecycleCost
	for _, cost := range lifeCycleCostLines {
		costLine := &models.EstimatedLifecycleCost{
			BusinessCaseID: cost.BusinessCaseID,
			Cost:           cost.Cost,
			ID:             cost.ID,
			Phase:          cost.Phase,
			Solution:       cost.Solution,
			Year:           cost.Year,
		}
		costLines = append(costLines, costLine)
	}

	return costLines, nil
}

// PreferredSolution is the resolver for the preferredSolution field.
func (r *businessCaseResolver) PreferredSolution(ctx context.Context, obj *models.BusinessCase) (*model.BusinessCaseSolution, error) {
	return &model.BusinessCaseSolution{
		AcquisitionApproach:     obj.PreferredAcquisitionApproach.Ptr(),
		Cons:                    obj.PreferredCons.Ptr(),
		CostSavings:             obj.PreferredCostSavings.Ptr(),
		HasUI:                   obj.PreferredHasUI.Ptr(),
		HostingCloudServiceType: obj.PreferredHostingCloudServiceType.Ptr(),
		HostingLocation:         obj.PreferredHostingLocation.Ptr(),
		HostingType:             obj.PreferredHostingType.Ptr(),
		Pros:                    obj.PreferredPros.Ptr(),
		SecurityIsApproved:      obj.PreferredSecurityIsApproved.Ptr(),
		SecurityIsBeingReviewed: obj.PreferredSecurityIsBeingReviewed.Ptr(),
		Summary:                 obj.PreferredSummary.Ptr(),
		Title:                   obj.PreferredTitle.Ptr(),
	}, nil
}

// SystemIntake is the resolver for the systemIntake field.
func (r *businessCaseResolver) SystemIntake(ctx context.Context, obj *models.BusinessCase) (*models.SystemIntake, error) {
	return r.store.FetchSystemIntakeByID(ctx, obj.SystemIntakeID)
}

// BudgetActualCost is the resolver for the budgetActualCost field.
func (r *cedarBudgetSystemCostResolver) BudgetActualCost(ctx context.Context, obj *models.CedarBudgetSystemCost) ([]*model.CedarBudgetActualCost, error) {
	budgetActualCosts := obj.BudgetActualCosts

	if len(budgetActualCosts) == 0 {
		return nil, nil
	}

	var actualCosts []*model.CedarBudgetActualCost
	for _, cost := range budgetActualCosts {
		fyCost := &model.CedarBudgetActualCost{
			ActualSystemCost: cost.ActualSystemCost.Ptr(),
			FiscalYear:       cost.FiscalYear.Ptr(),
			SystemID:         cost.SystemID.Ptr(),
		}
		actualCosts = append(actualCosts, fyCost)
	}

	return actualCosts, nil
}

// SoftwareProducts is the resolver for the softwareProducts field.
func (r *cedarSoftwareProductsResolver) SoftwareProducts(ctx context.Context, obj *models.CedarSoftwareProducts) ([]*model.CedarSoftwareProductItem, error) {
	softwareProducts := obj.SoftwareProducts

	if len(softwareProducts) == 0 {
		return nil, nil
	}

	var softwareProductItems []*model.CedarSoftwareProductItem
	for _, softwareProduct := range softwareProducts {
		softwareProductItem := &model.CedarSoftwareProductItem{
			APIGatewayUse:                  &softwareProduct.APIGatewayUse,
			ElaPurchase:                    softwareProduct.ElaPurchase.Ptr(),
			ElaVendorID:                    softwareProduct.ElaVendorID.Ptr(),
			ProvidesAiCapability:           &softwareProduct.ProvidesAiCapability,
			Refstr:                         softwareProduct.Refstr.Ptr(),
			SoftwareCatagoryConnectionGUID: softwareProduct.SoftwareCatagoryConnectionGUID.Ptr(),
			SoftwareVendorConnectionGUID:   softwareProduct.SoftwareVendorConnectionGUID.Ptr(),
			SoftwareCost:                   softwareProduct.SoftwareCost.Ptr(),
			SoftwareElaOrganization:        softwareProduct.SoftwareElaOrganization.Ptr(),
			SoftwareName:                   softwareProduct.SoftwareName.Ptr(),
			SystemSoftwareConnectionGUID:   softwareProduct.SystemSoftwareConnectionGUID.Ptr(),
			TechnopediaCategory:            softwareProduct.TechnopediaCategory.Ptr(),
			TechnopediaID:                  softwareProduct.TechnopediaID.Ptr(),
			VendorName:                     softwareProduct.VendorName.Ptr(),
		}
		softwareProductItems = append(softwareProductItems, softwareProductItem)
	}

	return softwareProductItems, nil
}

// BusinessOwnerRoles is the resolver for the businessOwnerRoles field.
func (r *cedarSystemResolver) BusinessOwnerRoles(ctx context.Context, obj *models.CedarSystem) ([]*models.CedarRole, error) {
	cedarRoles, err := r.cedarCoreClient.GetBusinessOwnerRolesBySystem(ctx, obj.ID.String)
	if err != nil {
		return nil, err
	}
	return cedarRoles, nil
}

// IsBookmarked is the resolver for the isBookmarked field.
func (r *cedarSystemResolver) IsBookmarked(ctx context.Context, obj *models.CedarSystem) (bool, error) {
	return resolvers.CedarSystemIsBookmarked(ctx, obj.ID.String)
}

// SystemMaintainerInformation is the resolver for the systemMaintainerInformation field.
func (r *cedarSystemDetailsResolver) SystemMaintainerInformation(ctx context.Context, obj *models.CedarSystemDetails) (*model.CedarSystemMaintainerInformation, error) {
	return &model.CedarSystemMaintainerInformation{
		AdHocAgileDeploymentFrequency:         obj.SystemMaintainerInformation.AdHocAgileDeploymentFrequency.Ptr(),
		AgileUsed:                             &obj.SystemMaintainerInformation.AgileUsed,
		AuthoritativeDatasource:               obj.SystemMaintainerInformation.AuthoritativeDatasource.Ptr(),
		BusinessArtifactsOnDemand:             &obj.SystemMaintainerInformation.BusinessArtifactsOnDemand,
		DataAtRestEncryptionKeyManagement:     obj.SystemMaintainerInformation.DataAtRestEncryptionKeyManagement.Ptr(),
		DeploymentFrequency:                   obj.SystemMaintainerInformation.DeploymentFrequency.Ptr(),
		DevCompletionPercent:                  obj.SystemMaintainerInformation.DevCompletionPercent.Ptr(),
		DevWorkDescription:                    obj.SystemMaintainerInformation.DevWorkDescription.Ptr(),
		EcapParticipation:                     &obj.SystemMaintainerInformation.EcapParticipation,
		FrontendAccessType:                    obj.SystemMaintainerInformation.FrontendAccessType.Ptr(),
		HardCodedIPAddress:                    &obj.SystemMaintainerInformation.HardCodedIPAddress,
		IP6EnabledAssetPercent:                obj.SystemMaintainerInformation.IP6EnabledAssetPercent.Ptr(),
		IP6TransitionPlan:                     obj.SystemMaintainerInformation.IP6TransitionPlan.Ptr(),
		IPEnabledAssetCount:                   &obj.SystemMaintainerInformation.IPEnabledAssetCount,
		LegalHoldCaseName:                     obj.SystemMaintainerInformation.LegalHoldCaseName.Ptr(),
		LocallyStoredUserInformation:          &obj.SystemMaintainerInformation.LocallyStoredUserInformation,
		MajorRefreshDate:                      obj.SystemMaintainerInformation.MajorRefreshDate.Ptr(),
		MultifactorAuthenticationMethod:       models.StringsFromZeroStrs(obj.SystemMaintainerInformation.MultifactorAuthenticationMethod),
		MultifactorAuthenticationMethodOther:  obj.SystemMaintainerInformation.MultifactorAuthenticationMethodOther.Ptr(),
		NetAccessibility:                      obj.SystemMaintainerInformation.NetAccessibility.Ptr(),
		NetworkTrafficEncryptionKeyManagement: obj.SystemMaintainerInformation.NetworkTrafficEncryptionKeyManagement.Ptr(),
		NoMajorRefresh:                        &obj.SystemMaintainerInformation.NoMajorRefresh,
		NoPersistentRecordsFlag:               &obj.SystemMaintainerInformation.NoPersistentRecordsFlag,
		NoPlannedMajorRefresh:                 &obj.SystemMaintainerInformation.NoPlannedMajorRefresh,
		OmDocumentationOnDemand:               &obj.SystemMaintainerInformation.OmDocumentationOnDemand,
		PlansToRetireReplace:                  obj.SystemMaintainerInformation.PlansToRetireReplace.Ptr(),
		QuarterToRetireReplace:                obj.SystemMaintainerInformation.QuarterToRetireReplace.Ptr(),
		RecordsManagementBucket:               models.StringsFromZeroStrs(obj.SystemMaintainerInformation.RecordsManagementBucket),
		RecordsManagementDisposalLocation:     obj.SystemMaintainerInformation.RecordsManagementDisposalLocation.Ptr(),
		RecordsManagementDisposalPlan:         obj.SystemMaintainerInformation.RecordsManagementDisposalPlan.Ptr(),
		RecordsUnderLegalHold:                 &obj.SystemMaintainerInformation.RecordsUnderLegalHold,
		SourceCodeOnDemand:                    &obj.SystemMaintainerInformation.SourceCodeOnDemand,
		SystemCustomization:                   obj.SystemMaintainerInformation.SystemCustomization.Ptr(),
		SystemDataLocation:                    models.StringsFromZeroStrs(obj.SystemMaintainerInformation.SystemDataLocation),
		SystemDataLocationNotes:               obj.SystemMaintainerInformation.SystemDataLocationNotes.Ptr(),
		SystemDesignOnDemand:                  &obj.SystemMaintainerInformation.SystemDesignOnDemand,
		SystemProductionDate:                  obj.SystemMaintainerInformation.SystemProductionDate.Ptr(),
		SystemRequirementsOnDemand:            &obj.SystemMaintainerInformation.SystemRequirementsOnDemand,
		TestPlanOnDemand:                      &obj.SystemMaintainerInformation.TestPlanOnDemand,
		TestReportsOnDemand:                   &obj.SystemMaintainerInformation.TestReportsOnDemand,
		TestScriptsOnDemand:                   &obj.SystemMaintainerInformation.TestScriptsOnDemand,
		YearToRetireReplace:                   obj.SystemMaintainerInformation.YearToRetireReplace.Ptr(),
	}, nil
}

// BusinessOwnerInformation is the resolver for the businessOwnerInformation field.
func (r *cedarSystemDetailsResolver) BusinessOwnerInformation(ctx context.Context, obj *models.CedarSystemDetails) (*model.CedarBusinessOwnerInformation, error) {
	return &model.CedarBusinessOwnerInformation{
		BeneficiaryAddressPurpose:      models.StringsFromZeroStrs(obj.BusinessOwnerInformation.BeneficiaryAddressPurpose),
		BeneficiaryAddressPurposeOther: obj.BusinessOwnerInformation.BeneficiaryAddressPurposeOther.Ptr(),
		BeneficiaryAddressSource:       models.StringsFromZeroStrs(obj.BusinessOwnerInformation.BeneficiaryAddressSource),
		BeneficiaryAddressSourceOther:  obj.BusinessOwnerInformation.BeneficiaryAddressSourceOther.Ptr(),
		BeneficiaryInformation:         models.StringsFromZeroStrs(obj.BusinessOwnerInformation.BeneficiaryInformation),
		CostPerYear:                    obj.BusinessOwnerInformation.CostPerYear.Ptr(),
		EditBeneficiaryInformation:     &obj.BusinessOwnerInformation.EditBeneficiaryInformation,
		IsCmsOwned:                     &obj.BusinessOwnerInformation.IsCmsOwned,
		Nr508UserInterface:             obj.BusinessOwnerInformation.Nr508UserInterface.Ptr(),
		NumberOfContractorFte:          obj.BusinessOwnerInformation.NumberOfContractorFte.Ptr(),
		NumberOfFederalFte:             obj.BusinessOwnerInformation.NumberOfFederalFte.Ptr(),
		NumberOfSupportedUsersPerMonth: obj.BusinessOwnerInformation.NumberOfSupportedUsersPerMonth.Ptr(),
		StoresBankingData:              &obj.BusinessOwnerInformation.StoresBankingData,
		StoresBeneficiaryAddress:       &obj.BusinessOwnerInformation.StoresBeneficiaryAddress,
	}, nil
}

// Author is the resolver for the author field.
func (r *governanceRequestFeedbackResolver) Author(ctx context.Context, obj *models.GovernanceRequestFeedback) (*models.UserInfo, error) {
	return resolvers.GetGovernanceRequestFeedbackAuthor(ctx, r.service.FetchUserInfo, obj.CreatedBy)
}

// IntakeFormStatus is the resolver for the intakeFormStatus field.
func (r *iTGovTaskStatusesResolver) IntakeFormStatus(ctx context.Context, obj *models.ITGovTaskStatuses) (models.ITGovIntakeFormStatus, error) {
	return resolvers.IntakeFormStatus(obj.ParentSystemIntake)
}

// FeedbackFromInitialReviewStatus is the resolver for the feedbackFromInitialReviewStatus field.
func (r *iTGovTaskStatusesResolver) FeedbackFromInitialReviewStatus(ctx context.Context, obj *models.ITGovTaskStatuses) (models.ITGovFeedbackStatus, error) {
	return resolvers.FeedbackFromInitialReviewStatus(obj.ParentSystemIntake)
}

// BizCaseDraftStatus is the resolver for the bizCaseDraftStatus field.
func (r *iTGovTaskStatusesResolver) BizCaseDraftStatus(ctx context.Context, obj *models.ITGovTaskStatuses) (models.ITGovDraftBusinessCaseStatus, error) {
	return resolvers.BizCaseDraftStatus(obj.ParentSystemIntake)
}

// GrtMeetingStatus is the resolver for the grtMeetingStatus field.
func (r *iTGovTaskStatusesResolver) GrtMeetingStatus(ctx context.Context, obj *models.ITGovTaskStatuses) (models.ITGovGRTStatus, error) {
	return resolvers.GrtMeetingStatus(obj.ParentSystemIntake)
}

// BizCaseFinalStatus is the resolver for the bizCaseFinalStatus field.
func (r *iTGovTaskStatusesResolver) BizCaseFinalStatus(ctx context.Context, obj *models.ITGovTaskStatuses) (models.ITGovFinalBusinessCaseStatus, error) {
	return resolvers.BizCaseFinalStatus(obj.ParentSystemIntake)
}

// GrbMeetingStatus is the resolver for the grbMeetingStatus field.
func (r *iTGovTaskStatusesResolver) GrbMeetingStatus(ctx context.Context, obj *models.ITGovTaskStatuses) (models.ITGovGRBStatus, error) {
	return resolvers.GrbMeetingStatus(obj.ParentSystemIntake)
}

// DecisionAndNextStepsStatus is the resolver for the decisionAndNextStepsStatus field.
func (r *iTGovTaskStatusesResolver) DecisionAndNextStepsStatus(ctx context.Context, obj *models.ITGovTaskStatuses) (models.ITGovDecisionStatus, error) {
	return resolvers.DecisionAndNextStepsStatus(obj.ParentSystemIntake)
}

// CreateSystemIntakeActionProgressToNewStep is the resolver for the createSystemIntakeActionProgressToNewStep field.
func (r *mutationResolver) CreateSystemIntakeActionProgressToNewStep(ctx context.Context, input model.SystemIntakeProgressToNewStepsInput) (*model.UpdateSystemIntakePayload, error) {
	updatedIntake, err := resolvers.ProgressIntake(
		ctx,
		r.store,
		r.emailClient,
		r.service.FetchUserInfo,
		input,
	)

	return &model.UpdateSystemIntakePayload{
		SystemIntake: updatedIntake,
	}, err
}

// CreateSystemIntakeActionRequestEdits is the resolver for the createSystemIntakeActionRequestEdits field.
func (r *mutationResolver) CreateSystemIntakeActionRequestEdits(ctx context.Context, input model.SystemIntakeRequestEditsInput) (*model.UpdateSystemIntakePayload, error) {
	intake, err := resolvers.CreateSystemIntakeActionRequestEdits(
		ctx,
		r.store,
		r.emailClient,
		r.service.FetchUserInfo,
		input,
	)
	return &model.UpdateSystemIntakePayload{
		SystemIntake: intake,
	}, err
}

// CreateSystemIntakeActionExpireLcid is the resolver for the createSystemIntakeActionExpireLCID field.
func (r *mutationResolver) CreateSystemIntakeActionExpireLcid(ctx context.Context, input model.SystemIntakeExpireLCIDInput) (*model.UpdateSystemIntakePayload, error) {
	intake, err := resolvers.ExpireLCID(
		ctx,
		r.store,
		r.emailClient,
		r.service.FetchUserInfo,
		input,
	)

	return &model.UpdateSystemIntakePayload{
		SystemIntake: intake,
	}, err
}

// CreateSystemIntakeActionUpdateLcid is the resolver for the createSystemIntakeActionUpdateLCID field.
func (r *mutationResolver) CreateSystemIntakeActionUpdateLcid(ctx context.Context, input model.SystemIntakeUpdateLCIDInput) (*model.UpdateSystemIntakePayload, error) {
	intake, err := resolvers.UpdateLCID(
		ctx,
		r.store,
		r.emailClient,
		r.service.FetchUserInfo,
		input,
	)

	return &model.UpdateSystemIntakePayload{
		SystemIntake: intake,
	}, err
}

// CreateSystemIntakeActionRetireLcid is the resolver for the createSystemIntakeActionRetireLCID field.
func (r *mutationResolver) CreateSystemIntakeActionRetireLcid(ctx context.Context, input model.SystemIntakeRetireLCIDInput) (*model.UpdateSystemIntakePayload, error) {
	intake, err := resolvers.RetireLCID(
		ctx,
		r.store,
		r.emailClient,
		r.service.FetchUserInfo,
		input,
	)

	return &model.UpdateSystemIntakePayload{
		SystemIntake: intake,
	}, err
}

// CreateSystemIntakeActionChangeLCIDRetirementDate is the resolver for the createSystemIntakeActionChangeLCIDRetirementDate field.
func (r *mutationResolver) CreateSystemIntakeActionChangeLCIDRetirementDate(ctx context.Context, input model.SystemIntakeChangeLCIDRetirementDateInput) (*model.UpdateSystemIntakePayload, error) {
	intake, err := resolvers.ChangeLCIDRetirementDate(
		ctx,
		r.store,
		r.emailClient,
		r.service.FetchUserInfo,
		input,
	)

	return &model.UpdateSystemIntakePayload{
		SystemIntake: intake,
	}, err
}

// CreateSystemIntakeActionConfirmLcid is the resolver for the createSystemIntakeActionConfirmLCID field.
func (r *mutationResolver) CreateSystemIntakeActionConfirmLcid(ctx context.Context, input model.SystemIntakeConfirmLCIDInput) (*model.UpdateSystemIntakePayload, error) {
	intake, err := resolvers.ConfirmLCID(
		ctx,
		r.store,
		r.emailClient,
		r.service.FetchUserInfo,
		input,
	)

	return &model.UpdateSystemIntakePayload{
		SystemIntake: intake,
	}, err
}

// CreateSystemIntakeActionIssueLcid is the resolver for the createSystemIntakeActionIssueLCID field.
func (r *mutationResolver) CreateSystemIntakeActionIssueLcid(ctx context.Context, input model.SystemIntakeIssueLCIDInput) (*model.UpdateSystemIntakePayload, error) {
	updatedIntake, err := resolvers.IssueLCID(
		ctx,
		r.store,
		r.emailClient,
		r.service.FetchUserInfo,
		input,
	)

	return &model.UpdateSystemIntakePayload{
		SystemIntake: updatedIntake,
	}, err
}

// CreateSystemIntakeActionRejectIntake is the resolver for the createSystemIntakeActionRejectIntake field.
func (r *mutationResolver) CreateSystemIntakeActionRejectIntake(ctx context.Context, input model.SystemIntakeRejectIntakeInput) (*model.UpdateSystemIntakePayload, error) {
	updatedIntake, err := resolvers.RejectIntakeAsNotApproved(
		ctx,
		r.store,
		r.emailClient,
		r.service.FetchUserInfo,
		input,
	)

	return &model.UpdateSystemIntakePayload{
		SystemIntake: updatedIntake,
	}, err
}

// CreateSystemIntakeActionReopenRequest is the resolver for the createSystemIntakeActionReopenRequest field.
func (r *mutationResolver) CreateSystemIntakeActionReopenRequest(ctx context.Context, input model.SystemIntakeReopenRequestInput) (*model.UpdateSystemIntakePayload, error) {
	intake, err := resolvers.CreateSystemIntakeActionReopenRequest(
		ctx,
		r.store,
		r.emailClient,
		r.service.FetchUserInfo,
		input,
	)
	return &model.UpdateSystemIntakePayload{
		SystemIntake: intake,
	}, err
}

// CreateSystemIntakeActionCloseRequest is the resolver for the createSystemIntakeActionCloseRequest field.
func (r *mutationResolver) CreateSystemIntakeActionCloseRequest(ctx context.Context, input model.SystemIntakeCloseRequestInput) (*model.UpdateSystemIntakePayload, error) {
	intake, err := resolvers.CreateSystemIntakeActionCloseRequest(
		ctx,
		r.store,
		r.emailClient,
		r.service.FetchUserInfo,
		input,
	)
	return &model.UpdateSystemIntakePayload{
		SystemIntake: intake,
	}, err
}

// CreateSystemIntakeActionNotITGovRequest is the resolver for the createSystemIntakeActionNotITGovRequest field.
func (r *mutationResolver) CreateSystemIntakeActionNotITGovRequest(ctx context.Context, input model.SystemIntakeNotITGovReqInput) (*model.UpdateSystemIntakePayload, error) {
	intake, err := resolvers.CreateSystemIntakeActionNotITGovRequest(
		ctx,
		r.store,
		r.emailClient,
		r.service.FetchUserInfo,
		input,
	)
	return &model.UpdateSystemIntakePayload{
		SystemIntake: intake,
	}, err
}

// CreateSystemIntakeNote is the resolver for the createSystemIntakeNote field.
func (r *mutationResolver) CreateSystemIntakeNote(ctx context.Context, input model.CreateSystemIntakeNoteInput) (*models.SystemIntakeNote, error) {
	return resolvers.CreateSystemIntakeNote(ctx, r.store, input)
}

// UpdateSystemIntakeNote is the resolver for the updateSystemIntakeNote field.
func (r *mutationResolver) UpdateSystemIntakeNote(ctx context.Context, input model.UpdateSystemIntakeNoteInput) (*models.SystemIntakeNote, error) {
	return resolvers.UpdateSystemIntakeNote(ctx, r.store, r.service.FetchUserInfo, input)
}

// CreateSystemIntake is the resolver for the createSystemIntake field.
func (r *mutationResolver) CreateSystemIntake(ctx context.Context, input model.CreateSystemIntakeInput) (*models.SystemIntake, error) {
	return resolvers.CreateSystemIntake(ctx, r.store, input)
}

// SubmitIntake is the resolver for the submitIntake field.
func (r *mutationResolver) SubmitIntake(ctx context.Context, input model.SubmitIntakeInput) (*model.UpdateSystemIntakePayload, error) {
	return resolvers.SubmitIntake(ctx, r.store, r.service.FetchUserInfo, r.service.SubmitIntake, input)
}

// UpdateSystemIntakeAdminLead is the resolver for the updateSystemIntakeAdminLead field.
func (r *mutationResolver) UpdateSystemIntakeAdminLead(ctx context.Context, input model.UpdateSystemIntakeAdminLeadInput) (*model.UpdateSystemIntakePayload, error) {
	savedAdminLead, err := r.store.UpdateAdminLead(ctx, input.ID, input.AdminLead)
	systemIntake := models.SystemIntake{
		AdminLead: null.StringFrom(savedAdminLead),
		ID:        input.ID,
	}
	return &model.UpdateSystemIntakePayload{
		SystemIntake: &systemIntake,
	}, err
}

// UpdateSystemIntakeReviewDates is the resolver for the updateSystemIntakeReviewDates field.
func (r *mutationResolver) UpdateSystemIntakeReviewDates(ctx context.Context, input model.UpdateSystemIntakeReviewDatesInput) (*model.UpdateSystemIntakePayload, error) {
	intake, err := r.store.UpdateReviewDates(ctx, input.ID, input.GrbDate, input.GrtDate)
	return &model.UpdateSystemIntakePayload{
		SystemIntake: intake,
	}, err
}

// UpdateSystemIntakeContactDetails is the resolver for the updateSystemIntakeContactDetails field.
func (r *mutationResolver) UpdateSystemIntakeContactDetails(ctx context.Context, input model.UpdateSystemIntakeContactDetailsInput) (*model.UpdateSystemIntakePayload, error) {
	return resolvers.SystemIntakeUpdateContactDetails(ctx, r.store, input)
}

// UpdateSystemIntakeRequestDetails is the resolver for the updateSystemIntakeRequestDetails field.
func (r *mutationResolver) UpdateSystemIntakeRequestDetails(ctx context.Context, input model.UpdateSystemIntakeRequestDetailsInput) (*model.UpdateSystemIntakePayload, error) {
	return resolvers.SystemIntakeUpdate(ctx, r.store, r.cedarCoreClient.GetSystem, input)
}

// UpdateSystemIntakeContractDetails is the resolver for the updateSystemIntakeContractDetails field.
func (r *mutationResolver) UpdateSystemIntakeContractDetails(ctx context.Context, input model.UpdateSystemIntakeContractDetailsInput) (*model.UpdateSystemIntakePayload, error) {
	return resolvers.SystemIntakeUpdateContractDetails(ctx, r.store, input)
}

// CreateCedarSystemBookmark is the resolver for the createCedarSystemBookmark field.
func (r *mutationResolver) CreateCedarSystemBookmark(ctx context.Context, input model.CreateCedarSystemBookmarkInput) (*model.CreateCedarSystemBookmarkPayload, error) {
	bookmark := models.CedarSystemBookmark{
		EUAUserID:     appcontext.Principal(ctx).ID(),
		CedarSystemID: input.CedarSystemID,
	}
	createdBookmark, err := r.store.CreateCedarSystemBookmark(ctx, &bookmark)
	if err != nil {
		return nil, err
	}
	return &model.CreateCedarSystemBookmarkPayload{
		CedarSystemBookmark: createdBookmark,
	}, nil
}

// DeleteCedarSystemBookmark is the resolver for the deleteCedarSystemBookmark field.
func (r *mutationResolver) DeleteCedarSystemBookmark(ctx context.Context, input model.CreateCedarSystemBookmarkInput) (*model.DeleteCedarSystemBookmarkPayload, error) {
	_, err := r.store.DeleteCedarSystemBookmark(ctx, &models.CedarSystemBookmark{
		CedarSystemID: input.CedarSystemID,
	})
	if err != nil {
		return nil, err
	}
	return &model.DeleteCedarSystemBookmarkPayload{CedarSystemID: input.CedarSystemID}, nil
}

// SetSystemIntakeRelationNewSystem is the resolver for the setSystemIntakeRelationNewSystem field.
func (r *mutationResolver) SetSystemIntakeRelationNewSystem(ctx context.Context, input *model.SetSystemIntakeRelationNewSystemInput) (*model.UpdateSystemIntakePayload, error) {
	// This resolver's only real purpose is to delete existing relations or data that might have been set previously by selecting other options when
	// selecting if the intake relates to another system, service, or contract.
	// It is also responsible for creating contract number relationships for this intake
	//
	// Pseudo-code for this resolver (best if handled in a transaction):
	// 1. Delete (if any) existing CEDAR System ID relations that were set by SetSystemIntakeRelationExistingSystem()
	// 2. Delete (if any) existing free-text contract/service name that might have been set by SetSystemIntakeRelationExistingService()
	// 3. Delete & Create Contract Number relations (Delete & Create because this mutation always receives the full state of the relations)
	intake, err := resolvers.SetSystemIntakeRelationNewSystem(ctx, r.store, input)
	if err != nil {
		return nil, err
	}

	return &model.UpdateSystemIntakePayload{
		SystemIntake: intake,
	}, nil
}

// SetSystemIntakeRelationExistingSystem is the resolver for the setSystemIntakeRelationExistingSystem field.
func (r *mutationResolver) SetSystemIntakeRelationExistingSystem(ctx context.Context, input *model.SetSystemIntakeRelationExistingSystemInput) (*model.UpdateSystemIntakePayload, error) {
	// This resolver's purpose is to relate this System Intake to some number of CEDAR System IDs and Contract Numbers
	// It is also responsible for clearing any previous relations that might have been set by SetSystemIntakeRelationExistingService(), which,
	// in practice, should just be the `contractName` field.
	intake, err := resolvers.SetSystemIntakeRelationExistingSystem(ctx, r.store, r.cedarCoreClient.GetSystem, input)
	if err != nil {
		return nil, err
	}

	return &model.UpdateSystemIntakePayload{
		SystemIntake: intake,
	}, nil
}

// SetSystemIntakeRelationExistingService is the resolver for the setSystemIntakeRelationExistingService field.
func (r *mutationResolver) SetSystemIntakeRelationExistingService(ctx context.Context, input *model.SetSystemIntakeRelationExistingServiceInput) (*model.UpdateSystemIntakePayload, error) {
	// This resolver's purpose is to relate this System Intake to a free-text contract/service name, and some number of Contract Numbers
	// It is also responsible for clearing any previous relations that might have been set by SetSystemIntakeRelationExistingSystem(), which,
	// in practice, should just be the CEDAR System ID relations.
	//
	// Pseudo-code for this resolver (best if handled in a transaction):
	// 1. Delete (if any) existing CEDAR System ID relations that might have been set by SetSystemIntakeRelationExistingSystem()
	// 2. Set the free-text contract/service name
	// 3. Delete & Create Contract Number relations (Delete & Create because this mutation always receives the full state of the relations)
	intake, err := resolvers.SetSystemIntakeRelationExistingService(ctx, r.store, input)
	if err != nil {
		return nil, err
	}

	return &model.UpdateSystemIntakePayload{
		SystemIntake: intake,
	}, nil
}

// UnlinkSystemIntakeRelation is the resolver for the unlinkSystemIntakeRelation field.
func (r *mutationResolver) UnlinkSystemIntakeRelation(ctx context.Context, intakeID uuid.UUID) (*model.UpdateSystemIntakePayload, error) {
	intake, err := resolvers.UnlinkSystemIntakeRelation(ctx, r.store, intakeID)

	if err != nil {
		return nil, err
	}

	return &model.UpdateSystemIntakePayload{
		SystemIntake: intake,
	}, nil
}

// CreateSystemIntakeContact is the resolver for the createSystemIntakeContact field.
func (r *mutationResolver) CreateSystemIntakeContact(ctx context.Context, input model.CreateSystemIntakeContactInput) (*model.CreateSystemIntakeContactPayload, error) {
	return resolvers.CreateSystemIntakeContact(ctx, r.store, input)
}

// UpdateSystemIntakeContact is the resolver for the updateSystemIntakeContact field.
func (r *mutationResolver) UpdateSystemIntakeContact(ctx context.Context, input model.UpdateSystemIntakeContactInput) (*model.CreateSystemIntakeContactPayload, error) {
	return resolvers.UpdateSystemIntakeContact(ctx, r.store, input)
}

// DeleteSystemIntakeContact is the resolver for the deleteSystemIntakeContact field.
func (r *mutationResolver) DeleteSystemIntakeContact(ctx context.Context, input model.DeleteSystemIntakeContactInput) (*model.DeleteSystemIntakeContactPayload, error) {
	contact := &models.SystemIntakeContact{
		ID: input.ID,
	}
	_, err := r.store.DeleteSystemIntakeContact(ctx, contact)
	if err != nil {
		return nil, err
	}
	return &model.DeleteSystemIntakeContactPayload{
		SystemIntakeContact: contact,
	}, nil
}

// UpdateSystemIntakeLinkedCedarSystem is the resolver for the updateSystemIntakeLinkedCedarSystem field.
func (r *mutationResolver) UpdateSystemIntakeLinkedCedarSystem(ctx context.Context, input model.UpdateSystemIntakeLinkedCedarSystemInput) (*model.UpdateSystemIntakePayload, error) {
	// If the linked system is not nil, make sure it's a valid CEDAR system, otherwise return an error
	if input.CedarSystemID != nil && len(*input.CedarSystemID) > 0 {
		_, err := r.cedarCoreClient.GetSystem(ctx, *input.CedarSystemID)

		if err != nil {
			return nil, err
		}
	}

	intake, err := r.store.UpdateSystemIntakeLinkedCedarSystem(ctx, input.ID, null.StringFromPtr(input.CedarSystemID))

	if err != nil {
		return nil, err
	}

	return &model.UpdateSystemIntakePayload{
		SystemIntake: intake,
	}, nil
}

// SendFeedbackEmail is the resolver for the sendFeedbackEmail field.
func (r *mutationResolver) SendFeedbackEmail(ctx context.Context, input model.SendFeedbackEmailInput) (*string, error) {
	var reporterName, reporterEmail string

	if !input.IsAnonymous {
		euaUserID := appcontext.Principal(ctx).ID()
		userInfo, err := r.service.FetchUserInfo(ctx, euaUserID)
		if err != nil {
			return nil, err
		}
		reporterName = userInfo.DisplayName
		reporterEmail = userInfo.Email.String()
	}

	err := r.emailClient.SendFeedbackEmail(ctx, email.SendFeedbackEmailInput{
		IsAnonymous:            input.IsAnonymous,
		ReporterName:           reporterName,
		ReporterEmail:          reporterEmail,
		CanBeContacted:         input.CanBeContacted,
		EasiServicesUsed:       input.EasiServicesUsed,
		CmsRole:                input.CmsRole,
		SystemEasyToUse:        input.SystemEasyToUse,
		DidntNeedHelpAnswering: input.DidntNeedHelpAnswering,
		QuestionsWereRelevant:  input.QuestionsWereRelevant,
		HadAccessToInformation: input.HadAccessToInformation,
		HowSatisfied:           input.HowSatisfied,
		HowCanWeImprove:        input.HowCanWeImprove,
	})

	if err != nil {
		return nil, err
	}

	msg := "Feedback sent successfully"
	return &msg, nil
}

// SendCantFindSomethingEmail is the resolver for the sendCantFindSomethingEmail field.
func (r *mutationResolver) SendCantFindSomethingEmail(ctx context.Context, input model.SendCantFindSomethingEmailInput) (*string, error) {
	euaUserID := appcontext.Principal(ctx).ID()
	userInfo, err := r.service.FetchUserInfo(ctx, euaUserID)
	if err != nil {
		return nil, err
	}

	err = r.emailClient.SendCantFindSomethingEmail(ctx, email.SendCantFindSomethingEmailInput{
		Name:  userInfo.DisplayName,
		Email: userInfo.Email.String(),
		Body:  input.Body,
	})

	if err != nil {
		return nil, err
	}

	msg := "Feedback sent successfully"
	return &msg, nil
}

// SendReportAProblemEmail is the resolver for the sendReportAProblemEmail field.
func (r *mutationResolver) SendReportAProblemEmail(ctx context.Context, input model.SendReportAProblemEmailInput) (*string, error) {
	var reporterName, reporterEmail string

	if !input.IsAnonymous {
		euaUserID := appcontext.Principal(ctx).ID()
		userInfo, err := r.service.FetchUserInfo(ctx, euaUserID)
		if err != nil {
			return nil, err
		}
		reporterName = userInfo.DisplayName
		reporterEmail = userInfo.Email.String()
	}

	err := r.emailClient.SendReportAProblemEmail(ctx, email.SendReportAProblemEmailInput{
		IsAnonymous:            input.IsAnonymous,
		ReporterName:           reporterName,
		ReporterEmail:          reporterEmail,
		CanBeContacted:         input.CanBeContacted,
		EasiService:            input.EasiService,
		WhatWereYouDoing:       input.WhatWereYouDoing,
		WhatWentWrong:          input.WhatWentWrong,
		HowSevereWasTheProblem: input.HowSevereWasTheProblem,
	})

	if err != nil {
		return nil, err
	}

	msg := "Feedback sent successfully"
	return &msg, nil
}

// CreateTRBRequest is the resolver for the createTRBRequest field.
func (r *mutationResolver) CreateTRBRequest(ctx context.Context, requestType models.TRBRequestType) (*models.TRBRequest, error) {
	return resolvers.CreateTRBRequest(ctx, requestType, r.store)
}

// UpdateTRBRequest is the resolver for the updateTRBRequest field.
func (r *mutationResolver) UpdateTRBRequest(ctx context.Context, id uuid.UUID, changes map[string]interface{}) (*models.TRBRequest, error) {
	return resolvers.UpdateTRBRequest(ctx, id, changes, r.store)
}

// CreateTRBRequestAttendee is the resolver for the createTRBRequestAttendee field.
func (r *mutationResolver) CreateTRBRequestAttendee(ctx context.Context, input model.CreateTRBRequestAttendeeInput) (*models.TRBRequestAttendee, error) {
	role := models.PersonRole(input.Role)
	return resolvers.CreateTRBRequestAttendee(
		ctx,
		r.store,
		r.emailClient.SendTRBAttendeeAddedNotification,
		r.service.FetchUserInfo,
		&models.TRBRequestAttendee{
			TRBRequestID: input.TrbRequestID,
			EUAUserID:    input.EuaUserID,
			Component:    &input.Component,
			Role:         &role,
		},
	)
}

// UpdateTRBRequestAttendee is the resolver for the updateTRBRequestAttendee field.
func (r *mutationResolver) UpdateTRBRequestAttendee(ctx context.Context, input model.UpdateTRBRequestAttendeeInput) (*models.TRBRequestAttendee, error) {
	role := models.PersonRole(input.Role)
	attendee := &models.TRBRequestAttendee{
		Component: &input.Component,
		Role:      &role,
	}
	attendee.ID = input.ID
	return resolvers.UpdateTRBRequestAttendee(ctx, r.store, attendee)
}

// DeleteTRBRequestAttendee is the resolver for the deleteTRBRequestAttendee field.
func (r *mutationResolver) DeleteTRBRequestAttendee(ctx context.Context, id uuid.UUID) (*models.TRBRequestAttendee, error) {
	return resolvers.DeleteTRBRequestAttendee(ctx, r.store, id)
}

// CreateTRBRequestDocument is the resolver for the createTRBRequestDocument field.
func (r *mutationResolver) CreateTRBRequestDocument(ctx context.Context, input model.CreateTRBRequestDocumentInput) (*model.CreateTRBRequestDocumentPayload, error) {
	doc, err := resolvers.CreateTRBRequestDocument(ctx, r.store, r.s3Client, input)
	if err != nil {
		return nil, err
	}

	return &model.CreateTRBRequestDocumentPayload{
		Document: doc,
	}, nil
}

// DeleteTRBRequestDocument is the resolver for the deleteTRBRequestDocument field.
func (r *mutationResolver) DeleteTRBRequestDocument(ctx context.Context, id uuid.UUID) (*model.DeleteTRBRequestDocumentPayload, error) {
	doc, err := resolvers.DeleteTRBRequestDocument(ctx, r.store, id)
	if err != nil {
		return nil, err
	}

	return &model.DeleteTRBRequestDocumentPayload{
		Document: doc,
	}, nil
}

// CreateSystemIntakeDocument is the resolver for the createSystemIntakeDocument field.
func (r *mutationResolver) CreateSystemIntakeDocument(ctx context.Context, input model.CreateSystemIntakeDocumentInput) (*model.CreateSystemIntakeDocumentPayload, error) {
	doc, err := resolvers.CreateSystemIntakeDocument(ctx, r.store, r.s3Client, input)
	if err != nil {
		return nil, err
	}

	return &model.CreateSystemIntakeDocumentPayload{
		Document: doc,
	}, nil
}

// DeleteSystemIntakeDocument is the resolver for the deleteSystemIntakeDocument field.
func (r *mutationResolver) DeleteSystemIntakeDocument(ctx context.Context, id uuid.UUID) (*model.DeleteSystemIntakeDocumentPayload, error) {
	doc, err := resolvers.DeleteSystemIntakeDocument(ctx, r.store, id)
	if err != nil {
		return nil, err
	}

	return &model.DeleteSystemIntakeDocumentPayload{
		Document: doc,
	}, nil
}

// UpdateTRBRequestForm is the resolver for the updateTRBRequestForm field.
func (r *mutationResolver) UpdateTRBRequestForm(ctx context.Context, input map[string]interface{}) (*models.TRBRequestForm, error) {
	return resolvers.UpdateTRBRequestForm(
		ctx,
		r.store,
		r.emailClient,
		r.service.FetchUserInfo,
		input,
	)
}

// UpdateTRBRequestFundingSources is the resolver for the updateTRBRequestFundingSources field.
func (r *mutationResolver) UpdateTRBRequestFundingSources(ctx context.Context, input model.UpdateTRBRequestFundingSourcesInput) ([]*models.TRBFundingSource, error) {
	return resolvers.UpdateTRBRequestFundingSources(ctx, r.store, input.TrbRequestID, input.FundingNumber, input.Sources)
}

// DeleteTRBRequestFundingSources is the resolver for the deleteTRBRequestFundingSources field.
func (r *mutationResolver) DeleteTRBRequestFundingSources(ctx context.Context, input model.DeleteTRBRequestFundingSourcesInput) ([]*models.TRBFundingSource, error) {
	return resolvers.DeleteTRBRequestFundingSources(ctx, r.store, input.TrbRequestID, input.FundingNumber)
}

// SetRolesForUserOnSystem is the resolver for the setRolesForUserOnSystem field.
func (r *mutationResolver) SetRolesForUserOnSystem(ctx context.Context, input model.SetRolesForUserOnSystemInput) (*string, error) {
	rs, err := r.cedarCoreClient.SetRolesForUser(ctx, input.CedarSystemID, input.EuaUserID, input.DesiredRoleTypeIDs)
	if err != nil {
		return nil, err
	}

	// Asyncronously send an email to the CEDAR team notifying them of the change
	go func() {
		// make a new context and copy the logger to it, or else the request will cancel when the parent context cancels
		emailCtx := appcontext.WithLogger(context.Background(), appcontext.ZLogger(ctx))

		// Fetch user info for _both_ the requester _and_ the user whose roles were changed
		// We're using 2 calls to `FetchUserInfo` rather than 1 call to `FetchUserInfos` since we don't know what order they'll come back in with the latter function
		g := new(errgroup.Group)
		var requesterUserInfo *models.UserInfo
		var errRequester error
		g.Go(func() error {
			requesterUserInfo, errRequester = r.service.FetchUserInfo(emailCtx, appcontext.Principal(ctx).ID())
			return errRequester
		})

		var targetUserInfo *models.UserInfo
		var errTarget error
		g.Go(func() error {
			targetUserInfo, errTarget = r.service.FetchUserInfo(emailCtx, input.EuaUserID)
			return errTarget
		})

		// wait for both calls to complete
		err := g.Wait()
		if err != nil {
			// don't fail the request if the lookup fails, just log and return from the go func
			appcontext.ZLogger(emailCtx).Error("failed to lookup user infos for CEDAR notification email", zap.Error(err))
			return
		}

		err = r.emailClient.SendCedarRolesChangedEmail(emailCtx, requesterUserInfo.DisplayName, targetUserInfo.DisplayName, rs.DidAdd, rs.DidDelete, rs.RoleTypeNamesBefore, rs.RoleTypeNamesAfter, rs.SystemName, time.Now())
		if err != nil {
			// don't fail the request if the email fails, just log and return from the go func
			appcontext.ZLogger(emailCtx).Error("failed to send CEDAR notification email", zap.Error(err))
			return
		}
	}()

	resp := "Roles changed successfully"
	return &resp, nil
}

// CreateTRBRequestFeedback is the resolver for the createTRBRequestFeedback field.
func (r *mutationResolver) CreateTRBRequestFeedback(ctx context.Context, input model.CreateTRBRequestFeedbackInput) (*models.TRBRequestFeedback, error) {
	notifyEuas := models.ConvertEnums[string](input.NotifyEuaIds)
	return resolvers.CreateTRBRequestFeedback(
		ctx,
		r.store,
		r.emailClient,
		r.service.FetchUserInfo,
		r.service.FetchUserInfos,
		&models.TRBRequestFeedback{
			TRBRequestID:    input.TrbRequestID,
			FeedbackMessage: models.HTML(input.FeedbackMessage),
			CopyTRBMailbox:  input.CopyTrbMailbox,
			NotifyEUAIDs:    notifyEuas,
			Action:          input.Action,
		})
}

// UpdateTRBRequestConsultMeetingTime is the resolver for the updateTRBRequestConsultMeetingTime field.
func (r *mutationResolver) UpdateTRBRequestConsultMeetingTime(ctx context.Context, input model.UpdateTRBRequestConsultMeetingTimeInput) (*models.TRBRequest, error) {
	return resolvers.UpdateTRBRequestConsultMeetingTime(
		ctx,
		r.store,
		r.emailClient,
		r.service.FetchUserInfo,
		r.service.FetchUserInfos,
		input.TrbRequestID,
		input.ConsultMeetingTime,
		input.CopyTrbMailbox,
		input.NotifyEuaIds,
		input.Notes,
	)
}

// UpdateTRBRequestTRBLead is the resolver for the updateTRBRequestTRBLead field.
func (r *mutationResolver) UpdateTRBRequestTRBLead(ctx context.Context, input model.UpdateTRBRequestTRBLeadInput) (*models.TRBRequest, error) {
	return resolvers.UpdateTRBRequestTRBLead(
		ctx,
		r.store,
		r.emailClient,
		r.service.FetchUserInfo,
		input.TrbRequestID,
		input.TrbLead,
	)
}

// SetTRBRequestRelationNewSystem is the resolver for the setTRBRequestRelationNewSystem field.
func (r *mutationResolver) SetTRBRequestRelationNewSystem(ctx context.Context, input model.SetTRBRequestRelationNewSystemInput) (*models.TRBRequest, error) {
	return resolvers.SetTRBRequestRelationNewSystem(ctx, r.store, input)
}

// SetTRBRequestRelationExistingSystem is the resolver for the setTRBRequestRelationExistingSystem field.
func (r *mutationResolver) SetTRBRequestRelationExistingSystem(ctx context.Context, input model.SetTRBRequestRelationExistingSystemInput) (*models.TRBRequest, error) {
	return resolvers.SetTRBRequestRelationExistingSystem(ctx, r.store, r.cedarCoreClient.GetSystem, input)
}

// SetTRBRequestRelationExistingService is the resolver for the setTRBRequestRelationExistingService field.
func (r *mutationResolver) SetTRBRequestRelationExistingService(ctx context.Context, input model.SetTRBRequestRelationExistingServiceInput) (*models.TRBRequest, error) {
	return resolvers.SetTRBRequestRelationExistingService(ctx, r.store, input)
}

// UnlinkTRBRequestRelation is the resolver for the unlinkTRBRequestRelation field.
func (r *mutationResolver) UnlinkTRBRequestRelation(ctx context.Context, trbRequestID uuid.UUID) (*models.TRBRequest, error) {
	return resolvers.UnlinkTRBRequestRelation(ctx, r.store, trbRequestID)
}

// CreateTRBAdminNoteGeneralRequest is the resolver for the createTRBAdminNoteGeneralRequest field.
func (r *mutationResolver) CreateTRBAdminNoteGeneralRequest(ctx context.Context, input model.CreateTRBAdminNoteGeneralRequestInput) (*models.TRBAdminNote, error) {
	return resolvers.CreateTRBAdminNoteGeneralRequest(ctx, r.store, input)
}

// CreateTRBAdminNoteInitialRequestForm is the resolver for the createTRBAdminNoteInitialRequestForm field.
func (r *mutationResolver) CreateTRBAdminNoteInitialRequestForm(ctx context.Context, input model.CreateTRBAdminNoteInitialRequestFormInput) (*models.TRBAdminNote, error) {
	return resolvers.CreateTRBAdminNoteInitialRequestForm(ctx, r.store, input)
}

// CreateTRBAdminNoteSupportingDocuments is the resolver for the createTRBAdminNoteSupportingDocuments field.
func (r *mutationResolver) CreateTRBAdminNoteSupportingDocuments(ctx context.Context, input model.CreateTRBAdminNoteSupportingDocumentsInput) (*models.TRBAdminNote, error) {
	return resolvers.CreateTRBAdminNoteSupportingDocuments(ctx, r.store, input)
}

// CreateTRBAdminNoteConsultSession is the resolver for the createTRBAdminNoteConsultSession field.
func (r *mutationResolver) CreateTRBAdminNoteConsultSession(ctx context.Context, input model.CreateTRBAdminNoteConsultSessionInput) (*models.TRBAdminNote, error) {
	return resolvers.CreateTRBAdminNoteConsultSession(ctx, r.store, input)
}

// CreateTRBAdminNoteAdviceLetter is the resolver for the createTRBAdminNoteAdviceLetter field.
func (r *mutationResolver) CreateTRBAdminNoteAdviceLetter(ctx context.Context, input model.CreateTRBAdminNoteAdviceLetterInput) (*models.TRBAdminNote, error) {
	return resolvers.CreateTRBAdminNoteAdviceLetter(ctx, r.store, input)
}

// SetTRBAdminNoteArchived is the resolver for the setTRBAdminNoteArchived field.
func (r *mutationResolver) SetTRBAdminNoteArchived(ctx context.Context, id uuid.UUID, isArchived bool) (*models.TRBAdminNote, error) {
	return resolvers.SetTRBAdminNoteArchived(ctx, r.store, id, isArchived)
}

// CreateTRBAdviceLetter is the resolver for the createTRBAdviceLetter field.
func (r *mutationResolver) CreateTRBAdviceLetter(ctx context.Context, trbRequestID uuid.UUID) (*models.TRBAdviceLetter, error) {
	return resolvers.CreateTRBAdviceLetter(ctx, r.store, trbRequestID)
}

// UpdateTRBAdviceLetter is the resolver for the updateTRBAdviceLetter field.
func (r *mutationResolver) UpdateTRBAdviceLetter(ctx context.Context, input map[string]interface{}) (*models.TRBAdviceLetter, error) {
	return resolvers.UpdateTRBAdviceLetter(ctx, r.store, input)
}

// RequestReviewForTRBAdviceLetter is the resolver for the requestReviewForTRBAdviceLetter field.
func (r *mutationResolver) RequestReviewForTRBAdviceLetter(ctx context.Context, id uuid.UUID) (*models.TRBAdviceLetter, error) {
	return resolvers.RequestReviewForTRBAdviceLetter(
		ctx,
		r.store,
		r.emailClient,
		r.service.FetchUserInfo,
		id)
}

// SendTRBAdviceLetter is the resolver for the sendTRBAdviceLetter field.
func (r *mutationResolver) SendTRBAdviceLetter(ctx context.Context, input model.SendTRBAdviceLetterInput) (*models.TRBAdviceLetter, error) {
	return resolvers.SendTRBAdviceLetter(
		ctx,
		r.store,
		input.ID,
		r.emailClient,
		r.service.FetchUserInfo,
		r.service.FetchUserInfos,
		input.CopyTrbMailbox,
		input.NotifyEuaIds)
}

// CreateTRBAdviceLetterRecommendation is the resolver for the createTRBAdviceLetterRecommendation field.
func (r *mutationResolver) CreateTRBAdviceLetterRecommendation(ctx context.Context, input model.CreateTRBAdviceLetterRecommendationInput) (*models.TRBAdviceLetterRecommendation, error) {
	links := models.ConvertEnums[string](input.Links)
	return resolvers.CreateTRBAdviceLetterRecommendation(
		ctx,
		r.store,
		&models.TRBAdviceLetterRecommendation{
			TRBRequestID:   input.TrbRequestID,
			Title:          input.Title,
			Recommendation: input.Recommendation,
			Links:          links,
		})
}

// UpdateTRBAdviceLetterRecommendation is the resolver for the updateTRBAdviceLetterRecommendation field.
func (r *mutationResolver) UpdateTRBAdviceLetterRecommendation(ctx context.Context, input map[string]interface{}) (*models.TRBAdviceLetterRecommendation, error) {
	return resolvers.UpdateTRBAdviceLetterRecommendation(ctx, r.store, input)
}

// UpdateTRBAdviceLetterRecommendationOrder is the resolver for the updateTRBAdviceLetterRecommendationOrder field.
func (r *mutationResolver) UpdateTRBAdviceLetterRecommendationOrder(ctx context.Context, input model.UpdateTRBAdviceLetterRecommendationOrderInput) ([]*models.TRBAdviceLetterRecommendation, error) {
	return resolvers.UpdateTRBAdviceLetterRecommendationOrder(ctx, r.store, input.TrbRequestID, input.NewOrder)
}

// DeleteTRBAdviceLetterRecommendation is the resolver for the deleteTRBAdviceLetterRecommendation field.
func (r *mutationResolver) DeleteTRBAdviceLetterRecommendation(ctx context.Context, id uuid.UUID) (*models.TRBAdviceLetterRecommendation, error) {
	return resolvers.DeleteTRBAdviceLetterRecommendation(ctx, r.store, id)
}

// CloseTRBRequest is the resolver for the closeTRBRequest field.
func (r *mutationResolver) CloseTRBRequest(ctx context.Context, input model.CloseTRBRequestInput) (*models.TRBRequest, error) {
	return resolvers.CloseTRBRequest(
		ctx,
		r.store,
		r.emailClient,
		r.service.FetchUserInfo,
		r.service.FetchUserInfos,
		input.ID,
		input.ReasonClosed,
		input.CopyTrbMailbox,
		input.NotifyEuaIds,
	)
}

// ReopenTrbRequest is the resolver for the reopenTrbRequest field.
func (r *mutationResolver) ReopenTrbRequest(ctx context.Context, input model.ReopenTRBRequestInput) (*models.TRBRequest, error) {
	return resolvers.ReopenTRBRequest(
		ctx,
		r.store,
		input.TrbRequestID,
		input.ReasonReopened,
		input.CopyTrbMailbox,
		input.NotifyEuaIds,
		r.emailClient,
		r.service.FetchUserInfo,
		r.service.FetchUserInfos,
	)
}

// CreateTrbLeadOption is the resolver for the createTrbLeadOption field.
func (r *mutationResolver) CreateTrbLeadOption(ctx context.Context, eua string) (*models.UserInfo, error) {
	return resolvers.CreateTRBLeadOption(ctx, r.store, r.service.FetchUserInfo, eua)
}

// DeleteTrbLeadOption is the resolver for the deleteTrbLeadOption field.
func (r *mutationResolver) DeleteTrbLeadOption(ctx context.Context, eua string) (bool, error) {
	return resolvers.DeleteTRBLeadOption(ctx, r.store, eua)
}

// Requests is the resolver for the requests field. (First is not in use)
func (r *queryResolver) Requests(ctx context.Context, first int) (*model.RequestsConnection, error) {
	intakes, queryErr := r.store.FetchSystemIntakesByEuaID(ctx, appcontext.Principal(ctx).ID())
	if queryErr != nil {
		return nil, gqlerror.Errorf("query error: %s", queryErr)
	}

	edges := []*model.RequestEdge{}

	for _, intake := range intakes {
		var requesterStatus models.SystemIntakeStatusRequester
		requesterStatus, queryErr = resolvers.CalculateSystemIntakeRequesterStatus(&intake, time.Now())
		if queryErr != nil {
			return nil, gqlerror.Errorf("query error: %s", queryErr)
		}
		var nextMeetingDate *time.Time
		grbDateIsSetAndNotInPast := intake.GRBDate != nil && time.Now().Before(*intake.GRBDate)
		grtDateIsSetAndNotInPast := intake.GRTDate != nil && time.Now().Before(*intake.GRTDate)
		if grbDateIsSetAndNotInPast && grtDateIsSetAndNotInPast {
			if intake.GRBDate.Before(*intake.GRTDate) {
				nextMeetingDate = intake.GRBDate
			} else {
				nextMeetingDate = intake.GRTDate
			}
		} else if grtDateIsSetAndNotInPast {
			nextMeetingDate = intake.GRTDate
		} else if grbDateIsSetAndNotInPast {
			nextMeetingDate = intake.GRBDate
		}
		node := model.Request{
			ID:              intake.ID,
			SubmittedAt:     intake.SubmittedAt,
			Name:            intake.ProjectName.Ptr(),
			Type:            model.RequestTypeGovernanceRequest,
			StatusRequester: &requesterStatus,
			StatusCreatedAt: intake.CreatedAt,
			Lcid:            intake.LifecycleID.Ptr(),
			NextMeetingDate: nextMeetingDate,
		}
		edges = append(edges, &model.RequestEdge{
			Node: &node,
		})
	}

	return &model.RequestsConnection{Edges: edges}, nil
}

// SystemIntake is the resolver for the systemIntake field.
func (r *queryResolver) SystemIntake(ctx context.Context, id uuid.UUID) (*models.SystemIntake, error) {
	intake, err := r.store.FetchSystemIntakeByID(ctx, id)
	if err != nil {
		return nil, err
	}

	ok, err := services.AuthorizeUserIsIntakeRequesterOrHasGRTJobCode(ctx, intake)
	if err != nil {
		return nil, err
	}
	if !ok {
		return nil, &apperrors.UnauthorizedError{Err: errors.New("unauthorized to fetch system intake")}
	}

	return intake, nil
}

// SystemIntakes is the resolver for the systemIntakes field.
func (r *queryResolver) SystemIntakes(ctx context.Context, openRequests bool) ([]*models.SystemIntake, error) {
	return resolvers.SystemIntakes(ctx, r.store, openRequests)
}

// SystemIntakesWithLcids is the resolver for the systemIntakesWithLcids field.
func (r *queryResolver) SystemIntakesWithLcids(ctx context.Context) ([]*models.SystemIntake, error) {
	return r.store.GetSystemIntakesWithLCIDs(ctx)
}

// CurrentUser is the resolver for the currentUser field.
func (r *queryResolver) CurrentUser(ctx context.Context) (*model.CurrentUser, error) {
	ldUser := flags.Principal(ctx)
	userKey := ldUser.GetKey()
	signedHash := r.ldClient.SecureModeHash(ldUser)

	currentUser := model.CurrentUser{
		LaunchDarkly: &model.LaunchDarklySettings{
			UserKey:    userKey,
			SignedHash: signedHash,
		},
	}
	return &currentUser, nil
}

// CedarAuthorityToOperate is the resolver for the cedarAuthorityToOperate field.
func (r *queryResolver) CedarAuthorityToOperate(ctx context.Context, cedarSystemID string) ([]*models.CedarAuthorityToOperate, error) {
	cedarATO, err := r.cedarCoreClient.GetAuthorityToOperate(ctx, cedarSystemID)
	if err != nil {
		return nil, err
	}

	return cedarATO, nil
}

// CedarBudget is the resolver for the cedarBudget field.
func (r *queryResolver) CedarBudget(ctx context.Context, cedarSystemID string) ([]*models.CedarBudget, error) {
	cedarBudget, err := r.cedarCoreClient.GetBudgetBySystem(ctx, cedarSystemID)
	if err != nil {
		return nil, err
	}

	return cedarBudget, nil
}

// CedarBudgetSystemCost is the resolver for the cedarBudgetSystemCost field.
func (r *queryResolver) CedarBudgetSystemCost(ctx context.Context, cedarSystemID string) (*models.CedarBudgetSystemCost, error) {
	cedarBudgetSystemCost, err := r.cedarCoreClient.GetBudgetSystemCostBySystem(ctx, cedarSystemID)
	if err != nil {
		return nil, err
	}

	return cedarBudgetSystemCost, nil
}

// CedarPersonsByCommonName is the resolver for the cedarPersonsByCommonName field.
func (r *queryResolver) CedarPersonsByCommonName(ctx context.Context, commonName string) ([]*models.UserInfo, error) {
	response, err := r.service.SearchCommonNameContains(ctx, commonName)
	if err != nil {
		return nil, err
	}

	return response, nil
}

// CedarSoftwareProducts is the resolver for the cedarSoftwareProducts field.
func (r *queryResolver) CedarSoftwareProducts(ctx context.Context, cedarSystemID string) (*models.CedarSoftwareProducts, error) {
	cedarSoftwareProducts, err := r.cedarCoreClient.GetSoftwareProductsBySystem(ctx, cedarSystemID)
	if err != nil {
		return nil, err
	}
	return cedarSoftwareProducts, nil
}

// CedarSystem is the resolver for the cedarSystem field.
func (r *queryResolver) CedarSystem(ctx context.Context, cedarSystemID string) (*models.CedarSystem, error) {
	cedarSystem, err := r.cedarCoreClient.GetSystem(ctx, cedarSystemID)
	if err != nil {
		return nil, err
	}
	return cedarSystem, nil
}

// CedarSystems is the resolver for the cedarSystems field.
func (r *queryResolver) CedarSystems(ctx context.Context) ([]*models.CedarSystem, error) {
	return r.cedarCoreClient.GetSystemSummary(ctx)
}

// CedarSubSystems is the resolver for the cedarSubSystems field.
func (r *queryResolver) CedarSubSystems(ctx context.Context, cedarSystemID string) ([]*models.CedarSubSystem, error) {
	systems, err := r.cedarCoreClient.GetSystemSummary(ctx, cedarcore.WithSubSystems(cedarSystemID))
	if err != nil {
		return nil, err
	}

	var subSystems []*models.CedarSubSystem
	for _, system := range systems {
		subSystems = append(subSystems, &models.CedarSubSystem{
			ID:          system.ID,
			Name:        system.Name,
			Acronym:     system.Acronym,
			Description: system.Description,
		})
	}

	return subSystems, nil
}

// CedarContractsBySystem is the resolver for the cedarContractsBySystem field.
func (r *queryResolver) CedarContractsBySystem(ctx context.Context, cedarSystemID string) ([]*models.CedarContract, error) {
	return r.cedarCoreClient.GetContractBySystem(ctx, cedarSystemID)
}

// MyCedarSystems is the resolver for the myCedarSystems field.
func (r *queryResolver) MyCedarSystems(ctx context.Context) ([]*models.CedarSystem, error) {
	requesterEUAID := appcontext.Principal(ctx).ID()
	return r.cedarCoreClient.GetSystemSummary(ctx, cedarcore.WithEuaIDFilter(requesterEUAID))
}

// CedarSystemBookmarks is the resolver for the cedarSystemBookmarks field.
func (r *queryResolver) CedarSystemBookmarks(ctx context.Context) ([]*models.CedarSystemBookmark, error) {
	cedarSystemBookmarks, err := r.store.FetchCedarSystemBookmarks(ctx)
	if err != nil {
		return nil, err
	}
	return cedarSystemBookmarks, nil
}

// CedarThreat is the resolver for the cedarThreat field.
func (r *queryResolver) CedarThreat(ctx context.Context, cedarSystemID string) ([]*models.CedarThreat, error) {
	cedarThreat, err := r.cedarCoreClient.GetThreat(ctx, cedarSystemID)
	if err != nil {
		return nil, err
	}
	return cedarThreat, nil
}

// Deployments is the resolver for the deployments field.
func (r *queryResolver) Deployments(ctx context.Context, cedarSystemID string, deploymentType *string, state *string, status *string) ([]*models.CedarDeployment, error) {
	var optionalParams *cedarcore.GetDeploymentsOptionalParams
	if deploymentType != nil || state != nil || status != nil {
		optionalParams = &cedarcore.GetDeploymentsOptionalParams{}

		if deploymentType != nil {
			optionalParams.DeploymentType = deploymentType
		}

		if state != nil {
			optionalParams.State = state
		}

		if status != nil {
			optionalParams.Status = status
		}
	}

	cedarDeployments, err := r.cedarCoreClient.GetDeployments(ctx, cedarSystemID, optionalParams)
	if err != nil {
		return nil, err
	}

	return cedarDeployments, nil
}

// RoleTypes is the resolver for the roleTypes field.
func (r *queryResolver) RoleTypes(ctx context.Context) ([]*models.CedarRoleType, error) {
	roleTypes, err := r.cedarCoreClient.GetRoleTypes(ctx)
	if err != nil {
		return nil, err
	}

	return roleTypes, nil
}

// Roles is the resolver for the roles field.
func (r *queryResolver) Roles(ctx context.Context, cedarSystemID string, roleTypeID *string) ([]*models.CedarRole, error) {
	cedarRoles, err := r.cedarCoreClient.GetRolesBySystem(ctx, cedarSystemID, roleTypeID)
	if err != nil {
		return nil, err
	}

	return cedarRoles, nil
}

// Exchanges is the resolver for the exchanges field.
func (r *queryResolver) Exchanges(ctx context.Context, cedarSystemID string) ([]*models.CedarExchange, error) {
	exchanges, err := r.cedarCoreClient.GetExchangesBySystem(ctx, cedarSystemID)
	if err != nil {
		return nil, err
	}

	return exchanges, nil
}

// Urls is the resolver for the urls field.
func (r *queryResolver) Urls(ctx context.Context, cedarSystemID string) ([]*models.CedarURL, error) {
	cedarURLs, err := r.cedarCoreClient.GetURLsForSystem(ctx, cedarSystemID)
	if err != nil {
		return nil, err
	}
	return cedarURLs, nil
}

// CedarSystemDetails is the resolver for the cedarSystemDetails field.
func (r *queryResolver) CedarSystemDetails(ctx context.Context, cedarSystemID string) (*models.CedarSystemDetails, error) {
	g := new(errgroup.Group)

	var sysDetail *models.CedarSystemDetails
	var errS error
	g.Go(func() error {
		sysDetail, errS = r.cedarCoreClient.GetSystemDetail(ctx, cedarSystemID)
		return errS
	})

	var cedarRoles []*models.CedarRole
	var errR error
	g.Go(func() error {
		cedarRoles, errR = r.cedarCoreClient.GetRolesBySystem(ctx, cedarSystemID, nil)
		return errR
	})

	var cedarDeployments []*models.CedarDeployment
	var errD error
	g.Go(func() error {
		cedarDeployments, errD = r.cedarCoreClient.GetDeployments(ctx, cedarSystemID, nil)
		return errD
	})

	var cedarThreats []*models.CedarThreat
	var errT error
	g.Go(func() error {
		cedarThreats, errT = r.cedarCoreClient.GetThreat(ctx, cedarSystemID)
		return errT
	})

	var cedarURLs []*models.CedarURL
	var errU error
	g.Go(func() error {
		cedarURLs, errU = r.cedarCoreClient.GetURLsForSystem(ctx, cedarSystemID)
		return errU
	})

	if err := g.Wait(); err != nil {
		return nil, err
	}

	dCedarSys := models.CedarSystemDetails{
		CedarSystem:                 sysDetail.CedarSystem,
		BusinessOwnerInformation:    sysDetail.BusinessOwnerInformation,
		SystemMaintainerInformation: sysDetail.SystemMaintainerInformation,
		Roles:                       cedarRoles,
		Deployments:                 cedarDeployments,
		Threats:                     cedarThreats,
		URLs:                        cedarURLs,
	}

	return &dCedarSys, nil
}

// SystemIntakeContacts is the resolver for the systemIntakeContacts field.
func (r *queryResolver) SystemIntakeContacts(ctx context.Context, id uuid.UUID) (*model.SystemIntakeContactsPayload, error) {
	contacts, err := r.store.FetchSystemIntakeContactsBySystemIntakeID(ctx, id)
	if err != nil {
		return nil, err
	}

	if len(contacts) == 0 {
		return &model.SystemIntakeContactsPayload{}, nil
	}

	euaIDs := make([]string, len(contacts))
	for i, contact := range contacts {
		euaIDs[i] = contact.EUAUserID
	}

	userInfos, err := r.service.FetchUserInfos(ctx, euaIDs)
	if err != nil {
		return nil, err
	}

	userInfoMap := make(map[string]*models.UserInfo)
	for _, userInfo := range userInfos {
		if userInfo != nil {
			userInfoMap[userInfo.Username] = userInfo
		}
	}

	augmentedContacts := make([]*models.AugmentedSystemIntakeContact, 0, len(contacts))
	invalidEUAIDs := make([]string, 0, len(contacts))
	for _, contact := range contacts {
		if userInfo, found := userInfoMap[contact.EUAUserID]; found {
			augmentedContacts = append(augmentedContacts, &models.AugmentedSystemIntakeContact{
				SystemIntakeContact: *contact,
				CommonName:          userInfo.DisplayName,
				Email:               userInfo.Email,
			})
		} else {
			invalidEUAIDs = append(invalidEUAIDs, contact.EUAUserID)
		}
	}

	return &model.SystemIntakeContactsPayload{
		SystemIntakeContacts: augmentedContacts,
		InvalidEUAIDs:        invalidEUAIDs,
	}, nil
}

// TrbRequest is the resolver for the trbRequest field.
func (r *queryResolver) TrbRequest(ctx context.Context, id uuid.UUID) (*models.TRBRequest, error) {
	return resolvers.GetTRBRequestByID(ctx, id, r.store)
}

// TrbRequests is the resolver for the trbRequests field.
func (r *queryResolver) TrbRequests(ctx context.Context, archived bool) ([]*models.TRBRequest, error) {
	return resolvers.GetTRBRequests(ctx, archived, r.store)
}

// MyTrbRequests is the resolver for the myTrbRequests field.
func (r *queryResolver) MyTrbRequests(ctx context.Context, archived bool) ([]*models.TRBRequest, error) {
	return resolvers.GetMyTRBRequests(ctx, archived, r.store)
}

// TrbLeadOptions is the resolver for the trbLeadOptions field.
func (r *queryResolver) TrbLeadOptions(ctx context.Context) ([]*models.UserInfo, error) {
	return resolvers.GetTRBLeadOptions(ctx, r.store, r.service.FetchUserInfos)
}

// TrbAdminNote is the resolver for the trbAdminNote field.
func (r *queryResolver) TrbAdminNote(ctx context.Context, id uuid.UUID) (*models.TRBAdminNote, error) {
	return resolvers.GetTRBAdminNoteByID(ctx, r.store, id)
}

// UserAccount is the resolver for the userAccount field.
func (r *queryResolver) UserAccount(ctx context.Context, username string) (*authentication.UserAccount, error) {
	return resolvers.UserAccountGetByUsername(r.store, username)
}

// Actions is the resolver for the actions field.
func (r *systemIntakeResolver) Actions(ctx context.Context, obj *models.SystemIntake) ([]*model.SystemIntakeAction, error) {
	actions, actionsErr := r.store.GetActionsByRequestID(ctx, obj.ID)
	if actionsErr != nil {
		return nil, actionsErr
	}

	var results []*model.SystemIntakeAction
	for _, action := range actions {
		graphAction := model.SystemIntakeAction{
			ID:   action.ID,
			Step: action.Step,
			Type: model.SystemIntakeActionType(action.ActionType),
			Actor: &model.SystemIntakeActionActor{
				Name:  action.ActorName,
				Email: action.ActorEmail.String(),
			},
			Feedback:               action.Feedback,
			CreatedAt:              *action.CreatedAt,
			NewRetirementDate:      action.LCIDRetirementChangeNewDate,
			PreviousRetirementDate: action.LCIDRetirementChangePreviousDate,
		}

		if action.LCIDExpirationChangeNewDate != nil && action.LCIDExpirationChangePreviousDate != nil {
			graphAction.LcidExpirationChange = &model.SystemIntakeLCIDExpirationChange{
				NewDate:              *action.LCIDExpirationChangeNewDate,
				PreviousDate:         *action.LCIDExpirationChangePreviousDate,
				NewScope:             action.LCIDExpirationChangeNewScope,
				PreviousScope:        action.LCIDExpirationChangePreviousScope,
				NewNextSteps:         action.LCIDExpirationChangeNewNextSteps,
				PreviousNextSteps:    action.LCIDExpirationChangePreviousNextSteps,
				NewCostBaseline:      action.LCIDExpirationChangeNewCostBaseline.Ptr(),
				PreviousCostBaseline: action.LCIDExpirationChangePreviousCostBaseline.Ptr(),
			}
		}
		results = append(results, &graphAction)
	}
	return results, nil
}

// BusinessCase is the resolver for the businessCase field.
func (r *systemIntakeResolver) BusinessCase(ctx context.Context, obj *models.SystemIntake) (*models.BusinessCase, error) {
	return r.store.FetchBusinessCaseBySystemIntakeID(ctx, obj.ID)
}

// BusinessOwner is the resolver for the businessOwner field.
func (r *systemIntakeResolver) BusinessOwner(ctx context.Context, obj *models.SystemIntake) (*model.SystemIntakeBusinessOwner, error) {
	return &model.SystemIntakeBusinessOwner{
		Component: obj.BusinessOwnerComponent.Ptr(),
		Name:      obj.BusinessOwner.Ptr(),
	}, nil
}

// BusinessSolution is the resolver for the businessSolution field.
func (r *systemIntakeResolver) BusinessSolution(ctx context.Context, obj *models.SystemIntake) (*string, error) {
	return obj.Solution.Ptr(), nil
}

// Contract is the resolver for the contract field.
func (r *systemIntakeResolver) Contract(ctx context.Context, obj *models.SystemIntake) (*model.SystemIntakeContract, error) {
	contractEnd := model.ContractDate{}
	if len(obj.ContractEndMonth.String) > 0 {
		contractEnd.Month = obj.ContractEndMonth.Ptr()
	}

	if len(obj.ContractEndYear.String) > 0 {
		contractEnd.Year = obj.ContractEndYear.Ptr()
	}

	if obj.ContractEndDate != nil {
		endDate := *obj.ContractEndDate
		year, month, day := endDate.Date()

		dayStr := strconv.Itoa(day)
		monthStr := strconv.Itoa(int(month))
		yearStr := strconv.Itoa(year)

		contractEnd.Day = &dayStr
		contractEnd.Month = &monthStr
		contractEnd.Year = &yearStr
	}

	contractStart := model.ContractDate{}
	if len(obj.ContractStartMonth.String) > 0 {
		contractStart.Month = obj.ContractStartMonth.Ptr()
	}

	if len(obj.ContractStartYear.String) > 0 {
		contractStart.Year = obj.ContractStartYear.Ptr()
	}

	if obj.ContractStartDate != nil {
		startDate := *obj.ContractStartDate
		year, month, day := startDate.Date()

		dayStr := strconv.Itoa(day)
		monthStr := strconv.Itoa(int(month))
		yearStr := strconv.Itoa(year)

		contractStart.Day = &dayStr
		contractStart.Month = &monthStr
		contractStart.Year = &yearStr
	}

	return &model.SystemIntakeContract{
		Contractor:  obj.Contractor.Ptr(),
		EndDate:     &contractEnd,
		HasContract: obj.ExistingContract.Ptr(),
		StartDate:   &contractStart,
		Vehicle:     obj.ContractVehicle.Ptr(),
	}, nil
}

// Costs is the resolver for the costs field.
func (r *systemIntakeResolver) Costs(ctx context.Context, obj *models.SystemIntake) (*model.SystemIntakeCosts, error) {
	return &model.SystemIntakeCosts{
		ExpectedIncreaseAmount: obj.CostIncreaseAmount.Ptr(),
		IsExpectingIncrease:    obj.CostIncrease.Ptr(),
	}, nil
}

// AnnualSpending is the resolver for the annualSpending field.
func (r *systemIntakeResolver) AnnualSpending(ctx context.Context, obj *models.SystemIntake) (*model.SystemIntakeAnnualSpending, error) {
	return &model.SystemIntakeAnnualSpending{
		CurrentAnnualSpending:           obj.CurrentAnnualSpending.Ptr(),
		CurrentAnnualSpendingITPortion:  obj.CurrentAnnualSpendingITPortion.Ptr(),
		PlannedYearOneSpending:          obj.PlannedYearOneSpending.Ptr(),
		PlannedYearOneSpendingITPortion: obj.PlannedYearOneSpendingITPortion.Ptr(),
	}, nil
}

// CurrentStage is the resolver for the currentStage field.
func (r *systemIntakeResolver) CurrentStage(ctx context.Context, obj *models.SystemIntake) (*string, error) {
	return obj.ProcessStatus.Ptr(), nil
}

// FundingSources is the resolver for the fundingSources field.
func (r *systemIntakeResolver) FundingSources(ctx context.Context, obj *models.SystemIntake) ([]*models.SystemIntakeFundingSource, error) {
	return r.store.FetchSystemIntakeFundingSourcesByIntakeID(ctx, obj.ID)
}

// GovernanceRequestFeedbacks is the resolver for the governanceRequestFeedbacks field.
func (r *systemIntakeResolver) GovernanceRequestFeedbacks(ctx context.Context, obj *models.SystemIntake) ([]*models.GovernanceRequestFeedback, error) {
	return resolvers.GetGovernanceRequestFeedbacksByIntakeID(ctx, r.store, obj.ID)
}

// GovernanceTeams is the resolver for the governanceTeams field.
func (r *systemIntakeResolver) GovernanceTeams(ctx context.Context, obj *models.SystemIntake) (*model.SystemIntakeGovernanceTeam, error) {
	var teams []*model.SystemIntakeCollaborator

	if len(obj.TRBCollaboratorName.String) > 0 {
		key := "technicalReviewBoard"
		label := "Technical Review Board (TRB)"
		acronym := "TRB"
		name := "Technical Review Board"

		teams = append(teams, &model.SystemIntakeCollaborator{
			Key:          key,
			Label:        label,
			Acronym:      acronym,
			Name:         name,
			Collaborator: obj.TRBCollaboratorName.String,
		})
	}

	if len(obj.OITSecurityCollaboratorName.String) > 0 {
		key := "securityPrivacy"
		label := "OIT's Security and Privacy Group (ISPG)"
		acronym := "ISPG"
		name := "OIT's Security and Privacy Group"

		teams = append(teams, &model.SystemIntakeCollaborator{
			Key:          key,
			Label:        label,
			Acronym:      acronym,
			Name:         name,
			Collaborator: obj.OITSecurityCollaboratorName.String,
		})
	}

	if len(obj.EACollaboratorName.String) > 0 {
		key := "enterpriseArchitecture"
		label := "Enterprise Architecture (EA)"
		acronym := "EA"
		name := "Enterprise Architecture"

		teams = append(teams, &model.SystemIntakeCollaborator{
			Key:          key,
			Label:        label,
			Acronym:      acronym,
			Name:         name,
			Collaborator: obj.EACollaboratorName.String,
		})
	}

	isPresent := len(teams) > 0
	return &model.SystemIntakeGovernanceTeam{
		IsPresent: &isPresent,
		Teams:     teams,
	}, nil
}

// Isso is the resolver for the isso field.
func (r *systemIntakeResolver) Isso(ctx context.Context, obj *models.SystemIntake) (*model.SystemIntakeIsso, error) {
	isPresent := len(obj.ISSOName.String) > 0

	return &model.SystemIntakeIsso{
		IsPresent: &isPresent,
		Name:      obj.ISSOName.Ptr(),
	}, nil
}

// Lcid is the resolver for the lcid field.
func (r *systemIntakeResolver) Lcid(ctx context.Context, obj *models.SystemIntake) (*string, error) {
	return obj.LifecycleID.Ptr(), nil
}

// LcidScope is the resolver for the lcidScope field.
func (r *systemIntakeResolver) LcidScope(ctx context.Context, obj *models.SystemIntake) (*models.HTML, error) {
	return obj.LifecycleScope, nil
}

// LcidCostBaseline is the resolver for the lcidCostBaseline field.
func (r *systemIntakeResolver) LcidCostBaseline(ctx context.Context, obj *models.SystemIntake) (*string, error) {
	return obj.LifecycleCostBaseline.Ptr(), nil
}

// NeedsEaSupport is the resolver for the needsEaSupport field.
func (r *systemIntakeResolver) NeedsEaSupport(ctx context.Context, obj *models.SystemIntake) (*bool, error) {
	return obj.EASupportRequest.Ptr(), nil
}

// Notes is the resolver for the notes field.
func (r *systemIntakeResolver) Notes(ctx context.Context, obj *models.SystemIntake) ([]*models.SystemIntakeNote, error) {
	return resolvers.SystemIntakeNotes(ctx, r.store, obj)
}

// ProductManager is the resolver for the productManager field.
func (r *systemIntakeResolver) ProductManager(ctx context.Context, obj *models.SystemIntake) (*model.SystemIntakeProductManager, error) {
	return &model.SystemIntakeProductManager{
		Component: obj.ProductManagerComponent.Ptr(),
		Name:      obj.ProductManager.Ptr(),
	}, nil
}

// RequestName is the resolver for the requestName field.
func (r *systemIntakeResolver) RequestName(ctx context.Context, obj *models.SystemIntake) (*string, error) {
	return obj.ProjectName.Ptr(), nil
}

// Requester is the resolver for the requester field.
func (r *systemIntakeResolver) Requester(ctx context.Context, obj *models.SystemIntake) (*model.SystemIntakeRequester, error) {
	requesterWithoutEmail := &model.SystemIntakeRequester{
		Component: obj.Component.Ptr(),
		Email:     nil,
		Name:      obj.Requester,
	}

	// if the EUA doesn't exist (Sharepoint imports), don't bother calling Okta
	if !obj.EUAUserID.Valid {
		return requesterWithoutEmail, nil
	}

	user, err := r.service.FetchUserInfo(ctx, obj.EUAUserID.ValueOrZero())
	if err != nil {
		// check if the EUA ID is just invalid in Okta (i.e. the requester no longer has an active EUA account)
		if _, ok := err.(*apperrors.InvalidEUAIDError); ok {
			return requesterWithoutEmail, nil
		}

		// error we can't handle, like being unable to communicate with Okta
		return nil, err
	}

	email := user.Email.String()
	return &model.SystemIntakeRequester{
		Component: obj.Component.Ptr(),
		Email:     &email,
		Name:      obj.Requester,
	}, nil
}

// RequesterName is the resolver for the requesterName field.
func (r *systemIntakeResolver) RequesterName(ctx context.Context, obj *models.SystemIntake) (*string, error) {
	return &obj.Requester, nil
}

// RequesterComponent is the resolver for the requesterComponent field.
func (r *systemIntakeResolver) RequesterComponent(ctx context.Context, obj *models.SystemIntake) (*string, error) {
	return obj.Component.Ptr(), nil
}

// Documents is the resolver for the documents field.
func (r *systemIntakeResolver) Documents(ctx context.Context, obj *models.SystemIntake) ([]*models.SystemIntakeDocument, error) {
	return resolvers.GetSystemIntakeDocumentsByRequestID(ctx, r.store, r.s3Client, obj.ID)
}

// ItGovTaskStatuses is the resolver for the itGovTaskStatuses field.
func (r *systemIntakeResolver) ItGovTaskStatuses(ctx context.Context, obj *models.SystemIntake) (*models.ITGovTaskStatuses, error) {
	return &models.ITGovTaskStatuses{
		ParentSystemIntake: obj,
	}, nil
}

// StatusRequester is the resolver for the statusRequester field.
func (r *systemIntakeResolver) StatusRequester(ctx context.Context, obj *models.SystemIntake) (models.SystemIntakeStatusRequester, error) {
	return resolvers.CalculateSystemIntakeRequesterStatus(obj, time.Now())
}

// StatusAdmin is the resolver for the statusAdmin field.
func (r *systemIntakeResolver) StatusAdmin(ctx context.Context, obj *models.SystemIntake) (models.SystemIntakeStatusAdmin, error) {
	return resolvers.CalculateSystemIntakeAdminStatus(obj)
}

// LcidStatus is the resolver for the lcidStatus field.
func (r *systemIntakeResolver) LcidStatus(ctx context.Context, obj *models.SystemIntake) (*models.SystemIntakeLCIDStatus, error) {
	return obj.LCIDStatus(time.Now()), nil
}

// RelationType is the resolver for the relationType field.
func (r *systemIntakeResolver) RelationType(ctx context.Context, obj *models.SystemIntake) (*models.RequestRelationType, error) {
	return obj.SystemRelationType, nil
}

// Systems is the resolver for the systems field on system intakes.
func (r *systemIntakeResolver) Systems(ctx context.Context, obj *models.SystemIntake) ([]*models.CedarSystem, error) {
	return resolvers.SystemIntakeSystems(ctx, obj.ID)
}

// ContractNumbers is the resolver for the contractNumbers field on system intakes.
func (r *systemIntakeResolver) ContractNumbers(ctx context.Context, obj *models.SystemIntake) ([]*models.SystemIntakeContractNumber, error) {
	return resolvers.SystemIntakeContractNumbers(ctx, obj.ID)
}

// DocumentType is the resolver for the documentType field.
func (r *systemIntakeDocumentResolver) DocumentType(ctx context.Context, obj *models.SystemIntakeDocument) (*model.SystemIntakeDocumentType, error) {
	return &model.SystemIntakeDocumentType{
		CommonType:           obj.CommonDocumentType,
		OtherTypeDescription: &obj.OtherType,
	}, nil
}

// Status is the resolver for the status field.
func (r *systemIntakeDocumentResolver) Status(ctx context.Context, obj *models.SystemIntakeDocument) (models.SystemIntakeDocumentStatus, error) {
	return resolvers.GetStatusForSystemIntakeDocument(r.s3Client, obj.S3Key)
}

// UploadedAt is the resolver for the uploadedAt field.
func (r *systemIntakeDocumentResolver) UploadedAt(ctx context.Context, obj *models.SystemIntakeDocument) (*time.Time, error) {
	return &obj.CreatedAt, nil
}

// URL is the resolver for the url field.
func (r *systemIntakeDocumentResolver) URL(ctx context.Context, obj *models.SystemIntakeDocument) (string, error) {
	return resolvers.GetURLForSystemIntakeDocument(r.s3Client, obj.S3Key)
}

// Author is the resolver for the author field.
func (r *systemIntakeNoteResolver) Author(ctx context.Context, obj *models.SystemIntakeNote) (*model.SystemIntakeNoteAuthor, error) {
	return resolvers.SystemIntakeNoteAuthor(obj)
}

// Editor is the resolver for the editor field.
func (r *systemIntakeNoteResolver) Editor(ctx context.Context, obj *models.SystemIntakeNote) (*models.UserInfo, error) {
	return resolvers.SystemIntakeNoteEditor(ctx, obj)
}

// Author is the resolver for the author field.
func (r *tRBAdminNoteResolver) Author(ctx context.Context, obj *models.TRBAdminNote) (*models.UserInfo, error) {
	authorInfo, err := r.service.FetchUserInfo(ctx, obj.CreatedBy)
	if err != nil {
		return nil, err
	}

	return authorInfo, nil
}

// CategorySpecificData is the resolver for the categorySpecificData field.
func (r *tRBAdminNoteResolver) CategorySpecificData(ctx context.Context, obj *models.TRBAdminNote) (model.TRBAdminNoteCategorySpecificData, error) {
	return resolvers.GetTRBAdminNoteCategorySpecificData(ctx, r.store, obj)
}

// Author is the resolver for the author field.
func (r *tRBAdviceLetterResolver) Author(ctx context.Context, obj *models.TRBAdviceLetter) (*models.UserInfo, error) {
	authorInfo, err := r.service.FetchUserInfo(ctx, obj.CreatedBy)
	if err != nil {
		return nil, err
	}

	return authorInfo, nil
}

// Recommendations is the resolver for the recommendations field.
func (r *tRBAdviceLetterResolver) Recommendations(ctx context.Context, obj *models.TRBAdviceLetter) ([]*models.TRBAdviceLetterRecommendation, error) {
	return resolvers.GetTRBAdviceLetterRecommendationsByTRBRequestID(ctx, r.store, obj.TRBRequestID)
}

// Links is the resolver for the links field.
func (r *tRBAdviceLetterRecommendationResolver) Links(ctx context.Context, obj *models.TRBAdviceLetterRecommendation) ([]string, error) {
	links := models.ConvertEnums[string](obj.Links)
	return links, nil
}

// Author is the resolver for the author field.
func (r *tRBAdviceLetterRecommendationResolver) Author(ctx context.Context, obj *models.TRBAdviceLetterRecommendation) (*models.UserInfo, error) {
	authorInfo, err := r.service.FetchUserInfo(ctx, obj.CreatedBy)
	if err != nil {
		return nil, err
	}

	return authorInfo, nil
}

// Status is the resolver for the status field.
func (r *tRBRequestResolver) Status(ctx context.Context, obj *models.TRBRequest) (models.TRBRequestStatus, error) {
	return resolvers.GetTRBRequestStatus(ctx, r.store, *obj)
}

// Attendees is the resolver for the attendees field.
func (r *tRBRequestResolver) Attendees(ctx context.Context, obj *models.TRBRequest) ([]*models.TRBRequestAttendee, error) {
	return resolvers.GetTRBRequestAttendeesByTRBRequestID(ctx, r.store, obj.ID)
}

// Feedback is the resolver for the feedback field.
func (r *tRBRequestResolver) Feedback(ctx context.Context, obj *models.TRBRequest) ([]*models.TRBRequestFeedback, error) {
	return resolvers.GetTRBRequestFeedbackByTRBRequestID(ctx, r.store, obj.ID)
}

// Documents is the resolver for the documents field.
func (r *tRBRequestResolver) Documents(ctx context.Context, obj *models.TRBRequest) ([]*models.TRBRequestDocument, error) {
	return resolvers.GetTRBRequestDocumentsByRequestID(ctx, r.store, r.s3Client, obj.ID)
}

// Form is the resolver for the form field.
func (r *tRBRequestResolver) Form(ctx context.Context, obj *models.TRBRequest) (*models.TRBRequestForm, error) {
	return resolvers.GetTRBRequestFormByTRBRequestID(ctx, r.store, obj.ID)
}

// AdviceLetter is the resolver for the adviceLetter field.
func (r *tRBRequestResolver) AdviceLetter(ctx context.Context, obj *models.TRBRequest) (*models.TRBAdviceLetter, error) {
	return resolvers.GetTRBAdviceLetterByTRBRequestID(ctx, r.store, obj.ID)
}

// TaskStatuses is the resolver for the taskStatuses field.
func (r *tRBRequestResolver) TaskStatuses(ctx context.Context, obj *models.TRBRequest) (*models.TRBTaskStatuses, error) {
	return resolvers.GetTRBTaskStatuses(ctx, r.store, *obj)
}

// TrbLeadInfo is the resolver for the trbLeadInfo field.
func (r *tRBRequestResolver) TrbLeadInfo(ctx context.Context, obj *models.TRBRequest) (*models.UserInfo, error) {
	return resolvers.GetTRBLeadInfo(ctx, obj.TRBLead)
}

// RequesterInfo is the resolver for the requesterInfo field.
func (r *tRBRequestResolver) RequesterInfo(ctx context.Context, obj *models.TRBRequest) (*models.UserInfo, error) {
	return resolvers.GetTRBRequesterInfo(ctx, obj.CreatedBy)
}

// RequesterComponent is the resolver for the requesterComponent field.
func (r *tRBRequestResolver) RequesterComponent(ctx context.Context, obj *models.TRBRequest) (*string, error) {
	requester := obj.CreatedBy
	return resolvers.GetTRBUserComponent(ctx, r.store, &requester, obj.ID)
}

// AdminNotes is the resolver for the adminNotes field.
func (r *tRBRequestResolver) AdminNotes(ctx context.Context, obj *models.TRBRequest) ([]*models.TRBAdminNote, error) {
	return resolvers.GetTRBAdminNotesByTRBRequestID(ctx, r.store, obj.ID)
}

// IsRecent is the resolver for the isRecent field.
func (r *tRBRequestResolver) IsRecent(ctx context.Context, obj *models.TRBRequest) (bool, error) {
	return resolvers.IsRecentTRBRequest(ctx, obj, time.Now()), nil
}

// RelationType is the resolver for the relationType field.
func (r *tRBRequestResolver) RelationType(ctx context.Context, obj *models.TRBRequest) (*models.RequestRelationType, error) {
	return obj.SystemRelationType, nil
}

// ContractNumbers is the resolver for the contractNumbers field.
func (r *tRBRequestResolver) ContractNumbers(ctx context.Context, obj *models.TRBRequest) ([]*models.TRBRequestContractNumber, error) {
	return resolvers.TRBRequestContractNumbers(ctx, obj.ID)
}

// Systems is the resolver for the systems field.
func (r *tRBRequestResolver) Systems(ctx context.Context, obj *models.TRBRequest) ([]*models.CedarSystem, error) {
	return resolvers.TRBRequestSystems(ctx, obj.ID)
}

// UserInfo is the resolver for the userInfo field.
func (r *tRBRequestAttendeeResolver) UserInfo(ctx context.Context, obj *models.TRBRequestAttendee) (*models.UserInfo, error) {
	userInfo, err := r.service.FetchUserInfo(ctx, obj.EUAUserID)
	if err != nil {
		return nil, err
	}
	return userInfo, nil
}

// DocumentType is the resolver for the documentType field.
func (r *tRBRequestDocumentResolver) DocumentType(ctx context.Context, obj *models.TRBRequestDocument) (*model.TRBRequestDocumentType, error) {
	return &model.TRBRequestDocumentType{
		CommonType:           obj.CommonDocumentType,
		OtherTypeDescription: &obj.OtherType,
	}, nil
}

// Status is the resolver for the status field.
func (r *tRBRequestDocumentResolver) Status(ctx context.Context, obj *models.TRBRequestDocument) (models.TRBRequestDocumentStatus, error) {
	return resolvers.GetStatusForTRBRequestDocument(r.s3Client, obj.S3Key)
}

// UploadedAt is the resolver for the uploadedAt field.
func (r *tRBRequestDocumentResolver) UploadedAt(ctx context.Context, obj *models.TRBRequestDocument) (*time.Time, error) {
	return &obj.CreatedAt, nil
}

// URL is the resolver for the url field.
func (r *tRBRequestDocumentResolver) URL(ctx context.Context, obj *models.TRBRequestDocument) (string, error) {
	return resolvers.GetURLForTRBRequestDocument(r.s3Client, obj.S3Key)
}

// NotifyEuaIds is the resolver for the notifyEuaIds field.
func (r *tRBRequestFeedbackResolver) NotifyEuaIds(ctx context.Context, obj *models.TRBRequestFeedback) ([]string, error) {
	ids := models.ConvertEnums[string](obj.NotifyEUAIDs)
	return ids, nil
}

// Author is the resolver for the author field.
func (r *tRBRequestFeedbackResolver) Author(ctx context.Context, obj *models.TRBRequestFeedback) (*models.UserInfo, error) {
	user, err := r.service.FetchUserInfo(ctx, obj.CreatedBy)
	if err != nil {
		return &models.UserInfo{}, err
	}
	return user, nil
}

// CollabGroups is the resolver for the collabGroups field.
func (r *tRBRequestFormResolver) CollabGroups(ctx context.Context, obj *models.TRBRequestForm) ([]models.TRBCollabGroupOption, error) {
	collabGroups := models.ConvertEnums[models.TRBCollabGroupOption](obj.CollabGroups)
	return collabGroups, nil
}

// FundingSources is the resolver for the fundingSources field.
func (r *tRBRequestFormResolver) FundingSources(ctx context.Context, obj *models.TRBRequestForm) ([]*models.TRBFundingSource, error) {
	return resolvers.GetFundingSourcesByRequestID(ctx, r.store, obj.TRBRequestID)
}

// SystemIntakes is the resolver for the systemIntakes field.
func (r *tRBRequestFormResolver) SystemIntakes(ctx context.Context, obj *models.TRBRequestForm) ([]*models.SystemIntake, error) {
	return resolvers.GetTRBRequestSystemIntakesByTRBRequestID(ctx, r.store, obj.TRBRequestID)
}

// SubjectAreaOptions is the resolver for the subjectAreaOptions field.
func (r *tRBRequestFormResolver) SubjectAreaOptions(ctx context.Context, obj *models.TRBRequestForm) ([]models.TRBSubjectAreaOption, error) {
	subjectAreas := models.ConvertEnums[models.TRBSubjectAreaOption](obj.SubjectAreaOptions)
	return subjectAreas, nil
}

// CommonName is the resolver for the commonName field.
func (r *userInfoResolver) CommonName(ctx context.Context, obj *models.UserInfo) (string, error) {
	return obj.DisplayName, nil
	//TODO: this user info struct should eventually be refactored so that the schema matches the backend.
}

// EuaUserID is the resolver for the euaUserId field.
func (r *userInfoResolver) EuaUserID(ctx context.Context, obj *models.UserInfo) (string, error) {
	return obj.Username, nil
	//TODO: this user info struct should eventually be refactored so that the schema matches the backend.
}

// BusinessCase returns generated.BusinessCaseResolver implementation.
func (r *Resolver) BusinessCase() generated.BusinessCaseResolver { return &businessCaseResolver{r} }

// CedarBudgetSystemCost returns generated.CedarBudgetSystemCostResolver implementation.
func (r *Resolver) CedarBudgetSystemCost() generated.CedarBudgetSystemCostResolver {
	return &cedarBudgetSystemCostResolver{r}
}

// CedarSoftwareProducts returns generated.CedarSoftwareProductsResolver implementation.
func (r *Resolver) CedarSoftwareProducts() generated.CedarSoftwareProductsResolver {
	return &cedarSoftwareProductsResolver{r}
}

// CedarSystem returns generated.CedarSystemResolver implementation.
func (r *Resolver) CedarSystem() generated.CedarSystemResolver { return &cedarSystemResolver{r} }

// CedarSystemDetails returns generated.CedarSystemDetailsResolver implementation.
func (r *Resolver) CedarSystemDetails() generated.CedarSystemDetailsResolver {
	return &cedarSystemDetailsResolver{r}
}

// GovernanceRequestFeedback returns generated.GovernanceRequestFeedbackResolver implementation.
func (r *Resolver) GovernanceRequestFeedback() generated.GovernanceRequestFeedbackResolver {
	return &governanceRequestFeedbackResolver{r}
}

// ITGovTaskStatuses returns generated.ITGovTaskStatusesResolver implementation.
func (r *Resolver) ITGovTaskStatuses() generated.ITGovTaskStatusesResolver {
	return &iTGovTaskStatusesResolver{r}
}

// Mutation returns generated.MutationResolver implementation.
func (r *Resolver) Mutation() generated.MutationResolver { return &mutationResolver{r} }

// Query returns generated.QueryResolver implementation.
func (r *Resolver) Query() generated.QueryResolver { return &queryResolver{r} }

// SystemIntake returns generated.SystemIntakeResolver implementation.
func (r *Resolver) SystemIntake() generated.SystemIntakeResolver { return &systemIntakeResolver{r} }

// SystemIntakeDocument returns generated.SystemIntakeDocumentResolver implementation.
func (r *Resolver) SystemIntakeDocument() generated.SystemIntakeDocumentResolver {
	return &systemIntakeDocumentResolver{r}
}

// SystemIntakeNote returns generated.SystemIntakeNoteResolver implementation.
func (r *Resolver) SystemIntakeNote() generated.SystemIntakeNoteResolver {
	return &systemIntakeNoteResolver{r}
}

// TRBAdminNote returns generated.TRBAdminNoteResolver implementation.
func (r *Resolver) TRBAdminNote() generated.TRBAdminNoteResolver { return &tRBAdminNoteResolver{r} }

// TRBAdviceLetter returns generated.TRBAdviceLetterResolver implementation.
func (r *Resolver) TRBAdviceLetter() generated.TRBAdviceLetterResolver {
	return &tRBAdviceLetterResolver{r}
}

// TRBAdviceLetterRecommendation returns generated.TRBAdviceLetterRecommendationResolver implementation.
func (r *Resolver) TRBAdviceLetterRecommendation() generated.TRBAdviceLetterRecommendationResolver {
	return &tRBAdviceLetterRecommendationResolver{r}
}

// TRBRequest returns generated.TRBRequestResolver implementation.
func (r *Resolver) TRBRequest() generated.TRBRequestResolver { return &tRBRequestResolver{r} }

// TRBRequestAttendee returns generated.TRBRequestAttendeeResolver implementation.
func (r *Resolver) TRBRequestAttendee() generated.TRBRequestAttendeeResolver {
	return &tRBRequestAttendeeResolver{r}
}

// TRBRequestDocument returns generated.TRBRequestDocumentResolver implementation.
func (r *Resolver) TRBRequestDocument() generated.TRBRequestDocumentResolver {
	return &tRBRequestDocumentResolver{r}
}

// TRBRequestFeedback returns generated.TRBRequestFeedbackResolver implementation.
func (r *Resolver) TRBRequestFeedback() generated.TRBRequestFeedbackResolver {
	return &tRBRequestFeedbackResolver{r}
}

// TRBRequestForm returns generated.TRBRequestFormResolver implementation.
func (r *Resolver) TRBRequestForm() generated.TRBRequestFormResolver {
	return &tRBRequestFormResolver{r}
}

// UserInfo returns generated.UserInfoResolver implementation.
func (r *Resolver) UserInfo() generated.UserInfoResolver { return &userInfoResolver{r} }

type businessCaseResolver struct{ *Resolver }
type cedarBudgetSystemCostResolver struct{ *Resolver }
type cedarSoftwareProductsResolver struct{ *Resolver }
type cedarSystemResolver struct{ *Resolver }
type cedarSystemDetailsResolver struct{ *Resolver }
type governanceRequestFeedbackResolver struct{ *Resolver }
type iTGovTaskStatusesResolver struct{ *Resolver }
type mutationResolver struct{ *Resolver }
type queryResolver struct{ *Resolver }
type systemIntakeResolver struct{ *Resolver }
type systemIntakeDocumentResolver struct{ *Resolver }
type systemIntakeNoteResolver struct{ *Resolver }
type tRBAdminNoteResolver struct{ *Resolver }
type tRBAdviceLetterResolver struct{ *Resolver }
type tRBAdviceLetterRecommendationResolver struct{ *Resolver }
type tRBRequestResolver struct{ *Resolver }
type tRBRequestAttendeeResolver struct{ *Resolver }
type tRBRequestDocumentResolver struct{ *Resolver }
type tRBRequestFeedbackResolver struct{ *Resolver }
type tRBRequestFormResolver struct{ *Resolver }
type userInfoResolver struct{ *Resolver }