In headers, this is an objectively bad practice, since the type aliases leak into dependent code and can cause unexpected naming conflicts. In source files, it is debatable, but I prefer explicit aliases of the form 'using Foo = Bar'. The intentions are clear, and the resulting code is naturally resistent to naming conflicts.
428 lines
20 KiB
C++
428 lines
20 KiB
C++
#pragma once
|
|
|
|
#include "lib/api/services/AdminService.server.pb.h"
|
|
#include "lib/api/services/OrderService.server.pb.h"
|
|
#include "lib/config/config.h"
|
|
#include "lib/config/protos/toggles.pb.h"
|
|
#include "lib/utils/PBUtils.h"
|
|
|
|
namespace bts {
|
|
namespace admin {
|
|
|
|
class AdminServiceUtils {
|
|
public:
|
|
struct ExchangeSubAccountResolver {
|
|
const bts::config::toggles::ExchangeSubAccounts exch_sub_accounts;
|
|
ExchangeSubAccountResolver()
|
|
: exch_sub_accounts(
|
|
config::get<bts::config::toggles::ExchangeSubAccounts>()) {
|
|
LOG(OrderMan, Info,
|
|
"ExchangeSubAccountResolver::cons exch_sub_accounts: {}",
|
|
utils::pb::to_string(exch_sub_accounts));
|
|
}
|
|
bts::config::toggles::ExchangeSubAccountUnit const *find_entry(
|
|
api::Security const *sec,
|
|
const std::string &account,
|
|
bool is_int_account) {
|
|
auto get_account = [&](const auto &entry) {
|
|
return is_int_account ? entry.bts_account_name()
|
|
: entry.exchange_subaccount();
|
|
};
|
|
if (sec == nullptr)
|
|
return nullptr;
|
|
for (const auto &u : exch_sub_accounts.accounts()) {
|
|
if (get_account(u) == account)
|
|
return &u;
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
bts::config::toggles::ExchangeSubAccountUnit const *find_entry(
|
|
const std::string &account, bool is_internal_account) {
|
|
for (const auto &esa : exch_sub_accounts.accounts()) {
|
|
const auto &a = is_internal_account ? esa.bts_account_name()
|
|
: esa.exchange_subaccount();
|
|
if (a == account) {
|
|
return &esa;
|
|
}
|
|
}
|
|
return nullptr;
|
|
}
|
|
};
|
|
////////////////////////////////////////////
|
|
// connection accessors ////////////////////
|
|
////////////////////////////////////////////
|
|
// finds the max id out of all the existing connections
|
|
// (todo: deleted connections)
|
|
static uint32_t find_max_connection_id(const api::admin::AdminData &data);
|
|
// finds a connection by name and returns a mutable pointer to it
|
|
static const api::admin::ExchangeConnection *find_connection(
|
|
const api::admin::AdminData &data, const std::string &connection_name);
|
|
// finds the presence of an exchange in a connection
|
|
static bool has_exchange(
|
|
const api::admin::ExchangeConnection &conn, api::Venue exchange);
|
|
// finds the default connections for an exchange
|
|
// in a given account
|
|
static const api::admin::ExchangeConnection *find_default_account_connection(
|
|
const api::admin::AdminData &data,
|
|
const api::admin::BTSAccount &account,
|
|
api::Venue exchange);
|
|
static const api::admin::ExchangeConnection *resolve_cme_connection(
|
|
const api::admin::AdminData &data,
|
|
const api::admin::BTSAccount &account,
|
|
const api::Security &sec);
|
|
static const api::admin::ExchangeConnection *resolve_ice_connection(
|
|
const api::admin::AdminData &data,
|
|
const api::admin::BTSAccount &account,
|
|
const api::Security &sec);
|
|
static const api::admin::ExchangeConnection *resolve_sim_connection(
|
|
const api::admin::AdminData &data,
|
|
const api::admin::BTSAccount &account,
|
|
const api::Security &sec);
|
|
static const api::admin::ExchangeConnection *resolve_connection(
|
|
const api::admin::AdminData &data,
|
|
const api::admin::BTSAccount &account,
|
|
const api::Security &sec);
|
|
|
|
////////////////////////////////////////////
|
|
// connection mutators /////////////////////
|
|
////////////////////////////////////////////
|
|
// adds a new connection (does not check for name uniqueness)
|
|
static api::admin::ExchangeConnection *add_connection(
|
|
api::admin::AdminData &data,
|
|
const api::admin::ExchangeConnection &new_connection);
|
|
// reads the connections from config and fills in the
|
|
// admin data (with names only)
|
|
static void fill_connections_from_config(api::admin::AdminData &admin_data);
|
|
|
|
////////////////////////////////////////////
|
|
// account accessors ///////////////////////
|
|
////////////////////////////////////////////
|
|
// finds the account from the name and returns
|
|
// a mutable pointer to the account
|
|
static api::admin::BTSAccount *find_account(
|
|
api::admin::AdminData &data,
|
|
const std::string &acct_name,
|
|
bool include_deleted = false);
|
|
static std::map<std::string, uint32_t> get_clearing_account_map(
|
|
const api::admin::AdminData &);
|
|
|
|
// finds the account from a clearing account (and its venue)
|
|
static api::admin::BTSAccount const *find_account(
|
|
const api::admin::AdminData &data,
|
|
const std::string &clearing_account,
|
|
api::Venue);
|
|
// same as above for const pointer
|
|
static const api::admin::BTSAccount *find_account(
|
|
const api::admin::AdminData &data,
|
|
const std::string &acct_name,
|
|
bool include_deleted = false);
|
|
// finds the account from the id and returns
|
|
// a mutable pointer to the account
|
|
static api::admin::BTSAccount *find_account(
|
|
api::admin::AdminData &data, uint32_t id, bool include_deleted = false);
|
|
// like above but returns a const pointer
|
|
static const api::admin::BTSAccount *find_account(
|
|
const api::admin::AdminData &data,
|
|
uint32_t id,
|
|
bool include_deleted = false);
|
|
// this function is an indirection layer for account access
|
|
// so deletions are dealt in a more deliberate manner
|
|
static std::vector<const api::admin::BTSAccount *> accounts(
|
|
const api::admin::AdminData &data, bool include_deleted);
|
|
static std::vector<api::admin::BTSAccount *> accounts_mutable(
|
|
api::admin::AdminData &data, bool include_deleted);
|
|
// finds the max id amongts all the existing accounts
|
|
static uint32_t find_max_acct_id(const api::admin::AdminData &data);
|
|
// gets the account data for cme (and goes up the hierarchy
|
|
// if needed)
|
|
static const api::admin::CMEAccountData *get_account_cme_data(
|
|
const api::admin::BTSAccount &account,
|
|
const api::admin::AdminData &data);
|
|
static const api::admin::ICEAccountData *get_account_ice_data(
|
|
const api::admin::BTSAccount &account,
|
|
const api::admin::AdminData &data);
|
|
static const api::admin::SIMAccountData *get_account_sim_data(
|
|
const api::admin::BTSAccount &account,
|
|
const api::admin::AdminData &data);
|
|
// returns true if an account has a connection
|
|
bool static account_has_connection(
|
|
const api::admin::BTSAccount &account,
|
|
const std::string &connection_name);
|
|
// finds the external/clearing account associated
|
|
// with an account
|
|
static std::string find_account_exchange_account(
|
|
const api::admin::AdminData &data,
|
|
const api::admin::BTSAccount &account,
|
|
api::Venue exchange,
|
|
api::admin::AdminServiceOperationResult &out_result);
|
|
// returns a map of the accounts vs their 'is_active'
|
|
static std::map<uint32_t, bool> accounts_map(
|
|
const api::admin::AdminData &admin_data);
|
|
// validates that the update to the account is valid
|
|
static void validate_account_update(
|
|
const api::admin::AdminData &admin_data,
|
|
const api::admin::BTSAccount &updated_account,
|
|
api::admin::AdminServiceOperationResult &result);
|
|
// validates that the account exchange changes are valid
|
|
// (ex > 12 characters for accounts at CME)
|
|
static void validate_account_exchange_data(
|
|
const api::admin::BTSAccount &account,
|
|
api::admin::AdminServiceOperationResult &out_result);
|
|
static api::orderman::RoutingRecord get_routing_record(
|
|
const api::admin::AdminData &data,
|
|
const std::string &account_name,
|
|
const std::string &user_name,
|
|
const api::Security &sec,
|
|
api::admin::AdminServiceOperationResult &out_result);
|
|
static api::orderman::RoutingRecord get_routing_record(
|
|
const api::admin::AdminData &data,
|
|
uint32_t account_id,
|
|
uint32_t user_id,
|
|
const api::Security &sec,
|
|
api::admin::AdminServiceOperationResult &out_result);
|
|
|
|
////////////////////////////////////////////
|
|
// account mutators ////////////////////////
|
|
////////////////////////////////////////////
|
|
static api::admin::BTSAccount *create_account(
|
|
api::admin::AdminData &data,
|
|
uint32_t parent_account_id,
|
|
const std::string &account_name,
|
|
const std::string &description,
|
|
bool is_active,
|
|
api::admin::AdminServiceCreateAccountResult &result);
|
|
// writes over the account data completely
|
|
static void update_account(
|
|
api::admin::AdminData &data,
|
|
const api::admin::BTSAccount &updated_account,
|
|
api::admin::AdminServiceOperationResult &result);
|
|
static void delete_account(
|
|
api::admin::AdminData &admin_data,
|
|
const api::admin::IDAPIArgument &id,
|
|
api::admin::AdminServiceOperationResult &result);
|
|
static void set_account_exchange_data(
|
|
api::admin::BTSAccount *account,
|
|
const api::admin::ExchangeAccountData &exchange_data);
|
|
// this is not a generally useful function but since
|
|
// connection are in config, this cleans up the account's
|
|
// connections and syncs it with the list in api::admin::AdminData
|
|
static void sync_account_connections(
|
|
const api::admin::AdminData &data, api::admin::BTSAccount &account);
|
|
|
|
////////////////////////////////////////////
|
|
// group accessors /////////////////////////
|
|
////////////////////////////////////////////
|
|
// given an id, finds the mutable pointer to a group
|
|
static api::admin::BTSUserGroup *find_group(
|
|
api::admin::AdminData &data, uint32_t id);
|
|
// given an id, finds the const pointer to a group
|
|
static const api::admin::BTSUserGroup *const find_group(
|
|
const api::admin::AdminData &data, uint32_t id);
|
|
// given a name, finds the mutable pointer to a group
|
|
static api::admin::BTSUserGroup *find_group(
|
|
api::admin::AdminData &data, const std::string &group_name);
|
|
// finds the max id out of all the groups
|
|
static uint32_t find_max_group_id(const api::admin::AdminData &data);
|
|
// travels up the group tree until it finds a populated cme data
|
|
static const api::admin::CMEUserData *get_group_cme_data(
|
|
const api::admin::BTSUserGroup &group,
|
|
const api::admin::AdminData &data);
|
|
static const api::admin::ICEUserData *get_group_ice_data(
|
|
const api::admin::BTSUserGroup &group,
|
|
const api::admin::AdminData &data);
|
|
static const api::admin::SIMUserData *get_group_sim_data(
|
|
const api::admin::BTSUserGroup &group,
|
|
const api::admin::AdminData &data);
|
|
static const api::admin::UserAccountPermissions *const
|
|
get_group_user_permissions(
|
|
const api::admin::AdminData &admin_data, uint32_t group_id);
|
|
|
|
////////////////////////////////////////////
|
|
// group mutators/ /////////////////////////
|
|
////////////////////////////////////////////
|
|
static api::admin::BTSUserGroup *create_group(
|
|
api::admin::AdminData &data,
|
|
uint32_t parent_group_id,
|
|
const std::string &group_name,
|
|
api::admin::AdminServiceOperationResult &result);
|
|
|
|
////////////////////////////////////////////
|
|
// user accessors //////////////////////////
|
|
////////////////////////////////////////////
|
|
static api::admin::BTSUser *find_user(
|
|
api::admin::AdminData &data,
|
|
const std::string &user_name,
|
|
bool include_deleted = false);
|
|
static const api::admin::BTSUser *find_user(
|
|
const api::admin::AdminData &data,
|
|
const std::string &user_name,
|
|
bool include_deleted = false);
|
|
static api::admin::BTSUser *find_user(
|
|
api::admin::AdminData &data, uint32_t id, bool include_deleted = false);
|
|
static const api::admin::BTSUser *const find_user(
|
|
const api::admin::AdminData &data,
|
|
uint32_t id,
|
|
bool include_deleted = false);
|
|
static std::vector<const api::admin::BTSUser *> users(
|
|
const api::admin::AdminData &data, bool include_deleted);
|
|
static std::vector<api::admin::BTSUser *> users_mutable(
|
|
api::admin::AdminData &data, bool include_deleted);
|
|
static uint32_t find_max_user_id(const api::admin::AdminData &data);
|
|
static const api::admin::CMEUserData *get_user_cme_data(
|
|
const api::admin::BTSUser &user, const api::admin::AdminData &data);
|
|
static const api::admin::ICEUserData *get_user_ice_data(
|
|
const api::admin::BTSUser &user, const api::admin::AdminData &data);
|
|
static const api::admin::SIMUserData *get_user_sim_data(
|
|
const api::admin::BTSUser &user, const api::admin::AdminData &data);
|
|
// finds the "exchange user" (ex: "operator_id" at CME or "authorized_trader"
|
|
// at ICE) for a user
|
|
static std::string find_user_exchange_id(
|
|
const api::admin::AdminData &data,
|
|
const api::admin::BTSUser &user,
|
|
api::Venue exchange,
|
|
api::admin::AdminServiceOperationResult &out_result);
|
|
// i. uses the exchange and exchange_user to reverse lookup the user(s)
|
|
// ii. uses the exchange, connection and exchange_account to reverse lookup
|
|
// the account(s) iii. finds the first account from ii that a user from i is
|
|
// authorized to trade
|
|
static std::string find_user_company_id(
|
|
const api::admin::AdminData &data,
|
|
const api::admin::BTSUser &user,
|
|
api::Venue exchange,
|
|
api::admin::AdminServiceOperationResult &out_result);
|
|
|
|
static std::pair<const api::admin::BTSAccount *, const api::admin::BTSUser *>
|
|
find_user_account_matches(
|
|
const api::admin::AdminData &admin_data,
|
|
const std::string &connection,
|
|
const std::string &exchange_account,
|
|
const std::string &exchange_user,
|
|
api::Venue exchange);
|
|
// for a given user finds the account permissions (if permissions are
|
|
// derived from the group, it traverses the group hierarcy to find the
|
|
// correct permissions.
|
|
static const api::admin::UserAccountPermissions *get_user_permissions(
|
|
const api::admin::AdminData &admin_data, uint32_t user_id);
|
|
// for a given user, fills in the associated_accounts ref arg
|
|
// with the accounts the user has permission to trade in
|
|
static void find_user_trading_accounts(
|
|
const api::admin::AdminData &admin_data,
|
|
uint32_t user_id,
|
|
std::vector<const api::admin::BTSAccount *> &associated_accounts);
|
|
// for a given account, fills in the associated_users ref arg
|
|
// with the users that can trade into the account
|
|
static void find_users_for_trading_account(
|
|
const api::admin::AdminData &admin_data,
|
|
uint32_t account_id,
|
|
std::vector<const api::admin::BTSUser *> &associated_users);
|
|
// validates that changes in user data satisfy all the
|
|
// constraints
|
|
static void validate_user_update(
|
|
const api::admin::AdminData &admin_data,
|
|
const api::admin::BTSUser &updated_user,
|
|
api::admin::AdminServiceOperationResult &result);
|
|
// vaidates the exchange part of user data updates
|
|
static void validate_user_exchange_data(
|
|
const api::admin::BTSUser &updated_user,
|
|
api::admin::AdminServiceOperationResult &out_result);
|
|
static void get_md_entitlement_report(
|
|
const api::admin::AdminData &admin_data,
|
|
std::vector<api::admin::MDEntitlementReportUnit> &entitlements);
|
|
// Gets a reporting unit out of CMEMicData
|
|
static api::admin::MDEntitlementReportUnit get_cme_md_entitlement_unit(
|
|
const api::admin::BTSUser &user,
|
|
const api::admin::CMEMicData &cme_mic_data);
|
|
static api::admin::MDEntitlementReportUnit get_ice_md_entitlement_unit(
|
|
const api::admin::BTSUser &user,
|
|
const api::admin::ICEMicData &ice_mic_data);
|
|
static void get_user_symbol_permissions(
|
|
const api::admin::AdminData &data,
|
|
const api::admin::BTSUser &user,
|
|
std::vector<api::admin::UserSymbolMDPermissionUnit> &res);
|
|
|
|
////////////////////////////////////////////
|
|
// user mutators ///////////////////////////
|
|
////////////////////////////////////////////
|
|
static api::admin::BTSUser *create_user(
|
|
api::admin::AdminData &data,
|
|
uint32_t parent_group_id,
|
|
const std::string &name,
|
|
const std::string &password,
|
|
const std::string &full_name,
|
|
const std::string &company,
|
|
bool is_active,
|
|
const api::admin::LicenseData &license_data,
|
|
const api::admin::LicenseEntitlements &license_entitlements,
|
|
api::admin::AdminServiceCreateEntityResult &result);
|
|
static api::admin::BTSUser *update_user(
|
|
api::admin::AdminData &admin_data,
|
|
const api::admin::BTSUser &updated_user,
|
|
api::admin::AdminServiceOperationResult &result);
|
|
static void delete_user(
|
|
api::admin::AdminData &admin_data,
|
|
const api::admin::IDAPIArgument &id,
|
|
api::admin::AdminServiceOperationResult &result);
|
|
static void set_user_exchange_data(
|
|
api::admin::BTSUser *user,
|
|
const api::admin::ExchangeUserData &exchange_user_data);
|
|
static void clear_user_accounts(api::admin::BTSUser *user);
|
|
static void set_user_accounts(
|
|
api::admin::BTSUser *user,
|
|
const api::admin::UserAccountPermissions &user_account_permissions);
|
|
|
|
////////////////////////////////////////////
|
|
// risk limits //////////////////////////////
|
|
////////////////////////////////////////////
|
|
// sorting function used by sort_limits to
|
|
// sort SecurityScope's
|
|
static bool _sort_security_scopes(
|
|
const api::admin::SecurityScope &a, const api::admin::SecurityScope &b);
|
|
// sorting function used by sort_limits to
|
|
// sort ProductScope's
|
|
static bool _sort_product_scopes(
|
|
const api::admin::ProductScope &a, const api::admin::ProductScope &);
|
|
// this sorts the rules such that the most
|
|
// specific ones are at the top. this makes it
|
|
// easier to match rules with securities/products
|
|
static void sort_limits(api::admin::BTSAccount &account);
|
|
// creates a copy of api::admin::AdminData with sorted rules
|
|
static api::admin::AdminData sort_limits(
|
|
const api::admin::AdminData &admin_data);
|
|
// find the clip size for a security, account
|
|
static const uint32_t find_account_security_clip_size(
|
|
const api::admin::BTSAccount &account, const api::Security &security);
|
|
// find the position limit for an account, security
|
|
static const api::admin::AccountSecurityPositionLimitUnit *
|
|
find_account_security_position_limit(
|
|
const api::admin::BTSAccount &account, const api::Security &security);
|
|
// find the position limit for an account, product
|
|
static const api::admin::AccountProductPositionLimitUnit *
|
|
find_account_product_position_limit(
|
|
const api::admin::BTSAccount &account, const api::Product &product);
|
|
static bool match_security_scope(
|
|
const api::admin::SecurityScope &scope, const api::Security &security);
|
|
static bool match_product_scope(
|
|
const api::admin::ProductScope &scope, const api::Product &product);
|
|
static bool match_product(
|
|
const api::Security &security, const api::Product &product);
|
|
static bool _match_limit_rule_symbol(
|
|
const std::string &symbol, const std::string &limit_symbol);
|
|
static api::SecurityType security_type(const api::Security &security);
|
|
////////////////////////////////////////////
|
|
// misc//////// ////////////////////////////
|
|
////////////////////////////////////////////
|
|
static bool has_id(uint32_t id);
|
|
static bool is_symbol_set(const std::string &symbol);
|
|
static void bootstrap_data(api::admin::AdminData &data);
|
|
static void get_spread_prod_qty(
|
|
const api::Security &s,
|
|
std::map<std::string, double> &out_map,
|
|
double mult = 1.0);
|
|
// returns true if this spread effects the position of any outrights
|
|
static bool residual_pos_spread(const api::Security &s);
|
|
};
|
|
|
|
} // namespace admin
|
|
} // namespace bts
|