Easi 4470/dataloaders linked (#2674)

* POC with TRB, then will start on system intakes

* partway through linked system intake dataloaders

* (no verify) updating tests now, pushing feature code

* debugging tests

* fix sql + struct fields

* update to new oneToManyEmbed

pkg/dataloaders/cedar_system_linked_system_intakes.go

@@ -0,0 +1,35 @@
+package dataloaders
+
+import (
+ "context"
+ "errors"
+
+ "github.com/cms-enterprise/easi-app/pkg/helpers"
+ "github.com/cms-enterprise/easi-app/pkg/models"
+)
+
+func (d *dataReader) batchCedarSystemLinkedSystemIntakes(ctx context.Context, requests []models.SystemIntakesByCedarSystemIDsRequest) ([][]*models.SystemIntake, []error) {
+ data, err := d.db.SystemIntakesByCedarSystemIDs(ctx, requests)
+ if err != nil {
+ return nil, []error{err}
+ }
+
+ ids := make([]string, len(requests))
+ for i := range requests {
+ ids[i] = requests[i].CedarSystemID
+ }
+
+ return helpers.OneToManyEmbedded(ids, data), nil
+}
+
+func GetCedarSystemLinkedSystemIntakes(ctx context.Context, cedarSystemID string, state models.SystemIntakeState) ([]*models.SystemIntake, error) {
+ loaders, ok := loadersFromCTX(ctx)
+ if !ok {
+ return nil, errors.New("unexpected nil loaders in GetCedarSystemLinkedSystemIntakes")
+ }
+
+ return loaders.CedarSystemLinkedSystemIntakes.Load(ctx, models.SystemIntakesByCedarSystemIDsRequest{
+ CedarSystemID: cedarSystemID,
+ State: state,
+ })
+}

pkg/dataloaders/cedar_system_linked_trb_requests.go

@@ -0,0 +1,35 @@
+package dataloaders
+
+import (
+ "context"
+ "errors"
+
+ "github.com/cms-enterprise/easi-app/pkg/helpers"
+ "github.com/cms-enterprise/easi-app/pkg/models"
+)
+
+func (d *dataReader) batchCedarSystemLinkedTRBRequests(ctx context.Context, requests []models.TRBRequestsByCedarSystemIDsRequest) ([][]*models.TRBRequest, []error) {
+ data, err := d.db.TRBRequestsByCedarSystemIDs(ctx, requests)
+ if err != nil {
+ return nil, []error{err}
+ }
+
+ ids := make([]string, len(requests))
+ for i := range requests {
+ ids[i] = requests[i].CedarSystemID
+ }
+
+ return helpers.OneToManyEmbedded(ids, data), nil
+}
+
+func GetCedarSystemLinkedTRBRequests(ctx context.Context, cedarSystemID string, state models.TRBRequestState) ([]*models.TRBRequest, error) {
+ loaders, ok := loadersFromCTX(ctx)
+ if !ok {
+ return nil, errors.New("unexpected nil loaders in GetCedarSystemLinkedTRBRequests")
+ }
+
+ return loaders.CedarSystemLinkedTRBRequests.Load(ctx, models.TRBRequestsByCedarSystemIDsRequest{
+ CedarSystemID: cedarSystemID,
+ State: state,
+ })
+}

pkg/dataloaders/dataloaders.go

@@ -65,6 +65,8 @@ type dataReader struct {
 // you can then edit NewDataloaders below to include your new dataloader in the return
 type Dataloaders struct {
  CedarSystemBookmark *dataloadgen.Loader[models.BookmarkRequest, bool]
+ CedarSystemLinkedSystemIntakes *dataloadgen.Loader[models.SystemIntakesByCedarSystemIDsRequest, []*models.SystemIntake]
+ CedarSystemLinkedTRBRequests *dataloadgen.Loader[models.TRBRequestsByCedarSystemIDsRequest, []*models.TRBRequest]
  FetchUserInfo *dataloadgen.Loader[string, *models.UserInfo]
  GetUserAccount *dataloadgen.Loader[uuid.UUID, *authentication.UserAccount]
  GetCedarSystem *dataloadgen.Loader[string, *models.CedarSystem]
@@ -88,6 +90,8 @@ func NewDataloaders(store *storage.Store, fetchUserInfos fetchUserInfosFunc, get
  }
  return &Dataloaders{
  CedarSystemBookmark: dataloadgen.NewLoader(dr.batchCedarSystemIsBookmarked),
+ CedarSystemLinkedTRBRequests: dataloadgen.NewLoader(dr.batchCedarSystemLinkedTRBRequests),
+ CedarSystemLinkedSystemIntakes: dataloadgen.NewLoader(dr.batchCedarSystemLinkedSystemIntakes),
  FetchUserInfo: dataloadgen.NewLoader(dr.fetchUserInfosByEUAUserIDs),
  GetUserAccount: dataloadgen.NewLoader(dr.batchUserAccountsByIDs),
  GetCedarSystem: dataloadgen.NewLoader(dr.getCedarSystemsByIDs),

pkg/graph/resolvers/system_intake_system.go

@@ -30,3 +30,7 @@ func SystemIntakeSystems(ctx context.Context, systemIntakeID uuid.UUID) ([]*mode
  }
  return systems, nil
 }
+
+func CedarSystemLinkedSystemIntakes(ctx context.Context, cedarSystemID string, state models.SystemIntakeState) ([]*models.SystemIntake, error) {
+ return dataloaders.GetCedarSystemLinkedSystemIntakes(ctx, cedarSystemID, state)
+}

pkg/graph/resolvers/system_intake_system_test.go

@@ -83,3 +83,104 @@ func (s *ResolverSuite) TestIntakeRelatedSystems() {
  s.Empty(data)
  })
 }
+
+func (s *ResolverSuite) TestSystemIntakesByCedarSystemID() {
+ ctx := s.testConfigs.Context
+
+ var (
+ open1 uuid.UUID
+ open2 uuid.UUID
+
+ closed uuid.UUID
+ )
+
+ const (
+ system1 = "1"
+ system2 = "2"
+ system3 = "3"
+ system4 = "4"
+ )
+
+ s.Run("test getting system intakes by cedar system id", func() {
+ // create some intakes
+ intake1 := models.SystemIntake{
+ EUAUserID: testhelpers.RandomEUAIDNull(),
+ RequestType: models.SystemIntakeRequestTypeNEW,
+ State: models.SystemIntakeStateOpen,
+ }
+
+ create1, err := s.testConfigs.Store.CreateSystemIntake(ctx, &intake1)
+ s.NoError(err)
+ s.NotNil(create1)
+
+ open1 = create1.ID
+
+ intake2 := models.SystemIntake{
+ EUAUserID: testhelpers.RandomEUAIDNull(),
+ RequestType: models.SystemIntakeRequestTypeNEW,
+ State: models.SystemIntakeStateOpen,
+ }
+
+ create2, err := s.testConfigs.Store.CreateSystemIntake(ctx, &intake2)
+ s.NoError(err)
+ s.NotNil(create2)
+
+ open2 = create2.ID
+
+ intake3 := models.SystemIntake{
+ EUAUserID: testhelpers.RandomEUAIDNull(),
+ RequestType: models.SystemIntakeRequestTypeNEW,
+ State: models.SystemIntakeStateClosed,
+ }
+
+ create3, err := s.testConfigs.Store.CreateSystemIntake(ctx, &intake3)
+ s.NoError(err)
+ s.NotNil(create3)
+
+ closed = create3.ID
+
+ // link all systems to all system intakes
+ systemNumbers := []string{
+ system1,
+ system2,
+ system3,
+ system4,
+ }
+
+ err = sqlutils.WithTransaction(ctx, s.testConfigs.Store, func(tx *sqlx.Tx) error {
+ return s.testConfigs.Store.SetSystemIntakeSystems(ctx, tx, open1, systemNumbers)
+ })
+ s.NoError(err)
+
+ err = sqlutils.WithTransaction(ctx, s.testConfigs.Store, func(tx *sqlx.Tx) error {
+ return s.testConfigs.Store.SetSystemIntakeSystems(ctx, tx, open2, systemNumbers)
+ })
+ s.NoError(err)
+
+ err = sqlutils.WithTransaction(ctx, s.testConfigs.Store, func(tx *sqlx.Tx) error {
+ return s.testConfigs.Store.SetSystemIntakeSystems(ctx, tx, closed, systemNumbers)
+ })
+ s.NoError(err)
+
+ results, err := CedarSystemLinkedSystemIntakes(s.ctxWithNewDataloaders(), system1, models.SystemIntakeStateOpen)
+ s.NoError(err)
+ s.Len(results, 2)
+
+ foundClosed := false
+
+ for _, result := range results {
+ if result.ID == closed {
+ foundClosed = true
+ break
+ }
+ }
+
+ s.False(foundClosed)
+
+ // now get the closed one
+ results, err = CedarSystemLinkedSystemIntakes(s.ctxWithNewDataloaders(), system1, models.SystemIntakeStateClosed)
+ s.NoError(err)
+ s.Len(results, 1)
+ s.Equal(results[0].ID, closed)
+ })
+}

pkg/graph/resolvers/trb_request_system.go

@@ -30,3 +30,7 @@ func TRBRequestSystems(ctx context.Context, trbRequestID uuid.UUID) ([]*models.C
  }
  return systems, nil
 }
+
+func CedarSystemLinkedTRBRequests(ctx context.Context, cedarSystemID string, state models.TRBRequestState) ([]*models.TRBRequest, error) {
+ return dataloaders.GetCedarSystemLinkedTRBRequests(ctx, cedarSystemID, state)
+}

pkg/graph/resolvers/trb_request_system_test.go

@@ -6,6 +6,7 @@ import (
 
  "github.com/cms-enterprise/easi-app/pkg/models"
  "github.com/cms-enterprise/easi-app/pkg/sqlutils"
+ "github.com/cms-enterprise/easi-app/pkg/testhelpers"
 )
 
 func (s *ResolverSuite) TestTRBRequestRelatedSystems() {
@@ -74,3 +75,106 @@ func (s *ResolverSuite) TestTRBRequestRelatedSystems() {
  s.Empty(data)
  })
 }
+
+func (s *ResolverSuite) TestTRBRequestsByCedarSystemID() {
+ ctx := s.testConfigs.Context
+
+ var (
+ open1 uuid.UUID
+ open2 uuid.UUID
+
+ closed uuid.UUID
+ )
+
+ const (
+ system1 = "1"
+ system2 = "2"
+ system3 = "3"
+ system4 = "4"
+ )
+
+ s.Run("test getting TRB requests by cedar system id", func() {
+ // create trb requests
+ trb1 := models.TRBRequest{
+ Type: models.TRBTBrainstorm,
+ State: models.TRBRequestStateOpen,
+ }
+ trb1.CreatedBy = testhelpers.RandomEUAIDNull().String
+
+ create1, err := s.testConfigs.Store.CreateTRBRequest(ctx, s.testConfigs.Store, &trb1)
+ s.NoError(err)
+ s.NotNil(create1)
+
+ open1 = create1.ID
+
+ trb2 := models.TRBRequest{
+ Type: models.TRBTBrainstorm,
+ State: models.TRBRequestStateOpen,
+ }
+
+ trb2.CreatedBy = testhelpers.RandomEUAIDNull().String
+
+ create2, err := s.testConfigs.Store.CreateTRBRequest(ctx, s.testConfigs.Store, &trb2)
+ s.NoError(err)
+ s.NotNil(create2)
+
+ open2 = create2.ID
+
+ trb3 := models.TRBRequest{
+ Type: models.TRBTBrainstorm,
+ State: models.TRBRequestStateClosed,
+ }
+
+ trb3.CreatedBy = testhelpers.RandomEUAIDNull().String
+
+ create3, err := s.testConfigs.Store.CreateTRBRequest(ctx, s.testConfigs.Store, &trb3)
+ s.NoError(err)
+ s.NotNil(create3)
+
+ closed = create3.ID
+
+ // link all systems to all TRBs
+ systemNumbers := []string{
+ system1,
+ system2,
+ system3,
+ system4,
+ }
+
+ err = sqlutils.WithTransaction(ctx, s.testConfigs.Store, func(tx *sqlx.Tx) error {
+ return s.testConfigs.Store.SetTRBRequestSystems(ctx, tx, open1, systemNumbers)
+ })
+ s.NoError(err)
+
+ err = sqlutils.WithTransaction(ctx, s.testConfigs.Store, func(tx *sqlx.Tx) error {
+ return s.testConfigs.Store.SetTRBRequestSystems(ctx, tx, open2, systemNumbers)
+ })
+ s.NoError(err)
+
+ err = sqlutils.WithTransaction(ctx, s.testConfigs.Store, func(tx *sqlx.Tx) error {
+ return s.testConfigs.Store.SetTRBRequestSystems(ctx, tx, closed, systemNumbers)
+ })
+ s.NoError(err)
+
+ results, err := CedarSystemLinkedTRBRequests(s.ctxWithNewDataloaders(), system1, models.TRBRequestStateOpen)
+ s.NoError(err)
+ s.Len(results, 2)
+
+ foundClosed := false
+
+ for _, result := range results {
+ if result.ID == closed {
+ foundClosed = true
+ break
+ }
+ }
+
+ s.False(foundClosed)
+
+ // now find the closed one
+ results, err = CedarSystemLinkedTRBRequests(s.ctxWithNewDataloaders(), system1, models.TRBRequestStateClosed)
+ s.NoError(err)
+ s.Len(results, 1)
+ s.Equal(results[0].ID, closed)
+ })
+}

pkg/models/system_intake.go

@@ -245,3 +245,21 @@ func (s *RelatedSystemIntake) GetMappingID() uuid.UUID {
 func (s *RelatedSystemIntake) GetEmbedPtr() *SystemIntake {
  return &s.SystemIntake
 }
+
+type SystemIntakesByCedarSystemIDsRequest struct {
+ CedarSystemID string
+ State SystemIntakeState
+}
+
+type SystemIntakesByCedarSystemIDsResponse struct {
+ CedarSystemID string `db:"system_id"`
+ *SystemIntake
+}
+
+func (s *SystemIntakesByCedarSystemIDsResponse) GetMappingID() string {
+ return s.CedarSystemID
+}
+
+func (s *SystemIntakesByCedarSystemIDsResponse) GetEmbedPtr() *SystemIntake {
+ return s.SystemIntake
+}

pkg/models/trb_request.go

@@ -25,7 +25,6 @@ func NewTRBRequest(createdBy string) *TRBRequest {
  return &TRBRequest{
  BaseStruct: NewBaseStruct(createdBy),
  }
-
 }
 
 // TRBRequestType represents the types of TRBRequestType types
@@ -128,3 +127,21 @@ func (t *RelatedTRBRequest) GetMappingID() uuid.UUID {
 func (t *RelatedTRBRequest) GetEmbedPtr() *TRBRequest {
  return &t.TRBRequest
 }
+
+type TRBRequestsByCedarSystemIDsRequest struct {
+ CedarSystemID string
+ State TRBRequestState
+}
+
+type TRBRequestsByCedarSystemIDsResponse struct {
+ CedarSystemID string `db:"system_id"`
+ *TRBRequest
+}
+
+func (t *TRBRequestsByCedarSystemIDsResponse) GetMappingID() string {
+ return t.CedarSystemID
+}
+
+func (t *TRBRequestsByCedarSystemIDsResponse) GetEmbedPtr() *TRBRequest {
+ return t.TRBRequest
+}