#include <OTParty.hpp>

Public Member Functions
	OTParty ()

EXPORT	OTParty (const char szName, bool bIsOwnerNym, const char szOwnerID, const char *szAuthAgent, bool bCreateAgent=false)

EXPORT	OTParty (std::string str_PartyName, OTPseudonym &theNym, std::string str_agent_name, OTAccount pAccount=nullptr, const std::string pstr_account_name=nullptr, int64_t lClosingTransNo=0)

virtual	~OTParty ()

void	CleanupAgents ()

void	CleanupAccounts ()

bool	Compare (const OTParty &rhs) const

void	Serialize (OTString &strAppend, bool bCalculatingID=false, bool bSpecifyAssetID=false, bool bSpecifyParties=false) const

void	ClearTemporaryPointers ()

bool	SignContract (OTContract &theInput) const

bool	HasTransactionNum (const int64_t &lInput) const

void	GetAllTransactionNumbers (OTNumList &numlistOutput) const

bool	ReserveTransNumsForConfirm (const OTString &strServerID)

void	HarvestAllTransactionNumbers (const OTString &strServerID)

void	HarvestOpeningNumber (const OTString &strServerID)

void	HarvestOpeningNumber (OTAgent &theAgent, const OTString &strServerID)

void	HarvestOpeningNumber (OTPseudonym &theNym, const OTString &strServerID)

void	CloseoutOpeningNumber (const OTString &strServerID, bool bSave=false, OTPseudonym *pSignerNym=nullptr)

void	HarvestClosingNumbers (const OTString &strServerID, bool bSave=false, OTPseudonym *pSignerNym=nullptr)

void	HarvestClosingNumbers (OTAgent &theAgent, const OTString &strServerID)

void	HarvestClosingNumbers (OTPseudonym &theNym, const OTString &strServerID)

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

bool	DropFinalReceiptToInboxes (mapOfNyms pNymMap, const OTString &strServerID, OTPseudonym &theServerNym, const int64_t &lNewTransactionNumber, const OTString &strOrigCronItem, OTString pstrNote=nullptr, OTString *pstrAttachment=nullptr)

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

OTScriptable *	GetOwnerAgreement ()

void	SetOwnerAgreement (OTScriptable &theOwner)

void	SetMySignedCopy (const OTString &strMyCopy)

const OTString &	GetMySignedCopy ()

int64_t	GetOpeningTransNo () const

void	SetOpeningTransNo (const int64_t &theNumber)

int64_t	GetClosingTransNo (std::string str_for_acct_name) const

EXPORT std::string	GetPartyName (bool *pBoolSuccess=nullptr) const

bool	SetPartyName (const std::string &str_party_name_input)

bool	IsNym () const

bool	IsEntity () const

std::string	GetNymID (bool *pBoolSuccess=nullptr) const

std::string	GetEntityID (bool *pBoolSuccess=nullptr) const

EXPORT std::string	GetPartyID (bool *pBoolSuccess=nullptr) const

bool	HasActiveAgent () const

bool	AddAgent (OTAgent &theAgent)

int32_t	GetAgentCount () const

EXPORT OTAgent *	GetAgent (const std::string &str_agent_name) const

EXPORT OTAgent *	GetAgentByIndex (int32_t nIndex) const

const std::string &	GetAuthorizingAgentName () const

void	SetAuthorizingAgentName (std::string str_agent_name)

bool	HasAgent (OTPseudonym &theNym, OTAgent **ppAgent=nullptr) const

bool	HasAgentByNymID (const OTIdentifier &theNymID, OTAgent **ppAgent=nullptr) const

bool	HasAuthorizingAgent (OTPseudonym &theNym, OTAgent **ppAgent=nullptr) const

bool	HasAuthorizingAgentByNymID (const OTIdentifier &theNymID, OTAgent **ppAgent=nullptr) const

OTPseudonym *	LoadAuthorizingAgentNym (OTPseudonym &theSignerNym, OTAgent **ppAgent=nullptr)

void	RetrieveNymPointers (mapOfNyms &map_Nyms_Already_Loaded)

bool	AddAccount (OTPartyAccount &thePartyAcct)

EXPORT bool	AddAccount (const OTString &strAgentName, const OTString &strName, const OTString &strAcctID, const OTString &strAssetTypeID, int64_t lClosingTransNo)

EXPORT bool	AddAccount (const OTString &strAgentName, const char *szAcctName, OTAccount &theAccount, int64_t lClosingTransNo)

int32_t	GetAccountCount () const

int32_t	GetAccountCount (std::string str_agent_name) const

EXPORT OTPartyAccount *	GetAccount (const std::string &str_acct_name) const

EXPORT OTPartyAccount *	GetAccountByIndex (int32_t nIndex)

EXPORT OTPartyAccount *	GetAccountByAgent (const std::string &str_agent_name)

EXPORT OTPartyAccount *	GetAccountByID (const OTIdentifier &theAcctID) const

bool	HasAccount (OTAccount &theAccount, OTPartyAccount **ppPartyAccount=nullptr) const

bool	HasAccountByID (const OTIdentifier &theAcctID, OTPartyAccount **ppPartyAccount=nullptr) const

bool	VerifyOwnershipOfAccount (const OTAccount &theAccount) const

bool	VerifyAccountsWithTheirAgents (OTPseudonym &theSignerNym, const OTString &strServerID, bool bBurnTransNo=false)

EXPORT bool	CopyAcctsToConfirmingParty (OTParty &theParty) const

void	RegisterAccountsForExecution (OTScript &theScript)

bool	LoadAndVerifyAgentNyms (OTPseudonym &theServerNym, mapOfNyms &map_Nyms_Already_Loaded, mapOfNyms &map_NewlyLoaded)

bool	LoadAndVerifyAssetAccounts (OTPseudonym &theServerNym, const OTString &strServerID, mapOfAccounts &map_Accts_Already_Loaded, mapOfAccounts &map_NewlyLoaded)

Detailed Description

Definition at line 174 of file OTParty.hpp.

Constructor & Destructor Documentation

opentxs::OTParty::OTParty ( )

Definition at line 218 of file OTParty.cpp.

     : m_pstr_party_name(nullptr)
     , m_bPartyIsNym(false)
     , m_lOpeningTransNo(0)
     , m_pOwnerAgreement(nullptr)
 {
 }

opentxs::OTParty::OTParty	(	const char *	szName,
		bool	bIsOwnerNym,
		const char *	szOwnerID,
		const char *	szAuthAgent,
		bool	bCreateAgent = `false`
	)

Definition at line 226 of file OTParty.cpp.

     : m_pstr_party_name(nullptr)
     , m_bPartyIsNym(bIsOwnerNym)
     , m_str_owner_id(szOwnerID != nullptr ? szOwnerID : "")
     , m_str_authorizing_agent(szAuthAgent != nullptr ? szAuthAgent : "")
     , m_lOpeningTransNo(0)
     , m_pOwnerAgreement(nullptr)
 {
     m_pstr_party_name = new std::string(szName != nullptr ? szName : "");
 
     if (bCreateAgent) {
         const OTString strName(m_str_authorizing_agent.c_str()), strNymID(""),
             strRoleID(""), strGroupName("");
         OTAgent* pAgent =
             new OTAgent(true /*bNymRepresentsSelf*/, true /*bIsAnIndividual*/,
                         strName, strNymID, strRoleID, strGroupName);
         OT_ASSERT(nullptr != pAgent);
 
         if (!AddAgent(*pAgent)) {
             otErr << "OTParty::OTParty: *** Failed *** while adding default "
                      "agent in CONSTRUCTOR! 2\n";
             delete pAgent;
             pAgent = nullptr;
         }
     }
 }

opentxs::OTParty::OTParty	(	std::string	str_PartyName,
		OTPseudonym &	theNym,
		std::string	str_agent_name,
		OTAccount *	pAccount = `nullptr`,
		const std::string *	pstr_account_name = `nullptr`,
		int64_t	lClosingTransNo = `0`
	)

Definition at line 254 of file OTParty.cpp.

     : m_pstr_party_name(new std::string(str_PartyName))
     , m_bPartyIsNym(true)
     , m_lOpeningTransNo(0)
     , m_pOwnerAgreement(nullptr)
 {
     //  m_pstr_party_name = new std::string(str_PartyName);
     OT_ASSERT(nullptr != m_pstr_party_name);
 
     // theNym is owner, therefore save his ID information, and create the agent
     // for this Nym automatically (that's why it was passed in.)
     // This code won't compile until you do.  :-)
 
     OTString strNymID;
     theNym.GetIdentifier(strNymID);
     m_str_owner_id = strNymID.Get();
 
     OTAgent* pAgent =
         new OTAgent(str_agent_name, theNym); // (The third arg, bRepresentsSelf,
                                              // defaults here to true.)
     OT_ASSERT(nullptr != pAgent);
 
     if (!AddAgent(*pAgent)) {
         otErr << "OTParty::OTParty: *** Failed *** while adding default agent "
                  "in CONSTRUCTOR!\n";
         delete pAgent;
         pAgent = nullptr;
     }
     else
         m_str_authorizing_agent = str_agent_name;
 
     // if pAccount is NOT nullptr, then an account was passed in, so
     // let's also create a default partyaccount for it.
     //
     if (nullptr != pAccount) {
         OT_ASSERT(nullptr !=
                   pstr_account_name); // If passing an account, then you
                                       // MUST pass an account name also.
 
         bool bAdded =
             AddAccount(str_agent_name.c_str(), pstr_account_name->c_str(),
                        *pAccount, lClosingTransNo);
 
         if (!bAdded)
             otErr << "OTParty::OTParty: *** Failed *** while adding default "
                      "account in CONSTRUCTOR!\n";
     }
 }

opentxs::OTParty::~OTParty ( )

virtual

Definition at line 457 of file OTParty.cpp.

 {
     CleanupAgents();
     CleanupAccounts();
 
     if (nullptr != m_pstr_party_name) delete m_pstr_party_name;
     m_pstr_party_name = nullptr;
 
     m_pOwnerAgreement = nullptr;
 }

Member Function Documentation

bool opentxs::OTParty::AddAccount ( OTPartyAccount & thePartyAcct )

Definition at line 374 of file OTParty.cpp.

 {
     const std::string str_acct_name = thePartyAcct.GetName().Get();
 
     if (!OTScriptable::ValidateName(str_acct_name)) {
         otErr << "OTParty::AddAccount: Failed validating Account name.";
         return false;
     }
 
     auto it = m_mapPartyAccounts.find(str_acct_name);
 
     if (m_mapPartyAccounts.end() == it) // If it wasn't already there...
     {
         // Todo:  Validate here that there isn't another account already on the
         // same party
         // that, while it has a different "account name" actually has the same
         // Account ID.
         // We do not want the same Account ID on multiple accounts. (Unless the
         // script
         // interpreter is going to be smart enough to make them available that
         // way without
         // ever loading the same account twice.) We can't otherwise take the
         // risk, si server
         //  will have to validate this unless it juggles the accounts like that.
         //
 
         // Then insert it...
         m_mapPartyAccounts.insert(std::pair<std::string, OTPartyAccount*>(
             str_acct_name, &thePartyAcct));
 
         // Make sure it has a pointer back to me.
         thePartyAcct.SetParty(*this);
 
         return true;
     }
     else
         otOut << "OTParty::AddAccount: Failed -- Account was already on party "
                  "named " << str_acct_name << ".\n";
 
     return false;
 }

bool opentxs::OTParty::AddAccount	(	const OTString &	strAgentName,
		const OTString &	strName,
		const OTString &	strAcctID,
		const OTString &	strAssetTypeID,
		int64_t	lClosingTransNo
	)

Definition at line 342 of file OTParty.cpp.

 {
     OTPartyAccount* pPartyAccount = new OTPartyAccount(
         strName, strAgentName, strAcctID, strAssetTypeID, lClosingTransNo);
     OT_ASSERT(nullptr != pPartyAccount);
 
     if (!AddAccount(*pPartyAccount)) {
         delete pPartyAccount;
         return false;
     }
 
     return true;
 }

bool opentxs::OTParty::AddAccount	(	const OTString &	strAgentName,
		const char *	szAcctName,
		OTAccount &	theAccount,
		int64_t	lClosingTransNo
	)

Definition at line 359 of file OTParty.cpp.

 {
     OTPartyAccount* pPartyAccount = new OTPartyAccount(
         szAcctName, strAgentName, theAccount, lClosingTransNo);
     OT_ASSERT(nullptr != pPartyAccount);
 
     if (!AddAccount(*pPartyAccount)) {
         delete pPartyAccount;
         return false;
     }
 
     return true;
 }

bool opentxs::OTParty::AddAgent ( OTAgent & theAgent )

Definition at line 307 of file OTParty.cpp.

 {
     const std::string str_agent_name = theAgent.GetName().Get();
 
     if (!OTScriptable::ValidateName(str_agent_name)) {
         otErr << "OTParty::AddAgent: Failed validating Agent name.";
         return false;
     }
 
     auto it = m_mapAgents.find(str_agent_name);
 
     if (m_mapAgents.end() == it) // If it wasn't already there...
     {
         // TODO: Validate here that the same agent isn't already on this party
         // under a different name.
         // Server either has to validate this as well, or be smart enough to
         // juggle the Nyms inside the
         // agents so that they aren't loaded twice.
 
         // Then insert it...
         m_mapAgents.insert(
             std::pair<std::string, OTAgent*>(str_agent_name, &theAgent));
 
         // Make sure it has a pointer back to me.
         theAgent.SetParty(*this);
 
         return true;
     }
     else
         otOut << "OTParty::AddAgent: Failed -- Agent was already there named "
               << str_agent_name << ".\n";
 
     return false;
 }

void opentxs::OTParty::CleanupAccounts ( )

Definition at line 445 of file OTParty.cpp.

 {
 
     while (!m_mapPartyAccounts.empty()) {
         OTPartyAccount* pTemp = m_mapPartyAccounts.begin()->second;
         OT_ASSERT(nullptr != pTemp);
         delete pTemp;
         pTemp = nullptr;
         m_mapPartyAccounts.erase(m_mapPartyAccounts.begin());
     }
 }

void opentxs::OTParty::CleanupAgents ( )

Definition at line 433 of file OTParty.cpp.

 {
 
     while (!m_mapAgents.empty()) {
         OTAgent* pTemp = m_mapAgents.begin()->second;
         OT_ASSERT(nullptr != pTemp);
         delete pTemp;
         pTemp = nullptr;
         m_mapAgents.erase(m_mapAgents.begin());
     }
 }

void opentxs::OTParty::ClearTemporaryPointers ( )

Definition at line 468 of file OTParty.cpp.

 {
     for (auto& it : m_mapAgents) {
         OTAgent* pAgent = it.second;
         OT_ASSERT_MSG(nullptr != pAgent,
                       "Unexpected nullptr agent pointer in party map.");
 
         pAgent->ClearTemporaryPointers();
     }
 
     for (auto& it : m_mapPartyAccounts) {
         OTPartyAccount* pAcct = it.second;
         OT_ASSERT_MSG(nullptr != pAcct,
                       "Unexpected nullptr partyaccount pointer in party map.");
 
         pAcct->ClearTemporaryPointers();
     }
 }

void opentxs::OTParty::CloseoutOpeningNumber	(	const OTString &	strServerID,
		bool	bSave = `false`,
		OTPseudonym *	pSignerNym = `nullptr`
	)

Definition at line 1595 of file OTParty.cpp.

 {
     if (GetAuthorizingAgentName().size() <= 0) {
         otErr << "OTParty::" << __FUNCTION__
               << ": Error: Authorizing agent name is blank.\n";
         return;
     }
 
     OTAgent* pAgent = GetAgent(GetAuthorizingAgentName());
     if (nullptr == pAgent)
         otErr << "OTParty::" << __FUNCTION__
               << ": Error: Unable to find Authorizing agent ("
               << GetAuthorizingAgentName() << ") for party: " << GetPartyName()
               << ".\n";
     else if (GetOpeningTransNo() > 0)
         pAgent->RemoveIssuedNumber(GetOpeningTransNo(), strServerID, bSave,
                                    pSignerNym);
     else
         otOut << "OTParty::" << __FUNCTION__
               << ": Nothing to closeout, it was already 0 for party: "
               << GetPartyName() << "\n";
 }

bool opentxs::OTParty::Compare ( const OTParty & rhs ) const

Definition at line 1791 of file OTParty.cpp.

 {
     const std::string str_party_name(rhs.GetPartyName());
 
     if (!(str_party_name.compare(GetPartyName()) == 0)) {
         otOut << "OTParty::Compare: Names don't match.  " << GetPartyName()
               << "  /  " << str_party_name << " \n";
         return false;
     }
 
     // The party might first be added WITHOUT filling out the Nym/Agent info.
     // As long as the party's name is right, and the accounts are all there with
     // the
     // correct asset type IDs, then it should matter if LATER, when the party
     // CONFIRMS
     // the agreement, he supplies himself as an entity or a Nym, or whether he
     // supplies this
     // agent or that agent.  That information is important and is stored, but is
     // not relevant
     // for a Compare().
 
     if ((GetOpeningTransNo() > 0) && (rhs.GetOpeningTransNo() > 0) &&
         (GetOpeningTransNo() != rhs.GetOpeningTransNo())) {
         otOut << "OTParty::Compare: Opening transaction numbers don't match "
                  "for party " << GetPartyName() << ". ( " << GetOpeningTransNo()
               << "  /  " << rhs.GetOpeningTransNo() << " ) \n";
         return false;
     }
 
     if ((GetPartyID().size() > 0) && (rhs.GetPartyID().size() > 0) &&
         !(GetPartyID().compare(rhs.GetPartyID()) == 0)) {
         otOut << "OTParty::Compare: Party IDs don't match for party "
               << GetPartyName() << ". ( " << GetPartyID() << "  /  "
               << rhs.GetPartyID() << " ) \n";
         return false;
     }
 
     if ((GetAuthorizingAgentName().size() > 0) &&
         (rhs.GetAuthorizingAgentName().size() > 0) &&
         !(GetAuthorizingAgentName().compare(rhs.GetAuthorizingAgentName()) ==
           0)) {
         otOut << "OTParty::Compare: Authorizing agent names don't match for "
                  "party " << GetPartyName() << ". ( "
               << GetAuthorizingAgentName() << "  /  "
               << rhs.GetAuthorizingAgentName() << " ) \n";
         return false;
     }
 
     // No need to compare agents... right?
     //
     //    mapOfAgents            m_mapAgents; // These are owned.
 
     if (GetAccountCount() != rhs.GetAccountCount()) {
         otOut << "OTParty::Compare: Mismatched number of accounts when "
                  "comparing party " << GetPartyName() << ". \n";
         return false;
     }
 
     for (const auto& it : m_mapPartyAccounts) {
         const std::string str_acct_name = it.first;
         OTPartyAccount* pAcct = it.second;
         OT_ASSERT(nullptr != pAcct);
 
         OTPartyAccount* p2 = rhs.GetAccount(str_acct_name);
 
         if (nullptr == p2) {
             otOut << "OTParty::Compare: Unable to find Account "
                   << str_acct_name << " on rhs, when comparing party "
                   << GetPartyName() << ". \n";
             return false;
         }
         if (!pAcct->Compare(*p2)) {
             otOut << "OTParty::Compare: Accounts (" << str_acct_name
                   << ") don't match when comparing party " << GetPartyName()
                   << ". \n";
             return false;
         }
     }
 
     return true;
 }

bool opentxs::OTParty::CopyAcctsToConfirmingParty ( OTParty & theParty ) const

Definition at line 1877 of file OTParty.cpp.

 {
     theParty.CleanupAccounts(); // (We're going to copy our own accounts into
                                 // theParty.)
 
     for (const auto& it : m_mapPartyAccounts) {
         const std::string str_acct_name = it.first;
         OTPartyAccount* pAcct = it.second;
         OT_ASSERT(nullptr != pAcct);
 
         if (false ==
             theParty.AddAccount(pAcct->GetAgentName(), pAcct->GetName(),
                                 pAcct->GetAcctID(), pAcct->GetAssetTypeID(),
                                 pAcct->GetClosingTransNo())) {
             otOut
                 << "OTParty::CopyAcctsToConfirmingParty: Unable to add Account "
                 << str_acct_name << ", when copying from *this party "
                 << GetPartyName() << ". \n";
             return false;
         }
     }
 
     return true;
 }

bool opentxs::OTParty::DropFinalReceiptToInboxes	(	mapOfNyms *	pNymMap,
		const OTString &	strServerID,
		OTPseudonym &	theServerNym,
		const int64_t &	lNewTransactionNumber,
		const OTString &	strOrigCronItem,
		OTString *	pstrNote = `nullptr`,
		OTString *	pstrAttachment = `nullptr`
	)

Definition at line 967 of file OTParty.cpp.

 {
     bool bSuccess = true; // Success is defined as "all inboxes were notified"
     const char* szFunc = "OTParty::DropFinalReceiptToInboxes";
 
     OTSmartContract* pSmartContract = nullptr;
 
     if (nullptr == m_pOwnerAgreement) {
         otErr << szFunc << ": Missing pointer to owner agreement.\n";
         return false;
     }
     else if (nullptr == (pSmartContract = dynamic_cast<OTSmartContract*>(
                                m_pOwnerAgreement))) {
         otErr << szFunc
               << ": Can only drop finalReceipts for smart contracts.\n";
         return false;
     }
 
     // By this point, we know pSmartContract is a good pointer.
 
     for (auto& it : m_mapPartyAccounts) {
         OTPartyAccount* pAcct = it.second;
         OT_ASSERT_MSG(nullptr != pAcct,
                       "Unexpected nullptr partyaccount pointer in party map.");
 
         if (false ==
             pAcct->DropFinalReceiptToInbox(
                 pNymMap, // contains any Nyms who might already be
                          // loaded, mapped by ID.
                 strServerID, theServerNym, *pSmartContract,
                 lNewTransactionNumber, strOrigCronItem, pstrNote,
                 pstrAttachment)) {
             otErr << szFunc
                   << ": Failed dropping final Receipt to agent's Inbox.\n";
             bSuccess = false; // Notice: no break. We still try to notify them
                               // all, even if one fails.
         }
     }
 
     return bSuccess;
 }

bool opentxs::OTParty::DropFinalReceiptToNymboxes	(	const int64_t &	lNewTransactionNumber,
		const OTString &	strOrigCronItem,
		OTString *	pstrNote = `nullptr`,
		OTString *	pstrAttachment = `nullptr`,
		OTPseudonym *	pActualNym = `nullptr`
	)

Definition at line 1014 of file OTParty.cpp.

 {
     bool bSuccess =
         false; // Success is defined as "at least one agent was notified"
 
     OTSmartContract* pSmartContract = nullptr;
 
     if (nullptr == m_pOwnerAgreement) {
         otErr << "OTParty::DropFinalReceiptToNymboxes: Missing pointer to "
                  "owner agreement.\n";
         return false;
     }
     else if (nullptr == (pSmartContract = dynamic_cast<OTSmartContract*>(
                                m_pOwnerAgreement))) {
         otErr << "OTParty::DropFinalReceiptToNymboxes: Can only drop "
                  "finalReceipts for smart contracts.\n";
         return false;
     }
 
     // By this point, we know pSmartContract is a good pointer.
 
     for (auto& it : m_mapAgents) {
         OTAgent* pAgent = it.second;
         OT_ASSERT_MSG(nullptr != pAgent,
                       "Unexpected nullptr agent pointer in party map.");
 
         if (false ==
             pAgent->DropFinalReceiptToNymbox(
                 *pSmartContract, lNewTransactionNumber, strOrigCronItem,
                 pstrNote, pstrAttachment, pActualNym))
             otErr << "OTParty::DropFinalReceiptToNymboxes: Failed dropping "
                      "final Receipt to agent's Nymbox.\n";
         else
             bSuccess = true;
     }
 
     return bSuccess;
 }

OTPartyAccount * opentxs::OTParty::GetAccount ( const std::string & str_acct_name ) const

Definition at line 653 of file OTParty.cpp.

 {
     //    otErr << "DEBUGGING OTParty::GetAccount: above find. str_acct_name: %s
     // \n", str_acct_name.c_str());
 
     if (OTScriptable::ValidateName(str_acct_name)) {
         auto it = m_mapPartyAccounts.find(str_acct_name);
 
         if (m_mapPartyAccounts.end() != it) // If we found something...
         {
             OTPartyAccount* pAcct = it->second;
             OT_ASSERT(nullptr != pAcct);
 
             return pAcct;
         }
     }
     else
         otErr << "OTParty::GetAccount: Failed: str_acct_name is invalid.\n";
 
     return nullptr;
 }

OTPartyAccount * opentxs::OTParty::GetAccountByAgent ( const std::string & str_agent_name )

Definition at line 701 of file OTParty.cpp.

 {
     if (OTScriptable::ValidateName(str_agent_name)) {
         for (auto& it : m_mapPartyAccounts) {
             OTPartyAccount* pAcct = it.second;
             OT_ASSERT(nullptr != pAcct);
 
             if (pAcct->GetAgentName().Compare(str_agent_name.c_str()))
                 return pAcct;
         }
     }
     else
         otErr << __FUNCTION__ << ": Failed: str_agent_name is invalid.\n";
 
     return nullptr;
 }

OTPartyAccount * opentxs::OTParty::GetAccountByID ( const OTIdentifier & theAcctID ) const

Definition at line 721 of file OTParty.cpp.

 {
     for (const auto& it : m_mapPartyAccounts) {
         OTPartyAccount* pAcct = it.second;
         OT_ASSERT(nullptr != pAcct);
 
         if (pAcct->IsAccountByID(theAcctID)) return pAcct;
     }
 
     return nullptr;
 }

OTPartyAccount * opentxs::OTParty::GetAccountByIndex ( int32_t nIndex )

Get OTPartyAccount pointer by Index. Returns nullptr on failure.

Definition at line 677 of file OTParty.cpp.

 {
     if (!((nIndex >= 0) &&
           (nIndex < static_cast<int64_t>(m_mapPartyAccounts.size())))) {
         otErr << __FUNCTION__ << ": Index out of bounds: " << nIndex << "\n";
     }
     else {
         int32_t nLoopIndex = -1;
 
         for (auto& it : m_mapPartyAccounts) {
             OTPartyAccount* pAcct = it.second;
             OT_ASSERT(nullptr != pAcct);
 
             ++nLoopIndex; // 0 on first iteration.
 
             if (nLoopIndex == nIndex) return pAcct;
         }
     }
     return nullptr;
 }

int32_t opentxs::OTParty::GetAccountCount ( void ) const

inline

Definition at line 400 of file OTParty.hpp.

     {
         return static_cast<int32_t>(m_mapPartyAccounts.size());
     } // returns total of all accounts owned by this party.

int32_t opentxs::OTParty::GetAccountCount ( std::string str_agent_name ) const

Definition at line 181 of file OTParty.cpp.

 {
     int32_t nCount = 0;
 
     for (const auto& it : m_mapPartyAccounts) {
         const OTPartyAccount* pAcct = it.second;
         OT_ASSERT_MSG(nullptr != pAcct,
                       "Unexpected nullptr partyaccount pointer in party map.");
 
         const OTString& strAgentName = pAcct->GetAgentName();
 
         if (strAgentName.Compare(str_agent_name.c_str())) nCount++;
     }
 
     return nCount;
 }

OTAgent * opentxs::OTParty::GetAgent ( const std::string & str_agent_name ) const

Get Agent pointer by Name. Returns nullptr on failure.

Definition at line 609 of file OTParty.cpp.

 {
     if (OTScriptable::ValidateName(str_agent_name)) {
         auto it = m_mapAgents.find(str_agent_name);
 
         if (m_mapAgents.end() != it) // If we found something...
         {
             OTAgent* pAgent = it->second;
             OT_ASSERT(nullptr != pAgent);
 
             return pAgent;
         }
     }
     else
         otErr << __FUNCTION__ << ": Failed: str_agent_name is invalid...\n";
 
     return nullptr;
 }

OTAgent * opentxs::OTParty::GetAgentByIndex ( int32_t nIndex ) const

Get Agent pointer by Index. Returns nullptr on failure.

Definition at line 630 of file OTParty.cpp.

 {
     if (!((nIndex >= 0) &&
           (nIndex < static_cast<int64_t>(m_mapAgents.size())))) {
         otErr << __FUNCTION__ << ": Index out of bounds: " << nIndex << "\n";
     }
     else {
         int32_t nLoopIndex = -1;
 
         for (auto& it : m_mapAgents) {
             OTAgent* pAgent = it.second;
             OT_ASSERT(nullptr != pAgent);
 
             ++nLoopIndex; // 0 on first iteration.
 
             if (nLoopIndex == nIndex) return pAgent;
         }
     }
     return nullptr;
 }

int32_t opentxs::OTParty::GetAgentCount ( ) const

inline

Definition at line 347 of file OTParty.hpp.

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

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

Definition at line 165 of file OTParty.cpp.

 {
     if (m_lOpeningTransNo > 0) numlistOutput.Add(m_lOpeningTransNo);
 
     for (const auto& it : m_mapPartyAccounts) {
         const OTPartyAccount* pAcct = it.second;
         OT_ASSERT_MSG(nullptr != pAcct,
                       "Unexpected nullptr partyaccount pointer in party map.");
 
         const int64_t lTemp = pAcct->GetClosingTransNo();
         if (lTemp > 0) numlistOutput.Add(lTemp);
     }
 }

const std::string& opentxs::OTParty::GetAuthorizingAgentName ( ) const

inline

Definition at line 353 of file OTParty.hpp.

     {
         return m_str_authorizing_agent;
     }

int64_t opentxs::OTParty::GetClosingTransNo ( std::string str_for_acct_name ) const

Definition at line 416 of file OTParty.cpp.

 {
     auto it = m_mapPartyAccounts.find(str_for_acct_name);
 
     if (m_mapPartyAccounts.end() == it) // If it wasn't already there...
     {
         otOut << "OTParty::GetClosingTransNo: Failed -- Account wasn't found: "
               << str_for_acct_name << ".\n";
         return 0;
     }
 
     OTPartyAccount* pPartyAccount = it->second;
     OT_ASSERT(nullptr != pPartyAccount);
 
     return pPartyAccount->GetClosingTransNo();
 }

std::string opentxs::OTParty::GetEntityID ( bool * pBoolSuccess = nullptr ) const

Definition at line 556 of file OTParty.cpp.

 {
     if (IsEntity() && (m_str_owner_id.size() > 0)) {
         if (nullptr != pBoolSuccess) *pBoolSuccess = true;
 
         return m_str_owner_id;
     }
 
     if (nullptr != pBoolSuccess) *pBoolSuccess = false;
 
     std::string retVal("");
 
     return retVal;
 }

const OTString& opentxs::OTParty::GetMySignedCopy ( )

inline

Definition at line 291 of file OTParty.hpp.

     {
         return m_strMySignedCopy;
     }

std::string opentxs::OTParty::GetNymID ( bool * pBoolSuccess = nullptr ) const

Definition at line 541 of file OTParty.cpp.

 {
     if (IsNym() && (m_str_owner_id.size() > 0)) {
         if (nullptr != pBoolSuccess) *pBoolSuccess = true;
 
         return m_str_owner_id;
     }
 
     if (nullptr != pBoolSuccess) *pBoolSuccess = false;
 
     std::string retVal("");
 
     return retVal; // empty ID on failure.
 }

int64_t opentxs::OTParty::GetOpeningTransNo ( ) const

inline

Definition at line 295 of file OTParty.hpp.

     {
         return m_lOpeningTransNo;
     }

OTScriptable* opentxs::OTParty::GetOwnerAgreement ( )

inline

Definition at line 279 of file OTParty.hpp.

     {
         return m_pOwnerAgreement;
     }

std::string opentxs::OTParty::GetPartyID ( bool * pBoolSuccess = nullptr ) const

Definition at line 571 of file OTParty.cpp.

 {
     // If party is a Nym, this is the NymID. Else return EntityID().
     // if error, return false.
 
     if (IsNym()) return GetNymID(pBoolSuccess);
 
     return GetEntityID(pBoolSuccess);
 }

std::string opentxs::OTParty::GetPartyName ( bool * pBoolSuccess = nullptr ) const

Definition at line 489 of file OTParty.cpp.

 {
     std::string retVal("");
 
     // "sales_director", "marketer", etc
     if (nullptr == m_pstr_party_name) {
         if (nullptr != pBoolSuccess) *pBoolSuccess = false;
 
         return retVal;
     }
 
     if (nullptr != pBoolSuccess) *pBoolSuccess = true;
 
     retVal = *m_pstr_party_name;
 
     return retVal;
 }

void opentxs::OTParty::HarvestAllTransactionNumbers ( const OTString & strServerID )

Definition at line 1587 of file OTParty.cpp.

 {
     HarvestOpeningNumber(strServerID);
     HarvestClosingNumbers(strServerID);
 }

void opentxs::OTParty::HarvestClosingNumbers	(	const OTString &	strServerID,
		bool	bSave = `false`,
		OTPseudonym *	pSignerNym = `nullptr`
	)

Definition at line 1449 of file OTParty.cpp.

 {
 
     for (auto& it : m_mapPartyAccounts) {
         OTPartyAccount* pAcct = it.second;
         OT_ASSERT_MSG(nullptr != pAcct,
                       "OTParty::HarvestClosingNumbers: "
                       "Unexpected nullptr partyaccount pointer in "
                       "party map.");
 
         if (pAcct->GetClosingTransNo() <= 0) continue; // No log, for now.
 
         const std::string str_agent_name(pAcct->GetAgentName().Get());
         if (str_agent_name.size() <= 0) {
             otErr << __FUNCTION__ << ": Missing agent name on party account: "
                   << pAcct->GetName() << " \n";
             continue;
         }
 
         OTAgent* pAgent = GetAgent(str_agent_name);
         if (nullptr == pAgent)
             otErr << __FUNCTION__ << ": Couldn't find agent (" << str_agent_name
                   << ") for asset account: " << pAcct->GetName() << "\n";
         else
             pAgent->HarvestTransactionNumber(
                 pAcct->GetClosingTransNo(), strServerID, bSave,
                 pSignerNym); // server passes in serverNym here, otherwise each
                              // agent uses its own nym.
     }
 }

void opentxs::OTParty::HarvestClosingNumbers	(	OTAgent &	theAgent,
		const OTString &	strServerID
	)

Definition at line 1484 of file OTParty.cpp.

 {
     for (auto& it : m_mapPartyAccounts) {
         OTPartyAccount* pAcct = it.second;
         OT_ASSERT_MSG(nullptr != pAcct,
                       "OTParty::HarvestClosingNumbers: "
                       "Unexpected nullptr partyaccount pointer in "
                       "partyaccount map.");
 
         if (pAcct->GetClosingTransNo() <= 0) continue; // No log, for now.
 
         const std::string str_agent_name(pAcct->GetAgentName().Get());
         if (str_agent_name.size() <= 0) {
             //            otErr << "OTParty::%s: Missing agent name on party
             // account: %s \n",
             //                          __FUNCTION__, pAcct->GetName().Get());
             continue;
         }
 
         if (theAgent.GetName().Compare(str_agent_name.c_str()))
             theAgent.HarvestTransactionNumber(pAcct->GetClosingTransNo(),
                                               strServerID);
         // We don't break here, on success, because this agent might represent
         // multiple accounts.
         // else nothing...
     }
 }

void opentxs::OTParty::HarvestClosingNumbers	(	OTPseudonym &	theNym,
		const OTString &	strServerID
	)

Definition at line 1517 of file OTParty.cpp.

 {
     OTAgent* pAgent = nullptr;
 
     if (HasAgent(theNym, &pAgent)) {
         OT_ASSERT(nullptr != pAgent);
         HarvestClosingNumbers(*pAgent, strServerID);
     }
     // else nothing...
 }

void opentxs::OTParty::HarvestOpeningNumber ( const OTString & strServerID )

Definition at line 1568 of file OTParty.cpp.

 {
     if (GetAuthorizingAgentName().size() <= 0) {
         otErr << "OTParty::" << __FUNCTION__
               << ": Error: Authorizing agent name is blank.\n";
         return;
     }
 
     OTAgent* pAgent = GetAgent(GetAuthorizingAgentName());
     if (nullptr == pAgent)
         otErr << "OTParty::" << __FUNCTION__
               << ": Error: Unable to find Authorizing agent ("
               << GetAuthorizingAgentName() << ") for party: " << GetPartyName()
               << ".\n";
     else
         HarvestOpeningNumber(*pAgent, strServerID);
 }

void opentxs::OTParty::HarvestOpeningNumber	(	OTAgent &	theAgent,
		const OTString &	strServerID
	)

Definition at line 1548 of file OTParty.cpp.

 {
     if (!(GetAuthorizingAgentName().compare(theAgent.GetName().Get()) == 0))
         otErr << "OTParty::" << __FUNCTION__
               << ": Error: Agent name doesn't match:  "
               << GetAuthorizingAgentName() << " / " << theAgent.GetName()
               << "  \n";
     else if (GetOpeningTransNo() > 0)
         theAgent.HarvestTransactionNumber(
             GetOpeningTransNo(),
             strServerID); // bSave=false, pSignerNym=nullptr
     else
         otOut << "OTParty::" << __FUNCTION__
               << ": Nothing to harvest, it was already 0 for party: "
               << GetPartyName() << "\n";
 }

void opentxs::OTParty::HarvestOpeningNumber	(	OTPseudonym &	theNym,
		const OTString &	strServerID
	)

Definition at line 1533 of file OTParty.cpp.

 {
     OTAgent* pAgent = nullptr;
 
     if (HasAuthorizingAgent(theNym, &pAgent)) {
         OT_ASSERT(nullptr != pAgent);
         HarvestOpeningNumber(*pAgent, strServerID);
     }
     // else no error, since many nyms could get passed in here (in a loop)
 } // The function above me, calls the one below.

bool opentxs::OTParty::HasAccount	(	OTAccount &	theAccount,
		OTPartyAccount **	ppPartyAccount = `nullptr`
	)		const

Definition at line 755 of file OTParty.cpp.

 {
     for (const auto& it : m_mapPartyAccounts) {
         OTPartyAccount* pAcct = it.second;
         OT_ASSERT(nullptr != pAcct);
 
         if (pAcct->IsAccount(theAccount)) {
             if (nullptr != ppPartyAccount) *ppPartyAccount = pAcct;
 
             return true;
         }
     }
 
     return false;
 }

bool opentxs::OTParty::HasAccountByID	(	const OTIdentifier &	theAcctID,
		OTPartyAccount **	ppPartyAccount = `nullptr`
	)		const

Definition at line 736 of file OTParty.cpp.

 {
     for (const auto& it : m_mapPartyAccounts) {
         OTPartyAccount* pAcct = it.second;
         OT_ASSERT(nullptr != pAcct);
 
         if (pAcct->IsAccountByID(theAcctID)) {
             if (nullptr != ppPartyAccount) *ppPartyAccount = pAcct;
 
             return true;
         }
     }
 
     return false;
 }

bool opentxs::OTParty::HasActiveAgent ( ) const

Definition at line 592 of file OTParty.cpp.

 {
     // Loop through all agents and call IsAnIndividual() on each.
     // then return true if any is true. else return false;
     //
     for (const auto& it : m_mapAgents) {
         OTAgent* pAgent = it.second;
         OT_ASSERT(nullptr != pAgent);
 
         if (pAgent->IsAnIndividual()) return true;
     }
 
     return false;
 }

bool opentxs::OTParty::HasAgent	(	OTPseudonym &	theNym,
		OTAgent **	ppAgent = `nullptr`
	)		const

Definition at line 776 of file OTParty.cpp.

 {
     for (const auto& it : m_mapAgents) {
         OTAgent* pAgent = it.second;
         OT_ASSERT(nullptr != pAgent);
 
         if (pAgent->IsValidSigner(theNym)) {
             if (nullptr != ppAgent) *ppAgent = pAgent;
 
             return true;
         }
     }
 
     return false;
 }

bool opentxs::OTParty::HasAgentByNymID	(	const OTIdentifier &	theNymID,
		OTAgent **	ppAgent = `nullptr`
	)		const

Definition at line 792 of file OTParty.cpp.

 {
     for (const auto& it : m_mapAgents) {
         OTAgent* pAgent = it.second;
         OT_ASSERT(nullptr != pAgent);
 
         if (pAgent->IsValidSignerID(theNymID)) {
             if (nullptr != ppAgent) *ppAgent = pAgent;
 
             return true;
         }
     }
 
     return false;
 }

bool opentxs::OTParty::HasAuthorizingAgent	(	OTPseudonym &	theNym,
		OTAgent **	ppAgent = `nullptr`
	)		const

Definition at line 814 of file OTParty.cpp.

 {
     if (OTScriptable::ValidateName(m_str_authorizing_agent)) {
         auto it = m_mapAgents.find(m_str_authorizing_agent);
 
         if (m_mapAgents.end() != it) // If we found something...
         {
             OTAgent* pAgent = it->second;
             OT_ASSERT(nullptr != pAgent);
 
             if (pAgent->IsValidSigner(theNym)) // if theNym is valid signer for
                                                // pAgent.
             {
                 // Optionally can pass in a pointer-to-pointer-to-Agent, in
                 // order to get the Agent pointer back.
                 if (nullptr != ppAgent) *ppAgent = pAgent;
 
                 return true;
             }
         }
         else // found nothing.
             otErr << "OTParty::HasAuthorizingAgent: named agent wasn't found "
                      "on list.\n";
     }
 
     return false;
 }

bool opentxs::OTParty::HasAuthorizingAgentByNymID	(	const OTIdentifier &	theNymID,
		OTAgent **	ppAgent = `nullptr`
	)		const

Definition at line 845 of file OTParty.cpp.

 {
     if (OTScriptable::ValidateName(m_str_authorizing_agent)) {
         auto it = m_mapAgents.find(m_str_authorizing_agent);
 
         if (m_mapAgents.end() != it) // If we found something...
         {
             OTAgent* pAgent = it->second;
             OT_ASSERT(nullptr != pAgent);
 
             if (pAgent->IsValidSignerID(theNymID)) // if theNym is valid signer
                                                    // for pAgent.
             {
                 // Optionally can pass in a pointer-to-pointer-to-Agent, in
                 // order to get the Agent pointer back.
                 if (nullptr != ppAgent) *ppAgent = pAgent;
 
                 return true;
             }
         }
         else // found nothing.
             otErr << "OTParty::HasAuthorizingAgentByNymID: named agent wasn't "
                      "found on list.\n";
     }
 
     return false;
 }

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

Definition at line 150 of file OTParty.cpp.

 {
     if (lInput == m_lOpeningTransNo) return true;
 
     for (const auto& it : m_mapPartyAccounts) {
         const OTPartyAccount* pAcct = it.second;
         OT_ASSERT_MSG(nullptr != pAcct,
                       "Unexpected nullptr partyaccount pointer in party map.");
 
         if (lInput == pAcct->GetClosingTransNo()) return true;
     }
 
     return false;
 }

bool opentxs::OTParty::IsEntity ( ) const

Definition at line 532 of file OTParty.cpp.

 {
     // If the party is an Entity. (Either way, the AGENT carries out all
     // wishes.)
     return !m_bPartyIsNym;
 }

bool opentxs::OTParty::IsNym ( ) const

Definition at line 526 of file OTParty.cpp.

 {
     // If the party is a Nym. (The party is the actual owner/beneficiary.)
     return m_bPartyIsNym;
 }

bool opentxs::OTParty::LoadAndVerifyAgentNyms	(	OTPseudonym &	theServerNym,
		mapOfNyms &	map_Nyms_Already_Loaded,
		mapOfNyms &	map_NewlyLoaded
	)

Definition at line 1197 of file OTParty.cpp.

 {
     const bool bIsNym = IsNym();
 
     if (!bIsNym) // Owner MUST be a Nym (until I code Entities.)
     {
         otErr << "OTParty::LoadAndVerifyAgents: Entities and roles have not "
                  "been coded yet. Party owner MUST be a Nym. \n";
         return false;
     }
     if (GetOpeningTransNo() <= 0) // Opening Trans Number MUST be set for the
                                   // party! VerifyPartyAuthorization() only
                                   // verifies it if it's set. Therefore
     { // if we are verifying the agent Nyms based on the assumption that the
         // authorizing Nym is valid, then we want to make sure
         otErr << "OTParty::LoadAndVerifyAgents: This party doesn't have a "
                  "valid opening transaction number. Sorry. \n"; // the Opening
                                                                 // Num is being
                                                                 // checked for
                                                                 // that Nym.
                                                                 // (And if it's
                                                                 // above 0, then
                                                                 // it IS being
                                                                 // checked.)
         return false;
     }
 
     bool bGotPartyNymID = false;
     const std::string str_owner_id = GetNymID(
         &bGotPartyNymID); // str_owner_id  is the NymID of the party OWNER.
     OT_ASSERT(bGotPartyNymID);
 
     const OTString strServerNymID(theServerNym);
 
     for (auto& it_agent : m_mapAgents) {
         OTAgent* pAgent = it_agent.second;
         OT_ASSERT_MSG(pAgent != nullptr,
                       "Unexpected nullptr agent pointer in party map.");
 
         if (!pAgent->IsAnIndividual() || !pAgent->DoesRepresentHimself()) {
             otErr << "OTParty::LoadAndVerifyAgents: Entities and roles have "
                      "not been coded yet. "
                      "Agent needs to be an individual who represents himself, "
                      "and Party owner needs to be the same Nym.\n";
             return false;
         }
 
         OTIdentifier theNymID;
         bool bGotAgentNymID = pAgent->GetNymID(theNymID);
         const OTString strNymID(theNymID);
         const std::string str_agent_id =
             bGotAgentNymID ? strNymID.Get()
                            : ""; // str_agent_id is the NymID of the AGENT.
         OT_ASSERT(bGotAgentNymID);
 
         // COMPARE THE IDS...... Since the Nym for this agent is representing
         // himself (he is also owner)
         // therefore they should have the same NymID.
 
         if (!(str_agent_id.compare(str_owner_id) ==
               0)) // If they don't match. (Until I code entities, a party can
                   // only be a Nym representing himself as an agent.)
         {
             otErr << "OTParty::LoadAndVerifyAgents: Nym supposedly represents "
                      "himself (owner AND agent) yet "
                      "they have different Nym IDs:  " << str_owner_id << " / "
                   << str_agent_id << ".\n";
             return false;
         }
 
         // Server Nym is not allowed as a party (at this time :-)
         if (str_agent_id.compare(strServerNymID.Get()) ==
             0) // If they DO match.
         {
             otErr << "OTParty::LoadAndVerifyAgents: Server Nym is not allowed "
                      "to serve as an agent for smart contracts. Sorry.\n";
             return false;
         }
 
         // BY THIS POINT we know that the Party is a Nym, the Agent is an
         // individual representing himself, and
         // we know that they have the SAME NYM ID.
         //
         // Next step: See if the Nym is already loaded and if not, load him up.
 
         bool bHadToLoadtheNymMyself = true;
         OTPseudonym* pNym = nullptr;
 
         auto it =
             map_Nyms_Already_Loaded.find(str_agent_id); // If it's there, it's
                                                         // mapped by Nym ID, so
                                                         // we can look it up.
 
         if (map_Nyms_Already_Loaded.end() != it) // Found it.
         {
             pNym = it->second;
             OT_ASSERT(nullptr != pNym);
 
             // Now we KNOW the Nym is "already loaded" and we KNOW the agent has
             // a POINTER to that Nym:
             //
             OT_ASSERT(pAgent->IsValidSigner(*pNym)); // assert because the Nym
                                                      // was already mapped by
                                                      // ID, so it should already
                                                      // have been validated.
 
             bHadToLoadtheNymMyself =
                 false; // Whew. He was already loaded. Found him.
         }
 
         // Looks like the Nym wasn't already loaded....
         // Let's load him up
         //
         if (bHadToLoadtheNymMyself) {
             if (nullptr == (pNym = pAgent->LoadNym(theServerNym))) {
                 otErr << "OTParty::LoadAndVerifyAgents: Failed loading Nym "
                          "with ID: " << str_agent_id << "\n";
                 return false;
             }
             // Successfully loaded the Nym! We add to this map so it gets
             // cleaned-up properly later.
             map_NewlyLoaded.insert(std::pair<std::string, OTPseudonym*>(
                 str_agent_id, pNym)); // I use str_agent_id here because it
                                       // contains the right NymID.
         }
 
         // BY THIS POINT, we know the Nym is available for use, whether I had to
         // load it myself first or not.
         // We also know that if I DID have to load it myself, the pointer was
         // saved in map_NewlyLoaded for cleanup later.
         //
         // Until entities are coded, by this point we also KNOW that
         // the agent's NymID and the Party (owner)'s NymID are identical.
         //
         // Before this function was even called, we knew that
         // OTScriptable::VerifyPartyAuthorization() was already called
         // on all the parties, and we know that every party's signed copy was
         // verified against the signature of its authorizing
         // agent, and that the Opening trans# for that party is currently signed
         // out to THAT AGENT.
         //
         // If the NymIDs are identical between agent and owner, and the owner's
         // authorizing agent (that same nym) has SIGNED
         // its party's copy, and the Opening Trans# is signed out to that agent,
         // then we have basically verified that agent.
         // Right?
         //
         // WHAT if one of the Nyms loaded by this agent was NOT the same Nym as
         // the owner? In that case, it would have to be
         // a Nym working for an entity in a role, and I haven't coded entities
         // yet, so I just disallow that case entirely
         //
         // By this point, the call to LoadNym also did a LoadSignedNymFile() and
         // a call to VerifyPseudonym().
         //
         // FINALLY, the calls to pAgent->IsValidSigner( *pNym ) or
         // pAgent->LoadNym(theServerNym) (whichever occurred -- one or the
         // other)
         // have now insured by this point that pAgent continues to have an
         // INTERNAL POINTER to pNym...
     }
 
     return true;
 }

bool opentxs::OTParty::LoadAndVerifyAssetAccounts	(	OTPseudonym &	theServerNym,
		const OTString &	strServerID,
		mapOfAccounts &	map_Accts_Already_Loaded,
		mapOfAccounts &	map_NewlyLoaded
	)

Definition at line 1094 of file OTParty.cpp.

 {
     std::set<std::string> theAcctIDSet; // Make sure all the acct IDs are
                                         // unique.
 
     for (auto& it_acct : m_mapPartyAccounts) {
         const std::string str_acct_name = it_acct.first;
         OTPartyAccount* pPartyAcct = it_acct.second;
         OT_ASSERT(pPartyAcct != nullptr);
 
         bool bHadToLoadtheAcctMyself = true;
         OTAccount* pAccount = nullptr;
 
         const OTString& strAcctID = pPartyAcct->GetAcctID();
 
         if (!strAcctID.Exists()) {
             otOut << "OTParty::LoadAndVerifyAssetAccounts: Bad: Acct ID is "
                      "blank for account: " << str_acct_name
                   << ", on party: " << GetPartyName() << ".\n";
             return false;
         }
 
         // Disallow duplicate Acct IDs.
         // (Only can use an acct once inside a smart contract.)
         //
         auto it_acct_id = theAcctIDSet.find(strAcctID.Get());
 
         if (theAcctIDSet.end() == it_acct_id) // It's not already there (good).
         {
             theAcctIDSet.insert(strAcctID.Get()); // Save a copy so we can make
                                                   // sure there's no duplicate
                                                   // acct IDs. (Not allowed.)
         }
         else {
             otOut << "OTParty::LoadAndVerifyAssetAccounts: Failure: Found a "
                      "duplicate Acct ID (" << strAcctID
                   << "), on acct: " << str_acct_name << ".\n";
             return false;
         }
 
         auto it = map_Accts_Already_Loaded.find(
             strAcctID.Get()); // If it's there, it's mapped by Acct ID, so we
                               // can look it up.
 
         if (map_Accts_Already_Loaded.end() != it) // Found it.
         {
             pAccount = it->second;
             OT_ASSERT(nullptr != pAccount);
 
             // Now we KNOW the Account is "already loaded" and we KNOW the
             // partyaccount has a POINTER to that Acct:
             //
             const bool bIsPartyAcct = pPartyAcct->IsAccount(*pAccount);
             if (!bIsPartyAcct)
                 otErr << "OTParty::LoadAndVerifyAssetAccounts: Failed call: "
                          "pPartyAcct->IsAccount(*pAccount); \n";
             OT_ASSERT_MSG(
                 bIsPartyAcct,
                 "OTParty::LoadAndVerifyAssetAccounts: Failed call: "
                 "pPartyAcct->IsAccount(*pAccount); \n"); // assert because the
                                                          // Acct was already
                                                          // mapped by ID, so it
                                                          // should already have
                                                          // been validated.
 
             bHadToLoadtheAcctMyself = false; // Whew. The Acct was already
                                              // loaded. Found it. (And the ptr
                                              // is now set.)
         }
 
         // Looks like the Acct wasn't already loaded....
         // Let's load it up...
         //
         if (bHadToLoadtheAcctMyself == true) {
             if (nullptr == (pAccount = pPartyAcct->LoadAccount(
                                 theServerNym, strServerID))) // This calls
                                                              // VerifyAccount(),
                                                              // AND it sets
                                                              // pPartyAcct's
                                                              // internal ptr.
             {
                 otOut << "OTParty::LoadAndVerifyAssetAccounts: Failed loading "
                          "Account with name: " << str_acct_name
                       << " and ID: " << strAcctID << "\n";
                 return false;
             }
             // Successfully loaded the Acct! We add to this map so it gets
             // cleaned-up properly later.
             map_NewlyLoaded.insert(
                 std::pair<std::string, OTAccount*>(strAcctID.Get(), pAccount));
         }
     }
 
     return true;
 }

OTPseudonym * opentxs::OTParty::LoadAuthorizingAgentNym	(	OTPseudonym &	theSignerNym,
		OTAgent **	ppAgent = `nullptr`
	)

Definition at line 899 of file OTParty.cpp.

 {
     if (OTScriptable::ValidateName(m_str_authorizing_agent)) {
         auto it = m_mapAgents.find(m_str_authorizing_agent);
 
         if (m_mapAgents.end() != it) // If we found something...
         {
             OTAgent* pAgent = it->second;
             OT_ASSERT(nullptr != pAgent);
 
             OTPseudonym* pNym = nullptr;
 
             if (!pAgent->IsAnIndividual())
                 otErr << "OTParty::LoadAuthorizingAgentNym: This agent is not "
                          "an individual--there's no Nym to load.\n";
             else if (nullptr == (pNym = pAgent->LoadNym(theSignerNym)))
                 otErr << "OTParty::LoadAuthorizingAgentNym: Failed loading "
                          "Nym.\n";
             else {
                 if (nullptr !=
                     ppAgent) // Pass the agent back, too, if it was requested.
                     *ppAgent = pAgent;
 
                 return pNym; // Success
             }
         }
         else // found nothing.
             otErr << "OTParty::LoadAuthorizingAgentNym: named agent wasn't "
                      "found on list.\n";
     }
 
     return nullptr;
 }

void opentxs::OTParty::RegisterAccountsForExecution ( OTScript & theScript )

Definition at line 1779 of file OTParty.cpp.

 {
     for (auto& it : m_mapPartyAccounts) {
         const std::string str_acct_name = it.first;
         OTPartyAccount* pAccount = it.second;
         OT_ASSERT((nullptr != pAccount) && (str_acct_name.size() > 0));
 
         pAccount->RegisterForExecution(theScript);
     }
 }

bool opentxs::OTParty::ReserveTransNumsForConfirm ( const OTString & strServerID )

Definition at line 1631 of file OTParty.cpp.

 {
 
     // RESERVE THE OPENING TRANSACTION NUMBER, LOCATED ON THE AUTHORIZING AGENT
     // FOR THIS PARTY.
 
     if (GetAuthorizingAgentName().size() <= 0) {
         otOut << "OTParty::ReserveTransNumsForConfirm: Failure: Authorizing "
                  "agent's name is empty on this party: " << GetPartyName()
               << " \n";
         return false;
     }
 
     OTAgent* pMainAgent = GetAgent(GetAuthorizingAgentName());
 
     if (nullptr == pMainAgent) {
         otOut << "OTParty::ReserveTransNumsForConfirm: Failure: Authorizing "
                  "agent (" << GetPartyName()
               << ") not found on this party: " << GetAuthorizingAgentName()
               << " \n";
         return false;
     }
 
     if (false ==
         pMainAgent->ReserveOpeningTransNum(
             strServerID)) // <==============================
     {
         otOut << "OTParty::ReserveTransNumsForConfirm: Failure: Authorizing "
                  "agent (" << GetAuthorizingAgentName()
               << ") didn't have an opening transaction #, on party: "
               << GetPartyName() << " \n";
         return false;
     }
     // BELOW THIS POINT, the OPENING trans# has been RESERVED and
     // must be RETRIEVED in the event of failure, using this call:
     // HarvestAllTransactionNumbers(strServerID);
 
     // RESERVE THE CLOSING TRANSACTION NUMBER for each asset account, LOCATED ON
     // ITS AUTHORIZED AGENT.
     // (Do this for each account on this party.)
     //
     for (auto& it : m_mapPartyAccounts) {
         OTPartyAccount* pPartyAccount = it.second;
         OT_ASSERT(nullptr != pPartyAccount);
 
         if (!pPartyAccount->GetAgentName().Exists()) {
             otOut << "OTParty::ReserveTransNumsForConfirm: Failure: Authorized "
                      "agent name is blank for account: "
                   << pPartyAccount->GetName() << " \n";
             HarvestAllTransactionNumbers(strServerID); // We have to put them
                                                        // back before returning,
                                                        // since this function
                                                        // has failed.
             return false;
         }
 
         OTAgent* pAgent = GetAgent(pPartyAccount->GetAgentName().Get());
 
         if (nullptr == pAgent) {
             otOut << "OTParty::ReserveTransNumsForConfirm: Failure: Unable to "
                      "locate Authorized agent for account: "
                   << pPartyAccount->GetName() << " \n";
             HarvestAllTransactionNumbers(strServerID); // We have to put them
                                                        // back before returning,
                                                        // since this function
                                                        // has failed.
             return false;
         }
         // Below this point, pAgent is good.
 
         if (false ==
             pAgent->ReserveClosingTransNum(
                 strServerID, *pPartyAccount)) // <==============================
         {
             otOut << "OTParty::ReserveTransNumsForConfirm: Failure: "
                      "Authorizing agent (" << GetAuthorizingAgentName()
                   << ") didn't have a closing transaction #, on party: "
                   << GetPartyName() << " \n";
             HarvestAllTransactionNumbers(strServerID); // We have to put them
                                                        // back before returning,
                                                        // since this function
                                                        // has failed.
             return false;
         }
         // BELOW THIS POINT, the CLOSING TRANSACTION # has been reserved for
         // this account,
         // and MUST BE RETRIEVED in the event of failure.
     }
 
     // BY THIS POINT, we have successfully reserved the Opening Transaction #
     // for the party (from its
     // authorizing agent) and we have also successfully reserved Closing
     // Transaction #s for EACH ASSET
     // ACCOUNT, from the authorized agent for each asset account.
     // Therefore we have reserved ALL the needed transaction #s, so let's return
     // true.
 
     return true;
 }

void opentxs::OTParty::RetrieveNymPointers ( mapOfNyms & map_Nyms_Already_Loaded )

Definition at line 879 of file OTParty.cpp.

 {
     for (auto& it : m_mapAgents) {
         OTAgent* pAgent = it.second;
         OT_ASSERT(nullptr != pAgent);
 
         pAgent->RetrieveNymPointer(map_Nyms_Already_Loaded);
     }
 }

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

Definition at line 1057 of file OTParty.cpp.

 {
     bool bSuccess =
         false; // Success is defined as "at least one agent was notified"
 
     if (nullptr == m_pOwnerAgreement) {
         otErr << __FUNCTION__ << ": Missing pointer to owner agreement.\n";
         return false;
     }
 
     const int64_t lOpeningTransNo = GetOpeningTransNo();
 
     if (lOpeningTransNo > 0) {
         for (auto& it : m_mapAgents) {
             OTAgent* pAgent = it.second;
             OT_ASSERT_MSG(nullptr != pAgent,
                           "Unexpected nullptr agent pointer in party map.");
 
             if (false ==
                 pAgent->DropServerNoticeToNymbox(
                     bSuccessMsg, theServerNym, theServerID,
                     lNewTransactionNumber, lOpeningTransNo, // lInReferenceTo
                     strReference, pstrNote, pstrAttachment, pActualNym))
                 otErr << __FUNCTION__
                       << ": Failed dropping server notice to agent's Nymbox.\n";
             else
                 bSuccess = true;
         }
     }
     return bSuccess;
 }

void opentxs::OTParty::Serialize	(	OTString &	strAppend,
		bool	bCalculatingID = `false`,
		bool	bSpecifyAssetID = `false`,
		bool	bSpecifyParties = `false`
	)		const

Definition at line 1731 of file OTParty.cpp.

 {
     strAppend.Concatenate(
         "<party\n name=\"%s\"\n"
         " ownerType=\"%s\"\n" // "nym" or "entity"
         " ownerID=\"%s\"\n"   // Entity or Nym ID.  Perhaps should just have
                               // both...
         " openingTransNo=\"%lld\"\n"   // fine here.
         " signedCopyProvided=\"%s\"\n" // true/false
         " authorizingAgent=\"%s\"\n"   // When an agent activates this contract,
                                        // it's HIS opening trans#.
         " numAgents=\"%d\"\n"          // integer count.
         " numAccounts=\"%d\" >\n\n",   // integer count.
         GetPartyName().c_str(),
         bCalculatingID ? "" : (m_bPartyIsNym ? "nym" : "entity"),
         (bCalculatingID && !bSpecifyParties) ? "" : m_str_owner_id.c_str(),
         bCalculatingID ? 0 : m_lOpeningTransNo,
         (!bCalculatingID && m_strMySignedCopy.Exists()) ? "true" : "false",
         bCalculatingID ? "" : m_str_authorizing_agent.c_str(),
         bCalculatingID ? 0 : m_mapAgents.size(), m_mapPartyAccounts.size());
 
     if (!bCalculatingID) {
         for (auto& it : m_mapAgents) {
             OTAgent* pAgent = it.second;
             OT_ASSERT(nullptr != pAgent);
             pAgent->Serialize(strAppend);
         }
     }
 
     for (auto& it : m_mapPartyAccounts) {
         OTPartyAccount* pAcct = it.second;
         OT_ASSERT(nullptr != pAcct);
         pAcct->Serialize(strAppend, bCalculatingID, bSpecifyAssetID);
     }
 
     if (!bCalculatingID && m_strMySignedCopy.Exists()) {
         OTASCIIArmor ascTemp(m_strMySignedCopy);
         strAppend.Concatenate("<mySignedCopy>\n%s</mySignedCopy>\n\n",
                               ascTemp.Get());
     }
 
     strAppend.Concatenate("</party>\n\n");
 }

void opentxs::OTParty::SetAuthorizingAgentName ( std::string str_agent_name )

inline

Definition at line 357 of file OTParty.hpp.

     {
         m_str_authorizing_agent = str_agent_name;
     }

void opentxs::OTParty::SetMySignedCopy ( const OTString & strMyCopy )

inline

Definition at line 287 of file OTParty.hpp.

     {
         m_strMySignedCopy = strMyCopy;
     }

void opentxs::OTParty::SetOpeningTransNo ( const int64_t & theNumber )

inline

Definition at line 299 of file OTParty.hpp.

     {
         m_lOpeningTransNo = theNumber;
     }

void opentxs::OTParty::SetOwnerAgreement ( OTScriptable & theOwner )

inline

Definition at line 283 of file OTParty.hpp.

     {
         m_pOwnerAgreement = &theOwner;
     }

bool opentxs::OTParty::SetPartyName ( const std::string & str_party_name_input )

Definition at line 507 of file OTParty.cpp.

 {
     if (!OTScriptable::ValidateName(str_party_name_input)) {
         otErr << "OTParty::SetPartyName: Failed: Invalid name was passed in.\n";
         return false;
     }
 
     if (nullptr == m_pstr_party_name)
         OT_ASSERT(nullptr != (m_pstr_party_name = new std::string));
 
     *m_pstr_party_name = str_party_name_input;
 
     return true;
 }

bool opentxs::OTParty::SignContract ( OTContract & theInput ) const

Definition at line 1423 of file OTParty.cpp.

 {
     if (GetAuthorizingAgentName().size() <= 0) {
         otErr << "OTParty::" << __FUNCTION__
               << ": Error: Authorizing agent name is blank.\n";
         return false;
     }
 
     OTAgent* pAgent = GetAgent(GetAuthorizingAgentName());
 
     if (nullptr == pAgent) {
         otErr << "OTParty::" << __FUNCTION__
               << ": Error: Unable to find Authorizing agent ("
               << GetAuthorizingAgentName() << ") for party: " << GetPartyName()
               << ".\n";
         return false;
     }
 
     return pAgent->SignContract(theInput);
 }

bool opentxs::OTParty::VerifyAccountsWithTheirAgents	(	OTPseudonym &	theSignerNym,
		const OTString &	strServerID,
		bool	bBurnTransNo = `false`
	)

Definition at line 1370 of file OTParty.cpp.

 {
     OT_ASSERT(nullptr != m_pOwnerAgreement);
 
     bool bAllSuccessful = true;
 
     // By this time this function is called, ALL the Nyms and Asset Accounts
     // should ALREADY
     // be loaded up in memory!
     //
     for (auto& it : m_mapPartyAccounts) {
         const std::string str_acct_name = it.first;
         OTPartyAccount* pAcct = it.second;
         OT_ASSERT_MSG(nullptr != pAcct,
                       "Unexpected nullptr partyaccount pointer in party map.");
 
         const bool bVerified = m_pOwnerAgreement->VerifyPartyAcctAuthorization(
             *pAcct, // The party is assumed to have been verified already via
                     // VerifyPartyAuthorization()
             theSignerNym,  // For verifying signature on the authorizing Nym and
                            // for accts as well.
             strServerID,   // For verifying issued num, need the serverID the #
                            // goes with.
             bBurnTransNo); // bBurnTransNo=false ) // In
                            // OTServer::VerifySmartContract(), it not only wants
                            // to verify the closing # is properly issued, but it
                            // additionally wants to see that it hasn't been USED
                            // yet -- AND it wants to burn it, so it can't be
                            // used again!  This bool allows you to tell the
                            // function whether or not to do that.
         if (!bVerified)    // This mechanism is here because we still want
                            // to let them ALL verify, before returning
                            // false.
         {
             bAllSuccessful = false; // That is, we don't want to return at the
                                     // first failure, but let them all go
                                     // through. (This is in order to keep the
                                     // output consistent.)
             otOut << "OTParty::" << __FUNCTION__
                   << ": Ownership, agency, or potentially "
                      "closing transaction # failed to verify on account: "
                   << str_acct_name << " \n";
         }
     }
 
     return bAllSuccessful;
 }

bool opentxs::OTParty::VerifyOwnershipOfAccount ( const OTAccount & theAccount ) const

Definition at line 934 of file OTParty.cpp.

 {
     if (IsNym()) // For those cases where the party is actually just a
                  // solitary Nym (not an entity.)
     {
         bool bNymID = false;
         std::string str_nym_id =
             GetNymID(&bNymID); // If the party is a Nym, this is the Nym's
                                // ID. Otherwise this is false.
 
         if (!bNymID || (str_nym_id.size() <= 0)) {
             otErr << " OTParty::VerifyOwnershipOfAccount: Although party is a "
                      "Nym, unable to retrieve NymID!\n";
             return false;
         }
 
         const OTIdentifier thePartyNymID(str_nym_id.c_str());
 
         return theAccount.VerifyOwnerByID(thePartyNymID);
     }
     else if (IsEntity())
         otErr << "OTParty::VerifyOwnershipOfAccount: Error: Entities have not "
                  "been implemented yet, "
                  "but somehow this party is an entity.\n";
     else
         otErr << "OTParty::VerifyOwnershipOfAccount: Error: Unknown party "
                  "type.\n";
 
     return false;
 }

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

/usr/local/src/opentxs/include/opentxs/core/script/OTParty.hpp
/usr/local/src/opentxs/src/core/script/OTParty.cpp

Public Member Functions

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation