internal/server/server.go - master - IvanVerse/transaction

internal/server/server.go
97 строк3 KB
ivan
first commit
01 июл 2026, 15:33
01 июл 2026, 15:333185905
package server

import (
	"context"

	"gitverse.ru/IvanVerse/transaction/internal/mapper"
	"gitverse.ru/IvanVerse/transaction/internal/model"

	transactionpb "gitverse.ru/IvanVerse/contracts/transaction/go"

	"github.com/rs/zerolog"
	"google.golang.org/protobuf/types/known/emptypb"
)

type Server struct {
	transactionpb.UnimplementedTransactionServiceServer

	transactionService TransactionService
	logger             *zerolog.Logger
}

func New(transactionService TransactionService, logger *zerolog.Logger) *Server {
	return &Server{transactionService: transactionService, logger: logger}
}

type TransactionService interface {
	GetTransactionsWithDetails(ctx context.Context, params model.GetTransactionsParams) ([]model.TransactionDetails, error)
	Deposit(ctx context.Context, accountID uint64, amount float64) (model.TransactionDetails, error)
	Withdraw(ctx context.Context, accountID uint64, amount float64) (model.TransactionDetails, error)
	Transfer(ctx context.Context, fromAccountID, toAccountID uint64, amount float64) (model.TransactionDetails, error)
}

func (s *Server) GetTransactions(ctx context.Context, req *transactionpb.GetTransactionsRequest) (*transactionpb.GetTransactionsResponse, error) {
	// Конвертируем protobuf запрос в параметры фильтрации
	params := mapper.TransactionsRequestToParams(req)

	s.logger.Info().
		Interface("params", params).
		Msg("processing get transactions request")

	// Вызываем сервис для получения транзакций с деталями
	transactionDetails, err := s.transactionService.GetTransactionsWithDetails(ctx, params)
	if err != nil {
		s.logger.Error().Err(err).Msg("failed to get transactions")
		return nil, err
	}

	// Конвертируем в protobuf
	pbTransactionDetails := mapper.TransactionDetailsToPbs(transactionDetails)

	s.logger.Info().
		Int("count", len(pbTransactionDetails)).
		Msg("successfully retrieved transactions")

	return &transactionpb.GetTransactionsResponse{
		Transactions: pbTransactionDetails,
	}, nil
}

func (s *Server) Deposit(ctx context.Context, req *transactionpb.DepositRequest) (*emptypb.Empty, error) {
	s.logger.Info().
		Msg("processing deposit request")

	_, err := s.transactionService.Deposit(ctx, req.UserId, float64(req.Amount))
	if err != nil {
		s.logger.Error().Err(err).Msg("failed to process deposit")
		return nil, err
	}

	return &emptypb.Empty{}, nil
}

func (s *Server) Withdraw(ctx context.Context, req *transactionpb.WithdrawRequest) (*emptypb.Empty, error) {
	s.logger.Info().
		Msg("processing withdraw request")

	_, err := s.transactionService.Withdraw(ctx, req.UserId, float64(req.Amount))
	if err != nil {
		s.logger.Error().Err(err).Msg("failed to process withdraw")
		return nil, err
	}

	return &emptypb.Empty{}, nil
}

func (s *Server) Transfer(ctx context.Context, req *transactionpb.TransferRequest) (*emptypb.Empty, error) {
	s.logger.Info().
		Msg("processing transfer request")

	_, err := s.transactionService.Transfer(ctx, req.UserId, req.Recipient, float64(req.Amount))
	if err != nil {
		s.logger.Error().Err(err).Msg("failed to process transfer")
		return nil, err
	}

	return &emptypb.Empty{}, nil
}