How to use

id

method

in

org.reveno.atp.api.commands.CommandContext

public static long handler(CreateAccount cmd, CommandContext ctx) {
  cmd.id = ctx.id(Account.class);
  ctx.executeTxAction(cmd);
  return cmd.id;
}

AbstractDynamicTransaction tx = dynamicTransaction.newInstance();
tx.args.putAll(a.args);
entityTypes.forEach(c -> tx.ids.put(c, b.id(c)));

public static Long createAccount(CreateNewAccountCommand cmd, CommandContext ctx) {
  long accountId = ctx.id(Account.class);
  ctx.executeTxAction(new CreateAccount(accountId, cmd.currency));
  
  if (cmd.balance > 0)
    ctx.executeTxAction(new Credit(accountId, cmd.balance, System.currentTimeMillis()));
  
  return accountId;
}

public static Long newOrder(NewOrderCommand cmd, CommandContext ctx) { 
  long orderId = ctx.id(Order.class);
  Account account = ctx.repo().get(Account.class, cmd.accountId);
  
  if (cmd.positionId != null) {
    long positionId = cmd.positionId;
    require(account.positions().positions().containsKey(positionId), format("Can't find position %d in account %d", positionId, account.id()));
    Position position = ctx.repo().get(Position.class, cmd.positionId);
    long sum = position.sum() + account.orders().stream().map(oid -> ctx.repo().getO(Order.class, oid))
        .flatMap(Commands::streamopt).filter(o -> o.positionId().isPresent() && o.positionId().get() == positionId)
        .map(Order::size).reduce(0L, Long::sum);
    require(sum != 0, format("The position %d is already filled.", positionId));
  }
  
  ctx.executeTxAction(new AcceptOrder(orderId, cmd.accountId, cmd.positionId, cmd.symbol, cmd.price, cmd.size, cmd.orderType));
  
  return orderId;
}

protected Reveno createEngine(File baseDir) {
  Reveno engine = new Engine(baseDir);
  engine.domain().command(SqrtCommand.class, Double.class, (c, u) -> {
    double result = Math.sqrt(c.number);
    u.executeTxAction(new WriteLastCalculationTransaction(u.id(SqrtCommand.class), result));
    
    // test next id generation as well
    u.id(SqrtCommand.class);
    
    return result;
  });
  engine.domain().transactionAction(WriteLastCalculationTransaction.class, (t, u) -> {
    u.repo().store(t.id, t.sqrt);
  });
  engine.domain().viewMapper(Double.class, LastCalculatedView.class, (id,e,r) -> {
    Optional<LastCalculatedView> old = r.getO(LastCalculatedView.class, id);
    if (old.isPresent()) {
      old.get().sqrt = e;
      return old.get();
    } else return new LastCalculatedView(e);
  });
  return engine;
}