customer/internal/interface/controller/rest/history/history.go

package history

import (
	"bytes"
	"context"
	"encoding/json"
	"fmt"
	"log"
	"net/http"

	"github.com/labstack/echo/v4"
	"go.uber.org/zap"
	"penahub.gitlab.yandexcloud.net/pena-services/customer/internal/dto"
	"penahub.gitlab.yandexcloud.net/pena-services/customer/internal/errors"
	"penahub.gitlab.yandexcloud.net/pena-services/customer/internal/interface/swagger"
	"penahub.gitlab.yandexcloud.net/pena-services/customer/internal/models"
)

type historyService interface {
	GetHistoryList(context.Context, *dto.GetHistories) (*models.PaginationResponse[models.History], errors.Error)
	GetRecentTariffs(context.Context, string) ([]models.TariffID, errors.Error)   // new
	GetHistoryById(context.Context, string) (*models.ReportHistory, errors.Error) // new
}

type Deps struct {
	Logger         *zap.Logger
	HistoryService historyService
}

type Controller struct {
	logger         *zap.Logger
	historyService historyService
}

func New(deps Deps) *Controller {
	if deps.Logger == nil {
		log.Panicln("logger is nil on <New (history controller)>")
	}

	if deps.HistoryService == nil {
		log.Panicln("HistoryService is nil on <New (history controller)>")
	}

	return &Controller{
		logger:         deps.Logger,
		historyService: deps.HistoryService,
	}
}

func (receiver *Controller) GetHistoryList(ctx echo.Context, params swagger.GetHistoryParams) error {
	userID, ok := ctx.Get(models.AuthJWTDecodedUserIDKey).(string)
	if !ok {
		receiver.logger.Error("failed to convert jwt payload to string on <GetAccount> of <AccountController>")

		return errors.HTTP(ctx, errors.New(
			fmt.Errorf("failed to convert jwt payload to string: %s", userID),
			errors.ErrInvalidArgs,
		))
	}

	histories, err := receiver.historyService.GetHistoryList(ctx.Request().Context(), &dto.GetHistories{
		Type:   params.Type,
		UserID: userID,
		Pagination: &models.Pagination{
			Page:  int64(*params.Page),
			Limit: int64(*params.Limit),
		},
	})
	if err != nil {
		receiver.logger.Error("failed to get histories on <GetHistoryList> of <HistoryController>", zap.Error(err))
		return errors.HTTP(ctx, err)
	}

	return ctx.JSON(http.StatusOK, histories)
}

// TODO:tests.
func (receiver *Controller) GetRecentTariffs(ctx echo.Context) error {
	userID, ok := ctx.Get(models.AuthJWTDecodedUserIDKey).(string)
	if !ok {
		receiver.logger.Error("failed to convert jwt payload to string on <GetRecentTariffs> of <HistoryController>")
		return errors.HTTP(ctx, errors.New(
			fmt.Errorf("failed to convert jwt payload to string: %s", userID),
			errors.ErrInvalidArgs,
		))
	}

	tariffs, err := receiver.historyService.GetRecentTariffs(ctx.Request().Context(), userID)
	if err != nil {
		receiver.logger.Error("failed to get recent tariffs on <GetRecentTariffs> of <HistoryController>",
			zap.String("userId", userID),
			zap.Error(err),
		)
		return errors.HTTP(ctx, err)
	}

	return ctx.JSON(http.StatusOK, tariffs)
}

// TODO:tests.
// скорее всего нужно будет передавать токен авторизации но пока не точно, также брать урлы из переменных окружения или конфига
// также сделать рефакторинг, пока выглядит не очень
func (receiver *Controller) GetHistoryById(ctx echo.Context) error {
	historyID := ctx.Param("id")

	// Получаем запись из истории по идентификатору
	historyRecord, err := receiver.historyService.GetHistoryById(ctx.Request().Context(), historyID)
	if err != nil {
		receiver.logger.Error("failed to get history record on <GetHistoryById> of <HistoryController>", zap.Error(err))
		return errors.HTTP(ctx, err)
	}

	// Проверяем, что запись имеет ключ "payCart"
	if historyRecord.Key != models.CustomerHistoryKeyPayCart {
		err := errors.NewWithMessage("invalid history record key", errors.ErrInvalidArgs)
		receiver.logger.Error("invalid history record key", zap.Error(err))
		return errors.HTTP(ctx, err)
	}

	// Получаем данные о верификации
	client := &http.Client{}
	url := fmt.Sprintf("http://example/verification/%s", historyRecord.UserID)

	response, _ := client.Get(url)
	defer response.Body.Close()

	var verificationResponse models.Verification
	decoder := json.NewDecoder(response.Body)
	if err := decoder.Decode(&verificationResponse); err != nil {
		err := errors.NewWithMessage(err.Error(), errors.ErrInternalError)
		receiver.logger.Error("failed to decode verification response", zap.Error(err))
		return errors.HTTP(ctx, err)
	}

	if !verificationResponse.Accepted {
		err := errors.NewWithMessage("Verification not accepted", errors.ErrNoAccess)
		receiver.logger.Error("verification not accepted", zap.Error(err))
		return errors.HTTP(ctx, err)
	}

	// Получаем email
	url = fmt.Sprintf("http://example/user/%s", historyRecord.UserID)

	response, _ = client.Get(url)
	var userResponse models.User
	decoder = json.NewDecoder(response.Body)
	if err := decoder.Decode(&userResponse); err != nil {
		err := errors.NewWithMessage(err.Error(), errors.ErrInternalError)
		receiver.logger.Error("failed to decode verification response", zap.Error(err))
		return errors.HTTP(ctx, err)
	}

	// Получаем данные для передачи в templategen, возможно придется менять
	generatorRequest := models.GeneratorRequest{
		Email:      userResponse.Email,
		TaxNumber:  verificationResponse.TaxNumber,
		RawDetails: historyRecord.RawDetails,
	}

	// Маршалируем данные в JSON
	requestBody, _ := json.Marshal(generatorRequest)
	if err != nil {
		return errors.HTTP(ctx, err)
	}
	generatorURL := "http://example/generator/service"
	response, _ = client.Post(generatorURL, "application/json", bytes.NewBuffer(requestBody))
	if err != nil {
		return errors.HTTP(ctx, err)
	}

	return nil
}