opentxs::PayDividendVisitor Class Reference

#include <PayDividendVisitor.hpp>

Inheritance diagram for opentxs::PayDividendVisitor:

Collaboration diagram for opentxs::PayDividendVisitor:

Public Member Functions
	PayDividendVisitor (const OTIdentifier &theServerID, const OTIdentifier &theUserID, const OTIdentifier &thePayoutAssetID, const OTIdentifier &theVoucherAcctID, const OTString &strMemo, OTServer &theServer, int64_t lPayoutPerShare, mapOfAccounts *pLoadedAccounts=nullptr)
virtual	~PayDividendVisitor ()
OTIdentifier *	GetUserID ()
OTIdentifier *	GetPayoutAssetID ()
OTIdentifier *	GetVoucherAcctID ()
OTString *	GetMemo ()
OTServer *	GetServer ()
int64_t	GetPayoutPerShare ()
int64_t	GetAmountPaidOut ()
int64_t	GetAmountReturned ()
virtual bool	Trigger (OTAccount &theAccount)
Public Member Functions inherited from opentxs::AccountVisitor
EXPORT	AccountVisitor (const OTIdentifier &serverId, mapOfAccounts *loadedAccounts=nullptr)
virtual EXPORT	~AccountVisitor ()
EXPORT OTIdentifier *	GetServerID ()
EXPORT mapOfAccounts *	GetLoadedAccts ()

Additional Inherited Members
Protected Attributes inherited from opentxs::AccountVisitor
OTIdentifier	serverId_
mapOfAccounts *	loadedAccounts_

Detailed Description

Definition at line 157 of file PayDividendVisitor.hpp.

Constructor & Destructor Documentation

opentxs::PayDividendVisitor::PayDividendVisitor	(	const OTIdentifier &	theServerID,
		const OTIdentifier &	theUserID,
		const OTIdentifier &	thePayoutAssetID,
		const OTIdentifier &	theVoucherAcctID,
		const OTString &	strMemo,
		OTServer &	theServer,
		int64_t	lPayoutPerShare,
		mapOfAccounts *	pLoadedAccounts = nullptr
	)

Definition at line 145 of file PayDividendVisitor.cpp.

    : AccountVisitor(theServerID, pLoadedAccounts)
    , m_pUserID(new OTIdentifier(theUserID))
    , m_pPayoutAssetID(new OTIdentifier(thePayoutAssetID))
    , m_pVoucherAcctID(new OTIdentifier(theVoucherAcctID))
    , m_pstrMemo(new OTString(strMemo))
    , m_pServer(&theServer)
    , m_lPayoutPerShare(lPayoutPerShare)
    , m_lAmountPaidOut(0)
    , m_lAmountReturned(0)
{
}

opentxs::PayDividendVisitor::~PayDividendVisitor ( )

virtual

Definition at line 162 of file PayDividendVisitor.cpp.

{
    if (nullptr != m_pUserID) delete m_pUserID;
    m_pUserID = nullptr;
    if (nullptr != m_pPayoutAssetID) delete m_pPayoutAssetID;
    m_pPayoutAssetID = nullptr;
    if (nullptr != m_pVoucherAcctID) delete m_pVoucherAcctID;
    m_pVoucherAcctID = nullptr;
    if (nullptr != m_pstrMemo) delete m_pstrMemo;
    m_pstrMemo = nullptr;
    m_pServer = nullptr; // don't delete this one (I don't own it.)
    m_lPayoutPerShare = 0;
    m_lAmountPaidOut = 0;
    m_lAmountReturned = 0;
}

Member Function Documentation

int64_t opentxs::PayDividendVisitor::GetAmountPaidOut ( )

inline

Definition at line 206 of file PayDividendVisitor.hpp.

    {
        return m_lAmountPaidOut;
    }

int64_t opentxs::PayDividendVisitor::GetAmountReturned ( )

inline

Definition at line 210 of file PayDividendVisitor.hpp.

    {
        return m_lAmountReturned;
    }

OTString* opentxs::PayDividendVisitor::GetMemo ( )

inline

Definition at line 194 of file PayDividendVisitor.hpp.

    {
        return m_pstrMemo;
    }

OTIdentifier* opentxs::PayDividendVisitor::GetPayoutAssetID ( )

inline

Definition at line 186 of file PayDividendVisitor.hpp.

    {
        return m_pPayoutAssetID;
    }

int64_t opentxs::PayDividendVisitor::GetPayoutPerShare ( )

inline

Definition at line 202 of file PayDividendVisitor.hpp.

    {
        return m_lPayoutPerShare;
    }

OTServer* opentxs::PayDividendVisitor::GetServer ( )

inline

Definition at line 198 of file PayDividendVisitor.hpp.

    {
        return m_pServer;
    }

OTIdentifier* opentxs::PayDividendVisitor::GetUserID ( )

inline

Definition at line 182 of file PayDividendVisitor.hpp.

    {
        return m_pUserID;
    }

OTIdentifier* opentxs::PayDividendVisitor::GetVoucherAcctID ( )

inline

Definition at line 190 of file PayDividendVisitor.hpp.

    {
        return m_pVoucherAcctID;
    }

bool opentxs::PayDividendVisitor::Trigger ( OTAccount &  theAccount )

virtual

Implements opentxs::AccountVisitor.

Definition at line 184 of file PayDividendVisitor.cpp.

{
    const int64_t lPayoutAmount =
        (theSharesAccount.GetBalance() * GetPayoutPerShare());

    if (lPayoutAmount <= 0) {
        OTLog::Output(0, "PayDividendVisitor::Trigger: nothing to pay, "
                         "since this account owns no shares. (Returning "
                         "true.)");
        return true; // nothing to pay, since this account owns no shares.
                     // Success!
    }
    OT_ASSERT(nullptr != GetServerID());
    const OTIdentifier& theServerID = *(GetServerID());
    OT_ASSERT(nullptr != GetPayoutAssetID());
    const OTIdentifier& thePayoutAssetID = *(GetPayoutAssetID());
    OT_ASSERT(nullptr != GetVoucherAcctID());
    const OTIdentifier& theVoucherAcctID = *(GetVoucherAcctID());
    OT_ASSERT(nullptr != GetServer());
    OTServer& theServer = *(GetServer());
    OTPseudonym& theServerNym =
        const_cast<OTPseudonym&>(theServer.GetServerNym());
    const OTIdentifier theServerNymID(theServerNym);
    const OTIdentifier& RECIPIENT_ID = theSharesAccount.GetUserID();
    OT_ASSERT(nullptr != GetUserID());
    const OTIdentifier& theSenderUserID = *(GetUserID());
    OT_ASSERT(nullptr != GetMemo());
    const OTString& strMemo = *(GetMemo());
    // Note: theSenderUserID is the originator of the Dividend Payout.
    // However, all the actual vouchers will be from "the server Nym" and
    // not from theSenderUserID. So then why is it even here? Because anytime
    // there's an error, the server will send to theSenderUserID instead of
    // RECIPIENT_ID (so the original sender can have his money back, instead of
    // just having it get lost in the ether.)
    bool bReturnValue = false;

    OTCheque theVoucher(theServerID, thePayoutAssetID);

    // 10 minutes ==    600 Seconds
    // 1 hour    ==     3600 Seconds
    // 1 day    ==    86400 Seconds
    // 30 days    ==  2592000 Seconds
    // 3 months ==  7776000 Seconds
    // 6 months == 15552000 Seconds

    const time64_t VALID_FROM =
        OTTimeGetCurrentTime(); // This time is set to TODAY NOW
    const time64_t VALID_TO = OTTimeAddTimeInterval(
        VALID_FROM, OTTimeGetSecondsFromTime(
                        OT_TIME_SIX_MONTHS_IN_SECONDS)); // This time occurs in
                                                         // 180 days (6 months).
                                                         // Todo hardcoding.

    int64_t lNewTransactionNumber = 0;

    bool bGotNextTransNum = theServer.transactor_.issueNextTransactionNumber(
        theServerNym, lNewTransactionNumber); // bStoreTheNumber defaults to
                                              // true. We save the transaction
    // number on the server Nym (normally we'd discard it) because
    // when the cheque is deposited, the server nym, as the owner of
    // the voucher account, needs to verify the transaction # on the
    // cheque (to prevent double-spending of cheques.)
    if (bGotNextTransNum) {
        const bool bIssueVoucher = theVoucher.IssueCheque(
            lPayoutAmount,         // The amount of the cheque.
            lNewTransactionNumber, // Requiring a transaction number prevents
                                   // double-spending of cheques.
            VALID_FROM, // The expiration date (valid from/to dates) of the
                        // cheque
            VALID_TO, // Vouchers are automatically starting today and lasting 6
                      // months.
            theVoucherAcctID, // The asset account the cheque is drawn on.
            theServerNymID,   // User ID of the sender (in this case the server
                              // nym.)
            strMemo, // Optional memo field. Includes item note and request
                     // memo.
            &RECIPIENT_ID);

        // All account crediting / debiting happens in the caller, in OTServer.
        //    (AND it happens only ONCE, to cover ALL vouchers.)
        // Then in here, the voucher either gets send to the recipient, or if
        // error, sent back home to
        // the issuer Nym. (ALL the funds are removed, then the vouchers are
        // sent one way or the other.)
        // Any returned vouchers, obviously serve to notify the dividend payer
        // of where the errors were
        // (as well as give him the opportunity to get his money back.)
        //
        bool bSent = false;
        if (bIssueVoucher) {
            // All this does is set the voucher's internal contract string to
            // "VOUCHER" instead of "CHEQUE". We also set the server itself as
            // the remitter, which is unusual for vouchers, but necessary in the
            // case of dividends.
            //
            theVoucher.SetAsVoucher(theServerNymID, theVoucherAcctID);
            theVoucher.SignContract(theServerNym);
            theVoucher.SaveContract();

            // Send the voucher to the payments inbox of the recipient.
            //
            const OTString strVoucher(theVoucher);
            OTPayment thePayment(strVoucher);

            // calls DropMessageToNymbox
            bSent = theServer.SendInstrumentToNym(
                theServerID, theServerNymID,          // sender nym
                RECIPIENT_ID,                         // recipient nym
                nullptr, &thePayment, "payDividend"); // todo: hardcoding.
            bReturnValue = bSent;                     // <======= RETURN VALUE.
            if (bSent)
                m_lAmountPaidOut +=
                    lPayoutAmount; // At the end of iterating all accounts, if
                                   // m_lAmountPaidOut is less than
                                   // lTotalPayoutAmount, then we return to rest
                                   // to the sender.
        }
        else {
            const OTString strPayoutAssetID(thePayoutAssetID),
                strRecipientUserID(RECIPIENT_ID);
            OTLog::vError("PayDividendVisitor::Trigger: ERROR failed "
                          "issuing voucher (to send to dividend payout "
                          "recipient.) "
                          "WAS TRYING TO PAY %ld of asset type %s to Nym %s.\n",
                          lPayoutAmount, strPayoutAssetID.Get(),
                          strRecipientUserID.Get());
        }
        // If we didn't send it, then we need to return the funds to where they
        // came from.
        //
        if (!bSent) {
            OTCheque theReturnVoucher(theServerID, thePayoutAssetID);

            const bool bIssueReturnVoucher = theReturnVoucher.IssueCheque(
                lPayoutAmount,         // The amount of the cheque.
                lNewTransactionNumber, // Requiring a transaction number
                                       // prevents double-spending of cheques.
                VALID_FROM, // The expiration date (valid from/to dates) of the
                            // cheque
                VALID_TO,   // Vouchers are automatically starting today and
                            // lasting 6 months.
                theVoucherAcctID, // The asset account the cheque is drawn on.
                theServerNymID,   // User ID of the sender (in this case the
                                  // server nym.)
                strMemo, // Optional memo field. Includes item note and request
                         // memo.
                &theSenderUserID); // We're returning the money to its original
                                   // sender.
            if (bIssueReturnVoucher) {
                // All this does is set the voucher's internal contract string
                // to
                // "VOUCHER" instead of "CHEQUE".
                //
                theReturnVoucher.SetAsVoucher(theServerNymID, theVoucherAcctID);
                theReturnVoucher.SignContract(theServerNym);
                theReturnVoucher.SaveContract();

                // Return the voucher back to the payments inbox of the original
                // sender.
                //
                const OTString strReturnVoucher(theReturnVoucher);
                OTPayment theReturnPayment(strReturnVoucher);

                // calls DropMessageToNymbox
                bSent = theServer.SendInstrumentToNym(
                    theServerID, theServerNymID, // sender nym
                    theSenderUserID, // recipient nym (original sender.)
                    nullptr, &theReturnPayment,
                    "payDividend"); // todo: hardcoding.
                if (bSent)
                    m_lAmountReturned +=
                        lPayoutAmount; // At the end of iterating all accounts,
                                       // if m_lAmountPaidOut+m_lAmountReturned
                                       // is less than lTotalPayoutAmount, then
                                       // we return the rest to the sender.
            }
            else {
                const OTString strPayoutAssetID(thePayoutAssetID),
                    strSenderUserID(theSenderUserID);
                OTLog::vError("PayDividendVisitor::Trigger: ERROR "
                              "failed issuing voucher (to return back to "
                              "the dividend payout initiator, after a failed "
                              "payment attempt to the originally intended "
                              "recipient.) WAS TRYING TO PAY %ld of asset type "
                              "%s to Nym %s.\n",
                              lPayoutAmount, strPayoutAssetID.Get(),
                              strSenderUserID.Get());
            }
        }  // if !bSent
    }
    else // !bGotNextTransNum
    {
        const OTString strPayoutAssetID(thePayoutAssetID),
            strRecipientUserID(RECIPIENT_ID);
        OTLog::vError(
            "PayDividendVisitor::Trigger: ERROR!! Failed issuing next "
            "transaction "
            "number while trying to send a voucher (while paying dividends.) "
            "WAS TRYING TO PAY %ld of asset type %s to Nym %s.\n",
            lPayoutAmount, strPayoutAssetID.Get(), strRecipientUserID.Get());
    }

    return bReturnValue;
}

---

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

• /usr/local/src/opentxs/include/opentxs/server/PayDividendVisitor.hpp
• /usr/local/src/opentxs/src/server/PayDividendVisitor.cpp