sendico/api/gateway/mntx/internal/service/gateway/card_payout_handlers.go

package gateway

import (
	"context"
	"strings"

	"github.com/tech/sendico/gateway/mntx/internal/service/monetix"
	"github.com/tech/sendico/pkg/api/routers/gsresponse"
	"github.com/tech/sendico/pkg/merrors"
	"github.com/tech/sendico/pkg/mservice"
	mntxv1 "github.com/tech/sendico/pkg/proto/gateway/mntx/v1"
	"google.golang.org/protobuf/proto"
)

func (s *Service) CreateCardPayout(ctx context.Context, req *mntxv1.CardPayoutRequest) (*mntxv1.CardPayoutResponse, error) {
	return executeUnary(ctx, s, "CreateCardPayout", s.handleCreateCardPayout, req)
}

func (s *Service) handleCreateCardPayout(ctx context.Context, req *mntxv1.CardPayoutRequest) gsresponse.Responder[mntxv1.CardPayoutResponse] {
	if s.card == nil {
		return gsresponse.Internal[mntxv1.CardPayoutResponse](s.logger, mservice.MntxGateway, merrors.Internal("card payout processor not initialised"))
	}

	resp, err := s.card.Submit(ctx, req)
	if err != nil {
		return gsresponse.Auto[mntxv1.CardPayoutResponse](s.logger, mservice.MntxGateway, err)
	}
	return gsresponse.Success(resp)
}

func (s *Service) CreateCardTokenPayout(ctx context.Context, req *mntxv1.CardTokenPayoutRequest) (*mntxv1.CardTokenPayoutResponse, error) {
	return executeUnary(ctx, s, "CreateCardTokenPayout", s.handleCreateCardTokenPayout, req)
}

func (s *Service) handleCreateCardTokenPayout(ctx context.Context, req *mntxv1.CardTokenPayoutRequest) gsresponse.Responder[mntxv1.CardTokenPayoutResponse] {
	if s.card == nil {
		return gsresponse.Internal[mntxv1.CardTokenPayoutResponse](s.logger, mservice.MntxGateway, merrors.Internal("card payout processor not initialised"))
	}

	resp, err := s.card.SubmitToken(ctx, req)
	if err != nil {
		return gsresponse.Auto[mntxv1.CardTokenPayoutResponse](s.logger, mservice.MntxGateway, err)
	}
	return gsresponse.Success(resp)
}

func (s *Service) CreateCardToken(ctx context.Context, req *mntxv1.CardTokenizeRequest) (*mntxv1.CardTokenizeResponse, error) {
	return executeUnary(ctx, s, "CreateCardToken", s.handleCreateCardToken, req)
}

func (s *Service) handleCreateCardToken(ctx context.Context, req *mntxv1.CardTokenizeRequest) gsresponse.Responder[mntxv1.CardTokenizeResponse] {
	if s.card == nil {
		return gsresponse.Internal[mntxv1.CardTokenizeResponse](s.logger, mservice.MntxGateway, merrors.Internal("card payout processor not initialised"))
	}

	resp, err := s.card.Tokenize(ctx, req)
	if err != nil {
		return gsresponse.Auto[mntxv1.CardTokenizeResponse](s.logger, mservice.MntxGateway, err)
	}
	return gsresponse.Success(resp)
}

func (s *Service) GetCardPayoutStatus(ctx context.Context, req *mntxv1.GetCardPayoutStatusRequest) (*mntxv1.GetCardPayoutStatusResponse, error) {
	return executeUnary(ctx, s, "GetCardPayoutStatus", s.handleGetCardPayoutStatus, req)
}

func (s *Service) handleGetCardPayoutStatus(_ context.Context, req *mntxv1.GetCardPayoutStatusRequest) gsresponse.Responder[mntxv1.GetCardPayoutStatusResponse] {
	if s.card == nil {
		return gsresponse.Internal[mntxv1.GetCardPayoutStatusResponse](s.logger, mservice.MntxGateway, merrors.Internal("card payout processor not initialised"))
	}

	state, err := s.card.Status(context.Background(), req.GetPayoutId())
	if err != nil {
		return gsresponse.Auto[mntxv1.GetCardPayoutStatusResponse](s.logger, mservice.MntxGateway, err)
	}
	return gsresponse.Success(&mntxv1.GetCardPayoutStatusResponse{Payout: state})
}

func sanitizeCardPayoutRequest(req *mntxv1.CardPayoutRequest) *mntxv1.CardPayoutRequest {
	if req == nil {
		return nil
	}
	clean := proto.Clone(req)
	r, ok := clean.(*mntxv1.CardPayoutRequest)
	if !ok {
		return req
	}
	r.PayoutId = strings.TrimSpace(r.GetPayoutId())
	r.CustomerId = strings.TrimSpace(r.GetCustomerId())
	r.CustomerFirstName = strings.TrimSpace(r.GetCustomerFirstName())
	r.CustomerMiddleName = strings.TrimSpace(r.GetCustomerMiddleName())
	r.CustomerLastName = strings.TrimSpace(r.GetCustomerLastName())
	r.CustomerIp = strings.TrimSpace(r.GetCustomerIp())
	r.CustomerZip = strings.TrimSpace(r.GetCustomerZip())
	r.CustomerCountry = strings.TrimSpace(r.GetCustomerCountry())
	r.CustomerState = strings.TrimSpace(r.GetCustomerState())
	r.CustomerCity = strings.TrimSpace(r.GetCustomerCity())
	r.CustomerAddress = strings.TrimSpace(r.GetCustomerAddress())
	r.Currency = strings.ToUpper(strings.TrimSpace(r.GetCurrency()))
	r.CardPan = strings.TrimSpace(r.GetCardPan())
	r.CardHolder = strings.TrimSpace(r.GetCardHolder())
	return r
}

func sanitizeCardTokenPayoutRequest(req *mntxv1.CardTokenPayoutRequest) *mntxv1.CardTokenPayoutRequest {
	if req == nil {
		return nil
	}
	clean := proto.Clone(req)
	r, ok := clean.(*mntxv1.CardTokenPayoutRequest)
	if !ok {
		return req
	}
	r.PayoutId = strings.TrimSpace(r.GetPayoutId())
	r.CustomerId = strings.TrimSpace(r.GetCustomerId())
	r.CustomerFirstName = strings.TrimSpace(r.GetCustomerFirstName())
	r.CustomerMiddleName = strings.TrimSpace(r.GetCustomerMiddleName())
	r.CustomerLastName = strings.TrimSpace(r.GetCustomerLastName())
	r.CustomerIp = strings.TrimSpace(r.GetCustomerIp())
	r.CustomerZip = strings.TrimSpace(r.GetCustomerZip())
	r.CustomerCountry = strings.TrimSpace(r.GetCustomerCountry())
	r.CustomerState = strings.TrimSpace(r.GetCustomerState())
	r.CustomerCity = strings.TrimSpace(r.GetCustomerCity())
	r.CustomerAddress = strings.TrimSpace(r.GetCustomerAddress())
	r.Currency = strings.ToUpper(strings.TrimSpace(r.GetCurrency()))
	r.CardToken = strings.TrimSpace(r.GetCardToken())
	r.CardHolder = strings.TrimSpace(r.GetCardHolder())
	r.MaskedPan = strings.TrimSpace(r.GetMaskedPan())
	return r
}

func sanitizeCardTokenizeRequest(req *mntxv1.CardTokenizeRequest) *mntxv1.CardTokenizeRequest {
	if req == nil {
		return nil
	}
	clean := proto.Clone(req)
	r, ok := clean.(*mntxv1.CardTokenizeRequest)
	if !ok {
		return req
	}
	r.RequestId = strings.TrimSpace(r.GetRequestId())
	r.CustomerId = strings.TrimSpace(r.GetCustomerId())
	r.CustomerFirstName = strings.TrimSpace(r.GetCustomerFirstName())
	r.CustomerMiddleName = strings.TrimSpace(r.GetCustomerMiddleName())
	r.CustomerLastName = strings.TrimSpace(r.GetCustomerLastName())
	r.CustomerIp = strings.TrimSpace(r.GetCustomerIp())
	r.CustomerZip = strings.TrimSpace(r.GetCustomerZip())
	r.CustomerCountry = strings.TrimSpace(r.GetCustomerCountry())
	r.CustomerState = strings.TrimSpace(r.GetCustomerState())
	r.CustomerCity = strings.TrimSpace(r.GetCustomerCity())
	r.CustomerAddress = strings.TrimSpace(r.GetCustomerAddress())
	r.CardPan = strings.TrimSpace(r.GetCardPan())
	r.CardHolder = strings.TrimSpace(r.GetCardHolder())
	r.CardCvv = strings.TrimSpace(r.GetCardCvv())
	if card := r.GetCard(); card != nil {
		card.Pan = strings.TrimSpace(card.GetPan())
		card.CardHolder = strings.TrimSpace(card.GetCardHolder())
		card.Cvv = strings.TrimSpace(card.GetCvv())
		r.Card = card
	}
	return r
}

func buildCardPayoutRequest(projectID int64, req *mntxv1.CardPayoutRequest) monetix.CardPayoutRequest {
	card := monetix.Card{
		PAN:        req.GetCardPan(),
		Year:       int(req.GetCardExpYear()),
		Month:      int(req.GetCardExpMonth()),
		CardHolder: req.GetCardHolder(),
	}

	return monetix.CardPayoutRequest{
		General: monetix.General{
			ProjectID: projectID,
			PaymentID: req.GetPayoutId(),
		},
		Customer: monetix.Customer{
			ID:        req.GetCustomerId(),
			FirstName: req.GetCustomerFirstName(),
			Middle:    req.GetCustomerMiddleName(),
			LastName:  req.GetCustomerLastName(),
			IP:        req.GetCustomerIp(),
			Zip:       req.GetCustomerZip(),
			Country:   req.GetCustomerCountry(),
			State:     req.GetCustomerState(),
			City:      req.GetCustomerCity(),
			Address:   req.GetCustomerAddress(),
		},
		Payment: monetix.Payment{
			Amount:   req.GetAmountMinor(),
			Currency: strings.ToUpper(strings.TrimSpace(req.GetCurrency())),
		},
		Card: card,
	}
}

func buildCardTokenPayoutRequest(projectID int64, req *mntxv1.CardTokenPayoutRequest) monetix.CardTokenPayoutRequest {
	return monetix.CardTokenPayoutRequest{
		General: monetix.General{
			ProjectID: projectID,
			PaymentID: req.GetPayoutId(),
		},
		Customer: monetix.Customer{
			ID:        req.GetCustomerId(),
			FirstName: req.GetCustomerFirstName(),
			Middle:    req.GetCustomerMiddleName(),
			LastName:  req.GetCustomerLastName(),
			IP:        req.GetCustomerIp(),
			Zip:       req.GetCustomerZip(),
			Country:   req.GetCustomerCountry(),
			State:     req.GetCustomerState(),
			City:      req.GetCustomerCity(),
			Address:   req.GetCustomerAddress(),
		},
		Payment: monetix.Payment{
			Amount:   req.GetAmountMinor(),
			Currency: strings.ToUpper(strings.TrimSpace(req.GetCurrency())),
		},
		Token: monetix.Token{
			CardToken:  req.GetCardToken(),
			CardHolder: req.GetCardHolder(),
			MaskedPAN:  req.GetMaskedPan(),
		},
	}
}

func buildCardTokenizeRequest(projectID int64, req *mntxv1.CardTokenizeRequest, card *tokenizeCardInput) monetix.CardTokenizeRequest {
	tokenizeCard := monetix.CardTokenize{
		PAN:        card.pan,
		Year:       int(card.year),
		Month:      int(card.month),
		CardHolder: card.holder,
		CVV:        card.cvv,
	}

	return monetix.CardTokenizeRequest{
		General: monetix.General{
			ProjectID: projectID,
			PaymentID: req.GetRequestId(),
		},
		Customer: monetix.Customer{
			ID:        req.GetCustomerId(),
			FirstName: req.GetCustomerFirstName(),
			Middle:    req.GetCustomerMiddleName(),
			LastName:  req.GetCustomerLastName(),
			IP:        req.GetCustomerIp(),
			Zip:       req.GetCustomerZip(),
			Country:   req.GetCustomerCountry(),
			State:     req.GetCustomerState(),
			City:      req.GetCustomerCity(),
			Address:   req.GetCustomerAddress(),
		},
		Card: tokenizeCard,
	}
}