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

package widget

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

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

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

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.WidgetID, error) {
	exists, err := widgetService.widgetRepo.CheckWidgetName(ctx, streamerID, name)
	if err != nil {
		return 0, err
	}
	fmt.Println(exists)
	if exists == true {
		slog.Error("GetWidgetDb with name %s already exists", name)
		return 0, 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 0, err
	}
	return widgetID, nil
}

func (widgetService *ServiceWidget) GetWidgetsByStreamer(
	ctx context.Context,
	streamerID int,
) ([]*model.WidgetWithFileLink, error) {
	widgets, err := widgetService.widgetRepo.GetWidgetsByStreamerID(ctx, streamerID)
	if err != nil {
		slog.Error(err.Error())
		return nil, 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,
		})
	}

	return result, nil
}

func (widgetService *ServiceWidget) UpdateWidget(
	ctx context.Context,
	updateWidget model.UpdateWidget,
	widgetID int,
	accountID int,
) error {
	err := widgetService.widgetRepo.WidgetByID(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) GetWidgetHTML(
//	ctx context.Context,
//	streamerID model.StreamerID,
//) (model.WidgetHTML, error) {
//
//	widgets, err := widgetService.widgetRepo.GetWidgetsByStreamerID(ctx, streamerID)
//	if err != nil {
//		slog.Error(err.Error())
//		return "", err
//	}
//
//	if len(widgets) == 0 {
//		return "", errors.New("widget not found")
//	}
//	widget := widgets[0]
//
//	var widgetHTML model.WidgetHTML
//	if widget.TemplateID == 1 {
//		widgetHTML = model.GetTemplate1(
//			streamerID,
//			widget.BackgroundUrl,
//		)
//	}
//	return widgetHTML, nil
//}
//
//func (widgetService *ServiceWidget) GetWidgetByID(
//	ctx context.Context,
//	widgetID model.WidgetID,
//) ([]*model.GetWidgetDb, error) {
//
//	widget, err := widgetService.widgetRepo.GetWidgetByID(ctx, widgetID)
//	if err != nil {
//		slog.Error(err.Error())
//		return nil, err
//	}
//
//	return widget, nil
//}
//
//func (widgetService *ServiceWidget) SetMediaFile(
//	ctx context.Context,
//	mediaType model.MediaType,
//	widgetID model.WidgetID,
//	file model.UploadFile,
//	filename string,
//	size int64,
//	collection string,
//) error {
//	fileID, err := widgetService.widgetRepo.SetMediaFile(
//		file,
//		filename,
//		size,
//		collection,
//	)
//	if err != nil {
//		slog.Error(err.Error())
//		return err
//	}
//
//	err = widgetService.SetMediaUrl(
//		ctx,
//		mediaType,
//		widgetID,
//		model.MediaUrl(fileID),
//	)
//	if err != nil {
//		slog.Error(err.Error())
//		return err
//	}
//
//	return nil
//}
//
//func (widgetService *ServiceWidget) GetMediaFile(
//	ctx context.Context,
//	widgetID model.WidgetID,
//	mediaType model.MediaType,
//) (model.DownloadFile, error) {
//	fileID, err := widgetService.widgetRepo.GetMediaUrl(
//		ctx,
//		widgetID,
//		mediaType,
//	)
//	if err != nil {
//		slog.Error(err.Error())
//		return nil, err
//	}
//
//	file, err := widgetService.widgetRepo.GetMediaFile(
//		model.FileID(fileID),
//	)
//	if err != nil {
//		slog.Error(err.Error())
//		return nil, err
//	}
//	return file, nil
//}
//
//func (widgetService *ServiceWidget) SetMediaUrl(
//	ctx context.Context,
//	mediaType model.MediaType,
//	widgetID model.WidgetID,
//	mediaUrl model.MediaUrl,
//) error {
//	err := widgetService.widgetRepo.SetMediaUrl(
//		ctx,
//		widgetID,
//		mediaUrl,
//		mediaType,
//	)
//	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
}