#include <OTPayment.hpp>

Inheritance diagram for opentxs::OTPayment:

Collaboration diagram for opentxs::OTPayment:

Public Types
enum	paymentType { CHEQUE, VOUCHER, INVOICE, PAYMENT_PLAN, SMART_CONTRACT, PURSE, ERROR_STATE }

Public Member Functions
EXPORT bool	SetPayment (const OTString &strPayment)

EXPORT bool	IsCheque () const

EXPORT bool	IsVoucher () const

EXPORT bool	IsInvoice () const

EXPORT bool	IsPaymentPlan () const

EXPORT bool	IsSmartContract () const

EXPORT bool	IsPurse () const

EXPORT bool	IsValid () const

EXPORT paymentType	GetType () const

EXPORT OTTrackable *	Instantiate () const

EXPORT OTTrackable *	Instantiate (const OTString &strPayment)

EXPORT Purse *	InstantiatePurse () const

EXPORT Purse *	InstantiatePurse (const OTString &strPayment)

EXPORT bool	GetPaymentContents (OTString &strOutput) const

EXPORT bool	SetTempValues ()

EXPORT bool	SetTempValuesFromCheque (const OTCheque &theInput)

EXPORT bool	SetTempValuesFromPaymentPlan (const OTPaymentPlan &theInput)

EXPORT bool	SetTempValuesFromSmartContract (const OTSmartContract &theInput)

EXPORT bool	SetTempValuesFromPurse (const Purse &theInput)

EXPORT bool	GetAmount (int64_t &lOutput) const

EXPORT bool	GetTransactionNum (int64_t &lOutput) const

EXPORT bool	GetOpeningNum (int64_t &lOutput, const OTIdentifier &theNymID) const

EXPORT bool	GetClosingNum (int64_t &lOutput, const OTIdentifier &theAcctID) const

EXPORT bool	GetAllTransactionNumbers (OTNumList &numlistOutput) const

EXPORT bool	HasTransactionNum (const int64_t &lInput) const

EXPORT bool	GetMemo (OTString &strOutput) const

EXPORT bool	GetAssetTypeID (OTIdentifier &theOutput) const

EXPORT bool	GetServerID (OTIdentifier &theOutput) const

EXPORT bool	GetSenderUserID (OTIdentifier &theOutput) const

EXPORT bool	GetSenderAcctID (OTIdentifier &theOutput) const

EXPORT bool	GetRecipientUserID (OTIdentifier &theOutput) const

EXPORT bool	GetRecipientAcctID (OTIdentifier &theOutput) const

EXPORT bool	GetRemitterUserID (OTIdentifier &theOutput) const

EXPORT bool	GetRemitterAcctID (OTIdentifier &theOutput) const

EXPORT bool	GetSenderUserIDForDisplay (OTIdentifier &theOutput) const

EXPORT bool	GetSenderAcctIDForDisplay (OTIdentifier &theOutput) const

EXPORT bool	GetValidFrom (time64_t &tOutput) const

EXPORT bool	GetValidTo (time64_t &tOutput) const

EXPORT bool	VerifyCurrentDate (bool &bVerified)

EXPORT bool	IsExpired (bool &bExpired)

EXPORT	OTPayment ()

EXPORT	OTPayment (const OTString &strPayment)

virtual EXPORT	~OTPayment ()

EXPORT void	InitPayment ()

virtual EXPORT void	Release ()

EXPORT void	Release_Payment ()

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

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

EXPORT const char *	GetTypeString () 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 EXPORT const char *	_GetTypeString (paymentType theType)

static EXPORT paymentType	GetTypeFromString (const OTString &strType)

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	UpdateContents ()

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

Protected Attributes
OTString	m_strPayment

paymentType	m_Type

bool	m_bAreTempValuesSet

bool	m_bHasRecipient

bool	m_bHasRemitter

int64_t	m_lAmount

int64_t	m_lTransactionNum

OTString	m_strMemo

OTIdentifier	m_AssetTypeID

OTIdentifier	m_ServerID

OTIdentifier	m_SenderUserID

OTIdentifier	m_SenderAcctID

OTIdentifier	m_RecipientUserID

OTIdentifier	m_RecipientAcctID

OTIdentifier	m_RemitterUserID

OTIdentifier	m_RemitterAcctID

time64_t	m_VALID_FROM

time64_t	m_VALID_TO

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 196 of file OTPayment.hpp.

Member Enumeration Documentation

enum opentxs::OTPayment::paymentType

Enumerator
CHEQUE
VOUCHER
INVOICE
PAYMENT_PLAN
SMART_CONTRACT
PURSE
ERROR_STATE

Definition at line 202 of file OTPayment.hpp.

                      {
         // OTCheque is derived from OTTrackable, which is derived from
         // OTInstrument, which is
         // derived from OTScriptable, which is derived from OTContract.
         CHEQUE,  // A cheque drawn on a user's account.
         VOUCHER, // A cheque drawn on a server account (cashier's cheque aka
                  // banker's cheque)
         INVOICE, // A cheque with a negative amount. (Depositing this causes a
                  // payment out, instead of a deposit in.)
         PAYMENT_PLAN,   // An OTCronItem-derived OTPaymentPlan, related to a
                         // recurring payment plan.
         SMART_CONTRACT, // An OTCronItem-derived OTSmartContract, related to a
                         // smart contract.
         PURSE, // An OTContract-derived OTPurse containing a list of cash
                // OTTokens.
         ERROR_STATE
     }; // If you add any types to this list, update the list of strings at the

Constructor & Destructor Documentation

opentxs::OTPayment::OTPayment ( )

Definition at line 1225 of file OTPayment.cpp.

     : ot_super()
     , m_Type(OTPayment::ERROR_STATE)
     , m_bAreTempValuesSet(false)
     , m_bHasRecipient(false)
     , m_bHasRemitter(false)
     , m_lAmount(0)
     , m_lTransactionNum(0)
     , m_VALID_FROM(OT_TIME_ZERO)
     , m_VALID_TO(OT_TIME_ZERO)
 {
     InitPayment();
 }

opentxs::OTPayment::OTPayment ( const OTString & strPayment )

Definition at line 1239 of file OTPayment.cpp.

     : ot_super()
     , m_Type(OTPayment::ERROR_STATE)
     , m_bAreTempValuesSet(false)
     , m_bHasRecipient(false)
     , m_bHasRemitter(false)
     , m_lAmount(0)
     , m_lTransactionNum(0)
     , m_VALID_FROM(OT_TIME_ZERO)
     , m_VALID_TO(OT_TIME_ZERO)
 {
     InitPayment();
 
     SetPayment(strPayment);
 }

opentxs::OTPayment::~OTPayment ( )

virtual

Definition at line 1517 of file OTPayment.cpp.

 {
     Release_Payment();
 }

Member Function Documentation

const char * opentxs::OTPayment::_GetTypeString ( paymentType theType )

static

Definition at line 171 of file OTPayment.cpp.

 {
     int32_t nType = static_cast<int32_t>(theType);
     return __TypeStrings[nType];
 }

bool opentxs::OTPayment::GetAllTransactionNumbers ( OTNumList & numlistOutput ) const

Definition at line 533 of file OTPayment.cpp.

 {
     // SMART CONTRACTS and PAYMENT PLANS get a little special
     // treatment here at the top.
     //
     if ((false == m_bAreTempValuesSet) || // Why is this here? Because if temp
                                           // values haven't been set yet,
         (OTPayment::SMART_CONTRACT ==
          m_Type) || // then m_Type isn't set either. We only want smartcontracts
                     // and   UPDATE: m_Type IS set!!
         (OTPayment::PAYMENT_PLAN == m_Type)) // payment plans here, but without
                                              // m_Type we can't know the
                                              // type...This comment is wrong!!
     {
         OTTrackable* pTrackable = Instantiate();
         if (nullptr == pTrackable) {
             otErr << __FUNCTION__
                   << ": Failed instantiating OTPayment containing:\n"
                   << m_strPayment << "\n";
             return false;
         } // Below THIS POINT, MUST DELETE pTrackable!
         std::unique_ptr<OTTrackable> theTrackableAngel(pTrackable);
 
         OTPaymentPlan* pPlan = nullptr;
         OTSmartContract* pSmartContract = nullptr;
 
         pPlan = dynamic_cast<OTPaymentPlan*>(pTrackable);
         pSmartContract = dynamic_cast<OTSmartContract*>(pTrackable);
 
         if (nullptr != pPlan) {
             pPlan->GetAllTransactionNumbers(numlistOutput);
             return true;
         }
         else if (nullptr != pSmartContract) {
             pSmartContract->GetAllTransactionNumbers(numlistOutput);
             return true;
         }
     }
 
     if (!m_bAreTempValuesSet) // (This function normally fails, if temp values
                               // aren't set,
         return false; //  for all payment types except the recurring ones
                       // above.)
 
     // Next: ALL OTHER payment types...
     //
     bool bSuccess = false;
 
     switch (m_Type) {
     case OTPayment::CHEQUE:
     case OTPayment::VOUCHER:
     case OTPayment::INVOICE:
         if (m_lTransactionNum > 0) numlistOutput.Add(m_lTransactionNum);
         bSuccess = true;
         break;
 
     case OTPayment::PURSE:
         bSuccess = false;
         break;
 
     default:
     case OTPayment::PAYMENT_PLAN:   // Should never happen. (Handled already
                                     // above.)
     case OTPayment::SMART_CONTRACT: // Should never happen. (Handled already
                                     // above.)
         otErr << "OTPayment::" << __FUNCTION__ << ": Bad payment type!\n";
         break;
     }
 
     return bSuccess;
 }

bool opentxs::OTPayment::GetAmount ( int64_t & lOutput ) const

Definition at line 502 of file OTPayment.cpp.

 {
     lOutput = 0;
 
     if (!m_bAreTempValuesSet) return false;
 
     bool bSuccess = false;
 
     switch (m_Type) {
     case OTPayment::CHEQUE:
     case OTPayment::VOUCHER:
     case OTPayment::INVOICE:
     case OTPayment::PAYMENT_PLAN:
     case OTPayment::PURSE:
         lOutput = m_lAmount;
         bSuccess = true;
         break;
 
     case OTPayment::SMART_CONTRACT:
         lOutput = 0;
         bSuccess = false;
         break;
 
     default:
         otErr << "OTPayment::GetAmount: Bad payment type!\n";
         break;
     }
 
     return bSuccess;
 }

bool opentxs::OTPayment::GetAssetTypeID ( OTIdentifier & theOutput ) const

Definition at line 963 of file OTPayment.cpp.

 {
     theOutput.Release();
 
     if (!m_bAreTempValuesSet) return false;
 
     bool bSuccess = false;
 
     switch (m_Type) {
     case OTPayment::CHEQUE:
     case OTPayment::VOUCHER:
     case OTPayment::INVOICE:
     case OTPayment::PAYMENT_PLAN:
     case OTPayment::PURSE:
         theOutput = m_AssetTypeID;
         bSuccess = true;
         break;
 
     case OTPayment::SMART_CONTRACT:
         bSuccess = false;
         break;
 
     default:
         otErr << "OTPayment::GetAssetTypeID: Bad payment type!\n";
         break;
     }
 
     return bSuccess;
 }

bool opentxs::OTPayment::GetClosingNum	(	int64_t &	lOutput,
		const OTIdentifier &	theAcctID
	)		const

Definition at line 679 of file OTPayment.cpp.

 {
     lOutput = 0;
 
     // SMART CONTRACTS and PAYMENT PLANS get a little special
     // treatment here at the top.
     //
     if ((false ==
          m_bAreTempValuesSet) || // m_Type isn't even set if this is false.
         (OTPayment::SMART_CONTRACT == m_Type) ||
         (OTPayment::PAYMENT_PLAN == m_Type)) {
         OTTrackable* pTrackable = Instantiate();
         if (nullptr == pTrackable) {
             otErr << __FUNCTION__
                   << ": Failed instantiating OTPayment containing:\n"
                   << m_strPayment << "\n";
             return false;
         } // BELOW THIS POINT, MUST DELETE pTrackable!
         std::unique_ptr<OTTrackable> theTrackableAngel(pTrackable);
 
         OTSmartContract* pSmartContract = nullptr;
         pSmartContract = dynamic_cast<OTSmartContract*>(pTrackable);
 
         OTPaymentPlan* pPlan = nullptr;
         pPlan = dynamic_cast<OTPaymentPlan*>(pTrackable);
 
         if (nullptr != pSmartContract) {
             lOutput = pSmartContract->GetClosingNumber(theAcctID);
             if (lOutput > 0) return true;
             return false;
         }
         else if (nullptr != pPlan) {
             lOutput = pPlan->GetClosingNumber(theAcctID);
             if (lOutput > 0) return true;
             return false;
         }
     }
 
     if (!m_bAreTempValuesSet) return false;
 
     // Next: ALL OTHER payment types...
     //
     bool bSuccess = false;
 
     switch (m_Type) {
 
     case OTPayment::CHEQUE:
     case OTPayment::VOUCHER:
     case OTPayment::INVOICE:
     case OTPayment::PURSE:
         lOutput = 0; // Redundant, but just making sure.
         bSuccess = false;
         break;
 
     default:
     case OTPayment::PAYMENT_PLAN:
     case OTPayment::SMART_CONTRACT:
         otErr << __FUNCTION__ << ": Bad payment type!\n";
         break;
     }
 
     return bSuccess;
 }

bool opentxs::OTPayment::GetMemo ( OTString & strOutput ) const

Definition at line 468 of file OTPayment.cpp.

 {
     strOutput.Release();
 
     if (!m_bAreTempValuesSet) return false;
 
     bool bSuccess = false;
 
     switch (m_Type) {
     case OTPayment::CHEQUE:
     case OTPayment::VOUCHER:
     case OTPayment::INVOICE:
     case OTPayment::PAYMENT_PLAN:
         if (m_strMemo.Exists()) {
             strOutput = m_strMemo;
             bSuccess = true;
         }
         else
             bSuccess = false;
         break;
 
     case OTPayment::SMART_CONTRACT:
     case OTPayment::PURSE:
         bSuccess = false;
         break;
 
     default:
         otErr << "OTPayment::GetMemo: Bad payment type!\n";
         break;
     }
 
     return bSuccess;
 }

bool opentxs::OTPayment::GetOpeningNum	(	int64_t &	lOutput,
		const OTIdentifier &	theNymID
	)		const

Definition at line 744 of file OTPayment.cpp.

 {
     lOutput = 0;
 
     // SMART CONTRACTS and PAYMENT PLANS get a little special
     // treatment here at the top.
     //
     if ((false ==
          m_bAreTempValuesSet) || // m_Type isn't even set if this is false.
         (OTPayment::SMART_CONTRACT == m_Type) ||
         (OTPayment::PAYMENT_PLAN == m_Type)) {
         OTTrackable* pTrackable = Instantiate();
         if (nullptr == pTrackable) {
             otErr << __FUNCTION__
                   << ": Failed instantiating OTPayment containing:\n"
                   << m_strPayment << "\n";
             return false;
         } // BELOW THIS POINT, MUST DELETE pTrackable!
         std::unique_ptr<OTTrackable> theTrackableAngel(pTrackable);
 
         OTSmartContract* pSmartContract = nullptr;
         pSmartContract = dynamic_cast<OTSmartContract*>(pTrackable);
 
         OTPaymentPlan* pPlan = nullptr;
         pPlan = dynamic_cast<OTPaymentPlan*>(pTrackable);
 
         if (nullptr != pSmartContract) {
             lOutput = pSmartContract->GetOpeningNumber(theNymID);
             if (lOutput > 0) return true;
             return false;
         }
         else if (nullptr != pPlan) {
             lOutput = pPlan->GetOpeningNumber(theNymID);
             if (lOutput > 0) return true;
             return false;
         }
     }
 
     if (!m_bAreTempValuesSet) return false;
 
     //
     // Next: ALL OTHER payment types...
     //
     bool bSuccess = false;
 
     switch (m_Type) {
 
     case OTPayment::CHEQUE:
     case OTPayment::INVOICE:
         if (theNymID == m_SenderUserID) {
             lOutput = m_lTransactionNum; // The "opening" number for a cheque is
                                          // the ONLY number it has.
             bSuccess = true;
         }
         else {
             lOutput = 0;
             bSuccess = false;
         }
         break;
 
     case OTPayment::VOUCHER:
         if (theNymID == m_RemitterUserID) {
             lOutput = m_lTransactionNum; // The "opening" number for a cheque is
                                          // the ONLY number it has.
             bSuccess = true;
         }
         else {
             lOutput = 0;
             bSuccess = false;
         }
         break;
 
     case OTPayment::PURSE:
         lOutput = 0; // Redundant, but just making sure.
         bSuccess = false;
         break;
 
     default:
     case OTPayment::PAYMENT_PLAN:
     case OTPayment::SMART_CONTRACT:
         otErr << __FUNCTION__ << ": Bad payment type!\n";
         break;
     }
 
     return bSuccess;
 }

EXPORT bool opentxs::OTPayment::GetPaymentContents ( OTString & strOutput ) const

inline

Definition at line 323 of file OTPayment.hpp.

     {
         strOutput = m_strPayment;
         return true;
     }

bool opentxs::OTPayment::GetRecipientAcctID ( OTIdentifier & theOutput ) const

Definition at line 1182 of file OTPayment.cpp.

 {
     // NOTE:
     // A cheque HAS NO "Recipient Asset Acct ID", since the recipient's account
     // (where he deposits
     // the cheque) is not known UNTIL the time of the deposit. It's certain not
     // known at the time
     // that the cheque is written...
 
     theOutput.Release();
 
     if (!m_bAreTempValuesSet) return false;
 
     bool bSuccess = false;
 
     switch (m_Type) {
     case OTPayment::PAYMENT_PLAN:
         if (m_bHasRecipient) {
             theOutput = m_RecipientAcctID;
             bSuccess = true;
         }
         else
             bSuccess = false;
 
         break;
 
     case OTPayment::CHEQUE:
     case OTPayment::VOUCHER:
     case OTPayment::INVOICE:
     case OTPayment::SMART_CONTRACT:
     case OTPayment::PURSE: // A purse might have a recipient USER, but never a
                            // recipient ACCOUNT.
         bSuccess = false;
         break;
 
     default:
         otErr << "OTPayment::GetRecipientAcctID: Bad payment type!\n";
         break;
     }
 
     return bSuccess;
 }

bool opentxs::OTPayment::GetRecipientUserID ( OTIdentifier & theOutput ) const

Definition at line 1147 of file OTPayment.cpp.

 {
     theOutput.Release();
 
     if (!m_bAreTempValuesSet) return false;
 
     bool bSuccess = false;
 
     switch (m_Type) {
     case OTPayment::CHEQUE:
     case OTPayment::VOUCHER:
     case OTPayment::INVOICE:
     case OTPayment::PAYMENT_PLAN:
     case OTPayment::PURSE:
         if (m_bHasRecipient) {
             theOutput = m_RecipientUserID;
             bSuccess = true;
         }
         else
             bSuccess = false;
 
         break;
 
     case OTPayment::SMART_CONTRACT:
         bSuccess = false;
         break;
 
     default:
         otErr << "OTPayment::GetRecipientUserID: Bad payment type!\n";
         break;
     }
 
     return bSuccess;
 }

bool opentxs::OTPayment::GetRemitterAcctID ( OTIdentifier & theOutput ) const

Definition at line 1050 of file OTPayment.cpp.

 {
     theOutput.Release();
 
     if (!m_bAreTempValuesSet) return false;
 
     bool bSuccess = false;
 
     switch (m_Type) {
     case OTPayment::VOUCHER:
         theOutput = m_RemitterAcctID;
         bSuccess = true;
         break;
 
     default:
         otErr << "OTPayment::GetRemitterAcctID: Bad payment type! Expected a "
                  "voucher cheque.\n";
         break;
     }
 
     return bSuccess;
 }

bool opentxs::OTPayment::GetRemitterUserID ( OTIdentifier & theOutput ) const

Definition at line 1023 of file OTPayment.cpp.

 {
     theOutput.Release();
 
     if (!m_bAreTempValuesSet) return false;
 
     bool bSuccess = false;
 
     switch (m_Type) {
     case OTPayment::VOUCHER:
         theOutput = m_RemitterUserID;
         bSuccess = true;
         break;
 
     default:
         otErr << "OTPayment::GetRemitterUserID: Bad payment type! Expected a "
                  "voucher cheque.\n";
         break;
     }
 
     return bSuccess;
 }

bool opentxs::OTPayment::GetSenderAcctID ( OTIdentifier & theOutput ) const

Definition at line 1117 of file OTPayment.cpp.

 {
     theOutput.Release();
 
     if (!m_bAreTempValuesSet) return false;
 
     bool bSuccess = false;
 
     switch (m_Type) {
     case OTPayment::CHEQUE:
     case OTPayment::VOUCHER:
     case OTPayment::INVOICE:
     case OTPayment::PAYMENT_PLAN:
         theOutput = m_SenderAcctID;
         bSuccess = true;
         break;
 
     case OTPayment::SMART_CONTRACT:
     case OTPayment::PURSE:
         bSuccess = false;
         break;
 
     default:
         otErr << "OTPayment::GetSenderAcctID: Bad payment type!\n";
         break;
     }
 
     return bSuccess;
 }

bool opentxs::OTPayment::GetSenderAcctIDForDisplay ( OTIdentifier & theOutput ) const

Definition at line 1080 of file OTPayment.cpp.

 {
     if (IsVoucher()) return GetRemitterAcctID(theOutput);
 
     return GetSenderAcctID(theOutput);
 }

bool opentxs::OTPayment::GetSenderUserID ( OTIdentifier & theOutput ) const

Definition at line 1087 of file OTPayment.cpp.

 {
     theOutput.Release();
 
     if (!m_bAreTempValuesSet) return false;
 
     bool bSuccess = false;
 
     switch (m_Type) {
     case OTPayment::CHEQUE:
     case OTPayment::VOUCHER:
     case OTPayment::INVOICE:
     case OTPayment::PAYMENT_PLAN:
     case OTPayment::SMART_CONTRACT:
         theOutput = m_SenderUserID;
         bSuccess = true;
         break;
 
     case OTPayment::PURSE:
         bSuccess = false;
         break;
 
     default:
         otErr << "OTPayment::GetSenderUserID: Bad payment type!\n";
         break;
     }
 
     return bSuccess;
 }

bool opentxs::OTPayment::GetSenderUserIDForDisplay ( OTIdentifier & theOutput ) const

Definition at line 1073 of file OTPayment.cpp.

 {
     if (IsVoucher()) return GetRemitterUserID(theOutput);
 
     return GetSenderUserID(theOutput);
 }

bool opentxs::OTPayment::GetServerID ( OTIdentifier & theOutput ) const

Definition at line 993 of file OTPayment.cpp.

 {
     theOutput.Release();
 
     if (!m_bAreTempValuesSet) return false;
 
     bool bSuccess = false;
 
     switch (m_Type) {
     case OTPayment::CHEQUE:
     case OTPayment::VOUCHER:
     case OTPayment::INVOICE:
     case OTPayment::PAYMENT_PLAN:
     case OTPayment::SMART_CONTRACT:
     case OTPayment::PURSE:
         theOutput = m_ServerID;
         bSuccess = true;
         break;
 
     default:
         otErr << "OTPayment::GetServerID: Bad payment type!\n";
         break;
     }
 
     return bSuccess;
 }

bool opentxs::OTPayment::GetTransactionNum ( int64_t & lOutput ) const

Definition at line 832 of file OTPayment.cpp.

 {
     lOutput = 0;
 
     if (!m_bAreTempValuesSet) return false;
 
     bool bSuccess = false;
 
     switch (m_Type) {
     case OTPayment::CHEQUE:
     case OTPayment::VOUCHER:
     case OTPayment::INVOICE:
     case OTPayment::PAYMENT_PLAN:   // For payment plans, this is the opening
                                     // transaction FOR THE NYM who activated the
                                     // contract (probably the customer.)
     case OTPayment::SMART_CONTRACT: // For smart contracts, this is the opening
                                     // transaction number FOR THE NYM who
                                     // activated the contract.
         lOutput = m_lTransactionNum;
         bSuccess = true;
         break;
 
     case OTPayment::PURSE:
         lOutput = 0;
         bSuccess = false;
         break;
 
     default:
         otErr << "OTPayment::GetTransactionNum: Bad payment type!\n";
         break;
     }
 
     return bSuccess;
 }

EXPORT paymentType opentxs::OTPayment::GetType ( ) const

inline

Definition at line 306 of file OTPayment.hpp.

     {
         return m_Type;
     }

OTPayment::paymentType opentxs::OTPayment::GetTypeFromString ( const OTString & strType )

static

Definition at line 177 of file OTPayment.cpp.

 {
 #define OT_NUM_ELEM(blah) (sizeof(blah) / sizeof(*(blah)))
     for (uint32_t i = 0; i < (OT_NUM_ELEM(__TypeStrings) - 1); i++) {
         if (strType.Compare(__TypeStrings[i]))
             return static_cast<OTPayment::paymentType>(i);
     }
 #undef OT_NUM_ELEM
     return OTPayment::ERROR_STATE;
 }

EXPORT const char* opentxs::OTPayment::GetTypeString ( ) const

inline

Definition at line 387 of file OTPayment.hpp.

     {
         return _GetTypeString(m_Type);
     }

bool opentxs::OTPayment::GetValidFrom ( time64_t & tOutput ) const

Definition at line 867 of file OTPayment.cpp.

 {
     tOutput = OT_TIME_ZERO;
 
     if (!m_bAreTempValuesSet) return false;
 
     bool bSuccess = false;
 
     switch (m_Type) {
     case OTPayment::PURSE:
     case OTPayment::CHEQUE:
     case OTPayment::VOUCHER:
     case OTPayment::INVOICE:
     case OTPayment::PAYMENT_PLAN:
     case OTPayment::SMART_CONTRACT:
         tOutput = m_VALID_FROM;
         bSuccess = true;
         break;
 
     default:
         otErr << "OTPayment::GetValidFrom: Bad payment type!\n";
         break;
     }
 
     return bSuccess;
 }

bool opentxs::OTPayment::GetValidTo ( time64_t & tOutput ) const

Definition at line 894 of file OTPayment.cpp.

 {
     tOutput = OT_TIME_ZERO;
 
     if (!m_bAreTempValuesSet) return false;
 
     bool bSuccess = false;
 
     switch (m_Type) {
     case OTPayment::PURSE:
     case OTPayment::CHEQUE:
     case OTPayment::VOUCHER:
     case OTPayment::INVOICE:
     case OTPayment::PAYMENT_PLAN:
     case OTPayment::SMART_CONTRACT:
         tOutput = m_VALID_TO;
         bSuccess = true;
         break;
 
     default:
         otErr << "OTPayment::GetValidTo: Bad payment type!\n";
         break;
     }
 
     return bSuccess;
 }

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

Definition at line 608 of file OTPayment.cpp.

 {
     // SMART CONTRACTS and PAYMENT PLANS get a little special
     // treatment here at the top.
     //
     if ((false == m_bAreTempValuesSet) || // Why is this here? Because if temp
                                           // values haven't been set yet,
         (OTPayment::SMART_CONTRACT ==
          m_Type) || // then m_Type isn't set either. We only want smartcontracts
                     // and   UPDATE: m_Type IS set!!
         (OTPayment::PAYMENT_PLAN == m_Type)) // payment plans here, but without
                                              // m_Type we can't know the
                                              // type...This comment is wrong!!
     {
         OTTrackable* pTrackable = Instantiate();
         if (nullptr == pTrackable) {
             otErr << __FUNCTION__
                   << ": Failed instantiating OTPayment containing:\n"
                   << m_strPayment << "\n";
             return false;
         } // BELOW THIS POINT, MUST DELETE pTrackable!
         std::unique_ptr<OTTrackable> theTrackableAngel(pTrackable);
 
         OTPaymentPlan* pPlan = nullptr;
         OTSmartContract* pSmartContract = nullptr;
 
         pPlan = dynamic_cast<OTPaymentPlan*>(pTrackable);
         pSmartContract = dynamic_cast<OTSmartContract*>(pTrackable);
 
         if (nullptr != pPlan) {
             if (pPlan->HasTransactionNum(lInput)) return true;
             return false;
         }
         else if (nullptr != pSmartContract) {
             if (pSmartContract->HasTransactionNum(lInput)) return true;
             return false;
         }
     }
 
     if (!m_bAreTempValuesSet) // (This function normally fails, if temp values
                               // aren't set,
         return false; //  for all payment types except the recurring ones
                       // above.)
 
     // Next: ALL OTHER payment types...
     //
     bool bSuccess = false;
 
     switch (m_Type) {
     case OTPayment::CHEQUE:
     case OTPayment::VOUCHER:
     case OTPayment::INVOICE:
         if (lInput == m_lTransactionNum) bSuccess = true;
         break;
 
     case OTPayment::PURSE:
         bSuccess = false;
         break;
 
     default:
     case OTPayment::PAYMENT_PLAN:   // Should never happen. (Handled already
                                     // above.)
     case OTPayment::SMART_CONTRACT: // Should never happen. (Handled already
                                     // above.)
         otErr << "OTPayment::" << __FUNCTION__ << ": Bad payment type!\n";
         break;
     }
 
     return bSuccess;
 }

void opentxs::OTPayment::InitPayment ( )

Definition at line 1504 of file OTPayment.cpp.

 {
     m_Type = OTPayment::ERROR_STATE;
     m_lAmount = 0;
     m_lTransactionNum = 0;
     m_VALID_FROM = OT_TIME_ZERO;
     m_VALID_TO = OT_TIME_ZERO;
     m_bAreTempValuesSet = false;
     m_bHasRecipient = false;
     m_bHasRemitter = false;
     m_strContractType.Set("PAYMENT");
 }

OTTrackable * opentxs::OTPayment::Instantiate ( ) const

Definition at line 1257 of file OTPayment.cpp.

 {
     OTContract* pContract = nullptr;
     OTTrackable* pTrackable = nullptr;
     OTCheque* pCheque = nullptr;
     OTPaymentPlan* pPaymentPlan = nullptr;
     OTSmartContract* pSmartContract = nullptr;
 
     switch (m_Type) {
     case CHEQUE:
     case VOUCHER:
     case INVOICE:
         pContract = ::InstantiateContract(m_strPayment);
 
         if (nullptr != pContract) {
             pCheque = dynamic_cast<OTCheque*>(pContract);
 
             if (nullptr == pCheque) {
                 otErr << "OTPayment::Instantiate: Tried to instantiate cheque, "
                          "but factory returned non-cheque:\n\n" << m_strPayment
                       << "\n\n";
                 delete pContract;
                 pContract = nullptr;
             }
             else
                 pTrackable = pCheque;
         }
         else
             otErr << "OTPayment::Instantiate: Tried to instantiate cheque, but "
                      "factory returned nullptr:\n\n" << m_strPayment << "\n\n";
         break;
 
     case PAYMENT_PLAN:
         pContract = ::InstantiateContract(m_strPayment);
 
         if (nullptr != pContract) {
             pPaymentPlan = dynamic_cast<OTPaymentPlan*>(pContract);
 
             if (nullptr == pPaymentPlan) {
                 otErr << "OTPayment::Instantiate: Tried to instantiate payment "
                          "plan, but factory returned non-payment-plan:\n\n"
                       << m_strPayment << "\n\n";
                 delete pContract;
                 pContract = nullptr;
             }
             else
                 pTrackable = pPaymentPlan;
         }
         else
             otErr << "OTPayment::Instantiate: Tried to instantiate payment "
                      "plan, but factory returned nullptr:\n\n" << m_strPayment
                   << "\n\n";
         break;
 
     case SMART_CONTRACT:
         pContract = ::InstantiateContract(m_strPayment);
 
         if (nullptr != pContract) {
             pSmartContract = dynamic_cast<OTSmartContract*>(pContract);
 
             if (nullptr == pSmartContract) {
                 otErr << __FUNCTION__
                       << ": Tried to instantiate smart contract, but factory "
                          "returned non-smart-contract:\n\n" << m_strPayment
                       << "\n\n";
                 delete pContract;
                 pContract = nullptr;
             }
             else
                 pTrackable = pSmartContract;
         }
         else
             otErr << "OTPayment::Instantiate: Tried to instantiate smart "
                      "contract, but factory returned nullptr:\n\n"
                   << m_strPayment << "\n\n";
         break;
     case PURSE:
         otErr << "OTPayment::Instantiate: ERROR: Tried to instantiate purse, "
                  "but should have called OTPayment::InstantiatePurse.\n";
         return nullptr;
     default:
         otErr << "OTPayment::Instantiate: ERROR: Tried to instantiate payment "
                  "object, but had a bad type. Contents:\n\n" << m_strPayment
               << "\n\n";
         return nullptr;
     }
 
     return pTrackable;
 }

OTTrackable * opentxs::OTPayment::Instantiate ( const OTString & strPayment )

Definition at line 1347 of file OTPayment.cpp.

 {
     if (SetPayment(strPayment)) return Instantiate();
 
     return nullptr;
 }

Purse * opentxs::OTPayment::InstantiatePurse ( ) const

Definition at line 1359 of file OTPayment.cpp.

 {
     if (OTPayment::PURSE == GetType()) {
         return Purse::PurseFactory(m_strPayment);
     }
     else
         otErr << "OTPayment::InstantiatePurse: Failure: This payment object "
                  "does NOT contain a purse. "
                  "Contents:\n\n" << m_strPayment << "\n\n";
 
     return nullptr;
 }

Purse * opentxs::OTPayment::InstantiatePurse ( const OTString & strPayment )

Definition at line 1403 of file OTPayment.cpp.

 {
     if (!SetPayment(strPayment))
         otErr << "OTPayment::InstantiatePurse: WARNING: Failed setting the "
                  "payment string based on "
                  "what was passed in:\n\n" << strPayment << "\n\n";
     else if (OTPayment::PURSE != m_Type)
         otErr << "OTPayment::InstantiatePurse: WARNING: No purse was found in "
                  "the "
                  "payment string:\n\n" << strPayment << "\n\n";
     else
         return InstantiatePurse();
 
     return nullptr;
 }

EXPORT bool opentxs::OTPayment::IsCheque ( ) const

inline

Definition at line 277 of file OTPayment.hpp.

     {
         return (CHEQUE == m_Type);
     }

bool opentxs::OTPayment::IsExpired ( bool & bExpired )

Definition at line 928 of file OTPayment.cpp.

 {
     if (!m_bAreTempValuesSet) return false;
 
     const time64_t CURRENT_TIME = OTTimeGetCurrentTime();
 
     // If the current time is AFTER the valid-TO date,
     // AND the valid_to is a nonzero number (0 means "doesn't expire")
     // THEN return true (it's expired.)
     //
     if ((CURRENT_TIME >= m_VALID_TO) && (m_VALID_TO > OT_TIME_ZERO))
         bExpired = true;
     else
         bExpired = false;
 
     return true;
 }

EXPORT bool opentxs::OTPayment::IsInvoice ( ) const

inline

Definition at line 285 of file OTPayment.hpp.

     {
         return (INVOICE == m_Type);
     }

EXPORT bool opentxs::OTPayment::IsPaymentPlan ( ) const

inline

Definition at line 289 of file OTPayment.hpp.

     {
         return (PAYMENT_PLAN == m_Type);
     }

EXPORT bool opentxs::OTPayment::IsPurse ( ) const

inline

Definition at line 297 of file OTPayment.hpp.

     {
         return (PURSE == m_Type);
     }

EXPORT bool opentxs::OTPayment::IsSmartContract ( ) const

inline

Definition at line 293 of file OTPayment.hpp.

     {
         return (SMART_CONTRACT == m_Type);
     }

EXPORT bool opentxs::OTPayment::IsValid ( ) const

inline

Definition at line 301 of file OTPayment.hpp.

     {
         return (ERROR_STATE != m_Type);
     }

EXPORT bool opentxs::OTPayment::IsVoucher ( ) const

inline

Definition at line 281 of file OTPayment.hpp.

     {
         return (VOUCHER == m_Type);
     }

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

virtual

Reimplemented from opentxs::OTContract.

Definition at line 1582 of file OTPayment.cpp.

 {
     const OTString strNodeName(xml->getNodeName());
 
     if (strNodeName.Compare("payment")) {
         m_strVersion = xml->getAttributeValue("version");
 
         const OTString strPaymentType = xml->getAttributeValue("type");
 
         if (strPaymentType.Exists())
             m_Type = OTPayment::GetTypeFromString(strPaymentType);
         else
             m_Type = OTPayment::ERROR_STATE;
 
         otLog4 << "Loaded payment... Type: " << GetTypeString()
                << "\n----------\n";
 
         return (OTPayment::ERROR_STATE == m_Type) ? (-1) : 1;
     }
     else if (strNodeName.Compare("contents")) {
         OTString strContents;
 
         if (!OTContract::LoadEncodedTextField(xml, strContents) ||
             !strContents.Exists() || !SetPayment(strContents)) {
             otErr << "OTPayment::ProcessXMLNode: ERROR: \"contents\" field "
                      "without a value, OR error setting that "
                      "value onto this object. Raw:\n\n" << strContents
                   << "\n\n";
 
             return (-1); // error condition
         }
         // else success -- the value is now set on this object.
         // todo security: Make sure the type of the payment that's ACTUALLY
         // there
         // matches the type expected (based on the m_Type that we already read,
         // above.)
 
         return 1;
     }
 
     return 0;
 }

void opentxs::OTPayment::Release ( void )

virtual

Reimplemented from opentxs::OTContract.

Definition at line 1550 of file OTPayment.cpp.

 {
     Release_Payment();
 
     // Finally, we call the method we overrode:
     //
     ot_super::Release();
 }

void opentxs::OTPayment::Release_Payment ( )

Definition at line 1522 of file OTPayment.cpp.

 {
     m_Type = OTPayment::ERROR_STATE;
     m_lAmount = 0;
     m_lTransactionNum = 0;
     m_VALID_FROM = OT_TIME_ZERO;
     m_VALID_TO = OT_TIME_ZERO;
 
     m_strPayment.Release();
 
     m_bAreTempValuesSet = false;
     m_bHasRecipient = false;
     m_bHasRemitter = false;
 
     m_strMemo.Release();
 
     m_AssetTypeID.Release();
     m_ServerID.Release();
 
     m_SenderUserID.Release();
     m_SenderAcctID.Release();
     m_RecipientUserID.Release();
     m_RecipientAcctID.Release();
 
     m_RemitterUserID.Release();
     m_RemitterAcctID.Release();
 }

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

virtual

Implements opentxs::OTContract.

Definition at line 1625 of file OTPayment.cpp.

 {
     return true;
 }

bool opentxs::OTPayment::SetPayment ( const OTString & strPayment )

Definition at line 1456 of file OTPayment.cpp.

 {
     if (!strPayment.Exists()) return false;
 
     OTString strContract(strPayment);
 
     if (!strContract.DecodeIfArmored(false)) // bEscapedIsAllowed=true
                                              // by default.
     {
         otErr << __FUNCTION__ << ": Input string apparently was encoded and "
                                  "then failed decoding. Contents: \n"
               << strPayment << "\n";
         return false;
     }
 
     m_strPayment.Release();
 
     // todo: should be "starts with" and perhaps with a trim first
     //
     if (strContract.Contains("-----BEGIN SIGNED CHEQUE-----"))
         m_Type = OTPayment::CHEQUE;
     else if (strContract.Contains("-----BEGIN SIGNED VOUCHER-----"))
         m_Type = OTPayment::VOUCHER;
     else if (strContract.Contains("-----BEGIN SIGNED INVOICE-----"))
         m_Type = OTPayment::INVOICE;
 
     else if (strContract.Contains("-----BEGIN SIGNED PAYMENT PLAN-----"))
         m_Type = OTPayment::PAYMENT_PLAN;
     else if (strContract.Contains("-----BEGIN SIGNED SMARTCONTRACT-----"))
         m_Type = OTPayment::SMART_CONTRACT;
 
     else if (strContract.Contains("-----BEGIN SIGNED PURSE-----"))
         m_Type = OTPayment::PURSE;
     else {
         m_Type = OTPayment::ERROR_STATE;
 
         otErr << __FUNCTION__
               << ": Failure: Unable to determine payment type, from input:\n\n"
               << strContract << "\n\n";
     }
 
     if (OTPayment::ERROR_STATE == m_Type) return false;
 
     m_strPayment.Set(strContract);
 
     return true;
 }

bool opentxs::OTPayment::SetTempValues ( )

Definition at line 196 of file OTPayment.cpp.

 {
     if (OTPayment::PURSE == m_Type) {
         // Perform instantiation of a purse, then use it to set the temp values,
         // then cleans it up again before returning success/fail.
         //
         Purse* pPurse = InstantiatePurse();
 
         if (nullptr == pPurse) {
             otErr << "OTPayment::SetTempValues: Error: Failed instantiating "
                      "OTPayment (purported purse) contents:\n\n" << m_strPayment
                   << "\n\n";
             return false;
         }
         std::unique_ptr<Purse> thePurseAngel(pPurse);
 
         return SetTempValuesFromPurse(*pPurse);
     }
     else {
         OTTrackable* pTrackable = Instantiate();
 
         if (nullptr == pTrackable) {
             otErr << "OTPayment::SetTempValues: Error: Failed instantiating "
                      "OTPayment contents:\n\n" << m_strPayment << "\n\n";
             return false;
         }
         // BELOW THIS POINT, MUST DELETE pTrackable!
         std::unique_ptr<OTTrackable> theTrackableAngel(pTrackable);
 
         OTCheque* pCheque = nullptr;
         OTPaymentPlan* pPaymentPlan = nullptr;
         OTSmartContract* pSmartContract = nullptr;
 
         switch (m_Type) {
         case CHEQUE:
         case VOUCHER:
         case INVOICE:
             pCheque = dynamic_cast<OTCheque*>(pTrackable);
             if (nullptr == pCheque)
                 otErr << "OTPayment::SetTempValues: Failure: "
                          "dynamic_cast<OTCheque *>(pTrackable). Contents:\n\n"
                       << m_strPayment << "\n\n";
             // Let's grab all the temp values from the cheque!!
             //
             else // success
                 return SetTempValuesFromCheque(*pCheque);
             break;
 
         case PAYMENT_PLAN:
             pPaymentPlan = dynamic_cast<OTPaymentPlan*>(pTrackable);
             if (nullptr == pPaymentPlan)
                 otErr << "OTPayment::SetTempValues: Failure: "
                          "dynamic_cast<OTPaymentPlan *>(pTrackable). "
                          "Contents:\n\n" << m_strPayment << "\n\n";
             // Let's grab all the temp values from the payment plan!!
             //
             else // success
                 return SetTempValuesFromPaymentPlan(*pPaymentPlan);
             break;
 
         case SMART_CONTRACT:
             pSmartContract = dynamic_cast<OTSmartContract*>(pTrackable);
             if (nullptr == pSmartContract)
                 otErr << "OTPayment::SetTempValues: Failure: "
                          "dynamic_cast<OTSmartContract *>(pTrackable). "
                          "Contents:\n\n" << m_strPayment << "\n\n";
             // Let's grab all the temp values from the smart contract!!
             //
             else // success
                 return SetTempValuesFromSmartContract(*pSmartContract);
             break;
 
         default:
             otErr << "OTPayment::SetTempValues: Failure: Wrong m_Type. "
                      "Contents:\n\n" << m_strPayment << "\n\n";
             return false;
         }
     }
 
     return false; // Should never actually reach this point.
 }

bool opentxs::OTPayment::SetTempValuesFromCheque ( const OTCheque & theInput )

Definition at line 279 of file OTPayment.cpp.

 {
     switch (m_Type) {
     case OTPayment::CHEQUE:
     case OTPayment::VOUCHER:
     case OTPayment::INVOICE:
 
         m_bAreTempValuesSet = true;
 
         m_lAmount = theInput.GetAmount();
         m_lTransactionNum = theInput.GetTransactionNum();
 
         if (theInput.GetMemo().Exists())
             m_strMemo.Set(theInput.GetMemo());
         else
             m_strMemo.Release();
 
         m_AssetTypeID = theInput.GetAssetID();
         m_ServerID = theInput.GetServerID();
 
         m_SenderUserID = theInput.GetSenderUserID();
         m_SenderAcctID = theInput.GetSenderAcctID();
 
         if (theInput.HasRecipient()) {
             m_bHasRecipient = true;
             m_RecipientUserID = theInput.GetRecipientUserID();
         }
         else {
             m_bHasRecipient = false;
             m_RecipientUserID.Release();
         }
 
         if (theInput.HasRemitter()) {
             m_bHasRemitter = true;
             m_RemitterUserID = theInput.GetRemitterUserID();
             m_RemitterAcctID = theInput.GetRemitterAcctID();
         }
         else {
             m_bHasRemitter = false;
             m_RemitterUserID.Release();
             m_RemitterAcctID.Release();
         }
 
         // NOTE: the "Recipient Acct" is NOT KNOWN when cheque is written, but
         // only
         // once the cheque gets deposited. Therefore if type is CHEQUE, then
         // Recipient
         // Acct ID is not set, and attempts to read it will result in failure.
         //
         m_RecipientAcctID.Release();
 
         m_VALID_FROM = theInput.GetValidFrom();
         m_VALID_TO = theInput.GetValidTo();
 
         return true;
 
     default:
         otErr << "OTPayment::SetTempValuesFromCheque: Error: Wrong type. "
                  "(Returning false.)\n";
         break;
     }
 
     return false;
 }

bool opentxs::OTPayment::SetTempValuesFromPaymentPlan ( const OTPaymentPlan & theInput )

Definition at line 344 of file OTPayment.cpp.

 {
     if (OTPayment::PAYMENT_PLAN == m_Type) {
         m_bAreTempValuesSet = true;
         m_bHasRecipient = true;
         m_bHasRemitter = false;
 
         m_lAmount = theInput.GetInitialPaymentAmount(); // There're also regular
                                                         // payments of
         // GetPaymentPlanAmount(). Can't
         // fit 'em all.
         m_lTransactionNum = theInput.GetTransactionNum();
 
         // const OTString&  OTPaymentPlan::GetConsideration() const
         //                  { return m_strConsideration; }
         if (theInput.GetConsideration().Exists())
             m_strMemo.Set(theInput.GetConsideration());
         else
             m_strMemo.Release();
 
         m_AssetTypeID = theInput.GetAssetID();
         m_ServerID = theInput.GetServerID();
 
         m_SenderUserID = theInput.GetSenderUserID();
         m_SenderAcctID = theInput.GetSenderAcctID();
 
         m_RecipientUserID = theInput.GetRecipientUserID();
         m_RecipientAcctID = theInput.GetRecipientAcctID();
 
         m_RemitterUserID.Release();
         m_RemitterAcctID.Release();
 
         m_VALID_FROM = theInput.GetValidFrom();
         m_VALID_TO = theInput.GetValidTo();
 
         return true;
     }
     else
         otErr << "OTPayment::SetTempValuesFromPaymentPlan: Error: Wrong type. "
                  "(Returning false.)\n";
 
     return false;
 }

bool opentxs::OTPayment::SetTempValuesFromPurse ( const Purse & theInput )

Definition at line 427 of file OTPayment.cpp.

 {
     if (OTPayment::PURSE == m_Type) {
         m_bAreTempValuesSet = true;
         m_bHasRecipient = theInput.IsNymIDIncluded();
         m_bHasRemitter = false;
 
         m_lAmount = theInput.GetTotalValue();
         m_lTransactionNum = 0; // (A purse has no transaction number.)
 
         m_strMemo.Release(); // So far there's no purse memo (could add it,
                              // though.)
 
         m_AssetTypeID = theInput.GetAssetID();
         m_ServerID = theInput.GetServerID();
 
         m_SenderUserID.Release();
         m_SenderAcctID.Release();
 
         if (!m_bHasRecipient || !theInput.GetNymID(m_RecipientUserID)) {
             m_bHasRecipient = false;
             m_RecipientUserID.Release();
         }
 
         m_RecipientAcctID.Release();
 
         m_RemitterUserID.Release();
         m_RemitterAcctID.Release();
 
         m_VALID_FROM = theInput.GetLatestValidFrom();
         m_VALID_TO = theInput.GetEarliestValidTo();
 
         return true;
     }
     else
         otErr << "OTPayment::SetTempValuesFromPurse: Error: Wrong type. "
                  "(Returning false.)\n";
 
     return false;
 }

bool opentxs::OTPayment::SetTempValuesFromSmartContract ( const OTSmartContract & theInput )

Definition at line 388 of file OTPayment.cpp.

 {
     if (OTPayment::SMART_CONTRACT == m_Type) {
         m_bAreTempValuesSet = true;
         m_bHasRecipient = false;
         m_bHasRemitter = false;
 
         m_lAmount = 0; // not used here.
         m_lTransactionNum = theInput.GetTransactionNum();
 
         // Note: Maybe later, store the Smart Contract's temporary name, or ID,
         // in the memo field.
         // Or something.
         //
         m_strMemo.Release(); // not used here.
 
         m_ServerID = theInput.GetServerID();
         m_AssetTypeID.Release(); // not used here.
 
         m_SenderUserID = theInput.GetSenderUserID();
         m_SenderAcctID.Release();
 
         m_RecipientUserID.Release(); // not used here.
         m_RecipientAcctID.Release(); // not used here.
 
         m_RemitterUserID.Release();
         m_RemitterAcctID.Release();
 
         m_VALID_FROM = theInput.GetValidFrom();
         m_VALID_TO = theInput.GetValidTo();
 
         return true;
     }
     else
         otErr << __FUNCTION__ << ": Error: Wrong type. (Returning false.)\n";
 
     return false;
 }

void opentxs::OTPayment::UpdateContents ( )

protectedvirtual

Reimplemented from opentxs::OTContract.

Definition at line 1559 of file OTPayment.cpp.

 {
     // I release this because I'm about to repopulate it.
     m_xmlUnsigned.Release();
 
     m_xmlUnsigned.Concatenate("<?xml version=\"%s\"?>\n\n", "1.0");
 
     m_xmlUnsigned.Concatenate("<payment version=\"%s\"\n"
                               " type=\"%s\">\n\n",
                               m_strVersion.Get(), GetTypeString());
 
     if (m_strPayment.Exists()) {
         const OTASCIIArmor ascContents(m_strPayment);
 
         if (ascContents.Exists())
             m_xmlUnsigned.Concatenate("<contents>\n%s</contents>\n\n",
                                       ascContents.Get());
     }
 
     m_xmlUnsigned.Concatenate("</payment>\n");
 }

bool opentxs::OTPayment::VerifyCurrentDate ( bool & bVerified )

Definition at line 948 of file OTPayment.cpp.

 {
     if (!m_bAreTempValuesSet) return false;
 
     const time64_t CURRENT_TIME = OTTimeGetCurrentTime();
 
     if ((CURRENT_TIME >= m_VALID_FROM) &&
         ((CURRENT_TIME <= m_VALID_TO) || (OT_TIME_ZERO == m_VALID_TO)))
         bVerified = true;
     else
         bVerified = false;
 
     return true;
 }

Member Data Documentation

OTIdentifier opentxs::OTPayment::m_AssetTypeID

protected

Definition at line 249 of file OTPayment.hpp.

bool opentxs::OTPayment::m_bAreTempValuesSet

protected

Definition at line 231 of file OTPayment.hpp.

bool opentxs::OTPayment::m_bHasRecipient

protected

Definition at line 236 of file OTPayment.hpp.

bool opentxs::OTPayment::m_bHasRemitter

protected

Definition at line 237 of file OTPayment.hpp.

int64_t opentxs::OTPayment::m_lAmount

protected

Definition at line 242 of file OTPayment.hpp.

int64_t opentxs::OTPayment::m_lTransactionNum

protected

Definition at line 244 of file OTPayment.hpp.

OTIdentifier opentxs::OTPayment::m_RecipientAcctID

protected

Definition at line 261 of file OTPayment.hpp.

OTIdentifier opentxs::OTPayment::m_RecipientUserID

protected

Definition at line 258 of file OTPayment.hpp.

OTIdentifier opentxs::OTPayment::m_RemitterAcctID

protected

Definition at line 267 of file OTPayment.hpp.

OTIdentifier opentxs::OTPayment::m_RemitterUserID

protected

Definition at line 263 of file OTPayment.hpp.

OTIdentifier opentxs::OTPayment::m_SenderAcctID

protected

Definition at line 255 of file OTPayment.hpp.

OTIdentifier opentxs::OTPayment::m_SenderUserID

protected

Definition at line 253 of file OTPayment.hpp.

OTIdentifier opentxs::OTPayment::m_ServerID

protected

Definition at line 251 of file OTPayment.hpp.

OTString opentxs::OTPayment::m_strMemo

protected

Definition at line 247 of file OTPayment.hpp.

OTString opentxs::OTPayment::m_strPayment

protected

Definition at line 224 of file OTPayment.hpp.

paymentType opentxs::OTPayment::m_Type

protected

Definition at line 226 of file OTPayment.hpp.

time64_t opentxs::OTPayment::m_VALID_FROM

protected

Definition at line 272 of file OTPayment.hpp.

time64_t opentxs::OTPayment::m_VALID_TO

protected

Definition at line 273 of file OTPayment.hpp.

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

/usr/local/src/opentxs/include/opentxs/ext/OTPayment.hpp
/usr/local/src/opentxs/src/ext/OTPayment.cpp

Public Types

Public Member Functions

Static Public Member Functions

Protected Member Functions

Protected Attributes

Detailed Description

Member Enumeration Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation