github.com/kyma-incubator/compass/components/director@v0.0.0-20230623144113-d764f56ff805/internal/domain/apptemplateversion/repository.go (about)

     1  package apptemplateversion
     2  
     3  import (
     4  	"context"
     5  
     6  	"github.com/kyma-incubator/compass/components/director/pkg/log"
     7  
     8  	"github.com/kyma-incubator/compass/components/director/pkg/resource"
     9  
    10  	"github.com/kyma-incubator/compass/components/director/internal/model"
    11  	"github.com/kyma-incubator/compass/components/director/internal/repo"
    12  )
    13  
    14  const tableName string = `public.app_template_versions`
    15  
    16  var (
    17  	idTableColumns        = []string{"id"}
    18  	updatableTableColumns = []string{"title", "correlation_ids"}
    19  	tableColumns          = append(idTableColumns, []string{"version", "title", "correlation_ids", "release_date", "created_at", "app_template_id"}...)
    20  )
    21  
    22  // EntityConverter converts between internal model and entity
    23  //
    24  //go:generate mockery --name=EntityConverter --output=automock --outpkg=automock --case=underscore --disable-version-string
    25  type EntityConverter interface {
    26  	ToEntity(in *model.ApplicationTemplateVersion) *Entity
    27  	FromEntity(entity *Entity) *model.ApplicationTemplateVersion
    28  }
    29  
    30  type repository struct {
    31  	creator            repo.CreatorGlobal
    32  	existQuerierGlobal repo.ExistQuerierGlobal
    33  	singleGetterGlobal repo.SingleGetterGlobal
    34  	updaterGlobal      repo.UpdaterGlobal
    35  	listerGlobal       repo.ListerGlobal
    36  	conv               EntityConverter
    37  }
    38  
    39  // NewRepository returns a new entity responsible for repo-layer ApplicationTemplateVersion operations.
    40  func NewRepository(conv EntityConverter) *repository {
    41  	return &repository{
    42  		creator:            repo.NewCreatorGlobal(resource.Application, tableName, tableColumns),
    43  		existQuerierGlobal: repo.NewExistQuerierGlobal(resource.ApplicationTemplateVersion, tableName),
    44  		singleGetterGlobal: repo.NewSingleGetterGlobal(resource.ApplicationTemplateVersion, tableName, tableColumns),
    45  		updaterGlobal:      repo.NewUpdaterGlobal(resource.ApplicationTemplateVersion, tableName, updatableTableColumns, idTableColumns),
    46  		listerGlobal:       repo.NewListerGlobal(resource.ApplicationTemplateVersion, tableName, tableColumns),
    47  		conv:               conv,
    48  	}
    49  }
    50  
    51  // Create persists a model.ApplicationTemplateVersion
    52  func (r *repository) Create(ctx context.Context, item model.ApplicationTemplateVersion) error {
    53  	log.C(ctx).Debugf("Converting Application Template Version with id %s to entity", item.ID)
    54  	entity := r.conv.ToEntity(&item)
    55  
    56  	log.C(ctx).Debugf("Persisting Application Template Version entity with id %s to db", item.ID)
    57  	return r.creator.Create(ctx, entity)
    58  }
    59  
    60  // GetByAppTemplateIDAndVersion gets globally a model.ApplicationTemplateVersion based on Application Template ID and version
    61  func (r *repository) GetByAppTemplateIDAndVersion(ctx context.Context, appTemplateID, version string) (*model.ApplicationTemplateVersion, error) {
    62  	var entity Entity
    63  	if err := r.singleGetterGlobal.GetGlobal(ctx, repo.Conditions{
    64  		repo.NewEqualCondition("app_template_id", appTemplateID),
    65  		repo.NewEqualCondition("version", version),
    66  	}, repo.NoOrderBy, &entity); err != nil {
    67  		return nil, err
    68  	}
    69  
    70  	return r.conv.FromEntity(&entity), nil
    71  }
    72  
    73  // ListByAppTemplateID lists multiple model.ApplicationTemplateVersion based on Application Template ID
    74  func (r *repository) ListByAppTemplateID(ctx context.Context, appTemplateID string) ([]*model.ApplicationTemplateVersion, error) {
    75  	var entities EntityCollection
    76  	if err := r.listerGlobal.ListGlobal(ctx, &entities, repo.NewEqualCondition("app_template_id", appTemplateID)); err != nil {
    77  		return nil, err
    78  	}
    79  
    80  	return r.multipleFromEntities(entities)
    81  }
    82  
    83  // Exists checks if a ApplicationTemplateVersion with a given ID is in the database
    84  func (r *repository) Exists(ctx context.Context, id string) (bool, error) {
    85  	return r.existQuerierGlobal.ExistsGlobal(ctx, repo.Conditions{repo.NewEqualCondition("id", id)})
    86  }
    87  
    88  // Update updates a model.ApplicationTemplateVersion
    89  func (r *repository) Update(ctx context.Context, model model.ApplicationTemplateVersion) error {
    90  	entity := r.conv.ToEntity(&model)
    91  
    92  	return r.updaterGlobal.UpdateSingleGlobal(ctx, entity)
    93  }
    94  
    95  func (r *repository) multipleFromEntities(entities EntityCollection) ([]*model.ApplicationTemplateVersion, error) {
    96  	items := make([]*model.ApplicationTemplateVersion, 0, len(entities))
    97  	for _, ent := range entities {
    98  		m := r.conv.FromEntity(&ent)
    99  		items = append(items, m)
   100  	}
   101  	return items, nil
   102  }