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

package widget

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

func New(
	widgetRepo model.WidgetRepo,
	authClient model.AuthClient,
	fileRepo model.FileRepo,
	storage model.Storage,
	baseUrl string,
	ttsUrl string,
) *ServiceWidget {
	return &ServiceWidget{
		widgetRepo: widgetRepo,
		authClient: authClient,
		fileRepo:   fileRepo,
		storage:    storage,
		baseUrl:    baseUrl,
		ttsUrl:     ttsUrl,
	}
}

type ServiceWidget struct {
	widgetRepo model.WidgetRepo
	authClient model.AuthClient
	fileRepo   model.FileRepo
	storage    model.Storage
	baseUrl    string
	ttsUrl     string
}

func (widgetService *ServiceWidget) CreateWidget(
	ctx context.Context,
	streamerID int,
	templateID int,
	duration int,
	minAmount int,
	maxAmount int,
	image string,
	audio string,
	name string,
	isActive bool,
) (model.GetWidgetDb, error) {
	exists, err := widgetService.widgetRepo.CheckWidgetName(ctx, streamerID, name)
	if err != nil {
		return model.GetWidgetDb{}, err
	}
	fmt.Println(exists)
	if exists == true {
		slog.Error("GetWidgetDb with name %s already exists", name)
		return model.GetWidgetDb{}, fmt.Errorf("widget with name %s already exists", name)
	}

	widgetID, err := widgetService.widgetRepo.CreateWidget(
		ctx,
		streamerID,
		templateID,
		duration,
		minAmount,
		maxAmount,
		image,
		audio,
		name,
		isActive,
	)
	if err != nil {
		slog.Error(err.Error())
		return model.GetWidgetDb{}, err
	}
	widgetDB, err := widgetService.widgetRepo.GetWidgetByID(ctx, int(widgetID))
	if err != nil {
		slog.Error(err.Error())
		return model.GetWidgetDb{}, err
	}

	widgetDB.AudioLink = widgetService.storage.DownloadLink(widgetDB.AudioFileId)
	widgetDB.ImageLink = widgetService.storage.DownloadLink(widgetDB.ImageFileId)

	return widgetDB, nil
}

func (widgetService *ServiceWidget) GetWidgetsByStreamer(
	ctx context.Context,
	streamerID int,
) (model.AllWidgets, error) {
	widgets, err := widgetService.widgetRepo.GetWidgetsByStreamerID(ctx, streamerID)
	if err != nil {
		slog.Error(err.Error())
		return model.AllWidgets{}, err
	}

	groupedWidgets := make(map[int][]*model.GetWidgetDb)

	for _, widget := range widgets {
		widget.AudioLink = widgetService.storage.DownloadLink(widget.AudioFileId)
		widget.ImageLink = widgetService.storage.DownloadLink(widget.ImageFileId)

		groupedWidgets[widget.GroupID] = append(groupedWidgets[widget.GroupID], widget)
	}

	var result []*model.WidgetWithFileLink
	for groupID, widgets := range groupedWidgets {
		result = append(result, &model.WidgetWithFileLink{
			GroupID: groupID,
			Widgets: widgets,
		})
	}
	urlWidget, err := widgetService.widgetRepo.GetStreamerWidgetPageId(ctx, streamerID)
	if err != nil {
		slog.Error(err.Error())
		return model.AllWidgets{}, err
	}
	var allWidgets model.AllWidgets

	allWidgets.UrlWidget = "https://" + widgetService.baseUrl + "/api/widget/get-widget-html/" + urlWidget.String()
	allWidgets.Widgets = result

	return allWidgets, nil
}

func (widgetService *ServiceWidget) UpdateWidget(
	ctx context.Context,
	updateWidget model.UpdateWidget,
	widgetID int,
	accountID int,
) error {
	err := widgetService.widgetRepo.CheckExistsWidget(ctx, widgetID, accountID)
	if err != nil {
		slog.Error(err.Error())
		return err
	}

	err = widgetService.widgetRepo.UpdateWidget(
		ctx,
		widgetID,
		updateWidget.Duration,
		updateWidget.MinAmount,
		updateWidget.MaxAmount,
		updateWidget.IsActive,
		updateWidget.Image,
		updateWidget.Audio,
		updateWidget.Name,
	)
	if err != nil {
		slog.Error(err.Error())
		return err
	}

	return nil
}

func (widgetService *ServiceWidget) DeleteWidget(
	ctx context.Context,
	accountID int,
	widgetID int,
) error {
	println(widgetID, accountID)
	err := widgetService.widgetRepo.CheckExistsWidget(ctx, widgetID, accountID)
	if err != nil {
		slog.Error(err.Error())
		return err
	}

	err = widgetService.widgetRepo.DeleteWidget(
		ctx,
		widgetID,
		accountID,
	)
	if err != nil {
		slog.Error(err.Error())
		return err
	}

	return nil
}

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

	checkTokenResponse, err := widgetService.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 (widgetService *ServiceWidget) GetWidgetHTML(
	ctx context.Context,
	widgetPageID uuid.UUID,
) (string, error) {
	streamerID, err := widgetService.widgetRepo.GetStreamerIdByWidgetPageId(
		ctx,
		widgetPageID,
	)
	if err != nil {
		slog.Error(err.Error())
		return "", err
	}
	return model.GetTemplate1(streamerID, widgetService.baseUrl, widgetService.ttsUrl), nil
}