741 lines
25 KiB
Go
741 lines
25 KiB
Go
package donat
|
||
|
||
import (
|
||
"context"
|
||
"donat-widget/internal/model"
|
||
_ "donat-widget/internal/model/api"
|
||
"donat-widget/pkg/custom_response"
|
||
"donat-widget/pkg/validator"
|
||
"github.com/labstack/echo/v4"
|
||
"log/slog"
|
||
"mime/multipart"
|
||
"net/http"
|
||
"strconv"
|
||
)
|
||
|
||
// CreateDonat godoc
|
||
// @Summary Create donat
|
||
// @Description Create donat
|
||
// @Tags Donate
|
||
// @Accept json
|
||
// @Produce json
|
||
// @Param streamer-login path string true "Login стримера"
|
||
// @Param request body model.CreateDonatBody true "Create donat body json"
|
||
// @Success 200 {object} api.CreatePaymentResponse "Donat page updated successfully"
|
||
// @Failure 400 {object} echo.HTTPError "Bad request"
|
||
// @Failure 401 {object} echo.HTTPError "Unauthorized or expired token"
|
||
// @Failure 422 {object} echo.HTTPError "Validation error"
|
||
// @Router /donat/{streamer-login} [post]
|
||
func CreateDonat(donatService model.DonatService) echo.HandlerFunc {
|
||
return func(request echo.Context) error {
|
||
ctx := context.Background()
|
||
var body model.CreateDonatBody
|
||
|
||
err := validator.ParseAndValidate(&body, request)
|
||
if err != nil {
|
||
slog.Error(err.Error())
|
||
return echo.NewHTTPError(http.StatusUnprocessableEntity, "Unprocessable Entity")
|
||
}
|
||
|
||
streamerLogin := request.Param("streamer-login")
|
||
order, err := donatService.CreateDonat(
|
||
ctx,
|
||
streamerLogin,
|
||
body.Text,
|
||
body.DonatUser,
|
||
body.TargetID,
|
||
body.Amount,
|
||
)
|
||
if err != nil {
|
||
return request.JSON(http.StatusInternalServerError, err.Error())
|
||
}
|
||
|
||
return request.JSON(http.StatusCreated, order)
|
||
}
|
||
}
|
||
|
||
// GetDonat godoc
|
||
// @Summary Get donats
|
||
// @Description Получает список донатов для указанного стримера с пагинацией
|
||
// @Tags Donate
|
||
// @Accept json
|
||
// @Produce json
|
||
// @Security BearerAuth
|
||
// @Param page query int false "Номер страницы (по умолчанию 1)" default(1)
|
||
// @Param limit query int false "Количество элементов на странице (по умолчанию 10)" default(10)
|
||
// @Success 200 {array} model.Donat "Успешный возврат списка донатов"
|
||
// @Failure 400 {object} echo.HTTPError "Некорректный формат streamerID"
|
||
// @Failure 500 {object} echo.HTTPError "Внутренняя ошибка сервера"
|
||
// @Router /donat [get]
|
||
func GetDonat(donatService model.DonatService) echo.HandlerFunc {
|
||
return func(request echo.Context) error {
|
||
ctx := context.Background()
|
||
page, err := strconv.Atoi(request.QueryParam("page"))
|
||
if page == 0 || err != nil {
|
||
page = 1
|
||
}
|
||
limit, err := strconv.Atoi(request.QueryParam("limit"))
|
||
if limit == 0 || err != nil {
|
||
limit = 20
|
||
}
|
||
|
||
authData, err := donatService.CheckToken(request)
|
||
if err != nil {
|
||
slog.Error("Unauthorized")
|
||
return echo.NewHTTPError(http.StatusUnauthorized, err.Error())
|
||
}
|
||
if err != nil {
|
||
slog.Error(err.Error())
|
||
return request.JSON(http.StatusInternalServerError, err.Error())
|
||
}
|
||
donats, err := donatService.GetDonatsByStreamerID(
|
||
ctx,
|
||
authData.AccountID,
|
||
page,
|
||
limit,
|
||
)
|
||
if err != nil {
|
||
slog.Error(err.Error())
|
||
return request.JSON(http.StatusInternalServerError, err.Error())
|
||
}
|
||
|
||
slog.Info("get donat successfully")
|
||
return request.JSON(200, donats)
|
||
|
||
}
|
||
}
|
||
|
||
// MarkDonatPaid godoc
|
||
// @Summary Mark donat as paid
|
||
// @Description Mark donat as paid
|
||
// @Tags Donate
|
||
// @Accept json
|
||
// @Produce json
|
||
// @Param request body model.MarkDonatPaidBody true "order id body"
|
||
// @Success 200 {string} string "Ok"
|
||
// @Failure 400 {object} echo.HTTPError "Некорректный формат streamerID"
|
||
// @Failure 500 {object} echo.HTTPError "Внутренняя ошибка сервера"
|
||
// @Router /donat/paid [post]
|
||
func MarkDonatPaid(donatService model.DonatService) echo.HandlerFunc {
|
||
return func(request echo.Context) error {
|
||
ctx := context.Background()
|
||
var body model.MarkDonatPaidBody
|
||
err := validator.ParseAndValidate(&body, request)
|
||
if err != nil {
|
||
slog.Error(err.Error())
|
||
return echo.NewHTTPError(http.StatusUnprocessableEntity, "Unprocessable Entity")
|
||
}
|
||
|
||
err = donatService.MarkDonatPaid(ctx, body.OrderID)
|
||
if err != nil {
|
||
slog.Error(err.Error())
|
||
return request.JSON(http.StatusInternalServerError, err.Error())
|
||
}
|
||
slog.Info("mark donat paid successfully")
|
||
return request.String(200, "Donat paid success")
|
||
}
|
||
}
|
||
|
||
// MarkDonatView godoc
|
||
// @Summary Mark donat as viewed
|
||
// @Description Mark donat as viewed
|
||
// @Tags Donate
|
||
// @Accept json
|
||
// @Produce json
|
||
// @Param request body model.MarkDonatViewed true "order id body"
|
||
// @Success 200 {string} string "Ok"
|
||
// @Failure 500 {object} echo.HTTPError "Внутренняя ошибка сервера"
|
||
// @Router /donat/viewed [post]
|
||
func MarkDonatView(donatService model.DonatService) echo.HandlerFunc {
|
||
return func(request echo.Context) error {
|
||
ctx := context.Background()
|
||
|
||
var body model.MarkDonatViewed
|
||
|
||
err := validator.ParseAndValidate(&body, request)
|
||
if err != nil {
|
||
slog.Error(err.Error())
|
||
return echo.NewHTTPError(http.StatusUnprocessableEntity, "Unprocessable Entity")
|
||
}
|
||
|
||
err = donatService.MarkDonatView(
|
||
ctx,
|
||
body.OrderID,
|
||
)
|
||
if err != nil {
|
||
return echo.NewHTTPError(http.StatusInternalServerError, "Interaction Error")
|
||
}
|
||
slog.Info("Donat viewed successfully")
|
||
return request.JSON(http.StatusOK, "donat view success")
|
||
}
|
||
}
|
||
|
||
// GetInnerDonatePage godoc
|
||
// @Summary Get inner donate page info
|
||
// @Description Get inner donate page info
|
||
// @Tags Donate
|
||
// @Accept json
|
||
// @Produce json
|
||
// @Security BearerAuth
|
||
// @Success 200 {object} model.InnerDonatePageResponse "Current donate page state"
|
||
// @Failure 400 {object} echo.HTTPError "Bad request"
|
||
// @Failure 401 {object} echo.HTTPError "Unauthorized or expired token"
|
||
// @Failure 422 {object} echo.HTTPError "Validation error"
|
||
// @Router /inner-donate-page [get]
|
||
func GetInnerDonatePage(donatService model.DonatService) echo.HandlerFunc {
|
||
return func(request echo.Context) error {
|
||
authData, err := donatService.CheckToken(request)
|
||
if err != nil {
|
||
slog.Error("Unauthorized")
|
||
return echo.NewHTTPError(http.StatusUnauthorized, err.Error())
|
||
}
|
||
ctx := context.Background()
|
||
|
||
var innerPage model.InnerDonatePageResponse
|
||
innerPage, err = donatService.GetInnerDonatPage(ctx, authData.AccountID)
|
||
if err != nil {
|
||
return echo.NewHTTPError(http.StatusInternalServerError, err.Error())
|
||
}
|
||
return request.JSON(http.StatusOK, innerPage)
|
||
}
|
||
}
|
||
|
||
// GetOuterDonatePage godoc
|
||
// @Summary Get outer donate page info
|
||
// @Description Get outer donate page info
|
||
// @Tags Donate
|
||
// @Accept json
|
||
// @Produce json
|
||
// @Param streamer-login path string true "Login стримера"
|
||
// @Success 200 {object} model.OuterDonatePageResponse "Current donate page state"
|
||
// @Failure 400 {object} echo.HTTPError "Bad request"
|
||
// @Failure 401 {object} echo.HTTPError "Unauthorized or expired token"
|
||
// @Failure 422 {object} echo.HTTPError "Validation error"
|
||
// @Router /outer-donate-page/{streamer-login} [get]
|
||
func GetOuterDonatePage(donatService model.DonatService) echo.HandlerFunc {
|
||
return func(request echo.Context) error {
|
||
ctx := context.Background()
|
||
streamerLogin := request.Param("streamer-login")
|
||
|
||
outerPageResponse, err := donatService.GetOuterDonatPage(
|
||
ctx, streamerLogin,
|
||
)
|
||
if outerPageResponse.Login == "" {
|
||
return echo.NewHTTPError(http.StatusNotFound, "Пользователь не найден!")
|
||
}
|
||
if err != nil {
|
||
return echo.NewHTTPError(http.StatusInternalServerError, custom_response.InternalError)
|
||
}
|
||
return request.JSON(http.StatusOK, outerPageResponse)
|
||
}
|
||
}
|
||
|
||
// UpdateDonatePage godoc
|
||
// @Summary Update personal streamer donate page
|
||
// @Description Update personal streamer donate page with optional background and head image files.
|
||
// @Tags Donate
|
||
// @Consumes multipart/form-data
|
||
// @Produces json
|
||
// @Security BearerAuth
|
||
// @Param metadata formData model.UpdateDonatPage false "Update fields"
|
||
// @Param background formData file false "Background image"
|
||
// @Param head_img formData file false "Head image"
|
||
// @Param avatar formData file false "Avatar image"
|
||
// @Success 200 {string} string "Donat page updated successfully"
|
||
// @Failure 400 {object} echo.HTTPError "Bad request"
|
||
// @Failure 401 {object} echo.HTTPError "Unauthorized or expired token"
|
||
// @Failure 422 {object} echo.HTTPError "Validation error"
|
||
// @Router /donat-page [patch]
|
||
func UpdateDonatePage(donatService model.DonatService, fileService model.FileService) echo.HandlerFunc {
|
||
return func(request echo.Context) error {
|
||
ctx := context.Background()
|
||
|
||
var body model.UpdateDonatPage
|
||
err := validator.ParseAndValidate(&body, request)
|
||
if err != nil {
|
||
slog.Error(err.Error())
|
||
return echo.NewHTTPError(http.StatusUnprocessableEntity, "Unprocessable Entity")
|
||
}
|
||
|
||
authData, err := donatService.CheckToken(request)
|
||
if err != nil {
|
||
slog.Error(err.Error())
|
||
return echo.NewHTTPError(http.StatusUnauthorized, custom_response.Unauthorized)
|
||
}
|
||
|
||
bgFile, err := request.FormFile("background")
|
||
if err != nil {
|
||
bgFile = &multipart.FileHeader{
|
||
Filename: "",
|
||
Size: 0,
|
||
Header: nil,
|
||
}
|
||
}
|
||
|
||
headImgFile, err := request.FormFile("head_img")
|
||
if err != nil {
|
||
headImgFile = &multipart.FileHeader{
|
||
Filename: "",
|
||
Size: 0,
|
||
Header: nil,
|
||
}
|
||
}
|
||
|
||
avatarFile, err := request.FormFile("avatar")
|
||
if err != nil {
|
||
headImgFile = &multipart.FileHeader{
|
||
Filename: "",
|
||
Size: 0,
|
||
Header: nil,
|
||
}
|
||
}
|
||
|
||
// Передаем файлы только если они были переданы
|
||
err = donatService.UpdateDonatePage(
|
||
ctx,
|
||
authData.AccountID,
|
||
body,
|
||
*bgFile,
|
||
*headImgFile,
|
||
*avatarFile,
|
||
)
|
||
if err != nil {
|
||
return echo.NewHTTPError(http.StatusInternalServerError, custom_response.InternalError)
|
||
}
|
||
return request.JSON(http.StatusOK, "Success")
|
||
}
|
||
}
|
||
|
||
// GetVoiceSettings godoc
|
||
// @Summary Get donat voice settings
|
||
// @Description Get donat voice settings
|
||
// @Tags Donate
|
||
// @Accept json
|
||
// @Produce json
|
||
// @Security BearerAuth
|
||
// @Success 200 {object} model.VoiceSettingsResponse "Current voice settings"
|
||
// @Failure 400 {object} echo.HTTPError "Bad request"
|
||
// @Failure 401 {object} echo.HTTPError "Unauthorized or expired token"
|
||
// @Failure 422 {object} echo.HTTPError "Validation error"
|
||
// @Router /voice-settings [get]
|
||
func GetVoiceSettings(donatService model.DonatService) echo.HandlerFunc {
|
||
return func(request echo.Context) error {
|
||
ctx := context.Background()
|
||
|
||
authData, err := donatService.CheckToken(request)
|
||
if err != nil {
|
||
slog.Error("Unauthorized")
|
||
return echo.NewHTTPError(http.StatusUnauthorized, err.Error())
|
||
}
|
||
|
||
voiceSettings, err := donatService.GetVoiceSettings(ctx, authData.AccountID)
|
||
if err != nil {
|
||
slog.Error("Failed to get voice settings", "error", err)
|
||
return echo.NewHTTPError(http.StatusInternalServerError, "Internal server error")
|
||
}
|
||
|
||
// Возвращаем настройки голоса в JSON
|
||
return request.JSON(http.StatusOK, voiceSettings)
|
||
}
|
||
}
|
||
|
||
// UpdateVoiceSettings godoc
|
||
// @Summary Update donat voice settings.
|
||
// @Description Update donat voice settings.
|
||
// @Tags Donate
|
||
// @Accept json
|
||
// @Produce json
|
||
// @Security BearerAuth
|
||
// @Param request body model.UpdateVoiceSettings true "Update fields"
|
||
// @Success 200 {string} string "Voice settings updated successfully"
|
||
// @Failure 400 {object} echo.HTTPError "Bad request"
|
||
// @Failure 401 {object} echo.HTTPError "Unauthorized or expired token"
|
||
// @Failure 422 {object} echo.HTTPError "Validation error"
|
||
// @Router /voice-settings [patch]
|
||
func UpdateVoiceSettings(donatService model.DonatService) echo.HandlerFunc {
|
||
return func(request echo.Context) error {
|
||
ctx := context.Background()
|
||
|
||
authData, err := donatService.CheckToken(request)
|
||
if err != nil {
|
||
slog.Error("Unauthorized")
|
||
return echo.NewHTTPError(http.StatusUnauthorized, err.Error())
|
||
}
|
||
|
||
var body model.UpdateVoiceSettings
|
||
err = validator.ParseAndValidate(&body, request)
|
||
if err != nil {
|
||
slog.Error(err.Error())
|
||
return echo.NewHTTPError(http.StatusUnprocessableEntity, "Unprocessable Entity")
|
||
}
|
||
err = donatService.UpdateVoiceSettings(ctx, authData.AccountID, body)
|
||
if err != nil {
|
||
slog.Error("Failed to update voice settings", "error", err)
|
||
return echo.NewHTTPError(http.StatusInternalServerError, "Failed to update voice settings")
|
||
}
|
||
|
||
return request.JSON(http.StatusOK, "Voice settings updated successfully")
|
||
}
|
||
}
|
||
|
||
// GetFiltersSettings godoc
|
||
// @Summary Get donat filters settings
|
||
// @Description Get donat filters settings
|
||
// @Tags Donate
|
||
// @Accept json
|
||
// @Produce json
|
||
// @Security BearerAuth
|
||
// @Success 200 {object} model.FilterSettingResponse "Current filters settings"
|
||
// @Failure 400 {object} echo.HTTPError "Bad request"
|
||
// @Failure 401 {object} echo.HTTPError "Unauthorized or expired token"
|
||
// @Failure 422 {object} echo.HTTPError "Validation error"
|
||
// @Router /filters-settings [get]
|
||
func GetFiltersSettings(donatService model.DonatService) echo.HandlerFunc {
|
||
return func(request echo.Context) error {
|
||
ctx := context.Background()
|
||
|
||
authData, err := donatService.CheckToken(request)
|
||
if err != nil {
|
||
slog.Error("Unauthorized")
|
||
return echo.NewHTTPError(http.StatusUnauthorized, err.Error())
|
||
}
|
||
filtersSettings, err := donatService.GetFiltersSettings(ctx, authData.AccountID)
|
||
if err != nil {
|
||
slog.Error("Failed to get filters settings", "error", err)
|
||
return echo.NewHTTPError(http.StatusInternalServerError, "Internal server error")
|
||
}
|
||
return request.JSON(http.StatusOK, filtersSettings)
|
||
}
|
||
}
|
||
|
||
// UpdateFiltersSettings godoc
|
||
// @Summary Update donat filters settings.
|
||
// @Description Update donat filters settings.
|
||
// @Tags Donate
|
||
// @Accept json
|
||
// @Produce json
|
||
// @Security BearerAuth
|
||
// @Param request body model.UpdateFilterSettings true "Update fields"
|
||
// @Success 200 {string} string "Voice settings updated successfully"
|
||
// @Failure 400 {object} echo.HTTPError "Bad request"
|
||
// @Failure 401 {object} echo.HTTPError "Unauthorized or expired token"
|
||
// @Failure 422 {object} echo.HTTPError "Validation error"
|
||
// @Router /filters-settings [patch]
|
||
func UpdateFiltersSettings(donatService model.DonatService) echo.HandlerFunc {
|
||
return func(request echo.Context) error {
|
||
ctx := context.Background()
|
||
|
||
var body model.UpdateFilterSettings
|
||
err := validator.ParseAndValidate(&body, request)
|
||
if err != nil {
|
||
slog.Error(err.Error())
|
||
return echo.NewHTTPError(http.StatusUnprocessableEntity, "Unprocessable Entity")
|
||
}
|
||
|
||
authData, err := donatService.CheckToken(request)
|
||
if err != nil {
|
||
slog.Error("Unauthorized")
|
||
return echo.NewHTTPError(http.StatusUnauthorized, err.Error())
|
||
}
|
||
|
||
err = donatService.UpdateFiltersSettings(
|
||
ctx,
|
||
authData.AccountID,
|
||
body,
|
||
)
|
||
return request.JSON(http.StatusOK, "Success update")
|
||
}
|
||
}
|
||
|
||
// GetModerationSettings godoc
|
||
// @Summary Get donat moderation settings
|
||
// @Description Get donat moderation settings
|
||
// @Tags Donate
|
||
// @Accept json
|
||
// @Produce json
|
||
// @Security BearerAuth
|
||
// @Success 200 {object} model.ModerationResponse "Current moderation settings"
|
||
// @Failure 400 {object} echo.HTTPError "Bad request"
|
||
// @Failure 401 {object} echo.HTTPError "Unauthorized or expired token"
|
||
// @Failure 422 {object} echo.HTTPError "Validation error"
|
||
// @Router /moderation-settings [get]
|
||
func GetModerationSettings(donatService model.DonatService) echo.HandlerFunc {
|
||
return func(request echo.Context) error {
|
||
ctx := context.Background()
|
||
|
||
authData, err := donatService.CheckToken(request)
|
||
if err != nil {
|
||
slog.Error("Unauthorized")
|
||
return echo.NewHTTPError(http.StatusUnauthorized, err.Error())
|
||
}
|
||
|
||
moderationSettings, err := donatService.GetModerationSettings(ctx, authData.AccountID)
|
||
if err != nil {
|
||
slog.Error("Failed to get moderation settings", "error", err)
|
||
return echo.NewHTTPError(http.StatusInternalServerError, "Internal server error")
|
||
}
|
||
return request.JSON(http.StatusOK, moderationSettings)
|
||
}
|
||
}
|
||
|
||
// UpdateModerationSettings godoc
|
||
// @Summary Update donat moderation settings
|
||
// @Description Update donat moderation settings
|
||
// @Tags Donate
|
||
// @Accept json
|
||
// @Produce json
|
||
// @Security BearerAuth
|
||
// @Param request body model.UpdateModeration true "Update fields"
|
||
// @Success 200 {string} string "Moderation settings updated successfully"
|
||
// @Failure 400 {object} echo.HTTPError "Bad request"
|
||
// @Failure 401 {object} echo.HTTPError "Unauthorized or expired token"
|
||
// @Failure 422 {object} echo.HTTPError "Validation error"
|
||
// @Router /moderation-settings [patch]
|
||
func UpdateModerationSettings(donatService model.DonatService) echo.HandlerFunc {
|
||
return func(request echo.Context) error {
|
||
ctx := context.Background()
|
||
|
||
var body model.UpdateModeration
|
||
err := validator.ParseAndValidate(&body, request)
|
||
if err != nil {
|
||
slog.Error(err.Error())
|
||
return echo.NewHTTPError(http.StatusUnprocessableEntity, "Unprocessable Entity")
|
||
}
|
||
|
||
authData, err := donatService.CheckToken(request)
|
||
if err != nil {
|
||
slog.Error("Unauthorized")
|
||
return echo.NewHTTPError(http.StatusUnauthorized, err.Error())
|
||
}
|
||
|
||
err = donatService.UpdateModerationSettings(
|
||
ctx,
|
||
authData.AccountID,
|
||
body,
|
||
)
|
||
if err != nil {
|
||
slog.Error("Failed to update moderation settings", "error", err)
|
||
return echo.NewHTTPError(http.StatusInternalServerError, "Failed to update moderation settings")
|
||
}
|
||
|
||
return request.JSON(http.StatusOK, "Success update")
|
||
}
|
||
}
|
||
|
||
// GetDonationsStats godoc
|
||
// @Summary Get donations statistics
|
||
// @Description Get donations statistics for a given period
|
||
// @Tags Donate
|
||
// @Accept json
|
||
// @Produce json
|
||
// @Security BearerAuth
|
||
// @Param period query string true "Period for statistics" Enums(24h, 7d, 1m, 1y)
|
||
// @Success 200 {array} model.DonationSummaryResponse "Donations statistics"
|
||
// @Failure 400 {object} echo.HTTPError "Bad request"
|
||
// @Failure 401 {object} echo.HTTPError "Unauthorized or expired token"
|
||
// @Failure 422 {object} echo.HTTPError "Validation error"
|
||
// @Router /donat/period-stat [get]
|
||
func GetDonationsStats(donatService model.DonatService) echo.HandlerFunc {
|
||
return func(request echo.Context) error {
|
||
authData, err := donatService.CheckToken(request)
|
||
if err != nil {
|
||
slog.Error("Unauthorized")
|
||
return echo.NewHTTPError(http.StatusUnauthorized, err.Error())
|
||
}
|
||
ctx := context.Background()
|
||
|
||
period := request.QueryParam("period")
|
||
if period == "" {
|
||
return echo.NewHTTPError(http.StatusBadRequest, "period is required")
|
||
}
|
||
|
||
stats, err := donatService.GetDonationsStats(ctx, authData.AccountID, period)
|
||
if err != nil {
|
||
return echo.NewHTTPError(http.StatusInternalServerError, err.Error())
|
||
}
|
||
|
||
return request.JSON(http.StatusOK, stats)
|
||
}
|
||
}
|
||
|
||
// GetDonateModeration godoc
|
||
// @Summary Get the latest donation in moderation
|
||
// @Description Get the latest donation with status 'moderation' sorted by updated_at
|
||
// @Tags Donate
|
||
// @Accept json
|
||
// @Produce json
|
||
// @Security BearerAuth
|
||
// @Success 200 {object} model.DonationModeration "Latest donation in moderation"
|
||
// @Failure 400 {object} echo.HTTPError "Bad request"
|
||
// @Failure 401 {object} echo.HTTPError "Unauthorized or expired token"
|
||
// @Failure 404 {object} echo.HTTPError "No donations in moderation found"
|
||
// @Failure 500 {object} echo.HTTPError "Internal server error"
|
||
// @Router /donat-moderate/latest-moderation [get]
|
||
func GetDonateModeration(donatService model.DonatService) echo.HandlerFunc {
|
||
return func(request echo.Context) error {
|
||
authData, err := donatService.CheckToken(request)
|
||
if err != nil {
|
||
slog.Error("Unauthorized")
|
||
return echo.NewHTTPError(http.StatusUnauthorized, err.Error())
|
||
}
|
||
ctx := context.Background()
|
||
|
||
donation, err := donatService.GetDonatModeration(ctx, authData.AccountID)
|
||
if err != nil {
|
||
return echo.NewHTTPError(http.StatusInternalServerError, err.Error())
|
||
}
|
||
|
||
if donation.ID == 0 { // Если донат не найден
|
||
return request.JSON(http.StatusOK, map[string]interface{}{})
|
||
}
|
||
|
||
return request.JSON(http.StatusOK, donation)
|
||
}
|
||
}
|
||
|
||
// ModerateDonat godoc
|
||
// @Summary Update donat settings
|
||
// @Description Update donat settings such as accepted, show_text, play_content, show_name
|
||
// @Tags Donate
|
||
// @Accept json
|
||
// @Produce json
|
||
// @Security BearerAuth
|
||
// @Param donat-id path int true "ID доната"
|
||
// @Param request body model.ModerationDonat true "Update fields"
|
||
// @Success 200 {string} string "Donat settings updated successfully"
|
||
// @Failure 400 {object} echo.HTTPError "Bad request"
|
||
// @Failure 401 {object} echo.HTTPError "Unauthorized or expired token"
|
||
// @Failure 422 {object} echo.HTTPError "Validation error"
|
||
// @Router /donat-moderate/{donat-id} [patch]
|
||
func ModerateDonat(donatService model.DonatService) echo.HandlerFunc {
|
||
return func(request echo.Context) error {
|
||
ctx := context.Background()
|
||
donatID, err := strconv.Atoi(request.Param("donat-id"))
|
||
if err != nil {
|
||
slog.Error(err.Error())
|
||
return echo.NewHTTPError(http.StatusUnprocessableEntity, "Incorrect donat id")
|
||
}
|
||
var body model.ModerationDonat
|
||
err = validator.ParseAndValidate(&body, request)
|
||
if err != nil {
|
||
slog.Error(err.Error())
|
||
return echo.NewHTTPError(http.StatusUnprocessableEntity, "Unprocessable Entity")
|
||
}
|
||
|
||
authData, err := donatService.CheckToken(request)
|
||
if err != nil {
|
||
slog.Error("Unauthorized")
|
||
return echo.NewHTTPError(http.StatusUnauthorized, err.Error())
|
||
}
|
||
|
||
err = donatService.ModerateDonation(
|
||
ctx,
|
||
donatID,
|
||
authData.AccountID,
|
||
body,
|
||
)
|
||
if err != nil {
|
||
slog.Error("Failed to update donat settings", "error", err)
|
||
return echo.NewHTTPError(http.StatusInternalServerError, "Failed to update donat settings")
|
||
}
|
||
|
||
return request.JSON(http.StatusOK, "Donat settings updated successfully")
|
||
}
|
||
}
|
||
|
||
// InitNewStreamer godoc
|
||
// @Summary Initialize new streamer
|
||
// @Description Creates initial records for new streamer in related tables
|
||
// @Tags Donate
|
||
// @Accept json
|
||
// @Produce json
|
||
// @Param request body model.InitNewStreamerBody true "Streamer initialization data"
|
||
// @Success 200 {string} string "Streamer initialized successfully"
|
||
// @Failure 400 {object} echo.HTTPError "Bad request"
|
||
// @Failure 401 {object} echo.HTTPError "Unauthorized or expired token"
|
||
// @Failure 422 {object} echo.HTTPError "Validation error"
|
||
// @Router /init-streamer [post]
|
||
func InitNewStreamer(donatService model.DonatService) echo.HandlerFunc {
|
||
return func(request echo.Context) error {
|
||
ctx := context.Background()
|
||
|
||
var body model.InitNewStreamerBody
|
||
if err := validator.ParseAndValidate(&body, request); err != nil {
|
||
slog.Error("Validation error", "error", err)
|
||
return echo.NewHTTPError(http.StatusUnprocessableEntity, "Invalid request body")
|
||
}
|
||
|
||
if err := donatService.InitNewStreamer(
|
||
ctx,
|
||
body.StreamerID,
|
||
body.Login,
|
||
); err != nil {
|
||
slog.Error("Initialization failed", "error", err)
|
||
return echo.NewHTTPError(http.StatusInternalServerError, "Initialization failed")
|
||
}
|
||
|
||
return request.JSON(http.StatusCreated, "Streamer initialized successfully")
|
||
}
|
||
}
|
||
|
||
// GetDonatForPlaying godoc
|
||
// @Summary Initialize new streamer
|
||
// @Description Creates initial records for new streamer in related tables
|
||
// @Tags Donate
|
||
// @Accept json
|
||
// @Produce json
|
||
// @Param streamer-id path string true "Login стримера"
|
||
// @Success 200 {object} model.PlayingDonat "Donat data"
|
||
// @Failure 400 {object} echo.HTTPError "Bad request"
|
||
// @Failure 401 {object} echo.HTTPError "Unauthorized or expired token"
|
||
// @Failure 422 {object} echo.HTTPError "Validation error"
|
||
// @Router /get-donat-for-playing/{streamer-id} [get]
|
||
func GetDonatForPlaying(donatService model.DonatService) echo.HandlerFunc {
|
||
return func(request echo.Context) error {
|
||
ctx := context.Background()
|
||
streamerLogin := request.Param("streamer-id")
|
||
|
||
login, err := strconv.Atoi(streamerLogin)
|
||
|
||
playingDonat, err := donatService.GetPlayingDonat(ctx, login)
|
||
if err != nil {
|
||
slog.Error("Failed to get playing donat", "error", err)
|
||
return echo.NewHTTPError(http.StatusInternalServerError, "Failed to get playing donat")
|
||
}
|
||
return request.JSON(http.StatusOK, playingDonat)
|
||
|
||
}
|
||
}
|
||
|
||
// UpdateLoginDonatePage godoc
|
||
// @Summary Update streamer login
|
||
// @Description Updates the streamer login associated with the donate page
|
||
// @Tags Donate
|
||
// @Accept json
|
||
// @Produce json
|
||
// @Param request body model.UpdateLoginBody true "Update data"
|
||
// @Success 200 {object} string "Successfully updated streamer login"
|
||
// @Failure 400 {object} echo.HTTPError "Bad request"
|
||
// @Failure 401 {object} echo.HTTPError "Unauthorized or expired token"
|
||
// @Failure 500 {object} echo.HTTPError "Internal server error"
|
||
// @Router /update-login-donate [post]
|
||
func UpdateLoginDonatePage(donatService model.DonatService) echo.HandlerFunc {
|
||
return func(request echo.Context) error {
|
||
ctx := context.Background()
|
||
|
||
var body model.UpdateLoginBody
|
||
if err := validator.ParseAndValidate(&body, request); err != nil {
|
||
slog.Error("Validation error", "error", err)
|
||
return echo.NewHTTPError(http.StatusUnprocessableEntity, "Invalid request body")
|
||
}
|
||
|
||
err := donatService.UpdateStreamerLogin(ctx, body.Login, body.AccountID)
|
||
if err != nil {
|
||
slog.Error("Failed to update streamer login", "error", err)
|
||
return echo.NewHTTPError(http.StatusInternalServerError, "Failed to update streamer login")
|
||
}
|
||
return request.JSON(http.StatusOK, "Successfully updated streamer login")
|
||
|
||
}
|
||
}
|