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
	fileRepo      model.FileRepo
	fileService   model.FileService
	storage       model.Storage
}

func New(
	donatRepo model.DonatRepo,
	widgetRepo model.WidgetRepo,
	paymentClient model.PaymentClient,
	authClient model.AuthClient,
	fileRepo model.FileRepo,
	fileService model.FileService,
	storage model.Storage,
) *ServiceDonat {
	return &ServiceDonat{
		donatRepo:     donatRepo,
		widgetRepo:    widgetRepo,
		paymentClient: paymentClient,
		authClient:    authClient,
		fileRepo:      fileRepo,
		fileService:   fileService,
		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) {
	return api.CreatePaymentResponse{}, nil
	//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
	}

	// Создаем объекты InnerFile для каждого изображения
	headImgFile := model.InnerFile{
		FileID:   donatePage.HeadImgFileId,
		FileName: donatePage.HeadImgFileName,
		FileType: donatePage.HeadImgType,
		FileLink: donatService.storage.DownloadLink(donatePage.HeadImgFileId),
		FileSize: donatePage.HeadImgSize,
	}

	avatarFile := model.InnerFile{
		FileID:   donatePage.AvatarFileId,
		FileName: donatePage.AvatarFileName,
		FileType: donatePage.AvatarType,
		FileLink: donatService.storage.DownloadLink(donatePage.AvatarFileId),
		FileSize: donatePage.AvatarImgSize,
	}

	backgroundImgFile := model.InnerFile{
		FileID:   donatePage.BackgroundImgFileId,
		FileName: donatePage.BackgroundImgFileName,
		FileType: donatePage.BackgroundImgType,
		FileLink: donatService.storage.DownloadLink(donatePage.BackgroundImgFileId),
		FileSize: donatePage.BackgroundImgSize,
	}

	// Создаем объект InnerDonatePageResponse
	innerDonatePageResponse := model.InnerDonatePageResponse{
		Description:    donatePage.Description,
		TextAfterDonat: donatePage.TextAfterDonat,
		HeadImg:        headImgFile,
		Avatar:         avatarFile,
		BackgroundImg:  backgroundImgFile,
	}

	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: donatService.storage.DownloadLink(donatePage.BackgroundImgFileId),
		HeadImg:       donatService.storage.DownloadLink(donatePage.HeadImgFileId),
		AvatarImg:     donatService.storage.DownloadLink(donatePage.AvatarFileId),
	}
	return outerDonatePageResponse, nil
}

func (donatService *ServiceDonat) UpdateDonatePage(
	ctx context.Context,
	streamerID int,
	updateModel model.UpdateDonatPage,
	background multipart.FileHeader,
	headImg multipart.FileHeader,
) error {
	var backgroundFileID *string
	var headImgFileID *string

	if background.Size > 0 {
		fileID, err := donatService.fileService.AddNewFile(
			ctx,
			background,
			streamerID,
			"donat_page",
		)
		if err != nil {
			slog.Error(err.Error())
			return err
		}
		backgroundFileID = &fileID
	}

	if headImg.Size > 0 {
		fileID, err := donatService.fileService.AddNewFile(
			ctx,
			headImg,
			streamerID,
			"donat_page",
		)
		if err != nil {
			slog.Error(err.Error())
			return err
		}
		headImgFileID = &fileID
	}

	err := donatService.donatRepo.UpdateDonatePage(
		ctx,
		streamerID,
		backgroundFileID,
		headImgFileID,
		updateModel.Description,
		updateModel.TextAfterDonat,
	)
	if err != nil {
		slog.Error(err.Error())
		return err
	}
	return nil
}

func (donatService *ServiceDonat) GetVoiceSettings(
	ctx context.Context,
	streamerID int,
) (model.VoiceSettingsResponse, error) {
	voiceSettings, err := donatService.donatRepo.GetVoiceSettingsByStreamerID(ctx, streamerID)
	if err != nil {
		slog.Error("Failed to get voice settings", "error", err)
		return model.VoiceSettingsResponse{}, err
	}

	languages, err := donatService.donatRepo.GetLanguagesByStreamerID(ctx, streamerID)
	if err != nil {
		slog.Error("Failed to get languages", "error", err)
		return model.VoiceSettingsResponse{}, err
	}

	// Расширяем структуру VoiceSettingsResponse
	response := model.VoiceSettingsResponse{
		VoiceSpeed:        voiceSettings.VoiceSpeed,
		Scenery:           voiceSettings.Scenery,
		VoiceSoundPercent: voiceSettings.VoiceSoundPercent,
		MinPrice:          voiceSettings.MinPrice,
		Languages:         languages,
	}

	return response, nil
}

func (donatService *ServiceDonat) UpdateVoiceSettings(
	ctx context.Context,
	streamerID int,
	updateModel model.UpdateVoiceSettings,
) error {
	// Получаем voice_setting_id для streamerID
	voiceSettingID, err := donatService.donatRepo.GetVoiceSettingIDByStreamerID(ctx, streamerID)
	if err != nil {
		slog.Error("Failed to get voice setting ID", "error", err)
		return err
	}

	// Удаляем старые языки
	err = donatService.donatRepo.DeleteLanguagesByVoiceSettingID(ctx, voiceSettingID)
	if err != nil {
		slog.Error("Failed to delete old languages", "error", err)
		return err
	}

	// Получаем ID всех языков по их ISO-кодам
	languageIDs, err := donatService.donatRepo.GetLanguageIDsByISOCodes(ctx, updateModel.Languages)
	if err != nil {
		slog.Error("Failed to get language IDs by ISO codes", "error", err)
		return err
	}

	// Добавляем новые языки (пакетная вставка)
	err = donatService.donatRepo.InsertLanguagesForVoiceSetting(ctx, voiceSettingID, languageIDs)
	if err != nil {
		slog.Error("Failed to insert new languages", "error", err)
		return err
	}

	err = donatService.donatRepo.UpdateVoiceSettings(ctx, streamerID, updateModel)
	if err != nil {
		slog.Error("Failed to update voice settings", "error", err)
		return err
	}

	return nil
}

func (donatService *ServiceDonat) GetFiltersSettings(
	ctx context.Context,
	streamerID int,
) (model.FilterSettingResponse, error) {
	filterSettingID, enableLinks, err := donatService.donatRepo.GetFilterSettingsByStreamerID(ctx, streamerID)
	if err != nil {
		slog.Error("Failed to get filter settings", "error", err)
		return model.FilterSettingResponse{}, err
	}

	filteredWords, err := donatService.donatRepo.GetFilteredWords(ctx, filterSettingID)
	if err != nil {
		slog.Error("Failed to get filtered words", "error", err)
		return model.FilterSettingResponse{}, err
	}
	if filteredWords == nil {
		filteredWords = []string{}
	}
	response := model.FilterSettingResponse{
		EnableLinks:   enableLinks,
		FilteredWords: filteredWords,
	}

	return response, nil
}

func (donatService *ServiceDonat) UpdateFiltersSettings(
	ctx context.Context,
	streamerID int,
	updateModel model.UpdateFilterSettings,
) error {
	filterID, err := donatService.donatRepo.GetFilterIDByStreamer(ctx, streamerID)
	if err != nil {
		slog.Error("Failed to get filter ID", "error", err)
		return err
	}

	if updateModel.EnableLinks != nil {
		err = donatService.donatRepo.UpdateFilterSettings(ctx, streamerID, updateModel.EnableLinks)
		if err != nil {
			slog.Error("Failed to update filter settings", "error", err)
			return err
		}
	}

	if len(updateModel.AddWords) > 0 {
		err = donatService.donatRepo.AddFilteredWords(ctx, filterID, updateModel.AddWords)
		if err != nil {
			slog.Error("Failed to add filtered words", "error", err)
			return err
		}
	}

	if len(updateModel.RemoveWords) > 0 {
		err = donatService.donatRepo.RemoveFilteredWords(ctx, streamerID, updateModel.RemoveWords)
		if err != nil {
			slog.Error("Failed to remove filtered words", "error", err)
			return err
		}
	}

	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
}