顺序调用多个api的设计模式

Question

I am doing an integration with payment service. And I have to onboard a merchant. For onboarding a merchant I need to follow bellow steps

1. Create a user on payment service, if successfully created: POST api call
2. Create a business profile of the user created in previous step: POST api call
3. Create a payment profile for the user: POST api call
4. register a callback url for receiving webhook for transaction status change for payments for that user: POST api call

If any step fails, I need to retry from that step only. I can not start from starting.

My Solution:

I am maintaining a state object for onboarding of the user. state object has 4 fields

• userCreated
• businessProfileCreated
• paymentProfileCreated
• webhookRegistered

with each step I am setting respective state attribute as true and saving it.

Algotithm:

Initialise state object all

state.userCreated = false;
state.businessProfileCreated = false;
state.paymentProfileCreated = false;
state.webhookRegistered = false;`

if(state.userCreated != true)
    create user
if create profile **not** success
    save state 
    return
state.userCreated = true

if(state.businessProfileCreated != true)
    create business profile
if businessProfile creation  **not** success
    save state
    return
state.businessProfileCreated = true

if(state.paymentProfileCreated != true create payment profile if payment Profile creation not success save state return state.paymentProfileCreated

if(state.webhookRegistered:= true) :create webhook profile save state return

state.paymentProfileCreated save state ``

I need a clean way of doing this that also handle api failure. Is there any pattern exists for this task

Answer 1

Maybe others have better ideas, but what comes to my mind is a modified version of the Strategy Pattern. (See https://en.wikipedia.org/wiki/Strategy_pattern )

To implement this, you would need a list of functions to execute, (the strategy,) and you would write some code which walks through the list, invokes the function, checks the result, and keeps track of where the error occurred, by storing the index of the function that failed instead of jockeying a bunch of boolean flags.

Your problem, if you decide to use this pattern, is that different functions may need different parameters, and to complicate things even more, some function may depend on some result returned by a previously invoked function. To solve this, you will have to store all of the information that these functions might need into a separate object and pass that object to each one of the functions, so that they can read fields from that object and write fields to it as they need.

It is probably not worth the hassle, and it will probably not make it any more clear to the reader what is happening.

Consider keeping the structure of your existing code but just improving it, for example:

• Use a single enum telling you how far you went instead of a whole bunch of booleans;

• Move all the steps in a new function, and modify each error check so that it returns a failure indication instead of saving state and then returning. Then, from the place where you call this function, check whether it indicates error, and if so, save the state only in one place.

Answer 2

This is a place where State pattern can be used. As wiki says :

The state pattern is a behavioral software design pattern that allows an object to alter its behavior when its internal state changes. This pattern is close to the concept of finite-state machines

Let me show how it can be implemented via C#.

This is a class which will run multiple API'in a sequence:

public class APIMachine
{
    IState _userState;
    IState _callbackState;
    IState _paymentState;
    IState _businessState;

    public string Run() 
    {
        _userState = InitializeState();
        _userState.Do();
        return _callbackState.GetResult().ToString();
    }

    private IState InitializeState() 
    {
        _callbackState = new CallbackState();
        _paymentState = new PaymentState(_callbackState);
        _businessState = new BusinessState(_paymentState);
        return new UserState(_businessState);
    }
}

This is an abstraction of all states:

public interface IState
{
    void Do();

    bool HasSuccess { get; set; }

    int RetryCount { get; }

    object GetResult();
}

This is a concrete implementation of UserState :

public class UserState : IState
{
    IState _state;

    public UserState(IState state) => _state = state;

    public int RetryCount => 3;

    public bool HasSuccess { get ; set ; }

    public void Do()
    {
       int count = 0;
        while (count <= RetryCount)
        {
            // Make post request here to create user
            HasSuccess = true;
            if (HasSuccess)
            {
                _state.Do();
                break;
            }
            count++;
        }
    }

    public object GetResult()
    {
        throw new NotImplementedException();
    }
}

and:

public class BusinessState : IState
{
    IState _state;

    public BusinessState(IState state) => _state = state;

    public int RetryCount => 3;

    public bool HasSuccess { get; set; }

    public void Do()
    {
        int count = 0;
        while (count <= RetryCount)
        {
            // Make post request here to create business profile
            HasSuccess = true; // if post request is okay
            if (HasSuccess)
            {
                _state.Do();
                break;
            }
            count++;
        }
    }

    public object GetResult()
    {
        throw new NotImplementedException();
    }
}

and:

public class PaymentState : IState
{
    IState _state;

    public PaymentState(IState state) => _state = state;

    public int RetryCount => 3;

    public bool HasSuccess { get; set; }

    public void Do()
    {
        int count = 0;
        while (count <= RetryCount)
        {
            // Make post request here to create payment profile
            HasSuccess = true; // if post request is okay
            if (HasSuccess) 
            {
                _state.Do();
                break;
            }
            count++;
        }
    }

    public object GetResult()
    {
        throw new NotImplementedException();
    }
}

and:

public class CallbackState : IState
{
    public int RetryCount => 3;

    public bool HasSuccess { get; set; }

    public void Do()
    {
        int count = 0;
        while (count <= RetryCount)
        {
            // Make post request here to create payment profile
            HasSuccess = true; // if post request is okay
            if (HasSuccess)
            {
                break;
            }
            count++;
        }
    }

    public object GetResult()
    {
        return "foobar.com";
    }
}

And the above code can be run like this:

APIMachine apiMachine = new();
string callbackUri = apiMachine.Run();

OUTPUT: foobar.com