bool DlgMarkets::LowLevelLoadMarketList(QString qstrServerID, QString qstrNymID, mapIDName & the_map)
{
if (qstrServerID.isEmpty() || qstrNymID.isEmpty())
return false;
// -----------------------------------
OTDB::MarketList * pMarketList = LoadMarketListForServer(qstrServerID.toStdString());
OTCleanup<OTDB::MarketList> theAngel(pMarketList);
if (NULL != pMarketList)
{
size_t nMarketDataCount = pMarketList->GetMarketDataCount();
for (size_t ii = 0; ii < nMarketDataCount; ++ii)
{
OTDB::MarketData * pMarketData = pMarketList->GetMarketData(ii);
if (NULL == pMarketData) // Should never happen.
continue;
// -----------------------------------------------------------------------
QString qstrMarketID = QString::fromStdString(pMarketData->market_id);
QString qstrScale = QString::fromStdString(pMarketData->scale);
// -----------------------------------------------------------------------
QString qstrCompositeID = QString("%1,%2").arg(qstrMarketID).arg(qstrScale);
// -----------------------------------------------------------------------
// This multimap will have multiple markets of the same key (from
// different servers.)
//
m_mapMarkets.insertMulti(qstrCompositeID, VPtr<OTDB::MarketData>::asQVariant(pMarketData->clone()));
// -----------------------------------------------------------------------
// Whereas this map will only have a single entry for each key. (Thus
// we only add it here if it's not already present.)
//
mapIDName::iterator it_map = the_map.find(qstrCompositeID);
if (the_map.end() == it_map)
{
const std::string str_asset_name = OTAPI_Wrap::GetAssetType_Name(pMarketData->asset_type_id);
const std::string str_currency_name = OTAPI_Wrap::GetAssetType_Name(pMarketData->currency_type_id);
// --------------------------
QString qstrMarketName = QString("%1 for %2").
arg(QString::fromStdString(str_asset_name)).
arg(QString::fromStdString(str_currency_name));
// ---------------------------
the_map.insert(qstrCompositeID, qstrMarketName);
}
// ---------------------------
} // for
}
// -----------------------------------
return true;
}
int32_t CmdShowMarkets::run(string server)
{
if (!checkServer("server", server)) {
return -1;
}
OTDB::MarketList* marketList = loadMarketList(server);
if (nullptr == marketList) {
otOut << "Error: cannot load market list.\n";
return -1;
}
int32_t items = marketList->GetMarketDataCount();
if (0 > items) {
otOut << "Error: cannot load market list item count.\n";
return -1;
}
if (0 == items) {
otOut << "The market list is empty.\n";
return 0;
}
cout << "Index\tScale\tMarket\t\t\t\t\t\tAsset\t\t\t\t\t\tCurrency\n";
for (int32_t i = 0; i < items; i++) {
OTDB::MarketData* marketData = marketList->GetMarketData(i);
if (nullptr == marketData) {
otOut << "Error: cannot load market data at index " << i << ".\n";
return -1;
}
cout << i << "\t" << marketData->scale << "\tM "
<< marketData->market_id << "\tA "
<< marketData->instrument_definition_id << "\tC "
<< marketData->currency_type_id << "\n";
}
return 1;
}
bool OTCron::GetMarketList (OTASCIIArmor & ascOutput, int & nMarketCount)
{
nMarketCount = 0; // This parameter is set to zero here, and incremented in the loop below.
// ------------------------
OTMarket * pMarket = NULL;
OTDB::MarketList * pMarketList = dynamic_cast<OTDB::MarketList*>(OTDB::CreateObject(OTDB::STORED_OBJ_MARKET_LIST));
OTCleanup<OTDB::MarketList> theListAngel(*pMarketList);
// -----------------------------------------------------------
for (mapOfMarkets::iterator ii = m_mapMarkets.begin(); ii != m_mapMarkets.end(); ++ii)
{
pMarket = (*ii).second;
OT_ASSERT(NULL != pMarket);
OTDB::MarketData * pMarketData = dynamic_cast<OTDB::MarketData *>(OTDB::CreateObject(OTDB::STORED_OBJ_MARKET_DATA));
OTCleanup<OTDB::MarketData> theDataAngel(*pMarketData);
// --------------------------------------------
const OTIdentifier MARKET_ID(*pMarket);
const OTString str_MARKET_ID(MARKET_ID);
const OTString str_ServerID(pMarket->GetServerID());
const OTString str_ASSET_ID(pMarket->GetAssetID());
const OTString str_CURRENCY_ID(pMarket->GetCurrencyID());
pMarketData->server_id = str_ServerID.Get();
pMarketData->market_id = str_MARKET_ID.Get();
pMarketData->asset_type_id = str_ASSET_ID.Get();
pMarketData->currency_type_id = str_CURRENCY_ID.Get();
// --------------------------------------------
const long & lScale = pMarket->GetScale();
pMarketData->scale = to_string<long>(lScale);
// --------------------------------------------
const uint64_t theCurrentBid = pMarket->GetHighestBidPrice();
const uint64_t theCurrentAsk = pMarket->GetLowestAskPrice();
pMarketData->current_bid = to_string<uint64_t>(theCurrentBid);
pMarketData->current_ask = to_string<uint64_t>(theCurrentAsk);
// ---------------------------------------------
const long & lLastSalePrice = pMarket->GetLastSalePrice();
const long & lTotalAvailableAssets = pMarket->GetTotalAvailableAssets();
pMarketData->total_assets = to_string<long>(lTotalAvailableAssets);
pMarketData->last_sale_price = to_string<long>(lLastSalePrice);
// ---------------------------------------------
const mapOfOffers::size_type theBidCount = pMarket->GetBidCount();
const mapOfOffers::size_type theAskCount = pMarket->GetAskCount();
pMarketData->number_bids = to_string<mapOfOffers::size_type>(theBidCount);
pMarketData->number_asks = to_string<mapOfOffers::size_type>(theAskCount);
// ---------------------------------------------
// In the past 24 hours.
// (I'm not collecting this data yet, (maybe never), so these values aren't set at all.)
//
// pMarketData->volume_trades = ???;
// pMarketData->volume_assets = ???;
// pMarketData->volume_currency = ???;
//
// pMarketData->recent_highest_bid = ???;
// pMarketData->recent_lowest_ask = ???;
// ---------------------------------------------
// *pMarketData is CLONED at this time (I'm still responsible to delete.)
// That's also why I add it here, below: So the data is set right before the cloning occurs.
//
pMarketList->AddMarketData(*pMarketData);
nMarketCount++;
}
// -------------------------------------------------------------
// Now pack the list into strOutput...
if (nMarketCount == 0)
return true; // Success, but the list contains 0 markets.
else if (nMarketCount > 0)
{
OTDB::Storage * pStorage = OTDB::GetDefaultStorage();
OT_ASSERT(NULL != pStorage);
OTDB::OTPacker * pPacker = pStorage->GetPacker(); // No need to check for failure, since this already ASSERTS. No need to cleanup either.
// -----------------------------
OTDB::PackedBuffer * pBuffer = pPacker->Pack(*pMarketList); // Now we PACK our market list.
if (NULL == pBuffer)
{
OTLog::Error("Failed packing pMarketList in OTCron::GetMarketList. \n");
return false;
}
OTCleanup<OTDB::PackedBuffer> theBufferAngel(*pBuffer); // make sure memory is cleaned up.
// --------------------------------------------------------
// Now we need to translate pBuffer into strOutput.
const uint8_t* pUint = static_cast<const uint8_t*>(pBuffer->GetData());
const size_t theSize = pBuffer->GetSize();
if ((theSize > 0) && (NULL != pUint))
{
OTData theData(pUint, theSize);
// This function will base64 ENCODE theData,
// and then Set() that as the string contents.
ascOutput.SetData(theData);
// bool bSuccessSetData = false;
// bSuccessSetData = ascOutput.SetData(theData);
return true;
}
else
OTLog::Error("OTCron::GetMarketList: 0 size, or null return value, while getting raw data from packed buffer.\n");
}
else
OTLog::vError("OTCron::GetMarketList: nMarketCount is less than zero: %d.\n", nMarketCount);
return false;
}