From 7d4f8d5e6e2317e4bc5d42e26d0e8cbc7e311f49 Mon Sep 17 00:00:00 2001 From: Alamutu Khalid Date: Thu, 18 Jun 2026 13:26:56 +0100 Subject: [PATCH 1/2] feat: implemented payment refund and cancelation happy path --- cmd/app/main.go | 2 + internal/bank/ficmart_bank_repo.go | 2 - internal/paymentevent/pgsql_repo.go | 16 ++-- internal/paymentintent/cancel.go | 48 ++++++++-- internal/paymentintent/capture.go | 26 +++--- internal/paymentintent/create.go | 33 +++---- internal/paymentintent/dto.go | 32 ++++++- internal/paymentintent/handler.go | 118 +++++++++++++++++++++---- internal/paymentintent/model.go | 2 +- internal/paymentintent/refund.go | 52 +++++++++-- internal/paymentintent/service.go | 6 +- internal/paymentintent/service_test.go | 4 +- 12 files changed, 261 insertions(+), 80 deletions(-) diff --git a/cmd/app/main.go b/cmd/app/main.go index b6091a5..4cc8dfc 100644 --- a/cmd/app/main.go +++ b/cmd/app/main.go @@ -66,6 +66,8 @@ func main() { router.Post("/payment/intent", paymentIntentHandler.Create) router.Post("/payment/intent/capture", paymentIntentHandler.Capture) + router.Post("/payment/intent/refund", paymentIntentHandler.Refund) + router.Post("/payment/intent/cancel", paymentIntentHandler.Cancel) s := &http.Server{ Addr: ":" + config.Env.App.Port, diff --git a/internal/bank/ficmart_bank_repo.go b/internal/bank/ficmart_bank_repo.go index 1aa3b87..1cb60f7 100644 --- a/internal/bank/ficmart_bank_repo.go +++ b/internal/bank/ficmart_bank_repo.go @@ -45,7 +45,6 @@ func (r *FicMartBankRepo) Authorize(ctx context.Context, idempotencyKey string, return Payment{}, err } - log.Println("capture object in drom bank: ", resData) return resData.ToPayment(), nil } @@ -65,7 +64,6 @@ func (r *FicMartBankRepo) Capture(ctx context.Context, idempotencyKey, authoriza return Payment{}, err } - log.Println("capture object in drom bank: ", resData) return resData.ToPayment(), nil } diff --git a/internal/paymentevent/pgsql_repo.go b/internal/paymentevent/pgsql_repo.go index 19f0ca2..cf4caf6 100644 --- a/internal/paymentevent/pgsql_repo.go +++ b/internal/paymentevent/pgsql_repo.go @@ -21,7 +21,7 @@ func NewPostgresRepo(db DBTX) *PostgresRepo { } func (r *PostgresRepo) Create(ctx context.Context, intentId, status, providerStateId string) (PaymentEvent, error) { - var process PaymentEvent + var event PaymentEvent err := r.db.QueryRow(ctx, ` INSERT INTO payment_events ( payment_intent_id, state, external_state_id @@ -33,18 +33,18 @@ func (r *PostgresRepo) Create(ctx context.Context, intentId, status, providerSta status, providerStateId, ).Scan( - &process.Id, - &process.PaymentIntentId, - &process.State, - &process.ExternalStateId, - &process.Metadata, - &process.CreatedAt, + &event.Id, + &event.PaymentIntentId, + &event.State, + &event.ExternalStateId, + &event.Metadata, + &event.CreatedAt, ) if err != nil { return PaymentEvent{}, err } - return process, nil + return event, nil } func (r *PostgresRepo) GetByIntentAndStatus(ctx context.Context, intentId, status string) (PaymentEvent, error) { diff --git a/internal/paymentintent/cancel.go b/internal/paymentintent/cancel.go index 62c26b7..4807f9e 100644 --- a/internal/paymentintent/cancel.go +++ b/internal/paymentintent/cancel.go @@ -8,23 +8,57 @@ import ( "github.com/jackc/pgx/v5" ) -func (s *Service) Cancel(ctx context.Context, idempotencyKey, paymentRef string) (string, error) { - paymentIntent, err := s.repo.GetWithEvent(ctx, paymentRef, PaymentStatusAuthorized) +func (s *Service) Cancel(ctx context.Context, + idempotencyKey, requestHash, paymentRef string, +) (PaymentIntent, bool, error) { + reservedPI, err := s.getReservedIntent(ctx, idempotencyKey, requestHash) + if err != nil { + return PaymentIntent{}, false, err + } + + if reservedPI != nil { + return *reservedPI, true, nil + } + + pi, err := s.repo.GetWithEvent(ctx, paymentRef, PaymentStatusAuthorized) if err != nil { if errors.Is(err, pgx.ErrNoRows) { log.Printf("operation not allowed: intent=%s, required_status=%s", paymentRef, PaymentStatusAuthorized) - return "", ErrOperationNotAllowed + return PaymentIntent{}, false, ErrOperationNotAllowed } log.Printf("Error retrieving payment intent for payment reference %s: %s", paymentRef, err) - return "", ErrInternal + return PaymentIntent{}, false, ErrInternal } - payment, err := s.bankRepo.Void(ctx, idempotencyKey, paymentIntent.CurrentEvent.ExternalStateId) + payment, err := s.bankRepo.Void(ctx, idempotencyKey, pi.CurrentEvent.ExternalStateId) if err != nil { log.Printf("Bank failed to void payment: %s", err) - return "", ErrBankDeclined + return PaymentIntent{}, false, ErrBankDeclined + } + + err = s.uow.RunInTx(ctx, func(r Repos) error { + event, err := r.PaymentEvent.Create(ctx, pi.Id, PaymentStatusCanceled, payment.VoidId) + if err != nil { + return nil + } + + err = r.PaymentIntent.UpdateState(ctx, pi.PaymentRef, event.State) + if err != nil { + return err + } + + pi.Status = event.State + pi.CurrentEvent = nil + + return nil + }) + if err != nil { + log.Printf("Error updating payment intent state to %v: %s", PaymentStatusCanceled, err) + return PaymentIntent{}, false, err } - return payment.VoidId, nil + err = s.idempotencyService.ReserveKey(ctx, idempotencyKey, requestHash, pi.PaymentRef) + + return pi, false, nil } diff --git a/internal/paymentintent/capture.go b/internal/paymentintent/capture.go index ea575da..64f28f0 100644 --- a/internal/paymentintent/capture.go +++ b/internal/paymentintent/capture.go @@ -11,16 +11,16 @@ import ( func (s *Service) Capture(ctx context.Context, idempotencyKey, requestHash, paymentRef string, amount int, ) (PaymentIntent, bool, error) { - reservedPaymentIntent, err := s.getReserved(ctx, idempotencyKey, requestHash) + reservedPI, err := s.getReservedIntent(ctx, idempotencyKey, requestHash) if err != nil { return PaymentIntent{}, false, err } - if reservedPaymentIntent != nil { - return *reservedPaymentIntent, true, nil + if reservedPI != nil { + return *reservedPI, true, nil } - paymentIntent, err := s.repo.GetWithEvent(ctx, paymentRef, PaymentStatusAuthorized) + pi, err := s.repo.GetWithEvent(ctx, paymentRef, PaymentStatusAuthorized) if err != nil { if errors.Is(err, pgx.ErrNoRows) { log.Printf("operation not allowed: intent=%s, required_status=%s", paymentRef, PaymentStatusAuthorized) @@ -31,29 +31,27 @@ func (s *Service) Capture(ctx context.Context, return PaymentIntent{}, false, ErrInternal } - payment, err := s.bankRepo.Capture(ctx, idempotencyKey, paymentIntent.CurrentEvent.ExternalStateId, amount) - log.Println("paymetttttt: ", payment) + payment, err := s.bankRepo.Capture(ctx, idempotencyKey, pi.CurrentEvent.ExternalStateId, amount) if err != nil { log.Printf("Bank capture failed for payment reference %s: %s", paymentRef, err) return PaymentIntent{}, false, ErrBankDeclined } err = s.uow.RunInTx(ctx, func(r Repos) error { - err = r.PaymentIntent.UpdateState(ctx, paymentRef, PaymentStatusCaptured) + event, err := r.PaymentEvent.Create(ctx, pi.Id, PaymentStatusCaptured, payment.CaptureId) if err != nil { - log.Printf("Error updating bank capture for payment reference %s: %s", paymentRef, err) + log.Printf("Error creating payment event: %s", err) return ErrInternal } - process, err := r.PaymentEvent.Create(ctx, paymentIntent.Id, PaymentStatusCaptured, payment.CaptureId) + err = r.PaymentIntent.UpdateState(ctx, paymentRef, event.State) if err != nil { - log.Printf("Error creating payment process: %s", err) + log.Printf("Error updating bank capture for payment reference %s: %s", paymentRef, err) return ErrInternal } - paymentIntent.Status = process.State - // remove state object from getting returned to client - paymentIntent.CurrentEvent = nil + pi.Status = event.State + pi.CurrentEvent = nil return nil }) @@ -64,5 +62,5 @@ func (s *Service) Capture(ctx context.Context, return PaymentIntent{}, false, ErrInternal } - return paymentIntent, false, nil + return pi, false, nil } diff --git a/internal/paymentintent/create.go b/internal/paymentintent/create.go index 14e0ce4..eb41e25 100644 --- a/internal/paymentintent/create.go +++ b/internal/paymentintent/create.go @@ -11,18 +11,18 @@ import ( func (s *Service) Create( ctx context.Context, idempotencyKey, requestHash string, input CreateInput, ) (PaymentIntent, bool, error) { - reservedPaymentIntent, err := s.getReserved(ctx, idempotencyKey, requestHash) + reservedPI, err := s.getReservedIntent(ctx, idempotencyKey, requestHash) if err != nil { return PaymentIntent{}, false, err } - if reservedPaymentIntent != nil { - return *reservedPaymentIntent, true, nil + if reservedPI != nil { + return *reservedPI, true, nil } - var paymentIntent PaymentIntent + var pi PaymentIntent err = s.uow.RunInTx(ctx, func(r Repos) error { - paymentIntent, err = r.PaymentIntent.Create( + pi, err = r.PaymentIntent.Create( ctx, input.Amount.Figure, input.Amount.Currency, input.OrderId, input.CustomerId, ) if err != nil { @@ -30,16 +30,16 @@ func (s *Service) Create( return err } - id, err := strconv.ParseInt(paymentIntent.Id, 10, 64) + id, err := strconv.ParseInt(pi.Id, 10, 64) if err != nil { log.Printf("Error parsing payment intent ID: %s", err) return err } - paymentIntent.PaymentRef = utils.GeneratePaymentRef(id) + pi.PaymentRef = utils.GeneratePaymentRef(id) err = r.PaymentIntent.CreateReference( - ctx, paymentIntent.Id, paymentIntent.PaymentRef, + ctx, pi.Id, pi.PaymentRef, ) if err != nil { log.Printf("Error creating payment intent: %s", err) @@ -52,7 +52,7 @@ func (s *Service) Create( return PaymentIntent{}, false, err } - err = s.idempotencyService.ReserveKey(ctx, idempotencyKey, requestHash, paymentIntent.PaymentRef) + err = s.idempotencyService.ReserveKey(ctx, idempotencyKey, requestHash, pi.PaymentRef) if err != nil { return PaymentIntent{}, false, ErrInternal } @@ -76,27 +76,28 @@ func (s *Service) Create( }, ) if err != nil { - log.Printf("Bank authorization failed for payment reference %s: %s", paymentIntent.PaymentRef, err) + log.Printf("Bank authorization failed for payment reference %s: %s", pi.PaymentRef, err) return PaymentIntent{}, false, ErrBankDeclined } err = s.uow.RunInTx(ctx, func(r Repos) error { - err := r.PaymentIntent.UpdateState(ctx, paymentIntent.PaymentRef, PaymentStatusAuthorized) + event, err := r.PaymentEvent.Create(ctx, pi.Id, PaymentStatusAuthorized, payment.AuthorizationId) if err != nil { - log.Printf("Error updating payment intent state: %s", err) + log.Printf("Error creating payment event state: %s", err) return err } - process, err := r.PaymentEvent.Create(ctx, paymentIntent.Id, PaymentStatusAuthorized, payment.AuthorizationId) + err = r.PaymentIntent.UpdateState(ctx, pi.PaymentRef, event.State) if err != nil { - log.Printf("Error creating payment process state: %s", err) + log.Printf("Error updating payment intent state: %s", err) return err } - paymentIntent.Status = process.State + pi.Status = event.State + pi.CurrentEvent = nil return nil }) - return paymentIntent, false, nil + return pi, false, nil } diff --git a/internal/paymentintent/dto.go b/internal/paymentintent/dto.go index 56a3cbb..bcacded 100644 --- a/internal/paymentintent/dto.go +++ b/internal/paymentintent/dto.go @@ -30,7 +30,7 @@ func (c CardR) Validate() error { ) } -type CreatePaymentIntentRequest struct { +type CreateRequest struct { Card *Card `json:"card"` Amount int `json:"amount"` Currency string `json:"currency"` @@ -38,7 +38,7 @@ type CreatePaymentIntentRequest struct { CustomerId string `json:"customer_id"` } -func (r *CreatePaymentIntentRequest) Validate() error { +func (r *CreateRequest) Validate() error { return validation.ValidateStruct( r, validation.Field(&r.Card, validation.Required), @@ -49,12 +49,12 @@ func (r *CreatePaymentIntentRequest) Validate() error { ) } -type CapturePaymentIntentRequest struct { +type CaptureRequest struct { PaymentRef string `json:"payment_ref"` Amount int `json:"amount"` } -func (r *CapturePaymentIntentRequest) Validate() error { +func (r *CaptureRequest) Validate() error { return validation.ValidateStruct( r, validation.Field(&r.PaymentRef, validation.Required), @@ -62,6 +62,30 @@ func (r *CapturePaymentIntentRequest) Validate() error { ) } +type RefundRequest struct { + PaymentRef string `json:"payment_ref"` + Amount int `json:"amount"` +} + +func (r *RefundRequest) Validate() error { + return validation.ValidateStruct( + r, + validation.Field(&r.PaymentRef, validation.Required), + validation.Field(&r.Amount, validation.Required), + ) +} + +type CencelRequest struct { + PaymentRef string `json:"payment_ref"` +} + +func (r *CencelRequest) Validate() error { + return validation.ValidateStruct( + r, + validation.Field(&r.PaymentRef, validation.Required), + ) +} + // Bussiness DTO type CardExpiry struct { diff --git a/internal/paymentintent/handler.go b/internal/paymentintent/handler.go index 248011c..21d37fc 100644 --- a/internal/paymentintent/handler.go +++ b/internal/paymentintent/handler.go @@ -23,7 +23,7 @@ func (h *Handler) Create(w http.ResponseWriter, r *http.Request) { _ = r.Body.Close() }() - var req CreatePaymentIntentRequest + var req CreateRequest if err := json.NewDecoder(r.Body).Decode(&req); err != nil { log.Printf("Error decoding request body: %s", err) render.ErrorJSON(w, "invalid request body", http.StatusBadRequest) @@ -92,7 +92,7 @@ func (h *Handler) Capture(w http.ResponseWriter, r *http.Request) { _ = r.Body.Close() }() - var req CapturePaymentIntentRequest + var req CaptureRequest if err := json.NewDecoder(r.Body).Decode(&req); err != nil { log.Printf("Error decoding request body: %s", err) render.ErrorJSON(w, "invalid request body", http.StatusBadRequest) @@ -116,26 +116,47 @@ func (h *Handler) Capture(w http.ResponseWriter, r *http.Request) { requestHash, req.PaymentRef, req.Amount, ) if err != nil { - switch { - case errors.Is(err, ErrIdempotencyKeyReuse): - render.ErrorJSON(w, err.Error(), http.StatusConflict) + renderErr(err, w) + return + } - case errors.Is(err, ErrBankDeclined): - render.ErrorJSON(w, err.Error(), http.StatusUnprocessableEntity) + if replayed { + w.Header().Set("X-Idempotent-Replayed", "true") + } - case errors.Is(err, ErrInconsistentState): - render.ErrorJSON(w, err.Error(), http.StatusInternalServerError) + render.JSON(w, http.StatusCreated, "Payment captured successfully", paymentIntent) +} - case errors.Is(err, ErrInternal): - render.ErrorJSON(w, err.Error(), http.StatusInternalServerError) +func (h *Handler) Refund(w http.ResponseWriter, r *http.Request) { + defer func() { + _ = r.Body.Close() + }() + + var req RefundRequest + if err := json.NewDecoder(r.Body).Decode(&req); err != nil { + log.Printf("Error decoding request body: %s", err) + render.ErrorJSON(w, "invalid request body", http.StatusBadRequest) + return + } - case errors.Is(err, ErrOperationNotAllowed): - render.ErrorJSON(w, err.Error(), http.StatusForbidden) + if err := req.Validate(); err != nil { + render.ErrorJSON(w, err.Error(), http.StatusBadRequest) + return + } - default: - render.ErrorJSON(w, "Unexpected error", http.StatusInternalServerError) - } + requestHash, err := hashRequestBody(req) + if err != nil { + log.Printf("Error hashing request body: %s", err) + render.ErrorJSON(w, "Unable to hash request body", http.StatusInternalServerError) + return + } + paymentIntent, replayed, err := h.service.Refund( + r.Context(), r.Header.Get("X-Idempotency-Key"), + requestHash, req.PaymentRef, req.Amount, + ) + if err != nil { + renderErr(err, w) return } @@ -143,7 +164,48 @@ func (h *Handler) Capture(w http.ResponseWriter, r *http.Request) { w.Header().Set("X-Idempotent-Replayed", "true") } - render.JSON(w, http.StatusCreated, "Payment Intent captured successfully", paymentIntent) + render.JSON(w, http.StatusCreated, "Payment refunded successfully", paymentIntent) +} + +func (h *Handler) Cancel(w http.ResponseWriter, r *http.Request) { + defer func() { + _ = r.Body.Close() + }() + + var req CencelRequest + if err := json.NewDecoder(r.Body).Decode(&req); err != nil { + log.Printf("Error decoding request body: %s", err) + render.ErrorJSON(w, "invalid request body", http.StatusBadRequest) + return + } + + if err := req.Validate(); err != nil { + render.ErrorJSON(w, err.Error(), http.StatusBadRequest) + return + } + + requestHash, err := hashRequestBody(req) + if err != nil { + log.Printf("Error hashing request body: %s", err) + render.ErrorJSON(w, "Unable to hash request body", http.StatusInternalServerError) + return + } + + paymentIntent, replayed, err := h.service.Cancel( + r.Context(), + r.Header.Get("X-Idempotency-Key"), requestHash, + req.PaymentRef, + ) + if err != nil { + renderErr(err, w) + return + } + + if replayed { + w.Header().Set("X-Idempotent-Replayed", "true") + } + + render.JSON(w, http.StatusCreated, "Payment successfully canceled", paymentIntent) } func hashRequestBody(body any) (string, error) { @@ -156,3 +218,25 @@ func hashRequestBody(body any) (string, error) { return hash, nil } + +func renderErr(err error, w http.ResponseWriter) { + switch { + case errors.Is(err, ErrIdempotencyKeyReuse): + render.ErrorJSON(w, err.Error(), http.StatusConflict) + + case errors.Is(err, ErrBankDeclined): + render.ErrorJSON(w, err.Error(), http.StatusUnprocessableEntity) + + case errors.Is(err, ErrInconsistentState): + render.ErrorJSON(w, err.Error(), http.StatusInternalServerError) + + case errors.Is(err, ErrInternal): + render.ErrorJSON(w, err.Error(), http.StatusInternalServerError) + + case errors.Is(err, ErrOperationNotAllowed): + render.ErrorJSON(w, err.Error(), http.StatusForbidden) + + default: + render.ErrorJSON(w, "Unexpected error", http.StatusInternalServerError) + } +} diff --git a/internal/paymentintent/model.go b/internal/paymentintent/model.go index 85fc777..d7d05fa 100644 --- a/internal/paymentintent/model.go +++ b/internal/paymentintent/model.go @@ -10,7 +10,7 @@ const ( PaymentStatusAuthorized string = "authorized" PaymentStatusCaptured string = "captured" PaymentStatusRefunded string = "refunded" - PaymentStatusVoided string = "voided" + PaymentStatusCanceled string = "canceled" PaymentStatusFailed string = "failed" ) diff --git a/internal/paymentintent/refund.go b/internal/paymentintent/refund.go index 248b719..7603cd7 100644 --- a/internal/paymentintent/refund.go +++ b/internal/paymentintent/refund.go @@ -8,22 +8,62 @@ import ( "github.com/jackc/pgx/v5" ) -func (s *Service) Refund(ctx context.Context, idempotencyKey, paymentRef string, amount int) (string, error) { - paymentIntent, err := s.repo.GetWithEvent(ctx, paymentRef, PaymentStatusCaptured) +func (s *Service) Refund(ctx context.Context, + idempotencyKey, requestHash, paymentRef string, + amount int, +) (PaymentIntent, bool, error) { + reservedPI, err := s.getReservedIntent(ctx, idempotencyKey, requestHash) + if err != nil { + return PaymentIntent{}, false, err + } + + if reservedPI != nil { + return *reservedPI, true, nil + } + + pi, err := s.repo.GetWithEvent(ctx, paymentRef, PaymentStatusCaptured) if err != nil { if errors.Is(err, pgx.ErrNoRows) { log.Printf("operation not allowed: intent=%s, required_status=%s", paymentRef, PaymentStatusAuthorized) - return "", ErrOperationNotAllowed + return PaymentIntent{}, false, ErrOperationNotAllowed } log.Printf("Error retrieving payment intent for payment reference %s: %s", paymentRef, err) - return "", ErrInternal + return PaymentIntent{}, false, ErrInternal } - payment, err := s.bankRepo.Refund(ctx, idempotencyKey, paymentIntent.CurrentEvent.ExternalStateId, amount) + payment, err := s.bankRepo.Refund(ctx, idempotencyKey, pi.CurrentEvent.ExternalStateId, amount) if err != nil { log.Printf("Bank refund failed: %s", err) + return PaymentIntent{}, false, ErrBankDeclined + } + + err = s.uow.RunInTx(ctx, func(r Repos) error { + event, err := r.PaymentEvent.Create(ctx, pi.Id, PaymentStatusRefunded, payment.RefundId) + if err != nil { + return err + } + + err = r.PaymentIntent.UpdateState(ctx, pi.PaymentRef, event.State) + if err != nil { + return err + } + + pi.Status = event.State + pi.CurrentEvent = nil + + return nil + }) + if err != nil { + log.Printf("Error updating payment intent state to %v: %s", PaymentStatusRefunded, err) + return PaymentIntent{}, false, ErrInternal + } + + err = s.idempotencyService.ReserveKey(ctx, idempotencyKey, requestHash, pi.PaymentRef) + if err != nil { + log.Printf("Error reserving refunded payment intent: %s", err) + return PaymentIntent{}, false, ErrInternal } - return payment.RefundId, nil + return pi, false, nil } diff --git a/internal/paymentintent/service.go b/internal/paymentintent/service.go index 0d8a7fc..b9eba6a 100644 --- a/internal/paymentintent/service.go +++ b/internal/paymentintent/service.go @@ -33,15 +33,15 @@ type Service struct { func NewService( repo Repository, - processRepo paymentevent.Repository, + paymentEventRepo paymentevent.Repository, bankRepo bank.Repository, uow UoW, idempotencyService *idempotency.Service, ) *Service { - return &Service{repo, processRepo, bankRepo, uow, idempotencyService} + return &Service{repo, paymentEventRepo, bankRepo, uow, idempotencyService} } -func (s *Service) getReserved(ctx context.Context, idempotencyKey, requestHash string) (*PaymentIntent, error) { +func (s *Service) getReservedIntent(ctx context.Context, idempotencyKey, requestHash string) (*PaymentIntent, error) { entry, err := s.idempotencyService.GetKeyReserve(ctx, idempotencyKey) if err != nil && !errors.Is(err, redis.Nil) { log.Println("Redis internal error:", err) diff --git a/internal/paymentintent/service_test.go b/internal/paymentintent/service_test.go index 32296bf..56f7ccc 100644 --- a/internal/paymentintent/service_test.go +++ b/internal/paymentintent/service_test.go @@ -169,7 +169,7 @@ func TestGetReservedHappyPath(t *testing.T) { service := NewService(repo, &paymentEventRepoMock{}, &bankRepoMock{}, uow, idempotencyService) - paymentIntent, err := service.getReserved(context.Background(), "idm-key", requestHash) + paymentIntent, err := service.getReservedIntent(context.Background(), "idm-key", requestHash) if err != nil { t.Fatalf("Expected no error, got %v", err) } @@ -217,7 +217,7 @@ func TestGetReservedThrowsErrorOnIdempotencyKeyReuse(t *testing.T) { service := NewService(repo, &paymentEventRepoMock{}, &bankRepoMock{}, uow, idempotencyService) - _, err := service.getReserved(context.Background(), "idm-key", requestHash) + _, err := service.getReservedIntent(context.Background(), "idm-key", requestHash) if err == nil { t.Fatalf("Expected error due to idempotency key reuse with different request hash, got nil") } From 9b6d596cb8a2a418347e1898b4ea4a75fad6a7f7 Mon Sep 17 00:00:00 2001 From: Alamutu Khalid Date: Thu, 18 Jun 2026 13:36:00 +0100 Subject: [PATCH 2/2] fix: addressed lint errors --- internal/paymentintent/cancel.go | 10 +++++++--- internal/paymentintent/capture.go | 10 ++++++---- internal/paymentintent/create.go | 6 ++++-- internal/paymentintent/refund.go | 2 +- 4 files changed, 18 insertions(+), 10 deletions(-) diff --git a/internal/paymentintent/cancel.go b/internal/paymentintent/cancel.go index 4807f9e..e9f71ab 100644 --- a/internal/paymentintent/cancel.go +++ b/internal/paymentintent/cancel.go @@ -40,7 +40,7 @@ func (s *Service) Cancel(ctx context.Context, err = s.uow.RunInTx(ctx, func(r Repos) error { event, err := r.PaymentEvent.Create(ctx, pi.Id, PaymentStatusCanceled, payment.VoidId) if err != nil { - return nil + return err } err = r.PaymentIntent.UpdateState(ctx, pi.PaymentRef, event.State) @@ -54,11 +54,15 @@ func (s *Service) Cancel(ctx context.Context, return nil }) if err != nil { - log.Printf("Error updating payment intent state to %v: %s", PaymentStatusCanceled, err) - return PaymentIntent{}, false, err + log.Printf("Error creating payment event for state to %v: %s", PaymentStatusCanceled, err) + return PaymentIntent{}, false, ErrInternal } err = s.idempotencyService.ReserveKey(ctx, idempotencyKey, requestHash, pi.PaymentRef) + if err != nil { + log.Printf("Error reserving refunded payment intent: %s", err) + return PaymentIntent{}, false, ErrInternal + } return pi, false, nil } diff --git a/internal/paymentintent/capture.go b/internal/paymentintent/capture.go index 64f28f0..38e3daa 100644 --- a/internal/paymentintent/capture.go +++ b/internal/paymentintent/capture.go @@ -40,14 +40,12 @@ func (s *Service) Capture(ctx context.Context, err = s.uow.RunInTx(ctx, func(r Repos) error { event, err := r.PaymentEvent.Create(ctx, pi.Id, PaymentStatusCaptured, payment.CaptureId) if err != nil { - log.Printf("Error creating payment event: %s", err) - return ErrInternal + return err } err = r.PaymentIntent.UpdateState(ctx, paymentRef, event.State) if err != nil { - log.Printf("Error updating bank capture for payment reference %s: %s", paymentRef, err) - return ErrInternal + return err } pi.Status = event.State @@ -55,6 +53,10 @@ func (s *Service) Capture(ctx context.Context, return nil }) + if err != nil { + log.Printf("Error creating payment event for state to %v: %s", PaymentStatusCaptured, err) + return PaymentIntent{}, false, ErrInternal + } err = s.idempotencyService.ReserveKey(ctx, idempotencyKey, requestHash, paymentRef) if err != nil { diff --git a/internal/paymentintent/create.go b/internal/paymentintent/create.go index eb41e25..8048879 100644 --- a/internal/paymentintent/create.go +++ b/internal/paymentintent/create.go @@ -83,13 +83,11 @@ func (s *Service) Create( err = s.uow.RunInTx(ctx, func(r Repos) error { event, err := r.PaymentEvent.Create(ctx, pi.Id, PaymentStatusAuthorized, payment.AuthorizationId) if err != nil { - log.Printf("Error creating payment event state: %s", err) return err } err = r.PaymentIntent.UpdateState(ctx, pi.PaymentRef, event.State) if err != nil { - log.Printf("Error updating payment intent state: %s", err) return err } @@ -98,6 +96,10 @@ func (s *Service) Create( return nil }) + if err != nil { + log.Printf("Error creating payment event for state to %v: %s", PaymentStatusAuthorized, err) + return PaymentIntent{}, false, ErrInternal + } return pi, false, nil } diff --git a/internal/paymentintent/refund.go b/internal/paymentintent/refund.go index 7603cd7..0a10883 100644 --- a/internal/paymentintent/refund.go +++ b/internal/paymentintent/refund.go @@ -55,7 +55,7 @@ func (s *Service) Refund(ctx context.Context, return nil }) if err != nil { - log.Printf("Error updating payment intent state to %v: %s", PaymentStatusRefunded, err) + log.Printf("Error creating payment event for state to %v: %s", PaymentStatusRefunded, err) return PaymentIntent{}, false, ErrInternal }