140 lines
3.6 KiB
Go
140 lines
3.6 KiB
Go
package usecase
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"strings"
|
|
|
|
"github.com/zdam-egzamin-zawodowy/backend/internal/models"
|
|
"github.com/zdam-egzamin-zawodowy/backend/internal/qualification"
|
|
sqlutils "github.com/zdam-egzamin-zawodowy/backend/pkg/utils/sql"
|
|
)
|
|
|
|
type usecase struct {
|
|
qualificationRepository qualification.Repository
|
|
}
|
|
|
|
type Config struct {
|
|
QualificationRepository qualification.Repository
|
|
}
|
|
|
|
func New(cfg *Config) (qualification.Usecase, error) {
|
|
if cfg == nil || cfg.QualificationRepository == nil {
|
|
return nil, fmt.Errorf("qualification/usecase: QualificationRepository is required")
|
|
}
|
|
return &usecase{
|
|
cfg.QualificationRepository,
|
|
}, nil
|
|
}
|
|
|
|
func (ucase *usecase) Store(ctx context.Context, input *models.QualificationInput) (*models.Qualification, error) {
|
|
if err := ucase.validateInput(input, validateOptions{false}); err != nil {
|
|
return nil, err
|
|
}
|
|
return ucase.qualificationRepository.Store(ctx, input)
|
|
}
|
|
|
|
func (ucase *usecase) UpdateOne(ctx context.Context, id int, input *models.QualificationInput) (*models.Qualification, error) {
|
|
if id <= 0 {
|
|
return nil, fmt.Errorf(messageInvalidID)
|
|
}
|
|
if err := ucase.validateInput(input, validateOptions{true}); err != nil {
|
|
return nil, err
|
|
}
|
|
items, err := ucase.qualificationRepository.UpdateMany(ctx,
|
|
&models.QualificationFilter{
|
|
ID: []int{id},
|
|
},
|
|
input)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if len(items) == 0 {
|
|
return nil, fmt.Errorf(messageItemNotFound)
|
|
}
|
|
return items[0], nil
|
|
}
|
|
|
|
func (ucase *usecase) Delete(ctx context.Context, f *models.QualificationFilter) ([]*models.Qualification, error) {
|
|
return ucase.qualificationRepository.Delete(ctx, f)
|
|
}
|
|
|
|
func (ucase *usecase) Fetch(ctx context.Context, cfg *qualification.FetchConfig) ([]*models.Qualification, int, error) {
|
|
if cfg == nil {
|
|
cfg = &qualification.FetchConfig{
|
|
Limit: qualification.DefaultLimit,
|
|
Count: true,
|
|
}
|
|
}
|
|
cfg.Sort = sqlutils.SanitizeSortExpressions(cfg.Sort)
|
|
return ucase.qualificationRepository.Fetch(ctx, cfg)
|
|
}
|
|
|
|
func (ucase *usecase) GetByID(ctx context.Context, id int) (*models.Qualification, error) {
|
|
items, _, err := ucase.Fetch(ctx, &qualification.FetchConfig{
|
|
Limit: 1,
|
|
Count: false,
|
|
Filter: &models.QualificationFilter{
|
|
ID: []int{id},
|
|
},
|
|
})
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if len(items) == 0 {
|
|
return nil, fmt.Errorf(messageItemNotFound)
|
|
}
|
|
return items[0], nil
|
|
}
|
|
|
|
func (ucase *usecase) GetBySlug(ctx context.Context, slug string) (*models.Qualification, error) {
|
|
items, _, err := ucase.Fetch(ctx, &qualification.FetchConfig{
|
|
Limit: 1,
|
|
Count: false,
|
|
Filter: &models.QualificationFilter{
|
|
Slug: []string{slug},
|
|
},
|
|
})
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if len(items) == 0 {
|
|
return nil, fmt.Errorf(messageItemNotFound)
|
|
}
|
|
return items[0], nil
|
|
}
|
|
|
|
type validateOptions struct {
|
|
allowNilValues bool
|
|
}
|
|
|
|
func (ucase *usecase) validateInput(input *models.QualificationInput, opts validateOptions) error {
|
|
if input.IsEmpty() {
|
|
return fmt.Errorf(messageEmptyPayload)
|
|
}
|
|
|
|
if input.Name != nil {
|
|
trimmedName := strings.TrimSpace(*input.Name)
|
|
input.Name = &trimmedName
|
|
if trimmedName == "" {
|
|
return fmt.Errorf(messageNameIsRequired)
|
|
} else if len(trimmedName) > qualification.MaxNameLength {
|
|
return fmt.Errorf(messageNameIsTooLong, qualification.MaxNameLength)
|
|
}
|
|
} else if !opts.allowNilValues {
|
|
return fmt.Errorf(messageNameIsRequired)
|
|
}
|
|
|
|
if input.Code != nil {
|
|
trimmedCode := strings.TrimSpace(*input.Code)
|
|
input.Code = &trimmedCode
|
|
if trimmedCode == "" {
|
|
return fmt.Errorf(messageCodeIsRequired)
|
|
}
|
|
} else if !opts.allowNilValues {
|
|
return fmt.Errorf(messageCodeIsRequired)
|
|
}
|
|
|
|
return nil
|
|
}
|