Yimaru-BackEnd/internal/repository/transaction.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 convertDBTransaction(transaction dbgen.Transaction) domain.Transaction {
	return domain.Transaction{
		ID:               transaction.ID,
		Amount:           domain.Currency(transaction.Amount),
		BranchID:         transaction.BranchID,
		CashierID:        transaction.CashierID,
		BetID:            transaction.BetID,
		NumberOfOutcomes: transaction.NumberOfOutcomes,
		Type:             domain.TransactionType(transaction.Type),
		PaymentOption:    domain.PaymentOption(transaction.PaymentOption),
		FullName:         transaction.FullName,
		PhoneNumber:      transaction.PhoneNumber,
		BankCode:         transaction.BankCode,
		BeneficiaryName:  transaction.BeneficiaryName,
		AccountName:      transaction.AccountName,
		AccountNumber:    transaction.AccountNumber,
		ReferenceNumber:  transaction.ReferenceNumber,
		ApprovedBy: domain.ValidInt64{
			Value: transaction.ApprovedBy.Int64,
			Valid: transaction.ApprovedBy.Valid,
		},
		CreatedAt:      transaction.CreatedAt.Time,
		UpdatedAt:      transaction.UpdatedAt.Time,
		Verified:       transaction.Verified,
		BranchName:     transaction.BranchName,
		BranchLocation: transaction.BranchLocation,
		CashierName:    transaction.CashierName,
		CompanyID:      transaction.CompanyID,
		ApproverName: domain.ValidString{
			Value: transaction.ApproverName.String,
			Valid: transaction.ApprovedBy.Valid,
		},
	}
}

func convertCreateTransaction(transaction domain.CreateTransaction) dbgen.CreateTransactionParams {
	return dbgen.CreateTransactionParams{
		Amount:           int64(transaction.Amount),
		BranchID:         transaction.BranchID,
		CashierID:        transaction.CashierID,
		BetID:            transaction.BetID,
		Type:             int64(transaction.Type),
		PaymentOption:    int64(transaction.PaymentOption),
		FullName:         transaction.FullName,
		PhoneNumber:      transaction.PhoneNumber,
		BankCode:         transaction.BankCode,
		BeneficiaryName:  transaction.BeneficiaryName,
		AccountName:      transaction.AccountName,
		AccountNumber:    transaction.AccountNumber,
		ReferenceNumber:  transaction.ReferenceNumber,
		NumberOfOutcomes: transaction.NumberOfOutcomes,
		BranchName:       transaction.BranchName,
		BranchLocation:   transaction.BranchLocation,
		CashierName:      transaction.CashierName,
		CompanyID:        transaction.CompanyID,
	}
}

func (s *Store) CreateTransaction(ctx context.Context, transaction domain.CreateTransaction) (domain.Transaction, error) {

	newTransaction, err := s.queries.CreateTransaction(ctx, convertCreateTransaction(transaction))
	if err != nil {
		return domain.Transaction{}, err
	}
	return convertDBTransaction(newTransaction), err
}

func (s *Store) GetTransactionByID(ctx context.Context, id int64) (domain.Transaction, error) {
	transaction, err := s.queries.GetTransactionByID(ctx, id)
	if err != nil {
		return domain.Transaction{}, err
	}

	return convertDBTransaction(transaction), nil
}

func (s *Store) GetAllTransactions(ctx context.Context, filter domain.TransactionFilter) ([]domain.Transaction, error) {
	transaction, err := s.queries.GetAllTransactions(ctx, dbgen.GetAllTransactionsParams{
		BranchID: pgtype.Int8{
			Int64: filter.BranchID.Value,
			Valid: filter.BranchID.Valid,
		},
		CompanyID: pgtype.Int8{
			Int64: filter.CompanyID.Value,
			Valid: filter.CompanyID.Valid,
		},
		CashierID: pgtype.Int8{
			Int64: filter.CashierID.Value,
			Valid: filter.CashierID.Valid,
		},
	})

	if err != nil {
		return nil, err
	}

	var result []domain.Transaction = make([]domain.Transaction, 0, len(transaction))
	for _, ticket := range transaction {
		result = append(result, convertDBTransaction(ticket))
	}
	return result, nil
}
func (s *Store) GetTransactionByBranch(ctx context.Context, id int64) ([]domain.Transaction, error) {
	transaction, err := s.queries.GetTransactionByBranch(ctx, id)

	if err != nil {
		return nil, err
	}

	var result []domain.Transaction = make([]domain.Transaction, 0, len(transaction))
	for _, ticket := range transaction {
		result = append(result, convertDBTransaction(ticket))
	}
	return result, nil
}

func (s *Store) UpdateTransactionVerified(ctx context.Context, id int64, verified bool, approvedBy int64, approverName string) error {
	err := s.queries.UpdateTransactionVerified(ctx, dbgen.UpdateTransactionVerifiedParams{
		ID: id,
		ApprovedBy: pgtype.Int8{
			Int64: approvedBy,
			Valid: true,
		},
		Verified: verified,
		ApproverName: pgtype.Text{
			String: approverName,
			Valid:  true,
		},
	})
	return err
}