flamingo.me/flamingo-commerce/v3@v3.11.0/checkout/domain/placeorder/states/create_payment.go (about)

     1  package states
     2  
     3  import (
     4  	"context"
     5  	"encoding/gob"
     6  	"fmt"
     7  
     8  	"flamingo.me/flamingo-commerce/v3/cart/domain/placeorder"
     9  	"flamingo.me/flamingo-commerce/v3/checkout/domain/placeorder/process"
    10  	"flamingo.me/flamingo-commerce/v3/payment/application"
    11  	"go.opencensus.io/trace"
    12  )
    13  
    14  type (
    15  	// CreatePayment state
    16  	CreatePayment struct {
    17  		paymentService *application.PaymentService
    18  	}
    19  
    20  	// CreatePaymentRollbackData needed for rollback
    21  	CreatePaymentRollbackData struct {
    22  		PaymentID          string
    23  		Gateway            string
    24  		RawTransactionData interface{}
    25  	}
    26  )
    27  
    28  var _ process.State = CreatePayment{}
    29  
    30  func init() {
    31  	gob.Register(CreatePaymentRollbackData{})
    32  }
    33  
    34  // Inject dependencies
    35  func (c *CreatePayment) Inject(
    36  	paymentService *application.PaymentService,
    37  ) *CreatePayment {
    38  	c.paymentService = paymentService
    39  
    40  	return c
    41  }
    42  
    43  // Name get state name
    44  func (CreatePayment) Name() string {
    45  	return "CreatePayment"
    46  }
    47  
    48  // Run the state operations
    49  func (c CreatePayment) Run(ctx context.Context, p *process.Process) process.RunResult {
    50  	ctx, span := trace.StartSpan(ctx, "placeorder/state/CreatePayment/Run")
    51  	defer span.End()
    52  
    53  	cart := p.Context().Cart
    54  	paymentGateway, err := c.paymentService.PaymentGatewayByCart(cart)
    55  	if err != nil {
    56  		return process.RunResult{
    57  			Failed: process.PaymentErrorOccurredReason{Error: err.Error()},
    58  		}
    59  	}
    60  
    61  	_, err = paymentGateway.StartFlow(ctx, &cart, p.Context().UUID, p.Context().ReturnURL)
    62  	if err != nil {
    63  		return process.RunResult{
    64  			Failed: process.PaymentErrorOccurredReason{Error: err.Error()},
    65  		}
    66  	}
    67  
    68  	payment, err := paymentGateway.OrderPaymentFromFlow(ctx, &cart, p.Context().UUID)
    69  	if err != nil {
    70  		return process.RunResult{
    71  			Failed: process.PaymentErrorOccurredReason{Error: err.Error()},
    72  		}
    73  	}
    74  
    75  	p.UpdateState(CompleteCart{}.Name(), nil)
    76  	return process.RunResult{
    77  		RollbackData: CreatePaymentRollbackData{
    78  			PaymentID:          payment.PaymentID,
    79  			Gateway:            payment.Gateway,
    80  			RawTransactionData: payment.RawTransactionData,
    81  		},
    82  	}
    83  }
    84  
    85  // Rollback the state operations
    86  func (c CreatePayment) Rollback(ctx context.Context, data process.RollbackData) error {
    87  	ctx, span := trace.StartSpan(ctx, "placeorder/state/CreatePayment/Rollback")
    88  	defer span.End()
    89  
    90  	rollbackData, ok := data.(CreatePaymentRollbackData)
    91  	if !ok {
    92  		return fmt.Errorf("rollback data not of expected type 'CreatePaymentRollbackData', but %T", rollbackData)
    93  	}
    94  
    95  	paymentGateway, err := c.paymentService.PaymentGateway(rollbackData.Gateway)
    96  	if err != nil {
    97  		return err
    98  	}
    99  
   100  	err = paymentGateway.CancelOrderPayment(
   101  		ctx,
   102  		&placeorder.Payment{
   103  			Gateway:            rollbackData.Gateway,
   104  			PaymentID:          rollbackData.PaymentID,
   105  			RawTransactionData: rollbackData.RawTransactionData,
   106  		},
   107  	)
   108  	if err != nil {
   109  		return err
   110  	}
   111  
   112  	return nil
   113  }
   114  
   115  // IsFinal if state is a final state
   116  func (c CreatePayment) IsFinal() bool {
   117  	return false
   118  }