Merge pull request #25 from NLipatov/feature/2

Feature/2

Author: NLipatov

src/application/lavatop_use_cases.go

@@ -2,23 +2,47 @@ package application
 
 import (
 	"fmt"
+	"goproxy/dal/cache_serialization"
 	"goproxy/domain/lavatopsubdomain/lavatopaggregates"
 	"goproxy/domain/lavatopsubdomain/lavatopvalueobjects"
+	"time"
+)
+
+const (
+	lavaTopUseCasesCacheTtl = time.Hour * 12
 )
 
 type LavaTopUseCases struct {
-	invoiceRepository InvoiceRepository[lavatopaggregates.Invoice]
-	billingService    BillingService[lavatopaggregates.Invoice, lavatopvalueobjects.Offer]
+	invoiceRepository    InvoiceRepository[lavatopaggregates.Invoice]
+	billingService       BillingService[lavatopaggregates.Invoice, lavatopvalueobjects.Offer]
+	cache                CacheWithTTL[[]cache_serialization.LavaTopOfferDto]
+	offerCacheSerializer cache_serialization.CacheSerializer[lavatopvalueobjects.Offer, cache_serialization.LavaTopOfferDto]
 }
 
-func NewLavaTopUseCases(billingService BillingService[lavatopaggregates.Invoice, lavatopvalueobjects.Offer]) LavaTopUseCases {
+func NewLavaTopUseCases(billingService BillingService[lavatopaggregates.Invoice, lavatopvalueobjects.Offer],
+	cache CacheWithTTL[[]cache_serialization.LavaTopOfferDto]) LavaTopUseCases {
 	return LavaTopUseCases{
-		billingService: billingService,
+		billingService:       billingService,
+		cache:                cache,
+		offerCacheSerializer: cache_serialization.NewLavaTopOfferCacheSerializer(),
 	}
 }
 
 func (l *LavaTopUseCases) GetOffers() ([]lavatopvalueobjects.Offer, error) {
-	return l.billingService.GetOffers()
+	cached, cachedErr := l.cache.Get("lavatop_use_cases:get_offers")
+	if cachedErr == nil {
+		return l.offerCacheSerializer.ToTArray(cached), nil
+	}
+
+	offers, offersErr := l.billingService.GetOffers()
+	if offersErr != nil {
+		return nil, offersErr
+	}
+
+	_ = l.cache.Set("lavatop_use_cases:get_offers", l.offerCacheSerializer.ToDArray(offers))
+	_ = l.cache.Expire("lavatop_use_cases:get_offers", lavaTopUseCasesCacheTtl)
+
+	return offers, nil
 }
 
 func (l *LavaTopUseCases) PublishInvoice(invoice lavatopaggregates.Invoice) (lavatopaggregates.Invoice, error) {

src/application/repository.go

@@ -28,7 +28,8 @@ type EventRepository interface {
 
 type PlanRepository interface {
 	Repository[aggregates.Plan]
-	GetAll() (aggregates.Plan, error)
+	GetAll() ([]aggregates.Plan, error)
+	GetAllWithFeatures() ([]aggregates.Plan, error)
 	GetByName(name string) (aggregates.Plan, error)
 	GetByNameWithFeatures(name string) (aggregates.Plan, error)
 	GetByIdWithFeatures(id int) (aggregates.Plan, error)

src/dal/cache_serialization/aggegate_plan_cache_serializer.go

@@ -0,0 +1,75 @@
+package cache_serialization
+
+import (
+	"goproxy/domain/aggregates"
+	"goproxy/domain/valueobjects"
+	"time"
+)
+
+type PlanFeatureDto struct {
+	PlanId             int    `json:"plan_id"`
+	FeatureName        string `json:"name"`
+	FeatureDescription string `json:"description"`
+}
+
+type PlanDto struct {
+	Id         int              `json:"id"`
+	Name       string           `json:"name"`
+	BytesLimit int64            `json:"bytes_limit"`
+	Duration   int              `json:"duration"`
+	Features   []PlanFeatureDto `json:"features"`
+	CreatedAt  time.Time        `json:"created_at"`
+}
+
+type AggegatePlanCacheSerializer struct{}
+
+func NewAggegatePlanCacheSerializer() CacheSerializer[aggregates.Plan, PlanDto] {
+	return &AggegatePlanCacheSerializer{}
+}
+
+func (a *AggegatePlanCacheSerializer) ToT(dto PlanDto) aggregates.Plan {
+	features := make([]valueobjects.PlanFeature, len(dto.Features))
+	for i, v := range dto.Features {
+		features[i] = valueobjects.NewPlanFeature(v.PlanId, v.FeatureName, v.FeatureDescription)
+	}
+
+	plan, _ := aggregates.NewPlan(dto.Id, dto.Name, dto.BytesLimit, dto.Duration, features)
+	return plan
+}
+
+func (a *AggegatePlanCacheSerializer) ToTArray(dtos []PlanDto) []aggregates.Plan {
+	arr := make([]aggregates.Plan, len(dtos))
+	for i, dto := range dtos {
+		arr[i] = a.ToT(dto)
+	}
+
+	return arr
+}
+
+func (a *AggegatePlanCacheSerializer) ToD(plan aggregates.Plan) PlanDto {
+	features := make([]PlanFeatureDto, len(plan.Features()))
+	for i, v := range plan.Features() {
+		features[i] = PlanFeatureDto{
+			PlanId:             v.PlanId(),
+			FeatureName:        v.Feature(),
+			FeatureDescription: v.Description(),
+		}
+	}
+	return PlanDto{
+		Id:         plan.Id(),
+		Name:       plan.Name(),
+		BytesLimit: plan.LimitBytes(),
+		Duration:   plan.DurationDays(),
+		Features:   features,
+		CreatedAt:  plan.CreatedAt(),
+	}
+}
+
+func (a *AggegatePlanCacheSerializer) ToDArray(plans []aggregates.Plan) []PlanDto {
+	arr := make([]PlanDto, len(plans))
+	for i, plan := range plans {
+		arr[i] = a.ToD(plan)
+	}
+
+	return arr
+}

src/dal/cache_serialization/cache_serializer.go

@@ -0,0 +1,10 @@
+package cache_serialization
+
+// CacheSerializer used for cache_serialization serialization and deserialization
+// T - target type, D - dto type
+type CacheSerializer[T any, D any] interface {
+	ToT(dto D) T
+	ToD(plan T) D
+	ToTArray(dto []D) []T
+	ToDArray(plans []T) []D
+}

src/dal/cache_serialization/lava_top_offer_cache_serializer.go

@@ -0,0 +1,64 @@
+package cache_serialization
+
+import (
+	"goproxy/domain/lavatopsubdomain/lavatopvalueobjects"
+)
+
+type LavaTopOfferDto struct {
+	ExtId  string
+	Name   string
+	Prices []LavaTopOfferPriceDto
+}
+
+type LavaTopOfferPriceDto struct {
+	Cents       int64
+	Periodicity lavatopvalueobjects.Periodicity
+	Currency    lavatopvalueobjects.Currency
+}
+
+type LavaTopOfferCacheSerializer struct {
+}
+
+func NewLavaTopOfferCacheSerializer() CacheSerializer[lavatopvalueobjects.Offer, LavaTopOfferDto] {
+	return &LavaTopOfferCacheSerializer{}
+}
+
+func (l *LavaTopOfferCacheSerializer) ToT(dto LavaTopOfferDto) lavatopvalueobjects.Offer {
+	prices := make([]lavatopvalueobjects.Price, len(dto.Prices))
+	for i, p := range dto.Prices {
+		prices[i] = lavatopvalueobjects.NewPrice(p.Cents, p.Currency, p.Periodicity)
+	}
+
+	return lavatopvalueobjects.NewOffer(dto.ExtId, dto.Name, prices)
+}
+func (l *LavaTopOfferCacheSerializer) ToD(offer lavatopvalueobjects.Offer) LavaTopOfferDto {
+	prices := make([]LavaTopOfferPriceDto, len(offer.Prices()))
+
+	for i, p := range offer.Prices() {
+		prices[i] = LavaTopOfferPriceDto{
+			Cents:       p.Cents(),
+			Periodicity: p.Periodicity(),
+			Currency:    p.Currency(),
+		}
+	}
+
+	return LavaTopOfferDto{
+		ExtId:  offer.ExtId(),
+		Name:   offer.Name(),
+		Prices: prices,
+	}
+}
+func (l *LavaTopOfferCacheSerializer) ToTArray(dto []LavaTopOfferDto) []lavatopvalueobjects.Offer {
+	result := make([]lavatopvalueobjects.Offer, len(dto))
+	for i, d := range dto {
+		result[i] = l.ToT(d)
+	}
+	return result
+}
+func (l *LavaTopOfferCacheSerializer) ToDArray(offer []lavatopvalueobjects.Offer) []LavaTopOfferDto {
+	result := make([]LavaTopOfferDto, len(offer))
+	for i, d := range offer {
+		result[i] = l.ToD(d)
+	}
+	return result
+}

src/dal/cache_serialization/plan_lavatop_offer_dto.go

@@ -0,0 +1,50 @@
+package cache_serialization
+
+import (
+	"goproxy/domain/dataobjects"
+)
+
+type PlanLavatopOfferDto struct {
+	Id      int
+	PlanId  int
+	OfferId string
+}
+
+type DataObjectsPlanLavatopOfferCacheSerializer struct {
+}
+
+func NewPlanLavatopOfferSerializer() CacheSerializer[dataobjects.PlanLavatopOffer, PlanLavatopOfferDto] {
+	return &DataObjectsPlanLavatopOfferCacheSerializer{}
+}
+
+func (p *DataObjectsPlanLavatopOfferCacheSerializer) ToT(dto PlanLavatopOfferDto) dataobjects.PlanLavatopOffer {
+	return dataobjects.NewPlanLavatopOffer(dto.Id, dto.PlanId, dto.OfferId)
+}
+
+func (p *DataObjectsPlanLavatopOfferCacheSerializer) ToD(offer dataobjects.PlanLavatopOffer) PlanLavatopOfferDto {
+	return PlanLavatopOfferDto{
+		Id:      offer.Id(),
+		PlanId:  offer.PlanId(),
+		OfferId: offer.OfferId(),
+	}
+}
+
+func (p *DataObjectsPlanLavatopOfferCacheSerializer) ToTArray(dto []PlanLavatopOfferDto) []dataobjects.PlanLavatopOffer {
+	result := make([]dataobjects.PlanLavatopOffer, len(dto))
+	for i, d := range dto {
+		result[i] = p.ToT(d)
+	}
+	return result
+}
+
+func (p *DataObjectsPlanLavatopOfferCacheSerializer) ToDArray(plans []dataobjects.PlanLavatopOffer) []PlanLavatopOfferDto {
+	result := make([]PlanLavatopOfferDto, len(plans))
+	for i, plan := range plans {
+		result[i] = PlanLavatopOfferDto{
+			Id:      plan.Id(),
+			PlanId:  plan.PlanId(),
+			OfferId: plan.OfferId(),
+		}
+	}
+	return result
+}

src/dal/repositories/mocks/cache_with_ttl.go

@@ -2,6 +2,7 @@ package mocks
 
 import (
 	"errors"
+	"goproxy/application"
 	"sync"
 	"time"
 )
@@ -16,7 +17,7 @@ type MockCacheWithTTL[T any] struct {
 	mutex sync.RWMutex
 }
 
-func NewMockCacheWithTTL[T any]() *MockCacheWithTTL[T] {
+func NewMockCacheWithTTL[T any]() application.CacheWithTTL[T] {
 	return &MockCacheWithTTL[T]{
 		data: make(map[string]mockCacheItem[T]),
 	}

src/dal/repositories/plan_lavatop_offer_repository.go

@@ -5,6 +5,7 @@ import (
 	"errors"
 	"fmt"
 	"goproxy/application"
+	"goproxy/dal/cache_serialization"
 	"goproxy/domain/dataobjects"
 	"time"
 )
@@ -35,23 +36,25 @@ WHERE id = $1
 )
 
 type PlanLavatopOfferRepository struct {
-	db    *sql.DB
-	cache application.CacheWithTTL[[]dataobjects.PlanLavatopOffer]
+	db                              *sql.DB
+	cache                           application.CacheWithTTL[[]cache_serialization.PlanLavatopOfferDto]
+	cachePlanLavatopOfferSerializer cache_serialization.CacheSerializer[dataobjects.PlanLavatopOffer, cache_serialization.PlanLavatopOfferDto]
 }
 
 func NewPlanLavatopOfferRepository(db *sql.DB,
-	cache application.CacheWithTTL[[]dataobjects.PlanLavatopOffer]) application.PlanOfferRepository {
+	cache application.CacheWithTTL[[]cache_serialization.PlanLavatopOfferDto]) application.PlanOfferRepository {
 	return &PlanLavatopOfferRepository{
-		db:    db,
-		cache: cache,
+		db:                              db,
+		cache:                           cache,
+		cachePlanLavatopOfferSerializer: cache_serialization.NewPlanLavatopOfferSerializer(),
 	}
 }
 
 func (p *PlanLavatopOfferRepository) GetOffers(planId int) ([]dataobjects.PlanLavatopOffer, error) {
 	planKey := p.planToCacheKey(planId)
 	cached, cachedErr := p.cache.Get(planKey)
 	if cachedErr == nil {
-		return cached, nil
+		return p.cachePlanLavatopOfferSerializer.ToTArray(cached), nil
 	}
 
 	var offers []dataobjects.PlanLavatopOffer
@@ -81,7 +84,7 @@ func (p *PlanLavatopOfferRepository) GetOffers(planId int) ([]dataobjects.PlanLa
 		return make([]dataobjects.PlanLavatopOffer, 0), rows.Err()
 	}
 
-	_ = p.cache.Set(planKey, offers)
+	_ = p.cache.Set(planKey, p.cachePlanLavatopOfferSerializer.ToDArray(offers))
 	_ = p.cache.Expire(planKey, cacheTtl)
 
 	if offers == nil {

src/dal/repositories/plan_lavatop_offer_repository_test.go

@@ -5,6 +5,7 @@ import (
 	"fmt"
 	"github.com/google/uuid"
 	"goproxy/application"
+	"goproxy/dal/cache_serialization"
 	"goproxy/dal/repositories/mocks"
 	"goproxy/domain/dataobjects"
 	"os"
@@ -29,9 +30,10 @@ func TestPlanLavatopOfferRepository(t *testing.T) {
 		_ = db.Close()
 	}(db)
 
-	cache := mocks.NewMockCacheWithTTL[[]dataobjects.PlanLavatopOffer]()
-	planOfferRepo := NewPlanLavatopOfferRepository(db, cache)
-	planRepo := NewPlansRepository(db)
+	planOfferRepoCache := mocks.NewMockCacheWithTTL[[]cache_serialization.PlanLavatopOfferDto]()
+	planRepoCache := mocks.NewMockCacheWithTTL[[]cache_serialization.PlanDto]()
+	planOfferRepo := NewPlanLavatopOfferRepository(db, planOfferRepoCache)
+	planRepo := NewPlansRepository(db, planRepoCache)
 
 	t.Run("GetOffers", func(t *testing.T) {
 		ploCount := 5