donat-widget/internal/repository/widget/widget.go

package widget

import (
	"context"
	"donat-widget/internal/model"
	"donat-widget/internal/model/sql"
	"errors"
	"github.com/georgysavva/scany/v2/pgxscan"
	"github.com/google/uuid"
	"github.com/jackc/pgx/v5"
	"log/slog"
)

func New(
	db model.Db,
	storage model.Storage,
) *RepoWidget {
	return &RepoWidget{
		db:      db,
		storage: storage,
	}
}

type RepoWidget struct {
	db      model.Db
	storage model.Storage
}

func (widgetRepo *RepoWidget) CreateWidget(
	ctx context.Context,
	streamerID int,
	templateID int,
	duration int,
	minAmount int,
	maxAmount int,
	image string,
	audio string,
	name string,
	isActive bool,
	volumePercent int,
) (model.WidgetID, error) {
	args := pgx.NamedArgs{
		"streamer_id":    streamerID,
		"template_id":    templateID,
		"duration":       duration,
		"min_amount":     minAmount,
		"max_amount":     maxAmount,
		"image":          image,
		"audio":          audio,
		"name":           name,
		"is_active":      isActive,
		"volume_percent": volumePercent,
	}
	widgetID, err := widgetRepo.db.Insert(ctx, sql.CreateWidget, args)
	if err != nil {
		slog.Error(err.Error())
		return 0, err
	}

	return model.WidgetID(widgetID.(int32)), nil
}

func (widgetRepo *RepoWidget) CheckWidgetName(
	ctx context.Context,
	streamerID int,
	name string,
) (bool, error) {
	args := pgx.NamedArgs{
		"streamer_id": streamerID,
		"name":        name,
	}
	row := widgetRepo.db.SelectOne(ctx, sql.GetWidgetByName, args)
	var widgetId int

	err := row.Scan(&widgetId)
	if err != nil {
		if errors.Is(err, pgx.ErrNoRows) {
			return false, nil
		}
		slog.Error("failed to check widget name", "error", err.Error())
		return false, err
	}

	return false, nil
}

func (widgetRepo *RepoWidget) GetWidgetsByStreamerID(
	ctx context.Context,
	streamerID int,
) ([]*model.GetWidgetDb, error) {
	args := pgx.NamedArgs{"streamer_id": streamerID}
	rows, err := widgetRepo.db.Select(ctx, sql.GetWidgetsByStreamerID, args)
	if err != nil {
		slog.Error(err.Error())
		return nil, err
	}

	defer rows.Close()

	var widgets []*model.GetWidgetDb
	err = pgxscan.ScanAll(&widgets, rows)
	if err != nil {
		slog.Error(err.Error())
		return nil, err
	}

	return widgets, nil
}

func (widgetRepo *RepoWidget) GetWidgetByID(
	ctx context.Context,
	widgetID int,
) (model.GetWidgetDb, error) {
	args := pgx.NamedArgs{"widget_id": widgetID}
	rows, err := widgetRepo.db.Select(ctx, sql.GetWidgetByID, args)
	if err != nil {
		slog.Error(err.Error())
		return model.GetWidgetDb{}, err
	}

	defer rows.Close()

	var widgets []model.GetWidgetDb
	err = pgxscan.ScanAll(&widgets, rows)
	if err != nil {
		slog.Error(err.Error())
		return model.GetWidgetDb{}, err
	}
	if widgets[0].ID == 0 {
		return model.GetWidgetDb{}, errors.New("widget not found")
	}

	return widgets[0], nil
}

func (widgetRepo *RepoWidget) UpdateWidget(
	ctx context.Context,
	widgetID int,
	duration *int,
	minAmount *int,
	maxAmount *int,
	isActive *bool,
	image *uuid.UUID,
	audio *uuid.UUID,
	name *string,
	volumePercent *int,
) error {
	args := pgx.NamedArgs{
		"id": widgetID,
	}

	if duration != nil {
		args["duration"] = *duration
	}
	if minAmount != nil {
		args["min_amount"] = *minAmount
	}
	if maxAmount != nil {
		args["max_amount"] = *maxAmount
	}
	if image != nil {
		args["image"] = *image
	}
	if audio != nil {
		args["audio"] = *audio
	}
	if name != nil {
		args["name"] = *name
	}
	if isActive != nil {
		args["is_active"] = *isActive
	}
	if volumePercent != nil {
		args["volume_percent"] = *volumePercent
	}

	err := widgetRepo.db.Update(ctx, sql.UpdateWidget, args)
	if err != nil {
		slog.Error(err.Error())
		return err
	}

	return nil
}

func (widgetRepo *RepoWidget) CheckExistsWidget(
	ctx context.Context,
	widgetID int,
	accountID int,
) error {
	println("account", accountID, "widget", widgetID)
	args := pgx.NamedArgs{
		"widget_id":   widgetID,
		"streamer_id": accountID,
	}

	row := widgetRepo.db.SelectOne(ctx, sql.GetWidgetID, args)
	var widgetId int
	err := row.Scan(&widgetId)
	if err != nil {
		slog.Error(err.Error())
		return err
	}

	return nil
}

func (widgetRepo *RepoWidget) DeleteWidget(
	ctx context.Context,
	widgetID int,
	accountID int,
) error {
	args := pgx.NamedArgs{
		"widget_id":   widgetID,
		"streamer_id": accountID,
	}

	err := widgetRepo.db.Exec(ctx, sql.DeleteWidget, args)
	if err != nil {
		slog.Error(err.Error())
		return err
	}
	return nil
}

func (widgetRepo *RepoWidget) CreateStreamerWidgetPage(
	ctx context.Context,
	streamerID int,
) error {
	args := pgx.NamedArgs{
		"streamer_id": streamerID,
	}
	err := widgetRepo.db.Exec(ctx, sql.CreateStreamerWidgetPage, args)
	if err != nil {
		slog.Error(err.Error())
		return err
	}
	return nil
}

func (widgetRepo *RepoWidget) GetStreamerWidgetPageId(
	ctx context.Context,
	streamerID int,
) (uuid.UUID, error) {
	args := pgx.NamedArgs{
		"streamer_id": streamerID,
	}
	row := widgetRepo.db.SelectOne(ctx, sql.GetStreamerWidgetPage, args)

	var streamerWidgetPageId uuid.UUID
	err := row.Scan(&streamerWidgetPageId)
	if err != nil {
		slog.Error(err.Error())
		return uuid.UUID{}, err
	}
	return streamerWidgetPageId, nil
}

func (widgetRepo *RepoWidget) GetStreamerIdByWidgetPageId(
	ctx context.Context,
	widgetPageId uuid.UUID,
) (int, error) {
	args := pgx.NamedArgs{
		"widget_page_id": widgetPageId,
	}
	row := widgetRepo.db.SelectOne(ctx, sql.GetStreamerIdByWidgetPageId, args)

	var streamerID int
	err := row.Scan(&streamerID)
	if err != nil {
		slog.Error(err.Error())
		return 0, err
	}
	return streamerID, nil
}