Trading API

  
1
2
3
4
5
6

  
private TradingAccounts getTradingAccounts() {
  AccessTokenRequest request = AccessTokenRequest.newBuilder()
      .setAccessToken(accessToken)
      .build();
  return accountServiceBlockingStub.getTradingAccounts(request);
}

  
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

  
private void getTradingAccountsAsync() {
  AccessTokenRequest request = AccessTokenRequest.newBuilder()
      .setAccessToken(accessToken)
      .build();
  accountServiceStub.getTradingAccounts(request, new StreamObserver<TradingAccounts>() { (1)
    @Override
    public void onNext(TradingAccounts tradingAccounts) {
      System.out.println(tradingAccounts); (2)
    }

    @Override
    public void onError(Throwable t) {
      t.printStackTrace(); (3)
    }

    @Override
    public void onCompleted() {
      System.out.println("No results anymore"); (4)
    }
  });
}

  
1
2
3
4
5
6
7
8
9
10
11
12

  
private String login(String secret) {
  LoginRequest loginRequest = LoginRequest.newBuilder()
      .setSecret(secret)
      .build();
  LoginReply loginReply = accessServiceBlockingStub.login(loginRequest);
  if (loginReply.getError()!=Error.getDefaultInstance()) {
    System.err.println(loginReply.getError());
    return "";
  } else {
    return loginReply.getAccessToken();
  }
}

private void logout() {
  if (accessToken!=null && !accessToken.isEmpty()) {
    LogoutRequest request = LogoutRequest.newBuilder()
        .setAccessToken(accessToken)
        .build();
    accessServiceBlockingStub.logout(request);
  }
}

  
1
2
3
4
5
6
7
8
9
10

  
private static final Empty EMPTY = Empty.getDefaultInstance();

private final AccountServiceGrpc.AccountServiceBlockingStub accountServiceBlockingStub;

private TradingAccounts getTradingAccounts() {
  AccessTokenRequest request = AccessTokenRequest.newBuilder()
      .setAccessToken(accessToken)
      .build();
  return accountServiceBlockingStub.getTradingAccounts(request);
}

  
1
2
3
4
5
6
7
8
9
10
11
12
13
14

  
private void streamTradingAccountInformation() {
  TradingAccounts tradingAccounts = getTradingAccounts(); (1)
  for (int accountIndex = 0; accountIndex<tradingAccounts.getAccountsCount(); accountIndex++) {
    TradingAccount account = tradingAccounts.getAccounts(accountIndex); (2)
    TradingAccountRequest request = TradingAccountRequest.newBuilder()
        .setAccessToken(accessToken)
        .setTradingAccount(account)
        .build();

    TradingAccountInformationObserver observer = (3)
        new TradingAccountInformationObserver(request, accountServiceStub);
    accountObservers.put(account, observer);
  }
}

  
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

  
import com.consorsbank.module.tapi.grpc.AccountServiceGrpc.AccountServiceStub;
import com.consorsbank.module.tapi.grpc.account.TradingAccount;
import com.consorsbank.module.tapi.grpc.account.TradingAccountInformation;
import com.consorsbank.module.tapi.grpc.account.TradingAccountRequest;
import com.consorsbank.module.tapi.grpc.common.Error;


public class TradingAccountInformationObserver extends ServerSubscription<TradingAccount, TradingAccountInformation>{
  private final AccountServiceStub orderServiceStub;

  public TradingAccountInformationObserver(
      TradingAccountRequest request, AccountServiceStub orderServiceStub) {

    this.orderServiceStub = orderServiceStub;
    this.orderServiceStub.streamTradingAccount(request, this); (1)
  }

  @Override
  public void onCompleted() { (2)
    System.out.println("Call completed!");
  }

  @Override
  public void onNext(TradingAccountInformation reply) { (3)
    Error error = reply.getError(); (4)
    if (error==Error.getDefaultInstance()) {
      System.out.printf("Async trading information: %s%n", reply);
    } else {
      System.out.printf("Error: %s%n", error);
    }
  }
}

  
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

  
import io.grpc.Status;
import io.grpc.StatusRuntimeException;
import io.grpc.stub.ClientCallStreamObserver;
import io.grpc.stub.ClientResponseObserver;

public abstract class ServerSubscription<R, T> implements ClientResponseObserver<R, T>, Closeable {
  private ClientCallStreamObserver<R> observer;

  /**
   * This function is called during subscription initialization.
   * observer will created by GRPC engine and can be used for
   * data flow control.
   */
  @Override
  public void beforeStart(ClientCallStreamObserver<R> observer) {
    this.observer = observer; (1)
  }

  /**
   * Call this function to unsubscribe from server
   */
  @Override
  public void close() {
    observer.cancel("Fin", null); (2)
  }
  // ...
}

  
1
2
3
4
5
6
7
8
9
10
11
12
13

  
private void streamTradingAccountTransactions() {
  TradingAccounts tradingAccounts = getTradingAccounts(); (1)
  for (int accountIndex = 0; accountIndex<tradingAccounts.getAccountsCount(); accountIndex++) {
    TradingAccount account = tradingAccounts.getAccounts(accountIndex); (2)
    TradingAccountRequest request = TradingAccountRequest.newBuilder()
        .setAccessToken(accessToken)
        .setTradingAccount(account)
        .build();
    TradingAccountTransactionsObserver observer = (3)
        new TradingAccountTransactionsObserver(request, accountServiceStub);
    accountTransactionsObservers.put(account, observer);
  }
}

  
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

  
import com.consorsbank.module.tapi.grpc.AccountServiceGrpc.AccountServiceStub;
import com.consorsbank.module.tapi.grpc.account.TradingAccount;
import com.consorsbank.module.tapi.grpc.account.TradingAccountRequest;
import com.consorsbank.module.tapi.grpc.account.TradingAccountTransactions;
import com.consorsbank.module.tapi.grpc.account.TradingAccountTransactions.Transaction;
import com.consorsbank.module.tapi.grpc.common.Error;

public class TradingAccountTransactionsObserver extends ServerSubscription<TradingAccount, TradingAccountTransactions>{
  private final AccountServiceStub orderServiceStub;

  public TradingAccountTransactionsObserver(
      TradingAccountRequest request, AccountServiceStub orderServiceStub) {

    this.orderServiceStub = orderServiceStub;
    this.orderServiceStub.streamTradingAccountTransactions(request, this); (1)
  }

  @Override
  public void onCompleted() { (2)
    System.out.println("Call completed!");
  }

  @Override
  public void onNext(TradingAccountTransactions transactions) { (3)
    Error error = transactions.getError(); (4)
    if (error==Error.getDefaultInstance()) {
      System.out.printf("Async trading transactions: %s%n", transactions);
      TradingAccount account = transactions.getAccount();
      List<Transaction> transactionsList = transactions.getTransactionsList();
      // ...
    } else {
      System.out.printf("Error: %s%n", error);
    }
  }
}

  
1
2
3
4
5
6
7
8
9
10

  
private static final Empty EMPTY = Empty.getDefaultInstance();

private final StockExchangeServiceGrpc.StockExchangeServiceBlockingStub stockExchangeServiceBlockingStub;

private StockExchangeDescriptions getStockExchanges() {
  AccessTokenRequest request = AccessTokenRequest.newBuilder()
      .setAccessToken(accessToken)
      .build();
  return stockExchangeServiceBlockingStub.getStockExchanges(request);
}

  
1
2
3
4
5
6
7
8
9
10
11
12

  
private StockExchangeDescription getBaadaStockExchangeInformation() {
  StockExchange stockExchange = StockExchange.newBuilder()
      .setId("OTC")
      .setIssuer("BAAD")
      .build(); (1)

  StockExchangeRequest request = StockExchangeRequest.newBuilder()
      .setAccessToken(accessToken)
      .setStockExchange(stockExchange)
      .build(); (2)
  return stockExchangeServiceBlockingStub.getStockExchange(request); (3)
}

  
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

  
private final DepotServiceGrpc.DepotServiceStub depotServiceStub;

private void streamDepotData() {
  TradingAccounts tradingAccounts = getTradingAccounts(); (1)
  for (int accountIndex = 0; accountIndex<tradingAccounts.getAccountsCount(); accountIndex++) {
    TradingAccount account = tradingAccounts.getAccounts(accountIndex);

    TradingAccountRequest request = TradingAccountRequest.newBuilder()
        .setAccessToken(accessToken)
        .setTradingAccount(account)
        .build();

    DepotObserver depotObserver = new DepotObserver(request, depotServiceStub); (2)
    depotObservers.put(account, depotObserver);
  }
}

  
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

  
public class DepotObserver extends ServerSubscription<TradingAccountRequest, DepotEntries>{
  private final DepotServiceStub serviceStub;

  public DepotObserver(TradingAccountRequest request, DepotServiceStub depotServiceStub) {
    this.serviceStub = depotServiceStub;
    this.serviceStub.streamDepot(request, this); (1)
  }


  @Override
  public void onCompleted() { (2)
    System.out.println("Call completed!");
  }

  @Override
  public void onNext(DepotEntries depotEntries) { (3)
    Error error = depotEntries.getError(); (4)
    if (error==Error.getDefaultInstance()) {
      System.out.printf("Async depot: %s%n", depotEntries);
      TradingAccount account = depotEntries.getAccount();
      List<DepotEntry> entriesList = depotEntries.getEntriesList();
      // ...

    } else {
      System.out.printf("Error: %s%n", error);
    }
  }
}

  
1
2
3
4
5
6

  
public static SecurityCode getSecurityCode(String code, SecurityCodeType codeType) {
  return SecurityCode.newBuilder() (1)
      .setCode(code) (2)
      .setCodeType(codeType==null ? SecurityCodeType.NO_CODE_TYPE : codeType) (3)
      .build(); (4)
}

  
1
2
3
4
5
6
7
8
9
10
11

  
private final SecurityServiceGrpc.SecurityServiceBlockingStub securityServiceBlockingStub;

private SecurityInfoReply requestSecurityInfo(String code, SecurityCodeType securityCodeType) {
  SecurityCode securityCode = TestUtils.getSecurityCode(code, securityCodeType); (1)
  SecurityInfoRequest request = SecurityInfoRequest.newBuilder() (2)
      .setAccessToken(accessToken)
      .setSecurityCode(securityCode) (3)
      .build(); (4)
  SecurityInfoReply response = securityServiceBlockingStub.getSecurityInfo(request); (5)
  return response;
}

  
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

  
private final SecurityServiceGrpc.SecurityServiceStub securityServiceStub;

private MarketDataDataObserver streamMarketData(String code,
    SecurityCodeType securityCodeType, String stockExchangeId, String currency) {

  SecurityWithStockExchange securityWithStockExchange = (1)
      TestUtils.getSecurityWithStockExchange(code, securityCodeType, stockExchangeId, null);

  SecurityMarketDataRequest request =  SecurityMarketDataRequest.newBuilder()
      .setAccessToken(accessToken)
      .setSecurityWithStockexchange(securityWithStockExchange) (2)
      .setCurrency(currency!=null ? currency : "")
      .build();

  MarketDataDataObserver marketDataDataObserver = (3)
      new MarketDataDataObserver(request, securityServiceStub);

  String key = code+"|"+securityCodeType+"|"+stockExchangeId+"|"+currency;
  marketDataObservers.put(key, marketDataDataObserver);
  return marketDataDataObserver;
}

  
1
2
3
4
5
6
7
8

  
public static SecurityWithStockExchange getSecurityWithStockExchange(
    SecurityCode securityCode, StockExchange stockExchange) {

  return SecurityWithStockExchange.newBuilder() (1)
      .setSecurityCode(securityCode) (2)
      .setStockExchange(stockExchange) (3)
      .build(); (4)
}

  
1
2
3
4
5
6
7
8

  
public static StockExchange getStockExchange(String stockExchangeId, String issuer) {
  Builder stockBuilder = StockExchange.newBuilder(); (1)
  if (issuer!=null) {
    stockBuilder.setIssuer(issuer); (2)
  }
  return stockBuilder.setId(stockExchangeId) (3)
      .build(); (4)
}

  
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

  
public class MarketDataDataObserver extends ServerSubscription<SecurityMarketDataRequest, SecurityMarketDataReply> {
  private final SecurityServiceStub securityServiceStub;

  public MarketDataDataObserver(SecurityMarketDataRequest request,
      SecurityServiceStub securityServiceStub) {

    this.securityServiceStub = securityServiceStub;


    securityServiceStub.streamMarketData(request, this); (1)
  }

  @Override
  public void onCompleted() {
    System.out.println("Call completed!"); (2)
  }

  @Override
  public void onNext(SecurityMarketDataReply response) {
    Error error = response.getError();
    if (error==Error.getDefaultInstance()) { (3)
      System.out.printf("Async client onNext: %s%n", response);
      double lastPrice = response.getLastPrice();
      Timestamp lastDateTime = response.getLastDateTime();
      // ...

    } else {
      System.out.printf("Error: %s%n", error);
    }
  }
}

  
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

  
private final SecurityServiceGrpc.SecurityServiceStub securityServiceStub;

private OrderBookDataObserver streamOrderBook(String code,
    SecurityCodeType securityCodeType, String stockExchangeId, String currency) {

  SecurityWithStockExchange securityWithStockExchange =  (1)
      TestUtils.getSecurityWithStockExchange(code, securityCodeType, stockExchangeId, null);

  SecurityOrderBookRequest request = SecurityOrderBookRequest.newBuilder()
      .setAccessToken(accessToken)
      .setSecurityWithStockexchange(securityWithStockExchange)
      .setCurrency(currency==null ? "" : currency)
      .build(); (2)

  OrderBookDataObserver orderBookDataObserver =  (3)
      new OrderBookDataObserver(request, securityServiceStub);

  String key = code+"|"+securityCodeType+"|"+stockExchangeId+"|"+currency;
  orderBookObservers.put(key, orderBookDataObserver);
  return orderBookDataObserver;
}

  
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

  
public class OrderBookDataObserver extends ServerSubscription<SecurityOrderBookRequest, SecurityOrderBookReply> {
  private final SecurityServiceStub securityServiceStub;

  public OrderBookDataObserver(SecurityOrderBookRequest request,
      SecurityServiceStub securityServiceStub) {
    this.securityServiceStub = securityServiceStub;

    securityServiceStub.streamOrderBook(request, this); (1)
  }

  @Override
  public void onCompleted() {
    System.out.println("Call completed!"); (2)
  }

  @Override
  public void onNext(SecurityOrderBookReply response) {
    Error error = response.getError();
    if (error==Error.getDefaultInstance()) {
      System.out.printf("Async client onNext: %s%n", response); (3)
      List<OrderBookEntry> orderBookEntriesList = response.getOrderBookEntriesList();
      for (OrderBookEntry orderBookEntry : orderBookEntriesList) {
        double askPrice = orderBookEntry.getAskPrice();
        double askVolume = orderBookEntry.getAskVolume();
      }
      // ...

    } else {
      System.out.printf("Error: %s%n", error);
    }
  }
}

  
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

  
private final SecurityServiceGrpc.SecurityServiceStub securityServiceStub;

private CurrencyRateDataObserver streamCurrencyRate(String currencyFrom, String currencyTo) {
  CurrencyRateRequest request = CurrencyRateRequest.newBuilder()
      .setAccessToken(accessToken)
      .setCurrencyFrom(currencyFrom)
      .setCurrencyTo(currencyTo)
      .build(); (1)

  CurrencyRateDataObserver currencyRateDataObserver = (2)
      new CurrencyRateDataObserver(request, securityServiceStub);

  String key = currencyFrom+"|"+currencyTo;
  currencyObservers.put(key, currencyRateDataObserver);
  return currencyRateDataObserver;
}

  
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

  
public class CurrencyRateDataObserver extends ServerSubscription<CurrencyRateRequest, CurrencyRateReply> {
  private final SecurityServiceStub securityServiceStub;

  public CurrencyRateDataObserver(CurrencyRateRequest request,
      SecurityServiceStub securityServiceStub) {

    this.securityServiceStub = securityServiceStub;


    securityServiceStub.streamCurrencyRate(request, this); (1)
  }

  @Override
  public void onCompleted() {
    System.out.println("Call completed!"); (2)
  }

  @Override
  public void onNext(CurrencyRateReply response) {
    Error error = response.getError();
    if (error==Error.getDefaultInstance()) {
      System.out.printf("Async client onNext: %s%n", response);
      double currencyRate = response.getCurrencyRate(); (3)
      // ...

    } else {
      System.out.printf("Error: %s%n", error);
    }
  }
}

  
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

  
private final SecurityServiceGrpc.SecurityServiceBlockingStub securityServiceBlockingStub;

private SecurityPriceHistoryReply getSecurityPriceHistory(
    String code, SecurityCodeType securityCodeType, String stockExchangeId,
    int days, TimeResolution resolution) {

  SecurityWithStockExchange securityWithStockExchange =  (1)
      TestUtils.getSecurityWithStockExchange(code, securityCodeType, stockExchangeId, null);
  SecurityPriceHistoryRequest request = SecurityPriceHistoryRequest.newBuilder() (2)
      .setAccessToken(accessToken)
      .setSecurityWithStockexchange(securityWithStockExchange) (3)
      .setDays(days) (4)
      .setTimeResolution(resolution) (5)
      .build(); (6)
  SecurityPriceHistoryReply response =
      securityServiceBlockingStub.getSecurityPriceHistory(request); (7)
  return response;
}

  
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

  
SecurityWithStockExchange securityWithStockExchange = TestUtils.getSecurityWithStockExchange("710000", SecurityCodeType.WKN, "ETR", null);

//
AddOrderRequest addRequest = AddOrderRequest.newBuilder() (1)
    .setOrderModel(OrderModel.ONE_CANCELS_OTHER_MARKET) (2)
    .setAccountNumber(account.getAccountNumber())
    .setSecurityWithStockexchange(securityWithStockExchange)
    .setAmount(1)
    .setValidation(Validation.VALIDATE_ONLY)
    .setLimit(39)
    .setStop(40)
    .setOrderType(OrderType.BUY)
    .setValidityDate(TestUtils.getDate(LocalDate.now())) // today
    .build();
OrderReply addReply = getOrdersBlockingStub().addOrder(addRequest); (3)

  
1
2
3
4
5
6
7
8
9
10
11
12
13
14

  
private final OrderServiceGrpc.OrderServiceStub orderServiceStub;

private void streamOrders() {
  TradingAccounts tradingAccounts = getTradingAccounts(); (1)
  for (int accountIndex = 0; accountIndex<tradingAccounts.getAccountsCount(); accountIndex++) {
    TradingAccount account = tradingAccounts.getAccounts(accountIndex); (2)
    TradingAccountRequest request = TradingAccountRequest.newBuilder()
        .setAccessToken(accessToken)
        .setTradingAccount(account)
        .build();
    OrdersObserver ordersObserver = new OrdersObserver(request, orderServiceStub); (3)
    ordersObservers.put(account, ordersObserver);
  }
}

  
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

  
import com.consorsbank.module.tapi.grpc.OrderServiceGrpc.OrderServiceStub;
import com.consorsbank.module.tapi.grpc.account.TradingAccount;
import com.consorsbank.module.tapi.grpc.account.TradingAccountRequest;
import com.consorsbank.module.tapi.grpc.common.Error;
import com.consorsbank.module.tapi.grpc.order.Order;
import com.consorsbank.module.tapi.grpc.order.Orders;

public class OrdersObserver extends ServerSubscription<TradingAccount, Orders>{
  private final OrderServiceStub orderServiceStub;

  public OrdersObserver(TradingAccountRequest request, OrderServiceStub orderServiceStub) {
    this.orderServiceStub = orderServiceStub;
    this.orderServiceStub.streamOrders(request, this); (1)
  }

  @Override
  public void onCompleted() { (2)
    System.out.println("Call completed!");
  }

  @Override
  public void onNext(Orders orders) { (3)
    Error error = orders.getError(); (4)
    if (error==Error.getDefaultInstance()) {
      System.out.printf("Async orders: %s%n", orders);
      TradingAccount account = orders.getAccount();
      List<Order> ordersList = orders.getOrdersList();
      // ...

    } else {
      System.out.printf("Error: %s%n", error);
    }
  }
}

  
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

  
private void requestQuotesDirect(String code, SecurityCodeType securityCodeType) {
  QuoteRequest quoteRequest = QuoteRequest.newBuilder()
      .setAccessToken(accessToken)
      .setOrderType(OrderType.BUY) (1)
      .setSecurityCode(TestUtils.getSecurityCode(code, securityCodeType)) (2)
      .setAmount(10) (3)
      .addStockExchanges(TestUtils.getStockExchange("BAA", null)) (4)
      .addStockExchanges(TestUtils.getStockExchange("OTC", null))
      .addStockExchanges(TestUtils.getStockExchange("TRG", null))
      .build();
  QuoteReply quoteReply = orderServiceBlockingStub.getQuote(quoteRequest); (5)
  if (quoteReply.getError()!=Error.getDefaultInstance()) {
    List<QuoteEntry> priceEntriesList = quoteReply.getPriceEntriesList(); (6)
    for (QuoteEntry quoteEntry : priceEntriesList) {
      if (quoteEntry.getError()!=Error.getDefaultInstance()) {
        // ...
      }
    }
  }
}

  
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

  
private void requestQuotesAsynchronically(String code, SecurityCodeType securityCodeType) {
  final StreamObserver<QuoteReply> quotesObserver = new StreamObserver<QuoteReply>() { (1)
    @Override
    public void onNext(QuoteReply quoteReply) {
      System.err.println(quoteReply); (2)
      if (quoteReply.getError()!=Error.getDefaultInstance()) {
        List<QuoteEntry> priceEntriesList = quoteReply.getPriceEntriesList();
        // priceEntriesList will contain only one entry
        for (QuoteEntry quoteEntry : priceEntriesList) {
          StockExchange stockExchange = quoteEntry.getStockExchange();
          if (quoteEntry.getError()!=Error.getDefaultInstance()) {
            // ...
          }
        }
      }
    }
    @Override
    public void onError(Throwable t) {
      t.printStackTrace();
    }
    @Override
    public void onCompleted() {}
  };
  final SecurityCode securityCode = TestUtils.getSecurityCode(code, securityCodeType); (3)
  final StockExchange[] stockexchanges = { (4)
      TestUtils.getStockExchange("BAA", null),
      TestUtils.getStockExchange("OTC", null),
      TestUtils.getStockExchange("TRG", null),
  };

  // Request data
  for (StockExchange stockExchange : stockexchanges) {
    QuoteRequest quoteRequest = QuoteRequest.newBuilder() (5)
        .setAccessToken(accessToken)
        .setOrderType(OrderType.BUY)
        .setSecurityCode(securityCode)
        .setAmount(10)
        .addStockExchanges(stockExchange)
        .build();
    orderServiceStub.getQuote(quoteRequest, quotesObserver);
  }

  // ...
}

  
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

  
private void acceptQuote() {
  QuoteRequest quoteRequest = QuoteRequest.newBuilder() (1)
      .setAccessToken(accessToken)
      .setOrderType(OrderType.BUY)
      .setSecurityCode(TestUtils.getSecurityCode("710000", SecurityCodeType.WKN))
      .setAmount(10)
      .addStockExchanges(TestUtils.getStockExchange("OTC", null))
      .build();

  PerformanceCounter pcGetQuote = new PerformanceCounter("GetQuote");
  QuoteReply quoteReply = orderServiceBlockingStub.getQuote(quoteRequest); (2)
  pcGetQuote.print();

  if (quoteReply.getError()==Error.getDefaultInstance()) {
    QuoteEntry quoteEntry = quoteReply.getPriceEntries(0); (3)
    if (quoteEntry.getError()==Error.getDefaultInstance() &&
        !quoteEntry.getQuoteReference().isEmpty()) { (4)
      SecurityWithStockExchange securityWithStockExchange = (5)
          TestUtils.getSecurityWithStockExchange(
              quoteReply.getSecurityCode(), quoteEntry.getStockExchange());

      AcceptQuoteRequest acceptQuoteRequest = AcceptQuoteRequest.newBuilder() (6)
          .setAccessToken(accessToken)
          .setOrderType(OrderType.BUY)
          // .setAccountNumber(accountNumber)
          .setSecurityWithStockexchange(securityWithStockExchange)
          .setAmount(10)
          .setValidation(Validation.VALIDATE_ONLY) (7)
          .setLimit(quoteEntry.getBuyPrice())
          .setQuoteReference(quoteEntry.getQuoteReference()) (8)
          .build();
      OrderReply acceptQuote = orderServiceBlockingStub.acceptQuote(acceptQuoteRequest); (9)
      System.err.println(acceptQuote);
    }
  }
}

  
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

  
private final OrderServiceGrpc.OrderServiceBlockingStub orderServiceBlockingStub;

private OrderReply addOrder() {
  SecurityCode securityCode = TestUtils.getSecurityCode("710000", SecurityCodeType.WKN); (1)
  StockExchange stockExchange = TestUtils.getStockExchange("OTC", null); (2)
  SecurityWithStockExchange securityWithStockExchange =
      TestUtils.getSecurityWithStockExchange(securityCode, stockExchange); (3)
  AddOrderRequest request = AddOrderRequest.newBuilder() (4)
      .setAccessToken(accessToken)
      .setAccountNumber("123456789") (5)
      .setSecurityWithStockexchange(securityWithStockExchange)
      .setValidation(Validation.VALIDATE_ONLY) (6)
      .setAmount(1)
      .setOrderModel(OrderModel.LIMIT) (7)
      .setLimit(1)
      .setOrderType(OrderType.BUY) (8)
      .setCashQuotation(CashQuotation.KASSA)
      .setValidityDate(TestUtils.getDate(GregorianCalendar.getInstance()))
      .build();
  OrderReply addOrderReply = orderServiceBlockingStub.addOrder(request); (9)
  System.err.println(addOrderReply);
  return addOrderReply;
}

  
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

  
private final OrderServiceGrpc.OrderServiceBlockingStub orderServiceBlockingStub;

private void changeOrder(Order order, TradingAccount account) {
  if (order!=null) {
    String orderNumber = order.getOrderNumber();
    if (orderNumber!=null && !orderNumber.isEmpty()) {
      ChangeOrderRequest changeOrderRequest = ChangeOrderRequest.newBuilder()
          .setAccessToken(accessToken)
          .setAccountNumber(account.getAccountNumber()) (1)
          .setOrderNumber(order.getOrderNumber()) (2)
          .setValidation(Validation.VALIDATE_ONLY) (3)
          .setOrderModel(OrderModel.LIMIT) (4)
          .setLimit(2)
          .build();

      OrderReply changeOrderReply = (5)
          orderServiceBlockingStub.changeOrder(changeOrderRequest);
      System.out.println(changeOrderReply);
    }
  }
}

  
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

  
private final OrderServiceGrpc.OrderServiceBlockingStub orderServiceBlockingStub;

private void cancelOrder(Order order, TradingAccount account) {
  if (order!=null) {
    String orderNumber = order.getOrderNumber();
    if (orderNumber!=null && !orderNumber.isEmpty()) {
      CancelOrderRequest cancelOrderRequest = CancelOrderRequest.newBuilder()
          .setAccessToken(accessToken)
          .setAccountNumber(account.getAccountNumber()) (1)
          .setOrderNumber(order.getOrderNumber()) (2)
          .setValidation(Validation.VALIDATE_ONLY) (3)
          .build();

      OrderReply cancelOrderReply = (4)
          orderServiceBlockingStub.cancelOrder(cancelOrderRequest);
      System.out.println(cancelOrderReply);
    }
  }
}

  
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

  
private final OrderServiceGrpc.OrderServiceBlockingStub orderServiceBlockingStub;

private void activateOrder(Order order, TradingAccount account) {
  if (order!=null) {
    String orderNumber = order.getOrderNumber();
    if (orderNumber!=null && !orderNumber.isEmpty()) {
      ActivateOrderRequest activateOrderRequest = ActivateOrderRequest.newBuilder()
          .setAccessToken(accessToken)
          .setAccountNumber(account.getAccountNumber()) (1)
          .setOrderNumber(order.getOrderNumber()) (2)
          .setValidation(Validation.VALIDATE_ONLY) (3)
          .build();

      OrderReply changeOrderReply =  (4)
          orderServiceBlockingStub.activateOrder(activateOrderRequest);
      System.out.println(changeOrderReply);
    }
  }
}

  
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

  
private final OrderServiceGrpc.OrderServiceBlockingStub orderServiceBlockingStub;

private void deactivateOrder(Order order, TradingAccount account) {
  if (order!=null) {
    String orderNumber = order.getOrderNumber();
    if (orderNumber!=null && !orderNumber.isEmpty()) {
      DeactivateOrderRequest deactivateOrderRequest = DeactivateOrderRequest.newBuilder()
          .setAccessToken(accessToken)
          .setAccountNumber(account.getAccountNumber()) (1)
          .setOrderNumber(order.getOrderNumber()) (2)
          .setValidation(Validation.VALIDATE_ONLY) (3)
          .build();

      OrderReply changeOrderReply = (4)
          orderServiceBlockingStub.deactivateOrder(deactivateOrderRequest);
      System.out.println(changeOrderReply);
    }
  }
}