PlanetDB Class Reference

#include "PlanetDB.h"

Public Member Functions
PyRep *	GetPlanetsForChar (uint32 charID)
PyRep *	GetMyLaunchesDetails (uint32 charID)
void	GetPlanetData (DBQueryResult &res)
void	GetSchematicData (DBQueryResult &res)
void	GetSchematicTimes (DBQueryResult &res)
void	UpdatePins (uint32 pinID, PI_CCPin *ccPin)
void	UpdateECUPin (uint32 pinID, PI_CCPin *ccPin)
void	SavePins (PI_CCPin *ccPin)
void	SaveHeads (uint32 ccPinID, uint32 ownerID, uint32 ecuID, std::map< uint16, PI_Heads > &heads)
void	SaveLinks (PI_CCPin *ccPin)
void	SaveRoutes (PI_CCPin *ccPin)
void	SaveContents (PI_CCPin *ccPin)
void	SavePinContents (uint32 ccPinID, uint32 pinID, std::map< uint16, uint32 > &contents)
void	RemovePin (uint32 pinID)
void	RemoveHead (uint32 ecuID, uint32 headID)
void	RemoveLink (uint32 linkID)
void	RemoveRoute (uint16 routeID)
void	RemoveContents (uint32 pinID)
void	DeleteColony (uint32 ccPinID, uint32 planetID, uint32 charID)
void	LoadPins (uint32 ccPinID, std::map< uint32, PI_Pin > &pins)
void	LoadHeads (uint32 ecuID, std::map< uint16, PI_Heads > &heads)
void	LoadLinks (uint32 ccPinID, std::map< uint32, PI_Link > &links)
void	LoadRoutes (uint32 ccPinID, std::map< uint16, PI_Route > &routes)
void	LoadContents (uint32 pinID, std::map< uint16, uint32 > &contents)
void	SaveCCLevel (uint32 pinID, uint8 level)
void	SavePinLevel (uint32 pinID, uint8 level)
void	SaveLinkLevel (uint32 linkID, uint8 level)
void	SaveCommandCenter (uint32 pinID, uint32 charID, uint32 planetID, uint32 typeID, double latitude, double longitude)
void	SaveLaunch (uint32 contID, uint32 charID, uint32 systemID, uint32 planetID, GPoint &pos)
void	UpdatePinTimes (PI_CCPin *ccPin)
void	AddPlanetForChar (uint32 solarSystemID, uint32 planetID, uint32 charID, uint32 ccPinID, uint16 typeID)
void	UpdatePlanetPins (uint32 ccPinID, uint8 pins=1)
bool	LoadColony (uint32 charID, uint32 planetID, PI_CCPin *ccPin)
uint16	SaveRoute (uint32 ccPinID, PI_Route &route)

Static Public Member Functions
static void	GetLaunchDetails (Launch::Data &data)
static GPoint	GetLaunchPos (uint32 launchID)
static uint32	GetLaunchItemID (uint32 launchID)
static uint32	GetLaunchPlanet (uint32 launchID)
static void	UpdateLaunchStatus (uint32 itemID, uint8 status)
static void	GetExtractorsForPlanet (uint32 planetID, DBQueryResult &res)
static void	DeleteLaunch (uint32 contID)

Detailed Description

Definition at line 36 of file PlanetDB.h.

Member Function Documentation

void PlanetDB::AddPlanetForChar	(	uint32	solarSystemID,
		uint32	planetID,
		uint32	charID,
		uint32	ccPinID,
		uint16	typeID
	)

Definition at line 90 of file PlanetDB.cpp.

References _log, DBerror::GetError(), and sDatabase.

Referenced by Colony::CreateCommandPin().

{
    DBerror err;
    if(!sDatabase.RunQuery(err,
        "INSERT INTO piPlanets (solarSystemID, planetID, charID, typeID, ccPinID)"
        " VALUES (%u, %u, %u, %u, %u)", solarSystemID, planetID, charID, typeID, ccPinID))
    {
        _log(DATABASE__ERROR, "AddPlanetForChar - Unable to add planet %u for char %u: %s", planetID, charID, err.GetError());
    }

}

Here is the call graph for this function:

Here is the caller graph for this function:

void PlanetDB::DeleteColony	(	uint32	ccPinID,
		uint32	planetID,
		uint32	charID
	)

Todo:

remove items from entity* table...

Definition at line 831 of file PlanetDB.cpp.

References sDatabase.

Referenced by Colony::AbandonColony().

{
    DBerror err;
    sDatabase.RunQuery(err, "DELETE FROM entity WHERE locationID = %u AND ownerID = %u", planetID, charID);
    sDatabase.RunQuery(err, "DELETE FROM piCCPin WHERE pinID = %u", ccPinID);
    sDatabase.RunQuery(err, "DELETE FROM piPins WHERE ccPinID = %u", ccPinID);
    sDatabase.RunQuery(err, "DELETE FROM piLinks WHERE ccPinID = %u", ccPinID);
    sDatabase.RunQuery(err, "DELETE FROM piRoutes WHERE ccPinID = %u", ccPinID);
    sDatabase.RunQuery(err, "DELETE FROM piPlanets WHERE ccPinID = %u", ccPinID);
    sDatabase.RunQuery(err, "DELETE FROM piECUHeads WHERE ccPinID = %u", ccPinID);
    sDatabase.RunQuery(err, "DELETE FROM piPinContents WHERE ccPinID = %u", ccPinID);
}

Here is the caller graph for this function:

void PlanetDB::DeleteLaunch ( uint32  contID )

static

Definition at line 825 of file PlanetDB.cpp.

References sDatabase.

Referenced by CargoContainer::Delete().

{
    DBerror err;
    sDatabase.RunQuery(err, "DELETE FROM piLaunches WHERE itemID = %u", contID);
}

Here is the caller graph for this function:

void PlanetDB::GetExtractorsForPlanet ( uint32  planetID, DBQueryResult &  res  )

static

Definition at line 194 of file PlanetDB.cpp.

References _log, DBerror::c_str(), DBQueryResult::error, DBQueryResult::GetRowCount(), and sDatabase.

Referenced by PlanetSE::GetExtractorsForPlanet().

{
    //SELECT ccPinID, ownerID, ecuID, headID, typeID, latitude, longitude FROM piECUHeads WHERE 1
    if (!sDatabase.RunQuery(res,
        "SELECT headID, typeID, ownerID, latitude, longitude"
        " FROM piECUHeads"
        " WHERE ccPinID IN"
        " (SELECT pinID FROM piCCPin"
        " WHERE planetID = %u)",
        planetID))
    {
        _log(DATABASE__ERROR, "Error in LoadPins Query: %s", res.error.c_str());
        return;
    }

    _log(DATABASE__RESULTS, "GetExtractorsForPlanet returned %u items", res.GetRowCount());
}

Here is the call graph for this function:

Here is the caller graph for this function:

void PlanetDB::GetLaunchDetails ( Launch::Data &  data )

static

Definition at line 151 of file PlanetDB.cpp.

References _log, DBerror::c_str(), DBQueryResult::error, DBResultRow::GetDouble(), DBResultRow::GetInt(), DBResultRow::GetInt64(), DBQueryResult::GetRow(), Launch::Data::itemID, Launch::Data::launchID, Launch::Data::launchTime, Launch::Data::planetID, sDatabase, Launch::Data::solarSystemID, Launch::Data::status, Launch::Data::x, Launch::Data::y, and Launch::Data::z.

{
    DBQueryResult res;
    if(!sDatabase.RunQuery(res, "SELECT itemID, status, solarSystemID, planetID, launchTime, x, y, z FROM piLaunches WHERE launchID = %u", data.launchID)) {
        _log(DATABASE__ERROR, "Error in GetLaunchDetails query: %s", res.error.c_str());
    }
    DBResultRow row;
    if (!res.GetRow(row)) {
        _log(DATABASE__ERROR, "Error in GetLaunchDetails query: %s", res.error.c_str());
        return;
    }

    data.itemID = row.GetInt(0);
    data.status = row.GetInt(1);
    data.solarSystemID = row.GetInt(2);
    data.planetID = row.GetInt(3);
    data.launchTime = row.GetInt64(4);
    data.x = row.GetDouble(5);
    data.y = row.GetDouble(6);
    data.z = row.GetDouble(7);
}

Here is the call graph for this function:

uint32 PlanetDB::GetLaunchItemID ( uint32  launchID )

static

Definition at line 172 of file PlanetDB.cpp.

References _log, DBerror::c_str(), DBQueryResult::error, DBResultRow::GetInt(), DBQueryResult::GetRow(), and sDatabase.

{
    DBQueryResult res;
    if(!sDatabase.RunQuery(res, "SELECT itemID FROM piLaunches WHERE launchID = %u", launchID)) {
        _log(DATABASE__ERROR, "Error in GetLaunchItemID query: %s", res.error.c_str());
    }
    DBResultRow row;
    if (!res.GetRow(row)) {
        _log(DATABASE__ERROR, "Error in GetLaunchItemID query: %s", res.error.c_str());
        return 0;
    }

    return row.GetInt(0);
}

Here is the call graph for this function:

uint32 PlanetDB::GetLaunchPlanet ( uint32  launchID )

static

Definition at line 136 of file PlanetDB.cpp.

References _log, DBerror::c_str(), DBQueryResult::error, DBResultRow::GetInt(), DBQueryResult::GetRow(), and sDatabase.

{
    DBQueryResult res;
    if(!sDatabase.RunQuery(res, "SELECT planetID FROM piLaunches WHERE launchID = %u", launchID)) {
        _log(DATABASE__ERROR, "Error in GetLaunchPlanet query: %s", res.error.c_str());
    }
    DBResultRow row;
    if (!res.GetRow(row)) {
        _log(DATABASE__ERROR, "Error in GetLaunchPlanet query: %s", res.error.c_str());
        return 0;
    }

    return row.GetInt(0);
}

Here is the call graph for this function:

GPoint PlanetDB::GetLaunchPos ( uint32  launchID )

static

Definition at line 121 of file PlanetDB.cpp.

References _log, DBerror::c_str(), DBQueryResult::error, DBResultRow::GetDouble(), DBQueryResult::GetRow(), NULL_ORIGIN(), and sDatabase.

{
    DBQueryResult res;
    if(!sDatabase.RunQuery(res, "SELECT x,y,z FROM piLaunches WHERE launchID = %u", launchID)) {
        _log(DATABASE__ERROR, "Error in GetLaunchPos query: %s", res.error.c_str());
    }
    DBResultRow row;
    if (!res.GetRow(row)) {
        _log(DATABASE__ERROR, "Error in GetLaunchPos query: %s", res.error.c_str());
        return NULL_ORIGIN;
    }
    GPoint pos(row.GetDouble(0), row.GetDouble(1), row.GetDouble(2));
    return pos;
}

Here is the call graph for this function:

PyRep * PlanetDB::GetMyLaunchesDetails

(

uint32

charID

)

Definition at line 111 of file PlanetDB.cpp.

References _log, DBerror::c_str(), DBResultToRowset(), DBQueryResult::error, and sDatabase.

                                                   {
    DBQueryResult res;
    if(!sDatabase.RunQuery(res, "SELECT itemID AS launchID, status, itemID, solarSystemID, planetID, launchTime, x, y, z"
        " FROM piLaunches WHERE charID = %u", charID)) {
        _log(DATABASE__ERROR, "Error in GetMyLaunchesDetails Query: %s", res.error.c_str());
        return nullptr;
    }
    return DBResultToRowset(res);
}

Here is the call graph for this function:

void PlanetDB::GetPlanetData

(

DBQueryResult &

res

)

Definition at line 61 of file PlanetDB.cpp.

References _log, DBerror::c_str(), DBQueryResult::error, and sDatabase.

Referenced by PlanetDataMgr::_Populate().

{
    // load info into PlanetDataMgr
    if(!sDatabase.RunQuery(res,
        "SELECT planet.typeID AS planetTypeID,"
        " resource.typeID AS resourceID"
        " FROM invTypes planet, invTypes resource, dgmTypeAttributes dgm1, dgmTypeAttributes dgm2 "
        " WHERE dgm1.typeID = dgm2.typeID AND dgm1.attributeID = 1632 AND dgm1.valueFloat = planet.typeID AND dgm2.attributeID = 709"
        " AND dgm2.valueFloat = resource.typeID ORDER BY planet.typeID ")) {
        _log(DATABASE__ERROR, "Error in GetPlanetData Query: %s", res.error.c_str());
        }
}

Here is the call graph for this function:

Here is the caller graph for this function:

PyRep * PlanetDB::GetPlanetsForChar

(

uint32

charID

)

self.colonizationData = sm.RemoteSvc('planetMgr').GetPlanetsForChar() returns (solarSystemID, planetID, typeID, numberOfPins)

Definition at line 75 of file PlanetDB.cpp.

References _log, DBerror::c_str(), DBResultToCRowset(), DBQueryResult::error, DBQueryResult::GetRowCount(), and sDatabase.

                                                {
    DBQueryResult res;
    if(!sDatabase.RunQuery(res,
        "SELECT solarSystemID, planetID, typeID, numberOfPins"
        " FROM piPlanets WHERE charID = %u", charID)) {
        _log(DATABASE__ERROR, "Error in GetPlanetsForChar query: %s", res.error.c_str());
        return nullptr;
    }
    _log(DATABASE__RESULTS, "GetPlanetsForChar returned %u items", res.GetRowCount());
    return DBResultToCRowset(res);
}

Here is the call graph for this function:

void PlanetDB::GetSchematicData

(

DBQueryResult &

res

)

Definition at line 47 of file PlanetDB.cpp.

References _log, DBerror::c_str(), DBQueryResult::error, and sDatabase.

Referenced by PIDataMgr::_Populate().

{
    // load info into PIDataMgr
    if(!sDatabase.RunQuery(res, "SELECT schematicID, typeID, quantity, isInput FROM piTypeMap" ))
        _log(DATABASE__ERROR, "Error in GetSchematicData Query: %s", res.error.c_str());
}

Here is the call graph for this function:

Here is the caller graph for this function:

void PlanetDB::GetSchematicTimes

(

DBQueryResult &

res

)

Definition at line 54 of file PlanetDB.cpp.

References _log, DBerror::c_str(), DBQueryResult::error, and sDatabase.

Referenced by PIDataMgr::_Populate().

{
    // load info into PIDataMgr
    if(!sDatabase.RunQuery(res, "SELECT schematicID, cycleTime FROM piSchematics"))
        _log(DATABASE__ERROR, "Error in GetSchematicTimes Query: %s", res.error.c_str());
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool PlanetDB::LoadColony	(	uint32	charID,
		uint32	planetID,
		PI_CCPin *	ccPin
	)

Definition at line 212 of file PlanetDB.cpp.

References _log, DBerror::c_str(), PI_CCPin::ccPinID, DBQueryResult::error, DBResultRow::GetInt(), DBQueryResult::GetRow(), PI_CCPin::level, and sDatabase.

Referenced by Colony::Init().

{
    DBQueryResult res;
    if (!sDatabase.RunQuery(res,
        "SELECT pinID,level"
        " FROM piCCPin"
        " WHERE charID = %u"
        " AND planetID = %u",
        charID, planetID ))
    {
        _log(DATABASE__ERROR, "Error in LoadPins Query: %s", res.error.c_str());
        return false;
    }
    DBResultRow row;
    if (res.GetRow(row)) {
        ccPin->level = row.GetInt(1);
        ccPin->ccPinID = row.GetInt(0);
        return true;
    }
    return false;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void PlanetDB::LoadContents	(	uint32	pinID,
		std::map< uint16, uint32 > &	contents
	)

Definition at line 361 of file PlanetDB.cpp.

References _log, DBerror::c_str(), DBQueryResult::error, DBQueryResult::GetRow(), DBQueryResult::GetRowCount(), and sDatabase.

Referenced by LoadPins().

{
    //SELECT ccPinID, pinID, typeID, itemQty FROM piPinContents
    DBQueryResult res;
    if (!sDatabase.RunQuery(res,
        "SELECT typeID, itemQty"
        " FROM piPinContents WHERE pinID = %u",
        pinID ))
    {
        _log(DATABASE__ERROR, "Error in LoadContents Query: %s", res.error.c_str());
        return;
    }

    _log(DATABASE__RESULTS, "LoadContents returned %u items", res.GetRowCount());

    DBResultRow row;
    while (res.GetRow(row)) {
        contents[row.GetInt(0)] = row.GetInt(1);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void PlanetDB::LoadHeads	(	uint32	ecuID,
		std::map< uint16, PI_Heads > &	heads
	)

Definition at line 382 of file PlanetDB.cpp.

References _log, DBerror::c_str(), PI_Heads::ecuPinID, DBQueryResult::error, DBQueryResult::GetRow(), DBQueryResult::GetRowCount(), PI_Heads::latitude, PI_Heads::longitude, sDatabase, and PI_Heads::typeID.

Referenced by LoadPins().

{
    //SELECT ecuID, headID, typeID, latitude, longitude FROM piECUHeads
    DBQueryResult res;
    if (!sDatabase.RunQuery(res,
        "SELECT headID, typeID, latitude, longitude"
        " FROM piECUHeads WHERE ecuID = %u",
        ecuID ))
    {
        _log(DATABASE__ERROR, "Error in LoadHeads Query: %s", res.error.c_str());
        return;
    }

    _log(DATABASE__RESULTS, "LoadHeads returned %u items", res.GetRowCount());

    DBResultRow row;
    while (res.GetRow(row)) {
        PI_Heads head = PI_Heads();
            head.typeID = row.GetInt(1);
            head.ecuPinID = ecuID;
            head.latitude = row.GetDouble(2);
            head.longitude = row.GetDouble(3);
        heads[(uint16)row.GetInt(0)] = head;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void PlanetDB::LoadLinks	(	uint32	ccPinID,
		std::map< uint32, PI_Link > &	links
	)

Definition at line 290 of file PlanetDB.cpp.

References _log, DBerror::c_str(), PI_Link::endpoint1, PI_Link::endpoint2, DBQueryResult::error, DBQueryResult::GetRow(), DBQueryResult::GetRowCount(), PI_Link::level, sDatabase, PI_Link::state, and PI_Link::typeID.

Referenced by Colony::Load().

{
    DBQueryResult res;
    if (!sDatabase.RunQuery(res,
        "SELECT linkID, level, state, endpoint1, endpoint2"
        " FROM piLinks WHERE ccPinID = %u",
        ccPinID ))
    {
        _log(DATABASE__ERROR, "Error in LoadPins Query: %s", res.error.c_str());
        return;
    }

    _log(DATABASE__RESULTS, "LoadLinks returned %u items", res.GetRowCount());

    DBResultRow row;
    while (res.GetRow(row)) {
        PI_Link link = PI_Link();
            link.level = row.GetInt(1);
            link.state = row.GetInt(2);
            link.typeID = 2280; // only link type in game
            link.endpoint1 = row.GetInt(3);
            link.endpoint2 = row.GetInt(4);
        links[row.GetInt(0)] = link;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void PlanetDB::LoadPins	(	uint32	ccPinID,
		std::map< uint32, PI_Pin > &	pins
	)

Definition at line 234 of file PlanetDB.cpp.

References _log, DBerror::c_str(), PI_Pin::contents, PI_Pin::cycleTime, DBQueryResult::error, PI_Pin::expiryTime, DBQueryResult::GetRow(), DBQueryResult::GetRowCount(), PI_Pin::hasReceivedInputs, PI_Pin::headRadius, PI_Pin::heads, EvE::Time::Hour, PI_Pin::installTime, PI_Pin::isCommandCenter, PI_Pin::isECU, PI_Pin::isLaunchable, PI_Pin::isProcess, PI_Pin::isStorage, PI_Pin::lastLaunchTime, PI_Pin::lastRunTime, PI_Pin::latitude, PI_Pin::level, LoadContents(), LoadHeads(), PI_Pin::longitude, PI_Pin::ownerID, PI_Pin::programType, PI_Pin::qtyPerCycle, PI_Pin::receivedInputsLastCycle, PI_Pin::schematicID, sDatabase, PI_Pin::state, and PI_Pin::typeID.

Referenced by Colony::Load().

{
    DBQueryResult res;
    if (!sDatabase.RunQuery(res,
        "SELECT pinID, typeID, ownerID, state, level, latitude, longitude, "
        " isCommandCenter, isLaunchable, isProcess, isStorage, isECU,"
        " schematicID, programType, headRadius,"
        " launchTime, cycleTime, expiryTime, installTime, lastRunTime,"
        " hasReceivedInputs, receivedInputsLastCycle, qtyPerCycle"
        " FROM piPins"
        " WHERE ccPinID = %u", ccPinID))
    {
        _log(DATABASE__ERROR, "Error in LoadPins Query: %s", res.error.c_str());
        return;
    }

    _log(DATABASE__RESULTS, "LoadPins returned %u items", res.GetRowCount());

    DBResultRow row;
    while (res.GetRow(row)) {
        PI_Pin pin = PI_Pin();
            pin.typeID                  = row.GetInt(1);
            pin.ownerID                 = row.GetInt(2);
            pin.state                   = row.GetInt(3);
            pin.level                   = row.GetInt(4);
            pin.latitude                = row.GetFloat(5);
            pin.longitude               = row.GetFloat(6);
            pin.isCommandCenter         = row.GetBool(7);
            pin.isLaunchable            = row.GetBool(8);
            pin.isProcess               = row.GetBool(9);
            pin.isStorage               = row.GetBool(10);
            pin.isECU                   = row.GetBool(11);
            pin.schematicID             = row.GetInt(12);
            pin.programType             = row.GetInt(13);
            pin.headRadius              = row.GetFloat(14);
            pin.lastLaunchTime          = row.GetInt64(15);
            pin.cycleTime               = row.GetInt64(16);
            if (pin.isECU)              // ecu time is stored as filetime, but used as hours
                pin.cycleTime           /= EvE::Time::Hour;
            pin.expiryTime              = row.GetInt64(17);
            pin.installTime             = row.GetInt64(18);
            pin.lastRunTime             = row.GetInt64(19);
            pin.hasReceivedInputs       = row.GetBool(20);
            pin.receivedInputsLastCycle = row.GetBool(21);
            pin.qtyPerCycle             = row.GetInt(22);

        if (pin.isStorage or pin.isProcess)
            LoadContents(row.GetInt(0), pin.contents);

        if (pin.isECU)
            LoadHeads(row.GetInt(0), pin.heads);

        pins[row.GetInt(0)] = pin;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void PlanetDB::LoadRoutes	(	uint32	ccPinID,
		std::map< uint16, PI_Route > &	routes
	)

Definition at line 316 of file PlanetDB.cpp.

References _log, DBerror::c_str(), PI_Route::commodityQuantity, PI_Route::commodityTypeID, PI_Route::destPinID, DBQueryResult::error, DBQueryResult::GetRow(), DBQueryResult::GetRowCount(), PI_Route::path, PI_Route::priority, sDatabase, PI_Route::srcPinID, and PI_Route::state.

Referenced by Colony::Load().

{
    DBQueryResult res;
    if (!sDatabase.RunQuery(res,
        "SELECT routeID, srcPinID, destPinID, state, priority, path, typeID, itemQty"
        " FROM piRoutes WHERE ccPinID = %u",
        ccPinID ))
    {
        _log(DATABASE__ERROR, "Error in LoadPins Query: %s", res.error.c_str());
        return;
    }

    _log(DATABASE__RESULTS, "LoadRoutes returned %u items", res.GetRowCount());

    DBResultRow row;
    std::string tempPath;
    while (res.GetRow(row)) {
        tempPath.clear();
        PI_Route route = PI_Route();
            route.srcPinID = row.GetInt(1);
            route.destPinID = row.GetInt(2);
            route.state = row.GetInt(3);
            route.priority = row.GetInt(4);
            route.commodityTypeID = row.GetInt(6);
            route.commodityQuantity = row.GetInt(7);

        tempPath = row.GetText(5);
        if (!tempPath.empty()) {
            // route string is not empty, so extract one number at a time until it is
            int pos = 0;
            std::string tempString = "";

            while ((pos = tempPath.find_first_of(':')) > 0 ) {
                tempString = tempPath.substr(0,pos);
                tempPath = tempPath.substr(pos+1,tempPath.length()-1);
                route.path.insert(route.path.end(), (atoi(tempString.c_str())));
            }
            // insert last pinID
            route.path.insert(route.path.end(), (atoi(tempPath.c_str())));
        }

        routes[row.GetInt(0)] = route;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void PlanetDB::RemoveContents

(

uint32

pinID

)

Definition at line 819 of file PlanetDB.cpp.

References sDatabase.

Referenced by Colony::AbandonColony(), and Colony::Process().

{
    DBerror err;
    sDatabase.RunQuery(err, "DELETE FROM piPinContents WHERE pinID = %u", pinID);
}

Here is the caller graph for this function:

void PlanetDB::RemoveHead	(	uint32	ecuID,
		uint32	headID
	)

Definition at line 801 of file PlanetDB.cpp.

References sDatabase.

{
    DBerror err;
    sDatabase.RunQuery(err, "DELETE FROM piECUHeads WHERE ecuID = %u AND headID = %u", ecuID, headID);
}

void PlanetDB::RemoveLink

(

uint32

linkID

)

Definition at line 807 of file PlanetDB.cpp.

References sDatabase.

Referenced by Colony::RemoveLink(), and Colony::RemovePin().

{
    DBerror err;
    sDatabase.RunQuery(err, "DELETE FROM piLinks WHERE linkID = %u", linkID);
}

Here is the caller graph for this function:

void PlanetDB::RemovePin

(

uint32

pinID

)

Definition at line 793 of file PlanetDB.cpp.

References sDatabase.

Referenced by Colony::AbandonColony(), and Colony::RemovePin().

{
    DBerror err;
    sDatabase.RunQuery(err, "DELETE FROM piPins WHERE pinID = %u", pinID);
    sDatabase.RunQuery(err, "DELETE FROM entity WHERE itemID = %u", pinID);
    sDatabase.RunQuery(err, "DELETE FROM entity_attributes WHERE itemID = %u", pinID);
}

Here is the caller graph for this function:

void PlanetDB::RemoveRoute

(

uint16

routeID

)

Definition at line 813 of file PlanetDB.cpp.

References sDatabase.

Referenced by Colony::RemovePin(), and Colony::RemoveRoute().

{
    DBerror err;
    sDatabase.RunQuery(err, "DELETE FROM piRoutes WHERE routeID = %u", routeID);
}

Here is the caller graph for this function:

void PlanetDB::SaveCCLevel	(	uint32	pinID,
		uint8	level
	)

Definition at line 432 of file PlanetDB.cpp.

References _log, DBerror::GetError(), and sDatabase.

Referenced by Colony::UpgradeCommandCenter().

{
    DBerror err;
    if(!sDatabase.RunQuery(err, "UPDATE piCCPin SET level = %u WHERE pinID = %u", level, pinID))
        _log(DATABASE__ERROR, "SaveCCLevel - Unable to save CCLevel: %s", err.GetError());
    if(!sDatabase.RunQuery(err, "UPDATE piPins SET level = %u WHERE pinID = %u", level, pinID))
        _log(DATABASE__ERROR, "SaveCCLevel - Unable to save CCLevel: %s", err.GetError());

}

Here is the call graph for this function:

Here is the caller graph for this function:

void PlanetDB::SaveCommandCenter	(	uint32	pinID,
		uint32	charID,
		uint32	planetID,
		uint32	typeID,
		double	latitude,
		double	longitude
	)

Definition at line 420 of file PlanetDB.cpp.

References _log, DBerror::GetError(), and sDatabase.

Referenced by Colony::CreateCommandPin().

{
    DBerror err;
    if(!sDatabase.RunQuery(err,
        "INSERT INTO piCCPin (pinID, charID, planetID, typeID, latitude, longitude) "
        " VALUES (%u, %u, %u, %u, %f, %f)",
        pinID, charID, planetID, typeID, latitude, longitude))
    {
        _log(DATABASE__ERROR, "SaveCommandCenter - Unable to save CommandCenter: %s", err.GetError());
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void PlanetDB::SaveContents

(

PI_CCPin *

ccPin

)

Definition at line 733 of file PlanetDB.cpp.

References _log, DBerror::c_str(), PI_CCPin::ccPinID, PI_CCPin::pins, and sDatabase.

Referenced by Colony::LaunchCommodities(), Colony::PlanetXfer(), Colony::Save(), Colony::Shutdown(), and Colony::TransferCommodities().

{
    std::ostringstream Inserts;
    // start the insert into command.
    Inserts << "INSERT INTO piPinContents";
    Inserts << " (ccPinID, pinID, typeID, itemQty)";

    bool first = true;
    uint32 ccPinID = ccPin->ccPinID;
    std::map<uint16, uint32>::iterator itr;
    for (auto cur : ccPin->pins) {
        if (cur.second.isStorage) {
            for (itr = cur.second.contents.begin(); itr != cur.second.contents.end(); ++itr) {
                if (first) {
                    Inserts << " VALUES ";
                    first = false;
                } else {
                    Inserts << ", ";
                }
                Inserts << "(" << ccPinID << ", " << cur.first << ", " << itr->first << ", " << itr->second << ")";
            }
        }
    }
    if (!first) {
        // finish creating the command.
        Inserts << " ON DUPLICATE KEY UPDATE";
        Inserts << " itemQty=VALUES(itemQty);";
        // execute the command.
        DBerror err;
        if (!sDatabase.RunQuery(err, Inserts.str().c_str()))
            _log(DATABASE__ERROR, "SaveContents - unable to save contents - %s", err.c_str());
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void PlanetDB::SaveHeads	(	uint32	ccPinID,
		uint32	ownerID,
		uint32	ecuID,
		std::map< uint16, PI_Heads > &	heads
	)

Definition at line 595 of file PlanetDB.cpp.

References _log, DBerror::GetError(), and sDatabase.

Referenced by Colony::GetColony().

{
    if (heads.empty())
        return;

    DBerror err;
    for (auto cur : heads) {
        // save the head data separately
        if (!sDatabase.RunQuery(err,
            "INSERT INTO piECUHeads (ccPinID, ownerID, ecuID, headID, typeID, latitude, longitude)"
            " VALUES (%u, %u, %u, %u, %u, %f, %f)"
            " ON DUPLICATE KEY UPDATE "
            " typeID=VALUES(typeID),"
            " latitude=VALUES(latitude),"
            " longitude=VALUES(longitude)",
            ccPinID, ownerID, ecuID, cur.first, cur.second.typeID, cur.second.latitude, cur.second.longitude))
        {
            _log(DATABASE__ERROR, "SaveHeads - Unable to save heads: %s", err.GetError());
        }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void PlanetDB::SaveLaunch	(	uint32	contID,
		uint32	charID,
		uint32	systemID,
		uint32	planetID,
		GPoint &	pos
	)

Definition at line 408 of file PlanetDB.cpp.

References _log, DBerror::GetError(), GetFileTimeNow(), sDatabase, Ga::GaVec3::x, Ga::GaVec3::y, and Ga::GaVec3::z.

Referenced by Colony::LaunchCommodities().

{
    DBerror err;
    if(!sDatabase.RunQuery(err,
        "INSERT INTO piLaunches (itemID, status, charID, solarSystemID, planetID, launchTime, x, y, z) "
        " VALUES (%u, 0, %u, %u, %u, %f, %f, %f, %f)",
                           contID, charID, systemID, planetID, GetFileTimeNow(), pos.x, pos.y, pos.z))
        {
            _log(DATABASE__ERROR, "SaveLaunch - Unable to save Launch: %s", err.GetError());
        }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void PlanetDB::SaveLinkLevel	(	uint32	linkID,
		uint8	level
	)

Definition at line 658 of file PlanetDB.cpp.

References _log, DBerror::GetError(), and sDatabase.

{
    DBerror err;
    if(!sDatabase.RunQuery(err, "UPDATE piLinks SET level = %u WHERE linkID = %u", level, linkID))
    {
        _log(DATABASE__ERROR, "SaveLinkLevel - Unable to save LinkLevel: %s", err.GetError());
    }
}

Here is the call graph for this function:

void PlanetDB::SaveLinks

(

PI_CCPin *

ccPin

)

Definition at line 626 of file PlanetDB.cpp.

References _log, DBerror::c_str(), PI_CCPin::ccPinID, PI_CCPin::links, and sDatabase.

Referenced by Colony::CreateLink(), Colony::RemovePin(), Colony::Save(), and Colony::UpgradeLink().

{
    std::ostringstream Inserts;
    // start the insert into command.
    Inserts << "INSERT INTO piLinks";
    Inserts << " (ccPinID, linkID, level, endpoint1, endpoint2)";

    bool first = true;
    uint32 ccPinID = ccPin->ccPinID;
    for (auto cur : ccPin->links) {
        if (first) {
            Inserts << " VALUES ";
            first = false;
        } else {
            Inserts << ", ";
        }
        Inserts << "(" << ccPinID << ", " << cur.first << ", " << cur.second.level << ", " << cur.second.endpoint1 << ", " << cur.second.endpoint2 << ")";
    }

    if (!first) {
        // finish creating the command.
        Inserts << " ON DUPLICATE KEY UPDATE";
        Inserts << " level=VALUES(level), ";
        Inserts << " endpoint1=VALUES(endpoint1), ";
        Inserts << " endpoint2=VALUES(endpoint2)";
        // execute the command.
        DBerror err;
        if (!sDatabase.RunQuery(err, Inserts.str().c_str()))
            _log(DATABASE__ERROR, "SaveLinks - unable to save links - %s", err.c_str());
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void PlanetDB::SavePinContents	(	uint32	ccPinID,
		uint32	pinID,
		std::map< uint16, uint32 > &	contents
	)

Definition at line 767 of file PlanetDB.cpp.

References _log, DBerror::c_str(), and sDatabase.

Referenced by Colony::Process().

{
    std::ostringstream Inserts;
    // start the insert into command.
    Inserts << "INSERT INTO piPinContents";
    Inserts << " (ccPinID, pinID, typeID, itemQty)";

    bool first = true;
    std::map<uint16, uint32>::iterator itr;
    for (itr = contents.begin(); itr != contents.end(); ++itr) {
        if (first) {
            Inserts << " VALUES ";
            first = false;
        } else {
            Inserts << ", ";
        }
        Inserts << "(" << ccPinID << ", " << pinID << ", " << itr->first << ", " << itr->second << ")";
    }
    if (!first) {
        // execute the command.
        DBerror err;
        if (!sDatabase.RunQuery(err, Inserts.str().c_str()))
            _log(DATABASE__ERROR, "SavePinContents - unable to save contents - %s", err.c_str());
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void PlanetDB::SavePinLevel	(	uint32	pinID,
		uint8	level
	)

Definition at line 617 of file PlanetDB.cpp.

References _log, DBerror::GetError(), and sDatabase.

{
    DBerror err;
    if(!sDatabase.RunQuery(err, "UPDATE piPins SET level = %u WHERE pinID = %u", level, pinID))
    {
        _log(DATABASE__ERROR, "SavePinLevel - Unable to save PinLevel: %s", err.GetError());
    }
}

Here is the call graph for this function:

void PlanetDB::SavePins

(

PI_CCPin *

ccPin

)

Definition at line 442 of file PlanetDB.cpp.

References _log, DBerror::c_str(), PI_CCPin::ccPinID, PI_CCPin::pins, and sDatabase.

Referenced by Colony::CreateCommandPin(), and Colony::Save().

{
    std::ostringstream Inserts;
    // start the insert into command.
    Inserts << "INSERT INTO piPins";
    Inserts << " (ccPinID, pinID, typeID, ownerID, level, latitude, longitude,";
    Inserts << " isCommandCenter, isLaunchable, isProcess, isStorage, isECU,";
    Inserts << " schematicID, programType, headRadius, launchTime,";
    Inserts << " cycleTime, expiryTime, installTime, lastRunTime)";

    bool first = true;
    uint32 ccPinID = ccPin->ccPinID;
    for (auto cur : ccPin->pins) {
        if (first) {
            Inserts << " VALUES ";
            first = false;
        } else {
            Inserts << ", ";
        }
        Inserts << "(" << ccPinID << ", " << cur.first << ", " << cur.second.typeID << ", " << cur.second.ownerID << ", " << cur.second.level << ", " << cur.second.latitude << ", " << cur.second.longitude << ", ";
        Inserts << cur.second.isCommandCenter << ", " << cur.second.isLaunchable << ", " << cur.second.isProcess << ", " << cur.second.isStorage <<", " << cur.second.isECU << ", ";
        Inserts << cur.second.schematicID << ", " << cur.second.programType << ", " << cur.second.headRadius << ", " << cur.second.lastLaunchTime;
        Inserts << ", " << cur.second.cycleTime << ", " << cur.second.expiryTime << ", " << cur.second.installTime << ", " << cur.second.lastRunTime << ")";
    }

    if (!first) {
        // finish creating the command.
        Inserts << " ON DUPLICATE KEY UPDATE ";
        Inserts << " schematicID=VALUES(schematicID), ";
        Inserts << " programType=VALUES(programType), ";
        Inserts << " headRadius=VALUES(headRadius),";
        Inserts << " launchTime=VALUES(launchTime), ";
        Inserts << " cycleTime=VALUES(cycleTime),";
        Inserts << " expiryTime=VALUES(expiryTime), ";
        Inserts << " installTime=VALUES(installTime),";
        Inserts << " lastRunTime=VALUES(lastRunTime);";
        // execute the command.
        DBerror err;
        if (!sDatabase.RunQuery(err, Inserts.str().c_str()))
            _log(DATABASE__ERROR, "SavePins - unable to save pins: %s", err.c_str());
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

uint16 PlanetDB::SaveRoute	(	uint32	ccPinID,
		PI_Route &	route
	)

Definition at line 667 of file PlanetDB.cpp.

References _log, PI_Route::commodityQuantity, PI_Route::commodityTypeID, PI_Route::destPinID, DBerror::GetError(), PI_Route::path, PI_Route::priority, sDatabase, PI_Route::srcPinID, and PI_Route::state.

Referenced by Colony::CreateRoute().

{
    DBerror err;
    uint32 routeID = 0;
    std::string path;
    path.clear();
    std::list<uint32>::iterator itr = route.path.begin();
    while (itr != route.path.end()) {
        path += std::to_string(*itr);
        if (++itr != route.path.end())
            path += ":";
    }
    if (!sDatabase.RunQueryLID(err, routeID,
        "INSERT INTO `piRoutes`(`ccPinID`, `srcPinID`, `destPinID`, `state`, `priority`, `path`, `typeID`, `itemQty`) "
        " VALUES (%u, %u, %u, %u, %u, '%s', %u, %u)",
        ccPinID, route.srcPinID, route.destPinID, route.state, route.priority, path.c_str(), route.commodityTypeID, route.commodityQuantity))
    {
        _log(DATABASE__ERROR, "SaveHeads - Unable to save heads: %s", err.GetError());
    }
    return (uint16)routeID;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void PlanetDB::SaveRoutes

(

PI_CCPin *

ccPin

)

Definition at line 689 of file PlanetDB.cpp.

References _log, DBerror::c_str(), PI_CCPin::ccPinID, PI_CCPin::routes, and sDatabase.

Referenced by Colony::PrioritizeRoute(), Colony::RemovePin(), and Colony::Save().

{
    std::ostringstream Inserts;
    // start the insert into command.
    Inserts << "INSERT INTO piRoutes";
    Inserts << " (ccPinID, routeID, srcPinID, destPinID, path, typeID, itemQty)";

    bool first = true;
    std::string path;
    std::list<uint32>::iterator itr;
    uint32 ccPinID = ccPin->ccPinID;
    for (auto cur : ccPin->routes) {
        path.clear();
        if (first) {
            Inserts << " VALUES ";
            first = false;
        } else {
            Inserts << ", ";
        }
        itr = cur.second.path.begin();
        while (itr != cur.second.path.end()) {
            path += std::to_string(*itr);
            if (++itr != cur.second.path.end())
                path += ":";
        }
        Inserts << "(" << ccPinID << ", " << cur.first << ", " << cur.second.srcPinID << ", " << cur.second.destPinID << ", '" << path << "', ";
        Inserts << cur.second.commodityTypeID << ", " << cur.second.commodityQuantity << ")";
    }

    if (!first) {
        // finish creating the command.
        Inserts << " ON DUPLICATE KEY UPDATE";
        Inserts << " path=VALUES(path),";
        Inserts << " srcPinID=VALUES(srcPinID),";
        Inserts << " destPinID=VALUES(destPinID),";
        Inserts << " typeID=VALUES(typeID),";
        Inserts << " itemQty=VALUES(itemQty);";
        // execute the command.
        DBerror err;
        if (!sDatabase.RunQuery(err, Inserts.str().c_str()))
            _log(DATABASE__ERROR, "SaveRoutes - unable to save route - %s", err.c_str());
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void PlanetDB::UpdateECUPin	(	uint32	pinID,
		PI_CCPin *	ccPin
	)

Definition at line 536 of file PlanetDB.cpp.

References _log, DBerror::GetError(), PI_CCPin::pins, and sDatabase.

Referenced by Colony::SetProgramResults().

{
    std::map<uint32, PI_Pin>::iterator itr = ccPin->pins.find(pinID);
    if (itr == ccPin->pins.end()) {
        _log(PLANET__ERROR, "PlanetDB::UpdateECUPin() - pinID %u not found in ccPin.pins map", pinID);
        return;
    }

    DBerror err;
    if(!sDatabase.RunQuery(err,
        "UPDATE piPins SET"
        "  programType = %u,"
        "  headRadius = %f,"
        "  qtyPerCycle = %u,"
        "  schematicID = %u,"
        "  expiryTime = %li,"
        "  cycleTime = %li,"
        "  installTime = %li,"
        "  lastRunTime = %li"
        " WHERE pinID = %u",
        itr->second.programType, itr->second.headRadius, itr->second.qtyPerCycle, itr->second.schematicID, itr->second.expiryTime,
        itr->second.cycleTime, itr->second.installTime, itr->second.lastRunTime, pinID))
    {
        _log(DATABASE__ERROR, "UpdateECUPin - Unable to update pin: %s", err.GetError());
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void PlanetDB::UpdateLaunchStatus ( uint32  itemID, uint8  status  )

static

Definition at line 187 of file PlanetDB.cpp.

References sDatabase.

Referenced by CargoContainer::RemoveItem().

{
    DBerror err;
    sDatabase.RunQuery(err, "UPDATE piLaunches SET status=%u WHERE itemID = %u", status, itemID);
}

Here is the caller graph for this function:

void PlanetDB::UpdatePins	(	uint32	pinID,
		PI_CCPin *	ccPin
	)

Definition at line 485 of file PlanetDB.cpp.

References _log, DBerror::c_str(), PI_CCPin::ccPinID, PI_CCPin::pins, and sDatabase.

Referenced by Colony::LaunchCommodities(), Colony::PlanetXfer(), Colony::Process(), Colony::TransferCommodities(), and Colony::UpdatePlantPins().

{
    std::ostringstream Inserts;
    // start the insert into command.
    Inserts << "INSERT INTO piPins";
    Inserts << " (ccPinID, pinID, schematicID, programType, launchTime,";
    Inserts << " cycleTime, installTime, lastRunTime, receivedInputsLastCycle, hasReceivedInputs)";

    bool first = true;
    if (pinID) {
        std::map<uint32, PI_Pin>::iterator itr;
        itr = ccPin->pins.find(pinID);
        if (itr != ccPin->pins.end()) {
            first = false;
            Inserts << " VALUES ";
            Inserts << "(" << ccPin->ccPinID << ", " << itr->first << ", "<< itr->second.schematicID << ", " << itr->second.programType;
            Inserts << ", " << itr->second.lastLaunchTime << ", " << itr->second.cycleTime << ", " << itr->second.installTime;
            Inserts  << ", " << itr->second.lastRunTime << ", " << itr->second.receivedInputsLastCycle << ", " << itr->second.hasReceivedInputs << ")";
        }
    } else {
        for (auto cur : ccPin->pins) {
            if (first) {
                Inserts << " VALUES ";
                first = false;
            } else {
                Inserts << ", ";
            }
            Inserts << "(" << ccPin->ccPinID << ", " << cur.first << ", "<< cur.second.schematicID << ", " << cur.second.programType;
            Inserts << ", " << cur.second.lastLaunchTime << ", " << cur.second.cycleTime << ", " << cur.second.installTime;
            Inserts << ", " << cur.second.lastRunTime << ", " << cur.second.receivedInputsLastCycle << ", " << cur.second.hasReceivedInputs << ")";
        }
    }

    if (!first) {
        // finish creating the command.
        Inserts << " ON DUPLICATE KEY UPDATE ";
        Inserts << " schematicID=VALUES(schematicID), ";
        Inserts << " programType=VALUES(programType), ";
        Inserts << " launchTime=VALUES(launchTime), ";
        Inserts << " cycleTime=VALUES(cycleTime),";
        Inserts << " installTime=VALUES(installTime),";
        Inserts << " lastRunTime=VALUES(lastRunTime),";
        Inserts << " hasReceivedInputs=VALUES(hasReceivedInputs),";
        Inserts << " receivedInputsLastCycle=VALUES(receivedInputsLastCycle);";
        // execute the command.
        DBerror err;
        if (!sDatabase.RunQuery(err, Inserts.str().c_str()))
            _log(DATABASE__ERROR, "SavePins - unable to save pins: %s", err.c_str());
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void PlanetDB::UpdatePinTimes

(

PI_CCPin *

ccPin

)

Definition at line 563 of file PlanetDB.cpp.

References _log, DBerror::c_str(), PI_CCPin::pins, and sDatabase.

{
    std::ostringstream Inserts;
    // start the insert into command.
    Inserts << "INSERT INTO piPins";
    Inserts << " (pinID, launchTime, installTime, lastRunTime)";

    bool first = true;
    for (auto cur : ccPin->pins) {
        if (first) {
            Inserts << " VALUES ";
            first = false;
        } else {
            Inserts << ", ";
        }
        Inserts << "(" << cur.first << ", " << cur.second.lastLaunchTime << ", ";
        Inserts << cur.second.installTime << ", " << cur.second.lastRunTime << ")";
    }

    if (!first) {
        // finish creating the command.
        Inserts << " ON DUPLICATE KEY UPDATE ";
        Inserts << " launchTime=VALUES(launchTime),";
        Inserts << " installTime=VALUES(installTime),";
        Inserts << " lastRunTime=VALUES(lastRunTime);";
        // execute the command.
        DBerror err;
        if (!sDatabase.RunQuery(err, Inserts.str().c_str()))
            _log(DATABASE__ERROR, "SavePins - unable to save pins: %s", err.c_str());
    }
}

Here is the call graph for this function:

void PlanetDB::UpdatePlanetPins	(	uint32	ccPinID,
		uint8	pins = 1
	)

Definition at line 101 of file PlanetDB.cpp.

References _log, DBerror::GetError(), and sDatabase.

Referenced by Colony::RemovePin(), and Colony::Save().

{
    DBerror err;
    if(!sDatabase.RunQuery(err, "UPDATE piPlanets SET numberOfPins = %u WHERE ccPinID = %u ", pins, ccPinID))
    {
        _log(DATABASE__ERROR, "UpdatePlanetPins - Unable to update ccPinID %u : %s", ccPinID, err.GetError());
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

---

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

• /backups/local/src/eve/EvEmu_Crucible/src/eve-server/planet/PlanetDB.h
• /backups/local/src/eve/EvEmu_Crucible/src/eve-server/planet/PlanetDB.cpp