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

package donat

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"
)

func New(db model.Db) *RepoDonat {
	return &RepoDonat{
		db: db,
	}
}

type RepoDonat struct {
	db model.Db
}

func (repoDonat *RepoDonat) CreateDonat(
	ctx context.Context,
	streamerID model.StreamerID,
	widgetID model.WidgetID,
	orderID model.OrderID,
	targetID model.TargetID,
	amount model.DonatAmount,
	text string,
	donatUser string,
) error {
	args := pgx.NamedArgs{
		"streamer_id": streamerID,
		"widget_id":   widgetID,
		"order_id":    orderID,
		"target_id":   targetID,
		"text":        text,
		"amount":      amount,
		"donat_user":  donatUser,
	}
	_, err := repoDonat.db.Insert(ctx, sql.CreateDonat, args)
	if err != nil {
		slog.Error(err.Error())
		return err
	}

	return nil
}

func (repoDonat *RepoDonat) GetDonatByStreamerID(
	ctx context.Context,
	streamerID model.StreamerID,
) ([]*model.Donat, error) {
	args := pgx.NamedArgs{
		"streamer_id": streamerID,
		"paid":        true,
		"view":        false,
	}
	rows, err := repoDonat.db.Select(ctx, sql.GetDonatByStreamerID, args)
	if err != nil {
		slog.Error(err.Error())
		return nil, err
	}

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

	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.Select(ctx, sql.GetDonatByOrderID, args)
	if err != nil {
		slog.Error(err.Error())
		return nil, err
	}

	var donats []*model.Donat
	err = pgxscan.ScanAll(&donats, rows)
	if err != nil {
		slog.Error(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,
) error {
	args := pgx.NamedArgs{
		"id":   donatID,
		"view": true,
	}
	err := repoDonat.db.Update(ctx, sql.MarkDonatView, args)
	if err != nil {
		slog.Error(err.Error())
		return err
	}

	return nil
}

func (repoDonat *RepoDonat) MarkDonatPaid(
	ctx context.Context,
	orderID model.OrderID,
) error {
	args := pgx.NamedArgs{
		"order_id": orderID,
		"paid":     true,
	}
	err := repoDonat.db.Update(ctx, sql.MarkDonatPaid, args)
	if err != nil {
		slog.Error(err.Error())
		return err
	}

	return nil
}

func (repoDonat *RepoDonat) GetDonatPage(
	ctx context.Context,
	streamerID model.StreamerID,
) (model.DonatePage, error) {
	args := pgx.NamedArgs{
		"streamer_id": streamerID,
	}
	rows, err := repoDonat.db.Select(ctx, sql.GetDonationPage, args)
	if err != nil {
		slog.Error(err.Error())
		return model.DonatePage{}, err
	}

	var donatePage []*model.DonatePage
	err = pgxscan.ScanAll(&donatePage, rows)
	if err != nil {
		slog.Error(err.Error())
		return model.DonatePage{}, err
	}
	if len(donatePage) == 0 {
		return model.DonatePage{}, errors.New("donat not found")
	}

	return *donatePage[0], nil
}

func (repoDonat *RepoDonat) GetDonatPageByLogin(
	ctx context.Context,
	streamerLogin string,
) (model.DonatePage, error) {
	args := pgx.NamedArgs{
		"streamer_login": streamerLogin,
	}
	rows, err := repoDonat.db.Select(ctx, sql.GetDonationPageByLogin, args)
	if err != nil {
		slog.Error(err.Error())
		return model.DonatePage{}, err
	}

	var donatePage []*model.DonatePage
	err = pgxscan.ScanAll(&donatePage, rows)
	if err != nil {
		slog.Error(err.Error())
		return model.DonatePage{}, err
	}
	if len(donatePage) == 0 {
		return model.DonatePage{}, errors.New("donat not found")
	}

	return *donatePage[0], nil
}

func (repoDonat *RepoDonat) UpdateDonatePage(
	ctx context.Context,
	streamerID int,
	backgroundFileID *string,
	headImgFileID *string,
	description *string,
	textAfterDonation *string,
) error {
	args := pgx.NamedArgs{
		"streamer_id": streamerID,
	}

	if backgroundFileID != nil {
		args["background_img"] = *backgroundFileID
	}
	if headImgFileID != nil {
		args["head_img"] = *headImgFileID
	}
	if description != nil {
		args["description"] = *description
	}
	if textAfterDonation != nil {
		args["text_after_donat"] = *textAfterDonation
	}

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

	return nil
}

func (repoDonat *RepoDonat) GetLanguagesByStreamerID(ctx context.Context, streamerID int) ([]model.Language, error) {
	args := pgx.NamedArgs{
		"streamer_id": streamerID,
	}

	// Выполняем SQL-запрос
	rows, err := repoDonat.db.Select(ctx, sql.GetLanguagesByStreamerID, args)
	if err != nil {
		slog.Error("Failed to execute query", "error", err)
		return nil, err
	}

	// Сканируем результаты в структуру Language
	var languages []*model.Language
	err = pgxscan.ScanAll(&languages, rows)
	if err != nil {
		slog.Error("Failed to scan rows", "error", err)
		return nil, err
	}

	// Проверяем ошибки, которые могли возникнуть при итерации по строкам
	if err := rows.Err(); err != nil {
		slog.Error("Error during rows iteration", "error", err)
		return nil, err
	}

	// Преобразуем []*model.Language в []model.Language
	result := make([]model.Language, len(languages))
	for i, lang := range languages {
		result[i] = *lang
	}

	return result, nil
}

func (repoDonat *RepoDonat) GetVoiceSettingsByStreamerID(
	ctx context.Context,
	streamerID int,
) (model.VoiceSettingsResponse, error) {
	args := pgx.NamedArgs{
		"streamer_id": streamerID,
	}
	rows, err := repoDonat.db.Select(ctx, sql.GetVoiceSettingsByStreamerID, args)
	if err != nil {
		slog.Error(err.Error())
		return model.VoiceSettingsResponse{}, err
	}

	var voiceSettings []*model.VoiceSettingsResponse
	err = pgxscan.ScanAll(&voiceSettings, rows)
	if err != nil {
		slog.Error(err.Error())
		return model.VoiceSettingsResponse{}, err
	}
	if len(voiceSettings) == 0 {
		return model.VoiceSettingsResponse{}, errors.New("voice settings not found")
	}

	return *voiceSettings[0], nil
}