#include "PositionServiceServer.h" #include "lib/api/services/OrderService.pb.h" #include "lib/api/services/OrderService.client.pb.h" #include "lib/api/public/ServiceContext.h" #include "lib/logging/logging.h" #include "lib/utils/PBUtils.h" #include "lib/persistence/SqliteStore.h" #include "lib/utils/Puid.h" #include "PositionServicePNLHelper.h" #include #include #include #include #include #include namespace bts { namespace position{ using namespace bts::api::position; using namespace bts::api::orderman; using namespace bts::md; static auto const manual_fills_ns = "manual_fills"; struct PositionServiceServer::PImpl { bts::api::ServiceContext& context; PositionServiceBase::Position_dataStatefulPublisher publisher; PositionServiceBase::Pnl_dataStatefulPublisher pnl_publisher; PositionServiceBase::Pnl_account_dataStatefulPublisher pnl_account_publisher; bts::api::orderman::OrderService order_service; std::map> state; std::map manual_fills; int id; PositionServicePNLHelper pnl_helper; int64_t poll_period_ms; // manual fills management std::unique_ptr manual_fills_store ; PositionServiceBase::Manual_fillsStatefulPublisher manual_fills_publisher; PImpl(bts::api::ServiceContext& context, const PositionServiceBase::Position_dataStatefulPublisher& publisher, const PositionServiceBase::Pnl_dataStatefulPublisher& pnl_publisher, const PositionServiceBase::Pnl_account_dataStatefulPublisher& pnl_account_publisher, const PositionServiceBase::Manual_fillsStatefulPublisher &manual_fills_publisher, bts::md::MDClient& md_client) : context(context), publisher(publisher), pnl_publisher(pnl_publisher), pnl_account_publisher(pnl_account_publisher), order_service(context.locate()), state(), id(0), pnl_helper(md_client), poll_period_ms(1000), manual_fills_store(std::make_unique ("manual_fills")), manual_fills_publisher(manual_fills_publisher) { } }; PositionServiceServer::PositionServiceServer(bts::api::ServiceContext& context, bts::md::MDClient& md_client) : PositionServiceBase (context), me(new PImpl(context, make_position_data_stateful_publisher(), make_pnl_data_stateful_publisher(), make_pnl_account_data_stateful_publisher(), make_manual_fills_stateful_publisher(), md_client)) { me->order_service.subscribe_fills() | rxcpp::operators::subscribe( [this](auto const& update) { for (const auto& f : update.removed()) me->publisher.add_or_update(_on_fill(*f,false)); for (const auto& f : update.added()) me->publisher.add_or_update(_on_fill(*f,true)); for (const auto& f : update.changed()) { me->publisher.add_or_update(_on_fill(*f.previous(),false)); me->publisher.add_or_update(_on_fill(*f.current(),true)); } me->publisher.flush(); _compute_pnl_and_publish(); }); me->context.post([this](){_periodic_poll();},me->poll_period_ms); auto all = me->manual_fills_store->retrieve_all()[manual_fills_ns]; LOG(persist, Info, "Finished loading all {} manual fills", all.size()); ManualFill rec; for (auto const &kvp : all) if (utils::pb::from_string(kvp.second, &rec)) { me->manual_fills.insert({rec.record_id(), rec}); me->manual_fills_publisher.add_or_update(rec); me->publisher.add_or_update(_on_fill(to_fill(rec),true)); } else { LOG(OrderMan, Error, "Could not recover manual fill {} from storage. " "This should be investigated", kvp.first); } me->manual_fills_publisher.flush(); me->publisher.flush(); } bts::api::orderman::Fill PositionServiceServer::to_fill(bts::api::position::ManualFill const&src) { using namespace api::orderman; bts::api::orderman::Fill result; result.set_account(src.account_name()); result.set_security_key(src.security_key()); result.set_last_price(src.price()); result.set_side(src.side()); result.set_last_shares(src.quantity()); result.set_fill_kind(Fill::FILL_KIND_STANDARD); result.set_fill_key(std::string("manual:")+std::to_string(src.record_id())); return result; } const PositionUnit& PositionServiceServer::_on_fill (const Fill& f, bool is_add){ std::string fill_account=_fill_account(f); PositionUnit& pu=_get_or_add(fill_account,f.internal_account_id(), f.security_key()); double avg_price, tot_qty; if(f.fill_kind()==bts::api::orderman::Fill::FILL_KIND_SOD){ if(f.side()==api::Side::SIDE_BUY){ _avg_price_qty(pu.sod_long_avg_price(),pu.sod_long_pos(), f.last_price(),f.last_shares(), is_add,f.fill_key(), avg_price, tot_qty); pu.set_sod_long_avg_price(avg_price); pu.set_sod_long_pos(tot_qty); } else{ _avg_price_qty(pu.sod_short_avg_price(),pu.sod_short_pos(), f.last_price(),f.last_shares(), is_add,f.fill_key(), avg_price, tot_qty); pu.set_sod_short_avg_price(avg_price); pu.set_sod_short_pos(tot_qty); } } else{ if(f.side()==api::Side::SIDE_BUY){ _avg_price_qty(pu.day_long_avg_price(),pu.day_long_pos(), f.last_price(),f.last_shares(), is_add,f.fill_key(), avg_price, tot_qty); pu.set_day_long_avg_price(avg_price); pu.set_day_long_pos(tot_qty); } else{ _avg_price_qty(pu.day_short_avg_price(),pu.day_short_pos(), f.last_price(),f.last_shares(), is_add,f.fill_key(), avg_price, tot_qty); pu.set_day_short_avg_price(avg_price); pu.set_day_short_pos(tot_qty); } } return pu; } PositionUnit& PositionServiceServer::_get_or_add (const std::string& acct, uint32_t account_id, uint32_t seckey){ auto &pu = me->state[acct][seckey]; if (pu.record_id() == 0) { // new PU pu.set_record_id(++me->id); pu.set_account(acct); pu.set_account_id(account_id); pu.set_security_id(seckey); } return pu; } void PositionServiceServer::_avg_price_qty(double base_p, double base_q, double fill_p, double fill_q, bool is_add, const std::string& fill_id, double& avg_price, double& tot_qty){ if(fill_q<0){ LOG(OrderMan,Error,"PositionServiceServer::_avg_price_qty " "fill_id:{} fill_q:{} is_add:{}", fill_id, fill_q, is_add); fill_q=0; } if(is_add){ tot_qty=base_q+fill_q; avg_price = (base_p*base_q+fill_p*fill_q)/tot_qty; } else{ if(fill_q>=base_q){ tot_qty=0; avg_price=0; if(fill_q>base_q) LOG(OrderMan,Error,"PositionServiceServer::_avg_price_qty " "fill_id:{} base_qty:{} fill_qty:{}", fill_id, base_q, fill_q); } else{ tot_qty=base_q-fill_q; avg_price = (base_p*base_q-fill_p*fill_q)/tot_qty; } } } std::string PositionServiceServer::_fill_account(const Fill& fill){ return boost::trim_right_copy(fill.account()); } PositionServiceServer::~PositionServiceServer(){ } void PositionServiceServer::create_manual_fill( const ManualFillBatch &batch, const api::Response &r) { PositionServiceResponse resp; for (auto mf : batch.manual_fill()) { auto id = utils::gen_id ("manual_fills"); mf.set_record_id(id); me->manual_fills.insert({mf.record_id(), mf}); me->manual_fills_store->insert(manual_fills_ns, std::to_string(id), utils::pb::to_string(mf)); resp.add_response()->set_ok(true); me->manual_fills_publisher.add_or_update(mf); me->publisher.add_or_update(_on_fill(to_fill(mf),true)); } r(resp); me->manual_fills_publisher.flush(); me->publisher.flush(); } void PositionServiceServer::update_manual_fill( const ManualFillBatch &batch, const api::Response &r) { PositionServiceResponse resp; for (auto mf : batch.manual_fill()) { auto *this_resp = resp.add_response(); auto id = std::to_string(mf.record_id()); auto p = me->manual_fills_store->retrieve_one(manual_fills_ns,id); auto found = p.first; if (!found) { this_resp->set_ok(false); this_resp->set_msg("Could not find record"); } else { me->manual_fills_store->update(manual_fills_ns, id, utils::pb::to_string(mf)); this_resp->set_ok(true); // Retrieve old record so we can remove it from position auto it = me->manual_fills.find(mf.record_id()); bts_assert(it!= me->manual_fills.end()); auto &old = it->second; // remove old me->publisher.add_or_update(_on_fill(to_fill(old),false)); // add new me->manual_fills.insert({mf.record_id(), mf}); me->publisher.add_or_update(_on_fill(to_fill(mf),true)); me->manual_fills_publisher.add_or_update(mf); } } r(resp); me->publisher.flush(); me->manual_fills_publisher.flush(); } void PositionServiceServer::remove_manual_fill( const ManualFillBatch &batch, const api::Response &r) { PositionServiceResponse resp; for (auto mf : batch.manual_fill()) { auto *this_resp = resp.add_response(); auto id = std::to_string(mf.record_id()); auto p = me->manual_fills_store->retrieve_one(manual_fills_ns,id); auto found = p.first; if (!found) { this_resp->set_ok(false); this_resp->set_msg("Could not find record"); } else { // Retrieve old record so we can remove it from position auto it = me->manual_fills.find(mf.record_id()); bts_assert(it != me->manual_fills.end()); auto &old = it->second; me->publisher.add_or_update(_on_fill(to_fill(old),false)); me->manual_fills.erase(it); std::set to_r ; to_r.insert(id); me->manual_fills_store->remove(manual_fills_ns,to_r); this_resp->set_ok(true); me->manual_fills_publisher.erase(mf.record_id()); } } r(resp); me->publisher.flush(); me->manual_fills_publisher.flush(); } void PositionServiceServer::_compute_pnl_and_publish(){ std::vector in_pos; for (auto& acct_p : me->state) { for (auto& sec_p : acct_p.second) { const PositionUnit& pu = sec_p.second; in_pos.push_back(&pu); } } std::vector pnl; std::vector account_pnl; me->pnl_helper.compute_pnl(in_pos,pnl,account_pnl); for (const auto& u : pnl) me->pnl_publisher.add_or_update(u); for (const auto& u : account_pnl) me->pnl_account_publisher.add_or_update(u); me->pnl_publisher.flush(); me->pnl_account_publisher.flush(); } void PositionServiceServer::_periodic_poll(){ _compute_pnl_and_publish(); me->context.post([this](){_periodic_poll();},me->poll_period_ms); } }}