BookmarkDB Class Reference

#include "BookmarkDB.h"

Inheritance diagram for BookmarkDB:

Collaboration diagram for BookmarkDB:

Public Member Functions
PyRep *	GetBookmarksInFolder (uint32 folderID)
PyRep *	GetBookmarks (uint32 ownerID)
PyRep *	GetFolders (uint32 ownerID)
bool	GetBookmarkInformation (uint32 bookmarkID, uint32 &itemID, uint16 &typeID, uint32 &locationID, double &x, double &y, double &z)
bool	UpdateBookmark (uint32 bookmarkID, uint32 ownerID, std::string memo, std::string note, uint32 folderID=0)
bool	DeleteBookmark (uint32 ownerID, uint32 bookmarkID)
bool	DeleteBookmarks (std::vector< int32 > *bookmarkList)
bool	UpdateFolder (int32 folderID, std::string folderName)
bool	DeleteFolder (int32 folderID)
uint32	SaveNewFolder (std::string folderName, uint32 ownerID)
void	SaveNewBookmark (BmData &data)
void	ChangeOwner (uint32 bookmarkID, uint32 ownerID=1)
void	MoveBookmarkToFolder (int32 folderID, std::vector< int32 > *bookmarkList)
void	GetBookmarkByFolderID (int32 folderID, std::vector< int32 > &bmIDs)
void	GetVoucherData (BmData &data)
Public Member Functions inherited from ServiceDB
uint32	GetStationOwner (uint32 stationID)

Static Public Member Functions
static PyTuple *	GetBookmarkDescription (uint32 bookmarkID)
static const char *	GetBookmarkName (uint32 bookmarkID)
Static Public Member Functions inherited from ServiceDB
static bool	GetAccountInformation (CryptoChallengePacket &ccp, AccountData &aData, std::string &failMsg)
static bool	UpdateAccountHash (const char *username, std::string &hash)
static bool	IncrementLoginCount (uint32 accountID)
static void	UpdatePassword (uint32 accountID, const char *pass)
static void	SaveKillOrLoss (CharKillData &data)
static bool	GetConstant (const char *name, uint32 &into)
static void	SetServerOnlineStatus (bool online=false)
static void	SetCharacterOnlineStatus (uint32 char_id, bool online=false)
static void	SetAccountOnlineStatus (uint32 accountID, bool online=false)
static void	SetAccountBanStatus (uint32 accountID, bool banned=false)
static void	SaveServerStats (double threads, float rss, float vm, float user, float kernel, uint32 items, uint32 bubbles)
static uint32	SetClientSeed ()
static PyRep *	LookupChars (const char *match, bool exact=false)
static PyRep *	LookupOwners (const char *match, bool exact=false)
static PyRep *	LookupCorporations (const std::string &)
static PyRep *	LookupFactions (const std::string &)
static PyRep *	LookupCorporationTickers (const std::string &)
static PyRep *	LookupStations (const std::string &)
static PyRep *	LookupKnownLocationsByGroup (const std::string &, uint32)
static PyRep *	PrimeOwners (std::vector< int32 > &itemIDs)
static bool	ValidateAccountName (CryptoChallengePacket &ccp, std::string &failMsg)
static void	GetCorpHangarNames (uint32 corpID, std::map< uint8, std::string > &hangarNames)

Additional Inherited Members
Protected Member Functions inherited from ServiceDB
void	ProcessStringChange (const char *key, const std::string &oldValue, std::string newValue, PyDict *notif, std::vector< std::string > &dbQ)
void	ProcessRealChange (const char *key, double oldValue, double newValue, PyDict *notif, std::vector< std::string > &dbQ)
void	ProcessIntChange (const char *key, uint32 oldValue, uint32 newValue, PyDict *notif, std::vector< std::string > &dbQ)
void	ProcessLongChange (const char *key, int64 oldValue, int64 newValue, PyDict *notif, std::vector< std::string > &dbQ)
Static Protected Member Functions inherited from ServiceDB
static uint32	CreateNewAccount (const char *login, const char *pass, const char *passHash, int64 role)

Detailed Description

Definition at line 57 of file BookmarkDB.h.

Member Function Documentation

void BookmarkDB::ChangeOwner	(	uint32	bookmarkID,
		uint32	ownerID = 1
	)

Definition at line 301 of file BookmarkDB.cpp.

References sDatabase.

                                                               {
    DBerror err;
    sDatabase.RunQuery(err, "UPDATE bookmarks SET ownerID = %u WHERE bookmarkID = %u", ownerID, bookmarkID);
}

bool BookmarkDB::DeleteBookmark	(	uint32	ownerID,
		uint32	bookmarkID
	)

Definition at line 266 of file BookmarkDB.cpp.

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

{
    DBerror err;
    if (!sDatabase.RunQuery(err,
        "DELETE FROM bookmarks"
        " WHERE ownerID = %u AND bookmarkID = %u", ownerID, bookmarkID))
    {
        sLog.Error( "BookmarkDB::DeleteBookmarkFromDatabase()", "Error in query: %s", err.c_str() );
        return false;
    }

    return true;
}

Here is the call graph for this function:

bool BookmarkDB::DeleteBookmarks

(

std::vector< int32 > *

bookmarkList

)

Definition at line 280 of file BookmarkDB.cpp.

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

{
    std::stringstream st;
    std::string listString;

    std::size_t size = bookmarkList->size();
    for (int8 i=0; i<size; ++i) {
        st << bookmarkList->at(i);
        if (i < (size-1))
            st << ", ";
    }

    DBerror err;
    if (!sDatabase.RunQuery(err, "DELETE FROM bookmarks WHERE bookmarkID IN (%s)", st.str().c_str())) {
        sLog.Error( "BookmarkDB::DeleteBookmarksFromDatabase()", "Error in query: %s", err.c_str() );
        return false;
    }

    return true;
}

Here is the call graph for this function:

bool BookmarkDB::DeleteFolder

(

int32

folderID

)

Definition at line 356 of file BookmarkDB.cpp.

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

{
    DBerror err;
    if (!sDatabase.RunQuery(err, "DELETE FROM bookmarkFolders WHERE folderID = %u", folderID))
        sLog.Error( "BookmarkDB::DeleteFolder(1)", "Error in query: %s", err.c_str() );

    // these bms may have copies....cannot delete yet
    if (!sDatabase.RunQuery(err, "UPDATE bookmarks SET ownerID = 1 WHERE folderID = %u", folderID))
        sLog.Error( "BookmarkDB::DeleteFolder(2)", "Error in query: %s", err.c_str() );

    return true;
}

Here is the call graph for this function:

void BookmarkDB::GetBookmarkByFolderID	(	int32	folderID,
		std::vector< int32 > &	bmIDs
	)

Definition at line 66 of file BookmarkDB.cpp.

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

{
    DBQueryResult res;
    if (!sDatabase.RunQuery(res, "SELECT bookmarkID FROM bookmarks WHERE folderID = %u", folderID)) {
        sLog.Error( "BookmarkDB::GetBookmarkByFolderID()", "Failed to query bookmarks for folderID %u: %s.", folderID, res.error.c_str() );
        return;
    }

    DBResultRow row;
    while (res.GetRow(row))
        bmIDs.push_back(row.GetInt(0));
}

Here is the call graph for this function:

PyTuple * BookmarkDB::GetBookmarkDescription ( uint32  bookmarkID )

static

Definition at line 180 of file BookmarkDB.cpp.

References DBerror::c_str(), DBQueryResult::error, DBQueryResult::GetRow(), DBResultRow::GetText(), DBResultRow::IsNull(), PyStatic, sDatabase, PyTuple::SetItem(), and sLog.

{
    DBQueryResult res;
    if (!sDatabase.RunQuery(res, "SELECT memo, note FROM bookmarks WHERE bookmarkID = %u", bookmarkID)) {
        sLog.Error( "BookmarkDB::GetBookmarkName()", "Failed to query bookmarkID %u: %s.", bookmarkID, res.error.c_str() );
        return nullptr;
    }

    PyTuple* tuple = new PyTuple(2);
    DBResultRow row;
    if (res.GetRow(row)) {
        tuple->SetItem(0, new PyString(row.GetText(0)));
        if (row.IsNull(1)) {
            tuple->SetItem(1, PyStatic.NewNone());
        } else {
            tuple->SetItem(1, new PyString(row.GetText(1)));
        }
    } else {
        tuple->SetItem(0, PyStatic.NewNone());
        tuple->SetItem(1, PyStatic.NewNone());
    }

    return tuple;
}

Here is the call graph for this function:

bool BookmarkDB::GetBookmarkInformation	(	uint32	bookmarkID,
		uint32 &	itemID,
		uint16 &	typeID,
		uint32 &	locationID,
		double &	x,
		double &	y,
		double &	z
	)

Definition at line 205 of file BookmarkDB.cpp.

References DBerror::c_str(), DBQueryResult::error, DBResultRow::GetDouble(), DBQueryResult::GetRow(), DBResultRow::GetUInt(), sDatabase, and sLog.

Referenced by BookmarkService::LookupBookmark().

{
    DBQueryResult res;
    if (!sDatabase.RunQuery(res,
        "SELECT"
        "  itemID,"
        "  typeID,"
        "  locationID,"
        "  x, y, z"
        " FROM bookmarks "
        " WHERE bookmarkID = %u ", bookmarkID))
    {
        sLog.Error( "BookmarkDB::GetBookmarkInformation()", "Error in query: %s", res.error.c_str() );
        return false;
    }

    DBResultRow row;
    if (!res.GetRow(row))
        return false;

    itemID = row.GetUInt(0);
    typeID = row.GetUInt(1);
    locationID = row.GetUInt(2);
    x = row.GetDouble(3);
    y = row.GetDouble(4);
    z = row.GetDouble(5);

    return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

const char * BookmarkDB::GetBookmarkName ( uint32  bookmarkID )

static

Definition at line 165 of file BookmarkDB.cpp.

References DBerror::c_str(), DBQueryResult::error, DBQueryResult::GetRow(), DBResultRow::GetText(), sDatabase, and sLog.

{
    DBQueryResult res;
    if (!sDatabase.RunQuery(res, "SELECT memo FROM bookmarks WHERE bookmarkID = %u", bookmarkID)) {
        sLog.Error( "BookmarkDB::GetBookmarkName()", "Failed to query bookmarkID %u: %s.", bookmarkID, res.error.c_str() );
        return nullptr;
    }

    DBResultRow row;
    if (!res.GetRow(row))
        return nullptr;

    return row.GetText(0);
}

Here is the call graph for this function:

PyRep * BookmarkDB::GetBookmarks

(

uint32

ownerID

)

Definition at line 79 of file BookmarkDB.cpp.

References PyList::AddItem(), DBerror::c_str(), DBQueryResult::error, DBResultRow::GetFloat(), DBResultRow::GetInt(), DBResultRow::GetInt64(), DBQueryResult::GetRow(), DBResultRow::GetText(), DBResultRow::IsNull(), PyStatic, sDatabase, PyDict::SetItemString(), and sLog.

                                              {
    DBQueryResult res;
    if (!sDatabase.RunQuery(res,
        "SELECT"
        "  bookmarkID,"
        "  ownerID,"
        "  itemID,"
        "  typeID,"
        "  memo,"
        "  created,"
        "  x, y, z,"
        "  locationID,"
        "  note,"
        "  creatorID,"
        "  folderID"
        " FROM bookmarks"
        " WHERE ownerID = %u",
        ownerID))
    {
        sLog.Error( "BookmarkDB::GetBookmarks()", "Failed to query bookmarks for owner %u: %s.", ownerID, res.error.c_str() );
        return nullptr;
    }

    //return DBResultToCRowset(res);
    PyList* list = new PyList();
    DBResultRow row;
    while (res.GetRow(row)) {
        PyDict* dict = new PyDict();
        dict->SetItemString("bookmarkID", new PyInt(row.GetInt(0)));
        dict->SetItemString("ownerID", new PyInt(row.GetInt(1)));
        dict->SetItemString("itemID", new PyInt(row.GetInt(2)));
        dict->SetItemString("typeID", new PyInt(row.GetInt(3)));
        dict->SetItemString("memo", new PyString(row.GetText(4)));
        dict->SetItemString("created", new PyLong(row.GetInt64(5)));
        dict->SetItemString("x", new PyFloat(row.GetFloat(6)));
        dict->SetItemString("y", new PyFloat(row.GetFloat(7)));
        dict->SetItemString("z", new PyFloat(row.GetFloat(8)));
        dict->SetItemString("locationID", new PyInt(row.GetInt(9)));
        if (row.IsNull(10)) {
            dict->SetItemString("note", PyStatic.NewNone());
        } else {
            dict->SetItemString("note", new PyInt(row.GetInt(10)));
        }
        dict->SetItemString("creatorID", new PyInt(row.GetInt(11)));
        if (row.IsNull(12) or (row.GetInt(12) == 0)) {
            dict->SetItemString("folderID", PyStatic.NewNone());
        } else {
            dict->SetItemString("folderID", new PyInt(row.GetInt(12)));
        }
        list->AddItem(new PyObject("util.KeyVal", dict));
    }

    return list;
}

Here is the call graph for this function:

PyRep * BookmarkDB::GetBookmarksInFolder

(

uint32

folderID

)

Definition at line 34 of file BookmarkDB.cpp.

References PyList::AddItem(), DBerror::c_str(), DBQueryResult::error, DBResultRow::GetInt(), DBQueryResult::GetRow(), DBResultRow::IsNull(), PyStatic, sDatabase, PyDict::SetItemString(), and sLog.

{
    DBQueryResult res;
    if (!sDatabase.RunQuery(res,
        "SELECT"
        "  bookmarkID,"
        "  folderID"
        " FROM bookmarks"
        " WHERE folderID = %u",
        folderID))
    {
        sLog.Error( "BookmarkDB::GetBMData()", "Failed to query bookmarks for folderID %u: %s.", folderID, res.error.c_str() );
        return nullptr;
    }

    //return DBResultToCRowset(res);
    PyList* list = new PyList();
    DBResultRow row;
    while (res.GetRow(row)) {
        PyDict* dict = new PyDict();
        dict->SetItemString("bookmarkID", new PyInt(row.GetInt(0)));
        if (row.IsNull(1) or (row.GetInt(1) == 0)) {
            dict->SetItemString("folderID", PyStatic.NewNone());
        } else {
            dict->SetItemString("folderID", new PyInt(row.GetInt(1)));
        }
        list->AddItem(new PyObject("util.KeyVal", dict));
    }

    return list;
}

Here is the call graph for this function:

PyRep * BookmarkDB::GetFolders

(

uint32

ownerID

)

Definition at line 134 of file BookmarkDB.cpp.

References PyList::AddItem(), DBerror::c_str(), DBQueryResult::error, DBResultRow::GetInt(), DBQueryResult::GetRow(), DBResultRow::GetText(), sDatabase, PyDict::SetItemString(), and sLog.

                                            {
    DBQueryResult res;
    if (!sDatabase.RunQuery(res,
        "SELECT"
        "  ownerID,"
        "  folderID,"
        "  folderName,"
        "  creatorID"
        " FROM bookmarkFolders"
        " WHERE ownerID = %u",
        ownerID))
    {
        sLog.Error( "BookmarkDB::GetFolders()", "Failed to query bookmarks for owner %u: %s.", ownerID, res.error.c_str() );
        return nullptr;
    }

    //return DBResultToCRowset(res);
    PyList* list = new PyList();
    DBResultRow row;
    while (res.GetRow(row)) {
        PyDict* dict = new PyDict();
        dict->SetItemString("ownerID", new PyInt(row.GetInt(0)));
        dict->SetItemString("folderID", new PyInt(row.GetInt(1)));
        dict->SetItemString("folderName", new PyString(row.GetText(2)));
        dict->SetItemString("creatorID", new PyInt(row.GetInt(3)));
        list->AddItem(new PyObject("util.KeyVal", dict));
    }

    return list;
}

Here is the call graph for this function:

void BookmarkDB::GetVoucherData

(

BmData &

data

)

Definition at line 383 of file BookmarkDB.cpp.

References BmData::bookmarkID, DBerror::c_str(), BmData::created, BmData::creatorID, DBQueryResult::error, BmData::folderID, DBResultRow::GetFloat(), DBResultRow::GetInt64(), DBQueryResult::GetRow(), DBResultRow::GetText(), DBResultRow::GetUInt(), DBResultRow::IsNull(), BmData::itemID, BmData::locationID, BmData::memo, BmData::note, BmData::ownerID, BmData::point, sDatabase, sLog, BmData::typeID, Ga::GaVec3::x, Ga::GaVec3::y, and Ga::GaVec3::z.

                                              {

    DBQueryResult res;
    if (!sDatabase.RunQuery(res,
        "SELECT ownerID, itemID, typeID, memo, created, x, y, z, "
        "locationID, note, creatorID, folderID "
        "FROM bookmarks WHERE bookmarkID = %u", data.bookmarkID))
    {
        sLog.Error( "BookmarkDB::GetVoucherData()", "Failed to query data for Bookmark %u: %s.", data.bookmarkID, res.error.c_str() );
        return;
    }


    DBResultRow row;
    if (res.GetRow(row)) {
        data.ownerID = row.GetUInt(0);
        data.itemID = row.GetUInt(1);
        data.typeID = row.GetUInt(2);
        data.memo = row.GetText(3);
        data.created = row.GetInt64(4);
        data.point.x = row.GetFloat(5);
        data.point.y = row.GetFloat(6);
        data.point.z = row.GetFloat(7);
        data.locationID = row.GetUInt(8);
        if (row.IsNull(9)) {
            data.note = "";
        } else {
            data.note = row.GetText(9);
        }
        data.creatorID = row.GetUInt(10);
        if (row.IsNull(11)){
            data.folderID = 0;
        } else {
            data.folderID = row.GetUInt(11);
        }
    }
}

Here is the call graph for this function:

void BookmarkDB::MoveBookmarkToFolder	(	int32	folderID,
		std::vector< int32 > *	bookmarkList
	)

Definition at line 369 of file BookmarkDB.cpp.

References DBerror::c_str(), and sDatabase.

{
    std::stringstream st;
    std::size_t size = bookmarkList->size();
    for (int8 i=0; i<size; ++i) {
        st << bookmarkList->at(i);
        if (i < (size-1))
            st << ", ";
    }

    DBerror err;
    sDatabase.RunQuery(err, "UPDATE bookmarks SET folderID = %i WHERE bookmarkID IN (%s)", folderID, st.str().c_str());
}

Here is the call graph for this function:

void BookmarkDB::SaveNewBookmark

(

BmData &

data

)

Definition at line 236 of file BookmarkDB.cpp.

References BmData::bookmarkID, DBerror::c_str(), BmData::creatorID, BmData::folderID, GetFileTimeNow(), BmData::itemID, BmData::locationID, BmData::memo, BmData::note, BmData::ownerID, BmData::point, sDatabase, sLog, BmData::typeID, Ga::GaVec3::x, Ga::GaVec3::y, and Ga::GaVec3::z.

{
    std::string eMemo, eNote;
    sDatabase.DoEscapeString(eMemo, data.memo.c_str());
    sDatabase.DoEscapeString(eNote, data.note.c_str());

    DBerror err;
    if (data.folderID > 0) {
        if (!sDatabase.RunQueryLID(err, data.bookmarkID,
            "INSERT INTO bookmarks"
            " (ownerID, itemID, typeID, memo, created, x, y, z, locationID, note, creatorID, folderID)"
            " VALUES (%u, %u, %u, '%s', %f, %f, %f, %f, %u, '%s', %u, %u) ",
            data.ownerID, data.itemID, data.typeID, eMemo.c_str(), GetFileTimeNow(), data.point.x, data.point.y,
            data.point.z, data.locationID, eNote.c_str(), data.creatorID, data.folderID ))
        {
            sLog.Error( "BookmarkDB::SaveNewBookmarkToDatabase(1)", "Error in query, Bookmark content couldn't be saved: %s", err.c_str() );
        }
    } else {
        if (!sDatabase.RunQueryLID(err, data.bookmarkID,
            "INSERT INTO bookmarks"
            " (ownerID, itemID, typeID, memo, created, x, y, z, locationID, note, creatorID)"
            " VALUES (%u, %u, %u, '%s', %f, %f, %f, %f, %u, '%s', %u) ",
            data.ownerID, data.itemID, data.typeID, eMemo.c_str(), GetFileTimeNow(), data.point.x, data.point.y,
            data.point.z, data.locationID, eNote.c_str(), data.creatorID ))
        {
            sLog.Error( "BookmarkDB::SaveNewBookmarkToDatabase(2)", "Error in query, Bookmark content couldn't be saved: %s", err.c_str() );
        }
    }
}

Here is the call graph for this function:

uint32 BookmarkDB::SaveNewFolder	(	std::string	folderName,
		uint32	ownerID
	)

Definition at line 323 of file BookmarkDB.cpp.

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

{
    uint32 folderID(0);
    std::string eName = "";
    sDatabase.DoEscapeString( eName, folderName.c_str());

    DBerror err;
    if (!sDatabase.RunQueryLID(err, folderID, "INSERT INTO bookmarkFolders (folderName, ownerID, creatorID) VALUES ('%s', %u, %u) ",
                            eName.c_str(), ownerID, ownerID ))
    {
        sLog.Error( "BookmarkDB::SaveNewFolderToDatabase()", "Error in query, Folder couldn't be saved: %s", err.c_str() );
        return 0;
    }

    return folderID;
}

Here is the call graph for this function:

bool BookmarkDB::UpdateBookmark	(	uint32	bookmarkID,
		uint32	ownerID,
		std::string	memo,
		std::string	note,
		uint32	folderID = 0
	)

Definition at line 307 of file BookmarkDB.cpp.

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

{
    std::string memo_fixed = "";
    sDatabase.DoEscapeString(memo_fixed, memo.c_str());

    DBerror err;
    if (!sDatabase.RunQuery(err, "UPDATE bookmarks SET memo = '%s', note = '%s', folderID = %u WHERE bookmarkID = %u AND ownerID = %u",
        memo_fixed.c_str(), note.c_str(), folderID, bookmarkID, ownerID))
    {
        sLog.Error( "BookmarkDB::UpdateBookmarkInDatabase()", "Error in query: %s", err.c_str() );
        return false;
    }

    return true;
}

Here is the call graph for this function:

bool BookmarkDB::UpdateFolder	(	int32	folderID,
		std::string	folderName
	)

Definition at line 340 of file BookmarkDB.cpp.

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

{
    std::string eName = "";
    sDatabase.DoEscapeString( eName, folderName.c_str());

    DBerror err;
    if (!sDatabase.RunQuery(err, "UPDATE bookmarkFolders SET folderName = '%s' WHERE folderID = %u",
                               eName.c_str(), folderID))
    {
        sLog.Error( "BookmarkDB::UpdateFolder()", "Error in query, Folder couldn't be saved: %s", err.c_str() );
        return false;
    }

    return true;
}

Here is the call graph for this function:

---

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

• /backups/local/src/eve/EvEmu_Crucible/src/eve-server/system/BookmarkDB.h
• /backups/local/src/eve/EvEmu_Crucible/src/eve-server/system/BookmarkDB.cpp