donat-widget/internal/api/http/handlers/widget/widget.go

package widget

import (
	"context"
	"donat-widget/internal/model"
	"github.com/labstack/echo/v4"
	"log/slog"
	"strconv"
)

func CreateWidget(widgetService model.WidgetService, authClient model.AuthClient) echo.HandlerFunc {
	type Body struct {
		TemplateID model.TemplateID  `json:"templateID"`
		MinAmount  model.DonatAmount `json:"minAmount"`
		Duration   model.Duration    `json:"duration"`
	}

	type Response struct {
		WidgetID model.WidgetID `json:"widgetID"`
	}
	return func(request echo.Context) error {
		ctx := context.Background()
		var body Body
		if err := request.Bind(&body); err != nil {
			return echo.NewHTTPError(400, err.Error())
		}
		if err := request.Validate(&body); err != nil {
			return echo.NewHTTPError(400, err.Error())
		}

		authData, err := authClient.CheckToken(request)
		if err != nil {
			return echo.NewHTTPError(400, err.Error())
		}

		widgetID, err := widgetService.CreateWidget(
			ctx,
			model.StreamerID(authData.StreamerID),
			body.TemplateID,
			body.Duration,
			body.MinAmount,
		)
		if err != nil {
			return request.JSON(422, "Create widget error")
		}

		response := Response{
			WidgetID: widgetID,
		}

		return request.JSON(200, response)
	}
}

func GetWidgetHTML(widgetService model.WidgetService) echo.HandlerFunc {
	return func(request echo.Context) error {
		ctx := context.Background()

		widgetID, err := strconv.Atoi(request.Param("widgetID"))
		if err != nil {
			return echo.NewHTTPError(400, "Path parameter 'widgetID' is invalid")
		}

		widgetHTML, err := widgetService.GetWidgetHTML(
			ctx,
			model.WidgetID(widgetID),
		)
		if err != nil {
			return request.JSON(500, "Get widget HTML error")
		}
		slog.Info("Get widget HTML successfully")
		return request.HTML(200, string(widgetHTML))
	}
}

func GetWidgetInfo(widgetService model.WidgetService) echo.HandlerFunc {
	type Response struct {
		AudioUrl  model.MediaUrl    `json:"audioUrl"`
		ImageUrl  model.MediaUrl    `json:"imageUrl"`
		Text      string            `json:"text"`
		Amount    model.DonatAmount `json:"amount"`
		DonatUser string            `json:"donatUser"`
		Display   model.Display     `json:"display"`
		Duration  model.Duration    `json:"duration"`
		DonatID   model.DonatID     `json:"donatID"`
	}
	return func(request echo.Context) error {
		ctx := context.Background()

		widgetID, err := strconv.Atoi(request.Param("widgetID"))
		if err != nil {
			return echo.NewHTTPError(400, "Path parameter 'widgetID' is invalid")
		}

		donatAndWidget, err := widgetService.GetWidgetInfo(ctx, model.WidgetID(widgetID))
		if err != nil {
			return request.JSON(422, "Get widget info error")
		}

		if !donatAndWidget.Display {
			response := Response{
				Display: donatAndWidget.Display,
			}
			return request.JSON(200, response)
		}

		response := Response{
			AudioUrl:  donatAndWidget.Widget.AudioUrl,
			ImageUrl:  donatAndWidget.Widget.ImageUrl,
			Text:      donatAndWidget.Donat.Text,
			Display:   donatAndWidget.Display,
			Duration:  donatAndWidget.Widget.Duration,
			DonatUser: donatAndWidget.Donat.DonatUser,
			Amount:    donatAndWidget.Donat.Amount,
			DonatID:   donatAndWidget.Donat.ID,
		}

		return request.JSON(200, response)
	}
}

func UpdateDuration(widgetService model.WidgetService) echo.HandlerFunc {
	type Body struct {
		WidgetID model.WidgetID `json:"widgetID" validate:"required"`
		Duration model.Duration `json:"duration" validate:"required"`
	}

	return func(request echo.Context) error {
		ctx := context.Background()
		var body Body
		if err := request.Bind(&body); err != nil {
			return echo.NewHTTPError(400, err.Error())
		}
		if err := request.Validate(&body); err != nil {
			return echo.NewHTTPError(400, err.Error())
		}

		err := widgetService.UpdateDuration(
			ctx,
			body.WidgetID,
			body.Duration,
		)
		if err != nil {
			return request.JSON(422, "Update duration error")
		}

		return request.JSON(200, "Update duration successfully")
	}
}

func SetMediaFile(widgetService model.WidgetService) echo.HandlerFunc {
	return func(request echo.Context) error {
		ctx := context.Background()

		widgetID, err := strconv.Atoi(request.FormValue("widgetID"))
		if err != nil {
			return echo.NewHTTPError(404, "Path parameter 'widgetID' is invalid")
		}

		mediaType := request.Param("mediaType")

		file, err := request.FormFile("file")
		if err != nil {
			return echo.NewHTTPError(404, "Form parameter 'file' is invalid")
		}

		src, err := file.Open()
		if err != nil {
			return echo.NewHTTPError(500, "File is invalid")
		}

		err = widgetService.SetMediaFile(
			ctx,
			model.MediaType(mediaType),
			model.WidgetID(widgetID),
			&src,
			file.Filename,
			file.Size,
			"",
		)
		if err != nil {
			return echo.NewHTTPError(500, "File upload is failed")
		}
		slog.Info("set " + mediaType + " file successfully")
		return request.String(200, "File successfully uploaded")
	}
}

func GetMediaFile(widgetService model.WidgetService) echo.HandlerFunc {
	return func(request echo.Context) error {
		ctx := context.Background()

		mediaType := request.Param("mediaType")
		if mediaType != "background" && mediaType != "image" && mediaType != "audio" {
			return echo.NewHTTPError(400, "Path parameter 'mediaType' is invalid")
		}
		widgetID, err := strconv.Atoi(request.Param("widgetID"))
		if err != nil {
			return echo.NewHTTPError(400, "Path parameter 'widgetID' is invalid")
		}

		file, err := widgetService.GetMediaFile(
			ctx,
			model.WidgetID(widgetID),
			model.MediaType(mediaType),
		)
		if err != nil {
			return echo.NewHTTPError(500, "Get File is failed")
		}
		slog.Info("get " + mediaType + " file successfully")
		return request.Blob(200, "application/octet-stream", file)
	}
}

func UpdateMediaFile(widgetService model.WidgetService) echo.HandlerFunc {
	return func(request echo.Context) error {
		ctx := context.Background()

		widgetID, err := strconv.Atoi(request.FormValue("widgetID"))
		if err != nil {
			return echo.NewHTTPError(404, "Path parameter 'widgetID' is invalid")
		}

		mediaType := request.Param("mediaType")

		file, err := request.FormFile("file")
		if err != nil {
			return echo.NewHTTPError(404, "Form parameter 'file' is invalid")
		}

		src, err := file.Open()
		if err != nil {
			return echo.NewHTTPError(500, "File is invalid")
		}

		err = widgetService.UpdateMediaFile(
			ctx,
			model.WidgetID(widgetID),
			model.MediaType(mediaType),
			&src,
			file.Filename,
			file.Size,
			"",
		)

		if err != nil {
			return echo.NewHTTPError(500, "File update is failed")
		}
		slog.Info("update media file successfully")
		return request.String(200, "Media successfully uploaded")
	}
}

func SetMediaUrl(widgetService model.WidgetService) echo.HandlerFunc {
	type Body struct {
		WidgetID model.WidgetID `json:"widgetID" validate:"required"`
		MediaUrl model.MediaUrl `json:"mediaUrl" validate:"required"`
	}
	return func(request echo.Context) error {
		ctx := context.Background()
		var body Body
		if err := request.Bind(&body); err != nil {
			return echo.NewHTTPError(400, err.Error())
		}
		if err := request.Validate(&body); err != nil {

			return echo.NewHTTPError(400, err.Error())
		}

		mediaType := request.Param("mediaType")

		err := widgetService.SetMediaUrl(
			ctx,
			model.MediaType(mediaType),
			body.WidgetID,
			body.MediaUrl,
		)
		if err != nil {
			return echo.NewHTTPError(500, "Set MediaUrl is failed")
		}

		return request.String(200, "Media URL successfully set")
	}
}