public async Task <BankAccountGrainState> Close(BankAccountGrainState state)
{
var stateMachineData = BankAccountData.NewBalance(Balance.ZeroBalance);
var stateMachineState = BankAccountState.ClosedState;
return(await Task.FromResult(new BankAccountGrainState(stateMachineData, stateMachineState)));
}
public async Task <BankAccountGrainState> Deposit(BankAccountGrainState state, Amount amount)
{
var newBalance = state.StateMachineData.Match(_ => _.Item.Deposit(amount));
var stateMachineData = BankAccountData.NewBalance(newBalance);
var stateMachineState = BankAccountState.ActiveState;
return(await Task.FromResult(new BankAccountGrainState(stateMachineData, stateMachineState)));
}
private static async Task <BankAccountGrainState> ActiveStateProcessor(
BankAccountGrainState state,
BankAccountMessage message)
=>
await
message.Match(
HandleInvalidMessage,
ActiveStateMessageDelegator.HandleActiveStateDepositMessage(state),
ActiveStateMessageDelegator.HandleActiveStateWithdrawMessage(state));
private static async Task <BankAccountGrainState> OverdrawnStateProcessor(
BankAccountGrainState state,
BankAccountMessage message)
{
var messageHandler = new OverdrawnStateMessageHandler();
return
(await
message.Match(
() => { throw new InvalidMessage(); },
_ => messageHandler.Deposit(state, _),
_ => { throw new InvalidMessage(); }));
}
private static async Task <BankAccountGrainState> ZeroBalanceStateProcessor(
BankAccountGrainState state,
BankAccountMessage message)
{
var messageHandler = new ZeroBalanceStateMessageHandler();
return
(await
message.Match(
() => messageHandler.Close(state),
_ => messageHandler.Deposit(state, _),
_ => messageHandler.Withdraw(state, _)));
}
public Task <ActiveWithdrawResult> Withdraw(BankAccountGrainState state, Amount amount)
{
var newBalance = state.StateMachineData.Match(_ => _.Item.Withdraw(amount));
var stateMachineData = BankAccountData.NewBalance(newBalance);
var stateMachineState = newBalance.IsZeroBalance
? ActiveWithdrawResultState.ZeroBalanceState
: (newBalance.IsOverdrawnBalance
? ActiveWithdrawResultState.OverdrawnState
: ActiveWithdrawResultState.ActiveState);
return(Task.FromResult(new ActiveWithdrawResult(stateMachineData, stateMachineState)));
}
public static Func <Amount, Task <BankAccountGrainState> > HandleActiveStateWithdrawMessage(BankAccountGrainState state) =>
async _ =>
{
var result = await _handler.Withdraw(state, _);
return((BankAccountGrainState)(result));
};
private static Task <BankAccountGrainState> ClosedStateProcessor(
BankAccountGrainState state,
BankAccountMessage message)
{
throw new InvalidMessage(message);
}
