#include "MarketMgr.h"

Inheritance diagram for MarketMgr:

Collaboration diagram for MarketMgr:

Public Member Functions
bool	NeedsUpdate ()

PyRep *	GetMarketGroups ()

Public Member Functions inherited from Singleton< MarketMgr >
	Singleton ()
	Primary constructor. More...

Private Attributes
MarketDB	m_db

PyServiceMgr *	m_manager

PyRep *	m_marketGroups

int64	m_timeStamp

MarketMgr.cpp
singleton object for storing, manipulating and managing in-game market data this mgr keeps track of market data without abusing the db on every call. (vs old system) this mgr will also track mineral pricing, taking monthly averages, then updating base prices accordingly : Allan Date : 19Dec17
	MarketMgr ()

	~MarketMgr ()

int	Initialize (PyServiceMgr *pManager)

void	Close ()

void	GetInfo ()

void	Process ()

void	SystemStartup (SystemData &data)

void	SystemShutdown (SystemData &data)

void	UpdatePriceHistory ()

bool	ExecuteBuyOrder (Client *seller, uint32 orderID, InventoryItemRef iRef, Call_PlaceCharOrder &args, uint16 accountKey=Account::KeyType::Cash)

void	ExecuteSellOrder (Client *buyer, uint32 orderID, Call_PlaceCharOrder &args)

void	SendOnOwnOrderChanged (Client pClient, uint32 orderID, uint8 action, bool isCorp=false, PyRep order=nullptr)

void	InvalidateOrdersCache (uint32 regionID, uint32 typeID)

PyRep *	GetNewPriceHistory (uint32 regionID, uint32 typeID)

PyRep *	GetOldPriceHistory (uint32 regionID, uint32 typeID)

void	SetBasePrice ()

void	UpdateMineralPrice ()

void	GetCruPrices ()

void	Populate ()

Additional Inherited Members
Static Public Member Functions inherited from Singleton< MarketMgr >
static MarketMgr &	get ()

Static Protected Attributes inherited from Singleton< MarketMgr >
static std::shared_ptr< MarketMgr >	mInstance

Detailed Description

Definition at line 23 of file MarketMgr.h.

Constructor & Destructor Documentation

MarketMgr::MarketMgr ( )

Definition at line 34 of file MarketMgr.cpp.

References m_timeStamp.

 : m_marketGroups(nullptr),
 m_manager(nullptr)
 {
     m_timeStamp = 0;
 }

MarketMgr::~MarketMgr ( )

Definition at line 41 of file MarketMgr.cpp.

 {
     //PyDecRef(m_marketGroups);
 }

Member Function Documentation

void MarketMgr::Close ( )

Todo:: put a save method here which will save anything changed before shutdown

Definition at line 46 of file MarketMgr.cpp.

References m_marketGroups, PyDecRef, and sLog.

 {
     PyDecRef(m_marketGroups);
     sLog.Warning("        MarketMgr", "Market Manager has been closed." );
 }

bool MarketMgr::ExecuteBuyOrder	(	Client *	seller,
		uint32	orderID,
		InventoryItemRef	iRef,
		Call_PlaceCharOrder &	args,
		uint16	accountKey = `Account::KeyType::Cash`
	)

Todo:: take off market overhead fees

Definition at line 303 of file MarketMgr.cpp.

References _log, Corp::Role::AccountCanTake1, Corp::Role::AccountCanTake2, Corp::Role::AccountCanTake3, Corp::Role::AccountCanTake4, Corp::Role::AccountCanTake5, Corp::Role::AccountCanTake6, Corp::Role::AccountCanTake7, EvESkill::Accounting, Market::TxData::accountKey, UserError::AddFormatValue(), MarketDB::AlterOrderQuantity(), InventoryItem::AlterQuantity(), Market::Type::Buy, Account::KeyType::Cash, Market::TxData::clientID, Market::QtyStatus::Complete, corpSCC, InventoryItem::Delete(), MarketDB::DeleteOrder(), InventoryItem::Donate(), Account::KeyType::Escrow, Market::Action::Expiry, flagCorpMarket, flagHangar, RefPtr< X >::get(), Client::GetChar(), Client::GetCharacterID(), Client::GetCorporationID(), Client::GetCorpRole(), MarketDB::GetOrderInfo(), MarketDB::GetOrderRow(), Character::GetSkillLevel(), Market::QtyStatus::Invalid, InvalidateOrdersCache(), Market::TxData::isBuy, IsCharacterID, Market::TxData::isCorp, Stat::iskMarket, IsPlayerCorp, IsTraderJoe, InventoryItem::itemID(), m_db, Journal::EntryType::MarketTransaction, Market::TxData::memberID, Market::OrderInfo::memberID, Market::Action::Modify, InventoryItem::name(), Market::QtyStatus::Over, Market::OrderInfo::ownerID, Market::TxData::price, Market::TxData::quantity, InventoryItem::quantity(), Market::OrderInfo::quantity, MarketDB::RecordTransaction(), Market::TxData::regionID, Market::OrderInfo::regionID, EvEMath::Market::SalesTax(), sConfig, sDataMgr, Market::Type::Sell, Client::SendNotifyMsg(), SendOnOwnOrderChanged(), InventoryItem::Split(), sStatMgr, Market::TxData::stationID, stDataMgr, Journal::EntryType::TransactionTax, AccountService::TranserFunds(), Market::TxData::typeID, and Market::QtyStatus::Under.

                                                                                                                                     {
 
     Market::OrderInfo oInfo = Market::OrderInfo();
     if (!m_db.GetOrderInfo(orderID, oInfo)) {
         _log(MARKET__ERROR, "ExecuteBuyOrder - Failed to get order info for #%u.", orderID);
         return true;
     }
 
     /*  will this method also be used to buy/sell using aurm?
      * unknown yet
      */
 
     // get buyer id and determine if buyer is player or corp (or bot for later)
     bool isPlayer(false), isCorp(false), isTrader(false);
     if (IsPlayerCorp(oInfo.ownerID)) {
         // buyer is player corp
         isCorp = true;
     } else if (oInfo.ownerID == 1) {
         oInfo.ownerID = stDataMgr.GetOwnerID(args.stationID);
     } else if (IsCharacterID(oInfo.ownerID)) {
         isPlayer = true;
     } else if (IsTraderJoe(oInfo.ownerID)) {
         isTrader = true;
     } else {
         // none of above conditionals hit....
         _log(MARKET__WARNING, "ExecuteBuyOrder - ownerID %u not corp, not char, not system, not joe.", oInfo.ownerID);
         // send the player some kind of notification about the market order, some standard market error should suffice
         seller->SendNotifyMsg ("Your order cannot be processed at this time, please try again later.");
         return false;
     }
 
     // quantity status of seller's item vs buyer's order
     uint8 qtyStatus(Market::QtyStatus::Invalid);
     if (iRef->quantity() == args.quantity) {
         qtyStatus = Market::QtyStatus::Complete;
         //use the owner change packet to alert the buyer of the new item
         if (isPlayer) {
             iRef->Donate(oInfo.ownerID, args.stationID, flagHangar, true);
         } else if (isCorp) {
             iRef->Donate(oInfo.ownerID, args.stationID, flagCorpMarket, true);
         } else if (isTrader) {
             // trader joe is a placeholder ID to trash every item sold to him
             iRef->Delete ();
         }
     } else if (iRef->quantity() > args.quantity) {
         // qty for sale > buy order amt
         qtyStatus = Market::QtyStatus::Over;
         //need to split item up...
         if (isTrader) {
             // trader joe is a blackhole, just subtract the amount of items we're selling to him and call it a day
             iRef->AlterQuantity(-args.quantity, true);
         } else {
             InventoryItemRef siRef = iRef->Split(args.quantity);
             if (siRef.get() == nullptr) {
                 _log(MARKET__ERROR, "ExecuteBuyOrder - Failed to split %u %s.", siRef->itemID(), siRef->name());
                 return true;
             }
             //use the owner change packet to alert the buyer of the new item
             if (isPlayer) {
                 siRef->Donate(oInfo.ownerID, args.stationID, flagHangar, true);
             } else if (isCorp) {
                 siRef->Donate(oInfo.ownerID, args.stationID, flagCorpMarket, true);
             }
         }
     } else {
         // qty for sale < buy order amt
         qtyStatus = Market::QtyStatus::Under;
         //use the owner change packet to alert the buyer of the new item
         if (isPlayer) {
             iRef->Donate(oInfo.ownerID, args.stationID, flagHangar, true);
         } else if (isCorp) {
             iRef->Donate(oInfo.ownerID, args.stationID, flagCorpMarket, true);
         } else if (isTrader) {
             iRef->Delete ();
         }
     }
 
     uint32 qtySold(args.quantity);
     switch (qtyStatus) {
         case Market::QtyStatus::Invalid: {
             // this should never hit. make error here.
         } break;
         case Market::QtyStatus::Under:  // order requires more items than seller is offering.  delete args.quantity and update order
         case Market::QtyStatus::Complete: { // order qty matches item qty.  delete args.quantity and delete order
             args.quantity = 0;
         } break;
         case Market::QtyStatus::Over: {
             // more for sale than order requires.  update args.quantity and delete order
             args.quantity -= qtySold;
         } break;
     }
 
     float money = args.price * qtySold;
     std::string reason = "DESC:  Buying items in ";
     reason += stDataMgr.GetStationName(args.stationID).c_str();
     uint32 sellerWalletOwnerID = 0;
     uint8 level = seller->GetChar ()->GetSkillLevel (EvESkill::Accounting);
     float tax = EvEMath::Market::SalesTax (sConfig.market.salesTax, level) * money;
 
     if (args.useCorp) {
         // make sure the user has permissions to take money from the corporation account
         if (
                 (accountKey == 1000 && (seller->GetCorpRole () & Corp::Role::AccountCanTake1) == 0) ||
                 (accountKey == 1001 && (seller->GetCorpRole () & Corp::Role::AccountCanTake2) == 0) ||
                 (accountKey == 1002 && (seller->GetCorpRole () & Corp::Role::AccountCanTake3) == 0) ||
                 (accountKey == 1003 && (seller->GetCorpRole () & Corp::Role::AccountCanTake4) == 0) ||
                 (accountKey == 1004 && (seller->GetCorpRole () & Corp::Role::AccountCanTake5) == 0) ||
                 (accountKey == 1005 && (seller->GetCorpRole () & Corp::Role::AccountCanTake6) == 0) ||
                 (accountKey == 1006 && (seller->GetCorpRole () & Corp::Role::AccountCanTake7) == 0)
         )
             throw UserError("CrpAccessDenied").AddFormatValue ("reason", new PyString ("You do not have access to that wallet"));
 
         sellerWalletOwnerID = seller->GetCorporationID ();
         _log(MARKET__DEBUG, "ExecuteBuyOrder - Seller is Corp: Price: %.2f, Tax: %.2f", money, tax);
     } else {
         sellerWalletOwnerID = seller->GetCharacterID ();
         _log(MARKET__DEBUG, "ExecuteBuyOrder - Seller is Player: Price: %.2f, Tax: %.2f", money, tax);
     }
 
     AccountService::TranserFunds (sellerWalletOwnerID, corpSCC, tax, reason.c_str (),
                                    Journal::EntryType::TransactionTax, orderID, accountKey);
 
     // send wallet blink event and record the transaction in their journal.
     reason.clear();
     reason += "DESC:  Selling items in ";
     reason += stDataMgr.GetStationName(args.stationID).c_str();
     // this is fulfilling a buy order.  seller will receive isk from escrow if buyer is player or corp
     if (isPlayer or isCorp) {
         //give the money to the seller from the escrow acct at station
         AccountService::TranserFunds(stDataMgr.GetOwnerID(args.stationID), seller->GetCharacterID(), \
                                 money, reason.c_str(), Journal::EntryType::MarketTransaction, orderID, \
                                 Account::KeyType::Escrow, accountKey);
     } else {
         // npc buyer.  direct xfer to seller
         AccountService::TranserFunds(oInfo.ownerID, seller->GetCharacterID(), money, reason.c_str(), \
                                     Journal::EntryType::MarketTransaction, orderID, Account::KeyType::Cash, accountKey);
     }
 
     // add data to StatisticMgr
     sStatMgr.Add(Stat::iskMarket, money);
 
     //record this sell transaction in market_transactions
     Market::TxData data = Market::TxData();
     data.accountKey     = accountKey;
     data.isBuy          = Market::Type::Sell;
     data.isCorp         = args.useCorp;
     data.memberID       = args.useCorp?seller->GetCharacterID():0;
     data.clientID       = args.useCorp?seller->GetCorporationID():seller->GetCharacterID();
     data.price          = args.price;
     data.quantity       = args.quantity;
     data.stationID      = args.stationID;
     data.regionID       = sDataMgr.GetStationRegion(args.stationID);
     data.typeID         = args.typeID;
 
     if (!m_db.RecordTransaction(data)) {
         _log(MARKET__ERROR, "ExecuteBuyOrder - Failed to record sale side of transaction.");
     }
 
     if (isPlayer or isCorp) {
         // update data for other side if player or player corp
         data.isBuy          = Market::Type::Buy;
         data.clientID       = oInfo.ownerID;
         data.memberID       = isCorp?oInfo.memberID:0;
         if (!m_db.RecordTransaction(data)) {
             _log(MARKET__ERROR, "ExecuteBuyOrder - Failed to record buy side of transaction.");
         }
     }
 
     if (qtyStatus == Market::QtyStatus::Under) {
         uint32 newQty(oInfo.quantity - args.quantity);
         _log(MARKET__TRACE, "ExecuteBuyOrder - Partially satisfied order #%u, altering quantity to %u.", orderID, newQty);
         if (!m_db.AlterOrderQuantity(orderID, newQty)) {
             _log(MARKET__ERROR, "ExecuteBuyOrder - Failed to alter quantity of order #%u.", orderID);
             return true;
         }
         InvalidateOrdersCache(oInfo.regionID, args.typeID);
         if (isPlayer or isCorp)
             SendOnOwnOrderChanged(seller, orderID, Market::Action::Modify, args.useCorp);
 
         return false;
     }
 
     _log(MARKET__TRACE, "ExecuteBuyOrder - Satisfied order #%u, deleting.", orderID);
     PyRep* order = m_db.GetOrderRow(orderID);
     if (!m_db.DeleteOrder(orderID)) {
         _log(MARKET__ERROR, "ExecuteBuyOrder - Failed to delete order #%u.", orderID);
         return true;
     }
     InvalidateOrdersCache(oInfo.regionID, args.typeID);
     if (isPlayer or isCorp)
         SendOnOwnOrderChanged(seller, orderID, Market::Action::Expiry, args.useCorp, order);
     return true;
 }

Here is the call graph for this function:

void MarketMgr::ExecuteSellOrder	(	Client *	buyer,
		uint32	orderID,
		Call_PlaceCharOrder &	args
	)

Todo:: get/implement accountKey here....

Todo:: for corp shit, implement accountKey

Definition at line 497 of file MarketMgr.cpp.

References _log, EvESkill::Accounting, Market::TxData::accountKey, Market::OrderInfo::accountKey, MarketDB::AlterOrderQuantity(), Market::Type::Buy, Account::KeyType::Cash, Market::TxData::clientID, corpSCC, MarketDB::DeleteOrder(), InventoryItem::Donate(), Market::Action::Expiry, flagHangar, flagNone, RefPtr< X >::get(), Client::GetChar(), Client::GetCharacterID(), Client::GetCorporationID(), MarketDB::GetOrderInfo(), MarketDB::GetOrderRow(), CharacterDB::GetSkillLevel(), Character::GetSkillLevel(), InvalidateOrdersCache(), Market::TxData::isBuy, IsCharacterID, Market::TxData::isCorp, Market::OrderInfo::isCorp, Stat::iskMarket, locTemp, m_db, Journal::EntryType::MarketTransaction, Market::TxData::memberID, Market::OrderInfo::memberID, Market::Action::Modify, Market::OrderInfo::ownerID, ownerStation, Market::TxData::price, Market::TxData::quantity, Market::OrderInfo::quantity, MarketDB::RecordTransaction(), Market::TxData::regionID, Market::OrderInfo::regionID, EvEMath::Market::SalesTax(), sConfig, sDataMgr, Market::Type::Sell, SendOnOwnOrderChanged(), sEntityList, sItemFactory, sStatMgr, Market::TxData::stationID, stDataMgr, EvESkill::TaxEvasion, Journal::EntryType::TransactionTax, AccountService::TranserFunds(), and Market::TxData::typeID.

                                                                                          {
     Market::OrderInfo oInfo = Market::OrderInfo();
     if (!m_db.GetOrderInfo(orderID, oInfo)) {
         _log(MARKET__ERROR, "ExecuteSellOrder - Failed to get info about sell order %u.", orderID);
         return;
     }
 
     bool orderConsumed(false);
     if (args.quantity > oInfo.quantity)
         args.quantity = oInfo.quantity;
     if (args.quantity == oInfo.quantity)
         orderConsumed = true;
 
     if (sDataMgr.IsStation(oInfo.ownerID))
         oInfo.ownerID = stDataMgr.GetOwnerID(oInfo.ownerID);
 
     float money = args.price * args.quantity;
     // send wallet blink event and record the transaction in their journal.
     std::string reason = "DESC:  Buying market items in ";
     reason += stDataMgr.GetStationName(args.stationID).c_str();
     // this will throw if funds not available.
     AccountService::TranserFunds(buyer->GetCharacterID(), oInfo.ownerID, money, reason.c_str(), \
                     Journal::EntryType::MarketTransaction, orderID, oInfo.accountKey);
 
     uint32 sellerCharacterID = 0;
 
     if (oInfo.isCorp) {
         sellerCharacterID = oInfo.memberID;
     } else {
         sellerCharacterID = oInfo.ownerID;
     }
 
     uint8 accountingLevel(0);
     uint8 taxEvasionLevel(0);
     Client* pSeller = sEntityList.FindClientByCharID (sellerCharacterID);
 
     if (pSeller == nullptr) {
         accountingLevel = CharacterDB::GetSkillLevel (sellerCharacterID, EvESkill::Accounting);
         taxEvasionLevel = CharacterDB::GetSkillLevel (sellerCharacterID, EvESkill::TaxEvasion);
     } else {
         accountingLevel = pSeller->GetChar ()->GetSkillLevel (EvESkill::Accounting);
         taxEvasionLevel = pSeller->GetChar ()->GetSkillLevel (EvESkill::TaxEvasion);
     }
 
     float tax = EvEMath::Market::SalesTax (sConfig.market.salesTax, accountingLevel, taxEvasionLevel) * money;
     AccountService::TranserFunds (oInfo.ownerID, corpSCC, tax, reason.c_str (),
                                   Journal::EntryType::TransactionTax, orderID, oInfo.accountKey);
     // after money is xferd, create and add item.
     ItemData idata(args.typeID, ownerStation, locTemp, flagNone, args.quantity);
     InventoryItemRef iRef = sItemFactory.SpawnItem(idata);
     if (iRef.get() == nullptr)
         return;
 
     //use the owner change packet to alert the buyer of the new item
     iRef->Donate(buyer->GetCharacterID(), args.stationID, flagHangar, true);
 
     // add data to StatisticMgr
     sStatMgr.Add(Stat::iskMarket, money);
 
     Client* seller(nullptr);
     if (IsCharacterID(oInfo.ownerID))
         seller = sEntityList.FindClientByCharID(oInfo.ownerID);
 
     if (orderConsumed) {
         _log(MARKET__TRACE, "ExecuteSellOrder - satisfied order #%u, deleting.", orderID);
         PyRep* order = m_db.GetOrderRow(orderID);
         if (!m_db.DeleteOrder(orderID)) {
             _log(MARKET__ERROR, "ExecuteSellOrder - Failed to delete order #%u.", orderID);
             return;
         }
         InvalidateOrdersCache(oInfo.regionID, args.typeID);
         SendOnOwnOrderChanged(seller, orderID, Market::Action::Expiry, args.useCorp, order);
     } else {
         uint32 newQty(oInfo.quantity - args.quantity);
         _log(MARKET__TRACE, "ExecuteSellOrder - Partially satisfied order #%u, altering quantity to %u.", orderID, newQty);
         if (!m_db.AlterOrderQuantity(orderID, newQty)) {
             _log(MARKET__ERROR, "ExecuteSellOrder - Failed to alter quantity of order #%u.", orderID);
             return;
         }
         InvalidateOrdersCache(oInfo.regionID, args.typeID);
         SendOnOwnOrderChanged(seller, orderID, Market::Action::Modify, args.useCorp);
     }
 
     //record this transaction in market_transactions
     Market::TxData data = Market::TxData();
     data.accountKey     = Account::KeyType::Cash;       // args.useCorp?accountKey: Account::KeyType::Cash;
     data.isBuy          = Market::Type::Buy;
     data.isCorp         = args.useCorp;
     data.memberID       = args.useCorp?buyer->GetCharacterID():0;
     data.clientID       = args.useCorp?buyer->GetCorporationID():buyer->GetCharacterID();
     data.price          = args.price;
     data.quantity       = args.quantity;
     data.stationID      = args.stationID;
     data.regionID       = sDataMgr.GetStationRegion(args.stationID);
     data.typeID         = args.typeID;
 
     if (!m_db.RecordTransaction(data)) {
         _log(MARKET__ERROR, "ExecuteSellOrder - Failed to record buy side of transaction.");
     }
 
     // update data for other side
     data.accountKey     = Account::KeyType::Cash;       // args.useCorp?accountKey: Account::KeyType::Cash;
     data.isBuy          = Market::Type::Sell;
     data.clientID       = oInfo.ownerID;
     if (!m_db.RecordTransaction(data)) {
         _log(MARKET__ERROR, "ExecuteSellOrder - Failed to record sell side of transaction.");
     }
 }

Here is the call graph for this function:

void MarketMgr::GetCruPrices ( )

Definition at line 916 of file MarketMgr.cpp.

References MarketDB::GetCruPriceAvg(), sDataMgr, sLog, and MarketDB::UpdateInvPrice().

 {
     /*
     std::map<uint16, Market::matlData> materialMap;
     materialMap.clear();
     // dont update minerals...they are set.
     //sDataMgr.GetMineralData(materialMap);       // 8
     sDataMgr.GetSalvageData(materialMap);       // 53
     sDataMgr.GetCompoundData(materialMap);      // 7
     sDataMgr.GetComponentData(materialMap);     // 114
     sDataMgr.GetPIResourceData(materialMap);    // 15
     sDataMgr.GetPICommodityData(materialMap);   // 66
 
     MarketDB::GetCruPriceAvg(materialMap);
 
     MarketDB::UpdateMktPrice(materialMap);
     */
 
     sLog.Warning("     SetBasePrice", "Getting types.");
     std::map<uint16, Inv::TypeData> types;
     sDataMgr.GetTypes(types);           //19669 unique items in type data
     sLog.Green("     SetBasePrice", "GetTypes returned %u items.  Getting price avg.", types.size());
     // delete the typeID '0'
     types.erase(0);
 
     MarketDB::GetCruPriceAvg(types);    //7723 unique items in price data
     sLog.Green("     SetBasePrice", "Got Avg prices.  updating items.");
     MarketDB::UpdateInvPrice(types);    //7712 non-zero prices
     sLog.Cyan("     SetBasePrice", "Completed.");
 }

Here is the call graph for this function:

void MarketMgr::GetInfo ( )

Definition at line 78 of file MarketMgr.cpp.

 {
     /* get info in current market data? */
 }

PyRep* MarketMgr::GetMarketGroups ( )

inline

Definition at line 53 of file MarketMgr.h.

References m_marketGroups, and PyIncRef.

53 { PyIncRef(m_marketGroups); return m_marketGroups; }

MarketMgr::m_marketGroups

PyRep * m_marketGroups

Definition: MarketMgr.h:73

PyIncRef

#define PyIncRef(op)

Definition: PyRep.h:56

PyRep * MarketMgr::GetNewPriceHistory	(	uint32	regionID,
		uint32	typeID
	)

Todo:: this doesnt belong here...

Definition at line 148 of file MarketMgr.cpp.

References _log, DBerror::c_str(), PyServiceMgr::cache_service, EvE::Time::Day, DBResultToCRowset(), PyRep::Dump(), DBQueryResult::error, DBQueryResult::GetRowCount(), ObjCacheService::GiveCache(), is_log_enabled, ObjCacheService::IsCacheLoaded(), m_manager, m_timeStamp, ObjCacheService::MakeObjectCachedMethodCallResult(), PyStatic, sConfig, and sDatabase.

                                                                    {
     PyRep* result(nullptr);
     std::string method_name ("GetNewHistory_");
     method_name += std::to_string(regionID);
     method_name += "_";
     method_name += std::to_string(typeID);
     ObjectCachedMethodID method_id("marketProxy", method_name.c_str());
     //check to see if this method is in the cache already.
     if (!m_manager->cache_service->IsCacheLoaded(method_id)) {
         //this method is not in cache yet, load up the contents and cache it
         DBQueryResult res;
 
         if(!sDatabase.RunQuery(res,
             "SELECT historyDate, lowPrice, highPrice, avgPrice, volume, orders"
             " FROM mktHistory "
             " WHERE regionID=%u AND typeID=%u"
             " AND historyDate > %li  LIMIT %u",
             regionID, typeID, (m_timeStamp - EvE::Time::Day), sConfig.market.NewPriceLimit))
         {
             _log(DATABASE__ERROR, "Error in query: %s", res.error.c_str());
             return nullptr;
         }
         _log(MARKET__DB_TRACE, "MarketMgr::GetNewPriceHistory() - Fetched %u buy orders for type %u in region %u from mktTransactions", res.GetRowCount(), typeID, regionID);
 
         result = DBResultToCRowset(res);
         if (result == nullptr) {
             _log(MARKET__DB_ERROR, "Failed to load cache, generating empty contents.");
             result = PyStatic.NewNone();
         }
         m_manager->cache_service->GiveCache(method_id, &result);
     }
 
     //now we know its in the cache one way or the other, so build a
     //cached object cached method call result.
     result = m_manager->cache_service->MakeObjectCachedMethodCallResult(method_id);
 
     if (is_log_enabled(MARKET__DB_TRACE))
         result->Dump(MARKET__DB_TRACE, "    ");
     return result;
 }

Here is the call graph for this function:

PyRep * MarketMgr::GetOldPriceHistory	(	uint32	regionID,
		uint32	typeID
	)

Todo:: this doesnt belong here...

Definition at line 190 of file MarketMgr.cpp.

References _log, DBerror::c_str(), PyServiceMgr::cache_service, EvE::Time::Day, DBResultToCRowset(), PyRep::Dump(), DBQueryResult::error, DBQueryResult::GetRowCount(), ObjCacheService::GiveCache(), is_log_enabled, ObjCacheService::IsCacheLoaded(), m_manager, m_timeStamp, ObjCacheService::MakeObjectCachedMethodCallResult(), PyStatic, sConfig, and sDatabase.

                                                                    {
     PyRep* result(nullptr);
     std::string method_name ("GetOldHistory_");
     method_name += std::to_string(regionID);
     method_name += "_";
     method_name += std::to_string(typeID);
     ObjectCachedMethodID method_id("marketProxy", method_name.c_str());
     //check to see if this method is in the cache already.
     if (!m_manager->cache_service->IsCacheLoaded(method_id)) {
         //this method is not in cache yet, load up the contents and cache it
         DBQueryResult res;
 
         if(!sDatabase.RunQuery(res,
             "SELECT historyDate, lowPrice, highPrice, avgPrice, volume, orders"
             " FROM mktHistory WHERE regionID=%u AND typeID=%u"
             " AND historyDate > %li AND historyDate < %li LIMIT %u",
             regionID, typeID, (m_timeStamp - (EvE::Time::Day *3)), (m_timeStamp - EvE::Time::Day), sConfig.market.OldPriceLimit))
         {
             _log(DATABASE__ERROR, "Error in query: %s", res.error.c_str());
             return nullptr;
         }
         _log(MARKET__DB_TRACE, "MarketMgr::GetOldPriceHistory() - Fetched %u orders for type %u in region %u from mktHistory", res.GetRowCount(), typeID, regionID);
 
         result = DBResultToCRowset(res);
         if (result == nullptr) {
             _log(MARKET__DB_ERROR, "Failed to load cache, generating empty contents.");
             result = PyStatic.NewNone();
         }
         m_manager->cache_service->GiveCache(method_id, &result);
     }
 
     //now we know its in the cache one way or the other, so build a
     //cached object cached method call result.
     result = m_manager->cache_service->MakeObjectCachedMethodCallResult(method_id);
 
     if (is_log_enabled(MARKET__DB_TRACE))
         result->Dump(MARKET__DB_TRACE, "    ");
     return result;
 }

Here is the call graph for this function:

int MarketMgr::Initialize ( PyServiceMgr * pManager )

Definition at line 53 of file MarketMgr.cpp.

References MarketDB::GetUpdateTime(), m_manager, m_timeStamp, Populate(), and sLog.

 {
     m_manager = pManager;
 
     m_timeStamp = MarketDB::GetUpdateTime();
 
     Populate();
     sLog.Blue("        MarketMgr", "Market Manager Initialized.");
     return 1;
 }

Here is the call graph for this function:

void MarketMgr::InvalidateOrdersCache	(	uint32	regionID,
		uint32	typeID
	)

Definition at line 264 of file MarketMgr.cpp.

References PyServiceMgr::cache_service, ObjCacheService::InvalidateCache(), and m_manager.

Referenced by ExecuteBuyOrder(), and ExecuteSellOrder().

 {
     std::string method_name ("GetOrders_");
     method_name += std::to_string(regionID);
     method_name += "_";
     method_name += std::to_string(typeID);
     ObjectCachedMethodID method_id("marketProxy", method_name.c_str());
     m_manager->cache_service->InvalidateCache( method_id );
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool MarketMgr::NeedsUpdate ( )

inline

Definition at line 51 of file MarketMgr.h.

References GetFileTimeNow(), and m_timeStamp.

51 { return m_timeStamp > GetFileTimeNow()?false:true; }

GetFileTimeNow

double GetFileTimeNow()

Definition: utils_time.cpp:84

MarketMgr::m_timeStamp

int64 m_timeStamp

Definition: MarketMgr.h:75

Here is the call graph for this function:

void MarketMgr::Populate ( )

protected

Definition at line 64 of file MarketMgr.cpp.

References MarketDB::GetMarketGroups(), GetTimeMSeconds(), m_db, m_marketGroups, Process(), sConfig, and sLog.

Referenced by Initialize().

 {
     double start = GetTimeMSeconds();
     m_marketGroups = m_db.GetMarketGroups();
 
     Process();
 
     // market orders stored as {regionID/typeID}    --do we want to store orders in memory for loaded region??
     // m_db.GetOrders(call.client->GetRegionID(), args.arg);
 
     sLog.Blue("        MarketMgr", "Market Manager loaded in %.3fms.", (GetTimeMSeconds() - start));
     sLog.Cyan("        MarketMgr", "Market Manager Updates Price History every %u hours.", sConfig.market.HistoryUpdateTime);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void MarketMgr::Process ( )

Definition at line 83 of file MarketMgr.cpp.

Referenced by Populate().

 {
     // make cache timer of xx(time) then invalidate the price history cache
 
     //if (m_timeStamp > GetFileTimeNow())
     //    UpdatePriceHistory();
 }

Here is the caller graph for this function:

void MarketMgr::SendOnOwnOrderChanged	(	Client *	pClient,
		uint32	orderID,
		uint8	action,
		bool	isCorp = `false`,
		PyRep *	order = `nullptr`
	)

Definition at line 231 of file MarketMgr.cpp.

References Market::Action::Add, Market::Action::Expiry, Client::GetCorporationID(), MarketDB::GetOrderRow(), m_db, Market::Action::Modify, Client::SendNotification(), and sEntityList.

Referenced by ExecuteBuyOrder(), and ExecuteSellOrder().

                                                                                                                 {
     if (pClient == nullptr)
         return;
     Notify_OnOwnOrderChanged ooc;
     if (order != nullptr) {
         ooc.order = order;
     } else {
         ooc.order = m_db.GetOrderRow(orderID);
     }
 
     switch (action) {
         case Market::Action::Add:
             ooc.reason = "Add";
             break;
         case Market::Action::Modify:
             ooc.reason = "Modify";
             break;
         case Market::Action::Expiry:
             ooc.reason = "Expiry";
             break;
     }
 
     ooc.isCorp = isCorp;
     PyTuple* tmp = ooc.Encode();
     // send journal blink and call 'self.RefreshOrders()' in client
     if (isCorp) {
         sEntityList.CorpNotify(pClient->GetCorporationID(), 125 /*MarketOrder*/, "OnOwnOrderChanged", "*corpid&corprole", tmp);
     } else {
         pClient->SendNotification("OnOwnOrderChanged", "clientID", &tmp);
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void MarketMgr::SetBasePrice ( )

Definition at line 610 of file MarketMgr.cpp.

 {
     /* method to estimate item base price, based on materials to manufacture that item
      *
      * mineral prices are queried from db with a +10% markup
      *
      * ships and modules are loaded and queried from static data for manufacturing materials
      * those materials are queried (as required) for minerals needed
      * once a total mineral value has been calculated, calculate estimated cost based on
      * current mineral values
      *
      * final prices will have markup based on item type
      *
      *
      * NOTES FOR IMPLEMETING THIS SHIT
      *
      *        //SELECT typeID, materialTypeID, quantity FROM invTypeMaterials
      *        EvERam::RamMaterials ramMatls = EvERam::RamMaterials();
      *        ramMatls.quantity       = row.GetInt(2);
      *        ramMatls.materialTypeID = row.GetInt(1);
      *
      * eventually, this will query all items that can be manufactured from BP or refined into minerals
      *
      */
 
     //  get mineral prices and put into data map
     // typeID/data{typeID, price, name}
     std::map<uint16, Market::matlData> mineralMap;
     mineralMap.clear();
     sDataMgr.GetMineralData(mineralMap);        // 8
 
     // this will have to use db to get current data.
     //  mineral prices are (will be) updated via a 'price average' method yet to be written
     MarketDB::GetMineralPrices(mineralMap);
 
 
     // get 'building blocks' used for cap ships and put into data map
     //block typeID/vector<data{materialTypeID, qty}>
     std::map<uint16, Market::matlData> materialMap;
     materialMap.clear();
     sDataMgr.GetComponentData(materialMap);         // 125
 
     // get compounds from ice and put into data map
     sDataMgr.GetCompoundData(materialMap);         // 7
 
     // get misc commodities and put into data map
     sDataMgr.GetMiscCommodityData(materialMap);         // 456
 
     // get salvage items for rigs and other items made from them
     sDataMgr.GetSalvageData(materialMap);         // 53
 
     // get PI resources
     sDataMgr.GetPIResourceData(materialMap);         // 15
 
     // get PI commodities
     sDataMgr.GetPICommodityData(materialMap);         // 66
 
     // hack to add this item to materialMap, instead of getting entire group
     //  22175 is Codebreaker I, which is a reproc item from Purloined Sansha Codebreaker.
     Market::matlData data = Market::matlData();
     data.typeID = 22175;
     data.name = "Codebreaker I";
     materialMap[22175] = data;
 
     // this will have to use db to get current data.
     //  mineral prices are (will be) updated via a 'price average' method yet to be written
     MarketDB::GetMaterialPrices(materialMap);
 
     // add minerals to material maps
     materialMap.insert(mineralMap.begin(), mineralMap.end());
     //sDataMgr.GetMineralData(materialMap);        // 8
 
 
     // item typeID/data{inventory data}
     std::map<uint16, Inv::TypeData> itemMap;
     itemMap.clear();
     // this gets only ships
     //MarketDB::GetShipIDs(itemMap);
     // this gets all items made from minerals either directly or indirectly
     MarketDB::GetManufacturedItems(itemMap);
 
     //item typeID/vector<data{materialTypeID, qty}>
     std::map<uint16, std::vector<EvERam::RamMaterials>> itemMatMap;
     itemMatMap.clear();
     std::map<uint16, Inv::TypeData>::iterator itemItr = itemMap.begin();
     for (; itemItr != itemMap.end(); ++itemItr) {
         // pull data for this item  -need r/w iterator to work
         sDataMgr.GetType(itemItr->first, itemItr->second);
 
         // get materials required for this item
         std::vector<EvERam::RamMaterials> matVec;
         matVec.clear();
         sDataMgr.GetRamMaterials(itemItr->first, matVec);
         itemMatMap[itemItr->first] = matVec;
     }
 
 
     // estimate price of item based on mineral requirements
     bool found(true);
     uint8 mLevel(0);
     double current(0);
     Inv::GrpData gData = Inv::GrpData();
     EvERam::bpTypeData bpData = EvERam::bpTypeData();
     // item typeID/data{inventory data}
     std::map<uint16, Inv::TypeData> missingItemMap;
     missingItemMap.clear();
     std::map<uint16, Market::matlData>::iterator materialItr = materialMap.begin();
     std::map<uint16, std::vector<EvERam::RamMaterials>>::iterator itemMatItr = itemMatMap.end();
     for (itemItr = itemMap.begin(); itemItr != itemMap.end(); ++itemItr) {
         itemMatItr = itemMatMap.find(itemItr->first);
         if (itemMatItr == itemMatMap.end())
             continue;
 
         found = true;
         current = itemItr->second.basePrice;
         // reset basePrice
         itemItr->second.basePrice = 0.0;
         // sum mineral counts with current prices for this ship
         for (auto cur2 : itemMatItr->second) {
             materialItr = materialMap.find(cur2.materialTypeID);
             if (materialItr == materialMap.end()) {
                 sLog.Error("     SetBasePrice", "resource %u for %s(%u) not found in materialMap", \
                         cur2.materialTypeID, itemItr->second.name.c_str(), itemItr->first);
                 missingItemMap[itemItr->first] = Inv::TypeData();
                 found = false;
                 continue;
             }
             itemItr->second.basePrice += (materialItr->second.price * cur2.quantity);
         }
         if (!found)
             continue;
 
         // add manuf costs to base price
         // currently uses production time to add cost at line rental default of 1k install and 2500/hr
         if (sDataMgr.GetBpDataForItem(itemItr->first, bpData)) {
             itemItr->second.basePrice += 1000 + (2500 * (bpData.productionTime / 3600));  // time is in seconds
         }
 
         mLevel = itemItr->second.metaLvl;
         gData = Inv::GrpData();
         sDataMgr.GetGroup(itemItr->second.groupID, gData);
 
         // apply modifier to base price according to item category (complexity, rarity, demand)
         // these should also be adjusted for portion size
         switch (gData.catID) {
             case EVEDB::invCategories::Drone:{
                 itemItr->second.basePrice /= itemItr->second.portionSize;
                 // modify price based on meta
                 switch (mLevel) {
                     case 0: {   //basic
                         itemItr->second.basePrice *= 2;
                     } break;
                     case 1: {   //t1
                         itemItr->second.basePrice *= 2.5;
                     } break;
                     case 2: {   //t2
                         itemItr->second.basePrice *= 3.5;
                     } break;
                 }
             } break;
             case EVEDB::invCategories::Celestial:
             case EVEDB::invCategories::Entity:
             case EVEDB::invCategories::Commodity:
             case EVEDB::invCategories::Material:
             case EVEDB::invCategories::Charge:{
                 if (mLevel)
                     itemItr->second.basePrice *= mLevel;
                 itemItr->second.basePrice /= itemItr->second.portionSize;
             } break;
             case EVEDB::invCategories::Asteroid: {
                 if (mLevel)
                     itemItr->second.basePrice *= mLevel;
                 // asteroids cannot be 'created' per se, but the mined ore can be sold.
                 //  this cat covers mined ore, so use same pricing method as charges
                 if (itemItr->first < 28000)
                     itemItr->second.basePrice /= itemItr->second.portionSize;
             } break;
             case EVEDB::invCategories::Module: {
                 itemItr->second.basePrice *= 2;
                 // multiply price by metaLvl
                 if (mLevel) {
                     switch (gData.id) {
                         case EVEDB::invGroups::Rig_Mining:
                         case EVEDB::invGroups::Rig_Armor:
                         case EVEDB::invGroups::Rig_Shield:
                         case EVEDB::invGroups::Rig_Energy_Weapon:
                         case EVEDB::invGroups::Rig_Hybrid_Weapon:
                         case EVEDB::invGroups::Rig_Projectile_Weapon:
                         case EVEDB::invGroups::Rig_Drones:
                         case EVEDB::invGroups::Rig_Launcher:
                         case EVEDB::invGroups::Rig_Electronics:
                         case EVEDB::invGroups::Rig_Energy_Grid:
                         case EVEDB::invGroups::Rig_Astronautic:
                         case EVEDB::invGroups::Rig_Electronics_Superiority:
                         case EVEDB::invGroups::Rig_Security_Transponder:  {
                             itemItr->second.basePrice *= (mLevel + 1);
                         } break;
                         default: {
                             itemItr->second.basePrice *= (mLevel + 10);
                         } break;
                     }
                 }
             } break;
             case EVEDB::invCategories::Ship: {
                 // multiply price by metaLvl
                 if (mLevel)
                     itemItr->second.basePrice *= mLevel;
                 // modify price based on class
                 switch (gData.id) {
                     case EVEDB::invGroups::Frigate:
                     case EVEDB::invGroups::Destroyer:
                     case EVEDB::invGroups::Rookieship:
                     case EVEDB::invGroups::Industrial: {
                         itemItr->second.basePrice *= 2.1;       // +80%
                     } break;
                     case EVEDB::invGroups::CovertOps: {
                         itemItr->second.basePrice *= 1.2;       // +20%
                     } break;
                     case EVEDB::invGroups::Capsule:
                     case EVEDB::invGroups::Cruiser:
                     case EVEDB::invGroups::Freighter:
                     case EVEDB::invGroups::Battleship:
                     case EVEDB::invGroups::Battlecruiser:
                     case EVEDB::invGroups::Interdictor:
                     case EVEDB::invGroups::Interceptor:
                     case EVEDB::invGroups::HeavyInterdictors:
                     case EVEDB::invGroups::IndustrialCommandShip:
                     case EVEDB::invGroups::ElecAttackShip:
                     case EVEDB::invGroups::Supercarrier:
                     case EVEDB::invGroups::StrategicCruiser: {
                         itemItr->second.basePrice *= 1.1;       // +10%
                     } break;
                     // these are good...
                     case EVEDB::invGroups::Carrier:
                     case EVEDB::invGroups::MiningBarge:
                     case EVEDB::invGroups::StealthBomber:
                     case EVEDB::invGroups::CapitalIndustrialShip: {
                         itemItr->second.basePrice *= 1.5;       // +50%
                     } break;
                     case EVEDB::invGroups::Exhumer:
                     case EVEDB::invGroups::Logistics:
                     case EVEDB::invGroups::Marauder:
                     case EVEDB::invGroups::BlackOps:
                     case EVEDB::invGroups::CombatRecon:
                     case EVEDB::invGroups::AssaultShip:
                     case EVEDB::invGroups::TransportShip:
                     case EVEDB::invGroups::HeavyAssaultShip:
                     // these can only be crated in pos.
                     case EVEDB::invGroups::Titan:
                     case EVEDB::invGroups::Dreadnought:
                     case EVEDB::invGroups::CommandShip: {
                         itemItr->second.basePrice *= 0.6;       // -40%  these are all outrageous at calculated prices
                     } break;
                     case EVEDB::invGroups::JumpFreighter:  {
                         itemItr->second.basePrice *= 0.35;        // this one is weird...
                     } break;
                     case EVEDB::invGroups::Shuttle: {
                         itemItr->second.basePrice *= 3;        // x3 for shuttles
                     } break;
                     case EVEDB::invGroups::Prototype_Exploration_Ship:
                     case EVEDB::invGroups::EliteBattleship: {
                         itemItr->second.basePrice *= 1000;        // x1000
                     } break;
                 }
             } break;
             case EVEDB::invCategories::Station: {
                 // for some reason, station pricing is way off....
                 itemItr->second.basePrice *= 100;
             } break;
         }
 
         if (itemItr->second.basePrice < 0.01) {
             sLog.Error("     SetBasePrice", "Calculated price for %s(%u) is 0", \
                     itemItr->second.name.c_str(), itemItr->first);
         } /*else {
             sLog.Blue("     SetBasePrice", "Calculated price for %u %s(cat:%u - %s - meta %u) from %.2f to %.2f", \
                     itemItr->first, itemItr->second.name.c_str(), gData.catID, gData.name.c_str(), \
                     itemItr->second.metaLvl, current, itemItr->second.basePrice);
         }*/
     }
 
     // check for missing items and get average price using crucible mkt data table
     if (missingItemMap.empty()) {
         // update db for 'new' base price
         MarketDB::UpdateInvPrice(itemMap);
     } else {
         MarketDB::GetCruPriceAvg(missingItemMap);
         MarketDB::UpdateInvPrice(missingItemMap);
         sLog.Error("     SetBasePrice", "Missing material.  run again.");
     }
 }

Here is the call graph for this function:

void MarketMgr::SystemShutdown ( SystemData & data )

Definition at line 96 of file MarketMgr.cpp.

 {
 
 }

void MarketMgr::SystemStartup ( SystemData & data )

Definition at line 91 of file MarketMgr.cpp.

 {
 
 }

void MarketMgr::UpdateMineralPrice ( )

Definition at line 903 of file MarketMgr.cpp.

References sDataMgr, and MarketDB::UpdateMktPrice().

 {
     //  get mineral prices and put into data map
     // typeID/data{typeID, price, name}
     std::map<uint16, Market::matlData> mineralMap;
     mineralMap.clear();
     sDataMgr.GetMineralData(mineralMap);        // 8
 
     //  update mineral price
     MarketDB::UpdateMktPrice(mineralMap);
 
 }

Here is the call graph for this function:

void MarketMgr::UpdatePriceHistory ( )

Todo:: this doesnt belong here...

Todo:: this doesnt belong here...

Definition at line 101 of file MarketMgr.cpp.

References EvE::Time::Day, GetFileTimeNow(), EvE::Time::Hour, m_timeStamp, sConfig, sDatabase, Market::Type::Sell, MarketDB::SetUpdateTime(), and EvE::Time::Year.

 {
     m_timeStamp = GetFileTimeNow() + (EvE::Time::Hour * sConfig.market.HistoryUpdateTime);
     MarketDB::SetUpdateTime(m_timeStamp);
 
     DBerror err;
     int64 cutoff_time = m_timeStamp;
     cutoff_time -= cutoff_time % EvE::Time::Day;    //round down to an even day boundary.
     cutoff_time -= EvE::Time::Day * 2;  //the cutoff between "new" and "old" price history in days
 
     //build the history record from the recent market transactions.
     sDatabase.RunQuery(err,
             "INSERT INTO"
             "    mktHistory"
             "     (regionID, typeID, historyDate, lowPrice, highPrice, avgPrice, volume, orders)"
             " SELECT"
             "    regionID,"
             "    typeID,"
             "    transactionDate,"
             "    MIN(price),"
             "    MAX(price),"
             "    AVG(price),"
             "    SUM(quantity),"
             "    COUNT(transactionID)"
             " FROM mktTransactions"
             " WHERE transactionType=%u AND transactionDate < %li",
             //" GROUP BY regionID, typeID, transactionDate",
             Market::Type::Sell, cutoff_time);
 
     // remove the transactions which have been aged out?
     if (sConfig.market.DeleteOldTransactions)
         sDatabase.RunQuery(err, "DELETE FROM mktTransactions WHERE transactionDate < %li", (cutoff_time - EvE::Time::Year));
 }