#include <OTCron.hpp>

Inheritance diagram for opentxs::OTCron:

Collaboration diagram for opentxs::OTCron:

Public Member Functions
bool	IsActivated () const

bool	ActivateCron ()

EXPORT bool	AddCronItem (OTCronItem &theItem, OTPseudonym *pActivator, bool bSaveReceipt, time64_t tDateAdded)

EXPORT bool	RemoveCronItem (int64_t lTransactionNum, OTPseudonym &theRemover)

EXPORT OTCronItem *	GetItemByOfficialNum (int64_t lTransactionNum)

EXPORT OTCronItem *	GetItemByValidOpeningNum (int64_t lOpeningNum)

EXPORT mapOfCronItems::iterator	FindItemOnMap (int64_t lTransactionNum)

EXPORT multimapOfCronItems::iterator	FindItemOnMultimap (int64_t lTransactionNum)

bool	AddMarket (OTMarket &theMarket, bool bSaveMarketFile=true)

bool	RemoveMarket (const OTIdentifier &MARKET_ID)

EXPORT OTMarket *	GetMarket (const OTIdentifier &MARKET_ID)

OTMarket *	GetOrCreateMarket (const OTIdentifier &ASSET_ID, const OTIdentifier &CURRENCY_ID, const int64_t &lScale)

EXPORT bool	GetMarketList (OTASCIIArmor &ascOutput, int32_t &nMarketCount)

EXPORT bool	GetNym_OfferList (OTASCIIArmor &ascOutput, const OTIdentifier &NYM_ID, int32_t &nOfferCount)

EXPORT void	AddTransactionNumber (const int64_t &lTransactionNum)

int64_t	GetNextTransactionNumber ()

EXPORT int32_t	GetTransactionCount () const

EXPORT void	ProcessCronItems ()

void	SetServerID (const OTIdentifier &SERVER_ID)

const OTIdentifier &	GetServerID () const

void	SetServerNym (OTPseudonym *pServerNym)

OTPseudonym *	GetServerNym () const

EXPORT bool	LoadCron ()

EXPORT bool	SaveCron ()

EXPORT	OTCron ()

	OTCron (const OTIdentifier &SERVER_ID)

	OTCron (const char *szFilename)

virtual EXPORT	~OTCron ()

void	InitCron ()

virtual void	Release ()

void	Release_Cron ()

virtual int32_t	ProcessXMLNode (irr::io::IrrXMLReader *&xml)

virtual void	UpdateContents ()

virtual bool	SaveContractWallet (std::ofstream &ofs) const

Public Member Functions inherited from opentxs::OTContract
const char *	GetHashType () const

void	SetIdentifier (const OTIdentifier &theID)

EXPORT	OTContract ()

EXPORT	OTContract (const OTString &name, const OTString &foldername, const OTString &filename, const OTString &strID)

EXPORT	OTContract (const OTString &strID)

EXPORT	OTContract (const OTIdentifier &theID)

void	Initialize ()

virtual EXPORT	~OTContract ()

EXPORT void	Release_Contract ()

EXPORT void	ReleaseSignatures ()

virtual EXPORT bool	CreateContract (const OTString &strContract, const OTPseudonym &theSigner)

EXPORT bool	InsertNym (const OTString &strKeyName, const OTString &strKeyValue)

EXPORT void	GetName (OTString &strName) const

EXPORT void	SetName (const OTString &strName)

virtual EXPORT bool	VerifyContract ()

virtual EXPORT void	GetIdentifier (OTIdentifier &theIdentifier) const

virtual EXPORT void	GetIdentifier (OTString &theIdentifier) const

EXPORT void	GetFilename (OTString &strFilename) const

EXPORT void	GetFoldername (OTString &strFoldername) const

virtual EXPORT bool	LoadContract ()

EXPORT bool	LoadContract (const char szFoldername, const char szFilename)

EXPORT bool	LoadContractFromString (const OTString &theStr)

bool	LoadContractRawFile ()

EXPORT bool	ParseRawFile ()

EXPORT bool	SaveToContractFolder ()

EXPORT bool	SaveContractRaw (OTString &strOutput) const

EXPORT bool	RewriteContract (OTString &strOutput) const

EXPORT bool	SaveContract ()

EXPORT bool	SaveContract (const char szFoldername, const char szFilename)

virtual EXPORT void	CreateContents ()

EXPORT void	CreateInnerContents ()

virtual EXPORT bool	SaveContents (std::ofstream &ofs) const

virtual EXPORT bool	SaveContractWallet (OTString &strContents) const

virtual EXPORT bool	DisplayStatistics (OTString &strContents) const

virtual EXPORT bool	SaveContents (OTString &strContents) const

virtual EXPORT bool	SignContract (const OTPseudonym &theNym, const OTPasswordData *pPWData=nullptr)

EXPORT bool	SignContractAuthent (const OTPseudonym &theNym, const OTPasswordData *pPWData=nullptr)

EXPORT bool	SignWithKey (const OTAsymmetricKey &theKey, const OTPasswordData *pPWData=nullptr)

EXPORT bool	SignContract (const OTPseudonym &theNym, OTSignature &theSignature, const OTPasswordData *pPWData=nullptr)

EXPORT bool	SignContractAuthent (const OTPseudonym &theNym, OTSignature &theSignature, const OTPasswordData *pPWData=nullptr)

EXPORT bool	SignContract (const OTAsymmetricKey &theKey, OTSignature &theSignature, const OTString &strHashType, const OTPasswordData *pPWData=nullptr)

EXPORT bool	SignContract (const char szFoldername, const char szFilename, OTSignature &theSignature, const OTPasswordData *pPWData=nullptr)

virtual EXPORT bool	VerifyContractID () const

virtual EXPORT void	CalculateContractID (OTIdentifier &newID) const

virtual EXPORT bool	VerifySignature (const OTPseudonym &theNym, const OTPasswordData *pPWData=nullptr) const

virtual EXPORT bool	VerifySigAuthent (const OTPseudonym &theNym, const OTPasswordData *pPWData=nullptr) const

EXPORT bool	VerifyWithKey (const OTAsymmetricKey &theKey, const OTPasswordData *pPWData=nullptr) const

EXPORT bool	VerifySignature (const OTPseudonym &theNym, const OTSignature &theSignature, const OTPasswordData *pPWData=nullptr) const

EXPORT bool	VerifySigAuthent (const OTPseudonym &theNym, const OTSignature &theSignature, const OTPasswordData *pPWData=nullptr) const

EXPORT bool	VerifySignature (const OTAsymmetricKey &theKey, const OTSignature &theSignature, const OTString &strHashType, const OTPasswordData *pPWData=nullptr) const

EXPORT bool	VerifySignature (const char szFoldername, const char szFilename, const OTSignature &theSignature, const OTPasswordData *pPWData=nullptr) const

EXPORT const OTAsymmetricKey *	GetContractPublicKey () const

EXPORT const OTPseudonym *	GetContractPublicNym () const

Static Public Member Functions
static int32_t	GetCronMsBetweenProcess ()

static void	SetCronMsBetweenProcess (int32_t lMS)

static int32_t	GetCronRefillAmount ()

static void	SetCronRefillAmount (int32_t nAmount)

static int32_t	GetCronMaxItemsPerNym ()

static void	SetCronMaxItemsPerNym (int32_t nMax)

Static Public Member Functions inherited from opentxs::OTContract
static EXPORT bool	DearmorAndTrim (const OTString &strInput, OTString &strOutput, OTString &strFirstLine)

static bool	AddBookendsAroundContent (OTString &strOutput, const OTString &strContents, const OTString &strContractType, const OTString &strHashType, const listOfSignatures &listSignatures)

static EXPORT bool	LoadEncodedTextField (irr::io::IrrXMLReader *&xml, OTASCIIArmor &ascOutput)

static EXPORT bool	LoadEncodedTextField (irr::io::IrrXMLReader *&xml, OTString &strOutput)

static bool	LoadEncodedTextFieldByName (irr::io::IrrXMLReader &xml, OTASCIIArmor &ascOutput, const char &szName, OTString::Map *pmapExtraVars=nullptr)

static bool	LoadEncodedTextFieldByName (irr::io::IrrXMLReader &xml, OTString &strOutput, const char &szName, OTString::Map *pmapExtraVars=nullptr)

static bool	SkipToElement (irr::io::IrrXMLReader *&xml)

static bool	SkipToTextField (irr::io::IrrXMLReader *&xml)

static bool	SkipAfterLoadingField (irr::io::IrrXMLReader *&xml)

static EXPORT bool	SignFlatText (OTString &strFlatText, const OTString &strContractType, const OTPseudonym &theSigner, OTString &strOutput)

Additional Inherited Members
Protected Member Functions inherited from opentxs::OTContract
bool	LoadContractXML ()

Protected Attributes inherited from opentxs::OTContract
OTString	m_strName

OTString	m_strFoldername

OTString	m_strFilename

OTIdentifier	m_ID

OTStringXML	m_xmlUnsigned

OTString	m_strRawFile

OTString	m_strSigHashType

OTString	m_strContractType

mapOfNyms	m_mapNyms

listOfSignatures	m_listSignatures

OTString	m_strVersion

OTString	m_strEntityShortName

OTString	m_strEntityLongName

OTString	m_strEntityEmail

OTString::Map	m_mapConditions

Detailed Description

Definition at line 164 of file OTCron.hpp.

Constructor & Destructor Documentation

opentxs::OTCron::OTCron ( )

Definition at line 1141 of file OTCron.cpp.

     : ot_super()
     , m_bIsActivated(false)
     , m_pServerNym(nullptr) // just here for convenience, not responsible to
                             // cleanup this pointer.
 {
     InitCron();
     otLog3 << "OTCron::OTCron: Finished calling InitCron 0.\n";
 }

opentxs::OTCron::OTCron ( const OTIdentifier & SERVER_ID )

Definition at line 1151 of file OTCron.cpp.

     : ot_super()
     , m_bIsActivated(false)
     , m_pServerNym(nullptr) // just here for convenience, not responsible to
                             // cleanup this pointer.
 {
     InitCron();
     SetServerID(SERVER_ID);
     otLog3 << "OTCron::OTCron: Finished calling InitCron 1.\n";
 }

opentxs::OTCron::OTCron ( const char * szFilename )

Definition at line 1162 of file OTCron.cpp.

     : ot_super()
     , m_bIsActivated(false)
     , m_pServerNym(nullptr) // just here for convenience, not responsible to
                             // cleanup this pointer.
 {
     OT_ASSERT(nullptr != szFilename);
     InitCron();
 
     m_strFoldername.Set(OTFolders::Cron().Get());
     m_strFilename.Set(szFilename);
     otLog3 << "OTCron::OTCron: Finished calling InitCron 2.\n";
 }

opentxs::OTCron::~OTCron ( )

virtual

Definition at line 1176 of file OTCron.cpp.

 {
     Release_Cron();
 
     m_pServerNym = nullptr;
 }

Member Function Documentation

bool opentxs::OTCron::ActivateCron ( )

inline

Definition at line 225 of file OTCron.hpp.

     {
         if (!m_bIsActivated)
             return m_bIsActivated = true;
         else
             return false;
     }

bool opentxs::OTCron::AddCronItem	(	OTCronItem &	theItem,
		OTPseudonym *	pActivator,
		bool	bSaveReceipt,
		time64_t	tDateAdded
	)

Definition at line 731 of file OTCron.cpp.

 {
     OT_ASSERT(nullptr != GetServerNym());
 
     // See if there's something else already there with the same transaction
     // number.
     OTCronItem* pCronItem = GetItemByOfficialNum(theItem.GetTransactionNum());
 
     // If it's not already on the list, then add it...
     if (nullptr == pCronItem) {
         // If I've been instructed to save the receipt, and theItem did NOT
         // successfully save the receipt,
         // then return false.
         //
         // This will happen if filesystem problems, but it will also happen if
         // the cron item WAS ALREADY THERE.
         // I don't want to save over it. If I'm trying to save over one that is
         // already there, then THAT is the
         // real problem.
         //
         if (bSaveReceipt &&
             (!theItem.SignContract(*GetServerNym()) || // Notice the server adds
                                                        // its signature
              // before saving the cron receipt to local
              // storage. This way, the server can
              // verify its own signature later, as
              // evidence the file hasn't been tampered
              // with. (BOTH signatures are there
              // now--user's and server's.)
              !theItem.SaveContract() || !theItem.SaveCronReceipt())) {
             otErr << __FUNCTION__ << ": Error saving receipt while adding new "
                                      "CronItem to Cron.\n";
             return false;
         }
 
         // Insert to the MAP (by Transaction Number)
         //
         m_mapCronItems.insert(std::pair<int64_t, OTCronItem*>(
             theItem.GetTransactionNum(), &theItem));
 
         // Insert to the MULTIMAP (by Date)
         //
         m_multimapCronItems.insert(
             m_multimapCronItems.upper_bound(tDateAdded),
             std::pair<time64_t, OTCronItem*>(tDateAdded, &theItem));
 
         theItem.SetCronPointer(*this);
         theItem.setServerNym(m_pServerNym);
         theItem.setServerId(&m_SERVER_ID);
 
         bool bSuccess = true;
 
         theItem.HookActivationOnCron(
             pActivator,    // (OTPseudonym* pActivator) // sometimes nullptr.
             bSaveReceipt); // If merely being reloaded after server reboot, this
                            // is false.
         // But if actually being activated for the first time, then this is
         // true.
 
         // When an item is added to Cron for the first time, a copy of it is
         // saved to the
         // cron folder, and it has the user's original signature on it. (If it's
         // a Trade,
         // it also contains an Offer with the user's original signature.) This
         // occurs
         // wherever this function is called with bSaveReceipt=true.
         //
         if (bSaveReceipt) // This executes only the first time that an item is
                           // added to Cron.
         // (versus when it's just being reloaded from file and added back to
         // the internal list.)
         {
             // Now that a copy of the cronitem is safely stored, I can release
             // the signature on it
             // and sign it with the Server's Nym instead. That way I can use the
             // server to verify
             // all cron and market-related activity from here on out.
             //            theItem.ReleaseSignatures();
             //            theItem.SignContract(*GetServerNym()); // THIS IS NOW
             // DONE ABOVE. See if (bSaveReceipt) ...
             //            theItem.SaveContract();
 
             // Since we added an item to the Cron, we SAVE it.
             bSuccess = SaveCron();
 
             if (bSuccess)
                 otOut << __FUNCTION__
                       << ": New CronItem has been added to Cron: "
                       << theItem.GetTransactionNum() << "\n";
             else
                 otErr << __FUNCTION__
                       << ": Error saving while adding new CronItem to Cron: "
                       << theItem.GetTransactionNum() << "\n";
         }
 
         return bSuccess;
     }
     // Otherwise, if it was already there, log an error.
     else {
         otErr << __FUNCTION__
               << ": Failed attempt to add CronItem with pre-existing "
                  "transaction number: " << theItem.GetTransactionNum() << "\n";
     }
 
     return false;
 }

bool opentxs::OTCron::AddMarket	(	OTMarket &	theMarket,
		bool	bSaveMarketFile = `true`
	)

Definition at line 1006 of file OTCron.cpp.

 {
     OT_ASSERT(nullptr != GetServerNym());
 
     theMarket.SetCronPointer(
         *this); // This way every Market has a pointer to Cron.
 
     OTIdentifier MARKET_ID(theMarket);
     OTString str_MARKET_ID(MARKET_ID);
     std::string std_MARKET_ID = str_MARKET_ID.Get();
 
     // See if there's something else already there with the same market ID.
     auto it = m_mapMarkets.find(std_MARKET_ID);
 
     // If it's not already on the list, then add it...
     if (it == m_mapMarkets.end()) {
         // If I've been instructed to save the market, and Cron did NOT
         // successfully save the market
         //  (to its own file), then return false.  This will happen if
         // filesystem problems.
         if (bSaveMarketFile && !theMarket.SaveMarket()) {
             otErr
                 << "Error saving market file while adding new Market to Cron:\n"
                 << std_MARKET_ID << "\n";
             return false;
         }
 
         m_mapMarkets[std_MARKET_ID] = &theMarket;
 
         bool bSuccess = true;
 
         // When Cron serializes, it stores a list of all its markets in the main
         // cron file.
         // The actual markets themselves serialize separately to the market
         // folder.
         //
         if (bSaveMarketFile) // This executes only the first time that a market
                              // is added to Cron.
         // (versus when it's just being reloaded from file and added back to
         // the internal list.)
         {
             // Since we added a market to the Cron, we SAVE it.
             bSuccess = SaveCron(); // If we're loading from file, and
                                    // bSaveMarketFile is false, I don't want to
                                    // save here. that's why it's in this block.
 
             if (bSuccess)
                 otLog3 << "New Market has been added to Cron.\n";
             else
                 otErr << "Error saving while adding new Market to Cron.\n";
         }
 
         return bSuccess;
     }
     // Otherwise, if it was already there, log an error.
     else {
         otErr << "Attempt to add Market that was already there: "
               << std_MARKET_ID << "\n";
     }
 
     return false;
 }

void opentxs::OTCron::AddTransactionNumber ( const int64_t & lTransactionNum )

Definition at line 415 of file OTCron.cpp.

 {
     m_listTransactionNumbers.push_back(lTransactionNum);
 }

mapOfCronItems::iterator opentxs::OTCron::FindItemOnMap ( int64_t lTransactionNum )

Definition at line 885 of file OTCron.cpp.

 {
     // See if there's something there with lTransactionNum
     // as its "official" number.
     //
     auto itt = m_mapCronItems.find(lTransactionNum);
 
     if (itt != m_mapCronItems.end()) // Found it!
     {
         OTCronItem* pItem = itt->second;
         OT_ASSERT((nullptr != pItem));
         OT_ASSERT(pItem->GetTransactionNum() == lTransactionNum);
 
         return itt;
     }
 
     return itt;
 }

multimapOfCronItems::iterator opentxs::OTCron::FindItemOnMultimap ( int64_t lTransactionNum )

Definition at line 913 of file OTCron.cpp.

 {
     auto itt = m_multimapCronItems.begin();
 
     while (m_multimapCronItems.end() != itt) {
         OTCronItem* pItem = itt->second;
         OT_ASSERT((nullptr != pItem));
 
         if (pItem->GetTransactionNum() == lTransactionNum) break;
 
         ++itt;
     }
 
     return itt;
 }

static int32_t opentxs::OTCron::GetCronMaxItemsPerNym ( )

inlinestatic

Definition at line 213 of file OTCron.hpp.

     {
         return __cron_max_items_per_nym;
     }

static int32_t opentxs::OTCron::GetCronMsBetweenProcess ( )

inlinestatic

Definition at line 196 of file OTCron.hpp.

     {
         return __cron_ms_between_process;
     }

static int32_t opentxs::OTCron::GetCronRefillAmount ( )

inlinestatic

Definition at line 205 of file OTCron.hpp.

     {
         return __trans_refill_amount;
     }

OTCronItem * opentxs::OTCron::GetItemByOfficialNum ( int64_t lTransactionNum )

Definition at line 938 of file OTCron.cpp.

 {
     // See if there's something there with lTransactionNum
     // as its "official" number.
     //
     auto itt = m_mapCronItems.find(lTransactionNum);
 
     if (itt != m_mapCronItems.end()) // Found it!
     {
         OTCronItem* pItem = itt->second;
         OT_ASSERT((nullptr != pItem));
         OT_ASSERT(pItem->GetTransactionNum() == lTransactionNum);
 
         return pItem;
     }
 
     return nullptr;
 }

OTCronItem * opentxs::OTCron::GetItemByValidOpeningNum ( int64_t lOpeningNum )

Definition at line 968 of file OTCron.cpp.

 {
     // See if there's something there with that transaction number.
     auto itt = m_mapCronItems.find(lOpeningNum);
 
     if (itt == m_mapCronItems.end()) {
         // We didn't find it as the "official" number, so let's loop
         // through the cron items one-by-one and see if it's a valid
         // opening number. (We searched for the "official" number first,
         // since it will often be the right one, and avoids doing this
         // longer search. Basically for optimization purposes.)
         //
         for (auto& it : m_mapCronItems) {
             OTCronItem* pItem = it.second;
             OT_ASSERT((nullptr != pItem));
 
             if (pItem->IsValidOpeningNumber(lOpeningNum)) // Todo optimization.
                                                           // Probably can remove
                                                           // this check.
                 return pItem;
         }
     }
     // Found it!
     else {
         OTCronItem* pItem = itt->second;
         OT_ASSERT((nullptr != pItem));
         OT_ASSERT(pItem->IsValidOpeningNumber(
             lOpeningNum)); // Todo optimization. Probably can remove this check.
 
         return pItem;
     }
 
     return nullptr;
 }

OTMarket * opentxs::OTCron::GetMarket ( const OTIdentifier & MARKET_ID )

Definition at line 1110 of file OTCron.cpp.

 {
     OTString str_MARKET_ID(MARKET_ID);
     std::string std_MARKET_ID = str_MARKET_ID.Get();
 
     // See if there's something there with that transaction number.
     auto it = m_mapMarkets.find(std_MARKET_ID);
 
     if (it == m_mapMarkets.end()) {
         // nothing found.
         return nullptr;
     }
     // Found it!
     else {
         OTMarket* pMarket = it->second;
 
         OT_ASSERT((nullptr != pMarket));
 
         const OTIdentifier LOOP_MARKET_ID(*pMarket);
         const OTString str_LOOP_MARKET_ID(LOOP_MARKET_ID);
 
         if (MARKET_ID == LOOP_MARKET_ID)
             return pMarket;
         else
             otErr << "Expected Market with ID:\n" << std_MARKET_ID
                   << "\n but found " << str_LOOP_MARKET_ID << "\n";
     }
 
     return nullptr;
 }

bool opentxs::OTCron::GetMarketList	(	OTASCIIArmor &	ascOutput,
		int32_t &	nMarketCount
	)

Definition at line 281 of file OTCron.cpp.

 {
     nMarketCount = 0; // This parameter is set to zero here, and incremented in
                       // the loop below.
 
     OTMarket* pMarket = nullptr;
 
     std::unique_ptr<OTDB::MarketList> pMarketList(
         dynamic_cast<OTDB::MarketList*>(
             OTDB::CreateObject(OTDB::STORED_OBJ_MARKET_LIST)));
 
     for (auto& it : m_mapMarkets) {
         pMarket = it.second;
         OT_ASSERT(nullptr != pMarket);
 
         std::unique_ptr<OTDB::MarketData> pMarketData(
             dynamic_cast<OTDB::MarketData*>(
                 OTDB::CreateObject(OTDB::STORED_OBJ_MARKET_DATA)));
 
         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 int64_t& lScale = pMarket->GetScale();
 
         pMarketData->scale = to_string<int64_t>(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 int64_t& lLastSalePrice = pMarket->GetLastSalePrice();
         const int64_t& lTotalAvailableAssets =
             pMarket->GetTotalAvailableAssets();
 
         pMarketData->total_assets = to_string<int64_t>(lTotalAvailableAssets);
         pMarketData->last_sale_price = to_string<int64_t>(lLastSalePrice);
 
         pMarketData->last_sale_date = pMarket->GetLastSaleDate();
 
         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 (0 == nMarketCount) {
         return true; // Success, but the list contains 0 markets.
     }
     else if (nMarketCount > 0) {
         OTDB::Storage* pStorage = OTDB::GetDefaultStorage();
         OT_ASSERT(nullptr != pStorage);
 
         OTDB::OTPacker* pPacker =
             pStorage->GetPacker(); // No need to check for failure, since this
                                    // already ASSERTS. No need to cleanup
                                    // either.
 
         std::unique_ptr<OTDB::PackedBuffer> pBuffer(
             pPacker->Pack(*pMarketList)); // Now we PACK our market list.
 
         if (nullptr == pBuffer) {
             otErr << "Failed packing pMarketList in OTCron::GetMarketList. \n";
             return false;
         }
 
         // --------------------------------------------------------
 
         // 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) && (nullptr != pUint)) {
             OTData theData(pUint, static_cast<uint32_t>(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
             otErr << "OTCron::GetMarketList: 0 size, or null return value, "
                      "while getting raw data from packed buffer.\n";
     }
     else
         otErr << "OTCron::GetMarketList: nMarketCount is less than zero: "
               << nMarketCount << ".\n";
 
     return false;
 }

int64_t opentxs::OTCron::GetNextTransactionNumber ( )

Definition at line 422 of file OTCron.cpp.

 {
     if (m_listTransactionNumbers.empty()) return 0;
 
     int64_t lTransactionNum = m_listTransactionNumbers.front();
 
     m_listTransactionNumbers.pop_front();
 
     return lTransactionNum;
 }

bool opentxs::OTCron::GetNym_OfferList	(	OTASCIIArmor &	ascOutput,
		const OTIdentifier &	NYM_ID,
		int32_t &	nOfferCount
	)

Definition at line 204 of file OTCron.cpp.

 {
     nOfferCount = 0; // Outputs the number of offers on this nym.
 
     std::unique_ptr<OTDB::OfferListNym> pOfferList(
         dynamic_cast<OTDB::OfferListNym*>(
             OTDB::CreateObject(OTDB::STORED_OBJ_OFFER_LIST_NYM)));
 
     for (auto& it : m_mapMarkets) {
         OTMarket* pMarket = it.second;
         OT_ASSERT(nullptr != pMarket);
 
         int32_t nNymOfferCount = 0;
 
         if (false ==
             pMarket->GetNym_OfferList(NYM_ID, *pOfferList,
                                       nNymOfferCount)) // appends to
                                                        // *pOfferList,
                                                        // each
                                                        // iteration.
         {
             // may wish to add a log later. Anyway, keep iterationg and
             // appending, then send back whatever we have.
         }
         else // Success!
             nOfferCount += nNymOfferCount;
     }
 
     // Now pack the list into strOutput...
     if (nOfferCount == 0)
         return true; // Success, but 0 offers being returned. (List is empty.)
 
     else if (nOfferCount > 0) {
         OTDB::Storage* pStorage = OTDB::GetDefaultStorage();
         OT_ASSERT(nullptr != pStorage);
 
         OTDB::OTPacker* pPacker =
             pStorage->GetPacker(); // No need to check for failure, since this
                                    // already ASSERTS. No need to cleanup
                                    // either.
 
         std::unique_ptr<OTDB::PackedBuffer> pBuffer(
             pPacker->Pack(*pOfferList)); // Now we PACK our nym's offer list.
 
         if (nullptr == pBuffer) {
             otErr
                 << "Failed packing pOfferList in OTCron::GetNym_OfferList. \n";
             return false;
         }
 
         // 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 ((nullptr != pUint) || (theSize < 2)) {
             OTData theData(pUint, static_cast<uint32_t>(theSize));
 
             // This function will base64 ENCODE theData,
             // and then Set() that as the string contents.
             ascOutput.SetData(theData);
 
             return true;
         }
         else
             otErr << "Null returned, or bad size, while getting buffer data in "
                      "OTCron::GetNym_OfferList.\n";
     }
     else
         otErr
             << "Error: Less-than-zero nOfferCount in OTCron::GetNym_OfferList: "
             << nOfferCount << ".\n";
 
     return false;
 }

OTMarket * opentxs::OTCron::GetOrCreateMarket	(	const OTIdentifier &	ASSET_ID,
		const OTIdentifier &	CURRENCY_ID,
		const int64_t &	lScale
	)

Definition at line 1070 of file OTCron.cpp.

 {
     OTMarket* pMarket =
         new OTMarket(GetServerID(), ASSET_ID, CURRENCY_ID, lScale);
 
     OT_ASSERT(nullptr != pMarket);
 
     OTIdentifier MARKET_ID(*pMarket);
 
     OTMarket* pExistingMarket = GetMarket(MARKET_ID);
 
     // If it was already there, there's no need to create it.
     if (nullptr != pExistingMarket) {
         delete pMarket;
         pMarket = nullptr;
         return pExistingMarket;
     }
 
     // If we got this far, it means the Market does NOT already exist in this
     // Cron.
     // So let's add it...
     bool bAdded = AddMarket(
         *pMarket, true); // bool bSaveMarketFile=true, since it was created new.
 
     if (bAdded) {
         otOut << "New market created and added to Cron.\n";
     }
     else {
         otErr << "Error trying to add new market to Cron.\n";
         delete pMarket;
         pMarket = nullptr;
     }
 
     return pMarket;
 }

const OTIdentifier& opentxs::OTCron::GetServerID ( ) const

inline

Definition at line 293 of file OTCron.hpp.

     {
         return m_SERVER_ID;
     }

OTPseudonym* opentxs::OTCron::GetServerNym ( ) const

inline

Definition at line 303 of file OTCron.hpp.

     {
         return m_pServerNym;
     }

int32_t opentxs::OTCron::GetTransactionCount ( ) const

Definition at line 408 of file OTCron.cpp.

 {
     if (m_listTransactionNumbers.empty()) return 0;
 
     return static_cast<int32_t>(m_listTransactionNumbers.size());
 }

void opentxs::OTCron::InitCron ( )

Definition at line 1183 of file OTCron.cpp.

 {
     m_strContractType = "CRON";
 }

bool opentxs::OTCron::IsActivated ( ) const

inline

Definition at line 221 of file OTCron.hpp.

     {
         return m_bIsActivated;
     }

bool opentxs::OTCron::LoadCron ( )

Definition at line 165 of file OTCron.cpp.

 {
     const char* szFoldername = OTFolders::Cron().Get();
     const char* szFilename = "OT-CRON.crn"; // todo stop hardcoding filenames.
 
     OT_ASSERT(nullptr != GetServerNym());
 
     bool bSuccess = LoadContract(szFoldername, szFilename);
 
     if (bSuccess) bSuccess = VerifySignature(*(GetServerNym()));
 
     return bSuccess;
 }

void opentxs::OTCron::ProcessCronItems ( )

Definition at line 648 of file OTCron.cpp.

 {
 
     if (!m_bIsActivated) {
         otErr << "OTCron::ProcessCronItems: Not activated yet. (Skipping.)\n";
         return;
     }
 
     // CRON RUNS ON A TIMER...
     static Timer tCron(true);
     static double cron_tick1 = tCron.getElapsedTimeInMilliSec();
     double cron_tick2 = tCron.getElapsedTimeInMilliSec();
     const int64_t cron_elapsed = static_cast<int64_t>(cron_tick2 - cron_tick1);
 
     if (cron_elapsed <= OTCron::GetCronMsBetweenProcess()) {
         return;
     }
     cron_tick1 = tCron.getElapsedTimeInMilliSec();
 
     const int32_t nTwentyPercent = OTCron::GetCronRefillAmount() / 5;
     if (GetTransactionCount() <= nTwentyPercent) {
         otErr << "WARNING: Cron has fewer than 20 percent of its normal "
                  "transaction number count available since the previous round! "
                  "\n"
                  "That is, " << GetTransactionCount()
               << " are currently available, with a max of "
               << OTCron::GetCronRefillAmount() << ", meaning "
               << OTCron::GetCronRefillAmount() - GetTransactionCount()
               << " were used in the last round alone!!! \n"
                  "SKIPPING THE CRON ITEMS THAT WERE SCHEDULED FOR THIS "
                  "ROUND!!!\n\n";
         return;
     }
     bool bNeedToSave = false;
 
     // loop through the cron items and tell each one to ProcessCron().
     // If the item returns true, that means leave it on the list. Otherwise,
     // if it returns false, that means "it's done: remove it."
     for (auto it = m_multimapCronItems.begin();
          it != m_multimapCronItems.end();) {
         if (GetTransactionCount() <= nTwentyPercent) {
             otErr << "WARNING: Cron has fewer than 20 percent of its normal "
                      "transaction "
                      "number count available since the previous cron item "
                      "alone! \n"
                      "That is, " << GetTransactionCount()
                   << " are currently available, with a max of "
                   << OTCron::GetCronRefillAmount() << ", meaning "
                   << OTCron::GetCronRefillAmount() - GetTransactionCount()
                   << " were used in the current round alone!!! \n"
                      "SKIPPING THE REMAINDER OF THE CRON ITEMS THAT WERE "
                      "SCHEDULED FOR THIS ROUND!!!\n\n";
             break;
         }
         OTCronItem* pItem = it->second;
         OT_ASSERT(nullptr != pItem);
         otInfo << "OTCron::" << __FUNCTION__
                << ": Processing item number: " << pItem->GetTransactionNum()
                << " \n";
 
         if (pItem->ProcessCron()) {
             it++;
             continue;
         }
         pItem->HookRemovalFromCron(nullptr, GetNextTransactionNumber());
         otOut << "OTCron::" << __FUNCTION__
               << ": Removing cron item: " << pItem->GetTransactionNum() << "\n";
         it = m_multimapCronItems.erase(it);
         auto it_map = FindItemOnMap(pItem->GetTransactionNum());
         OT_ASSERT(m_mapCronItems.end() != it_map);
         m_mapCronItems.erase(it_map);
 
         delete pItem;
         pItem = nullptr;
 
         bNeedToSave = true;
     }
     if (bNeedToSave) SaveCron();
 }

int32_t opentxs::OTCron::ProcessXMLNode ( irr::io::IrrXMLReader *& xml )

virtual

Reimplemented from opentxs::OTContract.

Definition at line 434 of file OTCron.cpp.

 {
     OT_ASSERT(nullptr != GetServerNym());
 
     int32_t nReturnVal = 0;
 
     // Here we call the parent class first.
     // If the node is found there, or there is some error,
     // then we just return either way.  But if it comes back
     // as '0', then nothing happened, and we'll continue executing.
     //
     // -- Note you can choose not to call the parent if
     // you don't want to use any of those xml tags.
     // As I do below, in the case of OTAccount.
     // if (nReturnVal = OTContract::ProcessXMLNode(xml))
     //    return nReturnVal;
 
     if (!strcmp("cron", xml->getNodeName())) {
         m_strVersion = xml->getAttributeValue("version");
 
         const OTString strServerID(xml->getAttributeValue("serverID"));
 
         m_SERVER_ID.SetString(strServerID);
 
         otOut << "\n\nLoading OTCron for ServerID: " << strServerID << "\n";
 
         nReturnVal = 1;
     }
     else if (!strcmp("transactionNum", xml->getNodeName())) {
         const int64_t lTransactionNum = atol(xml->getAttributeValue("value"));
 
         otWarn << "Transaction Number " << lTransactionNum
                << " available for Cron.\n";
 
         AddTransactionNumber(lTransactionNum); // This doesn't save to disk.
                                                // Make sure to save Cron when it
                                                // changes.
 
         nReturnVal = 1;
     }
     else if (!strcmp("cronItem", xml->getNodeName())) {
         const OTString str_date_added = xml->getAttributeValue("dateAdded");
         const int64_t lDateAdded =
             (!str_date_added.Exists() ? 0 : str_date_added.ToLong());
         const time64_t tDateAdded = OTTimeGetTimeFromSeconds(lDateAdded);
 
         OTString strData;
 
         if (!OTContract::LoadEncodedTextField(xml, strData) ||
             !strData.Exists()) {
             otErr << "Error in OTCron::ProcessXMLNode: cronItem field without "
                      "value.\n";
             return (-1); // error condition
         }
         else {
             OTCronItem* pItem = OTCronItem::NewCronItem(strData);
 
             if (nullptr == pItem) {
                 otErr << "Unable to create cron item from data in cron file.\n";
                 return (-1);
             }
 
             // Why not do this here (when loading from storage), as well as when
             // first adding the item to cron,
             // and thus save myself the trouble of verifying the signature EVERY
             // ITERATION of ProcessCron().
             //
             if (!pItem->VerifySignature(*m_pServerNym)) {
                 otErr << "OTCron::ProcessXMLNode: ERROR SECURITY: Server "
                          "signature failed to "
                          "verify on a cron item while loading: "
                       << pItem->GetTransactionNum() << "\n";
                 delete pItem;
                 pItem = nullptr;
                 return (-1);
             }
             else if (AddCronItem(*pItem, nullptr,
                                    false, // bSaveReceipt=false. The receipt is
                                           // only saved once: When item FIRST
                                           // added to cron...
                                    tDateAdded)) { // ...But here, the item was
                                                   // ALREADY in cron, and is
                                                   // merely being loaded from
                                                   // disk.
                 // Thus, it would be wrong to try to create the "original
                 // record" as if it were brand
                 // new and still had the user's signature on it. (Once added to
                 // Cron, the signatures are
                 // released and the SERVER signs it from there. That's why the
                 // user's version is saved
                 // as a receipt in the first place -- so we have a record of the
                 // user's authorization.)
                 otInfo << "Successfully loaded cron item and added to list.\n";
             }
             else {
                 otErr << "OTCron::ProcessXMLNode: Though loaded / verified "
                          "successfully, "
                          "unable to add cron item (from cron file) to cron "
                          "list.\n";
                 delete pItem;
                 pItem = nullptr;
                 return (-1);
             }
         }
 
         nReturnVal = 1;
     }
     else if (!strcmp("market", xml->getNodeName())) {
         const OTString strMarketID(xml->getAttributeValue("marketID"));
         const OTString strAssetID(xml->getAttributeValue("assetID"));
         const OTString strCurrencyID(xml->getAttributeValue("currencyID"));
 
         const int64_t lScale = atol(xml->getAttributeValue("marketScale"));
 
         const OTIdentifier ASSET_ID(strAssetID), CURRENCY_ID(strCurrencyID);
 
         otWarn << "Loaded cron entry for Market:\n" << strMarketID << ".\n";
 
         // LoadMarket() needs this info to do its thing.
         OTMarket* pMarket =
             new OTMarket(m_SERVER_ID, ASSET_ID, CURRENCY_ID, lScale);
 
         OT_ASSERT(nullptr != pMarket);
 
         pMarket->SetCronPointer(
             *this); // This way every Market has a pointer to Cron.
 
         //    AddMarket normally saves to file, but we don't want that when
         // we're LOADING from file, now do we?
         if (!pMarket->LoadMarket() ||
             !pMarket->VerifySignature(*GetServerNym()) ||
             !AddMarket(*pMarket, false)) // bSaveFile=false: don't save this
                                          // file WHILE loading it!!!
         {
             otErr << "Somehow error while loading, verifying, or adding market "
                      "while loading Cron file.\n";
             delete pMarket;
             pMarket = nullptr;
             return (-1);
         }
         else {
             otWarn << "Loaded market entry from cronfile, and also loaded the "
                       "market file itself.\n";
         }
         nReturnVal = 1;
     }
 
     return nReturnVal;
 }

void opentxs::OTCron::Release ( )

virtual

Reimplemented from opentxs::OTContract.

Definition at line 1188 of file OTCron.cpp.

 {
     Release_Cron();
 
     ot_super::Release();
 }

void opentxs::OTCron::Release_Cron ( )

Definition at line 1195 of file OTCron.cpp.

 {
     // If there were any dynamically allocated objects, clean them up here.
 
     while (!m_multimapCronItems.empty()) {
         auto it = m_multimapCronItems.begin();
         m_multimapCronItems.erase(it);
 
         // We don't delete the pItem in here, since these are the
         // same pItems being deleted in the next block.
     }
 
     while (!m_mapCronItems.empty()) {
         OTCronItem* pItem = m_mapCronItems.begin()->second;
         auto it = m_mapCronItems.begin();
         m_mapCronItems.erase(it);
         delete pItem;
         pItem = nullptr;
     }
 
     while (!m_mapMarkets.empty()) {
         OTMarket* pMarket = m_mapMarkets.begin()->second;
         auto it = m_mapMarkets.begin();
         m_mapMarkets.erase(it);
         delete pMarket;
         pMarket = nullptr;
     }
 }

bool opentxs::OTCron::RemoveCronItem	(	int64_t	lTransactionNum,
		OTPseudonym &	theRemover
	)

Definition at line 839 of file OTCron.cpp.

 {
     // See if there's a cron item with that transaction number.
     auto it_map = FindItemOnMap(lTransactionNum);
 
     // If it's not already on the list, then there's nothing to remove.
     if (m_mapCronItems.end() == it_map) {
         otErr << __FUNCTION__
               << ": Attempt to remove non-existent CronItem from OTCron. "
                  "Transaction #: " << lTransactionNum << "\n";
     }
 
     // Otherwise, if it WAS already there, remove it properly.
     else {
         OTCronItem* pItem = it_map->second;
         //      OT_ASSERT(nullptr != pItem); // Already done in FindItemOnMap.
 
         // We have to remove it from the multimap as well.
         auto it_multimap = FindItemOnMultimap(lTransactionNum);
         OT_ASSERT(m_multimapCronItems.end() !=
                   it_multimap); // If found on map, MUST be on multimap also.
 
         pItem->HookRemovalFromCron(&theRemover, GetNextTransactionNumber());
 
         m_mapCronItems.erase(it_map);           // Remove from MAP.
         m_multimapCronItems.erase(it_multimap); // Remove from MULTIMAP.
 
         delete pItem;
 
         // An item has been removed from Cron. SAVE.
         return SaveCron();
     }
 
     return false;
 }

bool opentxs::OTCron::RemoveMarket ( const OTIdentifier & MARKET_ID )

bool opentxs::OTCron::SaveContractWallet ( std::ofstream & ofs ) const

virtual

Implements opentxs::OTContract.

Definition at line 1224 of file OTCron.cpp.

 {
     return true;
 }

bool opentxs::OTCron::SaveCron ( )

Definition at line 179 of file OTCron.cpp.

 {
     const char* szFoldername = OTFolders::Cron().Get();
     const char* szFilename = "OT-CRON.crn"; // todo stop hardcoding filenames.
 
     OT_ASSERT(nullptr != GetServerNym());
 
     ReleaseSignatures();
 
     // Sign it, save it internally to string, and then save that out to the
     // file.
     if (!SignContract(*m_pServerNym) || !SaveContract() ||
         !SaveContract(szFoldername, szFilename)) {
         otErr << "Error saving main Cronfile:\n" << szFoldername
               << OTLog::PathSeparator() << szFilename << "\n";
         return false;
     }
     else
         return true;
 }

static void opentxs::OTCron::SetCronMaxItemsPerNym ( int32_t nMax )

inlinestatic

Definition at line 217 of file OTCron.hpp.

     {
         __cron_max_items_per_nym = nMax;
     }

static void opentxs::OTCron::SetCronMsBetweenProcess ( int32_t lMS )

inlinestatic

Definition at line 200 of file OTCron.hpp.

     {
         __cron_ms_between_process = lMS;
     }

static void opentxs::OTCron::SetCronRefillAmount ( int32_t nAmount )

inlinestatic

Definition at line 209 of file OTCron.hpp.

     {
         __trans_refill_amount = nAmount;
     }

void opentxs::OTCron::SetServerID ( const OTIdentifier & SERVER_ID )

inline

Definition at line 289 of file OTCron.hpp.

     {
         m_SERVER_ID = SERVER_ID;
     }

void opentxs::OTCron::SetServerNym ( OTPseudonym * pServerNym )

inline

Definition at line 298 of file OTCron.hpp.

     {
         OT_ASSERT(nullptr != pServerNym);
         m_pServerNym = pServerNym;
     }

void opentxs::OTCron::UpdateContents ( )

virtual

Reimplemented from opentxs::OTContract.

Definition at line 584 of file OTCron.cpp.

 {
     // I release this because I'm about to repopulate it.
     m_xmlUnsigned.Release();
 
     m_xmlUnsigned.Concatenate("<?xml version=\"%s\"?>\n\n", "1.0");
 
     const OTString SERVER_ID(m_SERVER_ID);
 
     m_xmlUnsigned.Concatenate("<cron\n version=\"%s\"\n"
                               " serverID=\"%s\""
                               " >\n\n",
                               m_strVersion.Get(), SERVER_ID.Get());
 
     // Save the Market entries (the markets themselves are saved in a markets
     // folder.)
     for (auto& it : m_mapMarkets) {
         OTMarket* pMarket = it.second;
         OT_ASSERT(nullptr != pMarket);
 
         OTIdentifier MARKET_ID(*pMarket);
         OTString str_MARKET_ID(MARKET_ID);
 
         OTString str_ASSET_ID(pMarket->GetAssetID());
         OTString str_CURRENCY_ID(pMarket->GetCurrencyID());
 
         m_xmlUnsigned.Concatenate("<market\n marketID=\"%s\"\n"
                                   " assetID=\"%s\"\n"
                                   " currencyID=\"%s\"\n"
                                   " marketScale=\"%lld\""
                                   " />\n\n",
                                   str_MARKET_ID.Get(), str_ASSET_ID.Get(),
                                   str_CURRENCY_ID.Get(), pMarket->GetScale());
     }
 
     // Save the Cron Items
     for (auto& it : m_multimapCronItems) {
         OTCronItem* pItem = it.second;
         OT_ASSERT(nullptr != pItem);
 
         time64_t tDateAdded = it.first;
         int64_t lDateAdded = OTTimeGetSecondsFromTime(tDateAdded);
 
         OTString strItem(
             *pItem); // Extract the cron item contract into string form.
         OTASCIIArmor ascItem(strItem); // Base64-encode that for storage.
 
         m_xmlUnsigned.Concatenate("<cronItem dateAdded=\"%" PRId64
                                   "\" >\n%s</cronItem>\n\n",
                                   lDateAdded, ascItem.Get());
     }
 
     // Save the transaction numbers.
     //
     for (auto& lTransactionNumber : m_listTransactionNumbers) {
         m_xmlUnsigned.Concatenate("<transactionNum value=\"%lld\" />\n\n",
                                   lTransactionNumber);
     } // for
 
     m_xmlUnsigned.Concatenate("</cron>\n");
 }

The documentation for this class was generated from the following files:

/usr/local/src/opentxs/include/opentxs/core/cron/OTCron.hpp
/usr/local/src/opentxs/src/core/cron/OTCron.cpp

Public Member Functions

Static Public Member Functions

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation