minor refactoring

NLipatov · NLipatov · commit efd713e9aa27 · 2025-01-23T21:21:31.000+03:00
diff --git a/src/dal/cache_serialization/aggegate_plan_cache_serializer.go b/src/dal/cache_serialization/aggegate_plan_cache_serializer.go
@@ -21,11 +21,13 @@ type PlanDto struct {
 	CreatedAt  time.Time        `json:"created_at"`
 }
 
-func NewPlanCacheSerializer() CacheSerializer[aggregates.Plan, PlanDto] {
-	return &PlanDto{}
+type AggegatePlanCacheSerializer struct{}
+
+func NewAggegatePlanCacheSerializer() CacheSerializer[aggregates.Plan, PlanDto] {
+	return &AggegatePlanCacheSerializer{}
 }
 
-func (p *PlanDto) ToT(dto PlanDto) aggregates.Plan {
+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)
@@ -35,16 +37,16 @@ func (p *PlanDto) ToT(dto PlanDto) aggregates.Plan {
 	return plan
 }
 
-func (p *PlanDto) ToTArray(dtos []PlanDto) []aggregates.Plan {
+func (a *AggegatePlanCacheSerializer) ToTArray(dtos []PlanDto) []aggregates.Plan {
 	arr := make([]aggregates.Plan, len(dtos))
 	for i, dto := range dtos {
-		arr[i] = p.ToT(dto)
+		arr[i] = a.ToT(dto)
 	}
 
 	return arr
 }
 
-func (p *PlanDto) ToD(plan aggregates.Plan) PlanDto {
+func (a *AggegatePlanCacheSerializer) ToD(plan aggregates.Plan) PlanDto {
 	features := make([]PlanFeatureDto, len(plan.Features()))
 	for i, v := range plan.Features() {
 		features[i] = PlanFeatureDto{
@@ -63,10 +65,10 @@ func (p *PlanDto) ToD(plan aggregates.Plan) PlanDto {
 	}
 }
 
-func (p *PlanDto) ToDArray(plans []aggregates.Plan) []PlanDto {
+func (a *AggegatePlanCacheSerializer) ToDArray(plans []aggregates.Plan) []PlanDto {
 	arr := make([]PlanDto, len(plans))
 	for i, plan := range plans {
-		arr[i] = p.ToD(plan)
+		arr[i] = a.ToD(plan)
 	}
 
 	return arr
diff --git a/src/dal/cache_serialization/lava_top_offer_cache_serializer.go b/src/dal/cache_serialization/lava_top_offer_cache_serializer.go
@@ -16,19 +16,22 @@ type LavaTopOfferPriceDto struct {
 	Currency    lavatopvalueobjects.Currency
 }
 
-func NewLavaTopOfferCacheSerializer() *LavaTopOfferDto {
-	return &LavaTopOfferDto{}
+type LavaTopOfferCacheSerializer struct {
 }
 
-func (l *LavaTopOfferDto) ToT(dto LavaTopOfferDto) lavatopvalueobjects.Offer {
+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 *LavaTopOfferDto) ToD(offer lavatopvalueobjects.Offer) LavaTopOfferDto {
+func (l *LavaTopOfferCacheSerializer) ToD(offer lavatopvalueobjects.Offer) LavaTopOfferDto {
 	prices := make([]LavaTopOfferPriceDto, len(offer.Prices()))
 
 	for i, p := range offer.Prices() {
@@ -45,14 +48,14 @@ func (l *LavaTopOfferDto) ToD(offer lavatopvalueobjects.Offer) LavaTopOfferDto {
 		Prices: prices,
 	}
 }
-func (l *LavaTopOfferDto) ToTArray(dto []LavaTopOfferDto) []lavatopvalueobjects.Offer {
+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 *LavaTopOfferDto) ToDArray(offer []lavatopvalueobjects.Offer) []LavaTopOfferDto {
+func (l *LavaTopOfferCacheSerializer) ToDArray(offer []lavatopvalueobjects.Offer) []LavaTopOfferDto {
 	result := make([]LavaTopOfferDto, len(offer))
 	for i, d := range offer {
 		result[i] = l.ToD(d)
diff --git a/src/dal/cache_serialization/plan_lavatop_offer_dto.go b/src/dal/cache_serialization/plan_lavatop_offer_dto.go
@@ -10,31 +10,34 @@ type PlanLavatopOfferDto struct {
 	OfferId string
 }
 
+type DataObjectsPlanLavatopOfferCacheSerializer struct {
+}
+
 func NewPlanLavatopOfferSerializer() CacheSerializer[dataobjects.PlanLavatopOffer, PlanLavatopOfferDto] {
-	return &PlanLavatopOfferDto{}
+	return &DataObjectsPlanLavatopOfferCacheSerializer{}
 }
 
-func (p PlanLavatopOfferDto) ToT(dto PlanLavatopOfferDto) dataobjects.PlanLavatopOffer {
+func (p *DataObjectsPlanLavatopOfferCacheSerializer) ToT(dto PlanLavatopOfferDto) dataobjects.PlanLavatopOffer {
 	return dataobjects.NewPlanLavatopOffer(dto.Id, dto.PlanId, dto.OfferId)
 }
 
-func (p PlanLavatopOfferDto) ToD(offer dataobjects.PlanLavatopOffer) PlanLavatopOfferDto {
+func (p *DataObjectsPlanLavatopOfferCacheSerializer) ToD(offer dataobjects.PlanLavatopOffer) PlanLavatopOfferDto {
 	return PlanLavatopOfferDto{
 		Id:      offer.Id(),
 		PlanId:  offer.PlanId(),
 		OfferId: offer.OfferId(),
 	}
 }
 
-func (p PlanLavatopOfferDto) ToTArray(dto []PlanLavatopOfferDto) []dataobjects.PlanLavatopOffer {
+func (p *DataObjectsPlanLavatopOfferCacheSerializer) ToTArray(dto []PlanLavatopOfferDto) []dataobjects.PlanLavatopOffer {
 	result := make([]dataobjects.PlanLavatopOffer, len(dto))
 	for i, d := range dto {
-		result[i] = d.ToT(d)
+		result[i] = p.ToT(d)
 	}
 	return result
 }
 
-func (p PlanLavatopOfferDto) ToDArray(plans []dataobjects.PlanLavatopOffer) []PlanLavatopOfferDto {
+func (p *DataObjectsPlanLavatopOfferCacheSerializer) ToDArray(plans []dataobjects.PlanLavatopOffer) []PlanLavatopOfferDto {
 	result := make([]PlanLavatopOfferDto, len(plans))
 	for i, plan := range plans {
 		result[i] = PlanLavatopOfferDto{
diff --git a/src/dal/repositories/plan_repository.go b/src/dal/repositories/plan_repository.go
@@ -100,7 +100,7 @@ func NewPlansRepository(db *sql.DB, cache application.CacheWithTTL[[]cache_seria
 	return &PlanRepository{
 		db:                  db,
 		cache:               cache,
-		planCacheSerializer: cache_serialization.NewPlanCacheSerializer(),
+		planCacheSerializer: cache_serialization.NewAggegatePlanCacheSerializer(),
 	}
 }
 

Original file line number	Diff line number	Diff line change
`@@ -21,11 +21,13 @@ type PlanDto struct {`
`21`	`21`	CreatedAt time.Time `json:"created_at"`
`22`	`22`	`}`
`23`	`23`
`24`		`-func NewPlanCacheSerializer() CacheSerializer[aggregates.Plan, PlanDto] {`
`25`		`- return &PlanDto{}`
	`24`	`+type AggegatePlanCacheSerializer struct{}`
	`25`	`+`
	`26`	`+func NewAggegatePlanCacheSerializer() CacheSerializer[aggregates.Plan, PlanDto] {`
	`27`	`+ return &AggegatePlanCacheSerializer{}`
`26`	`28`	`}`
`27`	`29`
`28`		`-func (p *PlanDto) ToT(dto PlanDto) aggregates.Plan {`
	`30`	`+func (a *AggegatePlanCacheSerializer) ToT(dto PlanDto) aggregates.Plan {`
`29`	`31`	`features := make([]valueobjects.PlanFeature, len(dto.Features))`
`30`	`32`	`for i, v := range dto.Features {`
`31`	`33`	`features[i] = valueobjects.NewPlanFeature(v.PlanId, v.FeatureName, v.FeatureDescription)`
`@@ -35,16 +37,16 @@ func (p *PlanDto) ToT(dto PlanDto) aggregates.Plan {`
`35`	`37`	`return plan`
`36`	`38`	`}`
`37`	`39`
`38`		`-func (p *PlanDto) ToTArray(dtos []PlanDto) []aggregates.Plan {`
	`40`	`+func (a *AggegatePlanCacheSerializer) ToTArray(dtos []PlanDto) []aggregates.Plan {`
`39`	`41`	`arr := make([]aggregates.Plan, len(dtos))`
`40`	`42`	`for i, dto := range dtos {`
`41`		`- arr[i] = p.ToT(dto)`
	`43`	`+ arr[i] = a.ToT(dto)`
`42`	`44`	`}`
`43`	`45`
`44`	`46`	`return arr`
`45`	`47`	`}`
`46`	`48`
`47`		`-func (p *PlanDto) ToD(plan aggregates.Plan) PlanDto {`
	`49`	`+func (a *AggegatePlanCacheSerializer) ToD(plan aggregates.Plan) PlanDto {`
`48`	`50`	`features := make([]PlanFeatureDto, len(plan.Features()))`
`49`	`51`	`for i, v := range plan.Features() {`
`50`	`52`	`features[i] = PlanFeatureDto{`
`@@ -63,10 +65,10 @@ func (p *PlanDto) ToD(plan aggregates.Plan) PlanDto {`
`63`	`65`	`}`
`64`	`66`	`}`
`65`	`67`
`66`		`-func (p *PlanDto) ToDArray(plans []aggregates.Plan) []PlanDto {`
	`68`	`+func (a *AggegatePlanCacheSerializer) ToDArray(plans []aggregates.Plan) []PlanDto {`
`67`	`69`	`arr := make([]PlanDto, len(plans))`
`68`	`70`	`for i, plan := range plans {`
`69`		`- arr[i] = p.ToD(plan)`
	`71`	`+ arr[i] = a.ToD(plan)`
`70`	`72`	`}`
`71`	`73`
`72`	`74`	`return arr`
Original file line number	Diff line number	Diff line change
`@@ -16,19 +16,22 @@ type LavaTopOfferPriceDto struct {`
`16`	`16`	`Currency lavatopvalueobjects.Currency`
`17`	`17`	`}`
`18`	`18`
`19`		`-func NewLavaTopOfferCacheSerializer() *LavaTopOfferDto {`
`20`		`- return &LavaTopOfferDto{}`
	`19`	`+type LavaTopOfferCacheSerializer struct {`
`21`	`20`	`}`
`22`	`21`
`23`		`-func (l *LavaTopOfferDto) ToT(dto LavaTopOfferDto) lavatopvalueobjects.Offer {`
	`22`	`+func NewLavaTopOfferCacheSerializer() CacheSerializer[lavatopvalueobjects.Offer, LavaTopOfferDto] {`
	`23`	`+ return &LavaTopOfferCacheSerializer{}`
	`24`	`+}`
	`25`	`+`
	`26`	`+func (l *LavaTopOfferCacheSerializer) ToT(dto LavaTopOfferDto) lavatopvalueobjects.Offer {`
`24`	`27`	`prices := make([]lavatopvalueobjects.Price, len(dto.Prices))`
`25`	`28`	`for i, p := range dto.Prices {`
`26`	`29`	`prices[i] = lavatopvalueobjects.NewPrice(p.Cents, p.Currency, p.Periodicity)`
`27`	`30`	`}`
`28`	`31`
`29`	`32`	`return lavatopvalueobjects.NewOffer(dto.ExtId, dto.Name, prices)`
`30`	`33`	`}`
`31`		`-func (l *LavaTopOfferDto) ToD(offer lavatopvalueobjects.Offer) LavaTopOfferDto {`
	`34`	`+func (l *LavaTopOfferCacheSerializer) ToD(offer lavatopvalueobjects.Offer) LavaTopOfferDto {`
`32`	`35`	`prices := make([]LavaTopOfferPriceDto, len(offer.Prices()))`
`33`	`36`
`34`	`37`	`for i, p := range offer.Prices() {`
`@@ -45,14 +48,14 @@ func (l *LavaTopOfferDto) ToD(offer lavatopvalueobjects.Offer) LavaTopOfferDto {`
`45`	`48`	`Prices: prices,`
`46`	`49`	`}`
`47`	`50`	`}`
`48`		`-func (l *LavaTopOfferDto) ToTArray(dto []LavaTopOfferDto) []lavatopvalueobjects.Offer {`
	`51`	`+func (l *LavaTopOfferCacheSerializer) ToTArray(dto []LavaTopOfferDto) []lavatopvalueobjects.Offer {`
`49`	`52`	`result := make([]lavatopvalueobjects.Offer, len(dto))`
`50`	`53`	`for i, d := range dto {`
`51`	`54`	`result[i] = l.ToT(d)`
`52`	`55`	`}`
`53`	`56`	`return result`
`54`	`57`	`}`
`55`		`-func (l *LavaTopOfferDto) ToDArray(offer []lavatopvalueobjects.Offer) []LavaTopOfferDto {`
	`58`	`+func (l *LavaTopOfferCacheSerializer) ToDArray(offer []lavatopvalueobjects.Offer) []LavaTopOfferDto {`
`56`	`59`	`result := make([]LavaTopOfferDto, len(offer))`
`57`	`60`	`for i, d := range offer {`
`58`	`61`	`result[i] = l.ToD(d)`
Original file line number	Diff line number	Diff line change
`@@ -10,31 +10,34 @@ type PlanLavatopOfferDto struct {`
`10`	`10`	`OfferId string`
`11`	`11`	`}`
`12`	`12`
	`13`	`+type DataObjectsPlanLavatopOfferCacheSerializer struct {`
	`14`	`+}`
	`15`	`+`
`13`	`16`	`func NewPlanLavatopOfferSerializer() CacheSerializer[dataobjects.PlanLavatopOffer, PlanLavatopOfferDto] {`
`14`		`- return &PlanLavatopOfferDto{}`
	`17`	`+ return &DataObjectsPlanLavatopOfferCacheSerializer{}`
`15`	`18`	`}`
`16`	`19`
`17`		`-func (p PlanLavatopOfferDto) ToT(dto PlanLavatopOfferDto) dataobjects.PlanLavatopOffer {`
	`20`	`+func (p *DataObjectsPlanLavatopOfferCacheSerializer) ToT(dto PlanLavatopOfferDto) dataobjects.PlanLavatopOffer {`
`18`	`21`	`return dataobjects.NewPlanLavatopOffer(dto.Id, dto.PlanId, dto.OfferId)`
`19`	`22`	`}`
`20`	`23`
`21`		`-func (p PlanLavatopOfferDto) ToD(offer dataobjects.PlanLavatopOffer) PlanLavatopOfferDto {`
	`24`	`+func (p *DataObjectsPlanLavatopOfferCacheSerializer) ToD(offer dataobjects.PlanLavatopOffer) PlanLavatopOfferDto {`
`22`	`25`	`return PlanLavatopOfferDto{`
`23`	`26`	`Id: offer.Id(),`
`24`	`27`	`PlanId: offer.PlanId(),`
`25`	`28`	`OfferId: offer.OfferId(),`
`26`	`29`	`}`
`27`	`30`	`}`
`28`	`31`
`29`		`-func (p PlanLavatopOfferDto) ToTArray(dto []PlanLavatopOfferDto) []dataobjects.PlanLavatopOffer {`
	`32`	`+func (p *DataObjectsPlanLavatopOfferCacheSerializer) ToTArray(dto []PlanLavatopOfferDto) []dataobjects.PlanLavatopOffer {`
`30`	`33`	`result := make([]dataobjects.PlanLavatopOffer, len(dto))`
`31`	`34`	`for i, d := range dto {`
`32`		`- result[i] = d.ToT(d)`
	`35`	`+ result[i] = p.ToT(d)`
`33`	`36`	`}`
`34`	`37`	`return result`
`35`	`38`	`}`
`36`	`39`
`37`		`-func (p PlanLavatopOfferDto) ToDArray(plans []dataobjects.PlanLavatopOffer) []PlanLavatopOfferDto {`
	`40`	`+func (p *DataObjectsPlanLavatopOfferCacheSerializer) ToDArray(plans []dataobjects.PlanLavatopOffer) []PlanLavatopOfferDto {`
`38`	`41`	`result := make([]PlanLavatopOfferDto, len(plans))`
`39`	`42`	`for i, plan := range plans {`
`40`	`43`	`result[i] = PlanLavatopOfferDto{`
Original file line number	Diff line number	Diff line change
`@@ -100,7 +100,7 @@ func NewPlansRepository(db *sql.DB, cache application.CacheWithTTL[[]cache_seria`
`100`	`100`	`return &PlanRepository{`
`101`	`101`	`db: db,`
`102`	`102`	`cache: cache,`
`103`		`- planCacheSerializer: cache_serialization.NewPlanCacheSerializer(),`
	`103`	`+ planCacheSerializer: cache_serialization.NewAggegatePlanCacheSerializer(),`
`104`	`104`	`}`
`105`	`105`	`}`
`106`	`106`