opentxs::OTAgent Class Reference

#include <OTAgent.hpp>

Public Member Functions
	OTAgent ()
	OTAgent (std::string str_agent_name, OTPseudonym &theNym, bool bNymRepresentsSelf=true)
	OTAgent (bool bNymRepresentsSelf, bool bIsAnIndividual, const OTString &strName, const OTString &strNymID, const OTString &strRoleID, const OTString &strGroupName)
virtual	~OTAgent ()
void	Serialize (OTString &strAppend) const
void	ClearTemporaryPointers ()
bool	VerifyIssuedNumber (const int64_t &lNumber, const OTString &strServerID)
bool	VerifyTransactionNumber (const int64_t &lNumber, const OTString &strServerID)
bool	RemoveIssuedNumber (const int64_t &lNumber, const OTString &strServerID, bool bSave=false, OTPseudonym *pSignerNym=nullptr)
bool	RemoveTransactionNumber (const int64_t &lNumber, const OTString &strServerID, OTPseudonym &SIGNER_NYM, bool bSave=true)
bool	HarvestTransactionNumber (const int64_t &lNumber, const OTString &strServerID, bool bSave=false, OTPseudonym *pSignerNym=nullptr)
bool	ReserveOpeningTransNum (const OTString &strServerID)
bool	ReserveClosingTransNum (const OTString &strServerID, OTPartyAccount &thePartyAcct)
EXPORT bool	SignContract (OTContract &theInput) const
bool	VerifyAgencyOfAccount (const OTAccount &theAccount) const
bool	VerifySignature (const OTContract &theContract) const
void	SetParty (OTParty &theOwnerParty)
void	SetNymPointer (OTPseudonym &theNym)
EXPORT bool	IsValidSigner (OTPseudonym &theNym)
EXPORT bool	IsValidSignerID (const OTIdentifier &theNymID)
bool	IsAuthorizingAgentForParty ()
int32_t	GetCountAuthorizedAccts ()
bool	DoesRepresentHimself () const
bool	DoesRepresentAnEntity () const
EXPORT bool	IsAnIndividual () const
bool	IsAGroup () const
EXPORT bool	GetNymID (OTIdentifier &theOutput) const
bool	GetRoleID (OTIdentifier &theOutput) const
bool	GetSignerID (OTIdentifier &theOutput) const
bool	GetEntityID (OTIdentifier &theOutput) const
EXPORT const OTString &	GetName ()
bool	GetGroupName (OTString &strGroupName)
bool	GetPartyID (OTIdentifier &theOutput) const
OTParty *	GetParty () const
void	RetrieveNymPointer (mapOfNyms &map_Nyms_Already_Loaded)
OTPseudonym *	LoadNym (OTPseudonym &theServerNym)
bool	DropFinalReceiptToNymbox (OTSmartContract &theSmartContract, const int64_t &lNewTransactionNumber, const OTString &strOrigCronItem, OTString *pstrNote=nullptr, OTString *pstrAttachment=nullptr, OTPseudonym *pActualNym=nullptr)
bool	DropFinalReceiptToInbox (mapOfNyms *pNymMap, const OTString &strServerID, OTPseudonym &theServerNym, OTSmartContract &theSmartContract, const OTIdentifier &theAccountID, const int64_t &lNewTransactionNumber, const int64_t &lClosingNumber, const OTString &strOrigCronItem, OTString *pstrNote=nullptr, OTString *pstrAttachment=nullptr)
bool	DropServerNoticeToNymbox (bool bSuccessMsg, OTPseudonym &theServerNym, const OTIdentifier &theServerID, const int64_t &lNewTransactionNumber, const int64_t &lInReferenceTo, const OTString &strReference, OTString *pstrNote=nullptr, OTString *pstrAttachment=nullptr, OTPseudonym *pActualNym=nullptr)

Detailed Description

Definition at line 164 of file OTAgent.hpp.

Constructor & Destructor Documentation

opentxs::OTAgent::OTAgent

(

)

Definition at line 266 of file OTAgent.cpp.

    : m_bNymRepresentsSelf(false)
    , m_bIsAnIndividual(false)
    , m_pNym(nullptr)
    , m_pForParty(nullptr)
{
}

opentxs::OTAgent::OTAgent	(	std::string	str_agent_name,
		OTPseudonym &	theNym,
		bool	bNymRepresentsSelf = true
	)

Definition at line 288 of file OTAgent.cpp.

    : m_bNymRepresentsSelf(bNymRepresentsSelf),
      m_bIsAnIndividual(true),
      m_pNym(&theNym),
      m_pForParty(nullptr),
      m_strName(str_agent_name.c_str())
{
    // Grab m_strNymID
    OTIdentifier theNymID;
    theNym.GetIdentifier(theNymID);
    theNymID.GetString(m_strNymID);

    //

    if (!bNymRepresentsSelf) {
        // Todo: if the Nym represents an Entity, then RoleID should
        // be passed in, and set here.  I WILL PROBABLY make that part into a
        // SEPARATE CONSTRUCTOR.
        // (Once I get around to adding Entities.)
        //
        otErr << "OTAgent::OTAgent: THIS HASN'T BEEN WRITTEN YET!!\n";
    }
}

opentxs::OTAgent::OTAgent	(	bool	bNymRepresentsSelf,
		bool	bIsAnIndividual,
		const OTString &	strName,
		const OTString &	strNymID,
		const OTString &	strRoleID,
		const OTString &	strGroupName
	)

Definition at line 274 of file OTAgent.cpp.

    : m_bNymRepresentsSelf(bNymRepresentsSelf)
    , m_bIsAnIndividual(bIsAnIndividual)
    , m_pNym(nullptr)
    , m_pForParty(nullptr)
    , m_strName(strName)
    , m_strNymID(strNymID)
    , m_strRoleID(strRoleID)
    , m_strGroupName(strGroupName)
{
}

opentxs::OTAgent::~OTAgent ( )

virtual

Definition at line 351 of file OTAgent.cpp.

{
    m_pNym =
        nullptr; // this pointer is not owned by this object, and is here for
                 // convenience only.
    m_pForParty =
        nullptr; // The agent probably has a pointer to the party it acts
                 // on behalf of.
}

Member Function Documentation

void opentxs::OTAgent::ClearTemporaryPointers ( )

inline

Definition at line 231 of file OTAgent.hpp.

    {
        m_pNym = nullptr;
    } /* Someday clear entity/role ptr here? And do NOT

bool opentxs::OTAgent::DoesRepresentAnEntity

(

)

const

Definition at line 375 of file OTAgent.cpp.

{
    return !m_bNymRepresentsSelf;
}

bool opentxs::OTAgent::DoesRepresentHimself

(

)

const

Definition at line 365 of file OTAgent.cpp.

{

    return m_bNymRepresentsSelf;
}

bool opentxs::OTAgent::DropFinalReceiptToInbox	(	mapOfNyms *	pNymMap,
		const OTString &	strServerID,
		OTPseudonym &	theServerNym,
		OTSmartContract &	theSmartContract,
		const OTIdentifier &	theAccountID,
		const int64_t &	lNewTransactionNumber,
		const int64_t &	lClosingNumber,
		const OTString &	strOrigCronItem,
		OTString *	pstrNote = nullptr,
		OTString *	pstrAttachment = nullptr
	)

Definition at line 717 of file OTAgent.cpp.

{
    // TODO: When entites and ROLES are added, this function may change a bit to
    // accommodate them.
    const char* szFunc = "OTAgent::DropFinalReceiptToInbox";

    OTIdentifier theAgentNymID;
    bool bNymID = GetNymID(theAgentNymID);

    // Not all agents have Nyms. (Might be a voting group.)
    // But in the case of Inboxes for asset accounts, shouldn't the agent be a
    // Nym?
    // Perhaps not... perhaps not... we shall see.

    if (true == bNymID) // therefore IsAnIndividual() is definitely true.
    {
        OTPseudonym* pNym = nullptr;
        std::unique_ptr<OTPseudonym> theNymAngel;

        // If a list of pre-loaded Nyms was passed in, see if one of them is
        // ours.
        //
        if (nullptr != pNymMap) {
            const OTString strNymID(theAgentNymID);
            OT_ASSERT(strNymID.Exists());

            auto ittt = pNymMap->find(strNymID.Get());

            if (pNymMap->end() != ittt) // found it!
            {
                pNym = ittt->second;
                OT_ASSERT(nullptr != pNym);
            }
        }

        if (nullptr ==
            pNym) // It wasn't on the list of already-loaded nyms that
                  // was passed in, so we have to load it.
        {
            // By this point we also know that pNym is NOT the server Nym, nor
            // is it the
            // Originator, nor pActingNym, nor pPartyNym, as they were all
            // loaded already and
            // were added to pNymMap, yet we didn't find the Nym we were looking
            // for among them.
            //
            // (Therefore this is some new Nym, and doesn't need to be verified
            // against those Nyms again,
            // before loading it. Let's load it up!)
            //
            if (nullptr == (pNym = LoadNym(theServerNym)))
                otErr << szFunc << ": Failed loading Nym.\n";
            else
                theNymAngel.reset(pNym); // CLEANUP  :-)
        }

        // I call this because LoadNym sets my internal Nym pointer to pNym, and
        // then
        // it goes out of scope before the end of this function and gets
        // cleaned-up.
        // Therefore, no point in letting this agent continue to point to bad
        // memory...
        //
        ClearTemporaryPointers();

        if ((nullptr != pNym) && (lClosingNumber > 0) &&
            pNym->VerifyIssuedNum(strServerID,
                                  lClosingNumber)) // <====================
        {
            return theSmartContract.DropFinalReceiptToInbox(
                theAgentNymID, theAccountID, lNewTransactionNumber,
                lClosingNumber, strOrigCronItem, pstrNote,
                pstrAttachment); // pActualAcct=nullptr here. (This call will
                                 // load
                                 // the acct up and update its inbox hash.)
        }
        else
            otErr << szFunc
                  << ": Error: pNym is nullptr, or lClosingNumber <=0, "
                     "or pNym->VerifyIssuedNum(strServerID, "
                     "lClosingNumber)) failed to verify.\n";
    }
    else
        otErr << szFunc << ": No NymID available for this agent...\n";

    return false;
}

bool opentxs::OTAgent::DropFinalReceiptToNymbox	(	OTSmartContract &	theSmartContract,
		const int64_t &	lNewTransactionNumber,
		const OTString &	strOrigCronItem,
		OTString *	pstrNote = nullptr,
		OTString *	pstrAttachment = nullptr,
		OTPseudonym *	pActualNym = nullptr
	)

Definition at line 810 of file OTAgent.cpp.

{
    OTIdentifier theAgentNymID;
    bool bNymID = GetNymID(theAgentNymID);

    // Not all agents have Nyms. (Might be a voting group.)

    if (true == bNymID) {
        OTPseudonym* pToActualNym = nullptr;

        if ((nullptr != pActualNym) && pActualNym->CompareID(theAgentNymID))
            pToActualNym = pActualNym;

        return theSmartContract.DropFinalReceiptToNymbox(
            theAgentNymID, lNewTransactionNumber, strOrigCronItem, pstrNote,
            pstrAttachment, pToActualNym);
    }

    // TODO: When entites and roles are added, this function may change a bit to
    // accommodate them.

    return false;
}

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

Definition at line 842 of file OTAgent.cpp.

{
    OTIdentifier theAgentNymID;
    bool bNymID = GetNymID(theAgentNymID);

    // Not all agents have Nyms. (Might be a voting group.)

    if (true == bNymID) {
        OTPseudonym* pToActualNym = nullptr;

        if ((nullptr != pActualNym) && pActualNym->CompareID(theAgentNymID))
            pToActualNym = pActualNym;
        else if ((nullptr != m_pNym) && m_pNym->CompareID(theAgentNymID))
            pToActualNym = m_pNym;

        return OTAgreement::DropServerNoticeToNymbox(
            bSuccessMsg, theServerNym, theServerID, theAgentNymID,
            lNewTransactionNumber, lInReferenceTo, strReference, pstrNote,
            pstrAttachment, pToActualNym);
    }

    // TODO: When entites and roles are added, this function may change a bit to
    // accommodate them.

    return false;
}

int32_t opentxs::OTAgent::GetCountAuthorizedAccts

(

)

Definition at line 636 of file OTAgent.cpp.

{
    if (nullptr == m_pForParty) {
        otErr << "OTAgent::CountAuthorizedAccts: Error: m_pForParty was "
                 "nullptr.\n";
        return 0; // Maybe should log here...
    }

    return m_pForParty->GetAccountCount(m_strName.Get());
}

bool opentxs::OTAgent::GetEntityID

(

OTIdentifier &

theOutput

)

const

Definition at line 601 of file OTAgent.cpp.

{
    // IF represents an entity, then this is its ID. Else fail.
    //
    if (DoesRepresentAnEntity() && (nullptr != m_pForParty) &&
        m_pForParty->IsEntity()) {
        bool bSuccessEntityID = false;
        std::string str_entity_id = m_pForParty->GetEntityID(&bSuccessEntityID);

        if (bSuccessEntityID && (str_entity_id.size() > 0)) {
            OTString strEntityID(str_entity_id.c_str());
            theOutput.SetString(strEntityID);

            return true;
        }
    }

    return false;
}

bool opentxs::OTAgent::GetGroupName

(

OTString &

strGroupName

)

Definition at line 650 of file OTAgent.cpp.

{
    if (IsAGroup()) {
        strGroupName.Set(m_strGroupName);

        return true;
    }

    return false;
}

EXPORT const OTString& opentxs::OTAgent::GetName ( )

inline

Definition at line 388 of file OTAgent.hpp.

    {
        return m_strName;
    } // agent's name as used in a script.

bool opentxs::OTAgent::GetNymID

(

OTIdentifier &

theOutput

)

const

Definition at line 473 of file OTAgent.cpp.

{
    if (IsAnIndividual()) {
        theOutput.SetString(m_strNymID);

        return true;
    }

    return false;
}

OTParty* opentxs::OTAgent::GetParty ( ) const

inline

Definition at line 414 of file OTAgent.hpp.

    {
        return m_pForParty;
    }

bool opentxs::OTAgent::GetPartyID

(

OTIdentifier &

theOutput

)

const

Definition at line 663 of file OTAgent.cpp.

{
    if (DoesRepresentHimself()) return GetNymID(theOutput);

    return GetEntityID(theOutput);
}

bool opentxs::OTAgent::GetRoleID

(

OTIdentifier &

theOutput

)

const

Definition at line 488 of file OTAgent.cpp.

{
    if (IsAnIndividual() && DoesRepresentAnEntity()) {
        theOutput.SetString(m_strRoleID);

        return true;
    }

    return false;
}

bool opentxs::OTAgent::GetSignerID

(

OTIdentifier &

theOutput

)

const

Definition at line 514 of file OTAgent.cpp.

{
    // If IsIndividual() and DoesRepresentAnEntity() then this returns
    // GetRoleID().
    // else if Individual() and DoesRepresentHimself() then this returns
    // GetNymID().
    // else (if IsGroup()) then return false;

    if (IsAnIndividual()) {
        if (DoesRepresentAnEntity()) {
            return GetRoleID(theOutput);
        }
        else // DoesRepresentHimself()
        {
            return GetNymID(theOutput);
        }
    }

    // else IsGroup()... unable to sign directly; must hold votes instead.
    //
    return false;
}

bool opentxs::OTAgent::HarvestTransactionNumber	(	const int64_t &	lNumber,
		const OTString &	strServerID,
		bool	bSave = false,
		OTPseudonym *	pSignerNym = nullptr
	)

Definition at line 933 of file OTAgent.cpp.

{

    // Todo: this function may change when entities / roles are added.
    //
    if (!IsAnIndividual() || !DoesRepresentHimself()) {
        otErr << __FUNCTION__
              << ":  Error: Entities and Roles are not yet supported. Agent: "
              << m_strName << "\n";
        return false;
    }

    if (nullptr != m_pNym) {
        // If a signer wasn't passed in (the server-side uses server nym to
        // sign)
        // then we use the Nym himself as his own signer (common to
        // client-side.)
        //
        if (nullptr == pSignerNym) pSignerNym = m_pNym;

        const OTIdentifier theServerID(strServerID);

        // This won't "add it back" unless we're SURE he had it in the first
        // place...
        //
        const bool bSuccess = m_pNym->ClawbackTransactionNumber(
            theServerID, lNumber, bSave, pSignerNym);

        if (bSuccess) {
            // The transaction is being removed from play, so we will remove it
            // from this list.
            // That is, when we called RemoveTransactionNumber, the number was
            // being put into play
            // until RemoveIssuedNumber is called to close it out. But now
            // RemoveIssuedNumber won't
            // ever be called, since we are harvesting it back for future use.
            // Therefore the number
            // is currently no longer in play, therefore we remove it from the
            // list of open cron numbers.
            //
            std::set<int64_t>& theIDSet = m_pNym->GetSetOpenCronItems();
            auto theSetIT = theIDSet.find(lNumber);

            if (theIDSet.end() != theSetIT) // IF it was there, THEN remove it.
                                            // (Client doesn't even track these,
                                            // though server does.)
                theIDSet.erase(lNumber);

            return true;
        }
        else
            otErr << __FUNCTION__ << ": Number (" << lNumber
                  << ") failed to verify for agent: " << m_strName
                  << " (Thus didn't bother 'adding it back'.)\n";
    }
    else
        otErr << __FUNCTION__
              << ": Error: m_pNym was nullptr. For agent: " << m_strName
              << "\n";

    return false;
}

bool opentxs::OTAgent::IsAGroup

(

)

const

Definition at line 399 of file OTAgent.cpp.

{
    return !m_bIsAnIndividual;
}

bool opentxs::OTAgent::IsAnIndividual

(

)

const

Definition at line 390 of file OTAgent.cpp.

{
    return m_bIsAnIndividual;
}

bool opentxs::OTAgent::IsAuthorizingAgentForParty

(

)

Definition at line 623 of file OTAgent.cpp.

{
    if (nullptr == m_pForParty) return false;

    if (m_strName.Compare(m_pForParty->GetAuthorizingAgentName().c_str()))
        return true;

    return false;
}

bool opentxs::OTAgent::IsValidSigner

(

OTPseudonym &

theNym

)

Definition at line 553 of file OTAgent.cpp.

{
    OTIdentifier theAgentNymID;
    bool bNymID = GetNymID(theAgentNymID);

    // If there's a NymID on this agent, and it matches theNym's ID...
    //
    if (bNymID && theNym.CompareID(theAgentNymID)) {
        // That means theNym *is* the Nym for this agent!
        // We'll save his pointer, for future reference...
        //
        SetNymPointer(theNym);

        return true;
    }

    // TODO Entity: Perhaps the original Nym was fired from his role... another
    // Nym has now
    // taken his place. In which case, the original Nym should be refused as a
    // valid
    // signer, and the new Nym should be allowed to sign in his place!
    //
    // This means if DoesRepresentAnEntity(), then I have to load the Role, and
    // verify
    // the Nym against that Role (which contains the updated status). Since I
    // haven't
    // coded Entities/Roles yet, then I don't have to do this just yet...
    // Might even update the NymID on this agent, for updated copies of the
    // agreement.
    // (Obviously the original can't be changed...)
    //

    return false;
}

bool opentxs::OTAgent::IsValidSignerID

(

const OTIdentifier &

theNymID

)

Definition at line 537 of file OTAgent.cpp.

{
    OTIdentifier theAgentNymID;
    bool bNymID = GetNymID(theAgentNymID);

    // If there's a NymID on this agent, and it matches theNymID...
    //
    if (bNymID && (theNymID == theAgentNymID)) return true;

    // TODO Entities...
    //
    return false;
}

OTPseudonym * opentxs::OTAgent::LoadNym

(

OTPseudonym &

theServerNym

)

Definition at line 224 of file OTAgent.cpp.

{
    OTIdentifier theAgentNymID;
    bool bNymID = GetNymID(theAgentNymID);

    if (bNymID) {
        OTPseudonym* pNym = new OTPseudonym;
        OT_ASSERT(nullptr != pNym);

        pNym->SetIdentifier(theAgentNymID);

        if (!pNym->LoadPublicKey()) {
            OTString strNymID(theAgentNymID);
            otErr << "OTAgent::LoadNym: Failure loading "
                     "agent's public key:\n" << strNymID << "\n";
            delete pNym;
            pNym = nullptr;
        }
        else if (pNym->VerifyPseudonym() &&
                   pNym->LoadSignedNymfile(theServerNym)) {
            SetNymPointer(
                *pNym); // set this pointer in case I need it for later.
            // also remember, caller is responsible to delete, so there's no
            // guarantee the pointer
            return pNym; // is any good.  Then again, caller is also responsible
                         // to call ClearTemporaryPointers().
        }
        else {
            OTString strNymID(theAgentNymID);
            otErr << "OTAgent::LoadNym: Failure verifying agent's public key "
                     "or loading signed nymfile: " << strNymID << "\n";
            delete pNym;
            pNym = nullptr;
        }
    }
    else
        otErr << "OTAgent::LoadNym: Failure. Are you sure this agent IS a Nym "
                 "at all? \n";

    return nullptr;
}

bool opentxs::OTAgent::RemoveIssuedNumber	(	const int64_t &	lNumber,
		const OTString &	strServerID,
		bool	bSave = false,
		OTPseudonym *	pSignerNym = nullptr
	)

Definition at line 1051 of file OTAgent.cpp.

{
    // Todo: this function may change when entities / roles are added.
    if (!IsAnIndividual() || !DoesRepresentHimself()) {
        otErr << "OTAgent::" << __FUNCTION__
              << ":  Error: Entities and Roles are not yet supported. Agent: "
              << m_strName << "\n";
        return false;
    }

    if (nullptr != m_pNym) {
        std::set<int64_t>& theIDSet =
            m_pNym->GetSetOpenCronItems(); // The transaction is being removed
                                           // from play, so we will remove it
                                           // from this list.
        const bool bSuccess =
            m_pNym->RemoveIssuedNum(strServerID, lNumber); // Doesn't save.

        if (bSuccess) {
            if (nullptr == pSignerNym) pSignerNym = m_pNym;

            // Since the Trans# is now out of play, the server removes it as an
            // open cron item.
            //
            auto theSetIT = theIDSet.find(lNumber);

            if (theIDSet.end() != theSetIT) // IF it was there, THEN remove it.
                                            // (Client doesn't even track these,
                                            // though server does.)
                theIDSet.erase(lNumber);

            if (bSave) m_pNym->SaveSignedNymfile(*pSignerNym);
        }
        else
            otErr << "OTAgent::" << __FUNCTION__
                  << ": Error, should never happen. (I'd assume you aren't "
                     "removing issued numbers without verifying first if "
                     "they're there.)\n";
        return bSuccess;
    }
    else
        otErr << "OTAgent::" << __FUNCTION__
              << ": Error: m_pNym was nullptr. For agent: " << m_strName
              << "\n";

    return false;
}

bool opentxs::OTAgent::RemoveTransactionNumber	(	const int64_t &	lNumber,
		const OTString &	strServerID,
		OTPseudonym &	SIGNER_NYM,
		bool	bSave = true
	)

Definition at line 1006 of file OTAgent.cpp.

{
    // Todo: this function may change when entities / roles are added.
    if (!IsAnIndividual() || !DoesRepresentHimself()) {
        otErr << "OTAgent::" << __FUNCTION__
              << ":  Error: Entities and Roles are not yet supported. Agent: "
              << m_strName << "\n";
        return false;
    }

    if (nullptr != m_pNym) {
        std::set<int64_t>& theIDSet =
            m_pNym->GetSetOpenCronItems(); // The transaction is now in play, so
                                           // we are going to add it to this
                                           // list.
        const bool bSuccess =
            m_pNym->RemoveTransactionNum(strServerID, lNumber); // Doesn't save.

        if (bSuccess) {
            theIDSet.insert(lNumber); // Since the Trans# is now in play, the
                                      // server records it as an open cron item.

            if (bSave) m_pNym->SaveSignedNymfile(SIGNER_NYM);
        }
        else
            otErr << "OTAgent::" << __FUNCTION__
                  << ": Error, should never happen. (I'd assume you aren't "
                     "removing numbers without verifying first if they're "
                     "there.)\n";
        return bSuccess;
    }
    else
        otErr << "OTAgent::" << __FUNCTION__
              << ": Error: m_pNym was nullptr. For agent: " << m_strName
              << "\n";

    return false;
}

bool opentxs::OTAgent::ReserveClosingTransNum	(	const OTString &	strServerID,
		OTPartyAccount &	thePartyAcct
	)

Definition at line 1102 of file OTAgent.cpp.

{
    if (IsAnIndividual() && DoesRepresentHimself() && (nullptr != m_pNym)) {
        int64_t lTransactionNumber = 0;
        if (thePartyAcct.GetClosingTransNo() > 0) {
            otOut << "OTAgent::ReserveClosingTransNum: Failure: The account "
                     "ALREADY has a closing transaction number "
                     "set on it. Don't you want to save that first, before "
                     "overwriting it?\n";
            return false;
        }

        if (m_pNym->GetTransactionNumCount(strServerID) <
            1) // Need a closing number...
        {
            otOut << "OTAgent::ReserveClosingTransNum: *** Failure *** Nym "
                     "needs at least 1 transaction number available in order "
                     "to do this.\n";
            return false;
        }
        else if (false ==
                   m_pNym->GetNextTransactionNum(*m_pNym, strServerID,
                                                 lTransactionNumber)) {
            otErr << "OTAgent::ReserveClosingTransNum: Error: Strangely, "
                     "unable to get a transaction number, even though "
                     "supposedly one was there.\n";
            return false;
        }

        // BELOW THIS POINT, TRANSACTION # HAS BEEN RESERVED, AND MUST BE
        // SAVED...
        // Any errors below this point will require this call before returning:
        // HarvestAllTransactionNumbers(strServerID);
        //
        thePartyAcct.SetClosingTransNo(lTransactionNumber);
        thePartyAcct.SetAgentName(m_strName);

        return true;
    }
    else // todo: when entities and roles are added... this function will
           // change.
    {
        otErr << "OTAgent::ReserveClosingTransNum: Either the Nym pointer "
                 "isn't set properly, "
                 "or you tried to use Entities when they haven't been coded "
                 "yet. Agent: " << m_strName << " \n";
    }

    return false;
}

bool opentxs::OTAgent::ReserveOpeningTransNum

(

const OTString &

strServerID

)

Definition at line 1155 of file OTAgent.cpp.

{
    if (IsAnIndividual() && DoesRepresentHimself() && (nullptr != m_pNym)) {
        int64_t lTransactionNumber = 0;
        if (nullptr == m_pForParty) {
            otErr << "OTAgent::ReserveOpeningTransNum: Error: Party pointer "
                     "was nullptr.  SHOULD NEVER HAPPEN!!\n";
            return false;
        }
        if (m_pForParty->GetOpeningTransNo() > 0) {
            otOut << "OTAgent::ReserveOpeningTransNum: Failure: Party ALREADY "
                     "had an opening transaction number "
                     "set on it. Don't you want to save that first, before "
                     "overwriting it?\n";
            return false;
        }

        if (m_pNym->GetTransactionNumCount(strServerID) <
            1) // Need opening number...
        {
            otOut << "OTAgent::ReserveOpeningTransNum: *** Failure *** Nym "
                     "needs at least 1 transaction number available in order "
                     "to do this.\n";
            return false;
        }
        else if (false ==
                   m_pNym->GetNextTransactionNum(*m_pNym, strServerID,
                                                 lTransactionNumber)) {
            otErr << "OTAgent::ReserveOpeningTransNum: Error: Strangely, "
                     "unable to get a transaction number, even though "
                     "supposedly one was there.\n";
            return false;
        }

        // BELOW THIS POINT, TRANSACTION # HAS BEEN RESERVED, AND MUST BE
        // SAVED...
        // Any errors below this point will require this call before returning:
        // HarvestAllTransactionNumbers(strServerID);
        //
        m_pForParty->SetOpeningTransNo(lTransactionNumber);
        m_pForParty->SetAuthorizingAgentName(m_strName.Get());

        return true;
    }
    else // todo: when entities and roles are added... this function will
           // change.
    {
        otErr << "OTAgent::ReserveOpeningTransNum: Either the Nym pointer "
                 "isn't set properly, "
                 "or you tried to use Entities when they haven't been coded "
                 "yet. Agent: " << m_strName << " \n";
    }

    return false;
}

void opentxs::OTAgent::RetrieveNymPointer

(

mapOfNyms &

map_Nyms_Already_Loaded

)

Definition at line 670 of file OTAgent.cpp.

{
    const std::string str_agent_name(m_strName.Get());

    //  We actually have a Nym pointer on this agent somehow (so let's add it to
    // the list.)
    //
    if (nullptr != m_pNym) {
        if (!m_strName.Exists()) // Whoaa!! Can't add it without the agent's
                                 // name for the map!
        {
            otErr << "OTAgent::RetrieveNymPointers: Failed: m_strName is "
                     "empty!\n";
        }
        else if (map_Nyms_Already_Loaded.end() ==
                   map_Nyms_Already_Loaded.insert(
                       map_Nyms_Already_Loaded.begin(),
                       std::pair<std::string, OTPseudonym*>(str_agent_name,
                                                            m_pNym)))
            otErr << "OTAgent::RetrieveNymPointer: Failed on insertion, as "
                     "though another nym were already "
                     "there with the same agent name! (" << m_strName << ")\n";
        // (else it was inserted successfully.)
    }
    // else nothing, since it's normal that most of them are nullptr, even when
    // one
    // is goood.
}

void opentxs::OTAgent::Serialize

(

OTString &

strAppend

)

const

Definition at line 1211 of file OTAgent.cpp.

{
    //    strAppend.Concatenate("<agent>\n\n");

    strAppend.Concatenate(
        "<agent\n name=\"%s\"\n"
        " doesAgentRepresentHimself=\"%s\"\n"
        " isAgentAnIndividual=\"%s\"\n"
        " nymID=\"%s\"\n"
        " roleID=\"%s\"\n"
        " groupName=\"%s\" />\n\n",
        m_strName.Get(), m_bNymRepresentsSelf ? "true" : "false",
        m_bIsAnIndividual ? "true" : "false", m_strNymID.Get(),
        m_strRoleID.Get(), m_strGroupName.Get());

    //    strAppend.Concatenate("</agent>\n");
}

void opentxs::OTAgent::SetNymPointer ( OTPseudonym &  theNym )

inline

Definition at line 277 of file OTAgent.hpp.

    {
        m_pNym = &theNym;
    }

void opentxs::OTAgent::SetParty

(

OTParty &

theOwnerParty

)

Definition at line 314 of file OTAgent.cpp.

{
    m_pForParty = &theOwnerParty;

    // A Nym can only act as agent for himself or for an entity
    // (never for another Nym. Start an entity if you want that.)
    // If the owner party is a Nym, therefore this agent IS the Nym acting for
    // himself.
    // Whereas if the owner party were an entity, then this agent could be a Nym
    // or a voting group.
    // Since inside this block the owner party IS a Nym, not an entity, then the
    // agent can therefore
    // only be THAT Nym, acting as an agent for himself. Remember, a Nym cannot
    // act as agent for
    // another Nym. That is only possible by an agreement between them, and that
    // agreement becomes
    // the entity (therefore it's only possible using an entity.)
    //
    if (theOwnerParty.IsNym()) // Thus, this basically means the agent IS the
                               // party.
    {
        m_bNymRepresentsSelf = true;
        m_bIsAnIndividual = true;

        bool bGetOwnerNymID = false;
        const std::string str_owner_nym_id =
            theOwnerParty.GetNymID(&bGetOwnerNymID);
        m_strNymID.Set(bGetOwnerNymID ? str_owner_nym_id.c_str() : "");

        // Todo here, instead of copying the Owner's Nym ID like above, just
        // make sure they match.
        // Similarly, make sure that the RoleID or GroupName, whichever is
        // relevant, is validated for the owner.
    }
}

bool opentxs::OTAgent::SignContract

(

OTContract &

theInput

)

const

Definition at line 875 of file OTAgent.cpp.

{
    if (!IsAnIndividual() || !DoesRepresentHimself()) {
        otErr << "OTAgent::SignContract: Entities and roles are not yet "
                 "supported. Agent: " << m_strName << ".\n";
        return false;
    } // todo: when adding entities, this will change.

    if (nullptr == m_pNym) {
        otErr << "OTAgent::SignContract: Nym was nullptr while trying to sign "
                 "contract. Agent: " << m_strName << ".\n";
        return false;
    } // todo: when adding entities, this will change.

    return theInput.SignContract(*m_pNym);
}

bool opentxs::OTAgent::VerifyAgencyOfAccount

(

const OTAccount &

theAccount

)

const

Definition at line 699 of file OTAgent.cpp.

{
    OTIdentifier theSignerID;

    if (!GetSignerID(theSignerID)) {
        otErr << "OTAgent::VerifyAgencyOfAccount: ERROR: Entities and roles "
                 "haven't been coded yet.\n";
        return false;
    }

    return theAccount.VerifyOwnerByID(theSignerID); // todo when entities and
                                                    // roles come, won't this
                                                    // "just work", or do I also
                                                    // have to warn the acct
                                                    // whether it's a Nym or a
                                                    // Role being passed?
}

bool opentxs::OTAgent::VerifyIssuedNumber	(	const int64_t &	lNumber,
		const OTString &	strServerID
	)

Definition at line 892 of file OTAgent.cpp.

{
    // Todo: this function may change when entities / roles are added.
    if (!IsAnIndividual() || !DoesRepresentHimself()) {
        otErr << "OTAgent::VerifyIssuedNumber:  Error: Entities and Roles are "
                 "not yet supported. Agent: " << m_strName << "\n";
        return false;
    }

    if (nullptr != m_pNym)
        return m_pNym->VerifyIssuedNum(strServerID, lNumber);
    else
        otErr << "OTAgent::VerifyIssuedNumber: Error: m_pNym was nullptr. For "
                 "agent: " << m_strName << "\n";

    return false;
}

bool opentxs::OTAgent::VerifySignature

(

const OTContract &

theContract

)

const

Definition at line 159 of file OTAgent.cpp.

{
    // Only individual agents can sign for things, not groups (groups vote, they
    // don't sign.)
    // Thus, an individual can verify a signature, whereas a voting group would
    // verify an election result (or whatever.)
    //
    if (!IsAnIndividual() || !DoesRepresentHimself()) {
        otErr << "OTAgent::VerifySignature: Entities and roles are not yet "
                 "supported. Agent: " << m_strName << ".\n";
        return false;
    } // todo: when adding entities, this will change.

    //    if (DoesRepresentAnEntity)
    //    {
    //        // The original version of a smartcontract might show that Frank,
    // the Sales Director, signed it.
    //        // Years later, Frank is fired, and Jim is appointed to his former
    // Role of sales director, in the same entity.
    //        // The original copy of the smart contract still contains Frank's
    // signature, and thus we still need to load Frank
    //        // in order to verify that original signature.  That's why we load
    // Frank by the NymID stored there. He was the Nym
    //        // at the time, so that's the key we load.
    //        //
    //        // NEXT: What if JIM tries to verify the signature on the
    // contract, even though FRANK was the original signer?
    //        // Should OTAgent be smart enough here to substitute Frank
    // whenever Jim tries to verify? I argue no: this function is
    //        // too low-level. Plus it's backwards. If Jim tries to DO an
    // action, THEN OT should be smart enough to verify that Jim
    //        // is in the proper Role and that Jim's signature is good enough
    // to authorize actions. But if OT is verifying Frank's
    //        // signature on some old copy of something that Frank formerly
    // signed, then this function should clearly tell me if Frank's
    //        // sig verified... or not.
    //        //
    //        // Therefore the "DoesRepresentAnEntity()" option is useless here,
    // since we are verifying the same Nym's signature whether
    //        // he represents an entity or not.
    //        //
    //    }
    //    else
    if (nullptr == m_pNym) {
        OTString strTemp(theContract);
        otErr << "OTAgent::VerifySignature: Attempted to verify signature on "
                 "contract, "
                 "but no Nym had ever been loaded for this agent:\n\n"
              << strTemp << "\n\n";
        return false;
    }

    return theContract.VerifySignature(*m_pNym);
}

bool opentxs::OTAgent::VerifyTransactionNumber	(	const int64_t &	lNumber,
		const OTString &	strServerID
	)

Definition at line 911 of file OTAgent.cpp.

{
    // Todo: this function may change when entities / roles are added.
    if (!IsAnIndividual() || !DoesRepresentHimself()) {
        otErr << "OTAgent::VerifyTransactionNumber:  Error: Entities and Roles "
                 "are not yet supported. Agent: " << m_strName << "\n";
        return false;
    }

    if (nullptr != m_pNym)
        return m_pNym->VerifyTransactionNum(strServerID, lNumber);
    else
        otErr << "OTAgent::VerifyTransactionNumber: Error: m_pNym was nullptr. "
                 "For agent: " << m_strName << "\n";

    return false;
}

---

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

• /usr/local/src/opentxs/include/opentxs/core/script/OTAgent.hpp
• /usr/local/src/opentxs/src/core/script/OTAgent.cpp