donat-widget/internal/service/donat/donat.go

package donat

import (
	"context"
	"donat-widget/internal/model"
	"donat-widget/internal/model/api"
	"github.com/labstack/echo/v4"
	"log/slog"
	"mime/multipart"
	"net/http"
)

type ServiceDonat struct {
	donatRepo     model.DonatRepo
	widgetRepo    model.WidgetRepo
	authClient    model.AuthClient
	paymentClient model.PaymentClient
	storage       model.Storage
}

func New(
	donatRepo model.DonatRepo,
	widgetRepo model.WidgetRepo,
	paymentClient model.PaymentClient,
	authClient model.AuthClient,
	storage model.Storage,
) *ServiceDonat {
	return &ServiceDonat{
		donatRepo:     donatRepo,
		widgetRepo:    widgetRepo,
		paymentClient: paymentClient,
		authClient:    authClient,
		storage:       storage,
	}
}

func (donatService *ServiceDonat) CheckToken(
	request echo.Context,
) (api.CheckTokenResponse, error) {
	accessToken := model.Token(request.Request().Header.Get("Authorization"))

	checkTokenResponse, err := donatService.authClient.CheckToken(accessToken)
	if err != nil {
		slog.Error("Failed to check token", "error", err.Error())
		return api.CheckTokenResponse{}, echo.NewHTTPError(http.StatusInternalServerError, err.Error())
	}

	if checkTokenResponse.AccountID == 0 {
		slog.Error("Unauthorized account")
		return api.CheckTokenResponse{}, echo.NewHTTPError(http.StatusUnauthorized, "Unauthorized account")
	}

	if checkTokenResponse.AccountID == -1 {
		slog.Error("Expired token")
		return api.CheckTokenResponse{}, echo.NewHTTPError(http.StatusUnauthorized, "Expired token")
	}

	return checkTokenResponse, nil
}

func (donatService *ServiceDonat) CreateDonat(
	ctx context.Context,
	streamerID model.StreamerID,
	orderID model.OrderID,
	targetID model.TargetID,
	amount model.DonatAmount,
	text string,
	donatUser string,
) (api.CreatePaymentResponse, error) {
	widgets, err := donatService.widgetRepo.GetAllWidget(ctx, streamerID)
	if err != nil {
		slog.Error(err.Error())
		return api.CreatePaymentResponse{}, err
	}

	var widgetID model.WidgetID
	for _, widget := range widgets {
		if widget.MinAmount <= amount {
			widgetID = widget.ID
		}
	}

	err = donatService.donatRepo.CreateDonat(
		ctx, streamerID, widgetID, orderID, targetID, amount, text, donatUser,
	)
	if err != nil {
		slog.Error(err.Error())
		return api.CreatePaymentResponse{}, err
	}

	createPaymentResponse, err := donatService.paymentClient.CreatePayment(streamerID, amount, orderID)
	if err != nil {
		slog.Error(err.Error())
		return api.CreatePaymentResponse{}, err
	}

	return createPaymentResponse, nil
}

func (donatService *ServiceDonat) GetDonatByStreamerID(
	ctx context.Context,
	streamerID model.StreamerID,
) ([]*model.Donat, error) {
	donats, err := donatService.donatRepo.GetDonatByStreamerID(ctx, streamerID)
	if err != nil {
		slog.Error(err.Error())
		return nil, err
	}
	return donats, 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(err.Error())
		return nil, err
	}
	return donat, nil
}

func (donatService *ServiceDonat) MarkDonatPaid(
	ctx context.Context,
	orderID model.OrderID,
) error {
	err := donatService.donatRepo.MarkDonatPaid(
		ctx,
		orderID,
	)
	if err != nil {
		slog.Error(err.Error())
		return err
	}
	return nil
}

func (donatService *ServiceDonat) MarkDonatView(
	ctx context.Context,
	donatID model.DonatID,
) error {
	err := donatService.donatRepo.MarkDonatView(
		ctx,
		donatID,
	)
	if err != nil {
		slog.Error("donatService.donatRepo.MarkDonatView: " + err.Error())
		return err
	}
	return nil
}

func (donatService *ServiceDonat) GetInnerDonatPage(
	ctx context.Context,
	streamerID model.StreamerID,
) (model.InnerDonatePageResponse, error) {
	donatePage, err := donatService.donatRepo.GetDonatPage(ctx, streamerID)
	if err != nil {
		slog.Error(err.Error())
		return model.InnerDonatePageResponse{}, err
	}

	var innerDonatePageResponse = model.InnerDonatePageResponse{
		Description:    donatePage.Description,
		TextAfterDonat: donatePage.TextAfterDonat,
		HeadImg:        donatePage.HeadImg,
		Avatar:         donatePage.Avatar,
		BackgroundImg:  donatePage.BackgroundImg,
	}

	return innerDonatePageResponse, nil
}

func (donatService *ServiceDonat) GetOuterDonatPage(
	ctx context.Context,
	streamerLogin string,
) (model.OuterDonatePageResponse, error) {
	donatePage, err := donatService.donatRepo.GetDonatPageByLogin(ctx, streamerLogin)
	if err != nil {
		slog.Error(err.Error())
		return model.OuterDonatePageResponse{}, err
	}

	var outerDonatePageResponse = model.OuterDonatePageResponse{
		Description:   donatePage.Description,
		Login:         donatePage.StreamerLogin,
		OnLine:        "online",
		BackgroundImg: donatePage.BackgroundImg,
		HeadImg:       donatePage.HeadImg,
		AvatarImg:     donatePage.Avatar,
	}
	return outerDonatePageResponse, nil
}

func (donatService *ServiceDonat) UpdateDonatePage(
	ctx context.Context,
	streamerID model.StreamerID,
	updateModel model.UpdateDonatPage,
	background *multipart.FileHeader,
	headImg *multipart.FileHeader,
) error {
	if background != nil {
		err := donatService.storage.Update(
			background, // ❌ Было &background → ✅ Просто background
			model.FileID("some-id"),
			"test-filename",
			999999,
			"hello world",
		)
		if err != nil {
			slog.Error(err.Error())
		}
	}

	return nil

}

func (donatService *ServiceDonat) GetVoiceSettings(
	ctx context.Context,
	streamerID model.StreamerID,
) (model.VoiceSettingsResponse, error) {
	return model.VoiceSettingsResponse{}, nil
}

func (donatService *ServiceDonat) UpdateVoiceSettings(
	ctx context.Context,
	streamerID model.StreamerID,
	updateModel model.UpdateVoiceSettings,
) error {
	return nil
}

func (donatService *ServiceDonat) GetFiltersSettings(
	ctx context.Context,
	streamerID model.StreamerID,
) (model.FilterSettingResponse, error) {
	return model.FilterSettingResponse{}, nil
}

func (donatService *ServiceDonat) UpdateFiltersSettings(
	ctx context.Context,
	streamerID model.StreamerID,
	updateModel model.UpdateFilterSettings,
) error {
	return nil
}

func (donatService *ServiceDonat) GetModerationSettings(
	ctx context.Context,
	streamerID model.StreamerID,
) (model.ModerationResponse, error) {
	return model.ModerationResponse{}, nil
}

func (donatService *ServiceDonat) UpdateModerationSettings(
	ctx context.Context,
	streamerID model.StreamerID,
	updateModel model.UpdateModeration,
) error {
	return nil
}