dev

cmd/main.go

@@ -4,8 +4,6 @@ import (
 	"context"
 	"donat-widget/internal/app/http"
 	"donat-widget/internal/config"
-	DonatRepo "donat-widget/internal/repository/donat"
-	DonatService "donat-widget/internal/service/donat"
 )
 
 import (
@@ -15,7 +13,11 @@ import (
 )
 
 import (
+	DonatRepo "donat-widget/internal/repository/donat"
+	TargetRepo "donat-widget/internal/repository/target"
 	WidgetRepo "donat-widget/internal/repository/widget"
+	DonatService "donat-widget/internal/service/donat"
+	TargetService "donat-widget/internal/service/target"
 	WidgetService "donat-widget/internal/service/widget"
 )
 
@@ -32,14 +34,17 @@ func main() {
 	// REPOSITORIES
 	widgetRepo := WidgetRepo.New(db, storage)
 	donatRepo := DonatRepo.New(db)
+	targetRepo := TargetRepo.New(db)
 
 	// SERVICES
 	widgetService := WidgetService.New(widgetRepo, donatRepo)
 	donatService := DonatService.New(donatRepo, widgetRepo, paymentClient)
+	targetService := TargetService.New(targetRepo)
 
 	http.NewApp(
 		db,
 		widgetService,
 		donatService,
+		targetService,
 	)
 }

internal/api/http/handlers/target/target.go

@@ -1 +1,88 @@
 package target
+
+import (
+	"context"
+	"donat-widget/internal/model"
+	"github.com/labstack/echo/v4"
+	"net/http"
+)
+
+func CreateTarget(targetService model.TargetService) echo.HandlerFunc {
+	type Body struct {
+		StreamerID model.StreamerID  `json:"streamer_id"`
+		Amount     model.DonatAmount `json:"amount"`
+		Text       string            `json:"text"`
+	}
+	return func(request echo.Context) error {
+		ctx := context.Background()
+		var body Body
+		if err := request.Bind(&body); err != nil {
+			return echo.NewHTTPError(400, err.Error())
+		}
+		if err := request.Validate(&body); err != nil {
+
+			return echo.NewHTTPError(400, err.Error())
+		}
+
+		err := targetService.CreateTarget(ctx, body.StreamerID, body.Amount, body.Text)
+		if err != nil {
+			return request.JSON(http.StatusInternalServerError, err)
+		}
+		return request.String(http.StatusOK, "Created target successfully")
+	}
+}
+
+func GetAllTarget(targetService model.TargetService) echo.HandlerFunc {
+	type Body struct {
+		StreamerID model.StreamerID `json:"streamer_id"`
+	}
+	return func(request echo.Context) error {
+		ctx := context.Background()
+		var body Body
+		if err := request.Bind(&body); err != nil {
+			return echo.NewHTTPError(400, err.Error())
+		}
+		if err := request.Validate(&body); err != nil {
+
+			return echo.NewHTTPError(400, err.Error())
+		}
+
+		targets, err := targetService.GetAllTarget(ctx, body.StreamerID)
+		if err != nil {
+			return request.JSON(http.StatusInternalServerError, err)
+		}
+
+		return request.JSON(http.StatusOK, targets)
+	}
+}
+
+func AddAmountTarget(
+	targetService model.TargetService,
+	donatService model.DonatService,
+) echo.HandlerFunc {
+	type Body struct {
+		OrderID model.OrderID `json:"order_id"`
+	}
+	return func(request echo.Context) error {
+		ctx := context.Background()
+		var body Body
+		if err := request.Bind(&body); err != nil {
+			return echo.NewHTTPError(400, err.Error())
+		}
+		if err := request.Validate(&body); err != nil {
+
+			return echo.NewHTTPError(400, err.Error())
+		}
+
+		donat, err := donatService.GetDonatByOrderID(ctx, body.OrderID)
+		if err != nil {
+			return request.JSON(http.StatusInternalServerError, err)
+		}
+
+		err = targetService.AddAmountToTarget(ctx, donat.TargetID, donat.Amount)
+		if err != nil {
+			return request.JSON(http.StatusInternalServerError, err)
+		}
+		return request.JSON(http.StatusOK, "Added target successfully")
+	}
+}

internal/app/http/app.go

@@ -16,6 +16,7 @@ import (
 
 import (
 	. "donat-widget/internal/api/http/handlers/donat"
+	. "donat-widget/internal/api/http/handlers/target"
 	. "donat-widget/internal/api/http/handlers/widget"
 )
 
@@ -25,6 +26,7 @@ func NewApp(
 	db model.Db,
 	widgetService model.WidgetService,
 	donatService model.DonatService,
+	targetService model.TargetService,
 ) {
 	server := echo.New()
 	server.Validator = validator.NewValidator()
@@ -35,10 +37,21 @@ func NewApp(
 
 	IncludeWidgetHandlers(server, widgetService)
 	IncludeDonatHandlers(server, donatService)
+	IncludeTargetHandlers(server, targetService, donatService)
 
 	server.Logger.Fatal(server.Start(":8002"))
 }
 
+func IncludeTargetHandlers(
+	server *echo.Echo,
+	targetService model.TargetService,
+	donatService model.DonatService,
+) {
+	server.POST(PREFIX+"/target/create", CreateTarget(targetService))
+	server.GET(PREFIX+"/target/all", GetAllTarget(targetService))
+	server.POST(PREFIX+"/target/addAmount", AddAmountTarget(targetService, donatService))
+}
+
 func IncludeDonatHandlers(
 	server *echo.Echo,
 	donatService model.DonatService,
@@ -55,13 +68,12 @@ func IncludeWidgetHandlers(
 	server.POST(PREFIX+"/create", CreateWidget(widgetService))
 	server.GET(PREFIX+"/html/:widgetID", GetWidgetHTML(widgetService))
 	server.GET(PREFIX+"/info/:widgetID", GetWidgetInfo(widgetService))
+	server.PATCH(PREFIX+"/duration/update", UpdateDuration(widgetService))
 
 	server.POST(PREFIX+"/media/:mediaType/upload", SetMediaFile(widgetService))
 	server.POST(PREFIX+"/media/:mediaType/set", SetMediaUrl(widgetService))
 	server.GET(PREFIX+"/media/:mediaType/get/:widgetID", GetMediaFile(widgetService))
 
-	server.PATCH(PREFIX+"/duration/update", UpdateDuration(widgetService))
-
 }
 
 func CreateTale(db model.Db) echo.HandlerFunc {

internal/model/interfaces.go

@@ -35,6 +35,7 @@ type WidgetRepo interface {
 
 type DonatService interface {
 	CreateDonat(ctx context.Context, streamerID StreamerID, orderID OrderID, targetID TargetID, amount DonatAmount, text string, donatUser string) (api.CreatePaymentResponse, error)
+	GetDonatByOrderID(ctx context.Context, orderID OrderID) (*Donat, error)
 	MarkDonatPaid(ctx context.Context, orderID OrderID) error
 	MarkDonatView(ctx context.Context, DonatID DonatID) error
 }
@@ -42,16 +43,21 @@ type DonatService interface {
 type DonatRepo interface {
 	CreateDonat(ctx context.Context, widgetID WidgetID, orderID OrderID, targetID TargetID, amount DonatAmount, text string, donatUser string) error
 	GetDonat(ctx context.Context, widgetID WidgetID) ([]*Donat, error)
+	GetDonatByOrderID(ctx context.Context, orderID OrderID) (*Donat, error)
 	MarkDonatPaid(ctx context.Context, orderID OrderID) error
 	MarkDonatView(ctx context.Context, DonatID DonatID) error
 }
 
 type TargetService interface {
-	CreateTarget()
+	CreateTarget(ctx context.Context, streamerID StreamerID, amount DonatAmount, text string) error
+	GetAllTarget(ctx context.Context, streamerID StreamerID) ([]*Target, error)
+	AddAmountToTarget(ctx context.Context, targetID TargetID, amount DonatAmount) error
 }
 
 type TargetRepo interface {
-	CreateTarget()
+	CreateTarget(ctx context.Context, streamerID StreamerID, amount DonatAmount, text string) error
+	GetAllTarget(ctx context.Context, streamerID StreamerID) ([]*Target, error)
+	AddAmountToTarget(ctx context.Context, targetID TargetID, amount DonatAmount) error
 }
 
 type Error interface {

internal/model/sql/query.go

@@ -60,6 +60,10 @@ var GetDonat = `
 SELECT * FROM donats
 WHERE widget_id = (@widget_id) AND paid = (@paid) AND view = (@view);
 `
+var GetDonatByOrderID = `
+SELECT * FROM donats
+WHERE order_id = (@order_id);
+`
 
 var CreateTarget = `
 INSERT INTO targets (streamer_id, text, amount)

internal/repository/donat/donat.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"donat-widget/internal/model"
 	"donat-widget/internal/model/sql"
+	"errors"
 	"github.com/georgysavva/scany/v2/pgxscan"
 	"github.com/jackc/pgx/v5"
 	"log/slog"
@@ -70,6 +71,32 @@ func (repoDonat *RepoDonat) GetDonat(
 	return donats, nil
 }
 
+func (repoDonat *RepoDonat) GetDonatByOrderID(
+	ctx context.Context,
+	orderID model.OrderID,
+) (*model.Donat, error) {
+	args := pgx.NamedArgs{
+		"order_id": orderID,
+	}
+	rows, err := repoDonat.db.Query(ctx, sql.GetDonatByOrderID, args)
+	if err != nil {
+		slog.Error("repoDonat.db.Query: " + err.Error())
+		return nil, err
+	}
+
+	var donats []*model.Donat
+	err = pgxscan.ScanAll(&donats, rows)
+	if err != nil {
+		slog.Error("repoMedia.pgxscan.ScanAll: " + err.Error())
+		return nil, err
+	}
+	if len(donats) == 0 {
+		return nil, errors.New("donat not found")
+	}
+
+	return donats[0], nil
+}
+
 func (repoDonat *RepoDonat) MarkDonatView(
 	ctx context.Context,
 	donatID model.DonatID,

internal/repository/target/target.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"donat-widget/internal/model"
 	"donat-widget/internal/model/sql"
+	"errors"
 	"github.com/georgysavva/scany/v2/pgxscan"
 	"github.com/jackc/pgx/v5"
 	"log/slog"
@@ -58,6 +59,9 @@ func (targetRepo *RepoTarget) GetAllTarget(
 		slog.Error("targetRepo.db.Query", err)
 		return nil, err
 	}
+	if len(targets) == 0 {
+		return nil, errors.New("donat not found")
+	}
 
 	return targets, nil
 

internal/repository/widget/widget.go

@@ -98,6 +98,9 @@ func (widgetRepo *RepoWidget) GetAllWidget(
 		slog.Error(err.Error())
 		return nil, err
 	}
+	if len(widgets) == 0 {
+		return nil, errors.New("donat not found")
+	}
 
 	return widgets, nil
 }

internal/service/donat/donat.go

@@ -72,6 +72,18 @@ func (donatService *ServiceDonat) CreateDonat(
 	return createPaymentResponse, nil
 }
 
+func (donatService *ServiceDonat) GetDonatByOrderID(
+	ctx context.Context,
+	orderID model.OrderID,
+) (*model.Donat, error) {
+	donat, err := donatService.donatRepo.GetDonatByOrderID(ctx, orderID)
+	if err != nil {
+		slog.Error("donatService.donatRepo.GetDonatByOrderID: " + err.Error())
+		return nil, err
+	}
+	return donat, nil
+}
+
 func (donatService *ServiceDonat) MarkDonatPaid(
 	ctx context.Context,
 	orderID model.OrderID,

internal/service/target/target.go

@@ -1,19 +1,59 @@
 package target
 
-import "donat-widget/internal/model"
+import (
-
+	"context"
-type ServiceDonat struct {
+	"donat-widget/internal/model"
-	targetRepo model.TargerRep
+	"log/slog"
-}
+)
 
 func New(
-	donatRepo model.DonatRepo,
+	targetRepo model.TargetRepo,
-	widgetRepo model.WidgetRepo,
+) *ServiceTarget {
-	paymentClient model.PaymentClient,
+	return &ServiceTarget{
-) *ServiceDonat {
+		targetRepo: targetRepo,
-	return &ServiceDonat{
-		donatRepo:     donatRepo,
-		widgetRepo:    widgetRepo,
-		paymentClient: paymentClient,
 	}
 }
+
+type ServiceTarget struct {
+	targetRepo model.TargetRepo
+}
+
+func (targetService *ServiceTarget) CreateTarget(
+	ctx context.Context,
+	streamerID model.StreamerID,
+	amount model.DonatAmount,
+	text string,
+) error {
+	err := targetService.targetRepo.CreateTarget(ctx, streamerID, amount, text)
+	if err != nil {
+		slog.Error("targetService.CreateTarget: ", err)
+		return err
+	}
+	return nil
+}
+
+func (targetService *ServiceTarget) GetAllTarget(
+	ctx context.Context,
+	streamerID model.StreamerID,
+) ([]*model.Target, error) {
+	targets, err := targetService.targetRepo.GetAllTarget(ctx, streamerID)
+	if err != nil {
+		slog.Error("targetService.GetAllTarget: ", err)
+		return nil, err
+	}
+
+	return targets, nil
+}
+
+func (targetService *ServiceTarget) AddAmountToTarget(
+	ctx context.Context,
+	targetID model.TargetID,
+	amount model.DonatAmount,
+) error {
+	err := targetService.targetRepo.AddAmountToTarget(ctx, targetID, amount)
+	if err != nil {
+		slog.Error("targetService.AddAmountToTarget: ", err)
+		return err
+	}
+	return nil
+}