#include <OTAgreement.hpp>

Inheritance diagram for opentxs::OTAgreement:

Collaboration diagram for opentxs::OTAgreement:

Public Member Functions
const OTString &	GetConsideration () const

void	SetMerchantSignedCopy (const OTString &strMerchantCopy)

const OTString &	GetMerchantSignedCopy () const

EXPORT bool	SetProposal (OTPseudonym &MERCHANT_NYM, const OTString &strConsideration, time64_t VALID_FROM=OT_TIME_ZERO, time64_t VALID_TO=OT_TIME_ZERO)

EXPORT bool	Confirm (OTPseudonym &PAYER_NYM, OTPseudonym pMERCHANT_NYM=nullptr, const OTIdentifier p_id_MERCHANT_NYM=nullptr)

virtual bool	VerifyAgreement (OTPseudonym &RECIPIENT_NYM, OTPseudonym &SENDER_NYM) const =0

virtual bool	CompareAgreement (const OTAgreement &rhs) const

const OTIdentifier &	GetRecipientAcctID () const

const OTIdentifier &	GetRecipientUserID () const

void	SetRecipientAcctID (const OTIdentifier &ACCT_ID)

void	SetRecipientUserID (const OTIdentifier &USER_ID)

EXPORT int64_t	GetRecipientClosingTransactionNoAt (uint32_t nIndex) const

EXPORT int32_t	GetRecipientCountClosingNumbers () const

void	AddRecipientClosingTransactionNo (const int64_t &lClosingTransactionNo)

EXPORT int64_t	GetRecipientOpeningNum () const

EXPORT int64_t	GetRecipientClosingNum () const

virtual bool	CanRemoveItemFromCron (OTPseudonym &theNym)

virtual void	HarvestOpeningNumber (OTPseudonym &theNym)

virtual EXPORT void	HarvestClosingNumbers (OTPseudonym &theNym)

virtual bool	ProcessCron ()

virtual bool	HasTransactionNum (const int64_t &lInput) const

virtual void	GetAllTransactionNumbers (OTNumList &numlistOutput) const

virtual bool	VerifyNymAsAgent (OTPseudonym &theNym, OTPseudonym &theSignerNym, mapOfNyms *pmap_ALREADY_LOADED=nullptr) const

virtual bool	VerifyNymAsAgentForAccount (OTPseudonym &theNym, OTAccount &theAccount) const

EXPORT bool	SendNoticeToAllParties (bool bSuccessMsg, OTPseudonym &theServerNym, const OTIdentifier &theServerID, const int64_t &lNewTransactionNumber, const OTString &strReference, OTString pstrNote=nullptr, OTString pstrAttachment=nullptr, OTPseudonym *pActualNym=nullptr) const

	OTAgreement ()

	OTAgreement (const OTIdentifier &SERVER_ID, const OTIdentifier &ASSET_ID)

	OTAgreement (const OTIdentifier &SERVER_ID, const OTIdentifier &ASSET_ID, const OTIdentifier &SENDER_ACCT_ID, const OTIdentifier &SENDER_USER_ID, const OTIdentifier &RECIPIENT_ACCT_ID, const OTIdentifier &RECIPIENT_USER_ID)

virtual	~OTAgreement ()

void	InitAgreement ()

virtual void	Release ()

void	Release_Agreement ()

virtual bool	IsValidOpeningNumber (const int64_t &lOpeningNum) const

virtual EXPORT int64_t	GetOpeningNumber (const OTIdentifier &theNymID) const

virtual int64_t	GetClosingNumber (const OTIdentifier &theAcctID) const

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

virtual void	UpdateContents ()

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

Public Member Functions inherited from opentxs::OTCronItem
	OTCronItem ()

bool	DropFinalReceiptToInbox (const OTIdentifier &USER_ID, const OTIdentifier &ACCOUNT_ID, const int64_t &lNewTransactionNumber, const int64_t &lClosingNumber, const OTString &strOrigCronItem, OTString pstrNote=nullptr, OTString pstrAttachment=nullptr, OTAccount *pActualAcct=nullptr)

bool	DropFinalReceiptToNymbox (const OTIdentifier &USER_ID, const int64_t &lNewTransactionNumber, const OTString &strOrigCronItem, OTString pstrNote=nullptr, OTString pstrAttachment=nullptr, OTPseudonym *pActualNym=nullptr)

void	HookActivationOnCron (OTPseudonym *pActivator, bool bForTheFirstTime=false)

void	HookRemovalFromCron (OTPseudonym *pRemover, int64_t newTransactionNo)

bool	IsFlaggedForRemoval () const

void	FlagForRemoval ()

void	SetCronPointer (OTCron &theCron)

void	SetCreationDate (const time64_t &CREATION_DATE)

const time64_t &	GetCreationDate () const

EXPORT bool	SetDateRange (time64_t VALID_FROM=OT_TIME_ZERO, time64_t VALID_TO=OT_TIME_ZERO)

void	SetLastProcessDate (const time64_t &THE_DATE)

const time64_t &	GetLastProcessDate () const

void	SetProcessInterval (const int64_t &THE_DATE)

const int64_t &	GetProcessInterval () const

OTCron *	GetCron () const

void	setServerNym (OTPseudonym *serverNym)

void	setServerId (OTIdentifier *serverId)

EXPORT bool	SaveCronReceipt ()

EXPORT bool	SaveActiveCronReceipt (const OTIdentifier &theNymID)

virtual	~OTCronItem ()

void	InitCronItem ()

void	Release_CronItem ()

EXPORT bool	GetCancelerID (OTIdentifier &theOutput) const

EXPORT bool	IsCanceled () const

EXPORT bool	CancelBeforeActivation (OTPseudonym &theCancelerNym)

EXPORT int64_t	GetClosingTransactionNoAt (uint32_t nIndex) const

EXPORT int32_t	GetCountClosingNumbers () const

EXPORT void	AddClosingTransactionNo (const int64_t &lClosingTransactionNo)

EXPORT int64_t	GetOpeningNum () const

EXPORT int64_t	GetClosingNum () const

Public Member Functions inherited from opentxs::OTTrackable
	OTTrackable ()

	OTTrackable (const OTIdentifier &SERVER_ID, const OTIdentifier &ASSET_ID)

	OTTrackable (const OTIdentifier &SERVER_ID, const OTIdentifier &ASSET_ID, const OTIdentifier &ACCT_ID, const OTIdentifier &USER_ID)

virtual	~OTTrackable ()

void	InitTrackable ()

void	Release_Trackable ()

int64_t	GetTransactionNum () const

void	SetTransactionNum (int64_t lTransactionNum)

const OTIdentifier &	GetSenderAcctID () const

const OTIdentifier &	GetSenderUserID () const

Public Member Functions inherited from opentxs::OTInstrument
EXPORT	OTInstrument ()

EXPORT	OTInstrument (const OTIdentifier &SERVER_ID, const OTIdentifier &ASSET_ID)

virtual EXPORT	~OTInstrument ()

void	Release_Instrument ()

EXPORT bool	VerifyCurrentDate ()

EXPORT bool	IsExpired ()

time64_t	GetValidFrom () const

time64_t	GetValidTo () const

const OTIdentifier &	GetAssetID () const

const OTIdentifier &	GetServerID () const

void	InitInstrument ()

Public Member Functions inherited from opentxs::OTScriptable
virtual EXPORT void	SetDisplayLabel (const std::string *pstrLabel=nullptr)

int32_t	GetPartyCount () const

int32_t	GetBylawCount () const

virtual EXPORT bool	AddParty (OTParty &theParty)

virtual EXPORT bool	AddBylaw (OTBylaw &theBylaw)

virtual EXPORT bool	ConfirmParty (OTParty &theParty)

EXPORT OTParty *	GetParty (std::string str_party_name) const

EXPORT OTBylaw *	GetBylaw (std::string str_bylaw_name) const

EXPORT OTClause *	GetClause (std::string str_clause_name) const

EXPORT OTParty *	GetPartyByIndex (int32_t nIndex) const

EXPORT OTBylaw *	GetBylawByIndex (int32_t nIndex) const

EXPORT OTParty *	FindPartyBasedOnNymAsAgent (OTPseudonym &theNym, OTAgent **ppAgent=nullptr) const

EXPORT OTParty *	FindPartyBasedOnNymAsAuthAgent (OTPseudonym &theNym, OTAgent **ppAgent=nullptr) const

OTParty *	FindPartyBasedOnAccount (OTAccount &theAccount, OTPartyAccount **ppPartyAccount=nullptr) const

OTParty *	FindPartyBasedOnNymIDAsAgent (const OTIdentifier &theNymID, OTAgent **ppAgent=nullptr) const

OTParty *	FindPartyBasedOnNymIDAsAuthAgent (const OTIdentifier &theNymID, OTAgent **ppAgent=nullptr) const

OTParty *	FindPartyBasedOnAccountID (const OTIdentifier &theAcctID, OTPartyAccount **ppPartyAccount=nullptr) const

OTAgent *	GetAgent (std::string str_agent_name) const

OTPartyAccount *	GetPartyAccount (std::string str_acct_name) const

OTPartyAccount *	GetPartyAccountByID (const OTIdentifier &theAcctID) const

EXPORT int32_t	GetCountTransNumsNeededForAgent (std::string str_agent_name) const

bool	VerifyPartyAuthorization (OTParty &theParty, OTPseudonym &theSignerNym, const OTString &strServerID, mapOfNyms pmap_ALREADY_LOADED=nullptr, mapOfNyms pmap_NEWLY_LOADED=nullptr, bool bBurnTransNo=false)

bool	VerifyPartyAcctAuthorization (OTPartyAccount &thePartyAcct, OTPseudonym &theSignerNym, const OTString &strServerID, bool bBurnTransNo=false)

EXPORT bool	VerifyThisAgainstAllPartiesSignedCopies ()

EXPORT bool	AllPartiesHaveSupposedlyConfirmed ()

void	RetrieveNymPointers (mapOfNyms &map_Nyms_Already_Loaded)

void	ClearTemporaryPointers ()

bool	GetHooks (std::string str_HookName, mapOfClauses &theResults)

OTClause *	GetCallback (std::string str_CallbackName)

OTVariable *	GetVariable (std::string str_VarName)

bool	IsDirty () const

bool	IsDirtyImportant () const

void	SetAsClean ()

EXPORT bool	SendNoticeToAllParties (bool bSuccessMsg, OTPseudonym &theServerNym, const OTIdentifier &theServerID, const int64_t &lNewTransactionNumber, const OTString &strReference, OTString pstrNote=nullptr, OTString pstrAttachment=nullptr, OTPseudonym *pActualNym=nullptr) const

EXPORT bool	CanExecuteClause (std::string str_party_name, std::string str_clause_name)

bool	ExecuteCallback (OTClause &theCallbackClause, mapOfVariables &theParameters, OTVariable &varReturnVal)

virtual EXPORT void	RegisterOTNativeCallsWithScript (OTScript &theScript)

virtual EXPORT bool	Compare (OTScriptable &rhs) const

	OTScriptable ()

virtual	~OTScriptable ()

void	UpdateContentsToString (OTString &strAppend, bool bCalculatingID) const

virtual EXPORT void	CalculateContractID (OTIdentifier &newID) const

void	Release_Scriptable ()

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 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 EXPORT bool	DropServerNoticeToNymbox (bool bSuccessMsg, OTPseudonym &theServerNym, const OTIdentifier &SERVER_ID, const OTIdentifier &USER_ID, const int64_t &lNewTransactionNumber, const int64_t &lInReferenceTo, const OTString &strReference, OTString pstrNote=nullptr, OTString pstrAttachment=nullptr, OTPseudonym *pActualNym=nullptr)

Static Public Member Functions inherited from opentxs::OTCronItem
static EXPORT OTCronItem *	NewCronItem (const OTString &strCronItem)

static EXPORT OTCronItem *	LoadCronReceipt (const int64_t &lTransactionNum)

static EXPORT OTCronItem *	LoadActiveCronReceipt (const int64_t &lTransactionNum, const OTIdentifier &serverID)

static EXPORT bool	EraseActiveCronReceipt (const int64_t &lTransactionNum, const OTIdentifier &nymID, const OTIdentifier &serverID)

static EXPORT bool	GetActiveCronTransNums (OTNumList &output, const OTIdentifier &nymID, const OTIdentifier &serverID)

Static Public Member Functions inherited from opentxs::OTScriptable
static EXPORT OTScriptable *	InstantiateScriptable (const OTString &strInput)

static bool	ValidateName (std::string str_name)

static std::string	GetTime ()

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)

Protected Member Functions
virtual void	onFinalReceipt (OTCronItem &theOrigCronItem, const int64_t &lNewTransactionNumber, OTPseudonym &theOriginator, OTPseudonym *pRemover)

virtual void	onRemovalFromCron ()

Protected Member Functions inherited from opentxs::OTCronItem
	OTCronItem (const OTIdentifier &SERVER_ID, const OTIdentifier &ASSET_ID)

	OTCronItem (const OTIdentifier &SERVER_ID, const OTIdentifier &ASSET_ID, const OTIdentifier &ACCT_ID, const OTIdentifier &USER_ID)

virtual void	onActivate ()

void	ClearClosingNumbers ()

Protected Member Functions inherited from opentxs::OTTrackable
void	SetSenderAcctID (const OTIdentifier &ACCT_ID)

void	SetSenderUserID (const OTIdentifier &USER_ID)

Protected Member Functions inherited from opentxs::OTInstrument
void	SetValidFrom (time64_t TIME_FROM)

void	SetValidTo (time64_t TIME_TO)

void	SetAssetID (const OTIdentifier &ASSET_ID)

void	SetServerID (const OTIdentifier &SERVER_ID)

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

Protected Attributes
OTString	m_strConsideration

OTString	m_strMerchantSignedCopy

std::deque< int64_t >	m_dequeRecipientClosingNumbers

Protected Attributes inherited from opentxs::OTCronItem
std::deque< int64_t >	m_dequeClosingNumbers

OTIdentifier *	m_pCancelerNymID

bool	m_bCanceled

bool	m_bRemovalFlag

Protected Attributes inherited from opentxs::OTTrackable
int64_t	m_lTransactionNum

OTIdentifier	m_SENDER_ACCT_ID

OTIdentifier	m_SENDER_USER_ID

Protected Attributes inherited from opentxs::OTInstrument
OTIdentifier	m_AssetTypeID

OTIdentifier	m_ServerID

time64_t	m_VALID_FROM

time64_t	m_VALID_TO

Protected Attributes inherited from opentxs::OTScriptable
mapOfParties	m_mapParties

mapOfBylaws	m_mapBylaws

bool	m_bCalculatingID

bool	m_bSpecifyAssetID

bool	m_bSpecifyParties

OTString	m_strLabel

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 169 of file OTAgreement.hpp.

Constructor & Destructor Documentation

opentxs::OTAgreement::OTAgreement ( )

Definition at line 1457 of file OTAgreement.cpp.

     : ot_super()
 {
     InitAgreement();
 }

opentxs::OTAgreement::OTAgreement	(	const OTIdentifier &	SERVER_ID,
		const OTIdentifier &	ASSET_ID
	)

Definition at line 1463 of file OTAgreement.cpp.

     : ot_super(SERVER_ID, ASSET_ID)
 {
     InitAgreement();
 }

opentxs::OTAgreement::OTAgreement	(	const OTIdentifier &	SERVER_ID,
		const OTIdentifier &	ASSET_ID,
		const OTIdentifier &	SENDER_ACCT_ID,
		const OTIdentifier &	SENDER_USER_ID,
		const OTIdentifier &	RECIPIENT_ACCT_ID,
		const OTIdentifier &	RECIPIENT_USER_ID
	)

Definition at line 1470 of file OTAgreement.cpp.

     : ot_super(SERVER_ID, ASSET_ID, SENDER_ACCT_ID, SENDER_USER_ID)
 {
     InitAgreement();
 
     SetRecipientAcctID(RECIPIENT_ACCT_ID);
     SetRecipientUserID(RECIPIENT_USER_ID);
 }

opentxs::OTAgreement::~OTAgreement ( )

virtual

Definition at line 1484 of file OTAgreement.cpp.

 {
     Release_Agreement();
 }

Member Function Documentation

void opentxs::OTAgreement::AddRecipientClosingTransactionNo ( const int64_t & lClosingTransactionNo )

Definition at line 1012 of file OTAgreement.cpp.

 {
     m_dequeRecipientClosingNumbers.push_back(lClosingTransactionNo);
 }

bool opentxs::OTAgreement::CanRemoveItemFromCron ( OTPseudonym & theNym )

virtual

See if theNym has rights to remove this item from Cron.

Reimplemented from opentxs::OTCronItem.

Definition at line 1045 of file OTAgreement.cpp.

 {
     // You don't just go willy-nilly and remove a cron item from a market unless
     // you check first
     // and make sure the Nym who requested it actually has said number (or a
     // related closing number)
     // signed out to him on his last receipt...
     //
     if (true == ot_super::CanRemoveItemFromCron(theNym)) return true;
 
     const OTString strServerID(GetServerID());
 
     // Usually the Nym is the originator. (Meaning GetTransactionNum() on this
     // agreement
     // is still verifiable as an issued number on theNum, and belongs to him.)
     // In that case,
     // the above call will discover this, and return true.
     // In other cases, theNym has the right to Remove the item even though
     // theNym didn't originate it.
     // (Like if he is the recipient -- not the sender -- in a payment plan.) We
     // check such things
     // HERE in this function (see below.)
     //
     if (!theNym.CompareID(GetRecipientUserID())) {
         otOut << "OTAgreement::" << __FUNCTION__
               << " Weird: Nym tried to remove agreement (payment plan), even "
                  "though he apparently wasn't the sender OR recipient.\n";
         return false;
     }
     else if (GetRecipientCountClosingNumbers() < 2) {
         otOut << "OTAgreement::" << __FUNCTION__
               << ": Weird: Recipient tried to remove agreement "
                  "(or payment plan); expected 2 closing numbers to be "
                  "available--that weren't."
                  " (Found " << GetRecipientCountClosingNumbers() << ").\n";
         return false;
     }
 
     if (false ==
         theNym.VerifyIssuedNum(strServerID, GetRecipientClosingNum())) {
         otOut << "OTAgreement::" << __FUNCTION__ << ": Recipient Closing "
                                                     "number didn't verify (for "
                                                     "removal from cron).\n";
         return false;
     }
 
     // By this point, we KNOW theNym is the sender, and we KNOW there are the
     // proper number of transaction
     // numbers available to close. We also know that this cron item really was
     // on the cron object, since
     // that is where it was looked up from, when this function got called! So
     // I'm pretty sure, at this point,
     // to authorize removal, as long as the transaction num is still issued to
     // theNym (this check here.)
     //
     return theNym.VerifyIssuedNum(strServerID, GetRecipientOpeningNum());
 
     // Normally this will be all we need to check. The originator will have the
     // transaction
     // number signed-out to him still, if he is trying to close it. BUT--in some
     // cases, someone
     // who is NOT the originator can cancel. Like in a payment plan, the sender
     // is also the depositor,
     // who would normally be the person cancelling the plan. But technically,
     // the RECIPIENT should
     // also have the ability to cancel that payment plan.  BUT: the transaction
     // number isn't signed
     // out to the RECIPIENT... In THAT case, the below VerifyIssuedNum() won't
     // work! In those cases,
     // expect that the special code will be in the subclasses override of this
     // function. (OTPaymentPlan::CanRemoveItem() etc)
 
     // P.S. If you override this function, MAKE SURE to call the parent
     // (OTCronItem::CanRemoveItem) first,
     // for the VerifyIssuedNum call above. Only if that fails, do you need to
     // dig deeper...
 }

bool opentxs::OTAgreement::CompareAgreement ( const OTAgreement & rhs ) const

virtual

Reimplemented in opentxs::OTPaymentPlan.

Definition at line 1123 of file OTAgreement.cpp.

 {
     // Compare OTAgreement specific info here.
 
     if ((m_strConsideration.Compare(rhs.m_strConsideration)) &&
         (GetRecipientAcctID() == rhs.GetRecipientAcctID()) &&
         (GetRecipientUserID() == rhs.GetRecipientUserID()) &&
         //        (   m_dequeClosingNumbers == rhs.m_dequeClosingNumbers ) && //
         // The merchant wouldn't know the customer's trans#s.
         // (Thus wouldn't expect them to be set in BOTH versions...)
         (m_dequeRecipientClosingNumbers ==
          rhs.m_dequeRecipientClosingNumbers) &&
         //      (   GetTransactionNum()  == rhs.GetTransactionNum()   ) && //
         // (commented out for same reason as above.)
         //      (   GetSenderAcctID()    == rhs.GetSenderAcctID()     ) && //
         // Same here -- we should let the merchant leave these blank,
         //      (   GetSenderUserID()    == rhs.GetSenderUserID()     ) && //
         // and then allow the customer to add them in his version,
         (GetAssetID() == rhs.GetAssetID()) && // (and this Compare function
                                               // still still verify it.)
         (GetServerID() == rhs.GetServerID()) &&
         (GetValidFrom() == rhs.GetValidFrom()) &&
         (GetValidTo() == rhs.GetValidTo()))
         return true;
 
     return false;
 }

bool opentxs::OTAgreement::Confirm	(	OTPseudonym &	PAYER_NYM,
		OTPseudonym *	pMERCHANT_NYM = `nullptr`,
		const OTIdentifier *	p_id_MERCHANT_NYM = `nullptr`
	)

Definition at line 1282 of file OTAgreement.cpp.

 {
 
     OTIdentifier id_PAYER_NYM;
     PAYER_NYM.GetIdentifier(id_PAYER_NYM);
 
     if (GetRecipientUserID() == GetSenderUserID()) {
         otOut << __FUNCTION__ << ": Error: Sender and recipient have the same "
                                  "Nym ID (not allowed.)\n";
         return false;
     }
     else if ((nullptr != p_id_MERCHANT_NYM) &&
                (GetRecipientUserID() != *p_id_MERCHANT_NYM)) {
         otOut << __FUNCTION__ << ": Merchant has wrong NymID (should be same "
                                  "as RecipientUserID.)\n";
         return false;
     }
     else if ((nullptr != pMERCHANT_NYM) &&
                (GetRecipientUserID() != pMERCHANT_NYM->GetConstID())) {
         otOut << __FUNCTION__ << ": Merchant has wrong NymID (should be same "
                                  "as RecipientUserID.)\n";
         return false;
     }
     else if (GetSenderUserID() != id_PAYER_NYM) {
         otOut << __FUNCTION__
               << ": Payer has wrong NymID (should be same as SenderUserID.)\n";
         return false;
     }
     else if (PAYER_NYM.GetTransactionNumCount(GetServerID()) <
                2) // Need opening and closing numbers (that's 2)...
     {
         otOut << __FUNCTION__ << ": Failure. You need at least 2 transaction "
                                  "numbers available to do this.\n";
         return false;
     }
     else if (GetRecipientCountClosingNumbers() < 2) {
         otOut << __FUNCTION__ << ": Failure. (The merchant was supposed to "
                                  "attach 2 transaction numbers.)\n";
         return false;
     }
 
     // This is the single reason why MERCHANT_NYM was even passed in here!
     // Supposedly merchant has already signed.  Let's verify this!!
     //
     if ((nullptr != pMERCHANT_NYM) &&
         (false == VerifySignature(*pMERCHANT_NYM))) {
         otOut << __FUNCTION__ << ": Merchant's signature failed to verify.\n";
         return false;
     }
 
     // Now that we KNOW the merchant signed it... SAVE MERCHANT's COPY.
     // Let's save a copy of the one the merchant signed, before changing it and
     // re-signing it,
     // (to add my own transaction numbers...)
     //
     OTString strTemp;
     SaveContractRaw(strTemp);
     SetMerchantSignedCopy(strTemp);
 
     // The payer has to submit TWO transaction numbers in order to activate this
     // agreement...
     //
     OTString strServerID(GetServerID());
     int64_t lTransactionNumber = 0, lClosingTransactionNo = 0;
 
     if (false ==
         PAYER_NYM.GetNextTransactionNum(PAYER_NYM, strServerID,
                                         lTransactionNumber)) {
         otErr << __FUNCTION__
               << ": Error: Strangely unable to get a transaction number.\n";
         return false;
     }
     else if (false ==
                PAYER_NYM.GetNextTransactionNum(PAYER_NYM, strServerID,
                                                lClosingTransactionNo)) {
         otErr << __FUNCTION__ << ": Error: Strangely unable to get a closing "
                                  "transaction number.\n";
         PAYER_NYM.AddTransactionNum(PAYER_NYM, strServerID, lTransactionNumber,
                                     true); // bSave=true
         // (Since the first one was successful, we just put it back before
         // returning.)
         return false;
     }
 
     // At this point we now HAVE 2 transaction numbers (for payer / sender)...
     // We can't return without USING THEM or PUTTING THEM BACK.
     //
 
     SetTransactionNum(lTransactionNumber); // Set the Transaction Number
     AddClosingTransactionNo(
         lClosingTransactionNo); // and the Closing Number (both for sender)...
 
     // CREATION DATE was set in the Merchant's proposal, and it's RESET here in
     // the Confirm.
     // This way, (since we still have the original proposal) we can see BOTH
     // times.
     //
     time64_t CURRENT_TIME = OTTimeGetCurrentTime();
     // Set the Creation Date.
     SetCreationDate(CURRENT_TIME);
 
     otLog4 << __FUNCTION__ << "(): Success!\n";
 
     return true;
 }

bool opentxs::OTAgreement::DropServerNoticeToNymbox	(	bool	bSuccessMsg,
		OTPseudonym &	theServerNym,
		const OTIdentifier &	SERVER_ID,
		const OTIdentifier &	USER_ID,
		const int64_t &	lNewTransactionNumber,
		const int64_t &	lInReferenceTo,
		const OTString &	strReference,
		OTString *	pstrNote = `nullptr`,
		OTString *	pstrAttachment = `nullptr`,
		OTPseudonym *	pActualNym = `nullptr`
	)

static

Definition at line 271 of file OTAgreement.cpp.

 {
     OTLedger theLedger(USER_ID, USER_ID, SERVER_ID);
 
     // Inbox will receive notification of something ALREADY DONE.
     //
     bool bSuccessLoading = theLedger.LoadNymbox();
 
     if (true == bSuccessLoading)
         bSuccessLoading = theLedger.VerifyAccount(theServerNym);
     else
         bSuccessLoading = theLedger.GenerateLedger(
             USER_ID, SERVER_ID, OTLedger::nymbox, true); // bGenerateFile=true
 
     if (!bSuccessLoading) {
         otErr << __FUNCTION__ << ": Failed loading or generating a nymbox. "
                                  "(FAILED WRITING RECEIPT!!) \n";
         return false;
     }
 
     OTTransaction* pTransaction = OTTransaction::GenerateTransaction(
         theLedger, OTTransaction::notice, lNewTransactionNumber);
 
     if (nullptr !=
         pTransaction) // The above has an OT_ASSERT within, but I just
                       // like to check my pointers.
     {
         // The nymbox will get a receipt with the new transaction ID.
         // That receipt has an "in reference to" field containing the original
         // OTScriptable
 
         // Set up the transaction items (each transaction may have multiple
         // items... but not in this case.)
         //
         OTItem* pItem1 =
             OTItem::CreateItemFromTransaction(*pTransaction, OTItem::notice);
         OT_ASSERT(nullptr != pItem1); // This may be unnecessary, I'll have to
                                       // check CreateItemFromTransaction. I'll
                                       // leave it for now.
 
         pItem1->SetStatus(
             bSuccessMsg ? OTItem::acknowledgement
                         : OTItem::rejection); // ACKNOWLEDGMENT or REJECTION ?
 
         //
         // Here I make sure that the receipt (the nymbox notice) references the
         // transaction number that the trader originally used to issue the cron
         // item...
         // This number is used to match up offers to trades, and used to track
         // all cron items.
         // (All Cron items require a transaction from the user to add them to
         // Cron in the
         // first place.)
         //
         pTransaction->SetReferenceToNum(lInReferenceTo);
 
         // The reference on the transaction probably contains a the original
         // cron item or entity contract.
         // Versus the updated item (which, if it exists, is stored on the pItem1
         // just below.)
         //
         pTransaction->SetReferenceString(strReference);
 
         // The notice ITEM's NOTE probably contains the UPDATED SCRIPTABLE
         // (usually a CRON ITEM. But maybe soon: Entity.)
         if (nullptr != pstrNote) {
             pItem1->SetNote(*pstrNote); // in markets, this is updated trade.
         }
 
         // Nothing is special stored here so far for OTTransaction::notice, but
         // the option is always there.
         //
         if (nullptr != pstrAttachment) {
             pItem1->SetAttachment(*pstrAttachment);
         }
 
         // sign the item
         //
         pItem1->SignContract(theServerNym);
         pItem1->SaveContract();
 
         // the Transaction "owns" the item now and will handle cleaning it up.
         pTransaction->AddItem(*pItem1);
 
         pTransaction->SignContract(theServerNym);
         pTransaction->SaveContract();
 
         // Here the transaction we just created is actually added to the ledger.
         theLedger.AddTransaction(*pTransaction);
 
         // Release any signatures that were there before (They won't
         // verify anymore anyway, since the content has changed.)
         theLedger.ReleaseSignatures();
 
         // Sign and save.
         theLedger.SignContract(theServerNym);
         theLedger.SaveContract();
 
         // TODO: Better rollback capabilities in case of failures here:
 
         OTIdentifier theNymboxHash;
 
         // Save nymbox to storage. (File, DB, wherever it goes.)
         theLedger.SaveNymbox(&theNymboxHash);
 
         // Corresponds to the AddTransaction() call just above. These
         // are stored in a separate file now.
         //
         pTransaction->SaveBoxReceipt(theLedger);
 
         // Update the NymboxHash (in the nymfile.)
         //
         const OTIdentifier ACTUAL_NYM_ID = USER_ID;
         OTPseudonym theActualNym; // unused unless it's really not already
                                   // loaded. (use pActualNym.)
 
         // We couldn't find the Nym among those already loaded--so we have to
         // load
         // it ourselves (so we can update its NymboxHash value.)
 
         if (nullptr == pActualNym) {
             if (theServerNym.CompareID(ACTUAL_NYM_ID))
                 pActualNym = &theServerNym;
 
             else {
                 theActualNym.SetIdentifier(ACTUAL_NYM_ID);
 
                 if (!theActualNym.LoadPublicKey()) // Note: this step
                                                    // may be unnecessary
                                                    // since we are only
                                                    // updating his
                                                    // Nymfile, not his
                                                    // key.
                 {
                     OTString strNymID(ACTUAL_NYM_ID);
                     otErr << __FUNCTION__
                           << ": Failure loading public key for Nym: "
                           << strNymID << ". "
                                          "(To update his NymboxHash.) \n";
                 }
                 else if (theActualNym.VerifyPseudonym() && // this line may be
                                                              // unnecessary.
                            theActualNym.LoadSignedNymfile(
                                theServerNym)) // ServerNym here is not
                                               // theActualNym's identity, but
                                               // merely the signer on this file.
                 {
                     otLog3 << __FUNCTION__ << ": Loading actual Nym, since he "
                                               "wasn't already loaded. (To "
                                               "update his NymboxHash.)\n";
                     pActualNym = &theActualNym; //  <=====
                 }
                 else {
                     OTString strNymID(ACTUAL_NYM_ID);
                     otErr << __FUNCTION__
                           << ": Failure loading or verifying Actual Nym public "
                              "key: " << strNymID
                           << ". "
                              "(To update his NymboxHash.)\n";
                 }
             }
         }
 
         // By this point we've made every possible effort to get the proper Nym
         // loaded,
         // so that we can update his NymboxHash appropriately.
         //
         if (nullptr != pActualNym) {
             pActualNym->SetNymboxHashServerSide(theNymboxHash);
             pActualNym->SaveSignedNymfile(theServerNym);
         }
 
         // Really this true should be predicated on ALL the above functions
         // returning true.
         // Right?
         //
         return true; // Really this true should be predicated on ALL the above
                      // functions returning true. Right?
     }
     else
         otErr << __FUNCTION__ << ": Failed trying to create Nymbox.\n";
 
     return false; // unreachable.
 }

void opentxs::OTAgreement::GetAllTransactionNumbers ( OTNumList & numlistOutput ) const

virtual

Reimplemented from opentxs::OTTrackable.

Definition at line 482 of file OTAgreement.cpp.

 {
 
     if (GetTransactionNum() > 0) numlistOutput.Add(GetTransactionNum());
 
     const size_t nSizeClosing = m_dequeClosingNumbers.size();
 
     for (size_t nIndex = 0; nIndex < nSizeClosing; ++nIndex) {
         const int64_t lTemp = m_dequeClosingNumbers.at(nIndex);
         if (lTemp > 0) numlistOutput.Add(lTemp);
     }
 
     const size_t nSizeRecipient = m_dequeRecipientClosingNumbers.size();
 
     for (size_t nIndex = 0; nIndex < nSizeRecipient; ++nIndex) {
         const int64_t lTemp = m_dequeRecipientClosingNumbers.at(nIndex);
         if (lTemp > 0) numlistOutput.Add(lTemp);
     }
 }

int64_t opentxs::OTAgreement::GetClosingNumber ( const OTIdentifier & theAcctID ) const

virtual

Reimplemented from opentxs::OTCronItem.

Definition at line 970 of file OTAgreement.cpp.

 {
     const OTIdentifier& theRecipientAcctID = GetRecipientAcctID();
 
     if (theAcctID == theRecipientAcctID) return GetRecipientClosingNum();
     // else...
     return ot_super::GetClosingNumber(theAcctID);
 }

const OTString& opentxs::OTAgreement::GetConsideration ( ) const

inline

Definition at line 203 of file OTAgreement.hpp.

     {
         return m_strConsideration;
     }

const OTString& opentxs::OTAgreement::GetMerchantSignedCopy ( ) const

inline

Definition at line 211 of file OTAgreement.hpp.

     {
         return m_strMerchantSignedCopy;
     }

int64_t opentxs::OTAgreement::GetOpeningNumber ( const OTIdentifier & theNymID ) const

virtual

Reimplemented from opentxs::OTCronItem.

Definition at line 961 of file OTAgreement.cpp.

 {
     const OTIdentifier& theRecipientNymID = GetRecipientUserID();
 
     if (theNymID == theRecipientNymID) return GetRecipientOpeningNum();
     // else...
     return ot_super::GetOpeningNumber(theNymID);
 }

const OTIdentifier& opentxs::OTAgreement::GetRecipientAcctID ( ) const

inline

Definition at line 346 of file OTAgreement.hpp.

     {
         return m_RECIPIENT_ACCT_ID;
     }

int64_t opentxs::OTAgreement::GetRecipientClosingNum ( ) const

Definition at line 986 of file OTAgreement.cpp.

 {
     return (GetRecipientCountClosingNumbers() > 1)
                ? GetRecipientClosingTransactionNoAt(1)
                : 0; // todo stop hardcoding.
 }

int64_t opentxs::OTAgreement::GetRecipientClosingTransactionNoAt ( uint32_t nIndex ) const

Definition at line 998 of file OTAgreement.cpp.

 {
     OT_ASSERT_MSG(
         (nIndex < m_dequeRecipientClosingNumbers.size()),
         "OTAgreement::GetClosingTransactionNoAt: index out of bounds.");
 
     return m_dequeRecipientClosingNumbers.at(nIndex);
 }

int32_t opentxs::OTAgreement::GetRecipientCountClosingNumbers ( ) const

Definition at line 1007 of file OTAgreement.cpp.

 {
     return static_cast<int32_t>(m_dequeRecipientClosingNumbers.size());
 }

int64_t opentxs::OTAgreement::GetRecipientOpeningNum ( ) const

Definition at line 979 of file OTAgreement.cpp.

 {
     return (GetRecipientCountClosingNumbers() > 0)
                ? GetRecipientClosingTransactionNoAt(0)
                : 0; // todo stop hardcoding.
 }

const OTIdentifier& opentxs::OTAgreement::GetRecipientUserID ( ) const

inline

Definition at line 350 of file OTAgreement.hpp.

     {
         return m_RECIPIENT_USER_ID;
     }

void opentxs::OTAgreement::HarvestClosingNumbers ( OTPseudonym & theNym )

virtual

Reimplemented from opentxs::OTCronItem.

Definition at line 922 of file OTAgreement.cpp.

 {
     // Since we overrode the parent, we give it a chance to harvest also.
     // If theNym is the sender, then his closing numbers will be harvested
     // inside here. But what if the transaction was a success? The numbers
     // will still be harvested, since they are still on the sender's issued
     // list, but they should not have been harvested, regardless, since the
     // transaction was a success and the server therefore has them marked as
     // "used." So clearly you cannot just blindly call this function unless
     // you know beforehand whether the message and transaction were a success.
     //
     ot_super::HarvestClosingNumbers(theNym);
 
     // The Nym is the original recipient. (If Compares true).
     // FYI, if Nym is the original sender, then the above call will handle him.
     //
     // GetTransactionNum() is burned, but we can harvest the closing
     // numbers from the "Closing" list, which is only for the sender's numbers.
     // Subclasses will have to override this function for recipients, etc.
     //
     if (theNym.CompareID(GetRecipientUserID())) {
         //      otOut << "%s: Harvesting RECIPIENT...\n", __FUNCTION__);
 
         // This function will only "add it back" if it was really there in the
         // first place.
         // (Verifies it is on issued list first, before adding to available
         // list.)
         //
         const bool bClawedBack = theNym.ClawbackTransactionNumber(
             GetServerID(), GetRecipientClosingNum(), true); // bSave=true
 
         if (!bClawedBack) {
             //          otErr << "OTAgreement::HarvestClosingNumbers: Number
             // (%lld) failed as issued. (Thus didn't bother 'adding it
             // back'.)\n", GetRecipientClosingTransactionNoAt(i));
         }
     }
 }

void opentxs::OTAgreement::HarvestOpeningNumber ( OTPseudonym & theNym )

virtual

Reimplemented from opentxs::OTCronItem.

Definition at line 873 of file OTAgreement.cpp.

 {
     // since we overrode the parent, we give it a chance to harvest also.
     // IF theNym is the original sender, the opening number will be harvested
     // inside this call.
     //
     ot_super::HarvestOpeningNumber(theNym);
 
     // The Nym is the original recipient. (If Compares true).
     // IN CASES where GetTransactionNum() isn't already burned, we can harvest
     // it here.
     //
     if (theNym.CompareID(GetRecipientUserID())) {
         // This function will only "add it back" if it was really there in the
         // first place.
         // (Verifies it is on issued list first, before adding to available
         // list.)
         //
         const bool bClawedBack = theNym.ClawbackTransactionNumber(
             GetServerID(), GetRecipientOpeningNum(), true); // bSave=true
 
         if (!bClawedBack) {
             //          otErr << "OTAgreement::HarvestOpeningNumber: Number
             // (%lld) failed as issued. (Thus didn't bother 'adding it
             // back'.)\n", GetRecipientOpeningNum());
         }
     }
 
     // NOTE: if the message failed (transaction never actually ran) then the
     // sender AND recipient
     // can both reclaim their opening numbers. But if the message SUCCEEDED and
     // the transaction FAILED,
     // then only the recipient can claim his opening number -- the sender's is
     // already burned. So then,
     // what if you mistakenly call this function and pass the sender, when that
     // number is already burned?
     // There's nothing this function can do, because we have no way of telling,
     // from inside here,
     // whether the message succeeded or not, and whether the transaction
     // succeeded or not. Therefore,
     // ==> we MUST rely on the CALLER to know this, and to avoid calling this
     // function in the first place,
     // if he's sitting on a sender with a failed transaction.
 }

bool opentxs::OTAgreement::HasTransactionNum ( const int64_t & lInput ) const

virtual

Reimplemented from opentxs::OTTrackable.

Definition at line 463 of file OTAgreement.cpp.

 {
     if (lInput == GetTransactionNum()) return true;
 
     const size_t nSizeClosing = m_dequeClosingNumbers.size();
 
     for (size_t nIndex = 0; nIndex < nSizeClosing; ++nIndex) {
         if (lInput == m_dequeClosingNumbers.at(nIndex)) return true;
     }
 
     const size_t nSizeRecipient = m_dequeRecipientClosingNumbers.size();
 
     for (size_t nIndex = 0; nIndex < nSizeRecipient; ++nIndex) {
         if (lInput == m_dequeRecipientClosingNumbers.at(nIndex)) return true;
     }
 
     return false;
 }

void opentxs::OTAgreement::InitAgreement ( )

Definition at line 1489 of file OTAgreement.cpp.

 {
     m_strContractType = "AGREEMENT";
 }

bool opentxs::OTAgreement::IsValidOpeningNumber ( const int64_t & lOpeningNum ) const

virtual

Reimplemented from opentxs::OTCronItem.

Definition at line 851 of file OTAgreement.cpp.

 {
     if (GetRecipientOpeningNum() == lOpeningNum) return true;
 
     return ot_super::IsValidOpeningNumber(lOpeningNum);
 }

void opentxs::OTAgreement::onFinalReceipt	(	OTCronItem &	theOrigCronItem,
		const int64_t &	lNewTransactionNumber,
		OTPseudonym &	theOriginator,
		OTPseudonym *	pRemover
	)

protectedvirtual

Reimplemented from opentxs::OTCronItem.

Definition at line 528 of file OTAgreement.cpp.

 {
 
     OTCron* pCron = GetCron();
     OT_ASSERT(nullptr != pCron);
 
     OTPseudonym* pServerNym = pCron->GetServerNym();
     OT_ASSERT(nullptr != pServerNym);
 
     const char* szFunc = "OTAgreement::onFinalReceipt";
 
     // The finalReceipt Item's ATTACHMENT contains the UPDATED Cron Item.
     // (With the SERVER's signature on it!)
     //
     OTString strUpdatedCronItem(*this);
     OTString* pstrAttachment = &strUpdatedCronItem;
 
     const OTString strOrigCronItem(theOrigCronItem);
 
     OTPseudonym theRecipientNym; // Don't use this... use the pointer just
                                  // below.
 
     // The Nym who is actively requesting to remove a cron item will be passed
     // in as pRemover.
     // However, sometimes there is no Nym... perhaps it just expired and
     // pRemover is nullptr.
     // The originating Nym (if different than remover) is loaded up. Otherwise
     // the originator
     // pointer just pointers to *pRemover.
     //
     OTPseudonym* pRecipient = nullptr;
 
     if (pServerNym->CompareID(GetRecipientUserID())) {
         pRecipient = pServerNym; // Just in case the recipient Nym is also the
                                  // server Nym.
     }
     //
     // If pRemover is NOT nullptr, and he has the Recipient's ID...
     // then set the pointer accordingly.
     //
     else if ((nullptr != pRemover) &&
              (true == pRemover->CompareID(GetRecipientUserID()))) {
         pRecipient = pRemover; // <======== now both pointers are set (to same
                                // Nym). DONE!
     }
 
     if (nullptr == pRecipient) {
         // GetSenderUserID() should be the same on THIS (updated version of the
         // same cron item)
         // but for whatever reason, I'm checking the userID on the original
         // version. Sue me.
         //
         const OTIdentifier NYM_ID(GetRecipientUserID());
 
         theRecipientNym.SetIdentifier(NYM_ID);
 
         if (!theRecipientNym.LoadPublicKey()) {
             const OTString strNymID(NYM_ID);
             otErr << szFunc << ": Failure loading Recipient's public key:\n"
                   << strNymID << "\n";
         }
         else if (theRecipientNym.VerifyPseudonym() &&
                    theRecipientNym.LoadSignedNymfile(*pServerNym)) // ServerNym
                                                                    // here is
                                                                    // merely the
                                                                    // signer on
                                                                    // this file.
         {
             pRecipient = &theRecipientNym; //  <=====
         }
         else {
             const OTString strNymID(NYM_ID);
             otErr << szFunc << ": Failure verifying Recipient's public key or "
                                "loading signed nymfile: " << strNymID << "\n";
         }
     }
 
     // First, we are closing the transaction number ITSELF, of this cron item,
     // as an active issued number on the originating nym. (Changing it to
     // CLOSED.)
     //
     // Second, we're verifying the CLOSING number, and using it as the closing
     // number
     // on the FINAL RECEIPT (with that receipt being "InReferenceTo"
     // GetTransactionNum())
     //
     const int64_t lRecipientOpeningNumber = GetRecipientOpeningNum();
     const int64_t lRecipientClosingNumber = GetRecipientClosingNum();
 
     const int64_t lSenderOpeningNumber = theOrigCronItem.GetTransactionNum();
 
     const int64_t lSenderClosingNumber =
         (theOrigCronItem.GetCountClosingNumbers() > 0)
             ? theOrigCronItem.GetClosingTransactionNoAt(0)
             : 0; // index 0 is closing number for sender, since
                  // GetTransactionNum() is his opening #.
 
     const OTString strServerID(GetServerID());
 
     OTPseudonym theActualNym; // unused unless it's really not already loaded.
                               // (use pActualNym.)
 
     //
     if ((lSenderOpeningNumber > 0) &&
         theOriginator.VerifyIssuedNum(strServerID, lSenderOpeningNumber)) {
 
         OTPseudonym* pActualNym = nullptr; // use this. DON'T use theActualNym.
 
         // The Nym (server side) stores a list of all opening and closing cron
         // #s.
         // So when the number is released from the Nym, we also take it off that
         // list.
         //
         std::set<int64_t>& theIDSet = theOriginator.GetSetOpenCronItems();
         theIDSet.erase(lSenderOpeningNumber);
 
         // the RemoveIssued call means the original transaction# (to find this
         // cron item on cron) is now CLOSED.
         // But the Transaction itself is still OPEN. How? Because the CLOSING
         // number is still signed out.
         // The closing number is also USED, since the NotarizePaymentPlan or
         // NotarizeMarketOffer call, but it
         // remains ISSUED, until the final receipt itself is accepted during a
         // process inbox.
         //
         theOriginator.RemoveIssuedNum(*pServerNym, strServerID,
                                       lSenderOpeningNumber,
                                       false); // bSave=false
         theOriginator.SaveSignedNymfile(*pServerNym);
 
         const OTIdentifier& ACTUAL_NYM_ID = GetSenderUserID();
 
         if ((nullptr != pServerNym) && pServerNym->CompareID(ACTUAL_NYM_ID))
             pActualNym = pServerNym;
         else if (theOriginator.CompareID(ACTUAL_NYM_ID))
             pActualNym = &theOriginator;
         else if ((nullptr != pRemover) && pRemover->CompareID(ACTUAL_NYM_ID))
             pActualNym = pRemover;
 
         else // We couldn't find the Nym among those already loaded--so we have
              // to load
         {    // it ourselves (so we can update its NymboxHash value.)
             theActualNym.SetIdentifier(ACTUAL_NYM_ID);
 
             if (!theActualNym.LoadPublicKey()) // Note: this step may be
                                                // unnecessary since we
                                                // are only updating his
                                                // Nymfile, not his key.
             {
                 OTString strNymID(ACTUAL_NYM_ID);
                 otErr << szFunc
                       << ": Failure loading public key for Nym : " << strNymID
                       << ". "
                          "(To update his NymboxHash.) \n";
             }
             else if (theActualNym.VerifyPseudonym() && // this line may be
                                                          // unnecessary.
                        theActualNym.LoadSignedNymfile(
                            *pServerNym)) // ServerNym here is not theActualNym's
                                          // identity, but merely the signer on
                                          // this file.
             {
                 otLog3
                     << szFunc
                     << ": Loading actual Nym, since he wasn't already loaded. "
                        "(To update his NymboxHash.)\n";
                 pActualNym = &theActualNym; //  <=====
             }
             else {
                 OTString strNymID(ACTUAL_NYM_ID);
                 otErr
                     << szFunc
                     << ": Failure loading or verifying Actual Nym public key: "
                     << strNymID << ". "
                                    "(To update his NymboxHash.)\n";
             }
         }
 
         if (!DropFinalReceiptToNymbox(GetSenderUserID(), lNewTransactionNumber,
                                       strOrigCronItem, nullptr, pstrAttachment,
                                       pActualNym)) {
             otErr << szFunc
                   << ": Failure dropping sender final receipt into nymbox.\n";
         }
     }
     else {
         otErr << szFunc << ": Failure verifying sender's opening number.\n";
     }
 
     if ((lSenderClosingNumber > 0) &&
         theOriginator.VerifyIssuedNum(strServerID, lSenderClosingNumber)) {
         // In this case, I'm passing nullptr for pstrNote, since there is no
         // note.
         // (Additional information would normally be stored in the note.)
         //
         if (false ==
             DropFinalReceiptToInbox(
                 GetSenderUserID(), GetSenderAcctID(), lNewTransactionNumber,
                 lSenderClosingNumber, // The closing transaction number to put
                                       // on the receipt.
                 strOrigCronItem, nullptr,
                 pstrAttachment)) // pActualAcct=nullptr by default. (This call
                                  // will
                                  // load it up and update its inbox hash.)
             otErr << szFunc
                   << ": Failure dropping receipt into sender's inbox.\n";
 
         // This part below doesn't happen until theOriginator ACCEPTS the final
         // receipt (when processing his inbox.)
         //
         //      theOriginator.RemoveIssuedNum(strServerID, lSenderClosingNumber,
         // true); //bSave=false
     }
     else {
         otErr << szFunc
               << ": Failed verifying "
                  "lSenderClosingNumber=theOrigCronItem."
                  "GetClosingTransactionNoAt(0)>0 &&  "
                  "theOriginator.VerifyTransactionNum(lSenderClosingNumber)\n";
     }
 
     //
     if ((nullptr != pRecipient) && (lRecipientOpeningNumber > 0) &&
         pRecipient->VerifyIssuedNum(strServerID, lRecipientOpeningNumber)) {
         // The Nym (server side) stores a list of all opening and closing cron
         // #s.
         // So when the number is released from the Nym, we also take it off that
         // list.
         //
         std::set<int64_t>& theIDSet = pRecipient->GetSetOpenCronItems();
         theIDSet.erase(lRecipientOpeningNumber);
 
         // the RemoveIssued call means the original transaction# (to find this
         // cron item on cron) is now CLOSED.
         // But the Transaction itself is still OPEN. How? Because the CLOSING
         // number is still signed out.
         // The closing number is also USED, since the NotarizePaymentPlan or
         // NotarizeMarketOffer call, but it
         // remains ISSUED, until the final receipt itself is accepted during a
         // process inbox.
         //
         pRecipient->RemoveIssuedNum(*pServerNym, strServerID,
                                     lRecipientOpeningNumber,
                                     false); // bSave=false
         //      pRecipient->SaveSignedNymfile(*pServerNym); // Moved lower.
 
         if (false ==
             DropFinalReceiptToNymbox(
                 GetRecipientUserID(), lNewTransactionNumber, strOrigCronItem,
                 nullptr, pstrAttachment,
                 pRecipient)) // NymboxHash is updated here in pRecipient.
         {
             otErr
                 << szFunc
                 << ": Failure dropping recipient final receipt into nymbox.\n";
         }
 
         // Saving both the Removed Issued Number, as well as the new NymboxHash.
         // NOTE: Todo: if the NymboxHash WAS updated (as it should have been)
         // then
         // it was probably saved at that time. Below is therefore a redundant
         // save.
         // Need to fix by making certain objects savable and dirty, and then let
         // them
         // autosave before destruction, IF they are dirty.
         //
         pRecipient->SaveSignedNymfile(*pServerNym);
     }
     else {
         otErr << szFunc
               << ": Failed verifying "
                  "lRecipientClosingNumber="
                  "GetRecipientClosingTransactionNoAt(1)>0 &&  "
                  "pRecipient->VerifyTransactionNum(lRecipientClosingNumber) && "
                  "VerifyIssuedNum(lRecipientOpeningNumber)\n";
     }
 
     //
     if ((nullptr != pRecipient) && (lRecipientClosingNumber > 0) &&
         pRecipient->VerifyIssuedNum(strServerID, lRecipientClosingNumber)) {
         if (!DropFinalReceiptToInbox(
                 GetRecipientUserID(), GetRecipientAcctID(),
                 lNewTransactionNumber,
                 lRecipientClosingNumber, // The closing transaction
                                          // number to put on the
                                          // receipt.
                 strOrigCronItem, nullptr, pstrAttachment))
             otErr << szFunc
                   << ": Failure dropping receipt into recipient's inbox.\n";
 
         // This part below doesn't happen until pRecipient ACCEPTs the final
         // receipt (when processing his inbox.)
         //
         //      pRecipient->RemoveIssuedNum(strServerID,
         // lRecipientClosingNumber, true); //bSave=false
     }
     else {
         otErr << szFunc
               << ": Failed verifying "
                  "lRecipientClosingNumber="
                  "GetRecipientClosingTransactionNoAt(1)>0 &&  "
                  "pRecipient->VerifyTransactionNum(lRecipientClosingNumber) && "
                  "VerifyIssuedNum(lRecipientOpeningNumber)\n";
     }
 
     // QUESTION: Won't there be Cron Items that have no asset account at all?
     // In which case, there'd be no need to drop a final receipt, but I don't
     // think
     // that's the case, since you have to use a transaction number to get onto
     // cron
     // in the first place.
 }

void opentxs::OTAgreement::onRemovalFromCron ( )

protectedvirtual

Reimplemented from opentxs::OTCronItem.

Definition at line 858 of file OTAgreement.cpp.

 {
     // Not much needed here.
     // Actually: Todo:  (unless it goes in payment plan code) need to set
     // receipts
     // in inboxes, and close out the closing transaction numbers.
     //
 }

bool opentxs::OTAgreement::ProcessCron ( )

virtual

Reimplemented from opentxs::OTCronItem.

Reimplemented in opentxs::OTPaymentPlan.

Definition at line 1020 of file OTAgreement.cpp.

 {
     // END DATE --------------------------------
     // First call the parent's version (which this overrides) so it has
     // a chance to check its stuff. Currently it checks IsExpired().
     if (!ot_super::ProcessCron())
         return false; // It's expired or flagged--removed it from Cron.
 
     // START DATE --------------------------------
     // Okay, so it's NOT expired. But might not have reached START DATE yet...
     // (If not expired, yet current date is not verified, that means it hasn't
     // ENTERED the date range YET.)
     //
     if (!VerifyCurrentDate())
         return true; // The Trade is not yet valid, so we return. BUT, we return
                      //  true, so it will stay on Cron until it BECOMES valid.
 
     // Process my Agreement-specific stuff
     // below.--------------------------------
 
     return true;
 }

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

virtual

Reimplemented from opentxs::OTCronItem.

Reimplemented in opentxs::OTPaymentPlan.

Definition at line 1526 of file OTAgreement.cpp.

 {
     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 (0 != (nReturnVal = ot_super::ProcessXMLNode(xml))) return nReturnVal;
 
     if (!strcmp("agreement", xml->getNodeName())) {
         m_strVersion = xml->getAttributeValue("version");
         SetTransactionNum(atol(xml->getAttributeValue("transactionNum")));
 
         const OTString strCreation = xml->getAttributeValue("creationDate");
         int64_t tCreation = strCreation.ToLong();
 
         SetCreationDate(OTTimeGetTimeFromSeconds(tCreation));
 
         const OTString str_valid_from = xml->getAttributeValue("validFrom");
         const OTString str_valid_to = xml->getAttributeValue("validTo");
 
         int64_t tValidFrom = str_valid_from.ToLong();
         int64_t tValidTo = str_valid_to.ToLong();
 
         SetValidFrom(OTTimeGetTimeFromSeconds(tValidFrom));
         SetValidTo(OTTimeGetTimeFromSeconds(tValidTo));
 
         const OTString strServerID(xml->getAttributeValue("serverID")),
             strAssetTypeID(xml->getAttributeValue("assetTypeID")),
             strSenderAcctID(xml->getAttributeValue("senderAcctID")),
             strSenderUserID(xml->getAttributeValue("senderUserID")),
             strRecipientAcctID(xml->getAttributeValue("recipientAcctID")),
             strRecipientUserID(xml->getAttributeValue("recipientUserID")),
             strCanceled(xml->getAttributeValue("canceled")),
             strCancelerUserID(xml->getAttributeValue("cancelerUserID"));
 
         if (strCanceled.Exists() && strCanceled.Compare("true")) {
             m_bCanceled = true;
 
             if (strCancelerUserID.Exists())
                 m_pCancelerNymID->SetString(strCancelerUserID);
             // else log
         }
         else {
             m_bCanceled = false;
             m_pCancelerNymID->Release();
         }
 
         const OTIdentifier SERVER_ID(strServerID), ASSET_ID(strAssetTypeID),
             SENDER_ACCT_ID(strSenderAcctID), SENDER_USER_ID(strSenderUserID),
             RECIPIENT_ACCT_ID(strRecipientAcctID),
             RECIPIENT_USER_ID(strRecipientUserID);
 
         SetServerID(SERVER_ID);
         SetAssetID(ASSET_ID);
         SetSenderAcctID(SENDER_ACCT_ID);
         SetSenderUserID(SENDER_USER_ID);
         SetRecipientAcctID(RECIPIENT_ACCT_ID);
         SetRecipientUserID(RECIPIENT_USER_ID);
 
         otWarn << "\n\n" << (m_bCanceled ? "Canceled a" : "A")
                << "greement. Transaction Number: " << m_lTransactionNum << "\n";
 
         otInfo << " Creation Date: " << tCreation
                << "   Valid From: " << tValidFrom << "\n Valid To: " << tValidTo
                << "\n"
                   " AssetTypeID: " << strAssetTypeID
                << "\n ServerID: " << strServerID
                << "\n"
                   " senderAcctID: " << strSenderAcctID
                << "\n senderUserID: " << strSenderUserID
                << "\n "
                   " recipientAcctID: " << strRecipientAcctID
                << "\n recipientUserID: " << strRecipientUserID << "\n ";
 
         nReturnVal = 1;
     }
     else if (!strcmp("consideration", xml->getNodeName())) {
         if (false ==
             OTContract::LoadEncodedTextField(xml, m_strConsideration)) {
             otErr << "Error in OTPaymentPlan::ProcessXMLNode: consideration "
                      "field without value.\n";
             return (-1); // error condition
         }
 
         nReturnVal = 1;
     }
     else if (!strcmp("merchantSignedCopy", xml->getNodeName())) {
         if (false ==
             OTContract::LoadEncodedTextField(xml, m_strMerchantSignedCopy)) {
             otErr << "Error in OTPaymentPlan::ProcessXMLNode: "
                      "merchant_signed_copy field without value.\n";
             return (-1); // error condition
         }
 
         nReturnVal = 1;
     }
 
     //  std::deque<int64_t>   m_dequeRecipientClosingNumbers; // Numbers used
     // for CLOSING a transaction. (finalReceipt.)
     else if (!strcmp("closingRecipientNumber", xml->getNodeName())) {
         OTString strClosingNumber = xml->getAttributeValue("value");
 
         if (strClosingNumber.Exists()) {
             const int64_t lClosingNumber = atol(strClosingNumber.Get());
 
             AddRecipientClosingTransactionNo(lClosingNumber);
         }
         else {
             otErr << "Error in OTAgreement::ProcessXMLNode: "
                      "closingRecipientNumber field without value.\n";
             return (-1); // error condition
         }
 
         nReturnVal = 1;
     }
 
     return nReturnVal;
 }

void opentxs::OTAgreement::Release ( void )

virtual

Reimplemented from opentxs::OTCronItem.

Reimplemented in opentxs::OTPaymentPlan.

Definition at line 1509 of file OTAgreement.cpp.

 {
     Release_Agreement();
 
     ot_super::Release(); // since I've overridden the base class (OTCronItem),
                          // so I call it now...
 
     // Then I call this to re-initialize everything
     InitAgreement();
 }

void opentxs::OTAgreement::Release_Agreement ( )

Definition at line 1494 of file OTAgreement.cpp.

 {
     // If there were any dynamically allocated objects, clean them up here.
     //
     m_RECIPIENT_ACCT_ID.Release();
     m_RECIPIENT_USER_ID.Release();
 
     m_strConsideration.Release();
     m_strMerchantSignedCopy.Release();
 
     m_dequeRecipientClosingNumbers.clear();
 }

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

virtual

Reimplemented from opentxs::OTInstrument.

Reimplemented in opentxs::OTPaymentPlan.

Definition at line 1651 of file OTAgreement.cpp.

 {
     return true;
 }

bool opentxs::OTAgreement::SendNoticeToAllParties	(	bool	bSuccessMsg,
		OTPseudonym &	theServerNym,
		const OTIdentifier &	theServerID,
		const int64_t &	lNewTransactionNumber,
		const OTString &	strReference,
		OTString *	pstrNote = `nullptr`,
		OTString *	pstrAttachment = `nullptr`,
		OTPseudonym *	pActualNym = `nullptr`
	)		const

Definition at line 150 of file OTAgreement.cpp.

 {
     bool bSuccess =
         true; // Success is defined as ALL parties receiving a notice
 
     OTPseudonym theRecipientNym; // Don't use this... use the pointer just
                                  // below.
     OTPseudonym* pRecipient = nullptr;
 
     if (theServerNym.CompareID(GetRecipientUserID())) {
         pRecipient = &theServerNym; // Just in case the recipient Nym is also
                                     // the server Nym.
     }
     else if ((nullptr != pActualNym) &&
                pActualNym->CompareID(GetRecipientUserID())) {
         pRecipient = pActualNym;
     }
 
     if (nullptr == pRecipient) {
         const OTIdentifier NYM_ID(GetRecipientUserID());
         theRecipientNym.SetIdentifier(NYM_ID);
 
         if (!theRecipientNym.LoadPublicKey()) {
             const OTString strNymID(NYM_ID);
             otErr << __FUNCTION__
                   << ": Failure loading Recipient's public key: " << strNymID
                   << "\n";
             return false;
         }
         else if (theRecipientNym.VerifyPseudonym() &&
                    theRecipientNym.LoadSignedNymfile(
                        theServerNym)) // ServerNym here is merely the signer on
                                       // this file.
         {
             pRecipient = &theRecipientNym; //  <=====
         }
         else {
             const OTString strNymID(NYM_ID);
             otErr << __FUNCTION__
                   << ": Failure verifying Recipient's public key or loading "
                      "signed nymfile: " << strNymID << "\n";
             return false;
         }
     }
     // BY THIS POINT, the Recipient Nym is definitely loaded up and we have
     // a pointer to him (pRecipient.)
 
     OTPseudonym theSenderNym; // Don't use this... use the pointer just below.
     OTPseudonym* pSender = nullptr;
 
     if (theServerNym.CompareID(GetSenderUserID())) {
         pSender = &theServerNym; // Just in case the Sender Nym is also the
                                  // server Nym.
     }
     else if ((nullptr != pActualNym) &&
                pActualNym->CompareID(GetSenderUserID())) {
         pSender = pActualNym;
     }
 
     if (nullptr == pSender) {
         const OTIdentifier NYM_ID(GetSenderUserID());
         theSenderNym.SetIdentifier(NYM_ID);
 
         if (!theSenderNym.LoadPublicKey()) {
             const OTString strNymID(NYM_ID);
             otErr << __FUNCTION__
                   << ": Failure loading Sender's public key: " << strNymID
                   << "\n";
             return false;
         }
         else if (theSenderNym.VerifyPseudonym() &&
                    theSenderNym.LoadSignedNymfile(theServerNym)) // ServerNym
                                                                  // here is
                                                                  // merely the
                                                                  // signer on
                                                                  // this file.
         {
             pSender = &theSenderNym; //  <=====
         }
         else {
             const OTString strNymID(NYM_ID);
             otErr << __FUNCTION__ << ": Failure verifying Sender's public key "
                                      "or loading signed nymfile: " << strNymID
                   << "\n";
             return false;
         }
     }
     // BY THIS POINT, the Sender Nym is definitely loaded up and we have
     // a pointer to him (pSender.)
 
     // (pRecipient and pSender are both good pointers by this point.)
 
     // Sender
     if (!OTAgreement::DropServerNoticeToNymbox(
             bSuccessMsg, // "success" notice? or "failure" notice?
             theServerNym, theServerID, GetSenderUserID(), lNewTransactionNumber,
             GetTransactionNum(), // in reference to
             strReference, pstrNote, pstrAttachment, pSender))
         bSuccess = false;
     // Notice I don't break here -- I still allow it to try to notice ALL
     // parties, even if one fails.
 
     // Recipient
     if (!OTAgreement::DropServerNoticeToNymbox(
             bSuccessMsg, // "success" notice? or "failure" notice?
             theServerNym, theServerID, GetRecipientUserID(),
             lNewTransactionNumber,
             GetRecipientOpeningNum(), // in reference to
             strReference, pstrNote, pstrAttachment, pRecipient))
         bSuccess = false;
 
     return bSuccess;
 }

void opentxs::OTAgreement::SetMerchantSignedCopy ( const OTString & strMerchantCopy )

inline

Definition at line 207 of file OTAgreement.hpp.

     {
         m_strMerchantSignedCopy = strMerchantCopy;
     }

bool opentxs::OTAgreement::SetProposal	(	OTPseudonym &	MERCHANT_NYM,
		const OTString &	strConsideration,
		time64_t	VALID_FROM = `OT_TIME_ZERO`,
		time64_t	VALID_TO = `OT_TIME_ZERO`
	)

Definition at line 1155 of file OTAgreement.cpp.

 {
 
     OTIdentifier id_MERCHANT_NYM;
     MERCHANT_NYM.GetIdentifier(id_MERCHANT_NYM);
 
     if (GetRecipientUserID() != id_MERCHANT_NYM) {
         otOut << __FUNCTION__ << ": Merchant has wrong NymID (should be same "
                                  "as RecipientUserID.)\n";
         return false;
     }
     else if (GetRecipientUserID() == GetSenderUserID()) {
         otOut << __FUNCTION__ << ": Error: Sender and recipient have the same "
                                  "Nym ID (not allowed.)\n";
         return false;
     }
     else if (MERCHANT_NYM.GetTransactionNumCount(GetServerID()) <
                2) // Need opening and closing numbers (that's 2)...
     {
         otOut << __FUNCTION__ << ": Failure. You need at least 2 transaction "
                                  "numbers available to do this.\n";
         return false;
     }
 
     // Set the CREATION DATE
     //
     const time64_t CURRENT_TIME = OTTimeGetCurrentTime();
 
     // Set the Creation Date.
     SetCreationDate(CURRENT_TIME);
 
     // Putting this above here so I don't have to put the transaction numbers
     // back if this fails:
 
     // VALID_FROM
     //
     // The default "valid from" time is NOW.
     if (OT_TIME_ZERO >= VALID_FROM) // if it's 0 or less, set to current time.
         SetValidFrom(CURRENT_TIME);
     else // Otherwise use whatever was passed in.
         SetValidFrom(VALID_FROM);
 
     // VALID_TO
     //
     // The default "valid to" time is 0 (which means no expiration date / cancel
     // anytime.)
     if (OT_TIME_ZERO == VALID_TO) // VALID_TO is 0
     {
         SetValidTo(VALID_TO); // Keep it at zero then, so it won't expire.
     }
     else if (OT_TIME_ZERO < VALID_TO) // VALID_TO is ABOVE zero...
     {
         SetValidTo(OTTimeAddTimeInterval(
             GetValidFrom(), OTTimeGetSecondsFromTime(VALID_TO))); // Set it to
                                                                   // itself +
                                                                   // valid_from.
     }
     else // VALID_TO is a NEGATIVE number... Error.
     {
         int64_t lValidTo = OTTimeGetSecondsFromTime(VALID_TO);
         otErr << __FUNCTION__ << ": Negative value for valid_to: " << lValidTo
               << "\n";
 
         return false;
     }
 
     // Since we'll be needing 2 transaction numbers to do this, let's grab
     // 'em...
     //
     OTString strServerID(GetServerID());
 
     int64_t lTransactionNumber = 0, lClosingTransactionNo = 0;
 
     if (MERCHANT_NYM.GetTransactionNumCount(GetServerID()) <
         2) // Need opening and closing numbers (that's 2)...
     {
         otOut << __FUNCTION__ << ": Failure. You need at least 2 transaction "
                                  "numbers available to do this.\n";
         return false;
     }
     else if (false ==
                MERCHANT_NYM.GetNextTransactionNum(MERCHANT_NYM, strServerID,
                                                   lTransactionNumber)) {
         otErr << __FUNCTION__
               << ": Error: Strangely unable to get a transaction number.\n";
         return false;
     }
     else if (false ==
                MERCHANT_NYM.GetNextTransactionNum(MERCHANT_NYM, strServerID,
                                                   lClosingTransactionNo)) {
         otErr << __FUNCTION__ << ": Error: Strangely unable to get a closing "
                                  "transaction number.\n";
         MERCHANT_NYM.AddTransactionNum(MERCHANT_NYM, strServerID,
                                        lTransactionNumber, true); // bSave=true
         // (Since the first one was successful, we just put it back before
         // returning.)
         return false;
     }
 
     // At this point we now have 2 transaction numbers...
     // We can't return without either USING THEM, or PUTTING THEM BACK.
     //
 
     // Set the Transaction Number and the Closing transaction number... (for
     // merchant / recipient.)
     //
     AddRecipientClosingTransactionNo(lTransactionNumber);
     AddRecipientClosingTransactionNo(lClosingTransactionNo);
     // (They just both go onto this same list.)
 
     // Set the Consideration memo...
     m_strConsideration.Set(strConsideration);
 
     otLog4 << "Successfully performed SetProposal.\n";
     return true;
 }

void opentxs::OTAgreement::SetRecipientAcctID ( const OTIdentifier & ACCT_ID )

inline

Definition at line 354 of file OTAgreement.hpp.

     {
         m_RECIPIENT_ACCT_ID = ACCT_ID;
     }

void opentxs::OTAgreement::SetRecipientUserID ( const OTIdentifier & USER_ID )

inline

Definition at line 358 of file OTAgreement.hpp.

     {
         m_RECIPIENT_USER_ID = USER_ID;
     }

void opentxs::OTAgreement::UpdateContents ( )

virtual

Reimplemented from opentxs::OTTrackable.

Reimplemented in opentxs::OTPaymentPlan.

Definition at line 1520 of file OTAgreement.cpp.

 {
     // See OTPaymentPlan::UpdateContents.
 }

virtual bool opentxs::OTAgreement::VerifyAgreement	(	OTPseudonym &	RECIPIENT_NYM,
		OTPseudonym &	SENDER_NYM
	)		const

pure virtual

Implemented in opentxs::OTPaymentPlan.

bool opentxs::OTAgreement::VerifyNymAsAgent	(	OTPseudonym &	theNym,
		OTPseudonym &	theSignerNym,
		mapOfNyms *	pmap_ALREADY_LOADED = `nullptr`
	)		const

virtual

Reimplemented from opentxs::OTScriptable.

Definition at line 509 of file OTAgreement.cpp.

 {
     return VerifySignature(theNym);
 }

bool opentxs::OTAgreement::VerifyNymAsAgentForAccount	(	OTPseudonym &	theNym,
		OTAccount &	theAccount
	)		const

virtual

Reimplemented from opentxs::OTScriptable.

Definition at line 518 of file OTAgreement.cpp.

 {
     return theAccount.VerifyOwner(theNym);
 }

Member Data Documentation

std::deque<int64_t> opentxs::OTAgreement::m_dequeRecipientClosingNumbers

protected

Definition at line 197 of file OTAgreement.hpp.

OTString opentxs::OTAgreement::m_strConsideration

protected

Definition at line 179 of file OTAgreement.hpp.

OTString opentxs::OTAgreement::m_strMerchantSignedCopy

protected

Definition at line 182 of file OTAgreement.hpp.

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

/usr/local/src/opentxs/include/opentxs/core/recurring/OTAgreement.hpp
/usr/local/src/opentxs/src/core/recurring/OTAgreement.cpp

Public Member Functions

Static Public Member Functions

Protected Member Functions

Protected Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation