lltrustnet.cpp

Go to the documentation of this file.

#include "llviewerprecompiledheaders.h"
#include "lltrustnet.h"
#include "llcachename.h"

#include <iostream>

LLTrustNet *gTrustNet = NULL;

const LLString DELIMITER = "|";


LLString LLTrustNetScoreRequest::asString()
{
        llinfos << "Requesting id " << mID << "; name " << mName << "; type " << mType << llendl;
        return "GetScore|" + mName + "|" +  mID.asString() + "|" + mType;
}

LLString LLTrustNetRateRequest::asString()
{
        std::ostringstream o; 
        o << mScore;

        llinfos << "Sending score for id " << mID << "; name " << mName << "; type " << mType << llendl;
        
        return "Rate|" + mName + "|" +  mID.asString() + "|" + mType + "|" + o.str() + "|" + mComment;
}

LLTrustNetScore::LLTrustNetScore(F32 score, LLString comments)
{
        mOperation = TN_GET_SCORE;
        mScore = score;

        set(score,comments);

        if ( mScore != 0.0f )
        {
                setState(TNS_RETRIEVED);
        }
        else
        {
                setState(TNS_UNKNOWN);
        }
}

void LLTrustNetDatum::addCallback(trustnet_callback_t callback, void *user_data)
{
        LLTrustNetCallbackEntry ent(callback, user_data);
        mCallbacks.push( ent );
}

void LLTrustNetDatum::notify(ETrustNetResult result)
{
        LLUUID id = LLUUID::null;

        // If there's a parent we get the ID from it. There may not be one, such
        // as for data not associated with any particular avatar, such as log
        // entries and statistics.
        if ( mParent )
        {
                id = mParent->getAvatar();
        }

        while( ! mCallbacks.empty() )
        {
                LLTrustNetCallbackEntry *ent = &mCallbacks.front();
                ent->callback(mOperation, result, id, ent->user_data);

                mCallbacks.pop();
        }
}

static std::vector<LLString> tokenize(LLString text, U32 max_tokens = 0)
{
        U32 count = 0;

        std::vector<LLString> tokens;

        LLString::size_type last_pos = text.find_first_not_of(DELIMITER, 0);
        LLString::size_type pos      = text.find_first_of(DELIMITER, last_pos);

        while(LLString::npos != pos && LLString::npos != last_pos && !(max_tokens > 0 && count >= max_tokens))
        {
                llinfos << "token: " << text.substr(last_pos, pos - last_pos) << llendl;
                tokens.push_back(text.substr(last_pos, pos - last_pos));

                last_pos = text.find_first_not_of(DELIMITER, pos);
                pos      = text.find_first_of(DELIMITER, last_pos);

                count++;
        }

        if (LLString::npos != last_pos)
        {
                // We stopped due to max token count, but there's still more data
                // add it all as the last token
                llinfos << "extra token: " << text.substr(last_pos) << llendl;
                tokens.push_back(text.substr(last_pos));
        }
        lldebugs << "Got " << count << " tokens" << llendl;

        return tokens;
}

//static 
void LLTrustNet::viewerCommCallback(LLString& data, LLViewerCircuit& circuit, void* userdata)
{
        llinfos << "I got: " << data << llendl;
        std::vector<LLString> tokens = tokenize(data);

        if (tokens.size() < 1) return;

        gTrustNet->mCircuit = &circuit;

        if ( tokens[0] == "Init" )
        {
                gTrustNet->mConnectionState = TRUSTNET_NO_CONNECTION;
        }
        else if ( tokens[0] == "LoginInProgress" )
        {
                gTrustNet->mConnectionState = TRUSTNET_LOGGING_IN;
        }
        else if ( tokens[0] == "AdapterRunning" )
        {
                gTrustNet->mConnectionState = TRUSTNET_CONNECTED;       
        }
        else if ( tokens[0] == "Score" && tokens.size() >= 4 )
        {
                LLUUID avatar(tokens[1]);
                LLString type = tokens[2];
                F32 score = 0.0;

                std::istringstream i(tokens[3]);
                i >> score;

                gTrustNet->setScore(avatar, type, score);
        }
        else
        {
                llwarns << "Unknown command " << tokens[0] << llendl;
        }
}

LLTrustNet::LLTrustNet()
{
        mCircuit = NULL;
        mConnectionState = TRUSTNET_NO_ADAPTER;

        // Register callback
        gViewerCommunication->registerExtension(
                LLViewerExtension("DaleGlass.TrustNet", 1, viewerCommCallback, NULL,
                "Dale Glass", "TrustNet Reputation System") );
}

LLTrustNetScore LLTrustNet::getScoreData(const LLUUID& avatar, const LLString& type)
{

        // First check whether we already have it. If these map elements
        // don't exist, they'll be automatically created. The constructor
        // ensures they'll be created in an empty state that we use as
        // a placeholder for when it arrives.
        mCache[avatar].setAvatar(avatar);
        LLTrustNetScore score = mCache[avatar].mScores[type];
        mCache[avatar].mScores[type].setParent(&mCache[avatar]);



        ETrustNetDatumState st = score.getState();

        if ( st != TNS_RETRIEVED && st != TNS_FETCHING )
        {
                LLString name;
                char first[DB_FIRST_NAME_BUF_SIZE];
                char last[DB_LAST_NAME_BUF_SIZE];
        
                if ( gCacheName->getName(avatar, first, last) )
                {
                        name = first;
                        name += " ";
                        name += last;

                        //score.mState = SCORE_FETCHING;
                        mCache[avatar].mScores[type].setState(TNS_FETCHING);

                        LLTrustNetScoreRequest *req = new LLTrustNetScoreRequest(avatar, name, type);
                        mQueue.push_back(req);

                        //avdata.mScores[type] = score;
                }

        }

        return score;
}

F32 LLTrustNet::getScore(const LLUUID& avatar, const LLString& type)
{
        if ( NULL == mCircuit )
        {
                llwarns << "Circuit not yet established" << llendl;
                return 0.0f;
        }

        LLTrustNetScore score = getScoreData(avatar, type);
        return score.mScore;
}

ETrustNetDatumState LLTrustNet::getScoreState(const LLUUID& avatar, const LLString& type)
{
        if ( NULL == mCircuit )
        {
                llwarns << "Circuit not yet established" << llendl;
                return TNS_UNKNOWN;
        }

        LLTrustNetScore score = getScoreData(avatar, type);
        return score.getState();
}


void LLTrustNet::setScore(const LLUUID& avatar, const LLString& type, F32 newscore)
{

        mCache[avatar].mScores[type].set(newscore,"");
        //mCache[avatar].mScores[type].mState = SCORE_RETRIEVED;

}

LLColor4 LLTrustNet::getScoreColor(const LLUUID& avatar,const LLString& type)
{
        F32 score = getScore(avatar, type);
        LLColor4 color;
        
        if ( score == 0.0f )
        {
                // Neutral
                color = LLColor4::grey;
        }
        else if ( score > 0.0f )
        {
                if ( score > 10.0f )
                {
                        // Self
                        color = LLColor4(0.0f, 1.0f, 1.0f);
                }
                else
                {
                        // Friend
                        color = LLColor4(0.0f, score / 10, 0.0f);
                }
        }
        else
        {
                // Enemy
                color = LLColor4(score / 10, 0.0f, 0.0f);
        }

        return color;
}

LLString LLTrustNet::getConnectionStateString() const
{
        switch( mConnectionState )
        {
                case TRUSTNET_NO_ADAPTER: return "Adapter not being worn";
                case TRUSTNET_NO_CONNECTION: return "No connection";
                case TRUSTNET_CONNECTING: return "Connecting...";
                case TRUSTNET_LOGGING_IN: return "Logging in...";
                case TRUSTNET_LOGIN_ERROR: return "Login error";
                case TRUSTNET_CONNECTED: return "Connected";
        }

        return "<BUG>";
}

void LLTrustNet::processRequests()
{
        //if ( mQueue.empty() ) return;

        while(!mQueue.empty())
        {
                LLTrustNetRequest *req = mQueue.front();
                LLString reqtext = req->asString();
                if ( reqtext.empty() )
                {
                        llwarns << "BUG!" << llendl;
                }
                else
                {
                        llinfos << "Requesting: " << reqtext << llendl;
                        mCircuit->sendReply( reqtext );
                }
                mQueue.pop_front();
                delete req;
        }
}

---