Merge branch 'JacobHanouna-master'

js/base/Exchange.js

@@ -1059,6 +1059,17 @@ module.exports = class Exchange {
         }
     }
 
+    mdy (timestamp, infix = '-') {
+        infix = infix || ''
+        let date = new Date (timestamp)
+        let Y = date.getUTCFullYear ().toString ()
+        let m = date.getUTCMonth () + 1
+        let d = date.getUTCDate ()
+        m = m < 10 ? ('0' + m) : m.toString ()
+        d = d < 10 ? ('0' + d) : d.toString ()
+        return m + infix + d + infix + y
+    }
+
     ymd (timestamp, infix = '-') {
         infix = infix || ''
         let date = new Date (timestamp)

js/bit2c.js

@@ -17,6 +17,7 @@ module.exports = class bit2c extends Exchange {
             'has': {
                 'CORS': false,
                 'fetchOpenOrders': true,
+                'fetchMyTrades': true,
             },
             'urls': {
                 'logo': 'https://user-images.githubusercontent.com/1294454/27766119-3593220e-5ece-11e7-8b3a-5a041f6bcc3f.jpg',
@@ -134,25 +135,6 @@ module.exports = class bit2c extends Exchange {
         };
     }
 
-    parseTrade (trade, market = undefined) {
-        let timestamp = parseInt (trade['date']) * 1000;
-        let symbol = undefined;
-        if (market)
-            symbol = market['symbol'];
-        return {
-            'id': trade['tid'].toString (),
-            'info': trade,
-            'timestamp': timestamp,
-            'datetime': this.iso8601 (timestamp),
-            'symbol': symbol,
-            'order': undefined,
-            'type': undefined,
-            'side': undefined,
-            'price': trade['price'],
-            'amount': trade['amount'],
-        };
-    }
-
     async fetchTrades (symbol, since = undefined, limit = undefined, params = {}) {
         let market = this.market (symbol);
         let response = await this.publicGetExchangesPairTrades (this.extend ({
@@ -252,4 +234,86 @@ module.exports = class bit2c extends Exchange {
             'info': order,
         };
     }
+
+    async fetchMyTrades (symbol = undefined, since = undefined, limit = undefined, params = {}) {
+        await this.loadMarkets ();
+        let market = undefined;
+        let method = 'privateGetOrderOrderhistory';
+        let request = {};
+        if (typeof limit !== 'undefined')
+            request['take'] = limit;
+        request['take'] = limit;
+        if (typeof since !== 'undefined') {
+            request['toTime'] = this.ymd (this.milliseconds (), '.');
+            request['fromTime'] = this.ymd (since, '.');
+        }
+        if (typeof symbol !== 'undefined') {
+            market = this.market (symbol);
+            request['pair'] = market['id'];
+        }
+        let response = await this[method] (this.extend (request, params));
+        return this.parseTrades (response, market, since, limit);
+    }
+
+    parseTrade (trade, market = undefined) {
+        let timestamp = undefined;
+        let id = undefined;
+        let price = undefined;
+        let amount = undefined;
+        let orderId = undefined;
+        let feeCost = undefined;
+        let side = undefined;
+        let reference = this.safeString (trade, 'reference');
+        if (typeof reference !== 'undefined') {
+            timestamp = this.safeInteger (trade, 'ticks') * 1000;
+            price = this.safeFloat (trade, 'price');
+            amount = this.safeFloat (trade, 'firstAmount');
+            let reference_parts = reference.split ('|'); // reference contains: 'pair|orderId|tradeId'
+            if (typeof market === 'undefined') {
+                let marketId = this.safeString (trade, 'pair');
+                if (marketId in this.markets_by_id[marketId]) {
+                    market = this.markets_by_id[marketId];
+                } else if (reference_parts[0] in this.markets_by_id) {
+                    market = this.markets_by_id[reference_parts[0]];
+                }
+            }
+            orderId = reference_parts[1];
+            id = reference_parts[2];
+            side = this.safeInteger (trade, 'action');
+            if (side === 0) {
+                side = 'buy';
+            } else if (side === 1) {
+                side = 'sell';
+            }
+            feeCost = this.safeFloat (trade, 'feeAmount');
+        } else {
+            timestamp = this.safeInteger (trade, 'date') * 1000;
+            id = this.safeInteger (trade, 'tid');
+            price = this.safeFloat (trade, 'price');
+            amount = this.safeFloat (trade, 'amount');
+        }
+        let symbol = undefined;
+        if (typeof market !== 'undefined')
+            symbol = market['symbol'];
+        return {
+            'info': trade,
+            'id': id,
+            'timestamp': timestamp,
+            'datetime': this.iso8601 (timestamp),
+            'symbol': symbol,
+            'order': orderId,
+            'type': undefined,
+            'side': side,
+            'takerOrMaker': undefined,
+            'price': price,
+            'amount': amount,
+            'cost': price * amount,
+            'fee': {
+                'cost': feeCost,
+                'currency': 'NIS',
+                'rate': undefined,
+            },
+        };
+    }
 };
+

php/Exchange.php

@@ -509,6 +509,10 @@ public static function parse8601 ($timestamp) {
         return $time;
     }
 
+    public static function dmy ($timestamp, $infix = '-') {
+        return gmdate ('m' . $infix . 'd' . $infix . 'Y', (int) round ($timestamp / 1000));
+    }
+
     public static function ymd ($timestamp, $infix = '-') {
         return gmdate ('Y' . $infix . 'm' . $infix . 'd', (int) round ($timestamp / 1000));
     }

python/ccxt/base/exchange.py

@@ -671,6 +671,11 @@ def iso8601(timestamp):
         utc = datetime.datetime.utcfromtimestamp(int(round(timestamp / 1000)))
         return utc.strftime('%Y-%m-%dT%H:%M:%S.%f')[:-6] + "{:<03d}".format(int(timestamp) % 1000) + 'Z'
 
+    @staticmethod
+    def dmy(timestamp, infix='-'):
+        utc_datetime = datetime.datetime.utcfromtimestamp(int(round(timestamp / 1000)))
+        return utc_datetime.strftime('%m' + infix + '%d' + infix + '%Y')
+
     @staticmethod
     def ymd(timestamp, infix='-'):
         utc_datetime = datetime.datetime.utcfromtimestamp(int(round(timestamp / 1000)))

python/ccxt/bit2c.py

@@ -6,7 +6,7 @@
 from ccxt.base.exchange import Exchange
 import hashlib
 from ccxt.base.errors import ExchangeError
-
+import datetime
 
 class bit2c (Exchange):
 
@@ -19,6 +19,7 @@ def describe(self):
             'has': {
                 'CORS': False,
                 'fetchOpenOrders': True,
+                'fetchMyTrades': True,
             },
             'urls': {
                 'logo': 'https://user-images.githubusercontent.com/1294454/27766119-3593220e-5ece-11e7-8b3a-5a041f6bcc3f.jpg',
@@ -238,3 +239,82 @@ def parse_order(self, order, market=None):
             'fee': None,
             'info': order,
         }
+
+    def fetch_my_trades(self, symbol=None, since=None, limit=None, params={}):
+        self.load_markets()
+        market = None
+
+        method = 'privateGetOrderOrderhistory'
+        toTime = datetime.datetime.now()
+        fromTime = datetime.datetime.fromtimestamp(since)
+
+        request = {}
+        request['take'] = limit
+        if since is not None:
+            request['toTime'] = toTime.strftime('%m.%d.%Y')     
+            request['fromTime'] = fromTime.strftime('%m.%d.%Y')        
+
+        if symbol is not None:
+            market = self.market(symbol)
+            request['pair'] = market['id']
+
+        response = getattr(self, method)(self.extend(request, params))
+        return self.parse_trades(response, market, since, limit)
+
+    def parse_trade(self, trade, market=None):
+        timestamp = None
+        id = None
+        price = None
+        amount = None
+        orderId = None
+        feeCost = None
+        side = None
+        symbol = market['symbol'] if market is not None else None
+
+        # Private Trade
+        if('reference' in trade):
+            timestamp = self.safe_integer(trade, 'ticks') * 1000
+            price = self.safe_float(trade, 'price')
+            amount = self.safe_float(trade, 'firstAmount')
+            if(symbol is None):
+                marketId = self.safe_string(trade, 'pair')
+                symbol = [self.markets[market]['symbol'] for market in self.markets if self.markets[market]['id'] == marketId][0]
+
+            reference = self.safe_string(trade, 'reference').split('|') # reference contain: 'pair|orderId|tradeId'
+            orderId = reference[1]
+            id = reference[2]
+
+            action = self.safe_integer(trade, 'action')
+            if action == 0:
+                side = 'buy'
+            elif action == 1:
+                side = 'sell'
+
+            feeCost = self.safe_float(trade, 'feeAmount')
+
+        # Public Trade
+        else:
+            timestamp = self.safe_integer(trade, 'date') * 1000
+            id = self.safe_integer(trade, 'tid')
+            price = self.safe_float(trade, 'price')
+            amount = self.safe_float(trade, 'amount')
+
+        return  {
+            'info': trade,
+            'id': id,          
+            'timestamp': timestamp,
+            'datetime': self.iso8601(timestamp),
+            'symbol': symbol,
+            'order': orderId,
+            'type': None,
+            'side': side,
+            'takerOrMaker': None,
+            'price': price,
+            'amount': amount,
+            'cost': price * amount,
+            'fee': {
+                'cost': feeCost,
+                'currency': 'NIS',
+                'rate': None,
+            },
+        }