├── .dockerignore
├── .gitignore
├── API
    ├── APIServer.py
    ├── Endpoints
    │   ├── APIexchangeInfoEndpoint.py
    │   ├── BalanceEndpoint.py
    │   ├── BotAPIResource.py
    │   ├── JWTEndpoint.py
    │   ├── LogsEndpoint.py
    │   ├── OrderBookEndpoint.py
    │   ├── ProxyEndpoint.py
    │   ├── TradeEndpoint.py
    │   ├── TradeListEndpoint.py
    │   └── __init__.py
    ├── Entities
    │   ├── APIResult.py
    │   └── __init__.py
    └── __init__.py
├── Bot
    ├── AccountBalances.py
    ├── ConfigLoader.py
    ├── CustomSerializable.py
    ├── EntryExitSettings.py
    ├── Exchange
    │   └── Binance
    │   │   └── BinanceWebsocket.py
    ├── ExchangeInfo.py
    ├── FXConnector.py
    ├── JsonEncoder.py
    ├── StopLossSettings.py
    ├── Strategy
    │   ├── EntryStrategy.py
    │   ├── PlaceOrderStrategy.py
    │   ├── SmartOrder.py
    │   ├── StopLossStrategy.py
    │   ├── TargetsAndStopLossStrategy.py
    │   ├── TradingStrategy.py
    │   └── __init__.py
    ├── Target.py
    ├── Trade.py
    ├── TradeEnums.py
    ├── TradeHandler.py
    ├── TradeValidator.py
    ├── Value.py
    └── __init__.py
├── BotVersion.py
├── Cloud
    ├── S3Sync.py
    └── __init__.py
├── ConsoleLauncher.py
├── Docker
    ├── Dockerfile-allinone
    ├── Dockerfile-botapi
    ├── Dockerfile-fe
    ├── Dockerfile-nginx
    ├── nginx-nossl.conf
    └── nginx-ssl.conf
├── Dockerfile
├── Docs
    ├── API.md
    ├── FLOW.md
    ├── SETUP.md
    ├── TRADE_FILE.md
    ├── TRADE_FILE_EXAMPLES.md
    ├── edit_view.png
    ├── grid_view.png
    └── uf.png
├── LICENSE.md
├── README.md
├── Trades
    └── TRADE_TEMPLATE.TPL
├── Utils
    ├── Logger.py
    ├── Utils.py
    └── __init__.py
├── __init__.py
├── admin
    ├── .browserslistrc
    ├── .editorconfig
    ├── .gitignore
    ├── README.md
    ├── angular.json
    ├── e2e
    │   ├── protractor.conf.js
    │   ├── src
    │   │   ├── app.e2e-spec.ts
    │   │   └── app.po.ts
    │   └── tsconfig.e2e.json
    ├── package-lock.json
    ├── package.json
    ├── src
    │   ├── app
    │   │   ├── apiresult.ts
    │   │   ├── app.component.css
    │   │   ├── app.component.html
    │   │   ├── app.component.spec.ts
    │   │   ├── app.component.ts
    │   │   ├── app.module.ts
    │   │   ├── asset-table
    │   │   │   ├── asset-table.component.css
    │   │   │   ├── asset-table.component.html
    │   │   │   ├── asset-table.component.spec.ts
    │   │   │   └── asset-table.component.ts
    │   │   ├── auth.interceptor.ts
    │   │   ├── auth.service.ts
    │   │   ├── auto-complete
    │   │   │   ├── auto-complete.component.css
    │   │   │   ├── auto-complete.component.html
    │   │   │   ├── auto-complete.component.spec.ts
    │   │   │   └── auto-complete.component.ts
    │   │   ├── balance.spec.ts
    │   │   ├── balance.ts
    │   │   ├── balances
    │   │   │   ├── balances.component.css
    │   │   │   ├── balances.component.html
    │   │   │   ├── balances.component.spec.ts
    │   │   │   └── balances.component.ts
    │   │   ├── binance.service.spec.ts
    │   │   ├── binance.service.ts
    │   │   ├── botapi.ts
    │   │   ├── log-entry.spec.ts
    │   │   ├── log-entry.ts
    │   │   ├── log-in
    │   │   │   ├── log-in.component.css
    │   │   │   ├── log-in.component.html
    │   │   │   ├── log-in.component.spec.ts
    │   │   │   └── log-in.component.ts
    │   │   ├── logs
    │   │   │   ├── logs.component.css
    │   │   │   ├── logs.component.html
    │   │   │   ├── logs.component.spec.ts
    │   │   │   └── logs.component.ts
    │   │   ├── main-tabs
    │   │   │   ├── main-tabs.component.css
    │   │   │   ├── main-tabs.component.html
    │   │   │   ├── main-tabs.component.spec.ts
    │   │   │   └── main-tabs.component.ts
    │   │   ├── options-scroll.directive.ts
    │   │   ├── services
    │   │   │   └── notification.service.ts
    │   │   ├── trade-details.ts
    │   │   ├── trade-details
    │   │   │   ├── entry-details.component.html
    │   │   │   ├── entry-details.component.ts
    │   │   │   ├── exit-details.component.html
    │   │   │   ├── exit-details.component.ts
    │   │   │   ├── sl-details.component.html
    │   │   │   ├── sl-details.component.ts
    │   │   │   ├── symbol-validator.ts
    │   │   │   ├── trade-details.component.css
    │   │   │   ├── trade-details.component.html
    │   │   │   ├── trade-details.component.spec.ts
    │   │   │   └── trade-details.component.ts
    │   │   ├── trade.service.ts
    │   │   ├── tradeInfo.ts
    │   │   ├── trades-routing.module.ts
    │   │   ├── websocket.service.spec.ts
    │   │   └── websocket.service.ts
    │   ├── assets
    │   │   └── .gitkeep
    │   ├── environments
    │   │   ├── environment.prod.ts
    │   │   ├── environment.test.ts
    │   │   └── environment.ts
    │   ├── favicon.ico
    │   ├── index.html
    │   ├── karma.conf.js
    │   ├── main.ts
    │   ├── polyfills.ts
    │   ├── styles.css
    │   ├── test.ts
    │   ├── tsconfig.app.json
    │   ├── tsconfig.spec.json
    │   └── tslint.json
    ├── tsconfig.json
    └── tslint.json
├── binance_ws_recoonect_test.py
├── docker-compose-nginx.yml
├── docker-compose.yml
├── main.py
└── requirements.txt


/.dockerignore:
--------------------------------------------------------------------------------
 1 | .idea
 2 | api.json
 3 | **/*.crt
 4 | **/*.key
 5 | /Conf
 6 | /venv
 7 | /Trades/Portfolio
 8 | /Trades/Portfolio/*
 9 | /Trades/Completed
10 | /Trades/Completed/*
11 | /Trades/Potential
12 | /Trades/Potential/*
13 | /admin/node_modules


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
 1 | .idea
 2 | .vscode
 3 | **/.env
 4 | api.json
 5 | /Conf/*
 6 | /venv
 7 | /logs
 8 | /Trades/Portfolio
 9 | /Trades/Portfolio/*
10 | /Trades/Completed
11 | /Trades/Completed/*
12 | /Trades/Potential
13 | /Trades/Potential/*
14 | sync_trades*.sh
15 | **/*.pyc
16 | 


--------------------------------------------------------------------------------
/API/APIServer.py:
--------------------------------------------------------------------------------
 1 | from datetime import datetime, timedelta
 2 | from distutils.log import Log
 3 | 
 4 | from flask import Flask, app, render_template
 5 | from flask_jwt_extended import JWTManager
 6 | from flask_restful import Api
 7 | from flask_cors import CORS
 8 | 
 9 | from API.Endpoints.LogsEndpoint import LogsEndpoint
10 | from API.Endpoints.APIexchangeInfoEndpoint import APIExchangeInfoEndpoint
11 | from API.Endpoints.BalanceEndpoint import BalanceEndpoint
12 | from API.Endpoints.JWTEndpoint import JWTEndpoint
13 | from API.Endpoints.OrderBookEndpoint import OrderBookEndpoint
14 | from API.Endpoints.ProxyEndpoint import ProxyEndpoint
15 | from API.Endpoints.TradeEndpoint import TradeEndpoint
16 | from API.Endpoints.TradeListEndpoint import TradeListEndpoint
17 | from Bot.TradeHandler import TradeHandler
18 | 
19 | app = Flask(__name__, static_folder='templates', static_url_path='')
20 | 
21 | @app.route('/')
22 | @app.route('/trades')
23 | def index():
24 |     return render_template('index.html')
25 | 
26 | class APIServer:
27 |     VERSION = 'v1'
28 |     API_PREFIX = '/api/'+VERSION
29 | 
30 |     def __init__(self, trade_handler: TradeHandler):
31 |         self.th = trade_handler
32 |         self.app = app
33 | 
34 |         self.app.config['JWT_SECRET_KEY'] = 'mHZ!?9@DzdLrn@H!gy2FD46W--M*Fap!'  # TODO: Change this!
35 |         self.app.config['SECRET_KEY'] = 'VS?cWpbD^CGa-M@h6+@pV#qCQRU3c4dn'  #  TODO: Change this!
36 |         self.app.config['JWT_ACCESS_TOKEN_EXPIRES'] = timedelta(weeks=48)
37 | 
38 |         self.jwt = JWTManager(app)
39 | 
40 |         self.api = Api(self.app)
41 | 
42 |         CORS(self.app)
43 |         # self.api.add_resource(BalanceEndpoint, APIServer.API_PREFIX + '/balance',
44 |         #                       resource_class_kwargs={'trade_handler': self.th})
45 | 
46 |         self.api.add_resource(ProxyEndpoint, APIServer.API_PREFIX + '/proxy/icon',
47 |                               resource_class_kwargs={'trade_handler': self.th})
48 | 
49 |         self.api.add_resource(LogsEndpoint, APIServer.API_PREFIX + '/logs',
50 |                               resource_class_kwargs={'trade_handler': self.th})
51 | 
52 |         self.api.add_resource(OrderBookEndpoint, APIServer.API_PREFIX + '/orderbook/<symbol>',
53 |                               resource_class_kwargs={'trade_handler': self.th})
54 | 
55 |         self.api.add_resource(BalanceEndpoint, APIServer.API_PREFIX + '/balance/<force>',
56 |                               resource_class_kwargs={'trade_handler': self.th})
57 | 
58 |         self.api.add_resource(TradeListEndpoint, APIServer.API_PREFIX + '/trades',
59 |                               resource_class_kwargs={'trade_handler': self.th})
60 | 
61 |         self.api.add_resource(TradeEndpoint, APIServer.API_PREFIX + '/trade/<id>',
62 |                               resource_class_kwargs={'trade_handler': self.th})
63 | 
64 |         self.api.add_resource(APIExchangeInfoEndpoint, APIServer.API_PREFIX + '/info',
65 |                               resource_class_kwargs={'trade_handler': self.th})
66 | 
67 |         self.api.add_resource(JWTEndpoint, APIServer.API_PREFIX + '/auth',
68 |                               resource_class_kwargs={'trade_handler': self.th})
69 | 
70 |     def run(self, port):
71 |         self.app.run(host='0.0.0.0', debug=True, port=port, use_reloader=False)
72 | 
73 | 
74 | 


--------------------------------------------------------------------------------
/API/Endpoints/APIexchangeInfoEndpoint.py:
--------------------------------------------------------------------------------
 1 | from flask_jwt_extended import jwt_required
 2 | 
 3 | from API.Endpoints.BotAPIResource import BotAPIResource
 4 | from API.Entities.APIResult import APIResult
 5 | from Bot.ExchangeInfo import ExchangeInfo
 6 | 
 7 | 
 8 | class APIExchangeInfoEndpoint(BotAPIResource):
 9 |     @jwt_required()
10 |     def get(self):
11 |         return list(ExchangeInfo().get_all_symbols())
12 | 
13 |     @jwt_required()
14 |     def post(self):
15 |         args = self.parser.parse_args()
16 |         action = args['action']
17 | 
18 |         if not action:
19 |             return APIResult.ErrorResult(100, msg='No "action" was provided'), 403
20 | 
21 |         if action == 'reconnect':
22 |             self.th.force_reconnect_sockets()


--------------------------------------------------------------------------------
/API/Endpoints/BalanceEndpoint.py:
--------------------------------------------------------------------------------
 1 | from API.Endpoints.BotAPIResource import BotAPIResource
 2 | from flask_jwt_extended import jwt_required
 3 | 
 4 | 
 5 | class BalanceEndpoint(BotAPIResource):
 6 | 
 7 |     @jwt_required()
 8 |     def get(self, force='0'):
 9 |         if force == '1':
10 |             self.th.balances.update_balances(self.th.fx.get_all_balances_dict())
11 | 
12 |         return self.th.balances.bal_dict
13 | 


--------------------------------------------------------------------------------
/API/Endpoints/BotAPIResource.py:
--------------------------------------------------------------------------------
 1 | from flask_restful import Resource
 2 | 
 3 | from Bot.TradeHandler import TradeHandler
 4 | from Utils.Logger import Logger
 5 | 
 6 | 
 7 | class BotAPIResource(Resource, Logger):
 8 |     def __init__(self, trade_handler: TradeHandler):
 9 |         Resource.__init__(self)
10 |         Logger.__init__(self)
11 |         self.th: TradeHandler = trade_handler


--------------------------------------------------------------------------------
/API/Endpoints/JWTEndpoint.py:
--------------------------------------------------------------------------------
 1 | import os
 2 | from calendar import timegm
 3 | from datetime import datetime
 4 | 
 5 | import flask
 6 | from flask import request
 7 | from flask_jwt_extended import create_access_token, jwt_required, get_jwt_identity
 8 | 
 9 | from API.Entities.APIResult import APIResult
10 | from API.Endpoints.BotAPIResource import BotAPIResource
11 | 
12 | 
13 | class JWTEndpoint(BotAPIResource):
14 |     user: str = os.getenv('API_USER', 'bot')
15 |     pwd: str = os.getenv('API_PASS', 'botpwd')
16 | 
17 |     def __init__(self, trade_handler):
18 |         super().__init__(trade_handler)
19 | 
20 |     # Provide a method to create access tokens. The create_jwt()
21 |     # function is used to actually generate the token
22 |     def post(self):
23 |         if not request.is_json:
24 |             return APIResult.ErrorResult(100, msg="Missing JSON in request"), 400
25 | 
26 |         params = request.get_json()
27 |         username = params.get('username', None)
28 |         password = params.get('password', None)
29 | 
30 |         if not username:
31 |             return APIResult.ErrorResult(status=101, msg="Missing username parameter"), 400
32 |         if not password:
33 |             return APIResult.ErrorResult(status=101, msg="Missing password parameter"), 400
34 | 
35 |         if username != JWTEndpoint.user or password != JWTEndpoint.pwd:
36 |             return APIResult.ErrorResult(status=101, msg="Bad username or password"), 401
37 | 
38 |         # Identity can be any data that is json serializable
39 | 
40 |         ret = {'jwt': create_access_token(identity=username),
41 |                'exp': timegm((flask.current_app.config['JWT_ACCESS_TOKEN_EXPIRES'] + datetime.now()).utctimetuple())}
42 |         return ret, 200
43 | 
44 |     # Protect a view with jwt_required, which requires a valid jwt
45 |     # to be present in the headers.
46 |     @jwt_required()
47 |     def get(self):
48 |         # Access the identity of the current user with get_jwt_identity
49 |         return {'hello_from': get_jwt_identity()}, 200


--------------------------------------------------------------------------------
/API/Endpoints/LogsEndpoint.py:
--------------------------------------------------------------------------------
 1 | import datetime
 2 | from flask import Request, request
 3 | 
 4 | from API.Endpoints.BotAPIResource import BotAPIResource
 5 | from flask_jwt_extended import jwt_required
 6 | import arrow
 7 | 
 8 | 
 9 | class LogsEndpoint(BotAPIResource):
10 | 
11 |     @jwt_required()
12 |     def get(self, file=None, limit=1000):
13 | 
14 |         file = request.args.get('file', file)
15 |         limit = int(request.args.get('limit', 1000))
16 | 
17 |         if not file:
18 |             return self.list_files()
19 | 
20 |         contents = self.get_file_contents(None if file == 'latest' else file)
21 | 
22 |         log_records = []
23 |         for line in contents.splitlines():
24 |             if not line:
25 |                 continue
26 | 
27 |             level_start = -1
28 |             if '[' in line:
29 |                level_start = line.index('[')
30 | 
31 |             if level_start > -1:
32 |                 log_entry = {}
33 | 
34 |                 dt_str = line[0:level_start]
35 |                 try:
36 |                     log_entry['d'] = arrow.get(dt_str).format('YYYY-MM-DD HH:mm:ss.SSS')
37 |                 except Exception as e:
38 |                     log_records[-1]['t'] += '\n' + line.strip()
39 |                     continue
40 | 
41 |                 level_end = line.index(']')
42 |                 log_entry['l'] = line[level_start + 1: level_end]
43 | 
44 |                 orig_start = line.index('[', level_end)
45 |                 orig_end = line.index(']', level_end+1)
46 | 
47 |                 log_entry['o'] = line[orig_start+1:orig_end]
48 | 
49 |                 log_start = line.index(':', orig_end+1)
50 | 
51 |                 log_entry['t'] = line[log_start +1:].strip()
52 |                 log_records.append(log_entry)
53 |             else:
54 |                 log_records[-1]['t'] += '\n' + line.strip()
55 | 
56 | 
57 |         return log_records[::-1][0:limit]
58 | 


--------------------------------------------------------------------------------
/API/Endpoints/OrderBookEndpoint.py:
--------------------------------------------------------------------------------
 1 | from API.Endpoints.BotAPIResource import BotAPIResource
 2 | from flask_jwt_extended import jwt_required
 3 | 
 4 | 
 5 | class OrderBookEndpoint(BotAPIResource):
 6 | 
 7 |     @jwt_required()
 8 |     def get(self, symbol):
 9 |         return self.th.fx.get_orderbook_tickers(symbol)
10 | 


--------------------------------------------------------------------------------
/API/Endpoints/ProxyEndpoint.py:
--------------------------------------------------------------------------------
 1 | import io
 2 | import requests
 3 | 
 4 | from flask import send_file
 5 | 
 6 | from API.Endpoints.BotAPIResource import BotAPIResource
 7 | 
 8 | 
 9 | class ProxyEndpoint(BotAPIResource):
10 | 
11 |     def get(self):
12 |         r = requests.get('https://img.shields.io/github/stars/iilunin/crypto-bot.svg?style=social&label=Star&maxAge=2592000')
13 |         return send_file(io.BytesIO(r.content), mimetype='image/svg+xml;charset=utf-8', as_attachment=False)
14 | 


--------------------------------------------------------------------------------
/API/Endpoints/TradeEndpoint.py:
--------------------------------------------------------------------------------
 1 | import json
 2 | import traceback
 3 | 
 4 | from flask import Response
 5 | from flask_jwt_extended import jwt_required
 6 | from flask_restful import reqparse
 7 | 
 8 | from API.Endpoints.BotAPIResource import BotAPIResource
 9 | from API.Entities.APIResult import APIResult
10 | from Bot.ConfigLoader import ConfigLoader
11 | 
12 | 
13 | class TradeEndpoint(BotAPIResource):
14 |     def __init__(self, trade_handler):
15 |         super().__init__(trade_handler)
16 |         self.parser = reqparse.RequestParser()
17 |         self.parser.add_argument('action', type=str, help='close|start|pause')
18 |         self.parser.add_argument('data', type=dict)
19 | 
20 |     @jwt_required()
21 |     def get(self, id):
22 |         return Response(response=ConfigLoader.get_json_str(self.th.get_strategy_by_id(id).trade),
23 |                         status=200,
24 |                         mimetype="application/json")
25 | 
26 |     @jwt_required()
27 |     def delete(self, id):
28 |         strategies = self.get_strategies(id)
29 | 
30 |         if not strategies:
31 |             return APIResult.ErrorResult(101, msg='No strategies were found'), 404
32 | 
33 |         for strategy in strategies:
34 |             self.th.remove_trade_by_strategy(strategy, True)
35 | 
36 |         return APIResult.OKResult()
37 | 
38 |     @jwt_required()
39 |     def get_strategies(self, id):
40 |         if id == '0':
41 |             strategies = self.th.strategies
42 |         else:
43 |             strategy = self.th.get_strategy_by_id(id)
44 |             strategies = None if not strategy else [strategy]
45 |         return strategies
46 | 
47 |     @jwt_required()
48 |     def put(self, trade_json):
49 |         pass
50 | 
51 |     @jwt_required()
52 |     def post(self, id=None):
53 |         args = self.parser.parse_args()
54 |         action = args['action']
55 | 
56 |         if not action:
57 |             return APIResult.ErrorResult(100, msg='No "action" was provided'), 403
58 | 
59 |         strategies = self.get_strategies(id)
60 | 
61 |         if not strategies and id != '0':
62 |             return APIResult.ErrorResult(101, msg='No strategies were found'), 404
63 | 
64 |         action = action.lower()
65 | 
66 |         if action == 'close':
67 |             for strategy in strategies:
68 |                 strategy.emergent_close_position()
69 | 
70 |         elif action in ['pause', 'resume']:
71 |             paused = True if action == 'pause' else False
72 | 
73 |             for strategy in strategies:
74 |                 strategy.paused = paused
75 |         elif action == 'add':
76 |             ids = []
77 |             try:
78 |                 trade_json = args['data']
79 |                 trades = ConfigLoader.load_trade_list_from_obj(trade_json)
80 |                 for trade in trades:
81 |                     ids.append(trade.id)
82 |                     self.th.updated_trade(trade)
83 |                     self.th.fire_trade_updated(trade, True)
84 |             except Exception as e:
85 |                 self.th.logger.error(traceback.format_exc())
86 |                 return json.dumps(APIResult.ErrorResult(100, str(e))), 500
87 | 
88 |             return APIResult.OKResult(ids), 201
89 | 
90 |         return APIResult.OKResult(), 200


--------------------------------------------------------------------------------
/API/Endpoints/TradeListEndpoint.py:
--------------------------------------------------------------------------------
 1 | from API.Endpoints.BotAPIResource import BotAPIResource
 2 | from flask_jwt_extended import jwt_required
 3 | 
 4 | class TradeListEndpoint(BotAPIResource):
 5 |     @jwt_required()
 6 |     def get(self):
 7 |         return [{
 8 |             'id': s.trade.id,
 9 |             'sym': s.symbol(),
10 |             'avail': s.balance.avail,
11 |             'locked': s.balance.locked,
12 |             'paused': s.paused,
13 |             'price': s.get_single_price(s.last_price),
14 |             'sell': s.trade.is_sell()} for s in self.th.strategies]


--------------------------------------------------------------------------------
/API/Endpoints/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/iilunin/crypto-bot/0944641e9b2defb88d80dea03dd47c126f1c0b64/API/Endpoints/__init__.py


--------------------------------------------------------------------------------
/API/Entities/APIResult.py:
--------------------------------------------------------------------------------
 1 | class APIResult:
 2 |     def __init__(self, status=0, msg=None):
 3 |         self.status = status
 4 |         self.msg = msg
 5 | 
 6 |     @classmethod
 7 |     def OKResult(cls, msg=None):
 8 |         return {'status': 0, 'msg': msg}
 9 | 
10 |     @classmethod
11 |     def ErrorResult(cls, status, msg=None):
12 |         return {'status': status, 'msg': msg}
13 | 


--------------------------------------------------------------------------------
/API/Entities/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/iilunin/crypto-bot/0944641e9b2defb88d80dea03dd47c126f1c0b64/API/Entities/__init__.py


--------------------------------------------------------------------------------
/API/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/iilunin/crypto-bot/0944641e9b2defb88d80dea03dd47c126f1c0b64/API/__init__.py


--------------------------------------------------------------------------------
/Bot/AccountBalances.py:
--------------------------------------------------------------------------------
 1 | from datetime import datetime
 2 | 
 3 | 
 4 | class Balance:
 5 |     def __init__(self, getter):
 6 |         self.__getter = getter
 7 | 
 8 |     @property
 9 |     def avail(self):
10 |         return self.__getter()['f']
11 | 
12 |     @property
13 |     def locked(self):
14 |         return self.__getter()['l']
15 | 
16 |     @avail.setter
17 |     def avail(self, val):
18 |         self.__getter()['f'] = val
19 | 
20 |     @locked.setter
21 |     def locked(self, val):
22 |         self.__getter()['l'] = val
23 | 
24 | 
25 | class AccountBalances:
26 |     __shared_state = {}
27 | 
28 |     def __init__(self):
29 |         self.__dict__ = self.__shared_state
30 |         if not self.__dict__:
31 |             self.bal_dict = {}
32 |             self.last_updated = None
33 | 
34 |     def update_balances(self, new_balances):
35 |         self.bal_dict.update(new_balances)
36 |         self.last_updated = datetime.now()
37 | 
38 |     def update_required(self, dt):
39 |         return self.last_updated < dt
40 | 
41 |     def get_balance(self, asset):
42 |         return Balance(lambda: self.bal_dict[asset])
43 | 


--------------------------------------------------------------------------------
/Bot/ConfigLoader.py:
--------------------------------------------------------------------------------
  1 | import json
  2 | import os
  3 | 
  4 | from os import listdir
  5 | from os.path import isfile, join
  6 | 
  7 | import Utils
  8 | from Bot.JsonEncoder import CustomJsonEncoder
  9 | from Bot.Trade import Trade
 10 | from Utils.Utils import get_symbol_and_id_from_file_path
 11 | 
 12 | 
 13 | class ConfigLoader:
 14 |     PARENT_ELEMENT = 'trades'
 15 |     ALT_PARENT_ELEMENT = 'trade'
 16 | 
 17 |     def json_loader(self, path):
 18 |         def load():
 19 |             with open(path, 'r') as f:
 20 |                 return json.load(f)
 21 | 
 22 |         return load
 23 | 
 24 |     def advanced_loader(self, path):
 25 |         def load():
 26 |             target_path_list = [f for f in listdir(path) if isfile(join(path, f)) and f.lower().endswith('json')]
 27 |             trades = []
 28 |             d = {ConfigLoader.PARENT_ELEMENT: trades}
 29 |             for t_path in target_path_list:
 30 |                 with open(join(path, t_path), 'r') as f:
 31 |                     trade_obj = json.load(f)[ConfigLoader.PARENT_ELEMENT]
 32 |                     trades.extend(trade_obj)
 33 |             return d
 34 | 
 35 |         return load
 36 | 
 37 |     def json_saver(self, path):
 38 |         def save(obj):
 39 |             with open(path() if callable(path) else path, 'w') as f:
 40 |                 json.dump(obj, fp=f, cls=CustomJsonEncoder, indent=2)
 41 | 
 42 |         return save
 43 | 
 44 |     @classmethod
 45 |     def get_json_str(cls, obj):
 46 |         return json.dumps(obj, cls=CustomJsonEncoder, indent=2)
 47 | 
 48 |     # def advanced_saver(self, path):
 49 |     #     def save(obj):
 50 |     #         with open(path, 'w') as f:
 51 |     #             json.dump(obj, fp=f, cls=CustomJsonEncoder, indent=4)
 52 | 
 53 |     def load_trade_list(self, path):
 54 |         if isfile(path):
 55 |             trades = self.load_trade_list_fromfile(path)
 56 | 
 57 |             if self._rename_trade_file(os.path.split(path)[0], path, trades):
 58 |                 os.remove(path)
 59 | 
 60 |             return trades
 61 | 
 62 |         target_path_list = [f for f in listdir(path) if isfile(join(path, f)) and f.lower().endswith('json')]
 63 |         trades = []
 64 |         for t_path in target_path_list:
 65 |             full_path = join(path, t_path)
 66 |             trades_from_file = self.load_trade_list_fromfile(full_path)
 67 |             trades.extend(trades_from_file)
 68 |             if len(trades_from_file) > 0:
 69 |                 if self._rename_trade_file(path, t_path, trades_from_file):
 70 |                     os.remove(full_path)
 71 | 
 72 |         return trades
 73 | 
 74 |     def _rename_trade_file(self, path, file_name, trades):
 75 |         symbol, id = get_symbol_and_id_from_file_path(file_name)
 76 |         if isinstance(trades, Trade):
 77 |             trades = [trades]
 78 | 
 79 |         update_file_name = False
 80 |         for trade in trades:
 81 |             if id is None or (symbol != trade.symbol and id != trade.id):
 82 |                 self.save_trades(self.json_saver(join(path, '{}_{}.json'.format(trade.symbol, trade.id))), trade)
 83 |                 update_file_name = True
 84 |         return update_file_name
 85 | 
 86 |     def load_trade_list_fromfile(self, file_path):
 87 |         with open(file_path, 'r') as f:
 88 |             trade_obj = json.load(f)
 89 |             return ConfigLoader.load_trade_list_from_obj(trade_obj)
 90 | 
 91 |     @classmethod
 92 |     def load_trade_list_from_json(cls, s):
 93 |         trade_obj = json.loads(s)
 94 |         return cls.load_trade_list_from_obj(trade_obj)
 95 | 
 96 |     @classmethod
 97 |     def load_trade_list_from_obj(cls, trade_obj):
 98 |         if ConfigLoader.PARENT_ELEMENT in trade_obj:
 99 |             return [Trade(**to) for to in trade_obj[ConfigLoader.PARENT_ELEMENT]]
100 |         if ConfigLoader.ALT_PARENT_ELEMENT in trade_obj:
101 |             return [Trade(**trade_obj[ConfigLoader.ALT_PARENT_ELEMENT])]
102 | 
103 | 
104 |     def save_trades(self, saver, trades):
105 |         if isinstance(trades, list):
106 |             parent = ConfigLoader.ALT_PARENT_ELEMENT if len(trades) == 1 else ConfigLoader.PARENT_ELEMENT
107 | 
108 |             if len(trades) == 1:
109 |                 trades = trades[0]
110 |         else:
111 |             parent = ConfigLoader.ALT_PARENT_ELEMENT
112 | 
113 |         d = {parent: trades}
114 |         saver(d)
115 | 
116 |     def persist_updated_trade(self, trade: Trade, saver):
117 |         #TODO: don't need to read file as there is only 1 trade per file at the moment
118 |         # old_trades = self.load_trade_list(loader)
119 |         # old_order = next(o for o in old_trades if o.symbol == trade.symbol)
120 |         # old_trades.remove(old_order)
121 |         # old_trades.append(trade)
122 |         #
123 |         # old_trades.sort(key=lambda trade: trade.symbol)
124 |         # self.save_trades(saver, old_trades)
125 | 
126 |         self.save_trades(saver, trade)
127 | 
128 | 
129 | 
130 | 


--------------------------------------------------------------------------------
/Bot/CustomSerializable.py:
--------------------------------------------------------------------------------
1 | class CustomSerializable:
2 |     def format_float(self, flt):
3 |         if flt.is_integer():
4 |             return '{:.0f}'.format(flt)
5 |         return '{:.08f}'.format(flt)
6 | 
7 |     def serializable_dict(self):
8 |         return self.__dict__
9 | 


--------------------------------------------------------------------------------
/Bot/EntryExitSettings.py:
--------------------------------------------------------------------------------
 1 | from collections import OrderedDict
 2 | from typing import List
 3 | 
 4 | from Bot.CustomSerializable import CustomSerializable
 5 | from Bot.TradeEnums import Side
 6 | from Bot.Target import EntryTarget, Target, ExitTarget
 7 | from Bot.Value import Value
 8 | 
 9 | 
10 | class EntryExitSettings(CustomSerializable):
11 |     DEFAULT_THRESHOLD = Value("1%")
12 | 
13 |     def __init__(self,
14 |                  targets=None,
15 |                  side=None,
16 |                  sl_threshold=None,
17 |                  is_entry=True,
18 |                  smart=False,
19 |                  **kvargs):
20 | 
21 |         if 'threshold' in kvargs:
22 |             sl_threshold = kvargs.get('threshold')
23 | 
24 |         self.sl_threshold = Value(sl_threshold) if sl_threshold else EntryExitSettings.DEFAULT_THRESHOLD
25 | 
26 |         self.side = Side(side.lower()) if side else None
27 |         self.smart = smart
28 |         self.is_entry = is_entry
29 | 
30 |         self.targets: [Target] = []
31 | 
32 |         # As an alternative to specifiying array of targets
33 |         if 'target' in kvargs:
34 |             self.targets.append(self._create_target(kvargs.get('target'), is_entry))
35 | 
36 |         if targets:
37 |             self.set_targets([self._create_target(t, is_entry) for t in targets])
38 | 
39 |     def set_targets(self, targets):
40 |         self.targets.extend(targets)
41 |         self.targets.sort(key=lambda t: (not t.is_completed(), t.price), reverse=self.side.is_buy())
42 | 
43 |     def get_completed_targets(self) -> List[Target]:
44 |         return [t for t in self.targets if t.is_completed()]
45 | 
46 |     def get_all_smart_targets(self) -> List[Target]:
47 |         return [t for t in self.targets if t.is_smart()]
48 | 
49 |     def get_all_incomplete_smart_targets(self) -> List[Target]:
50 |         return [t for t in self.targets if t.is_smart() and not t.is_completed()]
51 | 
52 |     def is_completed(self):
53 |         return all(t.is_completed() for t in self.targets)
54 | 
55 |     def _create_target(self, t, is_entry):
56 |         return EntryTarget(**t, parent_smart=self.smart) if is_entry else ExitTarget(**t, parent_smart=self.smart)
57 | 
58 |     def serializable_dict(self):
59 |         # d = dict(self.__dict__)
60 |         d = OrderedDict()
61 | 
62 |         # it is set automatically at Trade._init_entry_exit method
63 | 
64 |         if self.is_entry and self.side:
65 |             d['side'] = self.side
66 | 
67 |         if self.smart is not None:
68 |             d['smart'] = self.smart
69 | 
70 |         # if self.sl_threshold and (self.sl_threshold != EntryExitSettings.DEFAULT_THRESHOLD):
71 |         #     d['threshold'] = self.sl_threshold
72 | 
73 |         if self.sl_threshold:
74 |             d['threshold'] = self.sl_threshold
75 | 
76 |         if self.targets:
77 |             d['targets'] = self.targets
78 | 
79 |         return d
80 | 
81 |     def is_entry(self):
82 |         return self.is_entry
83 | 
84 |     def is_exit(self):
85 |         return not self.is_entry
86 | 
87 |     def describe(self):
88 |         description = 'Entry:' if self.is_entry else 'Exit:'
89 |         description += '\nSide:{}, Smart:{},Threshold:{}\n'.format(self.side, self.smart, self.sl_threshold)
90 |         if self.targets:
91 |             for t in self.targets:
92 |                 description += t.__str__() + '\n'
93 | 
94 |         return description
95 | 


--------------------------------------------------------------------------------
/Bot/ExchangeInfo.py:
--------------------------------------------------------------------------------
  1 | from datetime import datetime
  2 | from decimal import Decimal, ROUND_DOWN, ROUND_UP
  3 | 
  4 | 
  5 | class SymbolInfo:
  6 |     def __init__(self, symbol, filters):
  7 |         self.symbol = symbol
  8 | 
  9 |         self.minNotional = Decimal(self.strip_zeros(filters['MIN_NOTIONAL']['minNotional']))
 10 |         self.stepSize = Decimal(self.strip_zeros(filters['LOT_SIZE']['stepSize']))
 11 |         self.maxQty = Decimal(self.strip_zeros(filters['LOT_SIZE']['maxQty']))
 12 |         self.minQty = Decimal(self.strip_zeros(filters['LOT_SIZE']['minQty']))
 13 | 
 14 |         self.tickSize = Decimal(self.strip_zeros(filters['PRICE_FILTER']['tickSize']))
 15 |         self.maxPrice = Decimal(self.strip_zeros(filters['PRICE_FILTER']['maxPrice']))
 16 |         self.minPrice = Decimal(self.strip_zeros(filters['PRICE_FILTER']['minPrice']))
 17 | 
 18 |         self.multipUp = Decimal(self.strip_zeros(filters['PERCENT_PRICE']['multiplierUp']))
 19 |         self.multipDown = Decimal(self.strip_zeros(filters['PERCENT_PRICE']['multiplierDown']))
 20 | 
 21 | 
 22 |     # def __init__(self, minPrice, maxPrice, tickSize, minQty, maxQty, stepSize, minNotional, **kvargs):
 23 |     #     self.minNotional = Decimal(self.strip_zeros(minNotional))
 24 |     #     self.stepSize = Decimal(self.strip_zeros(stepSize))
 25 |     #     self.maxQty = Decimal(self.strip_zeros(maxQty))
 26 |     #     self.minQty = Decimal(self.strip_zeros(minQty))
 27 |     #     self.tickSize = Decimal(self.strip_zeros(tickSize))
 28 |     #     self.maxPrice = Decimal(self.strip_zeros(maxPrice))
 29 |     #     self.minPrice = Decimal(self.strip_zeros(minPrice))
 30 | 
 31 |     def strip_zeros(self, s):
 32 |         return s.rstrip('0')
 33 | 
 34 |     def adjust_quanity(self, q, round_down=True):
 35 |         if q == 0:
 36 |             return 0
 37 | 
 38 |         res = float(Decimal(q) if self.stepSize == 0.0 else Decimal(q).quantize(self.stepSize, rounding=ROUND_DOWN if round_down else ROUND_UP))
 39 |         return float(min(max(res, self.minQty), self.maxQty))
 40 | 
 41 |     def adjust_price(self, p, round_down=True):
 42 |         res = round(Decimal(p), 8)
 43 | 
 44 |         if self.tickSize:  # if tickSize Enabled
 45 |             res = res.quantize(self.tickSize, rounding=ROUND_DOWN if round_down else ROUND_UP)
 46 | 
 47 |         if self.minPrice:  # if minPrice Enabled
 48 |             res = max(res, self.minPrice)
 49 | 
 50 |         if self.maxPrice:  # if minPrice Enabled
 51 |             res = min(res, self.maxPrice)
 52 | 
 53 |         return float(res)
 54 | 
 55 |     def is_quanity_above_min(self, q):
 56 |         return q > self.minQty
 57 | 
 58 |     def is_min_notional_ok(self, q, p):
 59 |         return q * p >= self.minNotional
 60 | 
 61 |     def is_within_multiplier_range(self, p, current_price):
 62 |         return current_price * float(self.multipDown) <= p <= current_price * float(self.multipUp)
 63 | 
 64 |     def msg_mutliplier_range_error(self, current_price):
 65 |         return 'Price can not be lower thant {:.8f} and higher than {:.8f}.'\
 66 |             .format(current_price * float(self.multipDown), current_price * float(self.multipUp))
 67 | 
 68 | 
 69 | class ExchangeInfo:
 70 |     __shared_state = {}
 71 |     UPDATE_RATE_S = 30
 72 | 
 73 |     def __init__(self):
 74 |         self.__dict__ = self.__shared_state
 75 |         if not self.__dict__:
 76 |             self.symbols = {}
 77 |             self.last_updated = None
 78 | 
 79 |     def need_update(self):
 80 |         if not self.last_updated:
 81 |             return True
 82 | 
 83 |         return (datetime.now() - self.last_updated).seconds >= ExchangeInfo.UPDATE_RATE_S
 84 | 
 85 |     def update(self, info):
 86 |         self.symbols = {s['symbol']: s for s in info['symbols']}
 87 |         self.last_updated = datetime.now()
 88 | 
 89 |     def symbol_info(self, symbol):
 90 |         symbol_info = self.symbols.get(symbol)
 91 | 
 92 |         props = {}
 93 |         if symbol_info is None:
 94 |             raise KeyError('Symbol "{}" not found in the Exchnage makrets info'.format(symbol))
 95 | 
 96 |         for f in symbol_info['filters']:
 97 |             filter_type = f['filterType']
 98 |             f.pop(filter_type, None)
 99 |             props[filter_type] = f
100 | 
101 |         return SymbolInfo(symbol, props)
102 | 
103 |     def has_symbol(self, symbol):
104 |         return symbol in self.symbols
105 | 
106 |     def get_all_symbols(self):
107 |         return [{'s': s, 'b': info['baseAsset']} for (s, info) in self.symbols.items()]
108 | 


--------------------------------------------------------------------------------
/Bot/JsonEncoder.py:
--------------------------------------------------------------------------------
 1 | from enum import Enum
 2 | from json import JSONEncoder
 3 | 
 4 | from datetime import datetime
 5 | 
 6 | from Bot.CustomSerializable import CustomSerializable
 7 | from Bot.Value import Value
 8 | 
 9 | 
10 | class CustomJsonEncoder(JSONEncoder):
11 |     def default(self, obj):
12 |         if isinstance(obj, Value):
13 |             return str(obj)
14 |         if isinstance(obj, CustomSerializable):
15 |             return obj.serializable_dict()
16 |         if isinstance(obj, float):
17 |             return format(obj, '.8f')
18 |         if isinstance(obj, Enum):
19 |             return obj.name
20 |         if isinstance(obj, datetime):
21 |             return obj.now().replace(microsecond=0).isoformat(' ')
22 |         return obj.__dict__
23 | 


--------------------------------------------------------------------------------
/Bot/StopLossSettings.py:
--------------------------------------------------------------------------------
 1 | from collections import OrderedDict
 2 | from enum import Enum
 3 | 
 4 | from Bot.CustomSerializable import CustomSerializable
 5 | from Bot.Target import StopLossTarget
 6 | from Bot.Value import Value
 7 | 
 8 | 
 9 | class StopLossSettings(CustomSerializable):
10 |     DEFAULT_ZONE_ENTRY = '0.3%'
11 |     DEFAULT_LIMIT_PRICE = '0.3%'
12 |     DEFAULT_TRAILING_SL_VALUE = '5%'
13 | 
14 |     class Type(Enum):
15 |         TRAILING = 'trailing'
16 |         FIXED = 'fixed'
17 | 
18 |     def __init__(self, initial_target, type=Type.FIXED.name, val=DEFAULT_TRAILING_SL_VALUE,
19 |                  zone_entry=DEFAULT_ZONE_ENTRY, limit_price_threshold=DEFAULT_LIMIT_PRICE, last_stoploss=0,
20 |                  **kvargs):
21 |         self.type = StopLossSettings.Type(type.lower())
22 |         self.val = Value(kvargs.get('threshold', val))
23 | 
24 |         self.limit_price_threshold = Value(limit_price_threshold)
25 |         self.zone_entry = Value(zone_entry)
26 |         self.initial_target = StopLossTarget(**initial_target)
27 |         self.last_stoploss = float(last_stoploss)
28 | 
29 |     def is_trailing(self):
30 |         return self.type == StopLossSettings.Type.TRAILING
31 | 
32 |     def is_fixed(self):
33 |         return self.type == StopLossSettings.Type.FIXED
34 | 
35 |     def serializable_dict(self):
36 |         # d = dict(self.__dict__)
37 |         d = OrderedDict()
38 | 
39 |         d['type'] = self.type
40 | 
41 |         if self.is_trailing() and self.val != Value(StopLossSettings.DEFAULT_TRAILING_SL_VALUE):
42 |             d['threshold'] = self.val
43 | 
44 |         if self.last_stoploss:
45 |             d['last_stoploss'] = self.format_float(self.last_stoploss)
46 | 
47 |         if self.limit_price_threshold != Value(StopLossSettings.DEFAULT_LIMIT_PRICE):
48 |             d['limit_price_threshold'] = self.limit_price_threshold
49 | 
50 |         if self.zone_entry != Value(StopLossSettings.DEFAULT_ZONE_ENTRY):
51 |             d['zone_entry'] = self.zone_entry
52 | 
53 |         d['initial_target'] = self.initial_target
54 | 
55 |         return d
56 | 
57 |     def describe(self):
58 |         description = 'Stoploss:\n Type: {}, Threshold: {}, Limit Price: {}, Zone Entry: {}, Last Stoploss:{}; '.format(
59 |             self.type, self.val, self.limit_price_threshold, self.zone_entry, self.last_stoploss)
60 | 
61 |         if self.initial_target:
62 |             description += self.initial_target.__str__()
63 | 
64 |         return description


--------------------------------------------------------------------------------
/Bot/Strategy/PlaceOrderStrategy.py:
--------------------------------------------------------------------------------
  1 | from binance.exceptions import BinanceAPIException
  2 | 
  3 | from Bot.Strategy.EntryStrategy import ExitStrategy
  4 | from Bot.TradeEnums import OrderStatus
  5 | from Bot.FXConnector import FXConnector
  6 | from Bot.Strategy.TradingStrategy import TradingStrategy
  7 | from Bot.Trade import Trade
  8 | from Bot.Value import Value
  9 | 
 10 | 
 11 | class PlaceOrderStrategy(TradingStrategy):
 12 |     def __init__(self, trade: Trade, fx: FXConnector, trade_updated=None, nested=False, exchange_info=None, balance=None):
 13 |         super().__init__(trade, fx, trade_updated, nested, exchange_info, balance)
 14 |         self.strategy_exit = None
 15 |         self.init_smart_exit()
 16 |         if self.assign_calculated_volume(self.trade_targets()):
 17 |             self.trade_updated(self.trade, True)
 18 | 
 19 |     def get_trade_section(self):
 20 |         return self.trade.exit # can be interface for entry at some point too
 21 | 
 22 |     def has_smart_target(self):
 23 |         return len(self.get_trade_section().get_all_incomplete_smart_targets()) > 0
 24 | 
 25 |     def init_smart_exit(self):
 26 |         if self.has_smart_target():
 27 |             self.strategy_exit = ExitStrategy(self.trade, self.fx, self.trade_updated, True, self.exchange_info,
 28 |                                               self.balance)
 29 | 
 30 |     def execute(self, new_price):
 31 |         try:
 32 |             if self.is_completed():
 33 |                 return
 34 | 
 35 |             targets = self.trade_targets()
 36 | 
 37 |             if self.validate_all_completed(targets):
 38 |                 self.logInfo('All Orders are Completed')
 39 |                 self.set_trade_completed()
 40 |                 return
 41 | 
 42 |             # execute strategy for smart orders
 43 |             if self.strategy_exit:
 44 |                 self.strategy_exit.execute(new_price)
 45 | 
 46 |             if self.validate_all_orders(targets):
 47 |                 return
 48 | 
 49 |             alloc = self.prepare_volume_allocation(targets, self.get_single_price(new_price))
 50 | 
 51 |             if alloc:
 52 |                 self.place_orders(alloc)
 53 |                 self.logInfo('All Orders are Placed')
 54 |         except BinanceAPIException as bae:
 55 |             self.logError(str(bae))
 56 | 
 57 |     def update_trade(self, trade: Trade):
 58 |         self.trade = trade
 59 | 
 60 |         self.strategy_exit = None
 61 |         self.init_smart_exit()
 62 | 
 63 |         if self.assign_calculated_volume(self.trade_targets()):
 64 |             self.trade_updated(self.trade, True)
 65 | 
 66 |     def trade_targets(self):
 67 |         return self.trade.exit.targets
 68 | 
 69 |     def not_completed_targets(self):
 70 |         return [t for t in self.trade_targets() if not t.is_completed()]
 71 | 
 72 |     def validate_all_orders(self, targets):
 73 |         return all(t.status.is_completed() or (t.status.is_active() and t.has_id()) for t in targets if not t.is_smart())
 74 | 
 75 |     def validate_all_completed(self, targets):
 76 |         return all(t.status.is_completed() for t in targets)
 77 | 
 78 |     def prepare_volume_allocation(self, targets, current_price=0):
 79 |         currency_balance = self.get_balance_for_side()
 80 | 
 81 |         bal = self.trade.get_cap(currency_balance.avail) + (
 82 |             currency_balance.locked if any(t.is_active() for t in targets) else 0)
 83 | 
 84 |         if bal <= 0:
 85 |             self.logWarning('Available balance is 0')
 86 |             return
 87 | 
 88 |         orders = []
 89 |         # last_target = targets[-1] if self.last_target_smart() else None
 90 | 
 91 |         for t in targets:
 92 |             if t.is_completed():
 93 |                 continue
 94 | 
 95 |             price = self.exchange_info.adjust_price(t.price)
 96 | 
 97 |             adjusted_balance = bal
 98 | 
 99 |             # in case of BUY like with BTCUSDT we have balance in USDT e.g. 700, but specifying the vol in BTC e.g. 0.1
100 |             if self.trade_side().is_buy():
101 |                 adjusted_balance = round(bal / price, 8)
102 | 
103 |             vol = self.exchange_info.adjust_quanity(t.vol.get_val(adjusted_balance))
104 | 
105 |             t.calculated_volume = vol
106 | 
107 |             if not self.exchange_info.is_within_multiplier_range(price, current_price):
108 |                 self.logWarning('Target price {:.8f} is not within exchange multipliers. {}'
109 |                                 .format(price, self.exchange_info.msg_mutliplier_range_error(current_price)))
110 |                 continue
111 | 
112 |             if vol == 0:
113 |                 self.logWarning('No volume left to process order @ price {:.8f}'.format(price))
114 |                 continue
115 | 
116 |             if bal - vol < 0:
117 |                 self.logWarning(
118 |                     'Insufficient balance to place order. Bal: {}, Order: {}. Target: {}'.format(bal, vol, t.__str__()))
119 |                 return
120 | 
121 |             # place only new and not smart targets
122 |             if t.is_new() and not t.is_smart():
123 |                 # if self.last_target_smart() and t == last_target:
124 |                 #     continue
125 |                 orders.append({
126 |                     'price': price,
127 |                     'volume': vol,
128 |                     'side': self.trade_side().name,
129 |                     'target': t})
130 | 
131 |             if self.trade_side().is_sell():
132 |                 bal = round(bal - vol, 8)
133 |             else:
134 |                 bal = round(bal - t.vol.get_val(bal), 8)
135 | 
136 |         self.logInfo('Orders to be posted: {}'.format(orders))
137 |         return orders
138 | 
139 |     def place_orders(self, allocations):
140 |         for a in allocations:
141 |             target = a.pop('target', None)
142 |             order = self.fx.create_limit_order(sym=self.symbol(), **a)
143 |             target.set_active(order['orderId'])
144 |         self.trigger_target_updated()
145 | 
146 |     def on_order_status_changed(self, t, data):
147 |         if not t.is_exit_target():
148 |             return
149 | 
150 |         if t.is_completed():
151 |             self.logInfo('Target {} completed'.format(t))
152 |         else:
153 |             self.logInfo('Order status updated: {}'.format(t.status))
154 | 
155 | 
156 | 
157 | 
158 | 
159 | 


--------------------------------------------------------------------------------
/Bot/Strategy/SmartOrder.py:
--------------------------------------------------------------------------------
 1 | from Bot.Value import Value
 2 | from Utils.Logger import Logger
 3 | 
 4 | 
 5 | class SmartOrder(Logger):
 6 |     def __init__(self, is_buy, price, sl_threshold=Value("1%"), logger: Logger = None,
 7 |                  best_price=0):
 8 | 
 9 |         super().__init__(logger)
10 |         self.is_buy = is_buy
11 |         self.target_price = None
12 |         self.initialized = False
13 | 
14 |         self.sl_threshold = sl_threshold
15 | 
16 |         self.best_pullback_limit_price = best_price
17 |         self.target_zone_touched = False if self.best_pullback_limit_price == 0 else True
18 | 
19 |         self.init_price(price)
20 | 
21 |     def init_price(self, price):
22 |         if not price or isinstance(price, str):
23 |             return
24 | 
25 |         if not self.is_init():
26 |             self.target_price = price
27 |             self.initialized = True
28 | 
29 |         sl_limit = self.get_sl_and_pb(price)
30 |         self.logInfo('Target Price: {:.8f}; With Stop Loss Threshold: {:.8f}'.format(self.target_price, sl_limit))
31 | 
32 |     def get_sl_and_pb(self, price):
33 |         return self.get_price_limit(price, self.sl_threshold)
34 | 
35 |     def get_price_limit(self, price, val):
36 |         return round(price + val.get_val(price) * (1 if self.is_buy else -1), 8)
37 | 
38 |     def is_init(self):
39 |         return self.initialized
40 | 
41 |     def price_update(self, price):
42 |         if not self.initialized:
43 |             return None
44 | 
45 |         if self.within_target_zone(price):
46 |             self.target_zone_touched = True
47 | 
48 |         sl_limit = self.get_sl_and_pb(price)
49 | 
50 |         if self.target_zone_touched:
51 |             minormax = min if self.is_buy else max
52 | 
53 |             if self.best_pullback_limit_price != 0:
54 |                 sl_limit = minormax(sl_limit, self.best_pullback_limit_price)
55 | 
56 |             self.best_pullback_limit_price = round(sl_limit, 8)
57 | 
58 |         return self.best_pullback_limit_price
59 | 
60 |     def within_target_zone(self, price):
61 |         return (self.is_buy and price <= self.target_price) or (
62 |                 not self.is_buy and price >= self.target_price)
63 | 


--------------------------------------------------------------------------------
/Bot/Strategy/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/iilunin/crypto-bot/0944641e9b2defb88d80dea03dd47c126f1c0b64/Bot/Strategy/__init__.py


--------------------------------------------------------------------------------
/Bot/Target.py:
--------------------------------------------------------------------------------
  1 | from collections import OrderedDict
  2 | from datetime import datetime
  3 | 
  4 | from Bot.CustomSerializable import CustomSerializable
  5 | from Bot.TradeEnums import OrderStatus
  6 | from Bot.Value import Value
  7 | from Utils import Utils
  8 | 
  9 | 
 10 | class Target(CustomSerializable):
 11 |     def __init__(self, price=0, vol='100%', **kvargs):
 12 |         self.vol = Value(vol)
 13 |         self.price = PriceHelper.parse_price(price)
 14 | 
 15 |         self.id = kvargs.get('id')
 16 |         self.date = kvargs.get('date')
 17 |         self.status = OrderStatus(kvargs.get('status', OrderStatus.NEW.name).lower())
 18 |         sl_input = kvargs.get('sl', 0)
 19 |         self.sl = float(sl_input if sl_input else 0)
 20 |         self.smart = self.s2b(kvargs.get('smart', None))
 21 |         self.parent_smart = kvargs.get('parent_smart', None)
 22 |         self.best_price = float(kvargs.get('best_price', 0))
 23 | 
 24 |         cv = kvargs.get('calculated_volume', None)
 25 |         self.calculated_volume = float(cv) if cv else None
 26 | 
 27 |     def s2b(self, s):
 28 |         return Utils.s2b(s)
 29 | 
 30 |     def is_completed(self):
 31 |         return self.status.is_completed()
 32 | 
 33 |     def is_new(self):
 34 |         return self.status.is_new()
 35 | 
 36 |     def is_active(self):
 37 |         return self.status.is_active()
 38 | 
 39 |     def has_id(self):
 40 |         return self.id is not None
 41 | 
 42 |     # def set_completed(self, date_str=datetime.now().replace(microsecond=0).isoformat(' ')):
 43 |     def set_completed(self, id=None, date=datetime.now()):
 44 |         self.status = OrderStatus.COMPLETED
 45 |         self.date = date
 46 |         if id:
 47 |             self.id = id
 48 | 
 49 |     def set_canceled(self):
 50 |         self.status = OrderStatus.NEW
 51 |         self.id = None
 52 |         self.calculated_volume = None
 53 | 
 54 |     def set_active(self, id=None):
 55 |         self.status = OrderStatus.ACTIVE
 56 |         if id:
 57 |             self.id = id
 58 | 
 59 |     def has_custom_stop(self):
 60 |         return self.sl != 0
 61 | 
 62 |     def custom_stop(self):
 63 |         return self.sl
 64 | 
 65 |     def is_stoploss_target(self):
 66 |         return False
 67 | 
 68 |     def is_exit_target(self):
 69 |         return False
 70 | 
 71 |     def is_entry_target(self):
 72 |         return False
 73 | 
 74 |     def is_smart(self):
 75 |         if self.parent_smart is not None:
 76 |             if self.smart is not None:
 77 |                 return self.smart
 78 |             return self.parent_smart
 79 | 
 80 |         return False if self.smart is None else self.smart
 81 | 
 82 |     def __str__(self):
 83 |         desc = ('{}:{:.08f}@{}; Smart:{}' if PriceHelper.is_float_price(self.price) else '{}:{}@{}{}').format(
 84 |             self.__class__.__name__, self.price, self.vol, self.is_smart())
 85 |         if self.calculated_volume and self.vol.is_rel():
 86 |             desc += '; Abs Vol:{:.08f}'.format(self.calculated_volume)
 87 | 
 88 |         desc += ' ;Stoploss:{}'.format(self.sl)
 89 |         desc += ' ;Status:{}'.format(self.status)
 90 |         desc += ' ;ID:{}'.format(self.id)
 91 |         return desc
 92 |         # '(abs vol: {:.08f})'.format(self.calculated_volume) if self.vol.is_rel() and self.calculated_volume else ''
 93 | 
 94 |     def __repr__(self):
 95 |         return self.__str__()
 96 | 
 97 |     def serializable_dict(self):
 98 |         d = OrderedDict()
 99 | 
100 |         if not self.status.is_new():
101 |             d['status'] = self.status
102 | 
103 |         if self.id:
104 |             d['id'] = self.id
105 | 
106 |         if self.date:
107 |             d['date'] = self.date
108 | 
109 |         if PriceHelper.is_float_price(self.price):
110 |             d['price'] = self.format_float(self.price)
111 |         else:
112 |             d['price'] = self.price
113 | 
114 |         d['vol'] = self.vol
115 | 
116 |         if self.smart is not None:
117 |             d['smart'] = self.smart
118 | 
119 |         if self.sl != 0:
120 |             d['sl'] = self.format_float(self.sl)
121 | 
122 |         if self.best_price > 0:
123 |             d['best_price'] = self.format_float(self.best_price)
124 | 
125 |         if self.calculated_volume:
126 |             d['calculated_volume'] = self.format_float(self.calculated_volume)
127 | 
128 |         return d
129 | 
130 | 
131 | class PriceHelper:
132 |     CURR_PRICE_TOKEN = 'cp'
133 | 
134 |     def __init__(self, is_digit, price_val, operand, operation_val):
135 |         self.is_digit = is_digit
136 |         self.price_val = price_val
137 |         self.operand = operand
138 |         self.operation_val: Value = operation_val
139 | 
140 |     def get_value(self, ref_price):
141 |         if self.is_digit:
142 |             return self.price_val
143 | 
144 |         if str(self.price_val).lower() == PriceHelper.CURR_PRICE_TOKEN:
145 |             if not self.operand:
146 |                 return ref_price
147 |             if self.operand in ['+', '-']:
148 |                 return round(ref_price + self.operation_val.get_val(ref_price) * (1 if self.operand == '+' else -1), 8)
149 |             else:
150 |                 raise SyntaxError('Operation "{}" is unsupported. Use only + or -'.format(self.operand))
151 | 
152 |         raise SyntaxError('Reference price "{}" is unsupported. Use only "CP"'.format(str(self.price_val)))
153 | 
154 | 
155 |     @classmethod
156 |     def parse_price(cls, price_str):
157 |         try:
158 |             return float(price_str)
159 |         except ValueError:
160 |             return price_str
161 | 
162 |     @classmethod
163 |     def is_float_price(cls, price_str):
164 |         try:
165 |             float(price_str)
166 |             return True
167 |         except ValueError:
168 |             return False
169 | 
170 |     @classmethod
171 |     def create_price_helper(cls, price_str):
172 |         #Issue 21 float parsing
173 |         s = str(price_str).strip().lower().replace(',', '.')
174 |         if PriceHelper.is_float_price(s):
175 |             return PriceHelper(True, float(s), None, None)
176 | 
177 |         token = s
178 |         operand = None
179 |         val = None
180 |         if s.startswith(PriceHelper.CURR_PRICE_TOKEN):
181 |             token = PriceHelper.CURR_PRICE_TOKEN
182 | 
183 |             s = s[len(PriceHelper.CURR_PRICE_TOKEN):]
184 |             if len(s) > 0 and s[0] in ['+', '-']:
185 |                 operand = s[0]
186 |                 s = s[1:]
187 |                 if len(s) > 0:
188 |                     val = Value(s)
189 | 
190 |         return PriceHelper(False, token, operand, val)
191 | 
192 | 
193 | class ExitTarget(Target):
194 |     def __init__(self, **kvargs):
195 |         super().__init__(**kvargs)
196 | 
197 |     def is_exit_target(self):
198 |         return True
199 | 
200 | class StopLossTarget(Target):
201 |     def __init__(self, **kvargs):
202 |         super().__init__(**kvargs)
203 | 
204 |     def is_stoploss_target(self):
205 |         return True
206 | 
207 | 
208 | class EntryTarget(Target):
209 |     def __init__(self, **kvargs):
210 |         super().__init__(**kvargs)
211 | 
212 |     def is_entry_target(self):
213 |         return True
214 | 


--------------------------------------------------------------------------------
/Bot/Trade.py:
--------------------------------------------------------------------------------
  1 | from collections import OrderedDict
  2 | import uuid
  3 | from typing import List
  4 | from Bot.EntryExitSettings import EntryExitSettings
  5 | from Bot.TradeEnums import Side
  6 | from Bot.StopLossSettings import StopLossSettings
  7 | from Bot.Target import *
  8 | 
  9 | 
 10 | class Trade(CustomSerializable):
 11 |     # def __init__(self, symbol, side, asset, status=None, sl_settings=None, entry=None, exit=None):
 12 |     def __init__(self, symbol, side, asset, status=None, *args, **kvargs):
 13 |         self.side = Side(side.lower())
 14 |         self.symbol = symbol.upper()
 15 |         self.asset = asset.upper()
 16 | 
 17 |         self.entry: EntryExitSettings = None
 18 |         self.exit: EntryExitSettings = None
 19 | 
 20 |         self._init_entry_exit(True, kvargs.get('entry'), self.side)
 21 |         self._init_entry_exit(False, kvargs.get('exit'), self.side)
 22 | 
 23 |         sl_settings = kvargs.get('stoploss', kvargs.get('sl_settings'))
 24 | 
 25 |         # self.sl_settings: StopLossSettings = StopLossSettings(**sl_settings) if sl_settings else None
 26 |         self.sl_settings: StopLossSettings = StopLossSettings(**sl_settings) if sl_settings else StopLossSettings({})
 27 | 
 28 |         if status:
 29 |             self.status = OrderStatus(status.lower())
 30 |         else:
 31 |             self.status = OrderStatus.ACTIVE if not kvargs.get('entry') else OrderStatus.NEW
 32 | 
 33 |         self.cap = float(kvargs.get('cap')) if kvargs.get('cap') else None
 34 | 
 35 |         self.id = kvargs.get('id', None)
 36 | 
 37 |         if not self.id:
 38 |             self.id = str(uuid.uuid4())
 39 | 
 40 |     def _init_entry_exit(self, is_entry, data, side: Side):
 41 |         if data:
 42 |             if 'side' not in data:
 43 |                 data['side'] = (side.reverse() if is_entry else side).value
 44 | 
 45 |             # TODO: right now there is only Smart Entry option allowed
 46 |             if is_entry:
 47 |                 data['smart'] = True
 48 |                 self.entry = EntryExitSettings(is_entry=is_entry, **data)
 49 |             else:
 50 |                 self.exit = EntryExitSettings(is_entry=is_entry, **data)
 51 | 
 52 |     def get_cap(self, available_balance):
 53 |         return min(self.cap if self.cap else available_balance, available_balance)
 54 | 
 55 |     def is_sell(self):
 56 |         return self.side.is_sell()
 57 | 
 58 |     def has_entry(self):
 59 |         return self.entry is not None
 60 | 
 61 |     def has_exit(self):
 62 |         return self.exit is not None
 63 | 
 64 |     def has_stoploss(self):
 65 |         return self.sl_settings is not None and self.sl_settings.initial_target
 66 | 
 67 |     def has_stoploss_in_last_completed_target(self):
 68 |         completed_targets = self.get_completed_exit_targets()
 69 |         has_completed_targets = len(completed_targets) > 0
 70 | 
 71 |         return has_completed_targets and completed_targets[-1].has_custom_stop()
 72 | 
 73 |     def get_completed_exit_targets(self) -> List[Target]:
 74 |         if not self.exit:
 75 |             return []
 76 |         return self.exit.get_completed_targets()
 77 | 
 78 |     def get_initial_stop(self) -> Target:
 79 |         if self.sl_settings:
 80 |             return self.sl_settings.initial_target
 81 |         return None
 82 | 
 83 |     def serializable_dict(self):
 84 |         d = OrderedDict()
 85 | 
 86 |         d['id'] = self.id
 87 |         d['asset'] = self.asset
 88 |         d['symbol'] = self.symbol
 89 |         d['side'] = self.side
 90 |         d['status'] = self.status
 91 | 
 92 |         if self.cap:
 93 |             d['cap'] = self.format_float(self.cap)
 94 | 
 95 |         if self.entry:
 96 |             d['entry'] = self.entry
 97 | 
 98 |         if self.exit:
 99 |             d['exit'] = self.exit
100 | 
101 |         if self.sl_settings:
102 |             d['stoploss'] = self.sl_settings
103 | 
104 |         return d
105 | 
106 |     def get_all_active_placed_targets(self) -> List[Target]:
107 |         tgt = []
108 |         if self.has_exit():
109 |             tgt.extend(self.exit.targets)
110 |         if self.has_entry():
111 |             tgt.extend(self.entry.targets)
112 |         if self.has_stoploss():
113 |             tgt.append(self.sl_settings.initial_target)
114 | 
115 |         return [t for t in tgt if not t.is_completed() and t.has_id()]
116 | 
117 |     def is_completed(self):
118 |         return self.status.is_completed()
119 | 
120 |     def is_active(self):
121 |         return self.status.is_active()
122 | 
123 |     def is_new(self):
124 |         return self.status.is_new()
125 | 
126 |     def is_removed(self):
127 |         return self.status.is_removed()
128 | 
129 |     def set_active(self):
130 |         self.status = OrderStatus.ACTIVE
131 | 
132 |     def set_completed(self):
133 |         self.status = OrderStatus.COMPLETED
134 | 
135 |     def set_removed(self):
136 |         self.status = OrderStatus.REMOVED
137 | 
138 |     def __str__(self):
139 |         return '{}({}): {}'.format(self.symbol, self.id, self.side)
140 | 
141 |     def describe(self):
142 |         description = self.__str__()
143 |         if self.has_entry():
144 |             description += '\n'+self.entry.describe()
145 |         if self.has_exit():
146 |             description +='\n'+self.exit.describe()
147 |         if self.has_stoploss():
148 |             description += '\n'+self.sl_settings.describe()
149 |         return description
150 | 
151 | 


--------------------------------------------------------------------------------
/Bot/TradeEnums.py:
--------------------------------------------------------------------------------
 1 | from enum import Enum
 2 | 
 3 | class OrderStatus(Enum):
 4 |     NEW = 'new'
 5 |     COMPLETED = 'completed'
 6 |     ACTIVE = 'active'
 7 |     REMOVED = 'removed'
 8 | 
 9 |     def is_new(self):
10 |         return self == OrderStatus.NEW
11 | 
12 |     def is_completed(self):
13 |         return self == OrderStatus.COMPLETED
14 | 
15 |     def is_active(self):
16 |         return self == OrderStatus.ACTIVE
17 | 
18 |     def is_removed(self):
19 |         return self == OrderStatus.REMOVED
20 | 
21 | class Side(Enum):
22 |     BUY = 'buy'
23 |     SELL = 'sell'
24 | 
25 |     def is_buy(self):
26 |         return self == Side.BUY
27 | 
28 |     def is_sell(self):
29 |         return self == Side.SELL
30 | 
31 |     def reverse(self):
32 |         if self == Side.BUY:
33 |             return Side.SELL
34 |         return Side.BUY
35 | #
36 | # class Entry(Enum):
37 | #     SMART = 'smart'
38 | #     TARGET = 'target'
39 | #
40 | #     def is_smart(self):
41 | #         return self == Entry.SMART
42 | #
43 | #     def is_target(self):
44 | #         return self == Entry.TARGET
45 | 


--------------------------------------------------------------------------------
/Bot/TradeValidator.py:
--------------------------------------------------------------------------------
 1 | from Bot.Trade import Trade
 2 | 
 3 | 
 4 | class TradeValidator:
 5 | 
 6 |     def __init__(self):
 7 |         self.errors = {}
 8 |         self.warnings = {}
 9 | 
10 |     def validate(self, order):
11 |         """
12 | 
13 |         :type order: Trade
14 |         """
15 | 
16 |         self.errors = {}
17 |         self.warnings = {}
18 | 
19 |         self.validate_completed(order)
20 |         self.validate_sl(order)
21 | 
22 |         if len(self.errors) > 0:
23 |             return False
24 | 
25 |         return True
26 | 
27 | 
28 |     def validate_completed(self, order):
29 |         if order.is_completed():
30 |             self.errors["ORDER_COMPLETED"] = 'order already completed and should not be executed'
31 | 
32 | 
33 |     def validate_sl(self, trade):
34 |         """
35 | 
36 |         :type trade: Trade
37 |         """
38 | 
39 |         if not trade.has_stoploss():
40 |             if not trade.has_entry(): #in case it is entry only order
41 |                 self.warnings["NO_SL"] = 'no stop loss set'
42 |         elif trade.get_initial_stop().is_completed():
43 |             self.warnings["NO_SL"] = 'no active stop loss set'
44 | 
45 | 
46 |         if not (trade.has_exit() or trade.has_entry()):
47 |             self.warnings["NO_TARG"] = 'no targets set'
48 | 
49 |             for t in trade.exit.targets:
50 |                 if t.is_completed() or t.is_smart():
51 |                     continue
52 | 
53 |                 if (trade.side.is_sell() and trade.get_initial_stop().price >= t.price) or \
54 |                         (trade.side.is_buy() and trade.get_initial_stop().price <= t.price):
55 |                     self.errors['SL_PRICE_ERROR'] = 'stop loss price > than target price'
56 |                     return False
57 | 
58 |         return True
59 | 


--------------------------------------------------------------------------------
/Bot/Value.py:
--------------------------------------------------------------------------------
 1 | from enum import Enum
 2 | 
 3 | 
 4 | class Value:
 5 |     class Type(Enum):
 6 |         ABS = 0
 7 |         REL = 1
 8 | 
 9 |     def __init__(self, obj: str):
10 |         if not isinstance(obj, str):
11 |             obj = str(obj)
12 |         if obj.endswith('%'):
13 |             self.type = Value.Type.REL
14 |         else:
15 |             self.type = Value.Type.ABS
16 | 
17 |         #Issue 21 float parsing
18 |         self.v = float(obj.replace('%', '').replace(',', '.'))
19 | 
20 |     def is_abs(self):
21 |         return self.type == Value.Type.ABS
22 | 
23 |     def is_rel(self):
24 |         return self.type == Value.Type.REL
25 | 
26 |     def get_val(self, rel_val):
27 |         if self.is_abs():
28 |             return self.v
29 |         if self.v == 100:
30 |             return rel_val
31 |         return round(rel_val * self.v / 100, 8)
32 | 
33 |     def __eq__(self, other):
34 |         return self.v == other.v and self.type == other.type
35 | 
36 |     def __ne__(self, other):
37 |         return not self == other
38 | 
39 |     def __str__(self):
40 |         return ('{:.0f}%'.format(self.v) if self.v.is_integer() else '{:.2f}%'.format(
41 |             self.v)) if self.is_rel() else '{:.8f}'.format(self.v)
42 | 
43 |     def __repr__(self):
44 |         return self.__str__()
45 | 


--------------------------------------------------------------------------------
/Bot/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/iilunin/crypto-bot/0944641e9b2defb88d80dea03dd47c126f1c0b64/Bot/__init__.py


--------------------------------------------------------------------------------
/BotVersion.py:
--------------------------------------------------------------------------------
1 | BOT_VERSION = 'v0.0.4'


--------------------------------------------------------------------------------
/Cloud/__init__.py:
--------------------------------------------------------------------------------
1 | import logging
2 | 
3 | logging.getLogger('botocore').setLevel(logging.WARNING)
4 | logging.getLogger('boto3').setLevel(logging.WARNING)


--------------------------------------------------------------------------------
/Docker/Dockerfile-allinone:
--------------------------------------------------------------------------------
1 | FROM iilunin/crypto-bot:api-latest
2 | #FROM api # building form local built Dockerfile-botapi
3 | 
4 | # Copy form local built Dockerfile-fe
5 | COPY --from=bot-fe /usr/src/app/release /usr/src/app/API/templates
6 | 
7 | EXPOSE 3000
8 | CMD ["python3", "main.py", "api"]
9 | 


--------------------------------------------------------------------------------
/Docker/Dockerfile-botapi:
--------------------------------------------------------------------------------
 1 | FROM python:3.7-slim
 2 | MAINTAINER Igor Iliunin <ilunin.igor@gmail.com>
 3 | 
 4 | RUN mkdir -p /usr/src/app
 5 | 
 6 | WORKDIR /usr/src/app
 7 | 
 8 | ENV \
 9 |   TRADE_DIR=/usr/src/trades \
10 |   TRADE_COMPLETED_DIR=/usr/src/complete_trades \
11 |   CONF_DIR=/usr/src/configs \
12 |   LOGS_DIR=/usr/src/logs
13 | 
14 | RUN mkdir -p /usr/src/logs
15 | 
16 | COPY requirements.txt /usr/src/app/
17 | 
18 | RUN \
19 |   apt-get update && \
20 |   apt-get install -y && \
21 |   apt-get install -y tzdata && \
22 |   pip install --upgrade pip && \
23 |   pip install --no-cache-dir -r requirements.txt
24 | 
25 | VOLUME ["/usr/src/trades", "/usr/src/complete_trades", "/usr/src/configs"]
26 | 
27 | COPY ./API /usr/src/app/API
28 | COPY ./Bot /usr/src/app/Bot
29 | COPY ./Cloud /usr/src/app/Cloud
30 | COPY ./Utils /usr/src/app/Utils
31 | COPY ./*.py /usr/src/app/
32 | 
33 | ENV TZ=America/New_York
34 | RUN ln -snf /usr/share/zoneinfo/$TZ /etc/localtime && echo $TZ > /etc/timezone
35 | 
36 | EXPOSE 3000
37 | CMD ["python3", "main.py", "api"]
38 | 


--------------------------------------------------------------------------------
/Docker/Dockerfile-fe:
--------------------------------------------------------------------------------
 1 | FROM node:16
 2 | ENV PATH /usr/src/app/node_modules/.bin:$PATH
 3 | # set working directory
 4 | RUN mkdir /usr/src/app
 5 | WORKDIR /usr/src/app
 6 | 
 7 | # add `/usr/src/app/node_modules/.bin` to $PATH
 8 | 
 9 | 
10 | # install and cache app dependencies
11 | RUN npm install -g npm
12 | COPY ./admin/package.json /usr/src/app/package.json
13 | COPY ./admin/package-lock.json /usr/src/app/package-lock.json
14 | RUN npm install
15 | RUN npm install -g @angular/cli
16 | 
17 | # add app
18 | COPY ./admin /usr/src/app
19 | 
20 | RUN ng build --prod --output-path release


--------------------------------------------------------------------------------
/Docker/Dockerfile-nginx:
--------------------------------------------------------------------------------
1 | FROM nginx
2 | ARG NGINX_CONFIG
3 | ENV NGINX_CONFIG=${NGINX_CONFIG:-nginx-ssl.conf}
4 | COPY --from=bot-fe /usr/src/app/release /usr/share/nginx/html
5 | 
6 | COPY ./Docker/$NGINX_CONFIG /etc/nginx/nginx.conf
7 | 


--------------------------------------------------------------------------------
/Docker/nginx-nossl.conf:
--------------------------------------------------------------------------------
 1 | user  nginx;
 2 | worker_processes  1;
 3 | 
 4 | error_log  /var/log/nginx/error.log warn;
 5 | pid        /var/run/nginx.pid;
 6 | 
 7 | events {
 8 |     worker_connections  1024;
 9 | }
10 | 
11 | 
12 | http {
13 |     include       /etc/nginx/mime.types;
14 |     default_type  application/octet-stream;
15 | 
16 |     log_format  main  '$remote_addr - $remote_user [$time_local] "$request" '
17 |                       '$status $body_bytes_sent "$http_referer" '
18 |                       '"$http_user_agent" "$http_x_forwarded_for"';
19 | 
20 |     access_log  /var/log/nginx/access.log  main;
21 |     sendfile        on;
22 |     keepalive_timeout  65;
23 | 
24 |     server {
25 |         listen 80;
26 | 
27 |          location / {
28 |             root /usr/share/nginx/html;
29 |             index index.html;
30 | 
31 |             try_files $uri $uri/ /index.html?$args;
32 |             error_log /var/log/front_end_errors.log;
33 |         }
34 |         location /api/ {
35 |             proxy_pass http://bot:3000/api/;
36 |             error_log /var/log/api.log;
37 |         }
38 |     }
39 | 
40 |     #gzip  on;
41 | 
42 |     include /etc/nginx/conf.d/*.conf;
43 | }
44 | 


--------------------------------------------------------------------------------
/Docker/nginx-ssl.conf:
--------------------------------------------------------------------------------
 1 | user  nginx;
 2 | worker_processes  1;
 3 | 
 4 | error_log  /var/log/nginx/error.log warn;
 5 | pid        /var/run/nginx.pid;
 6 | 
 7 | events {
 8 |     worker_connections  1024;
 9 | }
10 | 
11 | 
12 | http {
13 |     include       /etc/nginx/mime.types;
14 |     default_type  application/octet-stream;
15 | 
16 |     log_format  main  '$remote_addr - $remote_user [$time_local] "$request" '
17 |                       '$status $body_bytes_sent "$http_referer" '
18 |                       '"$http_user_agent" "$http_x_forwarded_for"';
19 | 
20 |     access_log  /var/log/nginx/access.log  main;
21 |     sendfile        on;
22 |     keepalive_timeout  65;
23 | 
24 |     server {
25 |         listen 443 ssl;
26 |         ssl_certificate /etc/nginx/certs/server.crt;
27 |         ssl_certificate_key /etc/nginx/certs/server.key;
28 | 
29 |         location / {
30 |             root /usr/share/nginx/html;
31 |             index index.html;
32 | 
33 |             try_files $uri $uri/ /index.html?$args;
34 |             error_log /var/log/front_end_errors.log;
35 |         }
36 |         location /api/ {
37 |             proxy_pass http://bot:3000/api/;
38 |             error_log /var/log/api.log;
39 |         }
40 |     }
41 | 
42 |     #gzip  on;
43 | 
44 |     include /etc/nginx/conf.d/*.conf;
45 | }
46 | 


--------------------------------------------------------------------------------
/Dockerfile:
--------------------------------------------------------------------------------
 1 | #########################
 2 | ### build environment ###
 3 | #########################
 4 | 
 5 | # base image
 6 | FROM node:12 as builder
 7 | 
 8 | # install chrome for protractor tests
 9 | #RUN wget -q -O - https://dl-ssl.google.com/linux/linux_signing_key.pub | apt-key add -
10 | #RUN sh -c 'echo "deb [arch=amd64] http://dl.google.com/linux/chrome/deb/ stable main" >> /etc/apt/sources.list.d/google.list'
11 | #RUN apt-get update && apt-get install -yq google-chrome-stable
12 | 
13 | # set working directory
14 | RUN mkdir /usr/src/app
15 | WORKDIR /usr/src/app
16 | 
17 | # add `/usr/src/app/node_modules/.bin` to $PATH
18 | ENV PATH /usr/src/app/node_modules/.bin:$PATH
19 | 
20 | # install and cache app dependencies
21 | RUN npm install -g npm
22 | COPY ./admin/package.json /usr/src/app/package.json
23 | COPY ./admin/package-lock.json /usr/src/app/package-lock.json
24 | RUN npm install
25 | RUN npm install -g @angular/cli
26 | 
27 | # add app
28 | COPY ./admin /usr/src/app
29 | 
30 | # run tests
31 | #RUN ng test --watch=false
32 | 
33 | # generate build
34 | #RUN npm run lint && \ --depricated
35 | #RUN npm run build-prod
36 | RUN ng build --prod --output-path app_docker
37 | 
38 | ##################
39 | ### production ###
40 | ##################
41 | FROM python:3.7-slim
42 | MAINTAINER Igor Iliunin <ilunin.igor@gmail.com>
43 | 
44 | RUN mkdir -p /usr/src/app
45 | 
46 | WORKDIR /usr/src/app
47 | 
48 | ENV \
49 |   TRADE_DIR=/usr/src/trades \
50 |   TRADE_COMPLETED_DIR=/usr/src/complete_trades \
51 |   CONF_DIR=/usr/src/configs
52 |   LOGS_DIR=/usr/src/logs
53 | 
54 | COPY requirements.txt /usr/src/app/
55 | 
56 | RUN \
57 |   apt-get update && \
58 |   apt-get install -y && \
59 |   apt-get install -y tzdata && \
60 |   pip install --upgrade pip && \
61 |   pip install --no-cache-dir -r requirements.txt
62 | 
63 | VOLUME ["/usr/src/trades", "/usr/src/configs"]
64 | 
65 | COPY . /usr/src/app
66 | #COPY --from=builder /usr/src/app/dist/admin /usr/src/app/API/templates
67 | COPY --from=bot-fe /usr/src/app/release /usr/src/app/API/templates
68 | 
69 | ENV TZ=America/New_York
70 | RUN ln -snf /usr/share/zoneinfo/$TZ /etc/localtime && echo $TZ > /etc/timezone
71 | 
72 | EXPOSE 3000
73 | CMD ["python3", "main.py", "api"]
74 | 


--------------------------------------------------------------------------------
/Docs/API.md:
--------------------------------------------------------------------------------
1 | # API to control bot is coming soon


--------------------------------------------------------------------------------
/Docs/FLOW.md:
--------------------------------------------------------------------------------
 1 | # Cryptobot Flow
 2 | 
 3 | The bot doesn't place any orders intentionally except of ones specified in [trade files](./TRADE_FILE.md). Bot works only 
 4 | with markets/sybols specified in trade files. 
 5 | 
 6 | ## Work with trade files
 7 | Bot automatically monitors `Active` trades folder for any changes like added, updated or removed trade files.
 8 | 1. If the new file is detected and it is a valid trade file:
 9 |     - The bot will adjust its name (if needed to match `{SYMBOL}_{guid}.json` pattern e.g. `ADABTC_29868502-ef0e-42a8-91fe-76dc08879bae.json`)
10 |     - Load this trade to the trade list and start executing it
11 | 2. If the existing file was modified (changed stop-losses, targets, etc.):
12 |     - Reload this file and validate it
13 |     - Update existing trade - likely to cancel all existing limit ond stop-loss orders, 
14 |     and put new ones if guided by trade
15 | 3. If trade file was deleted:
16 |     - Remove the trade from the execution list. 
17 |     - All placed orders **will not** be canceled
18 | 
19 | ## Execute trades
20 | The bot connects to Binance WebSocket API to get real-time symbol tickers and get user data notifications
21 | such as balance change, order creation or cancellation. It also uses REST API to get additional information
22 | about exchange rules and limits and other functionality like placing orders.
23 | 
24 | In general, the trade flow comprised of up to 3 execution strategies:
25 | 1. Entry
26 | 2. Exit
27 | 3. Stop Loss
28 | 
29 | Each strategy is optional. Each strategy has a target which is essentially price and volume and additional configuration
30 | parameters.
31 | 
32 | Trade strategies are checked/executed each 500ms if there were bid/ask price changes during that period.
33 | 
34 | _"Smart Target"_ - is a target with the trailing stop-loss or take profit approach. If you sell at a price `100` and have a smart target
35 | with `threshold` `1%` it means that once the price reaches `100` stop-loss sell order will be placed at `99`. If the price goes up, 
36 | the order updates (cancels and places the new one) for the better price (for the price `105` stop-loss order will be `103.95`).
37 | It works in both directions - buy or sell whether it is Entry, Exit or Stop Loss strategy.
38 | 
39 | Right now "Smart" approach is tested only with stop-loss orders as it guarantees in case of spike your order will be triggered
40 | and executed immediately by the exchange. But this approach exhaust APIs as it makes at least 2 API calls to update the order 
41 | (cancel and place new). Market Orders approach is being tested, but it may end you up with a worst price.
42 | 
43 | Each Trade may or may not have set `cap` parameter to limit trades against the whole available balance.
44 | 
45 | ### Entry
46 | Entry strategy is active if the trade has `entry` section and trade `status` is `NEW`. Currently, it supports only smart entry.
47 | Once the entry is completed, bot sets the trade's `status` to `ACTIVE` and the `cap` of the trade equal to the entry volume. 
48 | e.g., if you bought 100 ltc, but have another 500 in your wallet the whole trade will be capped by 100 ltc. If trade doesn't 
49 | have `exit` section, then it is marked as completed and no more actions on assets will be performed within this trade.
50 | 
51 | ### Exit
52 | Exit strategy is active if the trade has `exit` section and trade `status` is `ACTIVE` and has at least one not completed target.
53 | Exit can have multiple limit and smart targets. If the Stop Loss strategy is also active, then Exit strategy works concurrently
54 | with Stop Loss providing One Cancels Other functionality. Exit strategy creates limit orders for all regular targets and 
55 | executes "Smart" approach for all smart targets. If all targets are completed, then the trade is marked as completed and 
56 | no more actions on assets will be performed within this trade.
57 | 
58 | ### Stop Loss
59 | Stop Loss strategy is active if the trade has `stoploss` section and trade `status` is `ACTIVE`. Stop Loss has two modes `FIXED` and
60 | `TRAILING`. With `FIXED` mode initial target stop-loss settings will be used by default. In `TRAILING` mode initial target stop
61 | loss settings used by default, and actual trailing is enabled after the first target completed. Both these modes can be overridden 
62 | by specific `sl` set in the particular `exit` target. 
63 | 
64 | For instance, you have initial `FIXED` stop-loss set to 100, and exit target #3 has `sl` set to 220. In this scenario stop-loss 100
65 | will be active until exit target #3 is hit, and after that stop-loss will become 220.
66 | 
67 | Another example, if you have initial `TRAILING` stop-loss set to 100 and 5% trailing value, and exit target #3 has `sl` set to 220.
68 | In this scenario 100 will be active stop-loss until the first exit target is completed, after that trailing mode kicks in,
69 | and stop-loss automatically adjusted to 5% of the price. When exit target #3 is completed stop-loss becomes fixed to 220.
70 | Once the next exit target without overridden stoploss is completed, trailing mode kicks in again.
71 | 
72 | **One Cancels Other** works this way. If price falls (or jumps in case of buy order) closer to active stop-loss value - 
73 | within `zone_entry` which is `0.3%` by default, then Stop Loss strategy takes control over. In this case all orders placed by 
74 | Exit strategy are canceled, and stop-loss order is placed instead. If the price goes back to normal and leaves this zone,
75 | then control is given back to Exit strategy. If price hits stop-loss order and it's executed, then the trade is marked as completed.
76 | Sometimes price falls significantly between the decision to place stop-loss order and actually placing it, so that the price is 
77 | lower that the stop-loss order. In this case, Market order will be placed immediately.
78 |  
79 |  


--------------------------------------------------------------------------------
/Docs/SETUP.md:
--------------------------------------------------------------------------------
 1 | # Cryptobot Setup Instructions
 2 |  
 3 | ## Prerequisite
 4 | - Install Docker. For the sake of simplicity, the bot is wrapped into Docker container.
 5 | - Create Binance API Key. Make sure it is trading only and restricted to withdrawals. 
 6 | 
 7 | ## Setting up API
 8 | After you get API Key and Secret from Binance there are 2 options how to proceed:
 9 | 1. Create config file 'api.json' with the following contents:
10 | ```json
11 | {
12 |   "exchanges":[
13 |       {
14 |         "name": "binance",
15 |         "key": "YOUR_API_KEY",
16 |         "secret": "YOUR_API_SECRET"
17 |       }
18 |     ]
19 | }
20 | ```
21 | 2. Pass Key and Secret as parameters to the Docker `-e "KEY=BINANCE_API_KEY"` 
22 | and `-e "SECRET=BINANCE_API_SECRET"`
23 | 
24 | ## Running bot on Mac / Linux
25 | 1. Pull the image `docker pull iilunin/crypto-bot:stable`.
26 | 2. Create the folder for active and completed trades:
27 |     - `mkdir Active` - where you will put all new trades
28 |     - `mkdir Completed` - where bot will put completed trades
29 | 3. If you store your API keys in `api.json` file then you need to create another 
30 | folder `mkdir Config` and copy `api.json` there.
31 | 4. Run the Bot. You will also need to specify timezone in the `TZ` parameter.
32 | The whole list of timezones is available [here](https://en.wikipedia.org/wiki/List_of_tz_database_time_zones). 
33 | If you don't use `api.json`, just remove this line `-v $(pwd)/Config:/usr/src/configs:ro \ `
34 | ```shell
35 | docker run -d --rm --name cryptobot \
36 | -e "TZ=America/New_York" \
37 | -e "KEY=BINANCE_API_KEY" \
38 | -e "SECRET=BINANCE_API_SECRET" \
39 | -v $(pwd)/Active:/usr/src/trades \
40 | -v $(pwd)/Completed:/usr/src/complete_trades \
41 | -v $(pwd)/Config:/usr/src/configs:ro \
42 | iilunin/crypto-bot:stable
43 | ```
44 | 
45 | Once the bot is started, you can place your trade files into the `Active` directory, so they picked up by the bot.
46 | If by the start time `Active` directory has trade files they will be picked up as well.
47 | 
48 | To stop the bot run `docker stop cryptobot`
49 | 
50 | Running Bot with UI enabled:
51 | ```shell
52 | docker run -d --rm -p 3000:3000 --name cryptobot \
53 | -e "TZ=America/New_York" \
54 | -e "KEY=BINANCE_API_KEY" \
55 | -e "SECRET=BINANCE_API_SECRET" \
56 | -e "API_USER=ANY_USER_NAME" \
57 | -e "API_PASS=ANY_PASSWORD" \
58 | -v $(pwd)/Active:/usr/src/trades \
59 | -v $(pwd)/Completed:/usr/src/complete_trades \
60 | -v $(pwd)/Config:/usr/src/configs:ro \
61 | iilunin/crypto-bot:stable
62 | ```
63 | 
64 | You need to specify `API_USER` and `API_PASS`. With this credentials you'll be able to authenticate 
65 | to the web interface. Web interface is accessible via this url [http://localhost:3000](http://localhost:3000)
66 | 
67 | Grid View: ![Grid View](./grid_view.png "Grid View")
68 | 
69 | ### Known Issues
70 | On Mac, sometimes Docker VM is getting out of sync with local time, 
71 | which makes Biancne API unusable. The fasted (and only so far) method of fixing it,
72 | just to restart Docker (Click Docker icon in the top bar, and select Restart menu)


--------------------------------------------------------------------------------
/Docs/TRADE_FILE_EXAMPLES.md:
--------------------------------------------------------------------------------
  1 | # Trade File Examples
  2 | 
  3 | Make sure to read [trade files structure](./TRADE_FILE.md)
  4 | 
  5 | ## Example 1 BTC-USDT
  6 | Example of the trade to gradually buy BTC. `limit_price_threshold` is set to `0.5%` as prices are more volatile. 
  7 | The lowest price order `8300` will be trailing profits with `threshold` `0.2%`. Which means if BTC price falls to `8200`, 
  8 | and then pulls back `0.2%` (~8,216.4) the order executes. 
  9 | 
 10 | ```json
 11 | {
 12 |   "trade": {
 13 |     "asset": "BTC",
 14 |     "symbol": "BTCUSDT",
 15 |     "side": "BUY",
 16 |     "status": "ACTIVE",
 17 |     "exit": {
 18 |       "threshold": "0.20%",
 19 |       "targets": [
 20 |         {
 21 |           "price": "8800",
 22 |           "vol": "25%"
 23 |         },
 24 |         {
 25 |           "price": "8600",
 26 |           "vol": "33%"
 27 |         },
 28 |         {
 29 |           "price": "8400",
 30 |           "vol": "50%"
 31 |         },
 32 |         {
 33 |           "price": "8300",
 34 |           "vol": "100%",
 35 |           "smart": true
 36 |         }
 37 |       ]
 38 |     },
 39 |     "stoploss": {
 40 |       "type": "FIXED",
 41 |       "limit_price_threshold": "0.50%",
 42 |       "initial_target": {
 43 |         "price": "9600",
 44 |         "vol": "100%"
 45 |       }
 46 |     }
 47 |   }
 48 | }
 49 | ```
 50 | 
 51 | ## Example 2 TRX-BTC Trailing
 52 | This trade has trailing stop loss and trailing profits last order. The execution flow is the following:
 53 | 1. There is no default stop loss. Trailing stop loss (00000650) will be activated only after at least one exit target is executed. 
 54 | 2. If target one hits (00000850), then it marked as completed, and it triggers trailing stop loss. It immediately raises
 55 | stop slos to 799 (6% of current price 850) and continue follows the price tightening stop loss.
 56 | 3. If target 2 hit, it cancels trailing stop loss, and sets it to the fixed value 00000900.
 57 | 4. If target 3 hit, it triggers back trailing stop loss and raises it to 00001023.
 58 | 5. If target 4 hit, it activates trailing profits with a small threshold 0.4%.
 59 | 6. The trade will be completed on a price pull back by triggered trailing profits stop limit order, as its threshold is less
 60 | than stop loss threshold.
 61 | 
 62 | ```json
 63 | {
 64 |   "trade": {
 65 |     "asset": "TRX",
 66 |     "symbol": "TRXBTC",
 67 |     "side": "SELL",
 68 |     "status": "ACTIVE",
 69 |     "exit": {
 70 |       "threshold": "0.40%",
 71 |       "targets": [
 72 |         {
 73 |           "price": "0.00000850",
 74 |           "vol": "25%"
 75 |         },
 76 |         {
 77 |           "price": "0.00001018",
 78 |           "vol": "33%",
 79 |           "sl": "0.00000900"
 80 |         },
 81 |         {
 82 |           "price": "0.00001088",
 83 |           "vol": "50%"
 84 |         },
 85 |         {
 86 |           "price": "0.00001140",
 87 |           "vol": "100%",
 88 |           "smart": true
 89 |         }
 90 |       ]
 91 |     },
 92 |     "stoploss": {
 93 |       "type": "TRAILING",
 94 |       "threshold": "6%",
 95 |       "initial_target": {
 96 |         "price": "0.00000650",
 97 |         "vol": "100%"
 98 |       }
 99 |     }
100 |   }
101 | }
102 | ```
103 | 


--------------------------------------------------------------------------------
/Docs/edit_view.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/iilunin/crypto-bot/0944641e9b2defb88d80dea03dd47c126f1c0b64/Docs/edit_view.png


--------------------------------------------------------------------------------
/Docs/grid_view.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/iilunin/crypto-bot/0944641e9b2defb88d80dea03dd47c126f1c0b64/Docs/grid_view.png


--------------------------------------------------------------------------------
/Docs/uf.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/iilunin/crypto-bot/0944641e9b2defb88d80dea03dd47c126f1c0b64/Docs/uf.png


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # Cryptobot
 2 | [![Build Status](https://dev.azure.com/iluninigor/CryptoBot/_apis/build/status/BuildImage?branchName=develop)](https://dev.azure.com/iluninigor/CryptoBot/_build/latest?definitionId=3&branchName=develop)
 3 | 
 4 | The main purpose of the bot is to keep track of your Binance trades while you're away. 
 5 | This bot is not supposed to earn money by itself, it requires targets and stop-loss inputs to follow your trades.
 6 | 
 7 | Binance REST API is based on [sammchardy/python-binance](https://github.com/sammchardy/python-binance) project
 8 | 
 9 | **Please read carefully all provided documentation before using the bot** 
10 | 
11 | ## Disclaimer
12 | - **Use it at your own risk.**
13 | - It is not a commercial project, immediate response and or fixes are not guaranteed.
14 | - This project was developed to improve my personal experience with Binance trading,
15 | I am not taking any responsibility for the outcomes you get when using it.  
16 | - Works on Mac and Amazon Linux. Other platforms were not verified.
17 | 
18 | ## Donations
19 | ![](./Docs/uf.png )
20 | 
21 | All donations will go to support people of Ukraine suffering from Russian invasion 
22 | - BTC - 357a3So9CbsNfBBgFYACGvxxS6tMaDoa1P
23 | - ETH and USDT (ERC-20) - 0x165CD37b4C644C2921454429E7F9358d18A45e14
24 | - $DOT: 1x8aa2N2Ar9SQweJv9vsuZn3WYDHu7gMQu1RePjZuBe33Hv.
25 | 
26 | ## Features
27 | - Simple Web User Interface 
28 | - Manage an unlimited number of trading pairs
29 | - Supports "smart" trade entry 
30 | - Unlimited exit targets 
31 | - Each exit target can be "smart" to gain max profits
32 | - Flexible stop loss settings: Fixed/Trialing + Custom SL after each target reached
33 | - One Cancels the Other functionality (OCO) 
34 | - FREE :)
35 | 
36 | Edit View: ![Edit View](./Docs/edit_view.png "Edit View")
37 | 
38 | ## Limitations
39 | - Can't have multiple trades for one trading pair
40 | - If you place orders manually, there is a chance they will be canceled by bot
41 | 
42 | ## Installation
43 | [Setup Instructions](./Docs/SETUP.md)
44 | 
45 | ## Flow
46 | [Flow Description](./Docs/FLOW.md)
47 | 
48 | ## Trade File
49 | [Trade File Description](./Docs/TRADE_FILE.md)
50 | 
51 | [Trade File Examples](./Docs/TRADE_FILE_EXAMPLES.md)
52 | 
53 | ## Management API (Coming soon)
54 | [API](./Docs/API.md)
55 | 
56 | ## Channels
57 | [Telegram Discussion Channel](https://t.me/CryptoTradingBotDiscussion)
58 | 
59 | [Telegram Announcement Channel](https://t.me/OpenSourceCryptoTradingBot)


--------------------------------------------------------------------------------
/Trades/TRADE_TEMPLATE.TPL:
--------------------------------------------------------------------------------
 1 | {
 2 |   "trade": {
 3 |     "asset": "ADA",
 4 |     "symbol": "ADABTC",
 5 |     "side": "SELL",
 6 |     "status": "NEW",
 7 |     "entry": {
 8 |       "targets": [
 9 |         {
10 |           "price": "0.00002950",
11 |           "vol": "1300"
12 |         }
13 |       ]
14 |     },
15 |     "exit": {
16 |       "threshold": "0.50%",
17 |       "targets": [
18 |         {
19 |           "price": "0.00003250",
20 |           "vol": "20%"
21 |         },
22 |         {
23 |           "price": "0.00003400",
24 |           "vol": "33%"
25 |         },
26 |         {
27 |           "price": "0.00003600",
28 |           "vol": "50%"
29 |         },
30 |         {
31 |           "vol": "100%",
32 |           "price": "0.00004100",
33 |           "smart": true
34 |         }
35 |       ]
36 |     },
37 |     "stoploss": {
38 |       "type": "FIXED",
39 |       "initial_target": {
40 |         "price": "0.00002500",
41 |         "vol": "100%"
42 |       }
43 |     }
44 |   }
45 | }


--------------------------------------------------------------------------------
/Utils/Logger.py:
--------------------------------------------------------------------------------
 1 | import logging
 2 | import os
 3 | from logging.handlers import TimedRotatingFileHandler, RotatingFileHandler
 4 | from os import environ, path, listdir
 5 | from os.path import isfile, join
 6 | 
 7 | LOG_FORMAT = '%(asctime)s[%(levelname)s][%(name)s|%(threadName)s]: %(message)s'
 8 | logging.basicConfig(level=logging.INFO, format=LOG_FORMAT)
 9 | 
10 | LOG_DIR = environ.get('LOGS_DIR')
11 | CURRENT_LOG_FN = path.join(LOG_DIR, 'log.txt') if LOG_DIR else None
12 | 
13 | if LOG_DIR:
14 |     handler = RotatingFileHandler(CURRENT_LOG_FN, maxBytes=1048576, backupCount=7)
15 |     handler.setFormatter(logging.Formatter(LOG_FORMAT))
16 | 
17 | class Logger:
18 |     def __init__(self, logger=None):
19 |         self.logger = logger if logger else logging.getLogger(self._get_logger_name())
20 | 
21 |         if LOG_DIR:
22 |             self.logger.addHandler(handler)
23 | 
24 |     def logInfo(self, msg):
25 |         self.logger.log(logging.INFO, msg)
26 | 
27 |     def logWarning(self, msg):
28 |         self.logger.log(logging.WARNING, msg)
29 | 
30 |     def logError(self, msg):
31 |         self.logger.log(logging.ERROR, msg)
32 | 
33 |     def logDebug(self, msg):
34 |         self.logger.log(logging.DEBUG, msg)
35 | 
36 |     def list_files(self):
37 |         if not LOG_DIR:
38 |             return None
39 | 
40 |         return [f for f in listdir(LOG_DIR) if isfile(join(LOG_DIR, f))]
41 | 
42 |     def get_file_contents(self, file):
43 |         if not file:
44 |             file = CURRENT_LOG_FN
45 |         f = open(file, 'r')
46 |         return f.read()
47 | 
48 | 
49 |     def _get_logger_name(self):
50 |         return self.__class__.__name__
51 | 
52 | 


--------------------------------------------------------------------------------
/Utils/Utils.py:
--------------------------------------------------------------------------------
 1 | import os
 2 | 
 3 | 
 4 | def get_symbol_and_id_from_file_path(file_path):
 5 |     file_name, _ = os.path.splitext(os.path.basename(file_path))
 6 |     parts = file_name.split('_')
 7 |     return parts[0], parts[1] if len(parts) > 1 else None
 8 | 
 9 | def get_file_name(symbol, id):
10 |     return '{}_{}.json'.format(symbol, id)
11 | 
12 | 
13 | def s2b(s):
14 |     if isinstance(s, bool):
15 |         return s
16 |     if s is None:
17 |         return None
18 |     if s.lower() in ['true', 'yes', '1']:
19 |         return True
20 |     return False
21 | 
22 | def is_simulation():
23 |     return s2b(os.environ.get("SIMULTATE", False))
24 | 


--------------------------------------------------------------------------------
/Utils/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/iilunin/crypto-bot/0944641e9b2defb88d80dea03dd47c126f1c0b64/Utils/__init__.py


--------------------------------------------------------------------------------
/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/iilunin/crypto-bot/0944641e9b2defb88d80dea03dd47c126f1c0b64/__init__.py


--------------------------------------------------------------------------------
/admin/.browserslistrc:
--------------------------------------------------------------------------------
1 | # This file is currently used by autoprefixer to adjust CSS to support the below specified browsers
2 | # For additional information regarding the format and rule options, please see:
3 | # https://github.com/browserslist/browserslist#queries
4 | # For IE 9-11 support, please uncomment the last line of the file and adjust as needed
5 | > 0.5%
6 | last 2 versions
7 | Firefox ESR
8 | not dead
9 | # IE 9-11


--------------------------------------------------------------------------------
/admin/.editorconfig:
--------------------------------------------------------------------------------
 1 | # Editor configuration, see http://editorconfig.org
 2 | root = true
 3 | 
 4 | [*]
 5 | charset = utf-8
 6 | indent_style = space
 7 | indent_size = 2
 8 | insert_final_newline = true
 9 | trim_trailing_whitespace = true
10 | 
11 | [*.md]
12 | max_line_length = off
13 | trim_trailing_whitespace = false
14 | 


--------------------------------------------------------------------------------
/admin/.gitignore:
--------------------------------------------------------------------------------
 1 | # See http://help.github.com/ignore-files/ for more about ignoring files.
 2 | 
 3 | # compiled output
 4 | /dist
 5 | /tmp
 6 | /out-tsc
 7 | 
 8 | # dependencies
 9 | /node_modules
10 | 
11 | # IDEs and editors
12 | /.idea
13 | .project
14 | .classpath
15 | .c9/
16 | *.launch
17 | .settings/
18 | *.sublime-workspace
19 | 
20 | # IDE - VSCode
21 | .vscode/*
22 | !.vscode/settings.json
23 | !.vscode/tasks.json
24 | !.vscode/launch.json
25 | !.vscode/extensions.json
26 | 
27 | # misc
28 | /.sass-cache
29 | /connect.lock
30 | /coverage
31 | /libpeerconnection.log
32 | npm-debug.log
33 | yarn-error.log
34 | testem.log
35 | /typings
36 | 
37 | # System Files
38 | .DS_Store
39 | Thumbs.db
40 | 


--------------------------------------------------------------------------------
/admin/README.md:
--------------------------------------------------------------------------------
 1 | ng# Admin
 2 | 
 3 | This project was generated with [Angular CLI](https://github.com/angular/angular-cli) version 6.0.3.
 4 | 
 5 | ## Development server
 6 | 
 7 | Run `ng serve` for a dev server. Navigate to `http://localhost:4200/`. The app will automatically reload if you change any of the source files.
 8 | 
 9 | ## Code scaffolding
10 | 
11 | Run `ng generate component component-name` to generate a new component. You can also use `ng generate directive|pipe|service|class|guard|interface|enum|module`.
12 | 
13 | ## Build
14 | 
15 | Run `ng build` to build the project. The build artifacts will be stored in the `dist/` directory. Use the `--prod` flag for a production build.
16 | 
17 | ## Running unit tests
18 | 
19 | Run `ng test` to execute the unit tests via [Karma](https://karma-runner.github.io).
20 | 
21 | ## Running end-to-end tests
22 | 
23 | Run `ng e2e` to execute the end-to-end tests via [Protractor](http://www.protractortest.org/).
24 | 
25 | ## Further help
26 | 
27 | To get more help on the Angular CLI use `ng help` or go check out the [Angular CLI README](https://github.com/angular/angular-cli/blob/master/README.md).
28 | 


--------------------------------------------------------------------------------
/admin/angular.json:
--------------------------------------------------------------------------------
  1 | {
  2 |   "$schema": "./node_modules/@angular/cli/lib/config/schema.json",
  3 |   "cli": {
  4 |     "analytics": false
  5 |   },
  6 |   "version": 1,
  7 |   "newProjectRoot": "projects",
  8 |   "projects": {
  9 |     "admin": {
 10 |       "root": "",
 11 |       "sourceRoot": "src",
 12 |       "projectType": "application",
 13 |       "prefix": "app",
 14 |       "schematics": {},
 15 |       "architect": {
 16 |         "build": {
 17 |           "builder": "@angular-devkit/build-angular:browser",
 18 |           "options": {
 19 |             "outputPath": "dist/admin",
 20 |             "index": "src/index.html",
 21 |             "main": "src/main.ts",
 22 |             "polyfills": "src/polyfills.ts",
 23 |             "tsConfig": "src/tsconfig.app.json",
 24 |             "assets": [
 25 |               "src/favicon.ico",
 26 |               "src/assets"
 27 |             ],
 28 |             "styles": [
 29 |               "./node_modules/@angular/material/prebuilt-themes/deeppurple-amber.css",
 30 |               "src/styles.css"
 31 |             ],
 32 |             "scripts": [],
 33 |             "aot": true
 34 |           },
 35 |           "configurations": {
 36 |             "production": {
 37 |               "fileReplacements": [
 38 |                 {
 39 |                   "replace": "src/environments/environment.ts",
 40 |                   "with": "src/environments/environment.prod.ts"
 41 |                 }
 42 |               ],
 43 |               "optimization": true,
 44 |               "outputHashing": "all",
 45 |               "sourceMap": false,
 46 |               "namedChunks": false,
 47 |               "extractLicenses": true,
 48 |               "vendorChunk": false,
 49 |               "buildOptimizer": true,
 50 |               "budgets": [
 51 |                 {
 52 |                   "type": "anyComponentStyle",
 53 |                   "maximumWarning": "6kb"
 54 |                 }
 55 |               ]
 56 |             },
 57 |             "test": {
 58 |               "fileReplacements": [
 59 |                 {
 60 |                   "replace": "src/environments/environment.ts",
 61 |                   "with": "src/environments/environment.test.ts"
 62 |                 }
 63 |               ],
 64 |               "budgets": [
 65 |                 {
 66 |                   "type": "anyComponentStyle",
 67 |                   "maximumWarning": "6kb"
 68 |                 }
 69 |               ]
 70 |             }
 71 |           }
 72 |         },
 73 |         "serve": {
 74 |           "builder": "@angular-devkit/build-angular:dev-server",
 75 |           "options": {
 76 |             "browserTarget": "admin:build"
 77 |           },
 78 |           "configurations": {
 79 |             "production": {
 80 |               "browserTarget": "admin:build:production"
 81 |             },
 82 |             "test": {
 83 |               "browserTarget": "admin:build:test"
 84 |             }
 85 |           }
 86 |         },
 87 |         "extract-i18n": {
 88 |           "builder": "@angular-devkit/build-angular:extract-i18n",
 89 |           "options": {
 90 |             "browserTarget": "admin:build"
 91 |           }
 92 |         },
 93 |         "test": {
 94 |           "builder": "@angular-devkit/build-angular:karma",
 95 |           "options": {
 96 |             "main": "src/test.ts",
 97 |             "polyfills": "src/polyfills.ts",
 98 |             "tsConfig": "src/tsconfig.spec.json",
 99 |             "karmaConfig": "src/karma.conf.js",
100 |             "styles": [
101 |               "./node_modules/@angular/material/prebuilt-themes/deeppurple-amber.css",
102 |               "src/styles.css"
103 |             ],
104 |             "scripts": [],
105 |             "assets": [
106 |               "src/favicon.ico",
107 |               "src/assets"
108 |             ]
109 |           }
110 |         },
111 |         "lint": {
112 |           "builder": "@angular-devkit/build-angular:tslint",
113 |           "options": {
114 |             "tsConfig": [
115 |               "src/tsconfig.app.json",
116 |               "src/tsconfig.spec.json"
117 |             ],
118 |             "exclude": [
119 |               "**/node_modules/**"
120 |             ]
121 |           }
122 |         }
123 |       }
124 |     },
125 |     "admin-e2e": {
126 |       "root": "e2e/",
127 |       "projectType": "application",
128 |       "architect": {
129 |         "e2e": {
130 |           "builder": "@angular-devkit/build-angular:protractor",
131 |           "options": {
132 |             "protractorConfig": "e2e/protractor.conf.js",
133 |             "devServerTarget": "admin:serve"
134 |           }
135 |         },
136 |         "lint": {
137 |           "builder": "@angular-devkit/build-angular:tslint",
138 |           "options": {
139 |             "tsConfig": "e2e/tsconfig.e2e.json",
140 |             "exclude": [
141 |               "**/node_modules/**"
142 |             ]
143 |           }
144 |         }
145 |       }
146 |     }
147 |   },
148 |   "defaultProject": "admin"
149 | }
150 | 


--------------------------------------------------------------------------------
/admin/e2e/protractor.conf.js:
--------------------------------------------------------------------------------
 1 | // Protractor configuration file, see link for more information
 2 | // https://github.com/angular/protractor/blob/master/lib/config.ts
 3 | 
 4 | const { SpecReporter } = require('jasmine-spec-reporter');
 5 | 
 6 | exports.config = {
 7 |   allScriptsTimeout: 11000,
 8 |   specs: [
 9 |     './src/**/*.e2e-spec.ts'
10 |   ],
11 |   capabilities: {
12 |     'browserName': 'chrome'
13 |   },
14 |   directConnect: true,
15 |   baseUrl: 'http://localhost:4200/',
16 |   framework: 'jasmine',
17 |   jasmineNodeOpts: {
18 |     showColors: true,
19 |     defaultTimeoutInterval: 30000,
20 |     print: function() {}
21 |   },
22 |   onPrepare() {
23 |     require('ts-node').register({
24 |       project: require('path').join(__dirname, './tsconfig.e2e.json')
25 |     });
26 |     jasmine.getEnv().addReporter(new SpecReporter({ spec: { displayStacktrace: true } }));
27 |   }
28 | };


--------------------------------------------------------------------------------
/admin/e2e/src/app.e2e-spec.ts:
--------------------------------------------------------------------------------
 1 | import { AppPage } from './app.po';
 2 | 
 3 | describe('workspace-project App', () => {
 4 |   let page: AppPage;
 5 | 
 6 |   beforeEach(() => {
 7 |     page = new AppPage();
 8 |   });
 9 | 
10 |   it('should display welcome message', () => {
11 |     page.navigateTo();
12 |     expect(page.getParagraphText()).toEqual('Welcome to app!');
13 |   });
14 | });
15 | 


--------------------------------------------------------------------------------
/admin/e2e/src/app.po.ts:
--------------------------------------------------------------------------------
 1 | import { browser, by, element } from 'protractor';
 2 | 
 3 | export class AppPage {
 4 |   navigateTo() {
 5 |     return browser.get('/');
 6 |   }
 7 | 
 8 |   getParagraphText() {
 9 |     return element(by.css('app-root h1')).getText();
10 |   }
11 | }
12 | 


--------------------------------------------------------------------------------
/admin/e2e/tsconfig.e2e.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "extends": "../tsconfig.json",
 3 |   "compilerOptions": {
 4 |     "outDir": "../out-tsc/app",
 5 |     "module": "commonjs",
 6 |     "target": "es5",
 7 |     "types": [
 8 |       "jasmine",
 9 |       "jasminewd2",
10 |       "node"
11 |     ]
12 |   }
13 | }


--------------------------------------------------------------------------------
/admin/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "admin",
 3 |   "version": "0.0.0",
 4 |   "scripts": {
 5 |     "ng": "ng",
 6 |     "start": "ng serve",
 7 |     "start-testnet": "ng serve --configuration=test",
 8 |     "build": "ng build",
 9 |     "build-prod": "ng build --prod",
10 |     "build-testnet": "ng build --configuration=test",
11 |     "test": "ng test",
12 |     "lint": "ng lint",
13 |     "e2e": "ng e2e"
14 |   },
15 |   "private": true,
16 |   "dependencies": {
17 |     "@angular/animations": "^11.2.14",
18 |     "@angular/cdk": "^11.2.13",
19 |     "@angular/common": "^11.2.14",
20 |     "@angular/compiler": "^11.2.14",
21 |     "@angular/core": "^11.2.14",
22 |     "@angular/forms": "^11.2.14",
23 |     "@angular/localize": "^11.2.14",
24 |     "@angular/material": "^11.2.13",
25 |     "@angular/platform-browser": "^11.2.14",
26 |     "@angular/platform-browser-dynamic": "^11.2.14",
27 |     "@angular/router": "^11.2.14",
28 |     "@schematics/angular": "^11.2.18",
29 |     "core-js": "^2.6.12",
30 |     "iconv": "^3.0.1",
31 |     "moment": "^2.29.1",
32 |     "open-iconic": "^1.1.1",
33 |     "rxjs": "^6.6.7",
34 |     "tslib": "^2.3.1",
35 |     "zone.js": "^0.11.5"
36 |   },
37 |   "devDependencies": {
38 |     "@angular-devkit/build-angular": "^0.1102.18",
39 |     "@angular/cli": "^11.2.18",
40 |     "@angular/compiler-cli": "^11.2.14",
41 |     "@angular/language-service": "^11.2.14",
42 |     "@types/jasmine": "^3.6.11",
43 |     "@types/jasminewd2": "^2.0.10",
44 |     "@types/node": "^12.20.47",
45 |     "codelyzer": "^6.0.2",
46 |     "jasmine-core": "~3.6.0",
47 |     "jasmine-spec-reporter": "~5.0.0",
48 |     "karma": "~5.0.0",
49 |     "karma-chrome-launcher": "^3.1.1",
50 |     "karma-coverage-istanbul-reporter": "~3.0.2",
51 |     "karma-jasmine": "~4.0.0",
52 |     "karma-jasmine-html-reporter": "^1.7.0",
53 |     "protractor": "~7.0.0",
54 |     "ts-node": "~5.0.1",
55 |     "tslint": "~6.1.0",
56 |     "typescript": "^4.1.6"
57 |   }
58 | }
59 | 


--------------------------------------------------------------------------------
/admin/src/app/apiresult.ts:
--------------------------------------------------------------------------------
1 | export class ApiResult {
2 |   status?: number;
3 |   msg?: string;
4 | }
5 | 


--------------------------------------------------------------------------------
/admin/src/app/app.component.css:
--------------------------------------------------------------------------------
1 | .login-ctrl{
2 |     display: flow-root; 
3 |     width: 100%;
4 | }


--------------------------------------------------------------------------------
/admin/src/app/app.component.html:
--------------------------------------------------------------------------------
1 | <!--The content below is only a placeholder and can be replaced.-->
2 | <div role="main">
3 |   <div class="login-ctrl">
4 |     <app-log-in *ngIf="!auth.isLoggedIn()"></app-log-in>
5 |   </div>
6 |   <app-main-tabs *ngIf="auth.isLoggedIn()"></app-main-tabs>
7 | </div>
8 | 


--------------------------------------------------------------------------------
/admin/src/app/app.component.spec.ts:
--------------------------------------------------------------------------------
 1 | import { TestBed, waitForAsync } from '@angular/core/testing';
 2 | import { AppComponent } from './app.component';
 3 | describe('AppComponent', () => {
 4 |   beforeEach(waitForAsync(() => {
 5 |     TestBed.configureTestingModule({
 6 |       declarations: [
 7 |         AppComponent
 8 |       ],
 9 |     }).compileComponents();
10 |   }));
11 |   it('should create the app', waitForAsync(() => {
12 |     const fixture = TestBed.createComponent(AppComponent);
13 |     const app = fixture.debugElement.componentInstance;
14 |     expect(app).toBeTruthy();
15 |   }));
16 |   it(`should have as title 'app'`, waitForAsync(() => {
17 |     const fixture = TestBed.createComponent(AppComponent);
18 |     const app = fixture.debugElement.componentInstance;
19 |     expect(app.title).toEqual('app');
20 |   }));
21 |   it('should render title in a h1 tag', waitForAsync(() => {
22 |     const fixture = TestBed.createComponent(AppComponent);
23 |     fixture.detectChanges();
24 |     const compiled = fixture.debugElement.nativeElement;
25 |     expect(compiled.querySelector('h1').textContent).toContain('Welcome to admin!');
26 |   }));
27 | });
28 | 


--------------------------------------------------------------------------------
/admin/src/app/app.component.ts:
--------------------------------------------------------------------------------
 1 | import { Component } from '@angular/core';
 2 | import { MatIconRegistry } from '@angular/material/icon';
 3 | import { MatSnackBar } from '@angular/material/snack-bar';
 4 | import { DomSanitizer } from '@angular/platform-browser';
 5 | import { AuthService } from './auth.service';
 6 | import { BotApi } from './botapi';
 7 | import { NotificationService, NotificatoinType } from './services/notification.service'
 8 | 
 9 | @Component({
10 |   selector: 'app-root',
11 |   templateUrl: './app.component.html',
12 |   styleUrls: ['./app.component.css']
13 | })
14 | 
15 | export class AppComponent {
16 |   title = 'Crypto Bot';
17 | 
18 |   constructor(
19 |     private notificationService: NotificationService, 
20 |     private snackBar: MatSnackBar,
21 |     public auth: AuthService,
22 |     private matIconRegistry: MatIconRegistry,
23 |     private domSanitizer: DomSanitizer,
24 |     private bot: BotApi
25 |   ) {
26 |     this.notificationService.notification$.subscribe(message => {
27 |       
28 |       this.snackBar.open(message.contents, message.action, 
29 |         { 
30 |           duration: 3000,
31 |           panelClass: [this.getPanelClass(message.type)]});
32 |           // panelClass: ["blue-snackbar"]});
33 |     });
34 |     
35 |     this.matIconRegistry.addSvgIcon(  
36 |       'my_git', domSanitizer.bypassSecurityTrustResourceUrl(`${this.bot.API_URL}/proxy/icon`)
37 |     );
38 |   }
39 | 
40 |   private getPanelClass(type: NotificatoinType): string {
41 |     switch(type){
42 |       case NotificatoinType.Regular:
43 |         return 'snackbar-primary';
44 |       case NotificatoinType.Warning:
45 |         return 'snackbar-warning';
46 |       case NotificatoinType.Alert:
47 |         return 'snackbar-alarm'
48 |       default:
49 |         return '';
50 |     }
51 |     
52 |   }
53 | }
54 | 


--------------------------------------------------------------------------------
/admin/src/app/app.module.ts:
--------------------------------------------------------------------------------
  1 | import {NgModule} from '@angular/core';
  2 | import {BrowserModule} from '@angular/platform-browser';
  3 | 
  4 | import {TradesRoutingModule} from './trades-routing.module';
  5 | import { CommonModule } from '@angular/common';  
  6 | import {FormsModule, ReactiveFormsModule} from '@angular/forms';
  7 | import {AppComponent} from './app.component';
  8 | import {LogInComponent} from './log-in/log-in.component';
  9 | 
 10 | import {HTTP_INTERCEPTORS, HttpClientModule, HttpInterceptor} from '@angular/common/http';
 11 | import {WebsocketService} from './websocket.service';
 12 | import {AuthInterceptor} from './auth.interceptor';
 13 | import { BrowserAnimationsModule } from '@angular/platform-browser/animations';
 14 | import { AssetTableComponent } from './asset-table/asset-table.component';
 15 | import { EntryDetailsComponent } from './trade-details/entry-details.component';
 16 | import { TradeDetailsComponent } from './trade-details/trade-details.component';
 17 | import { ExitDetailsComponent } from './trade-details/exit-details.component';
 18 | import { SLDetailsComponent } from './trade-details/sl-details.component';
 19 | import { SymbolValidatorDirective } from './trade-details/symbol-validator';
 20 | 
 21 | // material
 22 | import {A11yModule} from '@angular/cdk/a11y';
 23 | import {ClipboardModule} from '@angular/cdk/clipboard';
 24 | import {DragDropModule} from '@angular/cdk/drag-drop';
 25 | import {PortalModule} from '@angular/cdk/portal';
 26 | import {ScrollingModule} from '@angular/cdk/scrolling';
 27 | import {CdkStepperModule} from '@angular/cdk/stepper';
 28 | import {CdkTableModule} from '@angular/cdk/table';
 29 | import {CdkTreeModule} from '@angular/cdk/tree';
 30 | import {MatAutocompleteModule} from '@angular/material/autocomplete';
 31 | import {MatBadgeModule} from '@angular/material/badge';
 32 | import {MatBottomSheetModule} from '@angular/material/bottom-sheet';
 33 | import {MatButtonModule} from '@angular/material/button';
 34 | import {MatButtonToggleModule} from '@angular/material/button-toggle';
 35 | import {MatCardModule} from '@angular/material/card';
 36 | import {MatCheckboxModule} from '@angular/material/checkbox';
 37 | import {MatChipsModule} from '@angular/material/chips';
 38 | import {MatStepperModule} from '@angular/material/stepper';
 39 | import {MatDatepickerModule} from '@angular/material/datepicker';
 40 | import {MatDialogModule, MAT_DIALOG_DEFAULT_OPTIONS} from '@angular/material/dialog';
 41 | import {MatDividerModule} from '@angular/material/divider';
 42 | import {MatExpansionModule} from '@angular/material/expansion';
 43 | import {MatGridListModule} from '@angular/material/grid-list';
 44 | import {MatIconModule} from '@angular/material/icon';
 45 | import {MatInputModule} from '@angular/material/input';
 46 | import {MatListModule} from '@angular/material/list';
 47 | import {MatMenuModule} from '@angular/material/menu';
 48 | import {MatNativeDateModule, MatRippleModule} from '@angular/material/core';
 49 | import {MatPaginatorModule} from '@angular/material/paginator';
 50 | import {MatProgressBarModule} from '@angular/material/progress-bar';
 51 | import {MatProgressSpinnerModule} from '@angular/material/progress-spinner';
 52 | import {MatRadioModule} from '@angular/material/radio';
 53 | import {MatSelectModule} from '@angular/material/select';
 54 | import {MatSidenavModule} from '@angular/material/sidenav';
 55 | import {MatSliderModule} from '@angular/material/slider';
 56 | import {MatSlideToggleModule} from '@angular/material/slide-toggle';
 57 | import {MatSnackBarModule} from '@angular/material/snack-bar';
 58 | import {MatSortModule} from '@angular/material/sort';
 59 | import {MatTableModule} from '@angular/material/table';
 60 | import {MatTabsModule} from '@angular/material/tabs';
 61 | import {MatToolbarModule} from '@angular/material/toolbar';
 62 | import {MatTooltipModule} from '@angular/material/tooltip';
 63 | import {MatTreeModule} from '@angular/material/tree';
 64 | import {OverlayModule} from '@angular/cdk/overlay';
 65 | import { MainTabsComponent } from './main-tabs/main-tabs.component';
 66 | import { BalancesComponent } from './balances/balances.component';
 67 | import { AutoCompleteComponent } from './auto-complete/auto-complete.component';
 68 | import { LogsComponent } from './logs/logs.component';
 69 | // endmaterial
 70 | // const schemas: any[] = [];
 71 | // schemas.push(CUSTOM_ELEMENTS_SCHEMA);
 72 | 
 73 | @NgModule({
 74 |   declarations: [
 75 |     AppComponent,
 76 |     AssetTableComponent,
 77 |     EntryDetailsComponent,
 78 |     TradeDetailsComponent,
 79 |     ExitDetailsComponent,
 80 |     SLDetailsComponent,
 81 |     SymbolValidatorDirective,
 82 |     LogInComponent,
 83 |     MainTabsComponent,
 84 |     BalancesComponent,
 85 |     AutoCompleteComponent,
 86 |     LogsComponent
 87 |   ],
 88 |   imports: [
 89 |     CommonModule,
 90 |     BrowserModule,
 91 |     FormsModule,
 92 |     HttpClientModule,
 93 |     TradesRoutingModule,
 94 |     BrowserAnimationsModule,
 95 |     A11yModule,
 96 |     ClipboardModule,
 97 |     CdkStepperModule,
 98 |     CdkTableModule,
 99 |     CdkTreeModule,
100 |     DragDropModule,
101 |     MatAutocompleteModule,
102 |     MatBadgeModule,
103 |     MatBottomSheetModule,
104 |     MatButtonModule,
105 |     MatButtonToggleModule,
106 |     MatCardModule,
107 |     MatCheckboxModule,
108 |     MatChipsModule,
109 |     MatStepperModule,
110 |     MatDatepickerModule,
111 |     MatDialogModule,
112 |     MatDividerModule,
113 |     MatExpansionModule,
114 |     MatGridListModule,
115 |     MatIconModule,
116 |     MatInputModule,
117 |     MatListModule,
118 |     MatMenuModule,
119 |     MatNativeDateModule,
120 |     MatPaginatorModule,
121 |     MatProgressBarModule,
122 |     MatProgressSpinnerModule,
123 |     MatRadioModule,
124 |     MatRippleModule,
125 |     MatSelectModule,
126 |     MatSidenavModule,
127 |     MatSliderModule,
128 |     MatSlideToggleModule,
129 |     MatSnackBarModule,
130 |     MatSortModule,
131 |     MatTableModule,
132 |     MatTabsModule,
133 |     MatToolbarModule,
134 |     MatTooltipModule,
135 |     MatTreeModule,
136 |     OverlayModule,
137 |     PortalModule,
138 |     ScrollingModule,
139 |     ReactiveFormsModule,
140 |   ],
141 |   providers: [WebsocketService,
142 |     {
143 |       provide: HTTP_INTERCEPTORS,
144 |       useClass: AuthInterceptor,
145 |       multi: true
146 |     },
147 |     {provide: MAT_DIALOG_DEFAULT_OPTIONS, useValue: {hasBackdrop: true}}],
148 |   bootstrap: [AppComponent]
149 |   // schemas: schemas
150 | })
151 | export class AppModule {
152 | }
153 | 


--------------------------------------------------------------------------------
/admin/src/app/asset-table/asset-table.component.css:
--------------------------------------------------------------------------------
 1 | th.mat-sort-header-sorted {
 2 |   color: black;
 3 | }
 4 | 
 5 | table {
 6 |   width: 100%;
 7 | }
 8 | 
 9 | .pause-btn {
10 |   color: rgb(197, 150, 21)
11 | }
12 | 


--------------------------------------------------------------------------------
/admin/src/app/asset-table/asset-table.component.html:
--------------------------------------------------------------------------------
 1 | <div>
 2 |   <table mat-table [dataSource]="tradesDS" matSort class="mat-elevation-z2" >
 3 |     
 4 |     <ng-container matColumnDef="ctrl-view-edit">
 5 |       <th style="width: 8%" mat-header-cell *matHeaderCellDef>
 6 |       <button mat-icon-button matTooltip="Refresh trade list" (click)="refreshTrades()">
 7 |         <mat-icon>refresh</mat-icon>
 8 |       </button>
 9 |       <button mat-icon-button class="resume-btn" matTooltip="Create new trade" (click)="onTradeInfo(null, TradeDetailMode.Create)">
10 |         <mat-icon>add_circle_outline</mat-icon>
11 |       </button>
12 |       <td mat-cell *matCellDef="let trade">
13 |         <!-- <button type="button" class="btn btn-sm btn-outline-info"  (click)="onTradeInfo(trade, TradeDetailMode.View)" [disabled]="tradesDisabled.has(trade.id)" tooltip="Trade Info">
14 |           <span class="oi oi-eye"></span>
15 |         </button> -->
16 |         <button mat-icon-button class="pause-btn" matTooltip="Edit trade '{{trade.sym}}'" (click)="onTradeInfo(trade, TradeDetailMode.Edit)" [disabled]="tradesDisabled.has(trade.id)">
17 |           <mat-icon>edit</mat-icon>
18 |         </button>
19 |       </td>
20 |     </ng-container>
21 |     <ng-container matColumnDef="sym">
22 |       <th style="width: 14%" mat-header-cell *matHeaderCellDef mat-sort-header="sym">Symbol </th>
23 |       <td mat-cell *matCellDef="let trade">{{trade.sym}}</td>
24 |     </ng-container>
25 | 
26 |     <ng-container matColumnDef="btc-val">
27 |       <th style="width: 15%" mat-header-cell *matHeaderCellDef mat-sort-header="btcVal">Value</th>
28 |       <td mat-cell *matCellDef="let trade">{{ trade.btcVal | number:'1.6-6' }}</td>
29 |     </ng-container>
30 | 
31 |     <ng-container matColumnDef="price">
32 |       <th style="width: 15%" mat-header-cell *matHeaderCellDef mat-sort-header="price">Price</th>
33 |       <td mat-cell *matCellDef="let trade">{{ trade.price | number:'1.8-8' }}</td>
34 |     </ng-container>
35 | 
36 |     <ng-container matColumnDef="balance">
37 |       <th style="width: 15%" mat-header-cell *matHeaderCellDef mat-sort-header="balance">Balance</th>
38 |       <td mat-cell *matCellDef="let trade">{{ trade.balance | number:'1.2-6' }}</td>
39 |     </ng-container>
40 |     
41 |     <ng-container matColumnDef="ctrl-pause">
42 |       <th style="width: 8%" mat-header-cell *matHeaderCellDef>
43 |         <button mat-icon-button matTooltip="Pause All Trades" class="pause_btn" [disabled]="trades.length == 0" (click)="onPauseAll()">
44 |           <mat-icon>pause_circle_outline</mat-icon>
45 |         </button>
46 |         <button mat-icon-button matTooltip="Resume all trades" class="resume_btn" [disabled]="trades.length == 0" (click)="onResumeAll()">
47 |           <mat-icon>play_circle_outline</mat-icon>
48 |         </button>
49 |       </th>
50 |       <td mat-cell *matCellDef="let trade">
51 |         <button mat-icon-button matTooltip="{{ trade.paused? 'Resume': 'Pause' }} trade" class="{{ trade.paused? 'resume_btn' : 'pause_btn' }}" (click)="onPauseResume(trade)" [disabled]="tradesDisabled.has(trade.id)" >
52 |           <mat-icon>{{ trade.paused? 'play_circle_outline': 'pause_circle_outline' }}</mat-icon>
53 |         </button>
54 |       </td>
55 |     </ng-container>
56 | 
57 |     <ng-container matColumnDef="ctrl-close">
58 |       <th style="width: 5%" mat-header-cell *matHeaderCellDef>Close</th>
59 |       <td mat-cell *matCellDef="let trade">
60 |       <button mat-icon-button color="warn" aria-label="Sell Off" (click)="openModal(modal_template, trade, true)" [disabled]="tradesDisabled.has(trade.id)" tooltip="Sell Off" >
61 |         <mat-icon>attach_money</mat-icon>
62 |       </button>
63 |     </td>
64 |     </ng-container>
65 | 
66 |     <ng-container matColumnDef="ctrl-remove">
67 |       <th style="width: 5%" mat-header-cell *matHeaderCellDef>Remove</th>
68 |       <td mat-cell *matCellDef="let trade">
69 |         <button mat-icon-button color="warn" aria-label="Remove trade" matTooltip="Remove trade" (click)="openModal(modal_template, trade, false)" [disabled]="tradesDisabled.has(trade.id)">
70 |           <mat-icon>delete_outline</mat-icon>
71 |         </button>
72 |       </td>
73 |     </ng-container>
74 | 
75 |     <tr mat-header-row *matHeaderRowDef="displayedColumns"></tr>
76 |     <tr mat-row *matRowDef="let row; columns: displayedColumns;"></tr>
77 |   </table>
78 | 
79 |   <ng-template #modal_template>
80 |     <h2 mat-dialog-title>{{isCloseTradeAction ? 'Cancel' : 'Delete'}} {{'"' + selectedTrade.sym + '"'}} Trade?</h2>
81 |     <div mat-dialog-content>Please confirm if you want to {{isCloseTradeAction ? 'cancel' : 'delete' }} this trade</div>
82 |     <div mat-dialog-actions align="end">
83 |         <button mat-button mat-dialog-close="cancel" (click)="decline()" color="primary" cdkFocusInitial>No</button>
84 |         <button mat-button mat-dialog-close="ok"  (click)="confirm()" color="primary">Yes</button>
85 |     </div>
86 |   </ng-template>
87 | 
88 | </div>
89 | 
90 | 


--------------------------------------------------------------------------------
/admin/src/app/asset-table/asset-table.component.spec.ts:
--------------------------------------------------------------------------------
 1 | import { ComponentFixture, TestBed, waitForAsync } from '@angular/core/testing';
 2 | 
 3 | import { AssetTableComponent } from './asset-table.component';
 4 | 
 5 | describe('AssetTableComponent', () => {
 6 |   let component: AssetTableComponent;
 7 |   let fixture: ComponentFixture<AssetTableComponent>;
 8 | 
 9 |   beforeEach(waitForAsync(() => {
10 |     TestBed.configureTestingModule({
11 |       declarations: [ AssetTableComponent ]
12 |     })
13 |     .compileComponents();
14 |   }));
15 | 
16 |   beforeEach(() => {
17 |     fixture = TestBed.createComponent(AssetTableComponent);
18 |     component = fixture.componentInstance;
19 |     fixture.detectChanges();
20 |   });
21 | 
22 |   it('should create', () => {
23 |     expect(component).toBeTruthy();
24 |   });
25 | });
26 | 


--------------------------------------------------------------------------------
/admin/src/app/auth.interceptor.ts:
--------------------------------------------------------------------------------
 1 | import {HttpEvent, HttpHandler, HttpInterceptor, HttpRequest} from '@angular/common/http';
 2 | import {Observable} from 'rxjs';
 3 | import {Injectable} from '@angular/core';
 4 | 
 5 | @Injectable()
 6 | export class AuthInterceptor implements HttpInterceptor {
 7 | 
 8 |   intercept(req: HttpRequest<any>,
 9 |             next: HttpHandler): Observable<HttpEvent<any>> {
10 | 
11 |     const idToken = localStorage.getItem('token');
12 | 
13 |     if (idToken) {
14 |       const cloned = req.clone({
15 |         headers: req.headers.set('Authorization',
16 |           'Bearer ' + idToken)
17 |       });
18 | 
19 |       return next.handle(cloned);
20 |     } else {
21 |       return next.handle(req);
22 |     }
23 |   }
24 | }
25 | 
26 | 


--------------------------------------------------------------------------------
/admin/src/app/auth.service.ts:
--------------------------------------------------------------------------------
 1 | import {HttpClient, HttpHeaders} from '@angular/common/http';
 2 | import {Injectable} from '@angular/core';
 3 | import {tap} from 'rxjs/operators';
 4 | import * as  moment from 'moment';
 5 | import {Observable, Subject} from 'rxjs';
 6 | import {environment} from '../environments/environment';
 7 | 
 8 | const httpOptions = {
 9 |   headers: new HttpHeaders({
10 |     'Content-Type':  'application/json'
11 |   })
12 | };
13 | 
14 | @Injectable({ providedIn: 'root' })
15 | export class AuthService {
16 |   API_URL = `${environment.BOT_API_URL}/api/v1`;
17 | 
18 |   private loginAnouceSource = new Subject<boolean>();
19 |   loginEventAnounced$ =  this.loginAnouceSource.asObservable();
20 | 
21 |   constructor(private http: HttpClient) {
22 |     console.log(this.API_URL);
23 |   }
24 | 
25 |   login(user: string, password: string): Observable<any> {
26 |     return this.http.post<any>(`${this.API_URL}/auth`, {'username': user, 'password': password}, httpOptions).pipe(
27 |       tap(authResult => this.setSession(authResult))
28 |     );
29 |   }
30 | 
31 |   private setSession(authResult) {
32 |     const expiresAt = moment().add(authResult.exp, 'second');
33 | 
34 |     localStorage.setItem('token', authResult.jwt);
35 |     localStorage.setItem('exp', JSON.stringify(expiresAt.valueOf()) );
36 |     this.loginAnouceSource.next(true);
37 |   }
38 | 
39 |   logout() {
40 |     localStorage.removeItem('token');
41 |     localStorage.removeItem('exp');
42 |     this.loginAnouceSource.next(false);
43 |   }
44 | 
45 |   public isLoggedIn() {
46 |     return moment().isBefore(this.getExpiration());
47 |   }
48 | 
49 |   isLoggedOut() {
50 |     return !this.isLoggedIn();
51 |   }
52 | 
53 |   getExpiration() {
54 |     const expiration = localStorage.getItem('exp');
55 |     const expiresAt = JSON.parse(expiration);
56 |     return moment(expiresAt);
57 |   }
58 | }
59 | 


--------------------------------------------------------------------------------
/admin/src/app/auto-complete/auto-complete.component.css:
--------------------------------------------------------------------------------
1 | .full-width {
2 |     width: 100%;
3 | }


--------------------------------------------------------------------------------
/admin/src/app/auto-complete/auto-complete.component.html:
--------------------------------------------------------------------------------
 1 | <mat-form-field class="full-width" appearance="{{ appearance }}">
 2 | 	<mat-label>{{ label }}</mat-label>
 3 | 	<input #validatedInput
 4 |     matInput
 5 | 	[disabled]="disabled"
 6 | 	type="text"
 7 |     placeholder="{{ placeHolder }}"
 8 |     [matAutocomplete]="inputAuto"
 9 |     [formControl]="fieldCtrl"
10 | 	[class]="class"
11 |     (keyup)="onSelect($event)"
12 | 	autocomplete="off" 
13 | 	[appSymbolValidator]="smartList"
14 | 	[(ngModel)]="model"
15 | 	oninput="this.value = this.value.toUpperCase()"
16 | 	required
17 |   />
18 |   <mat-hint>Start typing symbols</mat-hint>
19 | 	<mat-error *ngIf="fieldCtrl.hasError('appSymbolValidator') && !fieldCtrl.hasError('required')">
20 | 		Please enter a valid symbol
21 | 	</mat-error>
22 | 	<mat-error *ngIf="fieldCtrl.hasError('required')">
23 | 		Symbol is <strong>required</strong>
24 | 	</mat-error> 
25 | 	<mat-autocomplete #inputAuto="matAutocomplete" showPanel="true"
26 | 		(optionsScroll)="onScroll()" [displayWith]="displayFn">
27 | 		<mat-option *ngFor="let element of filteredList | async" [value]="element" (click)="onSelect(element)"
28 | 			[title]="element">{{element}}
29 | 		</mat-option>
30 | 	</mat-autocomplete>
31 | </mat-form-field>


--------------------------------------------------------------------------------
/admin/src/app/auto-complete/auto-complete.component.spec.ts:
--------------------------------------------------------------------------------
 1 | import { ComponentFixture, TestBed } from '@angular/core/testing';
 2 | 
 3 | import { AutoCompleteComponent } from './auto-complete.component';
 4 | 
 5 | describe('AutoCompleteComponent', () => {
 6 |   let component: AutoCompleteComponent;
 7 |   let fixture: ComponentFixture<AutoCompleteComponent>;
 8 | 
 9 |   beforeEach(async () => {
10 |     await TestBed.configureTestingModule({
11 |       declarations: [ AutoCompleteComponent ]
12 |     })
13 |     .compileComponents();
14 |   });
15 | 
16 |   beforeEach(() => {
17 |     fixture = TestBed.createComponent(AutoCompleteComponent);
18 |     component = fixture.componentInstance;
19 |     fixture.detectChanges();
20 |   });
21 | 
22 |   it('should create', () => {
23 |     expect(component).toBeTruthy();
24 |   });
25 | });
26 | 


--------------------------------------------------------------------------------
/admin/src/app/auto-complete/auto-complete.component.ts:
--------------------------------------------------------------------------------
  1 | import {
  2 |   Component,
  3 |   OnInit,
  4 |   Input,
  5 |   Output,
  6 |   EventEmitter,
  7 |   OnDestroy,
  8 |   ViewChild,
  9 |   ElementRef
 10 | } from "@angular/core";
 11 | import { FormControl, FormGroupDirective, NgForm } from "@angular/forms";
 12 | import { Observable, of, Subject } from "rxjs";
 13 | import {
 14 |   startWith,
 15 |   map,
 16 |   debounceTime,
 17 |   filter,
 18 |   switchMap,
 19 |   exhaustMap,
 20 |   tap,
 21 |   scan,
 22 |   takeWhile
 23 | } from "rxjs/operators";
 24 | 
 25 | import {ErrorStateMatcher} from '@angular/material/core';
 26 | 
 27 | /** Error when invalid control is dirty, touched, or submitted. */
 28 | export class MyErrorStateMatcher implements ErrorStateMatcher {
 29 |   isErrorState(control: FormControl | null, form: FormGroupDirective | NgForm | null): boolean {
 30 |     const isSubmitted = form && form.submitted;
 31 |     return !!(control && control.invalid && (control.dirty || control.touched || isSubmitted));
 32 |   }
 33 | }
 34 | 
 35 | export interface MatInput {
 36 |   id: number | string;
 37 |   name: string;
 38 |   sequence?: number;
 39 | }
 40 | 
 41 | @Component({
 42 |   selector: "app-auto-complete",
 43 |   templateUrl: "./auto-complete.component.html",
 44 |   styleUrls: ["./auto-complete.component.css"]
 45 | })
 46 | export class AutoCompleteComponent implements OnInit, OnDestroy {
 47 |   @ViewChild('validatedInput') validatedInputCtrl: ElementRef; 
 48 |   @Input() fieldCtrl: FormControl;
 49 |   smartList = [];
 50 | 
 51 |   @Input("smartList") set updateSmartList(data: any) {
 52 |     if (data && data.length) {
 53 |       this.smartList = data;
 54 |       this.getFilteredList();
 55 |     } else {
 56 |       this.smartList = [];
 57 |       this.getFilteredList();
 58 |     }
 59 |   }
 60 |   @Input() defaultValue?: any;
 61 |   @Input() placeHolder: string;
 62 |   @Input() appearance?: string;
 63 |   @Input() label?: string;
 64 |   @Input() model?: any;
 65 |   @Input() class?: string;
 66 |   @Input() disabled?: boolean;
 67 | 
 68 |   @Output() optionSelected = new EventEmitter();
 69 |   toHighlight = "";
 70 |   filteredList: Observable<MatInput[]>;
 71 |   private nextPage$ = new Subject();
 72 | 
 73 |   constructor() {
 74 |   }
 75 | 
 76 |   ngOnInit(): void {
 77 |     this.getFilteredList();
 78 |     
 79 |     if(this.disabled)
 80 |       this.fieldCtrl.disable()
 81 |   }
 82 | 
 83 |   /**
 84 |    * Result = of(currInputVal)
 85 |    */
 86 |   getChangedValOfInput() {
 87 |     if (!this.fieldCtrl)
 88 |       return;
 89 |     const filter$ = this.fieldCtrl.valueChanges.pipe(
 90 |       startWith(""),
 91 |       debounceTime(400)
 92 |       // Note: If the option valye is bound to object, after selecting the option
 93 |       // Note: the value will change from string to {}. We want to perform search
 94 |       // Note: only when the type is string (no match)
 95 |       // filter(q => typeof q === 'string')
 96 |     );
 97 |     return filter$;
 98 |   }
 99 | 
100 |   getFilteredList() {
101 |     const filter$ = this.getChangedValOfInput();
102 |     this.filteredList = filter$.pipe(
103 |       switchMap(currInputVal => {
104 |         // Note: Reset the page with every new seach text
105 |         let currentPage = 1;
106 |         return this.nextPage$.pipe(
107 |           startWith(currentPage),
108 |           // Note: Until the backend responds, ignore NextPage requests.
109 |           exhaustMap(_ => this.getItems(currInputVal, currentPage)),
110 |           tap(() => currentPage++),
111 |           // Note: This is a custom operator because we also need the last emitted value.
112 |           // Note: Stop if there are no more pages, or no results at all for the current search text.
113 |           takeWhile(p => p.length > 0, true),
114 |           scan(
115 |             (allProducts, newProducts) => allProducts.concat(newProducts)
116 |           )
117 |         );
118 |       })
119 |     );
120 |   }
121 | 
122 |   private getItems(startsWith: any, page: number): Observable<MatInput[]> {
123 |     const take = 10;
124 |     const skip = page > 0 ? (page - 1) * take : 0;
125 |     let filterValue = "";
126 |     // if ((startsWith || {}).name) {
127 |     //   filterValue = (startsWith.name || "").toLowerCase();
128 |     // } else {
129 |     //   filterValue = (startsWith || "").toString().toLowerCase();
130 |     // }
131 | 
132 |     if ((startsWith || {})) {
133 |       filterValue = (startsWith || "").toUpperCase();
134 |     } else {
135 |       filterValue = (startsWith || "").toString().toUpperCase();
136 |     }
137 | 
138 |     // console.log(this.smartList);
139 |     
140 |     const filtered = this.smartList.filter(
141 |       // (option: any) => option.name.toLowerCase().indexOf(filterValue) >= 0
142 |       (option: any) => option.toUpperCase().indexOf(filterValue) >= 0
143 |     );
144 |     return of(filtered.slice(skip, skip + take));
145 |   }
146 | 
147 |   onSelect(event: any) {
148 |     this.toHighlight = event.name;
149 |     
150 |     if (!this.fieldCtrl)
151 |       return;
152 | 
153 |     if(!this.fieldCtrl.errors){
154 |       this.optionSelected.emit(this.validatedInputCtrl.nativeElement.value);
155 |     }
156 |   }
157 | 
158 |   onScroll() {
159 |     this.nextPage$.next();
160 |   }
161 | 
162 |     displayFn(data: any): string {
163 |     // return data && data.name ? data.name : '';
164 |     return data;
165 |   }
166 | 
167 |   ngOnDestroy() {
168 |     this.nextPage$.unsubscribe();
169 |     if (this.optionSelected) {
170 |       this.optionSelected.unsubscribe();
171 |     }
172 |   }
173 | }
174 | 


--------------------------------------------------------------------------------
/admin/src/app/balance.spec.ts:
--------------------------------------------------------------------------------
1 | import { Balance } from './balance';
2 | 
3 | describe('Balance', () => {
4 |   it('should create an instance', () => {
5 |     expect(new Balance()).toBeTruthy();
6 |   });
7 | });
8 | 


--------------------------------------------------------------------------------
/admin/src/app/balance.ts:
--------------------------------------------------------------------------------
 1 | export class Balance {
 2 |     sym: string;
 3 |     avail: number;
 4 |     locked: number;
 5 | 
 6 |     get total(): number {
 7 |         return this.avail + this.locked;
 8 |     }
 9 | 
10 |     constructor(init?: Partial<Balance>){
11 |         Object.assign(this, init)
12 |     }
13 | }
14 | 


--------------------------------------------------------------------------------
/admin/src/app/balances/balances.component.css:
--------------------------------------------------------------------------------
1 | table{
2 |     width: 100%;
3 | }


--------------------------------------------------------------------------------
/admin/src/app/balances/balances.component.html:
--------------------------------------------------------------------------------
 1 | <div>
 2 |     <table mat-table [dataSource]="balances" matSort class="mat-elevation-z2">
 3 |       
 4 |       <ng-container matColumnDef="sym">
 5 |         <th style="width: 10%" mat-header-cell *matHeaderCellDef mat-sort-header="sym">Symbol</th>
 6 |         <td mat-cell *matCellDef="let balance">{{balance.sym}}</td>
 7 |       </ng-container>
 8 |   
 9 |       <ng-container matColumnDef="available">
10 |         <th style="width: 15%" mat-header-cell *matHeaderCellDef mat-sort-header="avail">Free</th>
11 |         <td mat-cell *matCellDef="let balance">{{ balance.avail | number:'1.8-8' }}</td>
12 |       </ng-container>
13 | 
14 |       <ng-container matColumnDef="locked">
15 |         <th style="width: 15%" mat-header-cell *matHeaderCellDef mat-sort-header="locked">Locked</th>
16 |         <td mat-cell *matCellDef="let balance">{{ balance.locked | number:'1.8-8' }}</td>
17 |       </ng-container>
18 | 
19 |       <ng-container matColumnDef="total">
20 |         <th style="width: 15%" mat-header-cell *matHeaderCellDef mat-sort-header="total">Total</th>
21 |         <td mat-cell *matCellDef="let balance">{{ balance.total | number:'1.8-8' }}</td>
22 |       </ng-container>
23 |   
24 |       <tr mat-header-row *matHeaderRowDef="displayedColumns"></tr>
25 |       <tr mat-row *matRowDef="let row; columns: displayedColumns;"></tr>
26 |     </table>  
27 |   </div>
28 |   
29 |   


--------------------------------------------------------------------------------
/admin/src/app/balances/balances.component.spec.ts:
--------------------------------------------------------------------------------
 1 | import { ComponentFixture, TestBed } from '@angular/core/testing';
 2 | 
 3 | import { BalancesComponent } from './balances.component';
 4 | 
 5 | describe('BalancesComponent', () => {
 6 |   let component: BalancesComponent;
 7 |   let fixture: ComponentFixture<BalancesComponent>;
 8 | 
 9 |   beforeEach(async () => {
10 |     await TestBed.configureTestingModule({
11 |       declarations: [ BalancesComponent ]
12 |     })
13 |     .compileComponents();
14 |   });
15 | 
16 |   beforeEach(() => {
17 |     fixture = TestBed.createComponent(BalancesComponent);
18 |     component = fixture.componentInstance;
19 |     fixture.detectChanges();
20 |   });
21 | 
22 |   it('should create', () => {
23 |     expect(component).toBeTruthy();
24 |   });
25 | });
26 | 


--------------------------------------------------------------------------------
/admin/src/app/balances/balances.component.ts:
--------------------------------------------------------------------------------
 1 | import { AfterViewInit, Component, OnInit, ViewChild } from '@angular/core';
 2 | import { MatSort } from '@angular/material/sort';
 3 | import { MatTableDataSource } from '@angular/material/table';
 4 | import { Balance } from '../balance';
 5 | import { BotApi } from '../botapi';
 6 | 
 7 | @Component({
 8 |   selector: 'app-balances',
 9 |   templateUrl: './balances.component.html',
10 |   styleUrls: ['./balances.component.css']
11 | })
12 | export class BalancesComponent implements OnInit, AfterViewInit {
13 | 
14 |   @ViewChild(MatSort) sort: MatSort;
15 |   
16 |   balances: MatTableDataSource<Balance> = null;
17 |   displayedColumns: string[] = ['sym', 'available', 'locked', 'total'];
18 | 
19 |   constructor(private api: BotApi) { }
20 | 
21 |   ngOnInit(): void {
22 |  
23 |   }
24 | 
25 |   ngAfterViewInit(): void {
26 |     this.getBalances();
27 |   }
28 | 
29 |   getBalances():void {
30 |     this.api.getBalances(true).subscribe(
31 |       res => {
32 |         this.balances = new MatTableDataSource(res);
33 |         this.balances.sort = this.sort;
34 |         this.balances.sortingDataAccessor = (data, attribute) => data[attribute];
35 |         this.balances.filterPredicate = this.balanceFilter;
36 |         this.balances.filter = "+";
37 |         // this.exchangeInfo.forEach(si => this.symbols.push(<string>si.s.toUpperCase()));
38 |       }
39 |     );
40 |   }
41 |   //  <input matInput (keyup)="applyFilter($event)" placeholder="Ex. ium" #input>
42 |   
43 |   balanceFilter(balance: Balance, filter: string): boolean {
44 |     return (balance.avail + balance.locked) > 0;
45 |   }
46 | }
47 | 


--------------------------------------------------------------------------------
/admin/src/app/binance.service.spec.ts:
--------------------------------------------------------------------------------
 1 | import { TestBed, inject } from '@angular/core/testing';
 2 | 
 3 | import { BinanceService } from './binance.service';
 4 | 
 5 | describe('BinanceService', () => {
 6 |   beforeEach(() => {
 7 |     TestBed.configureTestingModule({
 8 |       providers: [BinanceService]
 9 |     });
10 |   });
11 | 
12 |   it('should be created', inject([BinanceService], (service: BinanceService) => {
13 |     expect(service).toBeTruthy();
14 |   }));
15 | });
16 | 


--------------------------------------------------------------------------------
/admin/src/app/binance.service.ts:
--------------------------------------------------------------------------------
  1 | import { Injectable } from '@angular/core';
  2 | import {WebsocketService} from './websocket.service';
  3 | import {Observable, of, Subject, throwError} from 'rxjs';
  4 | import {catchError, map, retry, tap} from 'rxjs/operators';
  5 | import {environment} from '../environments/environment';
  6 | import {HttpClient, HttpHeaders} from '@angular/common/http';
  7 | import {TradeInfo} from './tradeInfo';
  8 | 
  9 | @Injectable({
 10 |   providedIn: 'root'
 11 | })
 12 | export class BinanceService {
 13 |   API_URL = 'https://api1.binance.com/api/v3';
 14 |   RETRIES = 3;
 15 | 
 16 |   httpOptions = {
 17 |     headers: new HttpHeaders({
 18 |       'Content-Type':  'application/json'
 19 |     })
 20 |   };
 21 | 
 22 |   constructor(private http: HttpClient){
 23 | 
 24 |   }
 25 | 
 26 |   // bookTicker(symbol: string): Observable<BinancePriceResult> {
 27 |   //   return this.http.get<any>(`${this.API_URL}/ticker/bookTicker?symbol=${symbol}`, this.httpOptions).pipe(
 28 |   //     retry(this.RETRIES),
 29 |   //     map(data => {
 30 |   //       const result = new BinancePriceResult();
 31 |   //       result.symbol = data.symbol;
 32 |   //       result.bestAsk = data.askPrice;
 33 |   //       result.bestBid = data.askPrice;
 34 |   //       return result;
 35 |   //     }),
 36 |   //     catchError(this.handleError('getActiveTradeInfo', null))
 37 |   //   );
 38 |   // }
 39 | 
 40 |   symbols: Subject<string>;
 41 | 
 42 |   // getPrice(symbol: string): Subject<BinancePriceResult> {
 43 |   //   const listener = this.listenSymbols([symbol]);
 44 | 
 45 |   //   return <Subject<BinancePriceResult>>listener.pipe(
 46 |   //     map(data => JSON.parse(data).data),
 47 |   //     map(function(data) {
 48 |   //       setTimeout(() => this.complete());
 49 |   //       return Object.assign(new BinancePriceResult(), {
 50 |   //         symbol: data.s,
 51 |   //         bestAsk: data.a,
 52 |   //         bestBid: data.b,
 53 |   //       });
 54 |   //     })
 55 |   //   );
 56 |   // }
 57 | 
 58 |   listenSymbols(symbols: string[]): Subject<string> {
 59 |     if (this.symbols != null && this.symbols !== undefined) {
 60 |       this.symbols.complete();
 61 |     }
 62 | 
 63 |     let path: string = null;
 64 |     if (symbols !== null && symbols !== undefined) {
 65 |       path = '/stream?streams=' + symbols.map(sym => sym.toLowerCase() + '@ticker').join('/');
 66 |     } else {
 67 |       path = '/ws/!ticker@arr';
 68 |     }
 69 | 
 70 |     console.log(`Connecting to Binance ws: ${path}`);
 71 |     const wss: WebsocketService = new WebsocketService();
 72 | 
 73 |     this.symbols = <Subject<string>>wss
 74 |       .connect(`${environment.BINANCE_WSS_URL}${path}`).pipe(
 75 |         map((response: MessageEvent): string => {
 76 |         return response.data.toString();
 77 |         })
 78 |       );
 79 |     return this.symbols;
 80 | 
 81 |   //   if symbols:
 82 |   //   url = os.path.join(BinanceWebsocket.WS_URL,
 83 |   //     'stream?streams=' + '/'.join([s.lower() + '@ticker' for s in self.symbols]))
 84 |   // else:
 85 |   //   url = os.path.join(BinanceWebsocket.WS_URL, 'ws/!ticker@arr')
 86 |   }
 87 | 
 88 |   private handleError<T> (operation = 'operation', result?: T) {
 89 |     return (error: any): Observable<T> => {
 90 | 
 91 |       // TODO: send the error to remote logging infrastructure
 92 |       console.error(error); // log to console instead
 93 | 
 94 |       // TODO: better job of transforming error for user consumption
 95 |       console.log(`${operation} failed: ${error.message}`);
 96 | 
 97 |       if (error.status === 0) {
 98 |         return throwError('Binance API ERROR');
 99 |       }
100 |       // Let the app keep running by returning an empty result.
101 |       return of(result as T);
102 |     };
103 |   }
104 | }
105 | 


--------------------------------------------------------------------------------
/admin/src/app/botapi.ts:
--------------------------------------------------------------------------------
  1 | import { Injectable } from '@angular/core';
  2 | import {HttpClient, HttpErrorResponse, HttpHeaders} from '@angular/common/http';
  3 | import {Observable, of, throwError} from 'rxjs';
  4 | import {TradeInfo} from './tradeInfo';
  5 | import {catchError, map, retry, tap} from 'rxjs/operators';
  6 | import {ApiResult} from './apiresult';
  7 | import {TradeDetails, Entry} from './trade-details';
  8 | import deleteProperty = Reflect.deleteProperty;
  9 | import {environment} from '../environments/environment';
 10 | import { Balance } from './balance';
 11 | import { LogEntry } from './log-entry';
 12 | import * as moment from 'moment';
 13 | 
 14 | 
 15 | const httpOptions = {
 16 |   headers: new HttpHeaders({
 17 |     'Content-Type':  'application/json'
 18 |   })
 19 | };
 20 | 
 21 | export class BinancePriceResult {
 22 |   symbol: string;
 23 |   bestAsk: string;
 24 |   bestBid: string;
 25 | }
 26 | 
 27 | @Injectable({ providedIn: 'root' })
 28 | export class BotApi {
 29 |   RETRIES = 2;
 30 |   API_URL = `${environment.BOT_API_URL}/api/v1`;
 31 | 
 32 |   constructor(private http: HttpClient) {
 33 |   }
 34 | 
 35 |   getRecentLogFileContents(limit:number=1000, filename='latest'): Observable<LogEntry[]> {
 36 |     return this.http.get<LogEntry[]>(`${this.API_URL}/logs?file=${filename}&limit=${limit}`).pipe(
 37 |       retry(this.RETRIES),
 38 |       map(r => {
 39 | 
 40 |         const entries: LogEntry[] = [];
 41 | 
 42 |         r.forEach(entry => { 
 43 |           entry.d = new Date(entry.d)
 44 |           entries.push(new LogEntry(entry));
 45 |         });
 46 |         // console.log(entries);
 47 |         return entries;
 48 | 
 49 |       }),
 50 |       catchError(this.handleError('getActiveTrades',[])));
 51 |   }
 52 | 
 53 |   addTrade(trade: TradeDetails ): Observable<ApiResult> {
 54 |     const sanitizedTrade: any = Object.assign({}, trade, {stoploss: trade.stoploss});
 55 |     deleteProperty(sanitizedTrade, '_stoploss');
 56 | 
 57 |     // console.log(o);
 58 |     return this.http.post<ApiResult>(`${this.API_URL}/trade/0`,
 59 |                                           JSON.stringify({action: 'add', data: {trade: sanitizedTrade} }),
 60 |                                           httpOptions).pipe(
 61 |       // tap(_ => this.log(`Trade ${id} is closed`)),
 62 |       catchError(this.handleError('closeTrade'))
 63 |     );
 64 |   }
 65 | 
 66 |   bookTicker(symbol: string): Observable<BinancePriceResult> {
 67 |     return this.http.get<any>(`${this.API_URL}/orderbook/${symbol}`, httpOptions).pipe(
 68 |       retry(this.RETRIES),
 69 |       map(data => {
 70 |         if (!data)
 71 |           return null;
 72 |           
 73 |         const result = new BinancePriceResult();
 74 |         result.symbol = data.symbol;
 75 |         result.bestAsk = data.askPrice;
 76 |         result.bestBid = data.bidPrice;
 77 |         return result;
 78 |       }),
 79 |       catchError(this.handleError('getActiveTradeInfo', null))
 80 |     );
 81 |   }
 82 | 
 83 | 
 84 |   getActiveTradeInfo(id: string): Observable<TradeDetails> {
 85 |     return this.http.get<TradeDetails>(`${this.API_URL}/trade/${id}`, httpOptions).pipe(
 86 |       retry(this.RETRIES),
 87 |       tap(trade => this.log(`fetched trade ${id} info`)),
 88 |       map(data => {
 89 |         return new TradeDetails(false, data);
 90 |       }),
 91 |       catchError(this.handleError('getActiveTradeInfo', null))
 92 |     );
 93 |   }
 94 | 
 95 |   getActiveTrades(): Observable<TradeInfo[]> {
 96 |     return this.http.get<TradeInfo[]>(`${this.API_URL}/trades`).pipe(
 97 |       retry(this.RETRIES),
 98 |       map(trades => trades.map(trade => new TradeInfo(trade))),
 99 |       tap(trades => this.log(`fetched trades`)),
100 |       catchError(this.handleError('getActiveTrades', [])));
101 |   }
102 | 
103 |   getExchangeInfo(): Observable<any> {
104 |     return this.http.get<any>(`${this.API_URL}/info`).pipe(
105 |       retry(this.RETRIES),
106 |       catchError(this.handleError('getExchangeInfo', []))
107 |     );
108 |   }
109 | 
110 |   getBalances(force=false): Observable<Balance[]> {
111 |     return this.http.get<any>(`${this.API_URL}/balance/${force?'1':'0'}`, httpOptions).pipe(
112 |       retry(this.RETRIES),
113 |       map(data => {
114 |         const balanceList: Balance[] = [];
115 |         
116 |         for (let key in data) {
117 |           balanceList.push(new Balance({sym: key, avail: data[key].f, locked: data[key].l}))
118 |         }
119 | 
120 |         return balanceList;
121 |       }),
122 |       // tap(trades => this.log(`fetched trades`)),
123 |       catchError(this.handleError('getBalances', []))
124 |     );
125 |   }
126 | 
127 |   pauseAllTrades(): Observable<ApiResult> {
128 |    return this.pauseResumeTrade('0', true);
129 |   }
130 | 
131 |   resumeAllTrades(): Observable<ApiResult> {
132 |     return this.pauseResumeTrade('0', false);
133 |   }
134 | 
135 |   pauseResumeTrade(id: string, pause: boolean ): Observable<ApiResult> {
136 |     const pauseOrResume = pause ? 'pause' : 'resume';
137 | 
138 |     return this.http.post<ApiResult>(`${this.API_URL}/trade/${id}`, JSON.stringify({action: pauseOrResume}), httpOptions).pipe(
139 |       tap(_ => this.log(`All treades are ` + pause ? 'paused' : 'resumed')),
140 |       catchError(this.handleError('pauseResumeTrade'))
141 |     );
142 |   }
143 | 
144 |   removeTrade(id: string ): Observable<ApiResult> {
145 |     if (id === undefined || id === null) {
146 |       id = '0';
147 |     }
148 | 
149 |     return this.http.delete<ApiResult>(`${this.API_URL}/trade/${id}`, httpOptions).pipe(
150 |       tap(_ => this.log(`Trade ${id} is removed`)),
151 |       catchError(this.handleError('removeTrade'))
152 |     );
153 |   }
154 | 
155 |   closeTrade(id: string ): Observable<ApiResult> {
156 | 
157 |     if (id === undefined || id === null) {
158 |       id = '0';
159 |     }
160 | 
161 |     return this.http.post<ApiResult>(`${this.API_URL}/trade/${id}`, JSON.stringify({action: 'close'}), httpOptions).pipe(
162 |       tap(_ => this.log(`Trade ${id} is closed`)),
163 |       catchError(this.handleError('closeTrade'))
164 |     );
165 |   }
166 | 
167 |   private log(message: string) {
168 |     console.log('BotApi: ' + message);
169 |   }
170 | 
171 | 
172 |   /**
173 |    * Handle Http operation that failed.
174 |    * Let the app continue.
175 |    * @param operation - name of the operation that failed
176 |    * @param result - optional value to return as the observable result
177 |    */
178 |   private handleError<T> (operation, result?: T) {
179 |     return (error: any): Observable<T> => {
180 | 
181 |       // TODO: send the error to remote logging infrastructure
182 |       console.error(error); // log to console instead
183 | 
184 |       // TODO: better job of transforming error for user consumption
185 |       this.log(`${operation} failed: ${error.message}`);
186 | 
187 |       if (error.status === 0) {
188 |         return throwError('No connectivity to the bot');
189 |       }
190 |       // Let the app keep running by returning an empty result.
191 |       return of(result as T);
192 |     };
193 |   }
194 | }
195 | 
196 | 
197 | 


--------------------------------------------------------------------------------
/admin/src/app/log-entry.spec.ts:
--------------------------------------------------------------------------------
1 | import { LogEntry } from './log-entry';
2 | 
3 | describe('LogEntry', () => {
4 |   it('should create an instance', () => {
5 |     expect(new LogEntry()).toBeTruthy();
6 |   });
7 | });
8 | 


--------------------------------------------------------------------------------
/admin/src/app/log-entry.ts:
--------------------------------------------------------------------------------
 1 | export class LogEntry {
 2 |     
 3 |     d: Date;
 4 |     l: string;
 5 |     t: string;
 6 |     o: string;
 7 | 
 8 |     constructor(init?: Partial<LogEntry>){
 9 |         Object.assign(this, init)
10 |     }
11 | 
12 |     get date(): Date{
13 |         return this.d;
14 |     }
15 | 
16 |     get level(): string{
17 |         return this.l;
18 |     }
19 | 
20 |     get originator(): string{
21 |         return this.o;
22 |     }
23 | 
24 |     get text(): string{
25 |         return this.t;
26 |     }
27 | }
28 | 


--------------------------------------------------------------------------------
/admin/src/app/log-in/log-in.component.css:
--------------------------------------------------------------------------------
 1 | .login-container {
 2 |   min-width: 150px;
 3 |   max-width: 400px;
 4 |   width: 100%;
 5 |   padding: 0 16px;
 6 |   margin: 82px auto 32px;
 7 | }
 8 | 
 9 | .full-width {
10 |   width: 100%;
11 | }
12 | 
13 | .float-right {
14 |   float: right!important;
15 | }
16 | 
17 | col-auto {
18 |   -ms-flex: 0 0 auto;
19 |   flex: 0 0 auto;
20 |   width: auto;
21 |   max-width: 100%;
22 | }


--------------------------------------------------------------------------------
/admin/src/app/log-in/log-in.component.html:
--------------------------------------------------------------------------------
 1 | <div class="login-container">
 2 |   <form (ngSubmit)="onSubmit($event)">
 3 |     <mat-form-field class="full-width" appearance="standard">
 4 |       <mat-label>Login</mat-label>
 5 |       <input matInput placeholder="username" value="" name="login" [(ngModel)]="login">
 6 |     </mat-form-field>
 7 | 
 8 |     <mat-form-field class="full-width" appearance="standard">
 9 |       <mat-label>Password</mat-label>
10 |       <input matInput type="password" placeholder="password" name="password" [(ngModel)]="password">
11 |     </mat-form-field>
12 | 
13 |     <button mat-raised-button color="primary">Login</button>
14 |     <mat-error>{{error}}</mat-error>
15 |   </form>
16 | </div>
17 | 


--------------------------------------------------------------------------------
/admin/src/app/log-in/log-in.component.spec.ts:
--------------------------------------------------------------------------------
 1 | import { ComponentFixture, TestBed, waitForAsync } from '@angular/core/testing';
 2 | 
 3 | import { LogInComponent } from './log-in.component';
 4 | 
 5 | describe('LogInComponent', () => {
 6 |   let component: LogInComponent;
 7 |   let fixture: ComponentFixture<LogInComponent>;
 8 | 
 9 |   beforeEach(waitForAsync(() => {
10 |     TestBed.configureTestingModule({
11 |       declarations: [ LogInComponent ]
12 |     })
13 |     .compileComponents();
14 |   }));
15 | 
16 |   beforeEach(() => {
17 |     fixture = TestBed.createComponent(LogInComponent);
18 |     component = fixture.componentInstance;
19 |     fixture.detectChanges();
20 |   });
21 | 
22 |   it('should create', () => {
23 |     expect(component).toBeTruthy();
24 |   });
25 | });
26 | 


--------------------------------------------------------------------------------
/admin/src/app/log-in/log-in.component.ts:
--------------------------------------------------------------------------------
 1 | import { Component, OnInit } from '@angular/core';
 2 | import {AuthService} from '../auth.service';
 3 | import {NgForm} from '@angular/forms';
 4 | 
 5 | @Component({
 6 |   selector: 'app-log-in',
 7 |   templateUrl: './log-in.component.html',
 8 |   styleUrls: ['./log-in.component.css']
 9 | })
10 | export class LogInComponent implements OnInit {
11 |   public login: string;
12 |   public password: string;
13 |   public error: string;
14 | 
15 |   constructor(public auth: AuthService) { }
16 | 
17 |   ngOnInit() {
18 |   }
19 | 
20 |   onSubmit(evt) {
21 |     this.auth.login(this.login, this.password).subscribe(
22 |       (res) => {
23 |         this.login = '';
24 |         this.password = '';
25 |         this.error = '';
26 |       },
27 |       (e) => {
28 |         if (e.error && e.error.msg) {
29 |           this.error = e.error.msg;
30 |         }
31 |       }
32 |     );
33 |   }
34 | }
35 | 


--------------------------------------------------------------------------------
/admin/src/app/logs/logs.component.css:
--------------------------------------------------------------------------------
  1 | .top-panel-ctrl {
  2 |     display: flex;
  3 |     flex-direction: row;
  4 |     align-items: center;
  5 |     box-sizing: border-box;
  6 |     padding: 0 16px;
  7 |     position: relative;
  8 |     height: inherit;
  9 | }
 10 | 
 11 | table {
 12 |     width: 100%;
 13 | }
 14 | 
 15 | 
 16 | .mat-column-date, .mat-column-level, .mat-column-origin, .mat-column-message {
 17 |     word-wrap: break-word !important;
 18 |     white-space: unset !important;
 19 |     flex: 0 0 auto !important;
 20 |     width: 25% !important;
 21 |     overflow-wrap: break-word;
 22 |     word-wrap: break-word;
 23 | 
 24 |     word-break: break-word;
 25 | 
 26 |     -ms-hyphens: auto;
 27 |     -moz-hyphens: auto;
 28 |     -webkit-hyphens: auto;
 29 |     hyphens: auto;
 30 | }
 31 | 
 32 | .mat-column-date {
 33 |     flex: 0 0 15% !important;
 34 |     width: 15% !important;
 35 | }
 36 | 
 37 | .mat-column-level {
 38 |     flex: 0 0 5% !important;
 39 |     width: 5% !important;
 40 | }
 41 | 
 42 | .mat-column-origin {
 43 |     flex: 0 0 25% !important;
 44 |     width: 25% !important;
 45 | }
 46 | 
 47 | .mat-column-message {
 48 |     flex: 0 0 55% !important;
 49 |     width: 55% !important;
 50 | }
 51 | 
 52 | /*   
 53 |   .mat-column-emailid {
 54 |     word-wrap: break-word !important;
 55 |     white-space: unset !important;
 56 |     flex: 0 0 25% !important;
 57 |     width: 25% !important;
 58 |     overflow-wrap: break-word;
 59 |     word-wrap: break-word;
 60 |   
 61 |     word-break: break-word;
 62 |   
 63 |     -ms-hyphens: auto;
 64 |     -moz-hyphens: auto;
 65 |     -webkit-hyphens: auto;
 66 |     hyphens: auto;
 67 |   }
 68 |   
 69 |   .mat-column-contactno {
 70 |     word-wrap: break-word !important;
 71 |     white-space: unset !important;
 72 |     flex: 0 0 17% !important;
 73 |     width: 17% !important;
 74 |     overflow-wrap: break-word;
 75 |     word-wrap: break-word;
 76 |   
 77 |     word-break: break-word;
 78 |   
 79 |     -ms-hyphens: auto;
 80 |     -moz-hyphens: auto;
 81 |     -webkit-hyphens: auto;
 82 |     hyphens: auto;
 83 |   }
 84 |   
 85 |   .mat-column-userimage {
 86 |     word-wrap: break-word !important;
 87 |     white-space: unset !important;
 88 |     flex: 0 0 8% !important;
 89 |     width: 8% !important;
 90 |     overflow-wrap: break-word;
 91 |     word-wrap: break-word;
 92 |   
 93 |     word-break: break-word;
 94 |   
 95 |     -ms-hyphens: auto;
 96 |     -moz-hyphens: auto;
 97 |     -webkit-hyphens: auto;
 98 |     hyphens: auto;
 99 |   }
100 |   
101 |   .mat-column-userActivity {
102 |     word-wrap: break-word !important;
103 |     white-space: unset !important;
104 |     flex: 0 0 10% !important;
105 |     width: 10% !important;
106 |     overflow-wrap: break-word;
107 |     word-wrap: break-word;
108 |   
109 |     word-break: break-word;
110 |   
111 |     -ms-hyphens: auto;
112 |     -moz-hyphens: auto;
113 |     -webkit-hyphens: auto;
114 |     hyphens: auto;
115 |   } */


--------------------------------------------------------------------------------
/admin/src/app/logs/logs.component.html:
--------------------------------------------------------------------------------
 1 | <div class="full-width top-panel-ctrl">
 2 |     <mat-form-field appearance="standard">
 3 |         <mat-label># of log entries</mat-label>
 4 |         <input matInput type="number" min="1" step="1" id="targetPrice" name="targetPrice" [(ngModel)]="limit">
 5 |     </mat-form-field>
 6 |     <button mat-icon-button matTooltip="Refresh Log" (click)="refreshLogs()">
 7 |         <mat-icon>refresh</mat-icon>
 8 |     </button>
 9 |     <button mat-icon-button matTooltip="Copy All Log Records" *ngIf="logs">
10 |         <mat-icon [cdkCopyToClipboard]="getClipboard()">file_copy</mat-icon>
11 |     </button>
12 | </div>
13 | 
14 | <mat-progress-bar *ngIf="!logs" mode="query"></mat-progress-bar>
15 | <div> 
16 |     <table mat-table [dataSource]="dataSource" matSort class="mat-elevation-z2">
17 |   
18 |       <ng-container matColumnDef="date">
19 |         <th mat-header-cell *matHeaderCellDef mat-sort-header="d"> Date </th>
20 |         <td mat-cell *matCellDef="let log"> {{log.d | date: dateFormatStr}} </td>
21 |       </ng-container>
22 |   
23 |       <ng-container matColumnDef="level">
24 |         <th mat-header-cell *matHeaderCellDef mat-sort-header="l"> Level </th>
25 |         <td mat-cell *matCellDef="let log"> {{log.l}} </td>
26 |       </ng-container>  
27 | 
28 |       <ng-container matColumnDef="origin">
29 |         <th mat-header-cell *matHeaderCellDef mat-sort-header="o"> Origin </th>
30 |         <td mat-cell *matCellDef="let log"> {{log.o}} </td>
31 |       </ng-container>
32 |   
33 |       <ng-container matColumnDef="message">
34 |         <th mat-header-cell *matHeaderCellDef> Message </th>
35 |         <td mat-cell *matCellDef="let log"> {{log.t}} </td>
36 |       </ng-container>
37 |   
38 |       <tr mat-header-row *matHeaderRowDef="['date', 'level', 'origin', 'message']"></tr>
39 |       <tr mat-row *matRowDef="let row; columns: ['date', 'level', 'origin', 'message'];"></tr>
40 |     </table>
41 |     
42 |   </div>
43 |   <mat-paginator [pageSizeOptions]="[30, 50, 100]" showFirstLastButtons></mat-paginator>
44 | 


--------------------------------------------------------------------------------
/admin/src/app/logs/logs.component.spec.ts:
--------------------------------------------------------------------------------
 1 | import { ComponentFixture, TestBed } from '@angular/core/testing';
 2 | 
 3 | import { LogsComponent } from './logs.component';
 4 | 
 5 | describe('LogsComponent', () => {
 6 |   let component: LogsComponent;
 7 |   let fixture: ComponentFixture<LogsComponent>;
 8 | 
 9 |   beforeEach(async () => {
10 |     await TestBed.configureTestingModule({
11 |       declarations: [ LogsComponent ]
12 |     })
13 |     .compileComponents();
14 |   });
15 | 
16 |   beforeEach(() => {
17 |     fixture = TestBed.createComponent(LogsComponent);
18 |     component = fixture.componentInstance;
19 |     fixture.detectChanges();
20 |   });
21 | 
22 |   it('should create', () => {
23 |     expect(component).toBeTruthy();
24 |   });
25 | });
26 | 


--------------------------------------------------------------------------------
/admin/src/app/logs/logs.component.ts:
--------------------------------------------------------------------------------
 1 | import { DatePipe, formatDate } from '@angular/common';
 2 | import { AfterViewInit, Component, Inject, LOCALE_ID, OnInit, ViewChild } from '@angular/core';
 3 | import { MatPaginator } from '@angular/material/paginator';
 4 | import { MatSort } from '@angular/material/sort';
 5 | import { MatTableDataSource } from '@angular/material/table';
 6 | import { BotApi } from '../botapi';
 7 | import { LogEntry } from '../log-entry';
 8 | 
 9 | @Component({
10 |   selector: 'app-logs',
11 |   templateUrl: './logs.component.html',
12 |   styleUrls: ['./logs.component.css']
13 | })
14 | export class LogsComponent implements OnInit, AfterViewInit {
15 | 
16 |   public readonly dateFormatStr = 'dd/MM/yyyy HH:mm:ss.SSS';
17 |   pipe: DatePipe;
18 |   logs: LogEntry[];
19 |   dataSource: MatTableDataSource<LogEntry>;
20 |   limit: number = 1000;
21 |   @ViewChild(MatPaginator) paginator: MatPaginator;
22 |   @ViewChild(MatSort) sort: MatSort;
23 | 
24 | 
25 |   constructor(private api: BotApi,
26 |               @Inject(LOCALE_ID) public locale: string) { }
27 |   ngAfterViewInit(): void {
28 |     this.pipe = new DatePipe(this.locale); 
29 |     this.refreshLogs(); 
30 |   }
31 | 
32 |   ngOnInit(): void {
33 |     // this.refreshLogs();  
34 |   }
35 | 
36 |   refreshLogs(): void {
37 |     this.logs = null;
38 |     this.api.getRecentLogFileContents(this.limit).subscribe(r => {
39 |       if (r){
40 |         this.logs = r;
41 |         this.dataSource = new MatTableDataSource<LogEntry>(this.logs);
42 |         this.dataSource.paginator = this.paginator;
43 |         this.dataSource.sort = this.sort;
44 |       }
45 |     })
46 |   }
47 | 
48 |   getClipboard(): string {
49 |     let cb = ''
50 |     
51 |     
52 |     if (this.logs){
53 |       this.logs.forEach(l=> {
54 |         cb += `${this.pipe.transform(l.d, this.dateFormatStr)} [${l.l}] [${l.o}]: ${l.t}\n`
55 |       })
56 |     }
57 | 
58 |     return cb
59 |   }
60 | 
61 | }
62 | 


--------------------------------------------------------------------------------
/admin/src/app/main-tabs/main-tabs.component.css:
--------------------------------------------------------------------------------
 1 | .toolbar-container {
 2 |     display: flex;
 3 |     flex-direction: column;
 4 |     position: absolute;
 5 |     top: 0;
 6 |     bottom: 0;
 7 |     left: 0;
 8 |     right: 0;
 9 | }
10 | 
11 | .menu-toolbar {
12 |     position: fixed;
13 |     /* Make sure the toolbar will stay on top of the content as it scrolls past. */
14 |     z-index: 2;
15 | }
16 | 
17 | .side-nav-container {
18 |     flex: 1;
19 | }
20 | 
21 | .side-nav-container {
22 |     flex: 1 0 auto;
23 | }
24 | 
25 | h1.app-name {
26 |     margin-left: 16px;
27 | }
28 | 
29 | mat-icon[name=git] {
30 |     width: 100px;
31 |     padding: 10 px;
32 | }
33 | 
34 | span[name=gitcontainer]{
35 |     align-content: center;
36 |     text-align: center;
37 |     justify-content: center;
38 | }
39 | 
40 | .spacer {
41 |     flex: 1 1 auto;
42 |  }


--------------------------------------------------------------------------------
/admin/src/app/main-tabs/main-tabs.component.html:
--------------------------------------------------------------------------------
 1 | <div class="toolbar-container" *ngIf="auth.isLoggedIn()">
 2 |     <mat-toolbar color="primary" class="menu-toolbar">
 3 |       <button mat-icon-button (click)="snav.toggle()"><mat-icon>menu</mat-icon></button>
 4 |       <span>Crypto Trading Bot</span>
 5 |   <span class="spacer"></span>
 6 |     <!-- <a href="https://github.com/iilunin/crypto-bot/" target="_blank" rel="noopener"> -->
 7 |       <mat-icon aria-label="Example thumbs up SVG icon"  svgIcon="my_git" name="git" matTooltip="give the repo a star"></mat-icon>
 8 |     <!-- </a> -->
 9 |     </mat-toolbar>
10 |   
11 |     <mat-sidenav-container class="side-nav-container" [style.marginTop.px]="56">
12 |       <mat-sidenav #snav [mode]="'side'" opened="true" [fixedInViewport]="false" fixedTopGap="56">
13 |         <mat-nav-list>
14 |             <a routerLink="/trades">
15 |                 <mat-list-item>
16 |                     <mat-icon mat-list-icon>show_chart</mat-icon>
17 |                     <div mat-line>Trade</div>
18 |                 </mat-list-item>
19 |             </a>
20 |             <a routerLink="/balances">
21 |                 <mat-list-item>
22 |                     <mat-icon mat-list-icon>money</mat-icon>
23 |                     <div mat-line>Balances</div>
24 |                 </mat-list-item>
25 |             </a>
26 |             <a routerLink="/logs">
27 |               <mat-list-item>
28 |                   <mat-icon mat-list-icon>file_copy</mat-icon>
29 |                   <div mat-line>Logs</div>
30 |               </mat-list-item>
31 |           </a>
32 |             <mat-divider></mat-divider>
33 |             <a routerLink="/" (click)="auth.logout()">
34 |                 <mat-list-item>
35 |                     <mat-icon mat-list-icon>power_settings_new</mat-icon>
36 |                     <div mat-line>Logout</div>
37 |                 </mat-list-item>
38 |             </a>
39 |         </mat-nav-list>
40 |       </mat-sidenav>
41 |   
42 |       <mat-sidenav-content [style.marginTop.px]="10">
43 |         <router-outlet></router-outlet>
44 |       </mat-sidenav-content>
45 |     </mat-sidenav-container>
46 |   </div> 


--------------------------------------------------------------------------------
/admin/src/app/main-tabs/main-tabs.component.spec.ts:
--------------------------------------------------------------------------------
 1 | import { ComponentFixture, TestBed } from '@angular/core/testing';
 2 | 
 3 | import { MainTabsComponent } from './main-tabs.component';
 4 | 
 5 | describe('MainTabsComponent', () => {
 6 |   let component: MainTabsComponent;
 7 |   let fixture: ComponentFixture<MainTabsComponent>;
 8 | 
 9 |   beforeEach(async () => {
10 |     await TestBed.configureTestingModule({
11 |       declarations: [ MainTabsComponent ]
12 |     })
13 |     .compileComponents();
14 |   });
15 | 
16 |   beforeEach(() => {
17 |     fixture = TestBed.createComponent(MainTabsComponent);
18 |     component = fixture.componentInstance;
19 |     fixture.detectChanges();
20 |   });
21 | 
22 |   it('should create', () => {
23 |     expect(component).toBeTruthy();
24 |   });
25 | });
26 | 


--------------------------------------------------------------------------------
/admin/src/app/main-tabs/main-tabs.component.ts:
--------------------------------------------------------------------------------
 1 | import { Component, OnInit } from '@angular/core';
 2 | import { AuthService } from '../auth.service';
 3 | 
 4 | @Component({
 5 |   selector: 'app-main-tabs',
 6 |   templateUrl: './main-tabs.component.html',
 7 |   styleUrls: ['./main-tabs.component.css']
 8 | })
 9 | export class MainTabsComponent implements OnInit {
10 | 
11 |   constructor(public auth: AuthService) { 
12 |   }
13 | 
14 |   ngOnInit(): void {
15 |   }
16 | 
17 | }
18 | 


--------------------------------------------------------------------------------
/admin/src/app/options-scroll.directive.ts:
--------------------------------------------------------------------------------
 1 | import {
 2 |     Directive,
 3 |     EventEmitter,
 4 |     Input,
 5 |     Output,
 6 |     OnDestroy
 7 |   } from "@angular/core";
 8 |   import { MatAutocomplete } from "@angular/material/autocomplete";
 9 |   import { Subject } from "rxjs";
10 |   import { tap, takeUntil } from "rxjs/operators";
11 |   
12 |   export interface IAutoCompleteScrollEvent {
13 |     autoComplete: MatAutocomplete;
14 |     scrollEvent: Event;
15 |   }
16 |   
17 |   @Directive({
18 |     selector: "mat-autocomplete[optionsScroll]"
19 |   })
20 |   export class OptionsScrollDirective implements OnDestroy {
21 |     timeoutRef: any;
22 |     @Input() thresholdPercent = 0.8;
23 |     @Output("optionsScroll") scroll = new EventEmitter<
24 |       IAutoCompleteScrollEvent
25 |     >();
26 |     _onDestroy = new Subject();
27 |   
28 |     constructor(public autoComplete: MatAutocomplete) {
29 |       this.autoComplete.opened
30 |         .pipe(
31 |           tap(() => {
32 |             // Note: When autocomplete raises opened, panel is not yet created (by Overlay)
33 |             // Note: The panel will be available on next tick
34 |             // Note: The panel wil NOT open if there are no options to display
35 |             this.timeoutRef = setTimeout(() => {
36 |               // Note: remove listner just for safety, in case the close event is skipped.
37 |               this.removeScrollEventListener();
38 |               this.autoComplete.panel.nativeElement.addEventListener(
39 |                 "scroll",
40 |                 this.onScroll.bind(this)
41 |               );
42 |             });
43 |           }),
44 |           takeUntil(this._onDestroy)
45 |         )
46 |         .subscribe();
47 |   
48 |       this.autoComplete.closed
49 |         .pipe(
50 |           tap(() => this.removeScrollEventListener()),
51 |           takeUntil(this._onDestroy)
52 |         )
53 |         .subscribe();
54 |     }
55 |   
56 |     private removeScrollEventListener() {
57 |       if (this.autoComplete.panel) {
58 |         this.autoComplete.panel.nativeElement.removeEventListener(
59 |           "scroll",
60 |           this.onScroll
61 |         );
62 |       }
63 |     }
64 |   
65 |     ngOnDestroy() {
66 |       clearTimeout(this.timeoutRef);
67 |       this._onDestroy.next();
68 |       this._onDestroy.complete();
69 |   
70 |       this.removeScrollEventListener();
71 |     }
72 |   
73 |     onScroll(event: any) {
74 |       if (this.thresholdPercent === undefined) {
75 |         this.scroll.next({ autoComplete: this.autoComplete, scrollEvent: event });
76 |       } else {
77 |         const threshold =
78 |           (this.thresholdPercent * 100 * event.target.scrollHeight) / 100;
79 |         const current = event.target.scrollTop + event.target.clientHeight;
80 |         if (current > threshold) {
81 |           this.scroll.next({
82 |             autoComplete: this.autoComplete,
83 |             scrollEvent: event
84 |           });
85 |         }
86 |       }
87 |     }
88 |   }
89 |   


--------------------------------------------------------------------------------
/admin/src/app/services/notification.service.ts:
--------------------------------------------------------------------------------
 1 | import { Injectable } from "@angular/core";
 2 | import { Subject } from "rxjs";
 3 | 
 4 | export enum NotificatoinType {
 5 |     Regular,
 6 |     Warning,
 7 |     Alert
 8 | }
 9 | 
10 | export class NotificationMessage {
11 |     public contents: string;
12 |     public action?: string;
13 |     public type: NotificatoinType;
14 | 
15 |     constructor(contents: string, action?: string, type: NotificatoinType = NotificatoinType.Regular){
16 |         this.contents = contents;
17 |         this.action = action;
18 |         this.type = type
19 |     }
20 | }
21 | 
22 | @Injectable({ providedIn: 'root' })
23 | export class NotificationService {
24 |     public notification$: Subject<NotificationMessage> = new Subject();
25 | 
26 |     public Notify(msg: string, type: NotificatoinType = NotificatoinType.Regular): void{
27 |         this.notification$.next(new NotificationMessage(msg, null, type))
28 |     }
29 | 
30 |     public NotifyAlert(msg: string): void{
31 |         this.Notify(msg, NotificatoinType.Alert);
32 |     }
33 | 
34 |     public NotifyWarning(msg: string): void{
35 |         this.Notify(msg, NotificatoinType.Warning);
36 |     }
37 | 
38 | }


--------------------------------------------------------------------------------
/admin/src/app/trade-details.ts:
--------------------------------------------------------------------------------
  1 | export enum TradeStatus {
  2 |   NEW = 'NEW',
  3 |   ACTIVE = 'ACTIVE',
  4 |   COMPLETED = 'COMPLETED'
  5 | }
  6 | 
  7 | export enum SLType {
  8 |   FIXED = 'FIXED',
  9 |   TRAILING = 'TRAILING'
 10 | }
 11 | 
 12 | export class Target {
 13 |   constructor(init?: Partial<Target>) {
 14 |     Object.assign(this, init);
 15 |   }
 16 |   status: TradeStatus;
 17 |   id: number;
 18 |   date: string;
 19 |   price: string;
 20 |   vol: string;
 21 |   calculated_volume: string;
 22 |   smart: boolean;
 23 |   sl: string;
 24 |   best_price: string;
 25 |   isCompleted(): boolean { return this.status === TradeStatus.COMPLETED; }
 26 | }
 27 | 
 28 | export class ExitInfo {  
 29 |   smart: boolean;
 30 |   threshold: string;
 31 |   targets: Target[];
 32 |   constructor(init?: Partial<ExitInfo>) {
 33 | 
 34 |     Object.assign(this, init);
 35 |     
 36 |     this.targets = [];
 37 |     if(init?.targets){
 38 |       
 39 |       init?.targets.forEach(x => this.targets.push(new Target(x)));
 40 |     }
 41 |     if(!init?.threshold){
 42 |       this.threshold = 0.4.toString() + '%';
 43 |     }
 44 |   }
 45 |   
 46 | }
 47 | 
 48 | export class StopLoss {
 49 |   type: SLType = SLType.FIXED;
 50 |   threshold = '5%';
 51 |   initial_target: Target;
 52 |   isFixed(): boolean { return this.type === SLType.FIXED; }
 53 |  
 54 |   get isTrailing(): boolean { return this.type === SLType.TRAILING; }
 55 |   set isTrailing(value: boolean) { this.type = value ? SLType.TRAILING:SLType.FIXED;}
 56 |   
 57 |   constructor() {
 58 |     this.initial_target = new Target();
 59 |     this.initial_target.vol = '100%';
 60 |   }
 61 | }
 62 | 
 63 | export class TradeDetails {
 64 | 
 65 |   private _stoploss: StopLoss;
 66 | 
 67 |   id: string;
 68 |   asset: string;
 69 |   cap: string;
 70 |   symbol = '';
 71 |   side: 'BUY' | 'SELL' = 'SELL';
 72 |   status: 'NEW' | 'ACTIVE' | 'COMPLETED';
 73 |   exit: ExitInfo;
 74 |   entry?: Entry;
 75 | 
 76 |   get stoploss(): StopLoss {
 77 |     return this._stoploss;
 78 |   }
 79 | 
 80 |   set stoploss(stoploss: StopLoss) {
 81 |     if (!stoploss) {
 82 |       this._stoploss = null;
 83 |     } else if (stoploss instanceof StopLoss) {
 84 |       this._stoploss = stoploss;
 85 |     } else {
 86 |       this._stoploss = Object.assign(new StopLoss(), stoploss);
 87 |     }
 88 |   }
 89 | 
 90 |   constructor(create_new: boolean = false, init?: Partial<TradeDetails>) {
 91 |     Object.assign(this, init);
 92 |     if (init?.exit){
 93 |       this.exit = new ExitInfo(init.exit);
 94 |     }
 95 |     if (init?.entry){
 96 |       this.entry = new Entry(init.entry);
 97 |     }
 98 | 
 99 |     if (create_new) {
100 |       this.exit = new ExitInfo();
101 |       this.id = this.generateGuid();
102 |     }
103 |   }
104 | 
105 |   // getInstance<T>(obj: T, c: new () => T): T {
106 |   //   if (!obj) {
107 |   //     return null;
108 |   //   } else if (obj instanceof T) {
109 |   //     return obj;
110 |   //   } else {
111 |   //     Object.assign(c(), obj);
112 |   //   }
113 |   // }
114 | 
115 |   isBuy(): boolean { return this.side === 'BUY'; }
116 |   isSell(): boolean { return !this.isBuy(); }
117 | 
118 |   generateGuid(): string {
119 |     let result = '';
120 |     let i: string;
121 |     let j: number;
122 | 
123 |     for (j = 0; j < 32; j++) {
124 |       if (j === 8 || j === 12 || j === 16 || j === 20) {
125 |         result = result + '-';
126 |       }
127 |       i = Math.floor(Math.random() * 16).toString(16).toUpperCase();
128 |       result = result + i;
129 |     }
130 | 
131 |     return result;
132 |   }
133 | }
134 | 
135 | export class EntryTarget {
136 |   
137 |   constructor(init?: Partial<EntryTarget>) {
138 |     Object.assign(this, init);
139 |   }
140 | 
141 |   id: number;
142 |   date: string;
143 |   best_price: string;
144 |   status: TradeStatus;
145 |   price: string;
146 |   vol: string;
147 | 
148 |   isCompleted(): boolean { return this.status === TradeStatus.COMPLETED; }
149 | }
150 | 
151 | export class Entry {
152 | 
153 |   side: 'BUY' | 'SELL' = 'BUY';
154 |   targets: EntryTarget[];
155 |   smart: boolean;
156 | 
157 |   constructor(init?: Partial<Entry>, sell?: boolean) {
158 |     
159 |     Object.assign(this, init);
160 |     
161 |     if(init?.targets){
162 |       this.targets = [];
163 |       init?.targets.forEach(x => this.targets.push(new EntryTarget(x)));
164 |     }
165 |     
166 |     this.setIsSell(sell);
167 |   }
168 | 
169 |   getTarget(): EntryTarget {
170 |     return this.targets && this.targets.length > 0? this.targets[0] : null;
171 |   }
172 | 
173 |   
174 | 
175 |   isBuy(): boolean { return this.side === 'BUY'; }
176 |   isSell(): boolean { return !this.isBuy(); }
177 |   setIsSell(sell: boolean): void {
178 |     if (sell) { this.side = 'SELL'; } else { this.side = 'BUY'; }
179 |   }
180 | }
181 | 
182 | 
183 | 
184 | export enum TradeDetailMode {
185 |   View,
186 |   Edit,
187 |   Create
188 | }
189 | 
190 | export class Mode {
191 |   constructor(private mode: TradeDetailMode) {}
192 | 
193 |   isView(): boolean { return this.mode === TradeDetailMode.View; }
194 |   isEdit(): boolean { return this.mode === TradeDetailMode.Edit; }
195 |   isCreate(): boolean { return this.mode === TradeDetailMode.Create; }
196 | 
197 |   setEdit(): void { this.mode = TradeDetailMode.Edit; }
198 |   setView(): void { this.mode = TradeDetailMode.View; }
199 | 
200 |   str(): string {
201 |     if (this.mode === TradeDetailMode.View) { return 'View'; }
202 |     if (this.mode === TradeDetailMode.Edit) { return 'Edit'; }
203 |     if (this.mode === TradeDetailMode.Create) { return 'Create'; }
204 | 
205 |     return 'Unknown';
206 |   }
207 | 
208 | }
209 | 


--------------------------------------------------------------------------------
/admin/src/app/trade-details/entry-details.component.html:
--------------------------------------------------------------------------------
 1 | <mat-expansion-panel #exp>
 2 |   <mat-expansion-panel-header>
 3 |     <mat-panel-title>
 4 |       Entry Target
 5 |     </mat-panel-title>
 6 |     <mat-panel-description>
 7 |       Aquire The Asset Before Selling it Within One Trade
 8 |     </mat-panel-description>
 9 |   </mat-expansion-panel-header>
10 | 
11 |   <!-- <button mat-raised-button class="resume-btn" matTooltip="Add Target" (click)="addNewTarget()" *ngIf="!trade.entry">
12 |     Add Entry Target
13 | </button> -->
14 | <button mat-icon-button class="resume-btn" matTooltip="Add Target" (click)="addNewTarget()" *ngIf="!trade.entry">
15 |   <mat-icon>add_circle_outline</mat-icon>
16 | </button>
17 | <div class="trade-section" *ngIf="trade.entry">
18 |   
19 |   Operation: <span class="{{trade.entry.isSell()?'sell': 'buy'}}-button-on" style="padding: 2px;">{{trade.entry.isSell()?'Sell': 'Buy'}}</span>
20 |   <div *ngIf="!mode.isCreate()" style="display: inline;">&nbsp;Status: <span><strong>{{trade.entry.getTarget()?.status}}</strong></span></div>
21 |   <table class="full-width" cellspasing=0>
22 |     <tr *ngFor="let entryTarget of trade.entry.targets"><td>
23 |       <mat-form-field class="full-width" appearance="standard">
24 |         <mat-label>Entry Price</mat-label>
25 |         <input matInput type="text" id="targetPrice" name="targetPrice" [(ngModel)]="entryTarget.price" disabled="{{entryTarget.isCompleted()}}" >
26 |       </mat-form-field>
27 |     </td>
28 |     <td>
29 |       <mat-form-field class="full-width" appearance="standard">
30 |         <mat-label>Volume</mat-label>
31 |         <input matInput type="text" id="targetVol" name="targetVol" [(ngModel)]="entryTarget.vol" disabled="{{entryTarget.isCompleted()}}">
32 |       </mat-form-field>
33 |     </td>
34 |     <td>
35 |       <mat-form-field class="full-width exit-target-input" appearance="standard">
36 |         <mat-label>Status</mat-label>
37 |         <input matInput type="text" id="status" name="status" [(ngModel)]="entryTarget.status" disabled>
38 |       </mat-form-field>
39 |     </td>
40 |     <td>
41 |       <mat-form-field class="full-width exit-target-input" appearance="standard">
42 |       <mat-label>Order ID</mat-label>
43 |       <input matInput type="text" id="id" name="id" [(ngModel)]="entryTarget.id" disabled>
44 |       <mat-hint *ngIf="entryTarget.id && entryTarget.best_price" matTooltip="Trigger Price">tp: {{entryTarget.best_price | number: '1.0-8'}}</mat-hint>
45 |     </mat-form-field></td>
46 |     <td>
47 |     <td>
48 |     </td>
49 |     <td>
50 |       <button mat-icon-button class="delete-btn" matTooltip="Remove Target" (click)="deleteTarget()" disabled="{{entryTarget.isCompleted()}}" >
51 |         <mat-icon>remove_circle_outline</mat-icon>
52 |       </button>
53 |     </td>
54 |   </tr>
55 |   </table>
56 | </div>
57 | </mat-expansion-panel>
58 | 


--------------------------------------------------------------------------------
/admin/src/app/trade-details/entry-details.component.ts:
--------------------------------------------------------------------------------
 1 | import {AfterViewInit, Component, Input, OnInit, ViewChild} from '@angular/core';
 2 | import { MatExpansionPanel } from '@angular/material/expansion';
 3 | import {Mode, Entry, EntryTarget, TradeDetails} from '../trade-details';
 4 | 
 5 | @Component({
 6 |   selector: 'app-entry-details',
 7 |   templateUrl: './entry-details.component.html',
 8 |   styleUrls: ['./trade-details.component.css']
 9 | })
10 | 
11 | export class EntryDetailsComponent implements OnInit, AfterViewInit {
12 |   @ViewChild(MatExpansionPanel) exp: MatExpansionPanel;
13 |   
14 |   @Input()
15 |   trade: TradeDetails;
16 | 
17 |   @Input()
18 |   mode: Mode;
19 | 
20 |   entryTarget: EntryTarget;
21 | 
22 |   constructor() {
23 | 
24 |   }
25 |   
26 |   ngOnInit(): void {
27 |   }
28 | 
29 |   ngAfterViewInit(): void {
30 |     // console.log(this.exp)
31 |     // this.exp.expanded = true;
32 |     this.exp.expanded = this.trade.entry? true : false;
33 |   }
34 | 
35 |   deleteTarget(exitTarget: EntryTarget) {
36 |     this.entryTarget = null;
37 |     this.trade.entry = null;
38 |   }
39 | 
40 |   addNewTarget() {
41 |     if (this.entryTarget) {
42 |       return;
43 |     }
44 | 
45 |     this.entryTarget = new EntryTarget();
46 | 
47 |     if (!this.trade.entry) {
48 |       this.trade.entry = new Entry(null, !this.trade.isSell());
49 |     }
50 | 
51 |     this.trade.entry.targets = [this.entryTarget];
52 |   }
53 | }
54 | 
55 | 


--------------------------------------------------------------------------------
/admin/src/app/trade-details/exit-details.component.html:
--------------------------------------------------------------------------------
 1 | <mat-expansion-panel expanded>
 2 |   <mat-expansion-panel-header>
 3 |     <mat-panel-title>
 4 |       Exit Targets
 5 |     </mat-panel-title>
 6 |     <mat-panel-description>
 7 |       Configuration For Exit Targets
 8 |     </mat-panel-description>
 9 |   </mat-expansion-panel-header>
10 |   <!-- <mat-expansion-panel>
11 |     <mat-expansion-panel-header>
12 |       <mat-panel-title>
13 |         Default Settings
14 |       </mat-panel-title>
15 |       <mat-panel-description>
16 |       </mat-panel-description>
17 |     </mat-expansion-panel-header>
18 |     <table class="full-width" cellspasing=0>
19 |       <tr><td>
20 |         <mat-checkbox [(ngModel)]="trade.exit.smart" color="primary">Smart (can be overrwritten by individual target)</mat-checkbox>
21 |       </td><td>
22 |         <mat-form-field class="full-width" appearance="standard">
23 |           <mat-label>Threshold</mat-label>
24 |           <input matInput type="text" id="targetPrice" name="targetPrice" [(ngModel)]="trade.exit.threshold">
25 |         </mat-form-field>
26 |       </td></tr>
27 |     </table>
28 |   </mat-expansion-panel> -->
29 |     <div class="trade-section">
30 |       <table class="full-width" cellspasing=0>
31 |         <tr *ngFor="let exitTarget of trade.exit.targets">
32 |           <td>
33 |             <mat-form-field class="full-width exit-target-input" appearance="standard">
34 |               <mat-label>Target Price</mat-label>
35 |               <input matInput type="text" id="targetPrice" name="targetPrice" [(ngModel)]="exitTarget.price">
36 |             </mat-form-field>
37 |           </td>
38 |           <td>
39 |             <mat-form-field class="full-width exit-target-input" appearance="standard">
40 |               <mat-label>Volume</mat-label>
41 |               <input matInput type="text" id="targetPrice" name="targetPrice" [(ngModel)]="exitTarget.vol">
42 |               <mat-hint *ngIf="exitTarget.calculated_volume" matTooltip="Calculated Volume">{{exitTarget.calculated_volume | number: '1.0-8'}}</mat-hint>
43 |             </mat-form-field>
44 |           </td>
45 |           <td>
46 |             <mat-checkbox [(ngModel)]="exitTarget.smart" color="primary">Smart</mat-checkbox>
47 |           </td>
48 |           <td>
49 |             <mat-form-field class="full-width exit-target-input" appearance="standard">
50 |               <mat-label>Stop Loss</mat-label>
51 |               <input matInput type="text" id="sl" name="sl" [(ngModel)]="exitTarget.sl">
52 |             </mat-form-field>
53 |           </td>
54 |           <td>
55 |             <mat-form-field class="full-width exit-target-input" appearance="standard">
56 |               <mat-label>Status</mat-label>
57 |               <input matInput type="text" id="status" name="status" [(ngModel)]="exitTarget.status" disabled>
58 |             </mat-form-field>
59 |           </td>
60 |           <td>
61 |             <mat-form-field class="full-width exit-target-input" appearance="standard">
62 |             <mat-label>Order ID</mat-label>
63 |             <input matInput type="text" id="id" name="id" [(ngModel)]="exitTarget.id" disabled>
64 |             <mat-hint *ngIf="exitTarget.id && exitTarget.best_price" matTooltip="Trigger Price">tp: {{exitTarget.best_price | number: '1.0-8'}}</mat-hint>
65 |           </mat-form-field></td>
66 |           <td>
67 |             <button mat-icon-button class="delete-btn" matTooltip="Remove Target" (click)="deleteTarget(exitTarget)" disabled="{{exitTarget.isCompleted()}}">
68 |               <mat-icon>remove_circle_outline</mat-icon>
69 |             </button>
70 |           </td>
71 |         </tr>
72 |       </table>
73 |       <button mat-icon-button class="resume-btn" matTooltip="Add Target" (click)="addNewTarget()"
74 |       [disabled]="!(!lastAddedTarget || (lastAddedTarget && lastAddedTarget.vol && lastAddedTarget.price))">
75 |         <mat-icon>add_circle_outline</mat-icon>
76 |       </button>
77 |       <mat-form-field appearance="standard" style="display: block; width: 30%;">
78 |         <mat-label>Smart Target Threshold</mat-label>
79 |         <input matInput type="text" id="targetPrice" name="targetPrice" [(ngModel)]="trade.exit.threshold">
80 |       </mat-form-field>
81 |     </div>
82 | </mat-expansion-panel>
83 | 
84 | 


--------------------------------------------------------------------------------
/admin/src/app/trade-details/exit-details.component.ts:
--------------------------------------------------------------------------------
 1 | import {Component, Input, OnInit} from '@angular/core';
 2 | import {Mode, Target, TradeDetails} from '../trade-details';
 3 | 
 4 | @Component({
 5 |   selector: 'app-exit-details',
 6 |   templateUrl: './exit-details.component.html',
 7 |   styleUrls: ['./trade-details.component.css']
 8 | })
 9 | 
10 | export class ExitDetailsComponent implements OnInit {
11 |   @Input()
12 |   trade: TradeDetails;
13 | 
14 |   @Input()
15 |   mode: Mode;
16 | 
17 |   lastAddedTarget: Target;
18 | 
19 |   constructor() {
20 | 
21 |   }
22 | 
23 |   ngOnInit(): void {
24 |   }
25 | 
26 |   deleteTarget(exitTarget: Target) {
27 |     if (exitTarget === this.lastAddedTarget) {
28 |       this.lastAddedTarget = null;
29 |     }
30 |     this.trade.exit.targets = this.trade.exit.targets.filter(et => et !== exitTarget);
31 |   }
32 | 
33 |   addNewTarget() {
34 |     if (this.lastAddedTarget && !this.lastAddedTarget.price) { return; }
35 | 
36 |     this.lastAddedTarget = new Target();
37 | 
38 |     if (!this.trade.exit.targets){
39 |       this.trade.exit.targets = [];
40 |     }
41 |     this.trade.exit.targets.push(this.lastAddedTarget);
42 |   }
43 | }
44 | 


--------------------------------------------------------------------------------
/admin/src/app/trade-details/sl-details.component.html:
--------------------------------------------------------------------------------
 1 | <mat-expansion-panel #exp>
 2 |   <mat-expansion-panel-header>
 3 |     <mat-panel-title>
 4 |       Stoploss
 5 |     </mat-panel-title>
 6 |     <mat-panel-description>
 7 |       Configuration For The Stoploss
 8 |     </mat-panel-description>
 9 |   </mat-expansion-panel-header>
10 | 
11 |   <button mat-icon-button class="resume-btn" matTooltip="Add Stoploss" (click)="addStopLoss()" *ngIf="!trade.stoploss">
12 |     <mat-icon>add_circle_outline</mat-icon>
13 |   </button>
14 |   <table class="full-width" cellspasing=0 *ngIf="trade.stoploss" >
15 |     <tr>
16 |       <td><mat-checkbox [(ngModel)]="trade.stoploss.isTrailing">Trailing</mat-checkbox></td>
17 |       <td><mat-form-field class="full-width exit-target-input" appearance="standard">
18 |         <mat-label>Threshold</mat-label>
19 |           <input matInput type="text" id="th" name="th" [(ngModel)]="trade.stoploss.threshold" [disabled]="trade.stoploss.isFixed()">
20 |         </mat-form-field>
21 |       </td>
22 |       <td><mat-form-field class="full-width exit-target-input" appearance="standard">
23 |         <mat-label>Price</mat-label>
24 |           <input matInput type="text" id="tp" name="tp" [(ngModel)]="trade.stoploss.initial_target.price">
25 |         </mat-form-field></td>
26 |       <td>
27 |         <mat-form-field class="full-width exit-target-input" appearance="standard">
28 |         <mat-label>Volume</mat-label>
29 |           <input matInput type="text" id="vol" name="vol" [(ngModel)]="trade.stoploss.initial_target.vol">
30 |           <mat-hint *ngIf="trade.stoploss.initial_target.calculated_volume" matTooltip="Calculated Volume">{{trade.stoploss.initial_target.calculated_volume | number: '1.0-8'}}</mat-hint>
31 |         </mat-form-field>
32 |       </td>
33 |       <td>
34 |         <button mat-icon-button class="delete-btn" matTooltip="Remove Target" (click)="deleteStopLoss()">
35 |           <mat-icon>remove_circle_outline</mat-icon>
36 |         </button>
37 |       </td>
38 |     </tr>
39 |   </table>
40 | 
41 | </mat-expansion-panel>
42 | 


--------------------------------------------------------------------------------
/admin/src/app/trade-details/sl-details.component.ts:
--------------------------------------------------------------------------------
 1 | import {AfterViewInit, Component, ElementRef, Input, OnInit, ViewChild} from '@angular/core';
 2 | import { MatExpansionPanel } from '@angular/material/expansion';
 3 | import {Mode, SLType, StopLoss, TradeDetails} from '../trade-details';
 4 | 
 5 | 
 6 | @Component({
 7 |   selector: 'app-sl-details',
 8 |   templateUrl: './sl-details.component.html',
 9 |   styleUrls: ['./trade-details.component.css']
10 | })
11 | export class SLDetailsComponent implements OnInit, AfterViewInit {
12 |   private SLType = SLType;
13 |   // private _trade: TradeDetails;
14 | 
15 |   @ViewChild(MatExpansionPanel) exp: MatExpansionPanel;
16 |   @Input()
17 |   trade: TradeDetails;
18 | 
19 |   @Input()
20 |   mode: Mode;
21 | 
22 |   constructor() {
23 | 
24 |   }
25 | 
26 |   ngOnInit(): void {
27 |     
28 |   }
29 | 
30 |   ngAfterViewInit(): void {
31 |     this.exp.expanded = this.trade.stoploss? true:false;
32 |   }
33 | 
34 |   addStopLoss() {
35 |     if (!this.trade.stoploss) {
36 |       this.trade.stoploss = new StopLoss();
37 |     }
38 |   }
39 | 
40 |   deleteStopLoss() {
41 |     if (this.trade.stoploss) {
42 |       this.trade.stoploss = null;
43 |     }
44 |   }
45 | }
46 | 


--------------------------------------------------------------------------------
/admin/src/app/trade-details/symbol-validator.ts:
--------------------------------------------------------------------------------
 1 | import { Directive, Input } from '@angular/core';
 2 | import { AbstractControl, NG_VALIDATORS, Validator } from '@angular/forms';
 3 | 
 4 | @Directive({
 5 |   selector: '[appSymbolValidator]',
 6 |   providers: [{provide: NG_VALIDATORS, useExisting: SymbolValidatorDirective, multi: true}]
 7 | })
 8 | export class SymbolValidatorDirective implements Validator {
 9 |   symbols: Set<string>;
10 |   @Input('appSymbolValidator')
11 |   set appSymbolValidator(val: string[]){
12 |     this.symbols = new Set(val)
13 |   }
14 |   
15 | 
16 |   validate(control: AbstractControl): {[key: string]: any} | null {
17 |     if (this.symbols) {
18 |       return this.symbols.has(control.value) ? null : {'appSymbolValidator': {value: control.value}};
19 |     }
20 |     return null;
21 |   }
22 | }
23 | 


--------------------------------------------------------------------------------
/admin/src/app/trade-details/trade-details.component.css:
--------------------------------------------------------------------------------
 1 | .row-no-btm-margin { margin-bottom: 0px; }
 2 | 
 3 | .task-header {
 4 |     background-color: transparent;
 5 |     padding: 0 5px;
 6 |     height: 20px;
 7 | }
 8 | .fx-spacer {
 9 |     flex: 1 1 auto;
10 | }
11 | 
12 | .mat-grid-tile .mat-figure {
13 |     justify-content: flex-start !important ;
14 |     align-items: flex-start !important;
15 |  }
16 | 
17 |  .figure-div {
18 |     width: 100%; display: flex; align-items: flex-start;
19 |  }
20 | 
21 |  .trade-details-form {
22 |     display: flex;
23 |     flex-direction: column;
24 |     height: 100%;
25 |   }
26 | 
27 |   .full-width {
28 |     width: 100%;
29 |   }
30 |   
31 |   td {
32 |     padding-right: 8px;
33 |   }
34 |   
35 |   mat-button-toggle-group {
36 |     margin-left: 12px;
37 |     height: 32px;
38 |     align-items: center;
39 |   }
40 | 
41 |   .full-width-input {
42 |     width: 100%;
43 |     display: flex; 
44 |     justify-content: flex-start !important ;
45 |     align-items: flex-start !important;
46 |   }
47 | 
48 |   .exit-target-input {
49 |     min-width: 60px;
50 |     max-width: 100px;
51 |   }
52 | 
53 | .exp-headers-align .mat-expansion-panel-header-title,
54 | .exp-headers-align .mat-expansion-panel-header-description {
55 |   flex-basis: 0;
56 | }
57 | 
58 | .exp-headers-align .mat-expansion-panel-header-description {
59 |   justify-content: space-between;
60 |   align-items: flex-end;
61 | }
62 | 
63 | .exp-headers-align .mat-form-field + .mat-form-field {
64 |   margin-left: 8px;
65 | }
66 | 
67 | .right-aligned-header > .mat-content {
68 |   justify-content: space-between;
69 | }
70 | 
71 | .mat-content > mat-panel-title, .mat-content > mat-panel-description {
72 | flex: 0 0 auto;
73 | }
74 | 
75 | .accordeon {
76 |   margin: 1px;
77 | }
78 | 
79 | .mat-dialog-content
80 | {
81 |   flex-grow: 1;
82 |   max-height: unset;
83 | }


--------------------------------------------------------------------------------
/admin/src/app/trade-details/trade-details.component.html:
--------------------------------------------------------------------------------
 1 | <form #tradeForm="ngForm" class="trade-details-form" (keydown.enter)="$event.preventDefault()">
 2 |   <h1 mat-dialog-title>
 3 |     <mat-toolbar role="toolbar" class="task-header">
 4 |         <span>{{mode.str()}} Trade</span>
 5 |         <span class="fx-spacer"></span>
 6 |         <button mat-icon-button matTooltip="Refresh trade info" (click)="init()" *ngIf="!mode.isCreate()">
 7 |           <mat-icon>refresh</mat-icon>
 8 |         </button>
 9 |         <!-- <button mat-icon-button mat-dialog-close="cancel" aria-label="Close" matTooltip="Close">
10 |             <mat-icon mat-list-icon>close</mat-icon>
11 |         </button> -->
12 |     </mat-toolbar>
13 | 
14 |   </h1>
15 | 
16 | 
17 |   <div mat-dialog-content *ngIf="trade" class="trade-section">
18 |     <mat-accordion class="exp-headers-align" multi class="accordeon">
19 |       <mat-expansion-panel expanded>
20 |         <mat-expansion-panel-header>
21 |           <mat-panel-title>
22 |             Trading Pair
23 |           </mat-panel-title>
24 |           <mat-panel-description>
25 |             Basic Tade Information
26 |           </mat-panel-description>
27 |         </mat-expansion-panel-header>
28 |         <div [disabled]="!mode.isCreate()">
29 |           <p><span>ID: </span><span><strong>{{trade.id}}</strong></span></p>
30 |           <table class="full-width" cellspacing="0"><tr>
31 |             <td><app-auto-complete #symAutoComplete
32 |               [fieldCtrl]="myControl"
33 |               [placeHolder]="'ETHUSDC'"
34 |               [appearance]="'standard'"
35 |               [smartList]="symbols"
36 |               [label] = "'Trading Pair'"
37 |               (optionSelected)="onSymbolSelected($event)"
38 |               [model]="trade.symbol"
39 |               [class]="'full-width'"
40 |               [disabled]="!mode.isCreate()"
41 | 
42 |               >
43 |               </app-auto-complete></td>
44 |             <td><mat-form-field class="full-width" appearance="standard">
45 |                 <mat-label>Asset</mat-label>
46 |                 <input matInput type="text" id="asset" name="asset" [ngModel]="trade.asset" disabled="true">
47 |               </mat-form-field></td>
48 |             <td><mat-form-field class="full-width" appearance="standard">
49 |               <mat-label>Cap</mat-label>
50 |               <input matInput type="text" id="cap" name="cap" disabled="{{!mode.isCreate()}}" [ngModel]="trade.cap">
51 |               <mat-hint>Limit your trade</mat-hint>
52 |             </mat-form-field></td>
53 |           </tr></table>
54 |           <table class="full-width" cellspacing="0"><tr>
55 |             <td>Side
56 |               <mat-button-toggle-group name="side" [(ngModel)]="trade.side" (change)="onSideChanged($event)" >
57 |                 <mat-button-toggle value="SELL" class="sell-button-{{trade.isSell() ? 'on' : 'off'}}" *ngIf="mode.isCreate() || (!mode.isCreate() && trade.isSell())">Sell</mat-button-toggle>
58 |                 <mat-button-toggle value="BUY" class="buy-button-{{trade.isBuy() ? 'on' : 'off'}}"  *ngIf="mode.isCreate() || (!mode.isCreate() && trade.isBuy())">Buy</mat-button-toggle>
59 |               </mat-button-toggle-group>
60 |             </td>
61 |             <td *ngIf="priceInfo?.symbol == trade.symbol">
62 |               Price Info
63 |               <span class="buy-button-on">Bid: {{ priceInfo.bestBid }}</span><button mat-icon-button matTooltip="Copy bid price">
64 |                 <mat-icon [cdkCopyToClipboard]="priceInfo.bestBid">file_copy</mat-icon>
65 |               </button>&nbsp;
66 |               <span class="sell-button-on">Ask: {{ priceInfo.bestAsk }}</span><button mat-icon-button matTooltip="Copy ask price">
67 |                 <mat-icon [cdkCopyToClipboard]="priceInfo.bestAsk">file_copy</mat-icon>
68 |               </button>
69 |             </td>
70 |           </tr>
71 |           </table>
72 |         </div>
73 |       </mat-expansion-panel>
74 | 
75 |     <app-entry-details [trade]="trade" [mode]="mode"></app-entry-details>
76 |     <app-exit-details [trade]="trade" [mode]="mode"></app-exit-details>
77 |     <app-sl-details [trade]="trade" [mode]="mode"></app-sl-details>
78 |   </mat-accordion>
79 |   </div>
80 |   <mat-progress-bar #progress mode="query" *ngIf="showProgress"></mat-progress-bar>
81 |   <div mat-dialog-actions align="end">
82 |     <button mat-button type="submit" color="primary" (click)="showProgress = true; confirm()" *ngIf="!mode.isView()" [disabled]="myControl.errors && mode.isCreate()" >{{ mode.isCreate()? "Create":"Save" }}</button>
83 |     <button mat-button mat-dialog-close="cancel" color="primary">Cancel</button>
84 |   </div>
85 | </form>
86 | 


--------------------------------------------------------------------------------
/admin/src/app/trade-details/trade-details.component.spec.ts:
--------------------------------------------------------------------------------
 1 | import { ComponentFixture, TestBed, waitForAsync } from '@angular/core/testing';
 2 | 
 3 | import { TradeDetailsComponent } from './trade-details.component';
 4 | 
 5 | describe('TradeDetailsComponent', () => {
 6 |   let component: TradeDetailsComponent;
 7 |   let fixture: ComponentFixture<TradeDetailsComponent>;
 8 | 
 9 |   beforeEach(waitForAsync(() => {
10 |     TestBed.configureTestingModule({
11 |       declarations: [ TradeDetailsComponent ]
12 |     })
13 |     .compileComponents();
14 |   }));
15 | 
16 |   beforeEach(() => {
17 |     fixture = TestBed.createComponent(TradeDetailsComponent);
18 |     component = fixture.componentInstance;
19 |     fixture.detectChanges();
20 |   });
21 | 
22 |   it('should create', () => {
23 |     expect(component).toBeTruthy();
24 |   });
25 | });
26 | 


--------------------------------------------------------------------------------
/admin/src/app/trade-details/trade-details.component.ts:
--------------------------------------------------------------------------------
  1 | import {AfterContentInit, ChangeDetectorRef, Component, ElementRef, Inject, OnInit, Optional, TemplateRef, ViewChild} from '@angular/core';
  2 | import {Location} from '@angular/common';
  3 | import {ActivatedRoute, ParamMap, Router} from '@angular/router';
  4 | import {BinancePriceResult, BotApi} from '../botapi';
  5 | import {BinanceService} from '../binance.service';
  6 | import {switchMap} from 'rxjs/operators';
  7 | import {Mode, TradeDetailMode, TradeDetails} from '../trade-details';
  8 | import {Observable} from 'rxjs';
  9 | // import {BsModalService} from 'ngx-bootstrap/modal';
 10 | // import {BsModalRef} from 'ngx-bootstrap/modal/bs-modal-ref.service';
 11 | import {MatDialog, MatDialogRef, MAT_DIALOG_DATA} from '@angular/material/dialog';
 12 | import {TradeEvent, TradeService} from '../trade.service';
 13 | import { FormControl, Validators } from '@angular/forms';
 14 | import {map, startWith} from 'rxjs/operators';
 15 | import { AutoCompleteComponent } from '../auto-complete/auto-complete.component';
 16 | import { SymbolValidatorDirective } from './symbol-validator';
 17 | import { reduceEachTrailingCommentRange } from 'typescript';
 18 | import { NotificationMessage, NotificationService, NotificatoinType } from '../services/notification.service';
 19 | 
 20 | @Component({
 21 |   selector: 'app-trade-details',
 22 |   templateUrl: './trade-details.component.html',
 23 |   styleUrls: ['./trade-details.component.css']
 24 | })
 25 | export class TradeDetailsComponent implements OnInit {
 26 | 
 27 | 
 28 |   private tradeDetailMode = TradeDetailMode;
 29 |   @ViewChild('symAutoComplete') autoComplete: AutoCompleteComponent;
 30 | 
 31 |   // trade$: Observable<TradeDetails>;
 32 |   trade: TradeDetails;
 33 | 
 34 |   tradeId: string;
 35 |   mode: Mode;
 36 |   // trade: TradeDetails;
 37 |   priceInfo: BinancePriceResult;
 38 | 
 39 |   exchangeInfo: Map<string, string>;
 40 |   symbols: string[] = [];
 41 |   public showProgress: Boolean = false;
 42 | 
 43 |   myControl = new FormControl('', Validators.required);
 44 | 
 45 |   // private config = {
 46 |   //   class: 'modal-lg',
 47 |   //   keyboard: false,
 48 |   //   ignoreBackdropClick: true
 49 |   // };
 50 |   // modalRef: MatDialogRef<any, any>;
 51 | 
 52 |   constructor(@Inject(MAT_DIALOG_DATA) public data: {mode: Mode, id: string},
 53 |               private dialogRef: MatDialogRef<TradeDetailsComponent>,
 54 |               private notificationService: NotificationService,
 55 |               private route: ActivatedRoute,
 56 |               private changeDetector: ChangeDetectorRef,
 57 |               private router: Router,
 58 |               private location: Location,
 59 |               private api: BotApi,
 60 |               private binance: BinanceService,
 61 |               private tradeService: TradeService
 62 |               ) {
 63 |     this.mode = data.mode;
 64 |     this.tradeId = data.id
 65 |     // this.route.paramMap.subscribe(params => this.mode = new Mode(<TradeDetailMode>params.get('mode')));
 66 |   }
 67 | 
 68 |   static openDialog(dialog: MatDialog, mode: Mode,  tradeId: string) {
 69 |     let tdDialog = dialog.open(TradeDetailsComponent, {
 70 |       data: { mode: mode, id: tradeId },
 71 |       width: '800px',
 72 |       height: '90%'
 73 |     });
 74 |     // tdDialog.afterClosed().subscribe(result => {
 75 |     //   console.log(`Dialog result: ${result}`);
 76 |     // });
 77 |   }
 78 | 
 79 |   ngOnInit() {
 80 |     this.init()
 81 |   }
 82 | 
 83 |   init() {
 84 | 
 85 |     if (this.mode.isCreate()) {
 86 |       this.trade = new TradeDetails(true);
 87 | 
 88 |       this.api.getExchangeInfo().subscribe(
 89 |         res => {
 90 |           this.exchangeInfo = new Map<string, string>();
 91 | 
 92 |           res.forEach(si => {
 93 |             this.exchangeInfo.set(si.s, si.b);
 94 |             this.symbols.push(si.s);
 95 |           });
 96 | 
 97 |           this.autoComplete.smartList = this.symbols.sort();
 98 |         }
 99 |       );
100 |     } else {
101 |       this.exchangeInfo = new Map<string,string>();
102 |       this.api.getActiveTradeInfo(this.tradeId).subscribe(trade => {
103 |         this.trade = trade;
104 |         this.api.bookTicker(trade.symbol).subscribe(
105 |           result => { this.priceInfo = result;}
106 |         )
107 |       })
108 |     }
109 |   }
110 | 
111 |   confirm() {
112 |     this.api.addTrade(this.trade).subscribe(
113 |       res => {
114 |         if (this.mode.isCreate() || this.mode.isEdit()) {
115 |           this.tradeService.anounce(new TradeEvent('TradeDeatails', this.mode.isCreate() ? 'created': 'updated'));
116 |         }
117 | 
118 |         if(!this.myControl.errors && this.dialogRef)
119 |             this.dialogRef.close()
120 |       },
121 |       err => {
122 |         this.notificationService.NotifyAlert('Trade creation error');
123 |         console.log(err);
124 |       }
125 |     );
126 |   }
127 | 
128 |   // decline() {
129 |   //   this.closeModal();
130 |   // }
131 | 
132 |   // closeModal() {
133 |   //   // this.modalRef.close()
134 |   //   // this.router.navigate(['/trades']);
135 |   // }
136 | 
137 |   // onPriceUpdate(price: BinancePriceResult): void {
138 |   //   this.priceInfo = price;
139 |   // }
140 | 
141 |   // as entry doesn't allow to choose side now, changing side on the
142 |   // parent level will set opposite side for the entry
143 |   onSideChanged(event): void {
144 |     if (this.trade.entry){
145 |       this.trade.entry.setIsSell(this.trade.isBuy());
146 |     }
147 |   }
148 | 
149 |   onSymbolSelected(symbol) {
150 |     if (typeof(symbol) !== 'string')
151 |       return;
152 | 
153 |       if (this.mode.isCreate()) {
154 | 
155 |       let asset = this.exchangeInfo.get(symbol)
156 | 
157 |       if (this.trade.symbol !== symbol) {
158 |         this.trade.asset = asset;
159 |         this.trade.symbol = symbol;
160 | 
161 |         this.api.bookTicker(symbol).subscribe(
162 |           result => { this.priceInfo = result;}
163 |         )
164 |         // this.binance.getPrice(symbol).subscribe(this.onPriceUpdate.bind(this));
165 |       }
166 |     }
167 |   }
168 | }
169 | 


--------------------------------------------------------------------------------
/admin/src/app/trade.service.ts:
--------------------------------------------------------------------------------
 1 | 
 2 | import {Subject} from 'rxjs';
 3 | import {Injectable} from '@angular/core';
 4 | 
 5 | export class TradeEvent {
 6 |   source: string;
 7 |   type: 'created' | 'updated';
 8 | 
 9 |   constructor(source, type) {
10 |     this.source = source;
11 |     this.type = type;
12 |   }
13 | }
14 | 
15 | @Injectable({ providedIn: 'root' })
16 | export class TradeService {
17 |   private eventAnouncementSource = new Subject<TradeEvent>();
18 |   eventAnounces$ = this.eventAnouncementSource.asObservable();
19 | 
20 |   anounce(evt: TradeEvent): void {
21 |     this.eventAnouncementSource.next(evt);
22 |   }
23 | }
24 | 


--------------------------------------------------------------------------------
/admin/src/app/tradeInfo.ts:
--------------------------------------------------------------------------------
 1 | export class TradeInfo {
 2 |   id: string;
 3 |   sym: string;
 4 |   avail: number;
 5 |   locked: number;
 6 |   price: number;
 7 | //  currPriceB?: number;
 8 |   btcVal: number;
 9 |   paused: boolean;
10 |   buy: boolean;
11 | 
12 |   get balance(): number {
13 |     return this.avail + this.locked;
14 |   }
15 | 
16 |   constructor(init?: Partial<TradeInfo>){
17 |     Object.assign(this, init);
18 |   }
19 |   // public setCurrPrice(bid, ask) {
20 |   //   this.currPriceA = ask;
21 |   //   this.currPriceB = bid;
22 |   //   this.btcVal = this.currPriceA * (this.locked + this.avail);
23 |   // }
24 | }
25 | 
26 | 
27 | 


--------------------------------------------------------------------------------
/admin/src/app/trades-routing.module.ts:
--------------------------------------------------------------------------------
 1 | import { NgModule } from '@angular/core';
 2 | import { RouterModule, Routes } from '@angular/router';
 3 | import { AssetTableComponent } from './asset-table/asset-table.component';
 4 | import { BalancesComponent } from './balances/balances.component';
 5 | import { LogsComponent } from './logs/logs.component';
 6 | import {TradeDetailsComponent} from './trade-details/trade-details.component';
 7 | 
 8 | 
 9 | const appRoutes: Routes = [
10 |   { path: '',   redirectTo: 'trades', pathMatch: 'full' },
11 |   {path: 'balances',  component: BalancesComponent},
12 |   {path: 'logs',  component: LogsComponent},
13 |   {path: 'trades',  component: AssetTableComponent, children: [
14 |       { path: ':id', component: TradeDetailsComponent, outlet: 'trade' }
15 |     ] }
16 | 
17 | ];
18 | 
19 | @NgModule({
20 |   imports: [
21 |     RouterModule.forRoot(appRoutes, { relativeLinkResolution: 'legacy' })
22 |   ],
23 |   exports: [
24 |     RouterModule
25 |   ]
26 | })
27 | export class TradesRoutingModule { }
28 | 


--------------------------------------------------------------------------------
/admin/src/app/websocket.service.spec.ts:
--------------------------------------------------------------------------------
 1 | import { TestBed, inject } from '@angular/core/testing';
 2 | 
 3 | import { WebsocketService } from './websocket.service';
 4 | 
 5 | describe('WebsocketService', () => {
 6 |   beforeEach(() => {
 7 |     TestBed.configureTestingModule({
 8 |       providers: [WebsocketService]
 9 |     });
10 |   });
11 | 
12 |   it('should be created', inject([WebsocketService], (service: WebsocketService) => {
13 |     expect(service).toBeTruthy();
14 |   }));
15 | });
16 | 


--------------------------------------------------------------------------------
/admin/src/app/websocket.service.ts:
--------------------------------------------------------------------------------
 1 | import { Injectable } from '@angular/core';
 2 | import {Observable, Observer, Subject} from 'rxjs';
 3 | 
 4 | @Injectable()
 5 | export class WebsocketService {
 6 |   constructor() { }
 7 | 
 8 |   private subject: Subject<MessageEvent>;
 9 | 
10 |   public connect(url): Subject<MessageEvent> {
11 |     if (!this.subject) {
12 |       this.subject = this.create(url);
13 |       console.log('Successfully connected: ' + url);
14 |     }
15 |     return this.subject;
16 |   }
17 | 
18 |   private create(url): Subject<MessageEvent> {
19 |     const ws = new WebSocket(url);
20 | 
21 |     const observable = Observable.create(
22 |       (obs: Observer<MessageEvent>) => {
23 |         ws.onmessage = obs.next.bind(obs);
24 |         ws.onerror = obs.error.bind(obs);
25 |         ws.onclose = ev => { console.log(`ws closed`); obs.complete.bind(obs); };
26 |         return ws.close.bind(ws);
27 |       });
28 | 
29 |     const observer = {
30 |       next: (data: Object) => {
31 |         if (ws.readyState === WebSocket.OPEN) {
32 |           ws.send(JSON.stringify(data));
33 |         }
34 |       }
35 |     };
36 | 
37 |     return Subject.create(observer, observable);
38 |   }
39 | 
40 | }
41 | 


--------------------------------------------------------------------------------
/admin/src/assets/.gitkeep:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/iilunin/crypto-bot/0944641e9b2defb88d80dea03dd47c126f1c0b64/admin/src/assets/.gitkeep


--------------------------------------------------------------------------------
/admin/src/environments/environment.prod.ts:
--------------------------------------------------------------------------------
1 | export const environment = {
2 |   production: true,
3 |   BINANCE_WSS_URL: 'wss://stream.binance.com:9443',
4 |   BINANCE_API_URL: 'https://api.binance.com',
5 |   BOT_API_URL: `${window.location.origin}`
6 | };
7 | 


--------------------------------------------------------------------------------
/admin/src/environments/environment.test.ts:
--------------------------------------------------------------------------------
 1 | // This file can be replaced during build by using the `fileReplacements` array.
 2 | // `ng build ---prod` replaces `environment.ts` with `environment.prod.ts`.
 3 | // The list of file replacements can be found in `angular.json`.
 4 | 
 5 | export const environment = {
 6 |   production: false,
 7 |   BINANCE_WSS_URL: 'wss://testnet.binance.vision',
 8 |   BINANCE_API_URL: 'https://testnet.binance.vision',
 9 |   BOT_API_URL: 'http://127.0.0.1:3000'
10 | };
11 | 
12 | /*
13 |  * In development mode, to ignore zone related error stack frames such as
14 |  * `zone.run`, `zoneDelegate.invokeTask` for easier debugging, you can
15 |  * import the following file, but please comment it out in production mode
16 |  * because it will have performance impact when throw error
17 |  */
18 | // import 'zone.js/dist/zone-error';  // Included with Angular CLI.
19 | 


--------------------------------------------------------------------------------
/admin/src/environments/environment.ts:
--------------------------------------------------------------------------------
 1 | // This file can be replaced during build by using the `fileReplacements` array.
 2 | // `ng build ---prod` replaces `environment.ts` with `environment.prod.ts`.
 3 | // The list of file replacements can be found in `angular.json`.
 4 | 
 5 | export const environment = {
 6 |   production: false,
 7 |   BINANCE_WSS_URL: 'wss://stream.binance.com:9443',
 8 |   BINANCE_API_URL: 'https://api.binance.com',
 9 |   BOT_API_URL: 'http://127.0.0.1:3000'
10 | };
11 | 
12 | /*
13 |  * In development mode, to ignore zone related error stack frames such as
14 |  * `zone.run`, `zoneDelegate.invokeTask` for easier debugging, you can
15 |  * import the following file, but please comment it out in production mode
16 |  * because it will have performance impact when throw error
17 |  */
18 | // import 'zone.js/dist/zone-error';  // Included with Angular CLI.
19 | 


--------------------------------------------------------------------------------
/admin/src/favicon.ico:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/iilunin/crypto-bot/0944641e9b2defb88d80dea03dd47c126f1c0b64/admin/src/favicon.ico


--------------------------------------------------------------------------------
/admin/src/index.html:
--------------------------------------------------------------------------------
 1 | <!doctype html>
 2 | <html lang="en">
 3 | <head>
 4 |   <meta charset="utf-8">
 5 |   <title>Crypto Bot</title>
 6 |   <base href="/">
 7 | 
 8 |   <meta name="viewport" content="width=device-width, initial-scale=1">
 9 |   <link rel="icon" type="image/x-icon" href="favicon.ico">
10 |   <!-- <link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/bootstrap/4.5.2/css/bootstrap.min.css"> -->
11 |   <link rel="preconnect" href="https://fonts.gstatic.com">
12 |   <link href="https://fonts.googleapis.com/css2?family=Roboto:wght@300;400;500&display=swap" rel="stylesheet">
13 |   <link href="https://fonts.googleapis.com/icon?family=Material+Icons" rel="stylesheet">
14 | </head>
15 | <body class="mat-typography">
16 |   <app-root></app-root>
17 | </body>
18 | </html>
19 | 
20 | 


--------------------------------------------------------------------------------
/admin/src/karma.conf.js:
--------------------------------------------------------------------------------
 1 | // Karma configuration file, see link for more information
 2 | // https://karma-runner.github.io/1.0/config/configuration-file.html
 3 | 
 4 | module.exports = function (config) {
 5 |   config.set({
 6 |     basePath: '',
 7 |     frameworks: ['jasmine', '@angular-devkit/build-angular'],
 8 |     plugins: [
 9 |       require('karma-jasmine'),
10 |       require('karma-chrome-launcher'),
11 |       require('karma-jasmine-html-reporter'),
12 |       require('karma-coverage-istanbul-reporter'),
13 |       require('@angular-devkit/build-angular/plugins/karma')
14 |     ],
15 |     client: {
16 |       clearContext: false // leave Jasmine Spec Runner output visible in browser
17 |     },
18 |     coverageIstanbulReporter: {
19 |       dir: require('path').join(__dirname, '../coverage'),
20 |       reports: ['html', 'lcovonly'],
21 |       fixWebpackSourcePaths: true
22 |     },
23 |     reporters: ['progress', 'kjhtml'],
24 |     port: 9876,
25 |     colors: true,
26 |     logLevel: config.LOG_INFO,
27 |     autoWatch: true,
28 |     browsers: ['Chrome'],
29 |     singleRun: false
30 |   });
31 | };


--------------------------------------------------------------------------------
/admin/src/main.ts:
--------------------------------------------------------------------------------
 1 | import { enableProdMode } from '@angular/core';
 2 | import { platformBrowserDynamic } from '@angular/platform-browser-dynamic';
 3 | 
 4 | import { AppModule } from './app/app.module';
 5 | import { environment } from './environments/environment';
 6 | 
 7 | if (environment.production) {
 8 |   enableProdMode();
 9 | }
10 | 
11 | platformBrowserDynamic().bootstrapModule(AppModule)
12 |   .catch(err => console.log(err));
13 | 


--------------------------------------------------------------------------------
/admin/src/polyfills.ts:
--------------------------------------------------------------------------------
 1 | /***************************************************************************************************
 2 |  * Load `$localize` onto the global scope - used if i18n tags appear in Angular templates.
 3 |  */
 4 | import '@angular/localize/init';
 5 | 
 6 | 
 7 | 
 8 | /**
 9 |  * Web Animations `@angular/platform-browser/animations`
10 |  * Only required if AnimationBuilder is used within the application and using IE/Edge or Safari.
11 |  * Standard animation support in Angular DOES NOT require any polyfills (as of Angular 6.0).
12 |  **/
13 | // import 'web-animations-js';  // Run `npm install --save web-animations-js`.
14 | 
15 | /**
16 |  * By default, zone.js will patch all possible macroTask and DomEvents
17 |  * user can disable parts of macroTask/DomEvents patch by setting following flags
18 |  */
19 | 
20 |  // (window as any).__Zone_disable_requestAnimationFrame = true; // disable patch requestAnimationFrame
21 |  // (window as any).__Zone_disable_on_property = true; // disable patch onProperty such as onclick
22 |  // (window as any).__zone_symbol__BLACK_LISTED_EVENTS = ['scroll', 'mousemove']; // disable patch specified eventNames
23 | 
24 |  /*
25 |  * in IE/Edge developer tools, the addEventListener will also be wrapped by zone.js
26 |  * with the following flag, it will bypass `zone.js` patch for IE/Edge
27 |  */
28 | // (window as any).__Zone_enable_cross_context_check = true;
29 | 
30 | /***************************************************************************************************
31 |  * Zone JS is required by default for Angular itself.
32 |  */
33 | import 'zone.js/dist/zone';  // Included with Angular CLI.
34 | 
35 | 
36 | 
37 | /***************************************************************************************************
38 |  * APPLICATION IMPORTS
39 |  */
40 | 


--------------------------------------------------------------------------------
/admin/src/styles.css:
--------------------------------------------------------------------------------
 1 | /* You can add global styles to this file, and also import other style files */
 2 | html, body { height: 100%; }
 3 | body { margin: 0; font-family: Roboto, "Helvetica Neue", sans-serif; }
 4 | 
 5 | .snackbar-primary {
 6 |     background: #673ab7;
 7 |     color: #fff;
 8 | }
 9 | 
10 | .snackbar-warning {
11 |     background: #ffd740;
12 |     color: rgba(0,0,0,.87);
13 | }
14 | 
15 | .snackbar-alarm {
16 |     background: #f44336;
17 |     color: #fff;
18 | }
19 | 
20 | .buy-button-on {
21 |     color: #fff;
22 |     background-color: #28a745;
23 |     border-color: #28a745;
24 | }
25 | 
26 | .buy-button-off {
27 |     color: #28a745;
28 |     background-color: #fff;
29 |     border-color: #28a745;
30 | }
31 | 
32 | .sell-button-on {
33 |     color: #fff;
34 |     background-color: #dc3545;
35 |     border-color: #dc3545;
36 | }
37 | 
38 | .sell-button-off {
39 |     color: #dc3545;
40 |     background-color: #fff;
41 |     border-color: #dc3545;
42 | }
43 | 
44 | .resume-btn {
45 |     color: rgb(46, 95, 41)
46 | }
47 | 
48 | .delete-btn {
49 |     color: #b41e2dcc;
50 | }
51 | 
52 | .icon-display-sm {
53 |     transform: scale(0.8);
54 | }
55 | 
56 | .full-width {
57 |     width: 100%
58 | }
59 | 
60 | .trade-section {
61 |     margin: 6px 0 12px;
62 | }
63 | 
64 | .mat-accordion .mat-expansion-panel:not(.mat-expanded),
65 | .mat-accordion .mat-expansion-panel:not(.mat-expansion-panel-spacing) {
66 |    margin-bottom: 4px;
67 | }
68 | 
69 | .mat-accordion .mat-expansion-panel:is(.mat-expanded) {
70 |     margin: 6px 0;
71 | }
72 | 
73 | mat-expansion-panel-header > .mat-content, .right-aligned-header > .mat-content {
74 |     justify-content: space-between;
75 | }
76 | 
77 | .mat-content > mat-panel-title, .mat-content > mat-panel-description {
78 |   flex: 0 0 auto;
79 | }
80 | 
81 | mat-panel-description {
82 |     text-align: right;
83 | }
84 | 
85 | .accordeon {
86 |     margin: 1;
87 | }


--------------------------------------------------------------------------------
/admin/src/test.ts:
--------------------------------------------------------------------------------
 1 | // This file is required by karma.conf.js and loads recursively all the .spec and framework files
 2 | 
 3 | import 'zone.js/dist/zone-testing';
 4 | import { getTestBed } from '@angular/core/testing';
 5 | import {
 6 |   BrowserDynamicTestingModule,
 7 |   platformBrowserDynamicTesting
 8 | } from '@angular/platform-browser-dynamic/testing';
 9 | 
10 | declare const require: any;
11 | 
12 | // First, initialize the Angular testing environment.
13 | getTestBed().initTestEnvironment(
14 |   BrowserDynamicTestingModule,
15 |   platformBrowserDynamicTesting()
16 | );
17 | // Then we find all the tests.
18 | const context = require.context('./', true, /\.spec\.ts$/);
19 | // And load the modules.
20 | context.keys().map(context);
21 | 


--------------------------------------------------------------------------------
/admin/src/tsconfig.app.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "extends": "../tsconfig.json",
 3 |   "compilerOptions": {
 4 |     "outDir": "../out-tsc/app",
 5 |     "types": []
 6 |   },
 7 |   "files": [
 8 |     "main.ts",
 9 |     "polyfills.ts"
10 |   ],
11 |   "include": [
12 |     "src/**/*.d.ts"
13 |   ]
14 | }
15 | 


--------------------------------------------------------------------------------
/admin/src/tsconfig.spec.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "extends": "../tsconfig.json",
 3 |   "compilerOptions": {
 4 |     "outDir": "../out-tsc/spec",
 5 |     "types": [
 6 |       "jasmine",
 7 |       "node"
 8 |     ]
 9 |   },
10 |   "files": [
11 |     "test.ts",
12 |     "polyfills.ts"
13 |   ],
14 |   "include": [
15 |     "**/*.spec.ts",
16 |     "**/*.d.ts"
17 |   ]
18 | }
19 | 


--------------------------------------------------------------------------------
/admin/src/tslint.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "extends": "../tslint.json",
 3 |     "rules": {
 4 |         "directive-selector": [
 5 |             true,
 6 |             "attribute",
 7 |             "app",
 8 |             "camelCase"
 9 |         ],
10 |         "component-selector": [
11 |             true,
12 |             "element",
13 |             "app",
14 |             "kebab-case"
15 |         ]
16 |     }
17 | }
18 | 


--------------------------------------------------------------------------------
/admin/tsconfig.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "compileOnSave": false,
 3 |   "compilerOptions": {
 4 |     "baseUrl": "./",
 5 |     "outDir": "./dist/out-tsc",
 6 |     "downlevelIteration": true,
 7 |     "sourceMap": true,
 8 |     "declaration": false,
 9 |     "importHelpers": true,
10 |     "moduleResolution": "node",
11 |     "module": "es2020",
12 |     "emitDecoratorMetadata": true,
13 |     "experimentalDecorators": true,
14 |     "target": "es2015",
15 |     "typeRoots": [
16 |       "node_modules/@types"
17 |     ],
18 |     "lib": [
19 |       "es2017",
20 |       "dom"
21 |     ]
22 |   }
23 | }
24 | 


--------------------------------------------------------------------------------
/admin/tslint.json:
--------------------------------------------------------------------------------
  1 | {
  2 |   "rulesDirectory": [
  3 |     "node_modules/codelyzer"
  4 |   ],
  5 |   "rules": {
  6 |     "arrow-return-shorthand": true,
  7 |     "callable-types": true,
  8 |     "class-name": true,
  9 |     "comment-format": [
 10 |       true,
 11 |       "check-space"
 12 |     ],
 13 |     "curly": true,
 14 |     "deprecation": {
 15 |       "severity": "warn"
 16 |     },
 17 |     "eofline": true,
 18 |     "forin": true,
 19 |     "import-blacklist": [
 20 |       true,
 21 |       "rxjs/Rx"
 22 |     ],
 23 |     "import-spacing": true,
 24 |     "indent": [
 25 |       true,
 26 |       "spaces"
 27 |     ],
 28 |     "interface-over-type-literal": true,
 29 |     "label-position": true,
 30 |     "max-line-length": [
 31 |       true,
 32 |       140
 33 |     ],
 34 |     "member-access": false,
 35 |     "member-ordering": [
 36 |       true,
 37 |       {
 38 |         "order": [
 39 |           "static-field",
 40 |           "instance-field",
 41 |           "static-method",
 42 |           "instance-method"
 43 |         ]
 44 |       }
 45 |     ],
 46 |     "no-arg": true,
 47 |     "no-bitwise": true,
 48 |     "no-console": [
 49 |       true,
 50 |       "debug",
 51 |       "info",
 52 |       "time",
 53 |       "timeEnd",
 54 |       "trace"
 55 |     ],
 56 |     "no-construct": true,
 57 |     "no-debugger": true,
 58 |     "no-duplicate-super": true,
 59 |     "no-empty": false,
 60 |     "no-empty-interface": true,
 61 |     "no-eval": true,
 62 |     "no-inferrable-types": [
 63 |       true,
 64 |       "ignore-params"
 65 |     ],
 66 |     "no-misused-new": true,
 67 |     "no-host-metadata-property": true,
 68 |     "no-non-null-assertion": true,
 69 |     "no-shadowed-variable": true,
 70 |     "no-inputs-metadata-property": true,
 71 |     "no-string-literal": false,
 72 |     "no-string-throw": true,
 73 |     "no-switch-case-fall-through": true,
 74 |     "no-trailing-whitespace": true,
 75 |     "no-outputs-metadata-property": true,
 76 |     "no-unnecessary-initializer": true,
 77 |     "no-unused-expression": true,
 78 |     "no-var-keyword": true,
 79 |     "object-literal-sort-keys": false,
 80 |     "one-line": [
 81 |       true,
 82 |       "check-open-brace",
 83 |       "check-catch",
 84 |       "check-else",
 85 |       "check-whitespace"
 86 |     ],
 87 |     "prefer-const": true,
 88 |     "quotemark": [
 89 |       true,
 90 |       "single"
 91 |     ],
 92 |     "radix": true,
 93 |     "semicolon": [
 94 |       true,
 95 |       "always"
 96 |     ],
 97 |     "triple-equals": [
 98 |       true,
 99 |       "allow-null-check"
100 |     ],
101 |     "typedef-whitespace": [
102 |       true,
103 |       {
104 |         "call-signature": "nospace",
105 |         "index-signature": "nospace",
106 |         "parameter": "nospace",
107 |         "property-declaration": "nospace",
108 |         "variable-declaration": "nospace"
109 |       }
110 |     ],
111 |     "unified-signatures": true,
112 |     "variable-name": false,
113 |     "whitespace": [
114 |       true,
115 |       "check-branch",
116 |       "check-decl",
117 |       "check-operator",
118 |       "check-separator",
119 |       "check-type"
120 |     ],
121 |     "no-output-on-prefix": true,
122 |     "no-input-rename": true,
123 |     "use-lifecycle-interface": true,
124 |     "no-output-rename": true,
125 |     "use-pipe-transform-interface": true,
126 |     "component-class-suffix": true,
127 |     "directive-class-suffix": true
128 |   }
129 | }
130 | 


--------------------------------------------------------------------------------
/binance_ws_recoonect_test.py:
--------------------------------------------------------------------------------
 1 | from time import sleep
 2 | 
 3 | from binance.client import Client
 4 | 
 5 | import os
 6 | import os.path
 7 | 
 8 | from Bot.Exchange.Binance.BinanceWebsocket import BinanceWebsocket
 9 | 
10 | 
11 | def main():
12 | 
13 |     client = Client(os.environ.get('KEY'), os.environ.get('SECRET'))
14 | 
15 |     for _ in range(1, 10):
16 |         print('Creating BinanceWebsocketThread instance')
17 |         bwst = BinanceWebsocket(client)
18 | 
19 |         # signal.signal(signal.SIGINT, lambda sig, frame: bwst.stop_ws())
20 |         # signal.signal(signal.SIGTERM, lambda sig, frame: bwst.stop_ws())
21 |         bwst.start_ticker(['ontbtc'], callback=lambda msg: print(msg))
22 |         bwst.start_user_info(callback=lambda msg: print(msg))
23 |         bwst.start()
24 | 
25 |         print('sleep')
26 |         sleep(10)
27 |         bwst.stop_ticker_future()
28 |         bwst.start_ticker(['ETHBTC'], callback=lambda msg: print(msg))
29 |         sleep(10)
30 |         bwst.stop_sockets()
31 |         # sleep(1)
32 | 
33 |     # bwst.user_webscoket.close()
34 | 
35 | 
36 | 
37 | 
38 | def socket_handler(msg):
39 |     print(msg)
40 | 
41 | def user_data_handler(msg):
42 |     print(msg)
43 | 
44 | 
45 | if __name__ == '__main__':
46 |     main()
47 | 


--------------------------------------------------------------------------------
/docker-compose-nginx.yml:
--------------------------------------------------------------------------------
 1 | version: '3'
 2 | services:
 3 |   bot:
 4 |     image: iilunin/crypto-bot:api-latest
 5 |     ports:
 6 |       - "3000"
 7 |     environment:
 8 |       - TZ=Canada/Vancouver
 9 |     env_file: .env
10 |     volumes:
11 |       - ./Trades/Portfolio:/usr/src/trades
12 |       - ./Trades/Completed:/usr/src/complete_trades
13 |       - ./Conf:/usr/src/configs:ro
14 |     restart: always
15 | 
16 | #  web-nossl:
17 | #    image: iilunin/crypto-bot:fe-nosll-latest
18 | #    ports:
19 | #      - 8080:80
20 | #    depends_on:
21 | #      - bot
22 | #    restart: always
23 | 
24 |   web-ssl:
25 |     image: iilunin/crypto-bot:fe-sll-latest
26 |     ports:
27 |       - 3000:443
28 |     volumes:
29 |       - ./Nginx:/etc/nginx/certs
30 |     depends_on:
31 |       - bot
32 |     restart: always


--------------------------------------------------------------------------------
/docker-compose.yml:
--------------------------------------------------------------------------------
 1 | version: '3'
 2 | services:
 3 |   bot:
 4 |     image: iilunin/crypto-bot:stable
 5 |     ports:
 6 |       - '127.0.0.1:3000:3000'
 7 |     environment:
 8 |       - TZ=Canada/Vancouver
 9 |     env_file: .env
10 |     volumes:
11 |       - ./Trades/Portfolio:/usr/src/trades
12 |       - ./Trades/Completed:/usr/src/complete_trades
13 |       - ./Conf:/usr/src/configs:ro
14 |     restart: always
15 | 


--------------------------------------------------------------------------------
/main.py:
--------------------------------------------------------------------------------
  1 | # import atexit
  2 | import signal
  3 | 
  4 | from os.path import isfile, join
  5 | from os import listdir, environ
  6 | 
  7 | import sys
  8 | 
  9 | from API.APIServer import APIServer
 10 | from Bot.Target import Target
 11 | from ConsoleLauncher import ConsoleLauncher
 12 | from Bot.ConfigLoader import ConfigLoader
 13 | 
 14 | from Bot.Strategy.SmartOrder import SmartOrder
 15 | 
 16 | TRADE_FILE_PATH_PATTERN = '{}{}.json'
 17 | 
 18 | TEST_PORTFOLIO_PATH = environ.get('TRADE_DIR', 'Trades/Test/')
 19 | 
 20 | 
 21 | TRADE_PORTFOLIO_PATH = environ.get('TRADE_DIR', 'Trades/Portfolio/')
 22 | COMPLETED_ORDER_PATH_PORTFOLIO = environ.get('TRADE_COMPLETED_DIR', 'Trades/Completed/')
 23 | CONF_DIR = environ.get('CONF_DIR', 'Conf/')
 24 | 
 25 | ENABLE_CLOUD = True
 26 | 
 27 | def main():
 28 | 
 29 |     launcher = ConsoleLauncher(
 30 |         TRADE_PORTFOLIO_PATH,
 31 |         COMPLETED_ORDER_PATH_PORTFOLIO,
 32 |         CONF_DIR,
 33 |         environ.get('TRADE_BUCKET') is not None and ENABLE_CLOUD)
 34 | 
 35 |     api_mode = False
 36 |     if len(sys.argv) > 1:
 37 |         if sys.argv[1] == 'api':
 38 |             api_mode = True
 39 | 
 40 |         elif sys.argv[1] == 'sync':
 41 |             launcher.sync_down()
 42 |             return
 43 | 
 44 |         elif sys.argv[1] == 'gen':
 45 |             get_input_for_targets()
 46 |             return
 47 | 
 48 |     launcher.start_bot()
 49 | 
 50 |     if api_mode:
 51 |         api = APIServer(launcher.trade_handler)
 52 |         api.run(3000)
 53 | 
 54 | # def signal_handler(signal=None, frame=None):
 55 | #     launcher.stop_bot()
 56 | 
 57 | def get_input_for_targets():
 58 |     smart = 'y'
 59 |     if len(sys.argv) > 2:
 60 |         single_arg = sys.argv[2]
 61 |         args = single_arg.split('/', 4)
 62 |         price = args[0]
 63 |         iter = args[1]
 64 |         increment = args[2]
 65 |         if len(args) == 4:
 66 |             smart = args[3]
 67 |     else:
 68 |         price = get_input("Start price: ")
 69 |         iter = get_input("Iterations (5): ", 5)
 70 |         increment = get_input("Price increase in percent (2): ", 2)
 71 |         sl = get_input("Sl interval (3):", 3)
 72 |         smart = get_input("Smart (Y/n):", 'y')
 73 | 
 74 | 
 75 |     smart = True if not smart or smart.lower() == 'y' else False
 76 | 
 77 |     generate_targets(float(price), int(iter), float(increment), smart, int(sl))
 78 | 
 79 | def get_input(text, default=None):
 80 |     inp = input(text)
 81 |     if not inp:
 82 |         return default
 83 |     if not inp.strip():
 84 |         return default
 85 |     return inp.strip()
 86 | 
 87 | def generate_targets(start_price, iter=4, increment=4, smart=True, sl_interval=3):
 88 |     targets = []
 89 |     prices = []
 90 |     for i in range(0, iter):
 91 |         prices.append(start_price)
 92 |         vol = round(100/(iter - i), 2)
 93 | 
 94 |         target = Target(price=start_price, vol='{}%'.format(vol), smart=smart)
 95 |         if sl_interval != 0 and len(prices) >= sl_interval:
 96 |             target.sl = prices[-sl_interval]
 97 | 
 98 |         targets.append(target)
 99 |         start_price = round(start_price * (1+increment/100), 8)
100 | 
101 |     print(ConfigLoader.get_json_str(targets))
102 | 
103 | 
104 | def test_change_order():
105 |     cl = ConfigLoader()
106 |     orders = cl.load_trade_list(cl.json_loader('trades.json'))
107 | 
108 | 
109 |     # orders[0].get_available_targets()[0].set_completed()
110 |     # orders[0].status = OrderStatus.COMPLETED
111 |     cl.save_trades(cl.json_saver('trades2.json'), orders)
112 | 
113 |     orders = cl.load_trade_list(cl.json_loader('trades2.json'))
114 | 
115 | def test_smart_order():
116 |     price_change = []
117 |     price_change.extend(range(490, 465, -1))
118 |     price_change.extend(range(471, 479, 1))
119 |     price_change.extend(range(478, 463, -1))
120 |     price_change.extend(range(463, 473, 1))
121 |     so = SmartOrder(True, 467)
122 | 
123 |     print('BUY Order')
124 |     for p in price_change:
125 |         print('Price: {}, SL {}'.format(p, so.price_update(p)))
126 | 
127 |     print('SELL Order')
128 |     so = SmartOrder(False, 475)
129 |     for p in price_change:
130 |         print('Price: {}, SL {}'.format(p, so.price_update(p)))
131 | 
132 |     print('-' * 20)
133 |     print('-' * 20)
134 | 
135 |     price_change = []
136 |     price_change.extend(range(480, 474, -1))
137 |     price_change.extend(range(476, 480, 1))
138 |     so = SmartOrder(True, 475)
139 |     for p in price_change:
140 |         print('Price: {}, SL {}'.format(p, so.price_update(p)))
141 | 
142 | def save_new_order_file_structure(path, new_path):
143 | 
144 |     target_path_list = [f for f in listdir(path) if isfile(join(path, f)) and f.lower().endswith('json')]
145 |     for t_path in target_path_list:
146 |         cl = ConfigLoader()
147 |         o_loader = cl.json_loader(join(path, t_path))
148 |         trades = cl.load_trade_list(o_loader)
149 | 
150 |         for t in trades:
151 |             if t.is_completed():
152 |                 continue
153 | 
154 |             new_trade_path = new_path + t.symbol + '.json'
155 |             cl.save_trades(cl.json_saver(new_trade_path), [t])
156 | 
157 | if __name__ == '__main__':
158 |     main()
159 | 


--------------------------------------------------------------------------------
/requirements.txt:
--------------------------------------------------------------------------------
 1 | numpy
 2 | python-binance==1.0.10
 3 | retrying==1.3.3
 4 | boto3==1.17.62
 5 | websockets==9.0.1
 6 | 
 7 | Flask==1.1.2
 8 | Jinja2==3.0.3
 9 | itsdangerous==2.0.1
10 | werkzeug==2.0.2
11 | Flask-Cors==3.0.10
12 | Flask-JWT-Extended==4.2.0
13 | Flask-RESTful==0.3.9
14 | arrow==1.1.0


--------------------------------------------------------------------------------