void SqlCustDataSource::populateQuery(string query, Sqf::Parameters& params, CustomDataQueue& queue)
{
	for (int i = 0; i < params.size(); i++)
	{
		query = boost::algorithm::replace_nth_copy(query, "?", i, Sqf::GetStringAny(params.at(i)));
	}

	auto custRes = getDB()->queryParams(query.c_str());

	while (custRes->fetchRow())
	{
		Sqf::Parameters custParams;

		for (int i = 0; i < custRes->numFields(); i++)
		{
			int val = custRes->at(i).getInt32();

			if (val == 0 && custRes->at(i).getString() != "0")
			{
				custParams.push_back(custRes->at(i).getString());
			}
			else
			{
				custParams.push_back(val);
			}
		}

		queue.push(custParams);
	}
}
Ejemplo n.º 2
0
Sqf::Value SqlCharDataSource::fetchObjectId( Int64 objectIdent )
{
	Sqf::Parameters retVal;
	//get details from db
	auto charDetRes = getDB()->queryParams(
		"SELECT `ObjectID` FROM `Object_DATA` WHERE `ObjectUID`=%lld", objectIdent);

	if (charDetRes && charDetRes->fetchRow())
	{
		int objectid = 0;
		//get stuff from row	
		objectid = charDetRes->at(0).getInt32();
	
		if(objectid != 0)
		{
			retVal.push_back(string("PASS"));
			retVal.push_back(lexical_cast<string>(objectid));
		}
		else 
		{
			retVal.push_back(string("ERROR"));
		}
	}
	else
	{
		retVal.push_back(string("ERROR"));
	}

	return retVal;
}
void Database::populateHouses(std::queue<Sqf::Parameters>& queue)
{
	try
	{
		Poco::Data::Statement stmt((*activeSession));
		stmt << "select `player_id`, `unique_id`, `building_id`, `building_name`, `worldspace`, `lock`, `explosive`, `reinforcement` from `buildings` where `instance_id` = ?", use(serverID), now;
		Poco::Data::RecordSet rs(stmt);

		if (rs.columnCount() >= 1)
		{
			bool more = rs.moveFirst();
			while (more)
			{
				Sqf::Parameters objParams;
				objParams.push_back(string("HOUSE"));

				string playerID = rs[0].convert<std::string>();
				objParams.push_back(playerID);

				string uniqueID = rs[1].convert<std::string>();
				objParams.push_back(uniqueID);

				string buildingID = rs[2].convert<std::string>();
				objParams.push_back(buildingID);

				string buildingName = rs[3].convert<std::string>();
				objParams.push_back(buildingName);

				try
				{
					string worldSpace = rs[4].convert<std::string>();
					Sqf::Value worldSpaceArray = lexical_cast<Sqf::Value>(worldSpace);
					objParams.push_back(worldSpaceArray);
				}
				catch (boost::bad_lexical_cast)
				{
					console->log("Invalid Worldspace for House: " + buildingID);
				}

				string lock = rs[5].convert<std::string>();
				objParams.push_back(lock);

				bool explosive = rs[6].convert<bool>();
				objParams.push_back(explosive);

				int reinforcement = rs[7].convert<int>();
				objParams.push_back(reinforcement);

				queue.push(objParams);

				more = rs.moveNext();
			};
		};
	}
	catch (std::exception& ex)
	{
		std::cout << ex.what() << std::endl;
	};
};
void SqlAntiHackDataSource::fetchAntiHackWhitelist( AntiHackQueue& queue )
{
	
	auto antiHackRes = getDB()->queryParams(
			"SELECT antihack_whitelist.playerID FROM antihack_whitelist");
	
	if (!antiHackRes)
	{
		_logger.error("Failed to fetch whitelist from database");
		return;
	}
	string banId;
	while (antiHackRes->fetchRow())
	{
		Sqf::Parameters ahParams;
		auto row = antiHackRes->fields();
		//ahParams.push_back(string("BANS"));

		try
		{
			banId = row[0].getString(); //objectId should be stringified 
			ahParams.push_back(banId);
			_logger.information("Pushed whitelists (" + lexical_cast<string>(banId) + ")");
		}
			
		catch (const bad_lexical_cast&)
		{
			_logger.error("Skipping whitelist " + lexical_cast<string>(banId) + " load because of invalid data in db");
			continue;
		}
		queue.push(ahParams);
	}
}
void SqlAntiHackDataSource::fetchAntiHackAdmins(  int serverId, int adminlevel, AntiHackQueue& queue )
{

	auto antiHackRes = getDB()->queryParams(
			"SELECT antihack_admins.playerID FROM antihack_admins WHERE antihack_admins.instance = %d and antihack_admins.adminlevel = %d", serverId, adminlevel);
	
	if (!antiHackRes)
	{
		_logger.error("Failed to fetch admins from database");
		return;
	}
	string adminId;
	while (antiHackRes->fetchRow())
	{
		Sqf::Parameters ahParams;
		auto row = antiHackRes->fields();

		try
		{
			adminId = row[0].getString(); //objectId should be stringified 
			ahParams.push_back(adminId);
			_logger.information("Pushed Admin (" + lexical_cast<string>(adminId) + ")");
		}
			
		catch (const bad_lexical_cast&)
		{
			_logger.error("Skipping Admin " + lexical_cast<string>(adminId) + " load because of invalid data in db");
			continue;
		}
		queue.push(ahParams);
	}
	
}
void Database::populateTraps(std::queue<Sqf::Parameters>& queue)
{
	try
	{
		Poco::Data::Statement stmt((*activeSession));
		stmt << "select `unique_id`, `classname`, `worldspace` from `instance_traps` where `instance_id` = ?", use(serverID);
		stmt.execute();
		Poco::Data::RecordSet rs(stmt);

		if (rs.columnCount() >= 1)
		{
			bool more = rs.moveFirst();
			while (more)
			{
				Sqf::Parameters objParams;
				objParams.push_back(string("TRAP"));

				string uniqueID = rs[0].convert<std::string>();
				objParams.push_back(uniqueID);

				string classname = rs[1].convert<std::string>();
				objParams.push_back(classname);

				try
				{
					string worldSpace = rs[2].convert<std::string>();
					Sqf::Value worldSpaceArray = lexical_cast<Sqf::Value>(worldSpace);
					objParams.push_back(worldSpaceArray);
				}
				catch (boost::bad_lexical_cast)
				{
					console->log("Invalid Worldspace for Trap: " + uniqueID);
				}

				queue.push(objParams);

				more = rs.moveNext();
			};
		};
	}
	catch (std::exception& ex)
	{
		std::cout << ex.what() << std::endl;
	};
};
Sqf::Value Database::killCharacter(int characterID)
{
	//Update Stats Profile
	{
		Poco::Data::Statement stmt((*activeSession));
		stmt << "update `profile` p inner join `survivor` s on s.`unique_id` = p.`unique_id` set p.`survival_attempts` = p.`survival_attempts` + 1, p.`total_survivor_kills` = p.`total_survivor_kills` + s.`survivor_kills`, p.`total_zombie_kills` = p.`total_zombie_kills` + s.`zombie_kills`, p.`total_headshots` = p.`total_headshots` + s.`headshots`, p.`total_survival_time` = p.`total_survival_time` + s.`survival_time` where s.`id` = ? and s.`is_dead` = 0", use(characterID), now;
	}

	//Kill Character
	Poco::Data::Statement stmt((*activeSession));
	stmt << "update `survivor` set `is_dead` = 1 where `id` = ?", use(characterID), now;

	//Return Success
	Sqf::Parameters retVal;
	retVal.push_back(string("PASS"));
	retVal.push_back(lexical_cast<string>(characterID));
	return retVal;

};
Ejemplo n.º 8
0
Sqf::Parameters HiveExtApp::booleanReturn( bool isGood )
{
	Sqf::Parameters retVal;
	string retStatus = "PASS";
	if (!isGood)
		retStatus = "ERROR";

	retVal.push_back(retStatus);
	return retVal;
}
Ejemplo n.º 9
0
Sqf::Value HiveExtApp::loadTraderDetails( Sqf::Parameters params )
{
	if (_srvObjects.empty())
	{
		int characterId = Sqf::GetIntAny(params.at(0));

		_objData->populateTraderObjects(characterId, _srvObjects);

		Sqf::Parameters retVal;
		retVal.push_back(string("ObjectStreamStart"));
		retVal.push_back(static_cast<int>(_srvObjects.size()));
		return retVal;
	}
	else
	{
		Sqf::Parameters retVal = _srvObjects.front();
		_srvObjects.pop();

		return retVal;
	}
}
Ejemplo n.º 10
0
void SqlObjDataSource::populateTraderObjects( int characterId, ServerObjectsQueue& queue )
{	
	
	auto worldObjsRes = getDB()->queryParams("SELECT `id`, `item`, `qty`, `buy`, `sell`, `order`, `tid`, `afile` FROM `Traders_DATA` WHERE `tid`=%d", characterId);

	while (worldObjsRes->fetchRow())
	{
		auto row = worldObjsRes->fields();

		Sqf::Parameters objParams;
		objParams.push_back(row[0].getInt32());
		
		// `item` varchar(255) NOT NULL COMMENT '[Class Name,1 = CfgMagazines | 2 = Vehicle | 3 = Weapon]',
		// `qty` int(8) NOT NULL COMMENT 'amount in stock available to buy',
		// `buy`  varchar(255) NOT NULL COMMENT '[[Qty,Class,Type],]',
		// `sell`  varchar(255) NOT NULL COMMENT '[[Qty,Class,Type],]',
		// `order` int(2) NOT NULL DEFAULT '0' COMMENT '# sort order for addAction menu',
		// `tid` int(8) NOT NULL COMMENT 'Trader Menu ID',
		// `afile` varchar(64) NOT NULL DEFAULT 'trade_items',

		//get stuff from row
		objParams.push_back(lexical_cast<Sqf::Value>(row[1].getString()));  // item
		objParams.push_back(row[2].getInt32()); // qty
		objParams.push_back(lexical_cast<Sqf::Value>(row[3].getString()));  // buy
		objParams.push_back(lexical_cast<Sqf::Value>(row[4].getString()));  // sell
		objParams.push_back(row[5].getInt32()); // order
		objParams.push_back(row[6].getInt32()); // tid
		objParams.push_back(row[7].getString()); // afile

		queue.push(objParams);
	}
}
Ejemplo n.º 11
0
Sqf::Value HiveExtApp::streamObjects( Sqf::Parameters params )
{
	if (_srvObjects.empty())
	{
		int serverId = boost::get<int>(params.at(0));
		setServerId(serverId);

		_objData->populateObjects(getServerId(), _srvObjects);

		Sqf::Parameters retVal;
		retVal.push_back(string("ObjectStreamStart"));
		retVal.push_back(static_cast<int>(_srvObjects.size()));
		return retVal;
	}
	else
	{
		Sqf::Parameters retVal = _srvObjects.front();
		_srvObjects.pop();

		return retVal;
	}
}
Ejemplo n.º 12
0
Sqf::Value HiveExtApp::streamCustom( Sqf::Parameters params )
{
	if (_custQueue.empty())
	{
		string query = Sqf::GetStringAny(params.at(0));
		//if (!Sqf::IsNull(params.at(1)))
		Sqf::Parameters rawParams = boost::get<Sqf::Parameters>(params.at(1));

		_custData->populateQuery(query, rawParams, _custQueue);

		Sqf::Parameters retVal;
		retVal.push_back(string("CustomStreamStart"));
		retVal.push_back(static_cast<int>(_custQueue.size()));
		return retVal;
	}
	else
	{
		Sqf::Parameters retVal = _custQueue.front();
		_custQueue.pop();

		return retVal;
	}
}
Ejemplo n.º 13
0
void Database::populateHackData(int requestID, std::queue<Sqf::Parameters>& queue)
{
	Poco::Data::Statement stmt((*activeSession));
	switch (requestID)
	{
		//Weapons
		case 1:
		{
			  stmt << "select `weapon` from `hack_weapons` where 1";
			  break;
		}
		//Magazines
		case 2:
		{
			  stmt << "select `magazine` from `hack_magazines` where 1";
			  break;
		}
		//Vars
		case 3:
		{
			  stmt << "select `var` from `hack_vars` where 1";
			  break;
		}
		//Scripts
		case 4:
		{
			  stmt << "select `script` from `hack_scripts` where 1";
			  break;
		}
	}

	stmt.execute();
	Poco::Data::RecordSet rs(stmt);
	if (rs.columnCount() >= 1)
	{
		bool more = rs.moveFirst();
		while (more)
		{
			Sqf::Parameters objParams;

			string str = rs[0].convert<std::string>();
			objParams.push_back(str);

			queue.push(objParams);

			more = rs.moveNext();
		};
	};
};
Ejemplo n.º 14
0
Sqf::Value HiveExtApp::getDateTime( Sqf::Parameters params )
{
	namespace pt=boost::posix_time;
	pt::ptime now = pt::second_clock::universal_time() + _timeOffset;

	Sqf::Parameters retVal;
	retVal.push_back(string("PASS"));
	{
		Sqf::Parameters dateTime;
		dateTime.push_back(static_cast<int>(now.date().year()));
		dateTime.push_back(static_cast<int>(now.date().month()));
		dateTime.push_back(static_cast<int>(now.date().day()));
		dateTime.push_back(static_cast<int>(now.time_of_day().hours()));
		dateTime.push_back(static_cast<int>(now.time_of_day().minutes()));
		retVal.push_back(dateTime);
	}
	return retVal;
}
Ejemplo n.º 15
0
Sqf::Value SqlCharDataSource::fetchCharacterInitial( string playerId, int serverId, const string& playerName, int characterSlot )
{
	bool newPlayer = false;
	//make sure player exists in db
	{
		auto playerRes(getDB()->queryParams(("SELECT `PlayerName`, `PlayerSex` FROM `Player_DATA` WHERE `" + _idFieldName + "`='%s'").c_str(), getDB()->escape(playerId).c_str()));
		if (playerRes && playerRes->fetchRow())
		{
			newPlayer = false;
			//update player name if not current
			if (playerRes->at(0).getString() != playerName)
			{
				auto stmt = getDB()->makeStatement(_stmtChangePlayerName, "UPDATE `Player_DATA` SET `PlayerName`=? WHERE `" + _idFieldName + "`=?");
				stmt->addString(playerName);
				stmt->addString(playerId);
				bool exRes = stmt->execute();
				poco_assert(exRes == true);
				_logger.information("Changed name of player " + playerId + " from '" + playerRes->at(0).getString() + "' to '" + playerName + "'");
			}
		}
		else
		{
			newPlayer = true;
			//insert new player into db
			auto stmt = getDB()->makeStatement(_stmtInsertPlayer, "INSERT INTO `Player_DATA` (`" + _idFieldName + "`, `PlayerName`) VALUES (?, ?)");
			stmt->addString(playerId);
			stmt->addString(playerName);
			bool exRes = stmt->execute();
			poco_assert(exRes == true);
			_logger.information("Created a new player " + playerId + " named '" + playerName + "'");
		}
	}

	//get characters from db
	auto charsRes = getDB()->queryParams(
		("SELECT `CharacterID`, `" + _wsFieldName + "`, `Inventory`, `Backpack`, "
		"TIMESTAMPDIFF(MINUTE,`Datestamp`,`LastLogin`) as `SurvivalTime`, "
		"TIMESTAMPDIFF(MINUTE,`LastAte`,NOW()) as `MinsLastAte`, "
		"TIMESTAMPDIFF(MINUTE,`LastDrank`,NOW()) as `MinsLastDrank`, "
		"`Model` FROM `Character_DATA` WHERE `" + _idFieldName + "` = '%s' AND `Slot` = %d AND `Alive` = 1 ORDER BY `CharacterID` DESC LIMIT 1").c_str(), getDB()->escape(playerId).c_str(), characterSlot);
	int infected = 0;
	bool newChar = false; //not a new char
	int characterId = -1; //invalid charid
	Sqf::Value worldSpace = Sqf::Parameters(); //empty worldspace
	Sqf::Value inventory = lexical_cast<Sqf::Value>("[]"); //empty inventory
	Sqf::Value backpack = lexical_cast<Sqf::Value>("[]"); //empty backpack
	Sqf::Value survival = lexical_cast<Sqf::Value>("[0,0,0]"); //0 mins alive, 0 mins since last ate, 0 mins since last drank
	string model = ""; //empty models will be defaulted by scripts
	if (charsRes && charsRes->fetchRow())
	{
		newChar = false;
		characterId = charsRes->at(0).getInt32();
		try
		{
			worldSpace = lexical_cast<Sqf::Value>(charsRes->at(1).getString());
		}
		catch (bad_lexical_cast)
		{
			_logger.warning("Invalid Worldspace for CharacterID(" + lexical_cast<string>(characterId)+"): " + charsRes->at(1).getString());
		}
		if (!charsRes->at(2).isNull()) //inventory can be null
		{
			try
			{
				inventory = lexical_cast<Sqf::Value>(charsRes->at(2).getString());
				try { SanitiseInv(boost::get<Sqf::Parameters>(inventory)); }
				catch (const boost::bad_get&) {}
			}
			catch (bad_lexical_cast)
			{
				_logger.warning("Invalid Inventory for CharacterID(" + lexical_cast<string>(characterId)+"): " + charsRes->at(2).getString());
			}
		}
		if (!charsRes->at(3).isNull()) //backpack can be null
		{
			try
			{
				backpack = lexical_cast<Sqf::Value>(charsRes->at(3).getString());
			}
			catch (bad_lexical_cast)
			{
				_logger.warning("Invalid Backpack for CharacterID(" + lexical_cast<string>(characterId)+"): " + charsRes->at(3).getString());
			}
		}
		//set survival info
		{
			Sqf::Parameters& survivalArr = boost::get<Sqf::Parameters>(survival);
			survivalArr[0] = charsRes->at(4).getInt32();
			survivalArr[1] = charsRes->at(5).getInt32();
			survivalArr[2] = charsRes->at(6).getInt32();
		}
		try
		{
			model = boost::get<string>(lexical_cast<Sqf::Value>(charsRes->at(7).getString()));
		}
		catch (...)
		{
			model = charsRes->at(7).getString();
		}

		//update last login
		{
			//update last character login
			auto stmt = getDB()->makeStatement(_stmtUpdateCharacterLastLogin, "UPDATE `Character_DATA` SET `LastLogin` = CURRENT_TIMESTAMP WHERE `CharacterID` = ?");
			stmt->addInt32(characterId);
			bool exRes = stmt->execute();
			poco_assert(exRes == true);
		}
	}
	else //inserting new character
	{
		newChar = true;

		int generation = 1;
		int humanity = 2500;
		//try getting previous character info
		{
			auto prevCharRes = getDB()->queryParams(
				("SELECT `Generation`, `Humanity`, `Model`, `Infected` FROM `Character_DATA` WHERE `" + _idFieldName + "` = '%s' AND `Slot` = %d AND `Alive` = 0 ORDER BY `CharacterID` DESC LIMIT 1").c_str(), getDB()->escape(playerId).c_str(), characterSlot);
			if (prevCharRes && prevCharRes->fetchRow())
			{
				generation = prevCharRes->at(0).getInt32();
				generation++; //apparently this was the correct behaviour all along

				humanity = prevCharRes->at(1).getInt32();
				try
				{
					model = boost::get<string>(lexical_cast<Sqf::Value>(prevCharRes->at(2).getString()));
				}
				catch (...)
				{
					model = prevCharRes->at(2).getString();
				}
				infected = prevCharRes->at(3).getInt32();


			}
		}
		Sqf::Value medical = Sqf::Parameters(); //script will fill this in if empty
		//insert new char into db
		{
			auto stmt = getDB()->makeStatement(_stmtInsertNewCharacter,
				"INSERT INTO `Character_DATA` (`" + _idFieldName + "`, `Slot`, `InstanceID`, `" + _wsFieldName + "`, `Inventory`, `Backpack`, `Medical`, `Generation`, `Datestamp`, `LastLogin`, `LastAte`, `LastDrank`, `Humanity`) "
				"VALUES (?, ?, ?, ?, ?, ?, ?, ?, CURRENT_TIMESTAMP, CURRENT_TIMESTAMP, CURRENT_TIMESTAMP, CURRENT_TIMESTAMP, ?)");
			stmt->addString(playerId);
			stmt->addUInt8(characterSlot);
			stmt->addInt32(serverId);
			stmt->addString(lexical_cast<string>(worldSpace));
			stmt->addString(lexical_cast<string>(inventory));
			stmt->addString(lexical_cast<string>(backpack));
			stmt->addString(lexical_cast<string>(medical));
			stmt->addInt32(generation);
			stmt->addInt32(humanity);
			bool exRes = stmt->directExecute(); //need sync as we will be getting the CharacterID right after this
			if (exRes == false)
			{
				_logger.error("Error creating character for playerId " + playerId);
				Sqf::Parameters retVal;
				retVal.push_back(string("ERROR"));
				return retVal;
			}
		}
		//get the new character's id
		{
			auto newCharRes = getDB()->queryParams(
				("SELECT `CharacterID` FROM `Character_DATA` WHERE `" + _idFieldName + "` = '%s' AND `Alive` = 1 ORDER BY `CharacterID` DESC LIMIT 1").c_str(), getDB()->escape(playerId).c_str());
			if (!newCharRes || !newCharRes->fetchRow())
			{
				_logger.error("Error fetching created character for playerId " + playerId);
				Sqf::Parameters retVal;
				retVal.push_back(string("ERROR"));
				return retVal;
			}
			characterId = newCharRes->at(0).getInt32();
		}
		_logger.information("Created a new character " + lexical_cast<string>(characterId)+" for player '" + playerName + "' (" + playerId + ")");
	}

	Sqf::Parameters retVal;
	retVal.push_back(string("PASS"));
	retVal.push_back(newPlayer);
	retVal.push_back(lexical_cast<string>(characterId));
	if (!newChar)
	{
		retVal.push_back(worldSpace);
		retVal.push_back(inventory);
		retVal.push_back(backpack);
		retVal.push_back(survival);
	}
	else {
		retVal.push_back(infected);
	}
	retVal.push_back(model);
	//hive interface version
	retVal.push_back(0.96f);


	return retVal;
}
Ejemplo n.º 16
0
void SqlObjDataSource::populateObjects( int serverId, ServerObjectsQueue& queue )
{
	if (_cleanupPlacedDays >= 0)
	{
		string commonSql = "FROM `"+_objTableName+"` WHERE `Instance` = " + lexical_cast<string>(serverId) +
			" AND `ObjectUID` <> 0 AND `CharacterID` <> 0" +
			" AND `Datestamp` < DATE_SUB(CURRENT_TIMESTAMP, INTERVAL "+lexical_cast<string>(_cleanupPlacedDays)+" DAY)" +
			" AND ( (`Inventory` IS NULL) OR (`Inventory` = '[]') )";

		int numCleaned = 0;
		{
			auto numObjsToClean = getDB()->query(("SELECT COUNT(*) "+commonSql).c_str());
			if (numObjsToClean && numObjsToClean->fetchRow())
				numCleaned = numObjsToClean->at(0).getInt32();
		}
		if (numCleaned > 0)
		{
			_logger.information("Removing " + lexical_cast<string>(numCleaned) + " empty placed objects older than " + lexical_cast<string>(_cleanupPlacedDays) + " days");

			auto stmt = getDB()->makeStatement(_stmtDeleteOldObject, "DELETE "+commonSql);
			if (!stmt->directExecute())
				_logger.error("Error executing placed objects cleanup statement");
		}
	}
	
	auto worldObjsRes = getDB()->queryParams("SELECT `ObjectID`, `Classname`, `CharacterID`, `Worldspace`, `Inventory`, `Hitpoints`, `Fuel`, `Damage` FROM `%s` WHERE `Instance`=%d AND `Classname` IS NOT NULL", _objTableName.c_str(), serverId);
	if (!worldObjsRes)
	{
		_logger.error("Failed to fetch objects from database");
		return;
	}
	while (worldObjsRes->fetchRow())
	{
		auto row = worldObjsRes->fields();

		Sqf::Parameters objParams;
		objParams.push_back(string("OBJ"));

		int objectId = row[0].getInt32();
		objParams.push_back(lexical_cast<string>(objectId)); //objectId should be stringified
		try
		{
			objParams.push_back(row[1].getString()); //classname
			objParams.push_back(lexical_cast<string>(row[2].getInt32())); //ownerId should be stringified

			Sqf::Value worldSpace = lexical_cast<Sqf::Value>(row[3].getString());
			if (_vehicleOOBReset && row[2].getInt32() == 0) // no owner = vehicle
			{
				PositionInfo posInfo = FixOOBWorldspace(worldSpace);
				if (posInfo.is_initialized())
					_logger.information("Reset ObjectID " + lexical_cast<string>(objectId) + " (" + row[1].getString() + ") from position " + lexical_cast<string>(*posInfo));

			}			
			objParams.push_back(worldSpace);

			//Inventory can be NULL
			{
				string invStr = "[]";
				if (!row[4].isNull())
					invStr = row[4].getString();

				objParams.push_back(lexical_cast<Sqf::Value>(invStr));
			}	
			objParams.push_back(lexical_cast<Sqf::Value>(row[5].getCStr()));
			objParams.push_back(row[6].getDouble());
			objParams.push_back(row[7].getDouble());
		}
		catch (const bad_lexical_cast&)
		{
			_logger.error("Skipping ObjectID " + lexical_cast<string>(objectId) + " load because of invalid data in db");
			continue;
		}

		queue.push(objParams);
	}
}
Ejemplo n.º 17
0
Sqf::Value SqlCharDataSource::fetchCharacters( string playerId )
{
	//get characters from db (dead or alive)
	auto charsRes = getDB()->queryParams(
		("SELECT `CharacterID`, `Slot`, `" + _wsFieldName + "`, `Alive`, `Generation`, `Humanity`, `KillsZ`, `HeadshotsZ`, `KillsH`, `KillsB`, `DistanceFoot`, `Model`, `Infected`, "
		"TIMESTAMPDIFF(MINUTE,`LastLogin`,NOW()) as `LastLoginDiff`, "
		"TIMESTAMPDIFF(MINUTE,`Datestamp`,`LastLogin`) as `SurvivalTime` "
		"FROM `Character_DATA` `cd1` "
		"INNER JOIN (SELECT MAX(`CharacterID`) `MaxCharacterID` FROM `Character_DATA` WHERE `" + _idFieldName + "` = '%s' GROUP BY `Slot`) `cd2` "
		"ON `cd1`.`CharacterID` = `cd2`.`MaxCharacterID` "
		"ORDER BY `Slot`").c_str(), getDB()->escape(playerId).c_str());

	/*
	//get characters from db
	auto charsRes = getDB()->queryParams(
	("SELECT `CharacterID`, `Slot`, `"+_wsFieldName+"`, `Generation`, `Humanity`, `KillsZ`, `HeadshotsZ`, `KillsH`, `KillsB`, `DistanceFoot`, `Model`, `Infected`, "
	"TIMESTAMPDIFF(MINUTE,`LastLogin`,NOW()) as `LastLoginDiff`, "
	"TIMESTAMPDIFF(MINUTE,`Datestamp`,`LastLogin`) as `SurvivalTime` "
	"FROM `Character_DATA` "
	"WHERE `"+_idFieldName+"` = '%s' AND `Alive` = 1 "
	"ORDER BY `Slot`").c_str(), getDB()->escape(playerId).c_str());
	*/

	Sqf::Parameters retVal;
	Sqf::Parameters charsData;
	if (charsRes) {
		retVal.push_back(string("PASS"));
		while (charsRes->fetchRow())
		{
			int characterId = charsRes->at(0).getUInt32();
			int slot = charsRes->at(1).getUInt8();
			Sqf::Value worldSpace = Sqf::Parameters(); //empty worldspace
			try
			{
				worldSpace = lexical_cast<Sqf::Value>(charsRes->at(2).getString());
			}
			catch (bad_lexical_cast)
			{
				_logger.warning("Invalid Worldspace for CharacterID(" + lexical_cast<string>(characterId)+"): " + charsRes->at(2).getString());
			}
			int alive = charsRes->at(3).getUInt8();
			int generation = charsRes->at(4).getUInt32();
			int humanity = charsRes->at(5).getInt32();
			int killsZ = charsRes->at(6).getUInt32();
			int headshotsZ = charsRes->at(7).getUInt32();
			int killsH = charsRes->at(8).getUInt32();
			int killsB = charsRes->at(9).getUInt32();
			int distanceFoot = charsRes->at(10).getInt32();
			string model = "";
			try
			{
				model = boost::get<string>(lexical_cast<Sqf::Value>(charsRes->at(11).getString()));
			}
			catch (...)
			{
				model = charsRes->at(11).getString();
			}
			int infected = charsRes->at(12).getInt8();
			int lastLoginDiff = charsRes->at(13).getInt32();
			int survivalTime = charsRes->at(14).getInt32();

			Sqf::Parameters stats;
			stats.push_back(killsZ);
			stats.push_back(headshotsZ);
			stats.push_back(killsH);
			stats.push_back(killsB);

			Sqf::Parameters charData;
			charData.push_back(lexical_cast<string>(characterId));
			charData.push_back(slot);
			charData.push_back(worldSpace);
			charData.push_back(alive);
			charData.push_back(generation);
			charData.push_back(humanity);
			charData.push_back(stats);
			charData.push_back(distanceFoot);
			charData.push_back(model);
			charData.push_back(infected);
			charData.push_back(lastLoginDiff);
			charData.push_back(survivalTime);

			charsData.push_back(charData);
		}
	}
	else
	{
		retVal.push_back(string("ERROR"));
	}

	retVal.push_back(charsData);
	//hive interface version
	retVal.push_back(0.96f);

	return retVal;
}
Ejemplo n.º 18
0
Sqf::Value SqlCharDataSource::fetchCharacterDetails( int characterId )
{
	Sqf::Parameters retVal;
	//get details from db
	auto charDetRes = getDB()->queryParams(
		"SELECT `%s`, `Medical`, `Generation`, `KillsZ`, `HeadshotsZ`, `KillsH`, `KillsB`, `CurrentState`, `Humanity`, `InstanceID` "
		"FROM `Character_DATA` WHERE `CharacterID`=%d", _wsFieldName.c_str(), characterId);

	if (charDetRes && charDetRes->fetchRow())
	{
		Sqf::Value worldSpace = Sqf::Parameters(); //empty worldspace
		Sqf::Value medical = Sqf::Parameters(); //script will fill this in if empty
		int generation = 1;
		Sqf::Value stats = lexical_cast<Sqf::Value>("[0,0,0,0]"); //killsZ, headZ, killsH, killsB
		Sqf::Value currentState = Sqf::Parameters(); //empty state (aiming, etc)
		int humanity = 2500;
		int instance = 1;
		//get stuff from row
		{
			try
			{
				worldSpace = lexical_cast<Sqf::Value>(charDetRes->at(0).getString());
			}
			catch(bad_lexical_cast)
			{
				_logger.warning("Invalid Worldspace (detail load) for CharacterID("+lexical_cast<string>(characterId)+"): "+charDetRes->at(0).getString());
			}
			try
			{
				medical = lexical_cast<Sqf::Value>(charDetRes->at(1).getString());
			}
			catch(bad_lexical_cast)
			{
				_logger.warning("Invalid Medical (detail load) for CharacterID("+lexical_cast<string>(characterId)+"): "+charDetRes->at(1).getString());
			}
			generation = charDetRes->at(2).getInt32();
			//set stats
			{
				Sqf::Parameters& statsArr = boost::get<Sqf::Parameters>(stats);
				statsArr[0] = charDetRes->at(3).getInt32();
				statsArr[1] = charDetRes->at(4).getInt32();
				statsArr[2] = charDetRes->at(5).getInt32();
				statsArr[3] = charDetRes->at(6).getInt32();
			}
			try
			{
				currentState = lexical_cast<Sqf::Value>(charDetRes->at(7).getString());
			}
			catch(bad_lexical_cast)
			{
				_logger.warning("Invalid CurrentState (detail load) for CharacterID("+lexical_cast<string>(characterId)+"): "+charDetRes->at(7).getString());
			}
			humanity = charDetRes->at(8).getInt32();
			instance = charDetRes->at(9).getInt32();
		}

		retVal.push_back(string("PASS"));
		retVal.push_back(medical);
		retVal.push_back(stats);
		retVal.push_back(currentState);
		retVal.push_back(worldSpace);
		retVal.push_back(humanity);
		retVal.push_back(instance);
	}
	else
	{
		retVal.push_back(string("ERROR"));
	}

	return retVal;
}
Ejemplo n.º 19
0
Sqf::Value SqlCharDataSource::fetchTraderObject( int traderObjectId, int action)
{
	Sqf::Parameters retVal;
	//get details from db

	if(action == 0) { 
		auto charDetRes = getDB()->queryParams(
		"SELECT `qty` FROM `Traders_DATA` WHERE `id`=%d", traderObjectId);

		if (charDetRes && charDetRes->fetchRow())
		{
			int qty = 0;
			//get stuff from row	
			qty = charDetRes->at(0).getInt32();
	
			if(qty != 0)
			{
		
				auto stmt = getDB()->makeStatement(_stmtTradeObjectBuy, 
					"UPDATE `Traders_DATA` SET qty = qty - 1 WHERE `id`= ?");
				stmt->addInt32(traderObjectId);

				bool exRes = stmt->directExecute();
				if(exRes == true)
				{
					retVal.push_back(string("PASS"));
					return retVal;
				}
				else 
				{
					retVal.push_back(string("ERROR"));
					return retVal;
				}	
			

			}
			else 
			{
				retVal.push_back(string("ERROR"));
				return retVal;
			}
		}
		else
		{
			retVal.push_back(string("ERROR"));
			return retVal;
		}
	} else {
	
		
		auto stmt = getDB()->makeStatement(_stmtTradeObjectSell, 
			"UPDATE `Traders_DATA` SET qty = qty + 1 WHERE `id`= ?");
		stmt->addInt32(traderObjectId);

		bool exRes = stmt->directExecute(); 
		if(exRes == true)
		{
			retVal.push_back(string("PASS"));
			return retVal;
		}
		else 
		{
			retVal.push_back(string("ERROR"));
			return retVal;
		}	

	}

}
Ejemplo n.º 20
0
Sqf::Value Database::fetchCharacterDetails(int characterID)
{
	try
	{
		Poco::Data::Statement stmt((*activeSession));
		stmt << "select s.`worldspace`, s.`medical`, s.`zombie_kills`, s.`headshots`, s.`survivor_kills`, s.`state`, s.`class`, p.`ranger`, p.`outlaw`, p.`hunter`, p.`nomad`, p.`survivalist`, p.`engineer`, p.`undead`, p.`total_survivor_kills`, p.`clan` " <<
			"from `survivor` s join `profile` p on s.`unique_id` = p.`unique_id` where s.`id` = ?", use(characterID), now;

		Sqf::Parameters retVal;

		Poco::Data::Statement updateInstance((*activeSession));
		updateInstance << "update `survivor` set `lastserver` = ?, `activeserver` = ? where `id` = ?", use(serverID), use(serverID), use(characterID);
		updateInstance.executeAsync();

		Poco::Data::RecordSet rs(stmt);
		if (rs.rowCount() > 0 && rs.columnCount() >= 1)
		{
			Sqf::Value worldSpace = Sqf::Parameters(); //empty worldspace
			Sqf::Value medical = Sqf::Parameters(); //script will fill this in if empty
			Sqf::Value stats = lexical_cast<Sqf::Value>("[0,0,0]"); //killsZ, headZ, killsH
			Sqf::Value currentState = Sqf::Parameters(); //empty state (aiming, etc)

			int myClass = 0;
			int ranger = 0;
			int outlaw = 0;
			int hunter = 0;
			int nomad = 0;
			int survivalist = 0;
			int engineer = 0;
			int undead = 0;
			int humanKills = 0;
			string clan = "0";

			//Get Worldspace
			try
			{
				string ws = rs[0].convert<std::string>();
				worldSpace = lexical_cast<Sqf::Value>(ws);
			}
			catch (boost::bad_lexical_cast)
			{
				console->log("Invalid Worldspace for Character: " + characterID);
			}


			//Get Medical
			try
			{
				string med = rs[1].convert<std::string>();
				medical = lexical_cast<Sqf::Value>(med);
			}
			catch (boost::bad_lexical_cast)
			{
				console->log("Invalid Medical for Character: " + characterID);
			}

			//Get Stats
			try
			{
				Sqf::Parameters& statsArr = boost::get<Sqf::Parameters>(stats);
				int i;
				i = rs[2].convert<int>();
				statsArr[0] = i;
				i = rs[3].convert<int>();
				statsArr[1] = i;
				i = rs[4].convert<int>();
				statsArr[2] = i;
			}
			catch (boost::bad_lexical_cast)
			{
				console->log("Invalid Stats for Character: " + characterID);
			}

			//Get Current State
			try
			{
				string state = rs[5].convert<std::string>();
				currentState = lexical_cast<Sqf::Value>(state);
			}
			catch (boost::bad_lexical_cast)
			{
				console->log("Invalid State for Character: " + characterID);
			}

			myClass = rs[6].convert<int>();
			ranger = rs[7].convert<int>();
			outlaw = rs[8].convert<int>();
			hunter = rs[9].convert<int>();
			nomad = rs[10].convert<int>();
			survivalist = rs[11].convert<int>();
			engineer = rs[12].convert<int>();
			undead = rs[13].convert<int>();
			humanKills = rs[14].convert<int>();

			clan = rs[15].convert<string>();

			retVal.push_back(string("PASS"));
			retVal.push_back(medical);
			retVal.push_back(stats);
			retVal.push_back(currentState);
			retVal.push_back(worldSpace);

			retVal.push_back(myClass);
			retVal.push_back(ranger);
			retVal.push_back(outlaw);
			retVal.push_back(hunter);
			retVal.push_back(nomad);
			retVal.push_back(survivalist);
			retVal.push_back(engineer);
			retVal.push_back(undead);
			retVal.push_back(clan);

			//Wait for Async Update Player Model / Instance to finish
			updateInstance.wait();
		} else {
			retVal.push_back(string("ERROR"));
		}

		return retVal;
	}
	catch (Poco::Exception const& ex)
	{
		Sqf::Parameters retVal;
		retVal.push_back(string("ERROR"));
		console->log(ex.what());
		return retVal;
	}
	catch (boost::bad_lexical_cast const& ex)
	{
		Sqf::Parameters retVal;
		retVal.push_back(string("ERROR"));
		console->log(ex.what());
		return retVal;
	}
	catch (boost::bad_get const& ex)
	{
		Sqf::Parameters retVal;
		retVal.push_back(string("ERROR"));
		console->log(ex.what());
		return retVal;
	}
	catch (std::exception const& ex)
	{
		Sqf::Parameters retVal;
		retVal.push_back(string("ERROR"));
		console->log(ex.what());
		return retVal;
	}
};
Ejemplo n.º 21
0
Sqf::Value Database::fetchCharacterInitial(string playerID, string playerName)
{
	try
	{
		bool newPlayer = false;
		std::string guid = VAC::convertSteamIDtoBEGUID(playerID);

		//Make Sure Player Exists in the Database
		{
			Poco::Data::Statement stmt((*activeSession));
			stmt << "select `name` from `profile` WHERE `unique_id` = ?", use(playerID), now;
			Poco::Data::RecordSet rs(stmt);

			if (rs.rowCount() > 0 && rs.columnCount() >= 1)
			{
				std::string dbName = rs[0].convert<std::string>();
				if (playerName != dbName)
				{
					Poco::Data::Statement name_stmt((*activeSession));
					name_stmt << "update `profile` set `name` = ? where `unique_id` = ?", use(playerName), use(playerID), now;
				};
			} else {
				newPlayer = true;
				Poco::Data::Statement profile_stmt((*activeSession));
				profile_stmt << "insert into `profile` (`unique_id`, `name`, `guid`) values (?, ?, ?)", use(playerID), use(playerName), use(guid), now;
			}
		}

		//Get Characters From Database
		Poco::Data::Statement character_stmt((*activeSession));
		character_stmt << "select s.`id`, s.`lastserver`, s.`activeserver`, s.`inventory`, s.`backpack`, "
			"timestampdiff(minute, s.`start_time`, s.`last_updated`) as `SurvivalTime`, "
			"timestampdiff(minute, s.`last_updated`, NOW()) as `MinsLastUpdate`, "
			//"timestampdiff(minute, s.`last_drank`, NOW()) as `MinsLastDrank`, "
			"s.`dog` from `survivor` s join `instance` i on s.`world_id` = i.`world_id` and i.`id` = ? where s.`unique_id` = ? and s.`is_dead` = 0", use(serverID), use(playerID), now;
		Poco::Data::RecordSet rs(character_stmt);

		bool newChar = false; //not a new char
		int characterID = -1; //invalid charid
		int lastServer = 0;
		int activeServer = 0;
		Sqf::Value inventory = lexical_cast<Sqf::Value>("[]"); //empty inventory
		Sqf::Value backpack = lexical_cast<Sqf::Value>("[]"); //empty backpack
		Sqf::Value survival = lexical_cast<Sqf::Value>("[0,0,0]"); //0 mins alive, 0 mins since last ate, 0 mins since last drank
		Sqf::Value medical = lexical_cast<Sqf::Value>("[false,false,false,false,false,false,false,0,12000,[],[0,0],0]");
		string model = ""; //empty models will be defaulted by scripts
		Sqf::Value dog = lexical_cast<Sqf::Value>("[]"); //dog class id, dog hunger, dog thirst

		if (rs.rowCount() > 0 && rs.columnCount() >= 1)
		{
			characterID = rs[0].convert<int>();

			lastServer = rs[1].convert<int>();
			activeServer = rs[2].convert<int>();

			string inv = rs[3].convert<std::string>();
			inventory = lexical_cast<Sqf::Value>(inv);

			string bpk = rs[4].convert<std::string>();
			backpack = lexical_cast<Sqf::Value>(bpk);

			{
				Sqf::Parameters& survivalArr = boost::get<Sqf::Parameters>(survival);
				int i;
				i = rs[5].convert<int>();
				survivalArr[0] = i;
				i = rs[6].convert<int>();
				survivalArr[1] = i;
			}

			string dg = rs[7].convert<std::string>();
			dog = lexical_cast<Sqf::Value>(dg);

		} else {
			newChar = true;

			//Insert New Char into DB
			Poco::Data::Statement stmt((*activeSession));
			stmt << "insert into `survivor` (`unique_id`, `world_id`) select ?, i.`world_id` from `instance` i where i.`id` = ?", use(playerID), use(serverID), now;

			//Get The New Character's ID
			{
				Poco::Data::Statement stmt((*activeSession));
				stmt << "select s.`id` from `survivor` s join `instance` i on s.world_id = i.world_id and i.id = ? where s.`unique_id` = ? and s.`is_dead` = 0", use(serverID), use(playerID), now;
				Poco::Data::RecordSet rs(stmt);

				if (rs.rowCount() > 0 && rs.columnCount() >= 1) {
					characterID = rs[0].convert<int>();
				} else {
					Sqf::Parameters retVal;
					retVal.push_back(string("ERROR"));
					return retVal;
				}
			}
		}

		//Always Push Back Full Login Details
		Sqf::Parameters retVal;
		retVal.push_back(string("PASS"));
		retVal.push_back(newChar);
		retVal.push_back(lexical_cast<string>(characterID));
		retVal.push_back(inventory);
		retVal.push_back(survival);
		retVal.push_back(lastServer);
		retVal.push_back(activeServer);
		retVal.push_back(dog);
		retVal.push_back(guid);
		return retVal;
	}
	catch (Poco::Exception const& ex)
	{
		Sqf::Parameters retVal;
		retVal.push_back(string("ERROR"));
		console->log(ex.what());
		return retVal;
	}
	catch (boost::bad_lexical_cast const& ex)
	{
		Sqf::Parameters retVal;
		retVal.push_back(string("ERROR"));
		console->log(ex.what());
		return retVal;
	}
	catch (boost::bad_get const& ex)
	{
		Sqf::Parameters retVal;
		retVal.push_back(string("ERROR"));
		console->log(ex.what());
		return retVal;
	}
	catch (std::exception const& ex)
	{
		Sqf::Parameters retVal;
		retVal.push_back(string("ERROR"));
		console->log(ex.what());
		return retVal;
	}
}
Ejemplo n.º 22
0
void Database::populateObjects(std::queue<Sqf::Parameters>& queue)
{
	try
	{
		//Reset Ghosting Timer (Server Restart) for this instance
		Poco::Data::Statement ghostingStmt((*activeSession));
		ghostingStmt << "UPDATE `survivor` SET `lastserver` = '0', `activeserver` = '0' WHERE `lastserver` = ? OR `activeserver` = ?", use(serverID), use(serverID);

		//Fetch Objects For This Instance
		Poco::Data::Statement stmt((*activeSession));
		stmt << "select id.`unique_id`, d.`class_name`, id.`owner_id`, id.`player_id`, id.`worldspace`, id.`inventory`, id.`lock`, id.`building_id` from `instance_deployable` id inner join `deployable` d on id.`deployable_id` = d.`id` where id.`instance_id` = ? AND `deployable_id` IS NOT NULL", use(serverID);
		stmt.execute();

		//Execute Ghosting Async
		ghostingStmt.executeAsync();

		//Process Objects Data Set
		Poco::Data::RecordSet rs(stmt);

		if (rs.columnCount() >= 1)
		{
			bool more = rs.moveFirst();
			while (more)
			{
				Sqf::Value worldSpace = Sqf::Parameters(); //[]
				Sqf::Value inventory = Sqf::Parameters(); //[]
				Sqf::Value parts = Sqf::Parameters(); //[]

				Sqf::Parameters objParams;
				objParams.push_back(string("OBJ"));

				string objectID = rs[0].convert<std::string>();
				objParams.push_back(objectID);

				string classname = rs[1].convert<std::string>();
				objParams.push_back(classname);

				string ownerID = rs[2].convert<std::string>();
				objParams.push_back(ownerID);

				string playerID = rs[3].convert<std::string>();
				objParams.push_back(playerID);

				try
				{
					string worldSpaceStr = rs[4].convert<std::string>();
					worldSpace = lexical_cast<Sqf::Value>(worldSpaceStr);
				}
				catch (boost::bad_lexical_cast)
				{
					console->log("Invalid Worldspace for ObjectID: " + objectID);
				}

				objParams.push_back(worldSpace);

				try
				{
					string inventoryStr = rs[5].convert<std::string>();
					inventory = lexical_cast<Sqf::Value>(inventoryStr);
				}
				catch (boost::bad_lexical_cast)
				{
					console->log("Invalid Inventory for ObjectID: " + objectID);
				}

				objParams.push_back(inventory);

				string lock = rs[6].convert<std::string>();
				objParams.push_back(lock);

				string buildingID = rs[7].convert<std::string>();
				objParams.push_back(buildingID);

				queue.push(objParams);

				more = rs.moveNext();
			}
		}

		//Wait For Async Ghosting Timer Statement
		ghostingStmt.wait();
	}
	catch (boost::bad_lexical_cast& ex)
	{
		console->log(ex.what());
	}
	catch (boost::exception&)
	{
		console->log("unknown boost exception");
	}
	catch (Data::MySQL::StatementException& ex)
	{
		console->log(ex.message());
	}
	catch (Data::MySQL::TransactionException& ex)
	{
		console->log(ex.message());
	}
	catch (std::exception& ex)
	{
		console->log(ex.what());
	}
}
Ejemplo n.º 23
0
void Database::populateVehicles(std::queue<Sqf::Parameters>& queue)
{
	try
	{
		Poco::Data::Statement stmt((*activeSession));
		stmt << "select `unique_id`, `classname`, `worldspace`, `inventory`, `parts`, `fuel`, `damage` from `instance_vehicle` where `instance_id` = ?", use(serverID), now;
		Poco::Data::RecordSet rs(stmt);

		if (rs.columnCount() >= 1)
		{
			bool more = rs.moveFirst();
			while (more)
			{
				Sqf::Value worldSpace = Sqf::Parameters(); //[]
				Sqf::Value inventory = Sqf::Parameters(); //[]
				Sqf::Value parts = Sqf::Parameters(); //[]

				Sqf::Parameters objParams;
				objParams.push_back(string("VEH"));

				string uniqueID = rs[0].convert<std::string>();
				objParams.push_back(uniqueID);

				string classname = rs[1].convert<std::string>();
				objParams.push_back(classname);

				try
				{
					string worldSpaceStr = rs[2].convert<std::string>();
					worldSpace = lexical_cast<Sqf::Value>(worldSpaceStr);
				}
				catch (boost::bad_lexical_cast)
				{
					console->log("Invalid Worldspace for ObjectID: " + uniqueID);
				}

				objParams.push_back(worldSpace);

				try
				{
					string inventoryStr = rs[3].convert<std::string>();
					inventory = lexical_cast<Sqf::Value>(inventoryStr);
				}
				catch (boost::bad_lexical_cast)
				{
					console->log("Invalid Inventory for ObjectID: " + uniqueID);
				}

				objParams.push_back(inventory);

				try
				{
					string partsStr = rs[4].convert<std::string>();
					parts = lexical_cast<Sqf::Value>(partsStr);
				}
				catch (boost::bad_lexical_cast)
				{
					console->log("Invalid Parts for ObjectID: " + uniqueID);
				}

				objParams.push_back(parts);

				double fuel = rs[5].convert<double>();
				objParams.push_back(fuel);

				double damage = rs[6].convert<double>();
				objParams.push_back(damage);

				queue.push(objParams);

				more = rs.moveNext();
			}
		}
	}
	catch (boost::bad_lexical_cast& ex)
	{
		console->log(ex.what());
	}
	catch (boost::exception&)
	{
		console->log("unknown boost exception");
	}
	catch (Data::MySQL::StatementException& ex)
	{
		console->log(ex.message());
	}
	catch (Data::MySQL::TransactionException& ex)
	{
		console->log(ex.message());
	}
	catch (std::exception& ex)
	{
		console->log(ex.what());
	}
}