1 package org.oxerr.chbtc;
2
3 import java.math.BigDecimal;
4 import java.math.RoundingMode;
5 import java.util.ArrayList;
6 import java.util.Collections;
7 import java.util.Date;
8 import java.util.LinkedHashMap;
9 import java.util.List;
10 import java.util.Map;
11
12 import org.apache.commons.lang3.math.NumberUtils;
13 import org.oxerr.chbtc.dto.Balance;
14 import org.oxerr.chbtc.dto.Depth;
15 import org.oxerr.chbtc.dto.Order;
16 import org.oxerr.chbtc.dto.Result;
17 import org.oxerr.chbtc.dto.TickerResponse;
18 import org.oxerr.chbtc.dto.Type;
19
20 import com.xeiam.xchange.currency.Currencies;
21 import com.xeiam.xchange.currency.CurrencyPair;
22 import com.xeiam.xchange.dto.Order.OrderType;
23 import com.xeiam.xchange.dto.account.AccountInfo;
24 import com.xeiam.xchange.dto.marketdata.OrderBook;
25 import com.xeiam.xchange.dto.marketdata.Ticker;
26 import com.xeiam.xchange.dto.marketdata.Trade;
27 import com.xeiam.xchange.dto.marketdata.Trades;
28 import com.xeiam.xchange.dto.marketdata.Trades.TradeSortType;
29 import com.xeiam.xchange.dto.trade.LimitOrder;
30 import com.xeiam.xchange.dto.trade.UserTrade;
31 import com.xeiam.xchange.dto.trade.UserTrades;
32 import com.xeiam.xchange.dto.trade.Wallet;
33
34
35
36
37 public class CHBTCAdapters {
38
39
40
41
42 private CHBTCAdapters() {
43 }
44
45 public static Type adaptType(OrderType orderType) {
46 return orderType == OrderType.BID ? Type.BUY : Type.SELL;
47 }
48
49 public static OrderType adaptOrderType(int type) {
50 return adaptOrderType(Type.toType(type));
51 }
52
53 public static OrderType adaptOrderType(String type) {
54 return adaptOrderType(Type.toType(type));
55 }
56
57 public static OrderType adaptOrderType(Type type) {
58 return type == Type.BUY ? OrderType.BID : OrderType.ASK;
59 }
60
61 public static String adaptCurrency(CurrencyPair currencyPair) {
62 return currencyPair.baseSymbol.toLowerCase();
63 }
64
65 public static Ticker adaptTicker(TickerResponse tickerResponse,
66 CurrencyPair currencyPair) {
67 return new Ticker.Builder()
68 .currencyPair(currencyPair)
69 .high(tickerResponse.getTicker().getHigh())
70 .low(tickerResponse.getTicker().getLow())
71 .bid(tickerResponse.getTicker().getBuy())
72 .ask(tickerResponse.getTicker().getSell())
73 .last(tickerResponse.getTicker().getLast())
74 .volume(tickerResponse.getTicker().getVol())
75 .build();
76 }
77
78 public static OrderBook adaptOrderBook(Depth depth, CurrencyPair currencyPair) {
79 List<LimitOrder> asks = adaptLimitOrders(OrderType.ASK, depth.getAsks(), currencyPair);
80 Collections.sort(asks);
81
82 List<LimitOrder> bids = adaptLimitOrders(OrderType.BID, depth.getBids(), currencyPair);
83 Collections.sort(bids);
84
85 return new OrderBook(null, asks, bids);
86 }
87
88 public static Trades adaptTrades(org.oxerr.chbtc.dto.Trade[] trades,
89 CurrencyPair currencyPair) {
90 List<Trade> tradeList = new ArrayList<>(
91 trades.length);
92 for (org.oxerr.chbtc.dto.Trade trade : trades) {
93 tradeList.add(adaptTrade(trade, currencyPair));
94 }
95 long lastTid = trades.length > 0
96 ? NumberUtils.toLong(trades[trades.length - 1].getTid())
97 : 0L;
98 return new Trades(tradeList, lastTid, TradeSortType.SortByTimestamp);
99 }
100
101 public static AccountInfo adaptAccountInfo(
102 org.oxerr.chbtc.dto.AccountInfo accountInfo) {
103 Result result = accountInfo.getResult();
104 Map<String, Balance> balance = result.getBalance();
105 Map<String, Balance> frozen = result.getFrozen();
106
107 Map<String, BigDecimal> balances = new LinkedHashMap<>(
108 Math.max(balance.size(), frozen.size()));
109
110 addBalance(balance, balances);
111 addBalance(frozen, balances);
112
113 List<Wallet> wallets = new ArrayList<Wallet>(balances.size());
114 for (Map.Entry<String, BigDecimal> entry : balances.entrySet()) {
115 wallets.add(new Wallet(entry.getKey(), entry.getValue()));
116 }
117
118 return new AccountInfo(result.getBase().getUsername(), wallets);
119 }
120
121 public static List<LimitOrder> adaptLimitOrders(Order[] orders) {
122 List<LimitOrder> limitOrders = new ArrayList<>(orders.length);
123 for (Order order : orders) {
124 limitOrders.add(adaptLimitOrder(order));
125 }
126 return limitOrders;
127 }
128
129 public static UserTrades adaptUserTrades(Order order, int priceScale) {
130 return adaptUserTrades(new Order[] { order }, priceScale);
131 }
132
133 public static UserTrades adaptUserTrades(Order[] orders, int priceScale) {
134 List<UserTrade> userTrades = new ArrayList<>(orders.length);
135 for (Order order : orders) {
136 userTrades.add(adaptUserTrade(order, priceScale));
137 }
138 return new UserTrades(userTrades, TradeSortType.SortByTimestamp);
139 }
140
141 private static List<LimitOrder> adaptLimitOrders(
142 OrderType type,
143 BigDecimal[][] list,
144 CurrencyPair currencyPair) {
145 List<LimitOrder> limitOrders = new ArrayList<>(list.length);
146 for (BigDecimal[] data : list) {
147 limitOrders.add(adaptLimitOrder(type, data, currencyPair));
148 }
149 return limitOrders;
150 }
151
152 private static LimitOrder adaptLimitOrder(
153 OrderType type,
154 BigDecimal[] data,
155 CurrencyPair currencyPair) {
156 return new LimitOrder(
157 type,
158 data[1],
159 currencyPair,
160 null,
161 null,
162 data[0]);
163 }
164
165 private static LimitOrder adaptLimitOrder(Order order) {
166 BigDecimal tradableAmount = order.getTotalAmount().subtract(order.getTradeAmount());
167 String currency = order.getCurrency();
168 CurrencyPair currencyPair = new CurrencyPair(currency.toUpperCase(), Currencies.CNY);
169
170 return new LimitOrder(
171 adaptOrderType(order.getType()),
172 tradableAmount,
173 currencyPair,
174 String.valueOf(order.getId()),
175 new Date(order.getTradeDate()),
176 order.getPrice());
177 }
178
179 private static Trade adaptTrade(
180 org.oxerr.chbtc.dto.Trade trade, CurrencyPair currencyPair) {
181 return new Trade(
182 adaptOrderType(trade.getType()),
183 trade.getAmount(),
184 currencyPair,
185 trade.getPrice(),
186 new Date(Long.parseLong(trade.getDate()) * 1000),
187 trade.getTid());
188 }
189
190 private static UserTrade adaptUserTrade(Order order, int priceScale) {
191 String currency = order.getCurrency();
192 CurrencyPair currencyPair = new CurrencyPair(currency.toUpperCase(), Currencies.CNY);
193 BigDecimal price = order.getTradeAmount().compareTo(BigDecimal.ZERO) > 0
194 ? order.getTradeMoney().divide(
195 order.getTradeAmount(),
196 priceScale,
197 RoundingMode.HALF_EVEN)
198 : BigDecimal.ZERO;
199 return new UserTrade(
200 adaptOrderType(order.getType()),
201 order.getTradeAmount(),
202 currencyPair,
203 price,
204 new Date(order.getTradeDate()),
205 null,
206 String.valueOf(order.getId()),
207 null,
208 null
209 );
210 }
211
212 private static void addBalance(Map<String, Balance> from,
213 Map<String, BigDecimal> to) {
214 for (Map.Entry<String, Balance> entry : from.entrySet()) {
215 String currency = entry.getKey();
216 BigDecimal amount = entry.getValue().getAmount();
217 BigDecimal previous = to.get(currency);
218 if (previous == null) {
219 to.put(currency, amount);
220 } else {
221 to.put(currency, previous.add(amount));
222 }
223 }
224 }
225
226 }