389 lines
13 KiB
Go
389 lines
13 KiB
Go
package wallet
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"fmt"
|
|
|
|
"github.com/SamuelTariku/FortuneBet-Backend/internal/domain"
|
|
)
|
|
|
|
var (
|
|
ErrSenderWalletNotTransferable = errors.New("sender wallet is not transferable")
|
|
ErrReceiverWalletNotTransferable = errors.New("receiver wallet is not transferable")
|
|
ErrInsufficientBalance = errors.New("wallet balance is insufficient")
|
|
)
|
|
|
|
func (s *Service) CreateTransfer(ctx context.Context, transfer domain.CreateTransfer) (domain.Transfer, error) {
|
|
// This is just a transfer log when
|
|
return s.transferStore.CreateTransfer(ctx, transfer)
|
|
}
|
|
|
|
func (s *Service) GetAllTransfers(ctx context.Context) ([]domain.TransferDetail, error) {
|
|
return s.transferStore.GetAllTransfers(ctx)
|
|
}
|
|
|
|
func (s *Service) GetTransferByReference(ctx context.Context, reference string) (domain.TransferDetail, error) {
|
|
return s.transferStore.GetTransferByReference(ctx, reference)
|
|
}
|
|
|
|
func (s *Service) GetTransferByID(ctx context.Context, id int64) (domain.TransferDetail, error) {
|
|
return s.transferStore.GetTransferByID(ctx, id)
|
|
}
|
|
|
|
func (s *Service) GetTransfersByWallet(ctx context.Context, walletID int64) ([]domain.TransferDetail, error) {
|
|
return s.transferStore.GetTransfersByWallet(ctx, walletID)
|
|
}
|
|
|
|
func (s *Service) GetTransferStats(ctx context.Context, walletID int64) (domain.TransferStats, error) {
|
|
return s.transferStore.GetTransferStats(ctx, walletID)
|
|
}
|
|
func (s *Service) UpdateTransferVerification(ctx context.Context, id int64, verified bool) error {
|
|
return s.transferStore.UpdateTransferVerification(ctx, id, verified)
|
|
}
|
|
|
|
func (s *Service) UpdateTransferStatus(ctx context.Context, id int64, status string) error {
|
|
return s.transferStore.UpdateTransferStatus(ctx, id, status)
|
|
}
|
|
|
|
func (s *Service) TransferToWallet(ctx context.Context, senderID int64, receiverID int64,
|
|
amount domain.Currency, paymentMethod domain.PaymentMethod,
|
|
cashierID domain.ValidInt64, message string) (domain.Transfer, error) {
|
|
|
|
senderWallet, err := s.GetWalletByID(ctx, senderID)
|
|
if err != nil {
|
|
|
|
return domain.Transfer{}, err
|
|
}
|
|
|
|
if !senderWallet.IsTransferable {
|
|
fmt.Printf("Error: %d Sender Wallet is not transferable \n", senderWallet.ID)
|
|
return domain.Transfer{}, ErrSenderWalletNotTransferable
|
|
}
|
|
|
|
receiverWallet, err := s.GetWalletByID(ctx, receiverID)
|
|
if err != nil {
|
|
return domain.Transfer{}, err
|
|
}
|
|
|
|
if !receiverWallet.IsTransferable {
|
|
fmt.Printf("Error: %d Receiver Wallet is not transferable \n", senderWallet.ID)
|
|
return domain.Transfer{}, ErrReceiverWalletNotTransferable
|
|
}
|
|
|
|
// Deduct from sender
|
|
if senderWallet.Balance < amount {
|
|
return domain.Transfer{}, ErrBalanceInsufficient
|
|
}
|
|
|
|
err = s.walletStore.UpdateBalance(ctx, senderID, senderWallet.Balance-amount)
|
|
|
|
if err != nil {
|
|
return domain.Transfer{}, err
|
|
}
|
|
|
|
// Add to receiver
|
|
err = s.walletStore.UpdateBalance(ctx, receiverID, receiverWallet.Balance+amount)
|
|
|
|
if err != nil {
|
|
return domain.Transfer{}, err
|
|
}
|
|
|
|
// Log the transfer so that if there is a mistake, it can be reverted
|
|
transfer, err := s.CreateTransfer(ctx, domain.CreateTransfer{
|
|
Message: message,
|
|
SenderWalletID: domain.ValidInt64{
|
|
Value: senderID,
|
|
Valid: true,
|
|
},
|
|
ReceiverWalletID: domain.ValidInt64{
|
|
Value: receiverID,
|
|
Valid: true,
|
|
},
|
|
CashierID: cashierID,
|
|
Amount: amount,
|
|
Type: domain.WALLET,
|
|
PaymentMethod: paymentMethod,
|
|
Verified: true,
|
|
})
|
|
if err != nil {
|
|
return domain.Transfer{}, err
|
|
}
|
|
|
|
return transfer, nil
|
|
}
|
|
|
|
func (s *Service) SendTransferNotification(ctx context.Context, senderWallet domain.Wallet, receiverWallet domain.Wallet,
|
|
senderRole domain.Role, receiverRole domain.Role, amount domain.Currency) error {
|
|
// Send notification to sender (this could be any role) that money was transferred
|
|
senderWalletReceiverSide := domain.ReceiverFromRole(senderRole)
|
|
|
|
senderNotify := &domain.Notification{
|
|
RecipientID: senderWallet.UserID,
|
|
Type: domain.NOTIFICATION_TYPE_TRANSFER_SUCCESS,
|
|
Level: domain.NotificationLevelSuccess,
|
|
Reciever: senderWalletReceiverSide,
|
|
DeliveryChannel: domain.DeliveryChannelInApp,
|
|
Payload: domain.NotificationPayload{
|
|
Headline: "Wallet has been deducted",
|
|
Message: fmt.Sprintf(`%s %d has been transferred from your wallet`, senderWallet.Currency, amount),
|
|
},
|
|
Priority: 2,
|
|
Metadata: []byte(fmt.Sprintf(`{
|
|
"transfer_amount": %d,
|
|
"current_balance": %d,
|
|
"wallet_id": %d,
|
|
"notification_type": "customer_facing"
|
|
}`, amount, senderWallet.Balance, senderWallet.ID)),
|
|
}
|
|
|
|
// Sender notifications
|
|
if err := s.notificationSvc.SendNotification(ctx, senderNotify); err != nil {
|
|
s.logger.Error("failed to send sender notification",
|
|
"user_id", "",
|
|
"error", err)
|
|
return err
|
|
}
|
|
|
|
receiverWalletReceiverSide := domain.ReceiverFromRole(receiverRole)
|
|
|
|
receiverNotify := &domain.Notification{
|
|
RecipientID: receiverWallet.UserID,
|
|
Type: domain.NOTIFICATION_TYPE_TRANSFER_SUCCESS,
|
|
Level: domain.NotificationLevelSuccess,
|
|
Reciever: receiverWalletReceiverSide,
|
|
DeliveryChannel: domain.DeliveryChannelInApp,
|
|
Payload: domain.NotificationPayload{
|
|
Headline: "Wallet has been credited",
|
|
Message: fmt.Sprintf(`%s %d has been transferred to your wallet`, receiverWallet.Currency, amount),
|
|
},
|
|
Priority: 2,
|
|
Metadata: []byte(fmt.Sprintf(`{
|
|
"transfer_amount": %d,
|
|
"current_balance": %d,
|
|
"wallet_id": %d,
|
|
"notification_type": "customer_facing"
|
|
}`, amount, receiverWallet.Balance, receiverWallet.ID)),
|
|
}
|
|
// Sender notifications
|
|
if err := s.notificationSvc.SendNotification(ctx, receiverNotify); err != nil {
|
|
s.logger.Error("failed to send sender notification",
|
|
"user_id", "",
|
|
"error", err)
|
|
return err
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func ApproveTransfer(ctx context.Context, approval domain.ApprovalRequest) error {
|
|
return nil
|
|
}
|
|
|
|
/////////////////////////////////Transaction Make-Cheker/////////////////////////////////////////////////
|
|
|
|
// func (s *Service) InitiateTransfer(ctx context.Context, transfer domain.CreateTransfer) (domain.Transfer, error) {
|
|
// // Set transfer as unverified by default
|
|
// transfer.Verified = false
|
|
|
|
// // Create the transfer record
|
|
// newTransfer, err := s.transferStore.CreateTransfer(ctx, transfer)
|
|
// if err != nil {
|
|
// return domain.Transfer{}, err
|
|
// }
|
|
|
|
// // Create approval record
|
|
// approval := domain.TransactionApproval{
|
|
// TransferID: newTransfer.ID,
|
|
// Status: "pending",
|
|
// }
|
|
|
|
// if err := s.approvalStore.CreateApproval(ctx, approval); err != nil {
|
|
// return domain.Transfer{}, err
|
|
// }
|
|
|
|
// // Notify approvers
|
|
// go s.notifyApprovers(ctx, newTransfer.ID)
|
|
|
|
// return newTransfer, nil
|
|
// }
|
|
|
|
// func (s *Service) ApproveTransfer(ctx context.Context, approval domain.ApprovalRequest) error {
|
|
// // Get the transfer
|
|
// transfer, err := s.transferStore.GetTransferByID(ctx, approval.TransferID)
|
|
// if err != nil {
|
|
// return err
|
|
// }
|
|
|
|
// // Only allow approval of pending transfers
|
|
// if transfer.Status != "pending" {
|
|
// return errors.New("only pending transfers can be approved")
|
|
// }
|
|
|
|
// // Update approval record
|
|
// if err := s.approvalStore.UpdateApprovalStatus(ctx, approval.TransferID, "approved", approval.Comments); err != nil {
|
|
// return err
|
|
// }
|
|
|
|
// // Execute the actual transfer
|
|
// if transfer.Type == domain.WALLET {
|
|
// _, err = s.executeWalletTransfer(ctx, transfer)
|
|
// return err
|
|
// }
|
|
|
|
// // For other transfer types, implement similar execution logic
|
|
|
|
// return nil
|
|
// }
|
|
|
|
// func (s *Service) executeWalletTransfer(ctx context.Context, transfer domain.TransferDetail) (domain.Transfer, error) {
|
|
// // Original transfer logic from TransferToWallet, but now guaranteed to be approved
|
|
// senderWallet, err := s.GetWalletByID(ctx, transfer.SenderWalletID.Value)
|
|
// if err != nil {
|
|
// return domain.Transfer{}, err
|
|
// }
|
|
|
|
// receiverWallet, err := s.GetWalletByID(ctx, transfer.ReceiverWalletID.Value)
|
|
// if err != nil {
|
|
// return domain.Transfer{}, err
|
|
// }
|
|
|
|
// // Deduct from sender
|
|
// if senderWallet.Balance < transfer.Amount {
|
|
// return domain.Transfer{}, ErrBalanceInsufficient
|
|
// }
|
|
|
|
// err = s.walletStore.UpdateBalance(ctx, transfer.SenderWalletID.Value, senderWallet.Balance-transfer.Amount)
|
|
// if err != nil {
|
|
// return domain.Transfer{}, err
|
|
// }
|
|
|
|
// // Add to receiver
|
|
// err = s.walletStore.UpdateBalance(ctx, transfer.ReceiverWalletID.Value, receiverWallet.Balance+transfer.Amount)
|
|
// if err != nil {
|
|
// return domain.Transfer{}, err
|
|
// }
|
|
|
|
// // Mark transfer as completed
|
|
// if err := s.transferStore.UpdateTransferStatus(ctx, transfer.ID, "completed"); err != nil {
|
|
// return domain.Transfer{}, err
|
|
// }
|
|
|
|
// // Send notifications
|
|
// go s.SendTransferNotification(ctx, senderWallet, receiverWallet,
|
|
// domain.RoleFromString(transfer.SenderWalletID.Value),
|
|
// domain.RoleFromString(transfer.ReceiverWalletID.Value),
|
|
// transfer.Amount)
|
|
|
|
// return transfer, nil
|
|
// }
|
|
|
|
// func (s *Service) RejectTransfer(ctx context.Context, approval domain.ApprovalRequest) error {
|
|
// // Update approval record
|
|
// if err := s.approvalStore.UpdateApprovalStatus(ctx, approval.TransferID, "rejected", approval.Comments); err != nil {
|
|
// return err
|
|
// }
|
|
|
|
// // Update transfer status
|
|
// if err := s.transferStore.UpdateTransferStatus(ctx, approval.TransferID, "rejected"); err != nil {
|
|
// return err
|
|
// }
|
|
|
|
// // Notify the initiator
|
|
// go s.notifyInitiator(ctx, approval.TransferID, approval.Comments)
|
|
|
|
// return nil
|
|
// }
|
|
|
|
// func (s *Service) GetPendingApprovals(ctx context.Context) ([]domain.TransferDetail, error) {
|
|
// return s.approvalStore.GetPendingApprovals(ctx)
|
|
// }
|
|
|
|
// func (s *Service) GetTransferApprovalHistory(ctx context.Context, transferID int64) ([]domain.TransactionApproval, error) {
|
|
// return s.approvalStore.GetApprovalsByTransfer(ctx, transferID)
|
|
// }
|
|
|
|
// func (s *Service) notifyApprovers(ctx context.Context, transferID int64) {
|
|
// // Get approvers (could be from a config or role-based)
|
|
// approvers, err := s.userStore.GetUsersByRole(ctx, "approver")
|
|
// if err != nil {
|
|
// s.logger.Error("failed to get approvers", zap.Error(err))
|
|
// return
|
|
// }
|
|
|
|
// transfer, err := s.transferStore.GetTransferByID(ctx, transferID)
|
|
// if err != nil {
|
|
// s.logger.Error("failed to get transfer for notification", zap.Error(err))
|
|
// return
|
|
// }
|
|
|
|
// for _, approver := range approvers {
|
|
// notification := &domain.Notification{
|
|
// RecipientID: approver.ID,
|
|
// Type: domain.NOTIFICATION_TYPE_APPROVAL_REQUIRED,
|
|
// Level: domain.NotificationLevelWarning,
|
|
// Reciever: domain.NotificationRecieverSideAdmin,
|
|
// DeliveryChannel: domain.DeliveryChannelInApp,
|
|
// Payload: domain.NotificationPayload{
|
|
// Headline: "Transfer Approval Required",
|
|
// Message: fmt.Sprintf("Transfer #%d requires your approval", transfer.ID),
|
|
// },
|
|
// Priority: 1,
|
|
// Metadata: []byte(fmt.Sprintf(`{
|
|
// "transfer_id": %d,
|
|
// "amount": %d,
|
|
// "notification_type": "approval_request"
|
|
// }`, transfer.ID, transfer.Amount)),
|
|
// }
|
|
|
|
// if err := s.notificationStore.SendNotification(ctx, notification); err != nil {
|
|
// s.logger.Error("failed to send approval notification",
|
|
// zap.Int64("approver_id", approver.ID),
|
|
// zap.Error(err))
|
|
// }
|
|
// }
|
|
// }
|
|
|
|
// func (s *Service) notifyInitiator(ctx context.Context, transferID int64, comments string) {
|
|
// transfer, err := s.transferStore.GetTransferByID(ctx, transferID)
|
|
// if err != nil {
|
|
// s.logger.Error("failed to get transfer for notification", zap.Error(err))
|
|
// return
|
|
// }
|
|
|
|
// // Determine who initiated the transfer (could be cashier or user)
|
|
// recipientID := transfer.CashierID.Value
|
|
// if !transfer.CashierID.Valid {
|
|
// // If no cashier, assume user initiated
|
|
// wallet, err := s.GetWalletByID(ctx, transfer.SenderWalletID.Value)
|
|
// if err != nil {
|
|
// s.logger.Error("failed to get wallet for notification", zap.Error(err))
|
|
// return
|
|
// }
|
|
// recipientID = wallet.UserID
|
|
// }
|
|
|
|
// notification := &domain.Notification{
|
|
// RecipientID: recipientID,
|
|
// Type: domain.NOTIFICATION_TYPE_TRANSFER_REJECTED,
|
|
// Level: domain.NotificationLevelWarning,
|
|
// Reciever: domain.NotificationRecieverSideCustomer,
|
|
// DeliveryChannel: domain.DeliveryChannelInApp,
|
|
// Payload: domain.NotificationPayload{
|
|
// Headline: "Transfer Rejected",
|
|
// Message: fmt.Sprintf("Your transfer #%d was rejected. Comments: %s", transfer.ID, comments),
|
|
// },
|
|
// Priority: 2,
|
|
// Metadata: []byte(fmt.Sprintf(`{
|
|
// "transfer_id": %d,
|
|
// "notification_type": "transfer_rejected"
|
|
// }`, transfer.ID)),
|
|
// }
|
|
|
|
// if err := s.notificationStore.SendNotification(ctx, notification); err != nil {
|
|
// s.logger.Error("failed to send rejection notification",
|
|
// zap.Int64("recipient_id", recipientID),
|
|
// zap.Error(err))
|
|
// }
|
|
// }
|