Files
spark/src/server/sparkd/user/AdminServiceServer.cpp
T

173 lines
6.3 KiB
C++

#include "AdminServiceServer.h"
#include "server/sparkd/persistence/SqliteStore.h"
#include "lib/logging/logging.h"
#include "lib/utils/PBUtils.h"
#include "AdminServiceUtils.h"
#include <boost/tokenizer.hpp>
#include <fmt/format.h>
#include <map>
#include <set>
#include <utility>
namespace bts {
namespace admin{
AdminServiceServer::AdminServiceServer(bts::api::ServiceContext& context)
:
bts::api::admin::AdminServiceBase (context),
_table_name("users"),
_unique_key("0"),
_state(),
_store(new bts::persistence::SqliteStore("user_model"))
{
LOG(Gen, Info, "AdminServiceServer created");
std::map<std::string,std::map<std::string,std::string>> all_data = _store->retrieve_all();
auto table = all_data.find(_table_name);
bool data_found = false;
if (table != all_data.end())
{
auto row = table->second.find(_unique_key);
if (row != table->second.end())
{
std::string& ser_data = row->second;
if (_state.ParseFromString(ser_data))
{
data_found = true;
_update_and_publish();
}
}
}
if (!data_found)
{
// first time
// TODO add default group
_update_and_publish();
}
}
AdminServiceServer::~AdminServiceServer() {}
void AdminServiceServer::create_account(const api::admin::AccountCreateAPIArgument& acct_create_arg,
const api::Response<::bts::api::VoidMessage>&)
{
if (AdminServiceUtils::find_account(_state, acct_create_arg.account_name())==nullptr){
bts::api::admin::BTSAccount* new_account = _state.add_accounts();
new_account->set_id(AdminServiceUtils::find_curr_acct_id(_state)+1);
new_account->set_name(acct_create_arg.account_name());
new_account->set_description(acct_create_arg.description());
new_account->set_is_active(false);
_update_and_publish();
}
}
void AdminServiceServer::set_account_clip_limits(const api::admin::AccountSecurityClipLimitsAPIArgument& acct_clips_arg,
const api::Response<::bts::api::VoidMessage>&)
{
bts::api::admin::BTSAccount* account = AdminServiceUtils::find_account(_state, acct_clips_arg.account_id());
if (account != nullptr)
{
// if(!account->has_account_data())
// {
// account->mutable_account_data()->mutable_security_clip_limits()->mutable_limit()->Clear();
// }
}
else{
// TODO: return error
}
}
void AdminServiceServer::set_account_product_position_limits(const api::admin::AccountProductPositionLimitsAPIArgument&,
const api::Response<::bts::api::VoidMessage>&)
{
}
void AdminServiceServer::set_account_security_position_limits(const api::admin::AccountSecurityPositionLimitsAPIArgument&,
const api::Response<::bts::api::VoidMessage>&)
{
}
void AdminServiceServer::set_account_margin_limits(const api::admin::AccountMarginLimitAPIArgument&,
const api::Response<::bts::api::VoidMessage>&)
{
}
void AdminServiceServer::set_account_connections(const api::admin::AccountConnectionsAPIArgument&,
const api::Response<::bts::api::VoidMessage>&)
{
}
void AdminServiceServer::set_account_exchange_data(const api::admin::AccountExchangeDataAPIArgument& account_exchange_data,
const api::Response<::bts::api::admin::PersistRequestResult>& reply)
{
bts::api::admin::PersistRequestResult result; result.set_is_success(true);
bts::api::admin::BTSAccount* account = AdminServiceUtils::find_account(_state, account_exchange_data.account_id());
if(account != nullptr)
account->mutable_exchange_account_data()->CopyFrom(account_exchange_data.complete_data());
else{
result.set_is_success(false);
result.set_error_text("Could not find account");
}
reply(result);
}
void AdminServiceServer::create_user(const api::admin::UserCreateAPIArgument&,
const api::Response<::bts::api::VoidMessage>&)
{
}
void AdminServiceServer::set_user_account_association(const api::admin::UserAccountAssociationAPIArgument&,
const api::Response<::bts::api::VoidMessage>&)
{
}
void AdminServiceServer::set_user_exchange_routing_data(const api::admin::ExchangeUserDataAPIArgument& user_exchange_routing_data,
const api::Response<::bts::api::admin::PersistRequestResult>& reply){
bts::api::admin::BTSUser* user = AdminServiceUtils::find_user(_state, user_exchange_routing_data.user_id());
bts::api::admin::PersistRequestResult result; result.set_is_success(true);
if (user != nullptr){
AdminServiceUtils::set_user_exchange_data(user, user_exchange_routing_data.complete_data());
}
else{
result.set_is_success(false);
result.set_error_text("Could not find user");
}
reply(result);
}
void AdminServiceServer::set_user_md_entitlement_data(const bts::api::admin::ExchangeUserMarketDataEntitlementDataAPIArgument& user_md_entitlement_data,
const bts::api::Response<::bts::api::admin::PersistRequestResult>& reply){
bts::api::admin::BTSUser* user = AdminServiceUtils::find_user(_state, user_md_entitlement_data.user_id());
bts::api::admin::PersistRequestResult result; result.set_is_success(true);
if (user != nullptr){
AdminServiceUtils::set_user_md_entitlement_data(user, user_md_entitlement_data.complete_data());
}
else{
result.set_is_success(false);
result.set_error_text("Could not find user");
}
reply(result);
}
void AdminServiceServer::get_user_model(const bts::api::VoidMessage&,
const api::Response<::bts::api::admin::AdminData>& reply)
{
reply(_state);
}
void AdminServiceServer::_update_and_publish()
{
std::string ser_state;
if (_state.SerializeToString(&ser_state))
{
LOG(Gen, Info, "Could not save user data");
_store->update(_table_name, _unique_key, ser_state);
// publish it
}
else
LOG(Gen, Error, "Could not save user data");
}
}}