merch-api/internal/merch/service.go

package merch

import (
	"context"
	"merch-api/internal/user"
	"merch-api/pkg/utils"

	"github.com/google/uuid"
)

type service struct {
	repo         Repository
	utils        utils.Utils
	userProvider user.Provider
}

func newService(repo Repository, u utils.Utils, up user.Provider) *service {
	return &service{
		repo:         repo,
		utils:        u,
		userProvider: up,
	}
}

//origins

func (s *service) createOrigin(ctx context.Context, o *newOriginDTO) error {
	newOrigin := &Origin{
		CreatedAt: s.utils.TimeNowUTC(),
		DeletedAt: s.utils.DeletedNullTime(),
		Name:      o.Name,
	}

	logDebugService("create origin success")
	return s.repo.createOrigin(ctx, newOrigin)
}

func (s *service) getOrigins(ctx context.Context) (*originsDTO, error) {
	data, err := s.repo.getOrigins(ctx)
	if err != nil {
		logErrService(err)
		return nil, err
	}

	var origins []originItem
	for _, item := range data {
		origins = append(origins, originItem{
			Id:   item.Id,
			Name: item.Name,
		})
	}

	response := &originsDTO{
		Origins: origins,
	}

	logDebugService("get origins success")
	return response, nil
}

func (s *service) deleteOrigin(ctx context.Context, origin *deleteOriginDTO) error {
	logDebugService("delete origin success")
	return s.repo.deleteOriginByName(ctx, origin.Name, s.utils.NullTimeNowUTC())
}

// merch

func (s *service) createMerch(ctx context.Context, userUuid string, payload *newMerchDTO) error {
	userId, err := s.userProvider.GetUserId(ctx, userUuid)
	if err != nil {
		logErrService(err)
		return err
	}

	now := s.utils.TimeNowUTC()
	nullNow := s.utils.NullTimeFromNow(now)
	empty := s.utils.DeletedNullTime()

	merchUuid, err := uuid.NewV7()
	if err != nil {
		logErrService(err)
		return err
	}

	newMerch := &Merch{
		CreatedAt: now,
		UpdatedAt: nullNow,
		DeletedAt: empty,
		MerchUuid: merchUuid.String(),
		UserId:    userId,
		Name:      payload.Name,
	}

	var merchExtra []ExtraData
	if payload.Links != nil {

		originsMap, err := s.getOriginsMap(ctx)
		if err != nil {
			logErrService(err)
			return err
		}

		for _, item := range payload.Links {
			merchExtra = append(merchExtra, ExtraData{
				CreatedAt: now,
				UpdatedAt: nullNow,
				DeletedAt: empty,
				MerchId:   0,
				OriginId:  originsMap[item.Name],
				URL:       item.Link,
			})
		}
	}

	return s.repo.createMerch(ctx, newMerch, merchExtra)
}

func (s *service) getOriginsMap(ctx context.Context) (map[string]int64, error) {
	origins, err := s.repo.getOrigins(ctx)
	if err != nil {
		logErrService(err)
		return nil, err
	}

	originsMap := make(map[string]int64, len(origins))
	for _, origin := range origins {
		originsMap[origin.Name] = origin.Id
	}

	return originsMap, nil
}

func (s *service) getMany(ctx context.Context, userUuid string) ([]merchDTO, error) {
	userId, err := s.userProvider.GetUserId(ctx, userUuid)
	if err != nil {
		logErrService(err)
		return nil, err
	}

	return s.repo.getMany(ctx, userId)
}

func (s *service) deleteOneMerchRecord(ctx context.Context, userUuid, merchUuid string) error {
	userId, err := s.userProvider.GetUserId(ctx, userUuid)
	if err != nil {
		logErrService(err)
		return err
	}

	return s.repo.deleteOneMerchRecord(ctx, userId, merchUuid, s.utils.TimeNowUTC())
}