Files
spark/src/lib/api/service_helpers/AdminServiceUtils.h
T

318 lines
18 KiB
C++

#pragma once
#include <memory>
#include "lib/api/services/AdminService.server.pb.h"
#include "lib/api/services/OrderService.server.pb.h"
#include "lib/domain_model/Security.h"
namespace bts{
namespace admin{
using namespace bts::api::admin;
using namespace bts::api::orderman;
class AdminServiceUtils{
public:
////////////////////////////////////////////
// connection accessors ////////////////////
////////////////////////////////////////////
// finds the max id out of all the existing connections
// (todo: deleted connections)
static uint32_t find_max_connection_id (const AdminData& data);
// finds a connection by name and returns a mutable pointer to it
static const ExchangeConnection* find_connection(const AdminData& data,
const std::string& connection_name);
// finds the presence of an exchange in a connection
static bool has_exchange(const ExchangeConnection& conn,
bts::api::Venue exchange);
// finds the default connections for an exchange
// in a given account
static const ExchangeConnection* find_default_account_connection(
const AdminData& data,
const BTSAccount& account,
bts::api::Venue exchange);
static const ExchangeConnection* resolve_cme_connection(
const AdminData& data,
const BTSAccount& account,
const api::Security& sec);
static const ExchangeConnection* resolve_sim_connection(
const AdminData& data,
const BTSAccount& account,
const api::Security& sec);
static const ExchangeConnection* resolve_connection(
const AdminData& data,
const BTSAccount& account,
const bts::api::Security& sec);
////////////////////////////////////////////
// connection mutators /////////////////////
////////////////////////////////////////////
// adds a new connection (does not check for name uniqueness)
static ExchangeConnection* add_connection(AdminData& data,
const ExchangeConnection& new_connection);
// reads the connections from config and fills in the
// admin data (with names only)
static void fill_connections_from_config(AdminData& admin_data);
////////////////////////////////////////////
// account accessors ///////////////////////
////////////////////////////////////////////
// finds the account from the name and returns
// a mutable pointer to the account
static BTSAccount* find_account (AdminData& data,
const std::string& acct_name,
bool include_deleted=false);
// same as above for const pointer
static const BTSAccount* find_account (const 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 BTSAccount* find_account (AdminData& data,
uint32_t id,
bool include_deleted=false);
// like above but returns a const pointer
static const BTSAccount* find_account (const 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 BTSAccount*> accounts (const AdminData& data,
bool include_deleted);
static std::vector<BTSAccount*> accounts_mutable (AdminData& data,
bool include_deleted);
// finds the max id amongts all the existing accounts
static uint32_t find_max_acct_id (const AdminData& data);
// gets the account data for cme (and goes up the hierarchy
// if needed)
static const CMEAccountData* get_account_cme_data(const BTSAccount& account,
const AdminData& data);
static const SIMAccountData* get_account_sim_data(const BTSAccount& account,
const AdminData& data);
// returns true if an account has a connection
bool static account_has_connection(const BTSAccount& account,
const std::string& connection_name);
// finds the external/clearing account associated
// with an account
static std::string find_account_exchange_account (const AdminData& data,
const BTSAccount& account,
api::Venue exchange,
AdminServiceOperationResult& out_result);
// returns a map of the accounts vs their 'is_active'
static std::map<uint32_t,bool> accounts_map(const AdminData& admin_data);
// validates that the update to the account is valid
static void validate_account_update (const AdminData& admin_data,
const BTSAccount& updated_account,
AdminServiceOperationResult& result);
// validates that the account exchange changes are valid
// (ex > 12 characters for accounts at CME)
static void validate_account_exchange_data (const BTSAccount& account,
AdminServiceOperationResult& out_result);
static RoutingRecord get_routing_record(
const AdminData& data,
const std::string& account_name,
const std::string& user_name,
const bts::api::Security& sec,
AdminServiceOperationResult& out_result);
static RoutingRecord get_routing_record(const AdminData& data,
uint32_t account_id,
uint32_t user_id,
const bts::api::Security& sec,
AdminServiceOperationResult& out_result);
////////////////////////////////////////////
// account mutators ////////////////////////
////////////////////////////////////////////
static BTSAccount* create_account(AdminData& data,
uint32_t parent_account_id,
const std::string& account_name,
const std::string& description,
bool is_active,
AdminServiceCreateAccountResult& result);
// writes over the account data completely
static void update_account(AdminData& data,
const BTSAccount& updated_account,
AdminServiceOperationResult& result);
static void delete_account (AdminData& admin_data,
const IDAPIArgument& id,
AdminServiceOperationResult& result);
static void set_account_exchange_data(BTSAccount* account,
const 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 AdminData
static void sync_account_connections(const AdminData& data,
BTSAccount& account);
////////////////////////////////////////////
// group accessors /////////////////////////
////////////////////////////////////////////
// given an id, finds the mutable pointer to a group
static BTSUserGroup* find_group (AdminData& data, uint32_t id);
// given an id, finds the const pointer to a group
static const BTSUserGroup* const find_group (const AdminData& data,
uint32_t id);
// given a name, finds the mutable pointer to a group
static BTSUserGroup* find_group (AdminData& data,
const std::string& group_name);
// finds the max id out of all the groups
static uint32_t find_max_group_id (const AdminData& data);
// travels up the group tree until it finds a populated cme data
static const CMEUserData* get_group_cme_data(const BTSUserGroup& group,
const AdminData& data);
static const SIMUserData* get_group_sim_data(const BTSUserGroup& group,
const AdminData& data);
static const UserAccountPermissions* const get_group_user_permissions (
const bts::api::admin::AdminData& admin_data,
uint32_t group_id);
////////////////////////////////////////////
// group mutators/ /////////////////////////
////////////////////////////////////////////
static BTSUserGroup* create_group(AdminData& data,
uint32_t parent_group_id,
const std::string& group_name,
AdminServiceOperationResult& result);
////////////////////////////////////////////
// user accessors //////////////////////////
////////////////////////////////////////////
static BTSUser* find_user (AdminData& data,
const std::string& user_name,
bool include_deleted=false);
static const BTSUser* find_user (const AdminData& data,
const std::string& user_name,
bool include_deleted=false);
static BTSUser* find_user (AdminData& data,
uint32_t id,
bool include_deleted=false);
static const BTSUser* const find_user (const AdminData& data,
uint32_t id,
bool include_deleted=false);
static std::vector<const BTSUser*> users (const AdminData& data,
bool include_deleted);
static std::vector<BTSUser*> users_mutable (AdminData& data,
bool include_deleted);
static uint32_t find_max_user_id (const AdminData& data);
static const CMEUserData* get_user_cme_data(const BTSUser& user,
const AdminData& data);
static const SIMUserData* get_user_sim_data(const BTSUser& user,
const 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 AdminData& data,
const BTSUser& user,
api::Venue exchange,
AdminServiceOperationResult& out_result);
static std::pair<const BTSAccount*, const BTSUser*>
find_user_account_matches (const 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 UserAccountPermissions* get_user_permissions (
const 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 AdminData& admin_data,
uint32_t user_id,
std::vector<const 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 AdminData& admin_data,
uint32_t account_id,
std::vector<const BTSUser*>& associated_users);
// validates that changes in user data satisfy all the
// constraints
static void validate_user_update (const AdminData& admin_data,
const BTSUser& updated_user,
AdminServiceOperationResult& result);
// vaidates the exchange part of user data updates
static void validate_user_exchange_data (
const BTSUser& updated_user,
AdminServiceOperationResult& out_result);
static void get_md_entitlement_report(const AdminData& admin_data,
std::vector<MDEntitlementReportUnit>& entitlements);
// Gets a reporting unit out of CMEMicData
static MDEntitlementReportUnit get_cme_md_entitlement_unit(
const BTSUser& user,
const CMEMicData& cme_mic_data);
static void get_user_symbol_permissions(
const AdminData& data,
const BTSUser& user,
std::vector<UserSymbolMDPermissionUnit>& res);
////////////////////////////////////////////
// user mutators ///////////////////////////
////////////////////////////////////////////
static BTSUser* create_user (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 LicenseData& license_data,
const LicenseEntitlements& license_entitlements,
AdminServiceCreateEntityResult& result);
static BTSUser* update_user(AdminData& admin_data,
const BTSUser& updated_user,
AdminServiceOperationResult& result);
static void delete_user (AdminData& admin_data,
const IDAPIArgument& id,
AdminServiceOperationResult& result);
static void set_user_exchange_data(
BTSUser* user,
const ExchangeUserData& exchange_user_data);
static void set_user_md_entitlement_data(BTSUser* user,
const ExchangeUserMarketDataEntitlementData&);
static void clear_user_accounts (BTSUser* user);
static void set_user_accounts (BTSUser* user,
const UserAccountPermissions& user_account_permissions);
////////////////////////////////////////////
//risk limits //////////////////////////////
////////////////////////////////////////////
// sorting function used by sort_limits to
// sort SecurityScope's
static bool _sort_security_scopes (const SecurityScope& a,
const SecurityScope& b);
// sorting function used by sort_limits to
// sort ProductScope's
static bool _sort_product_scopes (const ProductScope& a,
const 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 (BTSAccount& account);
// creates a copy of AdminData with sorted rules
static AdminData sort_limits (const AdminData& admin_data);
// find the clip size for a security, account
static const uint32_t find_account_security_clip_size(
const BTSAccount& account,
const api::Security& security);
// find the position limit for an account, security
static const AccountSecurityPositionLimitUnit*
find_account_security_position_limit(const BTSAccount& account,
const api::Security& security);
// find the position limit for an account, product
static const AccountProductPositionLimitUnit*
find_account_product_position_limit(const BTSAccount& account,
const api::Product& product);
static bool match_security_scope (const SecurityScope& scope,
const api::Security& security);
static bool match_product_scope (const 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 (bts::api::admin::AdminData& data);
};
}}