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

     1  package apptemplateversion
     2  
     3  import (
     4  	"context"
     5  	"time"
     6  
     7  	"github.com/kyma-incubator/compass/components/director/pkg/apperrors"
     8  
     9  	"github.com/kyma-incubator/compass/components/director/internal/model"
    10  	"github.com/kyma-incubator/compass/components/director/pkg/log"
    11  	directortime "github.com/kyma-incubator/compass/components/director/pkg/time"
    12  	"github.com/pkg/errors"
    13  )
    14  
    15  // ApplicationTemplateVersionRepository is responsible for repo-layer ApplicationTemplateVersion operations
    16  //
    17  //go:generate mockery --name=ApplicationTemplateVersionRepository --output=automock --outpkg=automock --case=underscore --disable-version-string
    18  type ApplicationTemplateVersionRepository interface {
    19  	GetByAppTemplateIDAndVersion(ctx context.Context, appTemplateID, version string) (*model.ApplicationTemplateVersion, error)
    20  	ListByAppTemplateID(ctx context.Context, appTemplateID string) ([]*model.ApplicationTemplateVersion, error)
    21  	Create(ctx context.Context, item model.ApplicationTemplateVersion) error
    22  	Exists(ctx context.Context, id string) (bool, error)
    23  	Update(ctx context.Context, model model.ApplicationTemplateVersion) error
    24  }
    25  
    26  // ApplicationTemplateService is responsible for repo-layer ApplicationTemplate operations
    27  //
    28  //go:generate mockery --name=ApplicationTemplateService --output=automock --outpkg=automock --case=underscore --disable-version-string
    29  type ApplicationTemplateService interface {
    30  	Exists(ctx context.Context, id string) (bool, error)
    31  }
    32  
    33  // UIDService is responsible for UID operations
    34  //
    35  //go:generate mockery --name=UIDService --output=automock --outpkg=automock --case=underscore --disable-version-string
    36  type UIDService interface {
    37  	Generate() string
    38  }
    39  
    40  // TimeService is responsible for Time operations
    41  //
    42  //go:generate mockery --name=TimeService --output=automock --outpkg=automock --case=underscore --disable-version-string
    43  type TimeService interface {
    44  	Now() time.Time
    45  }
    46  
    47  type service struct {
    48  	appTemplateVersionRepo ApplicationTemplateVersionRepository
    49  	appTemplateService     ApplicationTemplateService
    50  	uidService             UIDService
    51  	timeService            directortime.Service
    52  }
    53  
    54  // NewService returns a new object responsible for service-layer ApplicationTemplateVersion operations.
    55  func NewService(appTemplateVersionRepo ApplicationTemplateVersionRepository, appTemplateSvc ApplicationTemplateService, uidService UIDService, timeService TimeService) *service {
    56  	return &service{
    57  		appTemplateVersionRepo: appTemplateVersionRepo,
    58  		appTemplateService:     appTemplateSvc,
    59  		uidService:             uidService,
    60  		timeService:            timeService,
    61  	}
    62  }
    63  
    64  // Create creates an ApplicationTemplateVersion for a given applicationTemplateID
    65  func (s *service) Create(ctx context.Context, applicationTemplateID string, in *model.ApplicationTemplateVersionInput) (string, error) {
    66  	if in == nil {
    67  		return "", errors.New("Application Template Version input cannot be null")
    68  	}
    69  
    70  	id := s.uidService.Generate()
    71  	applicationTemplateVersion := in.ToApplicationTemplateVersion(id, applicationTemplateID)
    72  	applicationTemplateVersion.CreatedAt = s.timeService.Now()
    73  
    74  	if err := s.appTemplateVersionRepo.Create(ctx, applicationTemplateVersion); err != nil {
    75  		return "", errors.Wrapf(err, "error occurred while creating an Application Template Version with id %s", id)
    76  	}
    77  	log.C(ctx).Infof("Successfully created Application Template Version with ID %s", id)
    78  
    79  	return id, nil
    80  }
    81  
    82  // Update checks if a ApplicationTemplateVersion exists and updates it
    83  func (s *service) Update(ctx context.Context, id, appTemplateID string, in model.ApplicationTemplateVersionInput) error {
    84  	exists, err := s.appTemplateVersionRepo.Exists(ctx, id)
    85  	if err != nil {
    86  		return err
    87  	}
    88  
    89  	if !exists {
    90  		return errors.Errorf("Application Template Version with ID %s does not exist", id)
    91  	}
    92  
    93  	applicationTemplateVersion := in.ToApplicationTemplateVersion(id, appTemplateID)
    94  
    95  	if err = s.appTemplateVersionRepo.Update(ctx, applicationTemplateVersion); err != nil {
    96  		return errors.Wrapf(err, "while updating Application Template Version with id %s", id)
    97  	}
    98  
    99  	return nil
   100  }
   101  
   102  // GetByAppTemplateIDAndVersion gets an ApplicationTemplateVersion by a given Application Template ID and a version
   103  func (s *service) GetByAppTemplateIDAndVersion(ctx context.Context, appTemplateID, version string) (*model.ApplicationTemplateVersion, error) {
   104  	exists, err := s.appTemplateService.Exists(ctx, appTemplateID)
   105  	if err != nil {
   106  		return nil, errors.Wrap(err, "while checking if Application Template exits")
   107  	}
   108  
   109  	if !exists {
   110  		return nil, apperrors.NewInvalidDataError("Application Template with ID %s does not exist", appTemplateID)
   111  	}
   112  
   113  	applicationTemplateVersion, err := s.appTemplateVersionRepo.GetByAppTemplateIDAndVersion(ctx, appTemplateID, version)
   114  	if err != nil {
   115  		return nil, errors.Wrapf(err, "while getting Application Template Version with Version %q and Application Template ID: %q", version, appTemplateID)
   116  	}
   117  
   118  	return applicationTemplateVersion, nil
   119  }
   120  
   121  // ListByAppTemplateID lists multiple ApplicationTemplateVersion by Application Template ID
   122  func (s *service) ListByAppTemplateID(ctx context.Context, appTemplateID string) ([]*model.ApplicationTemplateVersion, error) {
   123  	applicationTemplateVersion, err := s.appTemplateVersionRepo.ListByAppTemplateID(ctx, appTemplateID)
   124  	if err != nil {
   125  		return nil, errors.Wrapf(err, "while getting Application Template Version with Application Template ID: %q", appTemplateID)
   126  	}
   127  
   128  	return applicationTemplateVersion, nil
   129  }