ClientRegister.cpp

Go to the documentation of this file.

#include "ClientRegister.h"
namespace SraNetwork {

    ClientRegister* SraNetwork::ClientRegister::instance = new ClientRegister();

#pragma region Constructor/Destructor
    ClientRegister::ClientRegister(void)
    {
        //Initalize db connection
        // factory("localhost:3306", "root", "SRA_Dev", "sra_dev");
        //static SraData::DbConnectionFactory factory("localhost", "root", "SRA_Dev", "sra_dev");
        SraData::DbConnectionFactory factory( "tcp://127.0.0.1:3306", "root", "SRA_Dev", "sra_dev");
        sql::Connection* connection = SraData::DbConnectionFactory::GetSingleton().getConnection();
        nextID = 42;
    }

    ClientRegister::~ClientRegister(void)
    {
    }
#pragma endregion

#pragma region Singleton Instance Getter
    ClientRegister* ClientRegister::getInstance()
    {
        return instance;
    }
#pragma endregion

#pragma region Add/Remove Client
    void ClientRegister::addClient( SystemAddress address, SraClientData client) 
    {
        SystemAddress s = address;
        tbb::concurrent_hash_map<SystemAddress, SraClientData, SystemAddressCompare>::accessor acc;
        clientAddressRegister.insert(acc,s);
        acc->second = client;
    }

    void  ClientRegister::removeClient(const SystemAddress address)
    {
        tbb::concurrent_hash_map<SystemAddress, SraClientData, SystemAddressCompare>::accessor acc;
        if (clientAddressRegister.find(acc, address) ) {
            clientAddressRegister.erase(acc);
        }
    }

    void  ClientRegister::removeClient( const SraClientData* data)
    {
        const SystemAddress* addr = getAddressFromClient(data);
        if (addr != NULL) 
        {
            removeClient(*addr);
        }
    }
#pragma endregion

#pragma region Client<->Address 
    const SystemAddress* ClientRegister::getAddressFromClientID( const int clientID)
    {
        tbb::concurrent_hash_map<SystemAddress, SraClientData, SystemAddressCompare>::const_iterator it;
        for (  it = clientAddressRegister.begin(); it != clientAddressRegister.end(); ++it)
        {
            if ( it->second.clientID == clientID ) 
            {
                return &it->first;
            }
        }
        return NULL;
    }
    const SraClientData* ClientRegister::getClientFromAddress( SystemAddress address)
    {
        tbb::concurrent_hash_map<SystemAddress, SraClientData, SystemAddressCompare>::const_accessor acc;
        clientAddressRegister.find(acc,address);
        return acc.empty() ? NULL : &(acc->second);
    }

    const SystemAddress*  ClientRegister::getAddressFromClient( const SraClientData* client)
    {
        tbb::concurrent_hash_map<SystemAddress, SraClientData, SystemAddressCompare>::const_iterator it;
        for (  it = clientAddressRegister.begin(); it != clientAddressRegister.end(); ++it)
        {
            if ( it->second == *client ) 
            {
                return &it->first;
            }
        }
        return NULL;
    }
#pragma endregion

    
    int ClientRegister::loginClient( const string& username, const string& password, SystemAddress address)
    {
        // Create db factory ... until its fixed
        SraData::DbConnectionFactory factory( "tcp://127.0.0.1:3306", "root", "SRA_Dev", "sra_dev");

        int pID = -1;

        // Call database
        SraData::DbProcedures::createPlayer(username, password, &pID);
        
        // If we have found a player, process it and return the player ID
        if ( pID != -1 ) {
            //Create the struct
            SraClientData client = {0};
            client.clientID = pID;
            //client.lastKeepAlive = keepAlive.sec;
            //Read the current zone, we can only have one zone, so ignore the query id.
            int queryID;
            SraData::DbProcedures::getPcZone( pID, &client.zoneID, &queryID);

            addClient( address, client);
        }
        return pID;
    }

    int ClientRegister::createCharacterForPlayer(int raceId, SystemAddress address, int clientID )
    {
        if ( clientID == -1 )
        {
            return -1;
        }

        //int raceID = _wtoi(data);
        //if ( raceID == 0 )
        //{
        //  return;
        //}
        // Call database
        int charID, playID;
        
        // Create db factory ... until its fixed
        SraData::DbConnectionFactory factory( "tcp://127.0.0.1:3306", "root", "SRA_Dev", "sra_dev");
        SraData::DbProcedures::createPlayerCharacter( raceId, clientID, &playID, &charID);
        return charID;
    }

    void ClientRegister::getPlayersForClient( const int clientID, const int* outPlayerIDs)
    {
        //TODO: query DB for players
        //int playerIndex = 0;

    }

    
    bool ClientRegister::checkForValidCharacterInfo( const BasicCharacterInfo* info, RakString* resultMessage)
    {
        // Create db factory ... until its fixed
        //SraData::DbConnectionFactory factory( "tcp://127.0.0.1:3306", "root", "SRA_Dev", "sra_dev");
        //TODO: Add some checks to the DB 
        if (info->charName.IsEmpty())
        {
            *resultMessage = "Can not create a character without a name!";
            return false;
        } else if (info->raceId < 0)
        {
            *resultMessage = "Invalid race, please try again";
            return false;
        }
        return true;
    }
}