Yimaru-BackEnd/internal/repository/transfer.go

package repository

import (
	"context"

	dbgen "github.com/SamuelTariku/FortuneBet-Backend/gen/db"
	"github.com/SamuelTariku/FortuneBet-Backend/internal/domain"
	"github.com/jackc/pgx/v5/pgtype"
)

func convertDBTransferDetail(transfer dbgen.WalletTransferDetail) domain.TransferDetail {
	return domain.TransferDetail{
		ID:       transfer.ID,
		Amount:   domain.Currency(transfer.Amount.Int64),
		Type:     domain.TransferType(transfer.Type.String),
		Verified: transfer.Verified.Bool,
		Message:  transfer.Message,
		ReceiverWalletID: domain.ValidInt64{
			Value: transfer.ReceiverWalletID.Int64,
			Valid: transfer.ReceiverWalletID.Valid,
		},
		SenderWalletID: domain.ValidInt64{
			Value: transfer.SenderWalletID.Int64,
			Valid: transfer.SenderWalletID.Valid,
		},
		DepositorID: domain.ValidInt64{
			Value: transfer.CashierID.Int64,
			Valid: transfer.CashierID.Valid,
		},
		DepositorFirstName:   transfer.FirstName.String,
		DepositorLastName:    transfer.LastName.String,
		DepositorPhoneNumber: transfer.PhoneNumber.String,
		PaymentMethod:        domain.PaymentMethod(transfer.PaymentMethod.String),
		ReferenceNumber:      transfer.ReferenceNumber,
		SessionID:            transfer.SessionID.String,
		Status:               transfer.Status.String,
		CreatedAt:            transfer.CreatedAt.Time,
		UpdatedAt:            transfer.UpdatedAt.Time,
	}
}
func convertDBTransfer(transfer dbgen.WalletTransfer) domain.Transfer {
	return domain.Transfer{
		ID:       transfer.ID,
		Amount:   domain.Currency(transfer.Amount.Int64),
		Type:     domain.TransferType(transfer.Type.String),
		Verified: transfer.Verified.Bool,
		Message:  transfer.Message,
		ReceiverWalletID: domain.ValidInt64{
			Value: transfer.ReceiverWalletID.Int64,
			Valid: transfer.ReceiverWalletID.Valid,
		},
		SenderWalletID: domain.ValidInt64{
			Value: transfer.SenderWalletID.Int64,
			Valid: transfer.SenderWalletID.Valid,
		},
		DepositorID: domain.ValidInt64{
			Value: transfer.CashierID.Int64,
			Valid: transfer.CashierID.Valid,
		},
		PaymentMethod:   domain.PaymentMethod(transfer.PaymentMethod.String),
		ReferenceNumber: transfer.ReferenceNumber,
		SessionID:       transfer.SessionID.String,
		Status:          transfer.Status.String,
		CreatedAt:       transfer.CreatedAt.Time,
		UpdatedAt:       transfer.UpdatedAt.Time,
	}
}

func convertCreateTransfer(transfer domain.CreateTransfer) dbgen.CreateTransferParams {
	return dbgen.CreateTransferParams{
		Message: transfer.Message,
		Amount:  pgtype.Int8{Int64: int64(transfer.Amount), Valid: true},
		Type:    pgtype.Text{String: string(transfer.Type), Valid: true},
		ReceiverWalletID: pgtype.Int8{
			Int64: transfer.ReceiverWalletID.Value,
			Valid: transfer.ReceiverWalletID.Valid,
		},
		SenderWalletID: pgtype.Int8{
			Int64: transfer.SenderWalletID.Value,
			Valid: transfer.SenderWalletID.Valid,
		},
		CashierID: pgtype.Int8{
			Int64: transfer.CashierID.Value,
			Valid: transfer.CashierID.Valid,
		},
		ReferenceNumber: string(transfer.ReferenceNumber),
		SessionID: pgtype.Text{
			String: transfer.SessionID,
			Valid:  true,
		},

		PaymentMethod: pgtype.Text{String: string(transfer.PaymentMethod), Valid: true},
		Verified: pgtype.Bool{
			Bool:  transfer.Verified,
			Valid: true,
		},
	}
}

func (s *Store) CreateTransfer(ctx context.Context, transfer domain.CreateTransfer) (domain.Transfer, error) {
	newTransfer, err := s.queries.CreateTransfer(ctx, convertCreateTransfer(transfer))
	if err != nil {
		return domain.Transfer{}, err
	}
	return convertDBTransfer(newTransfer), nil
}

func (s *Store) GetAllTransfers(ctx context.Context) ([]domain.TransferDetail, error) {
	transfers, err := s.queries.GetAllTransfers(ctx)
	if err != nil {
		return nil, err
	}
	var result []domain.TransferDetail = make([]domain.TransferDetail, 0, len(transfers))

	for _, transfer := range transfers {
		result = append(result, convertDBTransferDetail(transfer))
	}
	return result, nil
}

func (s *Store) GetTransfersByWallet(ctx context.Context, walletID int64) ([]domain.TransferDetail, error) {
	transfers, err := s.queries.GetTransfersByWallet(ctx, pgtype.Int8{Int64: walletID, Valid: true})
	if err != nil {
		return nil, err
	}

	var result []domain.TransferDetail = make([]domain.TransferDetail, 0, len(transfers))

	for _, transfer := range transfers {
		result = append(result, convertDBTransferDetail(transfer))
	}
	return result, nil
}

func (s *Store) GetTransferByReference(ctx context.Context, reference string) (domain.TransferDetail, error) {
	transfer, err := s.queries.GetTransferByReference(ctx, reference)
	if err != nil {
		return domain.TransferDetail{}, nil
	}
	return convertDBTransferDetail(transfer), nil
}

func (s *Store) GetTransferByID(ctx context.Context, id int64) (domain.TransferDetail, error) {
	transfer, err := s.queries.GetTransferByID(ctx, id)
	if err != nil {
		return domain.TransferDetail{}, nil
	}
	return convertDBTransferDetail(transfer), nil
}

func (s *Store) UpdateTransferVerification(ctx context.Context, id int64, verified bool) error {
	err := s.queries.UpdateTransferVerification(ctx, dbgen.UpdateTransferVerificationParams{
		ID:       id,
		Verified: pgtype.Bool{Bool: verified, Valid: true},
	})

	return err
}

func (s *Store) UpdateTransferStatus(ctx context.Context, id int64, status string) error {
	err := s.queries.UpdateTransferStatus(ctx, dbgen.UpdateTransferStatusParams{
		ID:     id,
		Status: pgtype.Text{String: status, Valid: true},
	})

	return err
}

func ApproveTransfer(ctx context.Context, approval domain.ApprovalRequest) error {
	return nil
}