719 lines
19 KiB
Markdown
719 lines
19 KiB
Markdown
```plantuml
|
|
@startuml
|
|
|
|
participant BrighterTrades
|
|
participant ExchangeInterface
|
|
participant DataCache
|
|
participant Configuration
|
|
participant Signals
|
|
participant Candles
|
|
participant Indicators
|
|
participant Trades
|
|
participant Strategies
|
|
participant Backtester
|
|
|
|
BrighterTrades -> ExchangeInterface: create instance
|
|
BrighterTrades -> DataCache: create instance
|
|
BrighterTrades -> Configuration: create instance
|
|
BrighterTrades -> Signals: create instance
|
|
BrighterTrades -> Candles: create instance
|
|
BrighterTrades -> Indicators: create instance
|
|
BrighterTrades -> Trades: create instance
|
|
BrighterTrades -> Strategies: create instance
|
|
BrighterTrades -> Backtester: create instance
|
|
|
|
BrighterTrades -> ExchangeInterface: connect_user_to_exchange(user_name, exchange_name, keys)
|
|
ExchangeInterface -> ExchangeInterface: query exchange_data
|
|
alt exc_data.empty is False
|
|
ExchangeInterface -> BrighterTrades: True
|
|
else exc_data.empty is True
|
|
ExchangeInterface -> ExchangeInterface: connect_exchange(exchange_name, user_name, api_keys)
|
|
alt result is True
|
|
ExchangeInterface -> Configuration: users.active_exchange(exchange, user_name, cmd)
|
|
Configuration -> BrighterTrades: True
|
|
else result is False
|
|
ExchangeInterface -> BrighterTrades: False
|
|
end
|
|
end
|
|
|
|
BrighterTrades -> Configuration: update_data('signals', signals.get_signals('dict'))
|
|
BrighterTrades -> Configuration: update_data('strategies', strategies.get_strategies('dict'))
|
|
|
|
BrighterTrades -> Candles: set_cache(user_name)
|
|
BrighterTrades -> BrighterTrades: received_cdata(cdata)
|
|
Candles -> BrighterTrades: set_new_candle(cdata)
|
|
Signals -> BrighterTrades: process_all_signals(indicators)
|
|
Trades -> BrighterTrades: update(float(cdata['close']))
|
|
Strategies -> BrighterTrades: update(signals)
|
|
|
|
BrighterTrades -> BrighterTrades: get_js_init_data(user_name)
|
|
BrighterTrades -> BrighterTrades: get_rendered_data(user_name)
|
|
|
|
BrighterTrades -> Signals: new_signal(data)
|
|
BrighterTrades -> Configuration: update_data('signals', signals.get_signals('dict'))
|
|
|
|
BrighterTrades -> Strategies: new_strategy(data)
|
|
BrighterTrades -> Configuration: update_data('strategies', strategies.get_strategies('dict'))
|
|
|
|
BrighterTrades -> Strategies: delete_strategy(strategy_name)
|
|
BrighterTrades -> Configuration: remove('strategies', strategy_name)
|
|
|
|
BrighterTrades -> Signals: delete_signal(signal_name)
|
|
BrighterTrades -> Configuration: remove('signals', signal_name)
|
|
|
|
BrighterTrades -> Signals: get_signals()
|
|
BrighterTrades -> Strategies: get_strategies()
|
|
|
|
BrighterTrades -> ExchangeInterface: connect_exchange(api_keys, exchange, user_name)
|
|
ExchangeInterface -> Configuration: users.update_api_keys(api_keys, exchange, user_name)
|
|
|
|
BrighterTrades -> Trades: close_trade(trade_id)
|
|
BrighterTrades -> Configuration: remove('trades', trade_id)
|
|
|
|
BrighterTrades -> Trades: new_trade(target, symbol, price, side, order_type, qty)
|
|
Trades -> BrighterTrades: new_trade(target, symbol, price, side, order_type, qty)
|
|
BrighterTrades -> Configuration: update_data('trades', trades.get_trades('dict'))
|
|
|
|
BrighterTrades -> Trades: get_trade_by_id(trade_id)
|
|
Trades -> BrighterTrades: get_trade_by_id(result)
|
|
|
|
BrighterTrades -> Trades: get_trades()
|
|
|
|
BrighterTrades -> Configuration: users.set_chart_view(values, specific_property, user_name, default_market)
|
|
@enduml
|
|
```
|
|
```plantuml
|
|
@startuml
|
|
|
|
actor User
|
|
participant "BrighterTrades" as BT
|
|
participant "ExchangeInterface" as EI
|
|
participant "DataCache" as DC
|
|
participant "Configuration" as Conf
|
|
participant "Signals" as Sig
|
|
participant "Candles" as Can
|
|
participant "Indicators" as Ind
|
|
participant "Trades" as T
|
|
participant "Strategies" as St
|
|
participant "Backtester" as Btst
|
|
|
|
User -> BT: connect_user_to_exchange(user_name, exchange_name, keys)
|
|
BT -> EI: connect_exchange(exchange_name, user_name, api_keys)
|
|
EI -> DC: query(exchange_data)
|
|
DC --> BT: exc_data
|
|
BT -> BT: Return if exc_data is not empty
|
|
BT -> EI: connect_exchange(exchange_name, user_name, api_keys)
|
|
BT -> Conf: active_exchange(exchange, user_name, cmd='set')
|
|
BT --> User: True / False
|
|
|
|
User -> BT: get_js_init_data(user_name)
|
|
BT -> Conf: get_chart_view(user_name)
|
|
BT -> Ind: get_indicator_list(user_name)
|
|
BT --> User: js_data
|
|
|
|
User -> BT: get_rendered_data(user_name)
|
|
BT -> Conf: get_chart_view(user_name)
|
|
BT --> User: rendered_data
|
|
|
|
@enduml
|
|
```
|
|
```plantuml
|
|
@startuml
|
|
class User {
|
|
- name: string
|
|
- api_keys: string[]
|
|
+ connect_user_to_exchange(user_name: string, exchange_name: string, keys: string[]): bool
|
|
+ get_js_init_data(user_name: string): string
|
|
+ get_rendered_data(user_name: string): string
|
|
}
|
|
|
|
class BrighterTrades {
|
|
- exchanges: ExchangeInterface[]
|
|
- user_map: Map<string, User>
|
|
+ connect_user_to_exchange(user_name: string, exchange_name: string, keys: string[]): bool
|
|
+ get_js_init_data(user_name: string): string
|
|
+ get_rendered_data(user_name: string): string
|
|
}
|
|
|
|
class ExchangeInterface {
|
|
- exchange_name: string
|
|
- user_name: string
|
|
- api_keys: string[]
|
|
+ connect_exchange(exchange_name: string, user_name: string, api_keys: string[]): void
|
|
+ query(data: string): string
|
|
}
|
|
|
|
class DataCache {
|
|
- cache: Map<string, string>
|
|
+ query(data: string): string
|
|
}
|
|
|
|
class Configuration {
|
|
- active_exchange: string
|
|
- user_name: string
|
|
+ active_exchange(exchange: string, user_name: string, cmd: string): bool
|
|
+ get_chart_view(user_name: string): string
|
|
}
|
|
|
|
class Signals {
|
|
+ get_signal_list(user_name: string): string[]
|
|
}
|
|
|
|
class Candles {
|
|
+ get_candle_list(user_name: string): string[]
|
|
}
|
|
|
|
class Indicators {
|
|
+ get_indicator_list(user_name: string): string[]
|
|
}
|
|
|
|
class Trades {
|
|
+ get_trade_list(user_name: string): string[]
|
|
}
|
|
|
|
class Strategies {
|
|
+ get_strategy_list(user_name: string): string[]
|
|
}
|
|
|
|
class Backtester {
|
|
+ get_backtest_result(user_name: string): string[]
|
|
}
|
|
|
|
User -- BrighterTrades
|
|
BrighterTrades "1" *-- "1..*" ExchangeInterface
|
|
BrighterTrades -- DataCache
|
|
BrighterTrades -- Configuration
|
|
BrighterTrades -- Signals
|
|
BrighterTrades -- Candles
|
|
BrighterTrades -- Indicators
|
|
BrighterTrades -- Trades
|
|
BrighterTrades -- Strategies
|
|
BrighterTrades -- Backtester
|
|
|
|
@enduml
|
|
|
|
```
|
|
```plantuml
|
|
@startuml
|
|
|
|
class BrighterTrades {
|
|
- exchanges: ExchangeInterface
|
|
- data: DataCache
|
|
- config: Configuration
|
|
- signals: Signals
|
|
- candles: Candles
|
|
- indicators: Indicators
|
|
- trades: Trades
|
|
- strategies: Strategies
|
|
- backtester: Backtester
|
|
+ __init__()
|
|
+ connect_user_to_exchange(user_name: str, exchange_name: str, keys: dict) -> bool
|
|
+ get_js_init_data(user_name: str) -> dict
|
|
+ get_rendered_data(user_name: str) -> dict
|
|
+ received_cdata(cdata: dict) -> dict | None
|
|
+ received_new_signal(data) -> dict | None
|
|
+ received_new_strategy(data) -> dict | None
|
|
+ delete_strategy(strategy_name)
|
|
+ delete_signal(signal_name)
|
|
+ get_signals() -> dict
|
|
+ get_strategies() -> dict
|
|
+ config_exchange(user_name: str, exchange: str, api_keys: dict) -> bool
|
|
+ close_trade(trade_id)
|
|
+ received_new_trade(data)
|
|
+ get_trades() -> dict
|
|
+ adjust_setting(user_name: str, setting: str, params: Any)
|
|
}
|
|
|
|
class DataCache {
|
|
+ __init__(exchanges)
|
|
}
|
|
|
|
class Strategies {
|
|
+ __init__(strategies_list, trades)
|
|
+ new_strategy(data)
|
|
+ delete_strategy(strategy_name)
|
|
+ update(signals)
|
|
+ get_strategies(format) -> dict
|
|
}
|
|
|
|
class Backtester {
|
|
+ __init__()
|
|
}
|
|
|
|
class Candles {
|
|
+ __init__(config_obj, exchanges, database)
|
|
+ set_new_candle(cdata)
|
|
+ set_cache(user_name)
|
|
}
|
|
|
|
class Configuration {
|
|
+ __init__(cache)
|
|
+ users
|
|
+ app_data
|
|
+ signals_list
|
|
+ strategies_list
|
|
+ trades
|
|
+ update_data(key, value)
|
|
+ remove(key, item)
|
|
+ config_and_states(action)
|
|
}
|
|
|
|
class ExchangeInterface {
|
|
+ __init__()
|
|
+ exchange_data
|
|
+ connect_exchange(exchange_name, user_name, api_keys) -> bool
|
|
+ get_exchange(ename, uname)
|
|
+ get_available_exchanges() -> list
|
|
+ get_connected_exchanges(user_name) -> list
|
|
}
|
|
|
|
class Indicators {
|
|
+ __init__(candles, config)
|
|
+ toggle_indicator(user_name, params)
|
|
+ edit_indicator(user_name, params)
|
|
+ new_indicator(user_name, params)
|
|
+ update_indicators() -> dict
|
|
+ get_indicator_list(user_name)
|
|
+ get_enabled_indicators(user_name)
|
|
+ indicator_types
|
|
+ MV_AVERAGE_ENUM
|
|
}
|
|
|
|
class Signals {
|
|
+ __init__(signals_list)
|
|
+ new_signal(data)
|
|
+ delete_signal(signal_name)
|
|
+ process_all_signals(indicators) -> dict
|
|
+ get_signals(format) -> dict
|
|
}
|
|
|
|
class Trades {
|
|
+ __init__(config_trades)
|
|
+ connect_exchanges(exchanges)
|
|
+ new_trade(target, symbol, price, side, order_type, qty)
|
|
+ close_trade(trade_id)
|
|
+ update(price) -> dict
|
|
+ get_trade_by_id(trade_id)
|
|
+ get_trades(format) -> dict
|
|
}
|
|
|
|
class Backtester {
|
|
+ __init__()
|
|
}
|
|
|
|
BrighterTrades --> DataCache
|
|
BrighterTrades --> Strategies
|
|
BrighterTrades --> Backtester
|
|
BrighterTrades --> Candles
|
|
BrighterTrades --> Configuration
|
|
BrighterTrades --> ExchangeInterface
|
|
BrighterTrades --> Indicators
|
|
BrighterTrades --> Signals
|
|
|
|
```
|
|
```plantuml
|
|
@startuml
|
|
|
|
actor User
|
|
|
|
User -> BrighterTrades: login(username, password)
|
|
BrighterTrades -> Users: authenticate(username, password)
|
|
Users -> Database: get_user_data(username)
|
|
Database --> Database: _execute_query(query)
|
|
Database --> Users: Return user data
|
|
Users --> BrighterTrades: Return user data
|
|
BrighterTrades --> User: Return user data
|
|
User -> DataCache: get_data(symbol)
|
|
DataCache --> DataCache: check_cache(symbol)
|
|
alt Symbol data in cache
|
|
DataCache --> User: Return cached data
|
|
else Symbol data not in cache
|
|
User -> Database: get_data(symbol)
|
|
Database --> Database: _execute_query(query)
|
|
Database --> User: Return data from database
|
|
User -> DataCache: cache_data(symbol, data)
|
|
DataCache --> DataCache: Store data in cache
|
|
DataCache --> User: Return data from cache
|
|
end
|
|
|
|
@enduml
|
|
|
|
```
|
|
```plantuml
|
|
@startuml
|
|
|
|
left to right direction
|
|
|
|
actor Users
|
|
rectangle BrighterTrades {
|
|
usecase "Access DataCache" as AccessDataCache
|
|
usecase "Access Database" as AccessDatabase
|
|
}
|
|
|
|
Users --> AccessDataCache
|
|
Users --> AccessDatabase
|
|
AccessDataCache --> DataCache
|
|
AccessDatabase --> Database
|
|
|
|
@enduml
|
|
```
|
|
```plantuml
|
|
@startuml
|
|
|
|
!define ICONURL https://raw.githubusercontent.com/jaime-olivares/yuml-diagram/master/images
|
|
|
|
!define DarkYellow #ffd666
|
|
!define DarkGreen #75d68c
|
|
!define DarkBlue #6cb2ed
|
|
|
|
skinparam participant {
|
|
BackgroundColor DarkYellow
|
|
BorderColor DarkGreen
|
|
FontColor Black
|
|
}
|
|
|
|
!define CLASSURL [BrighterTrades](https://www.example.com)
|
|
!define USERSURL [Users](https://www.example.com)
|
|
!define DATACACHEURL [DataCache](https://www.example.com)
|
|
!define DATABASEURL [Database](https://www.example.com)
|
|
|
|
actor Users as "Users" <<(U,#FF7700)>>
|
|
boundary "BrighterTrades" as BrighterTrades <<(B,#FF7700)>>
|
|
control DataCache as "DataCache" <<(C,#FF7700)>>
|
|
database Database as "Database" <<(D,#FF7700)>>
|
|
|
|
Users --> BrighterTrades : "Access DataCache"
|
|
Users --> BrighterTrades : "Access Database"
|
|
BrighterTrades --> DataCache : "Access DataCache"
|
|
BrighterTrades --> Database : "Access Database"
|
|
|
|
note right of BrighterTrades : Application Layer
|
|
note right of DataCache : Cache Layer
|
|
note right of Database : Data Layer
|
|
|
|
@enduml
|
|
|
|
```
|
|
```plantuml
|
|
@startuml
|
|
start
|
|
:Users Interacts with BrighterTrades;
|
|
if (Request data) then (yes)
|
|
:BrighterTrades Requests data from DataCache;
|
|
if (Data exists in DataCache) then (yes)
|
|
:DataCache Returns data to BrighterTrades;
|
|
if (Display data) then (yes)
|
|
:BrighterTrades Displays data to Users;
|
|
else (no)
|
|
stop
|
|
endif
|
|
else (no)
|
|
:BrighterTrades Requests data from Database;
|
|
if (Data exists in Database) then (yes)
|
|
:Database Returns data to DataCache;
|
|
:DataCache Returns data to BrighterTrades;
|
|
if (Display data) then (yes)
|
|
:BrighterTrades Displays data to Users;
|
|
else (no)
|
|
stop
|
|
endif
|
|
else (no)
|
|
:Database Notifies DataCache of data unavailability;
|
|
:DataCache Notifies BrighterTrades of data unavailability;
|
|
stop
|
|
endif
|
|
endif
|
|
else (no)
|
|
stop
|
|
endif
|
|
stop
|
|
@enduml
|
|
|
|
```
|
|
```plantuml
|
|
@startuml
|
|
|BrighterTrades|
|
|
start
|
|
:Users Interacts with BrighterTrades;
|
|
if (Request data) then (yes)
|
|
|BrighterTrades|
|
|
:BrighterTrades Requests data from DataCache;
|
|
if (Data exists in DataCache) then (yes)
|
|
|DataCache|
|
|
:DataCache Returns data to BrighterTrades;
|
|
|BrighterTrades|
|
|
if (Display data) then (yes)
|
|
:BrighterTrades Displays data to Users;
|
|
else (no)
|
|
stop
|
|
endif
|
|
else (no)
|
|
|DataCache|
|
|
:BrighterTrades Requests data from Database;
|
|
if (Data exists in Database) then (yes)
|
|
|Database|
|
|
:Database Returns data to DataCache;
|
|
|DataCache|
|
|
:DataCache Returns data to BrighterTrades;
|
|
|BrighterTrades|
|
|
if (Display data) then (yes)
|
|
:BrighterTrades Displays data to Users;
|
|
else (no)
|
|
stop
|
|
endif
|
|
else (no)
|
|
|Database|
|
|
:Database Notifies DataCache of data unavailability;
|
|
|DataCache|
|
|
:DataCache Notifies BrighterTrades of data unavailability;
|
|
stop
|
|
endif
|
|
endif
|
|
else (no)
|
|
stop
|
|
endif
|
|
|BrighterTrades|
|
|
stop
|
|
@enduml
|
|
|
|
```
|
|
```plantuml
|
|
@startuml
|
|
|
|
participant Brightertrades
|
|
participant DataCache
|
|
participant Database
|
|
participant Strategies
|
|
participant Candles
|
|
participant Configuration
|
|
participant ExchangeInterface
|
|
participant Indicators
|
|
participant Signals
|
|
participant Trades
|
|
|
|
== Brightertrades Interactions ==
|
|
|
|
Brightertrades -> DataCache: retrieveData()
|
|
DataCache -> Database: fetchData()
|
|
Database --> DataCache: data
|
|
DataCache --> Brightertrades: data
|
|
Brightertrades -> Strategies: selectStrategy()
|
|
Brightertrades -> Configuration: getConfig()
|
|
Brightertrades -> ExchangeInterface: getAccountInfo()
|
|
Brightertrades -> Indicators: calculateIndicators(candleData, config)
|
|
Brightertrades -> Signals: generateSignals(indicators)
|
|
Brightertrades -> Strategies: evaluateSignals(signals)
|
|
Brightertrades -> Trades: executeTrades(evaluatedSignals, accountInfo)
|
|
|
|
== DataCache Interactions ==
|
|
|
|
DataCache -> Database: fetchData()
|
|
Database --> DataCache: data
|
|
|
|
== Strategies Interactions ==
|
|
|
|
Strategies -> Candles: getCandleData()
|
|
Candles --> Strategies: candleData
|
|
|
|
== Brightertrades Internal Interactions ==
|
|
|
|
Brightertrades -> Strategies: evaluateSignals(signals)
|
|
|
|
@enduml
|
|
|
|
```
|
|
```plantuml
|
|
@startuml
|
|
|
|
participant "Brightertrades" as BT
|
|
participant "DataCache" as DC
|
|
participant "Database" as DB
|
|
participant "Strategies" as ST
|
|
participant "Candles" as CD
|
|
participant "Configuration" as CFG
|
|
participant "ExchangeInterface" as EI
|
|
participant "Indicators" as IND
|
|
participant "Signals" as SG
|
|
participant "Trades" as TD
|
|
|
|
== Brightertrades Interactions ==
|
|
|
|
BT -> DC: retrieveData()
|
|
DC -> DB: fetchData()
|
|
DB --> DC: data
|
|
DC --> BT: data
|
|
BT -> ST: selectStrategy()
|
|
BT -> CFG: getConfig()
|
|
BT -> EI: getAccountInfo()
|
|
BT -> IND: calculateIndicators(candleData, config)
|
|
BT -> SG: generateSignals(indicators)
|
|
BT -> ST: evaluateSignals(signals)
|
|
BT -> TD: executeTrades(evaluatedSignals, accountInfo)
|
|
TD --> BT: tradeResult
|
|
|
|
== DataCache Interactions ==
|
|
|
|
DC -> DB: fetchData()
|
|
DB --> DC: data
|
|
|
|
== Strategies Interactions ==
|
|
|
|
ST -> CD: getCandleData()
|
|
CD --> ST: candleData
|
|
ST --> BT: strategyResult
|
|
|
|
== Brightertrades Internal Interactions ==
|
|
|
|
BT -> ST: evaluateSignals(signals)
|
|
BT --> TD: evaluatedSignals
|
|
|
|
@enduml
|
|
```
|
|
### dd
|
|
```plantuml
|
|
@startuml
|
|
|
|
!define LightBlueColor #00AEEF
|
|
!define LightGreyColor #D3D3D3
|
|
|
|
!define BrightertradesColor(LightBlueColor)
|
|
!define DataCacheColor(LightBlueColor)
|
|
!define DatabaseColor(LightBlueColor)
|
|
!define StrategiesColor(LightBlueColor)
|
|
!define CandlesColor(LightBlueColor)
|
|
!define ConfigurationColor(LightBlueColor)
|
|
!define ExchangeInterfaceColor(LightBlueColor)
|
|
!define IndicatorsColor(LightBlueColor)
|
|
!define SignalsColor(LightBlueColor)
|
|
!define TradesColor(LightBlueColor)
|
|
|
|
skinparam monochrome false
|
|
skinparam defaultTextAlignment center
|
|
skinparam component {
|
|
BackgroundColor LightGreyColor
|
|
BorderColor black
|
|
ArrowColor black
|
|
FontColor black
|
|
}
|
|
|
|
actor User
|
|
|
|
User --> Brightertrades: Request action
|
|
|
|
Brightertrades -> DataCache: Retrieve data
|
|
DataCache --> Brightertrades: Data
|
|
Brightertrades -> Database: Execute SQL
|
|
Database --> Brightertrades: Result
|
|
Brightertrades -> Strategies: Get strategies
|
|
Strategies --> Brightertrades: List of strategies
|
|
Brightertrades -> Candles: Get candles
|
|
Candles --> Brightertrades: Candles data
|
|
Brightertrades -> Configuration: Get configuration
|
|
Configuration --> Brightertrades: Configuration data
|
|
Brightertrades -> ExchangeInterface: Execute trade
|
|
ExchangeInterface --> Brightertrades: Trade result
|
|
Brightertrades -> Indicators: Calculate indicators
|
|
Indicators --> Brightertrades: Indicator values
|
|
Brightertrades -> Signals: Generate signals
|
|
Signals --> Brightertrades: List of signals
|
|
Brightertrades -> Trades: Execute trades
|
|
Trades --> Brightertrades: Trade execution results
|
|
|
|
@enduml
|
|
|
|
```
|
|
```plantuml
|
|
@startuml
|
|
|
|
!define LightBlueColor #00AEEF
|
|
!define LightGreyColor #D3D3D3
|
|
|
|
!define BrightertradesColor(LightBlueColor)
|
|
!define DataCacheColor(LightBlueColor)
|
|
!define DatabaseColor(LightBlueColor)
|
|
!define StrategiesColor(LightBlueColor)
|
|
!define CandlesColor(LightBlueColor)
|
|
!define ConfigurationColor(LightBlueColor)
|
|
!define ExchangeInterfaceColor(LightBlueColor)
|
|
!define IndicatorsColor(LightBlueColor)
|
|
!define SignalsColor(LightBlueColor)
|
|
!define TradesColor(LightBlueColor)
|
|
|
|
skinparam monochrome false
|
|
skinparam defaultTextAlignment center
|
|
skinparam participant {
|
|
BackgroundColor LightGreyColor
|
|
BorderColor black
|
|
FontColor black
|
|
}
|
|
|
|
participant User
|
|
participant Brightertrades
|
|
participant DataCache
|
|
participant Database
|
|
participant Strategies
|
|
participant Candles
|
|
participant Configuration
|
|
participant ExchangeInterface
|
|
participant Indicators
|
|
participant Signals
|
|
participant Trades
|
|
|
|
User -> Brightertrades: Request action
|
|
|
|
activate Brightertrades
|
|
|
|
Brightertrades -> DataCache: retrieveData()
|
|
activate DataCache
|
|
DataCache --> Brightertrades: Data
|
|
deactivate DataCache
|
|
|
|
Brightertrades -> Database: executeSQL()
|
|
activate Database
|
|
Database --> Brightertrades: Result
|
|
deactivate Database
|
|
|
|
Brightertrades -> Strategies: getStrategies()
|
|
activate Strategies
|
|
Strategies --> Brightertrades: List of strategies
|
|
deactivate Strategies
|
|
|
|
Brightertrades -> Candles: getCandles()
|
|
activate Candles
|
|
Candles --> Brightertrades: Candles data
|
|
deactivate Candles
|
|
|
|
Brightertrades -> Configuration: getConfiguration()
|
|
activate Configuration
|
|
Configuration --> Brightertrades: Configuration data
|
|
deactivate Configuration
|
|
|
|
Brightertrades -> ExchangeInterface: executeTrade()
|
|
activate ExchangeInterface
|
|
ExchangeInterface --> Brightertrades: Trade result
|
|
deactivate ExchangeInterface
|
|
|
|
Brightertrades -> Indicators: calculateIndicators()
|
|
activate Indicators
|
|
Indicators --> Brightertrades: Indicator values
|
|
deactivate Indicators
|
|
|
|
Brightertrades -> Signals: generateSignals()
|
|
activate Signals
|
|
Signals --> Brightertrades: List of signals
|
|
deactivate Signals
|
|
|
|
Brightertrades -> Trades: executeTrades()
|
|
activate Trades
|
|
Trades --> Brightertrades: Trade execution results
|
|
deactivate Trades
|
|
|
|
deactivate Brightertrades
|
|
|
|
@enduml
|
|
|
|
```
|
|
```plantuml
|
|
|
|
```
|