mirror of
https://bitbucket.org/theswgsource/src-1.2.git
synced 2026-10-03 18:12:58 -04:00
486 lines
15 KiB
C++
Executable File
486 lines
15 KiB
C++
Executable File
// ======================================================================
|
|
//
|
|
// TaskClaimRewards.cpp
|
|
// copyright (c) 2004 Sony Online Entertainment
|
|
//
|
|
// ======================================================================
|
|
|
|
#include "FirstLoginServer.h"
|
|
#include "TaskClaimRewards.h"
|
|
|
|
#include "DatabaseConnection.h"
|
|
#include "serverNetworkMessages/ClaimRewardsReplyMessage.h"
|
|
#include "serverNetworkMessages/FeatureIdTransactionResponse.h"
|
|
#include "sharedDatabaseInterface/Bindable.h"
|
|
#include "sharedDatabaseInterface/BindableNetworkId.h"
|
|
#include "sharedDatabaseInterface/DbQuery.h"
|
|
#include "sharedDatabaseInterface/DbSession.h"
|
|
|
|
// ======================================================================
|
|
|
|
namespace TaskClaimRewardsNamespace
|
|
{
|
|
class ConsumeEventQuery : public DB::Query
|
|
{
|
|
public:
|
|
ConsumeEventQuery(StationId stationId, NetworkId const & characterId, uint32 clusterId, std::string const & eventId);
|
|
|
|
virtual void getSQL(std::string &sql);
|
|
virtual bool bindParameters();
|
|
virtual bool bindColumns();
|
|
virtual QueryMode getExecutionMode() const;
|
|
|
|
bool getResult() const;
|
|
|
|
private:
|
|
DB::BindableLong station_id;
|
|
DB::BindableNetworkId character_id;
|
|
DB::BindableLong cluster_id;
|
|
DB::BindableString<255> event_id;
|
|
DB::BindableLong result;
|
|
|
|
private: //disable
|
|
ConsumeEventQuery();
|
|
ConsumeEventQuery(const ConsumeEventQuery&);
|
|
ConsumeEventQuery &operator=(const ConsumeEventQuery&);
|
|
};
|
|
|
|
class ClaimItemQuery : public DB::Query
|
|
{
|
|
public:
|
|
ClaimItemQuery(StationId stationId, NetworkId const & characterId, uint32 clusterId, std::string const & itemId);
|
|
|
|
virtual void getSQL(std::string &sql);
|
|
virtual bool bindParameters();
|
|
virtual bool bindColumns();
|
|
virtual QueryMode getExecutionMode() const;
|
|
|
|
bool getResult() const;
|
|
|
|
private:
|
|
DB::BindableLong station_id;
|
|
DB::BindableNetworkId character_id;
|
|
DB::BindableLong cluster_id;
|
|
DB::BindableString<255> item_id;
|
|
DB::BindableLong result;
|
|
|
|
private: //disable
|
|
ClaimItemQuery();
|
|
ClaimItemQuery(const ClaimItemQuery&);
|
|
ClaimItemQuery &operator=(const ClaimItemQuery&);
|
|
};
|
|
|
|
class UpdateFeatureIdTransactionQuery : public DB::Query
|
|
{
|
|
public:
|
|
UpdateFeatureIdTransactionQuery(StationId stationId, NetworkId const & characterId, uint32 clusterId, std::string const & itemId, int countAdjustment);
|
|
|
|
virtual void getSQL(std::string &sql);
|
|
virtual bool bindParameters();
|
|
virtual bool bindColumns();
|
|
virtual QueryMode getExecutionMode() const;
|
|
|
|
bool getResult() const;
|
|
|
|
private:
|
|
DB::BindableLong station_id;
|
|
DB::BindableNetworkId character_id;
|
|
DB::BindableLong cluster_id;
|
|
DB::BindableString<255> item_id;
|
|
DB::BindableLong count_adjustment;
|
|
DB::BindableLong result;
|
|
|
|
private: //disable
|
|
UpdateFeatureIdTransactionQuery();
|
|
UpdateFeatureIdTransactionQuery(const UpdateFeatureIdTransactionQuery&);
|
|
UpdateFeatureIdTransactionQuery &operator=(const UpdateFeatureIdTransactionQuery&);
|
|
};
|
|
|
|
class GetFeatureIdTransactionsQuery : public DB::Query
|
|
{
|
|
public:
|
|
GetFeatureIdTransactionsQuery(StationId stationId, NetworkId const & characterId, uint32 clusterId);
|
|
|
|
DB::BindableString<255> item_id;
|
|
DB::BindableLong count;
|
|
|
|
virtual void getSQL(std::string &sql);
|
|
virtual bool bindParameters();
|
|
virtual bool bindColumns();
|
|
virtual QueryMode getExecutionMode() const;
|
|
|
|
private:
|
|
DB::BindableLong station_id;
|
|
DB::BindableNetworkId character_id;
|
|
DB::BindableLong cluster_id;
|
|
|
|
private: //disable
|
|
GetFeatureIdTransactionsQuery(const GetFeatureIdTransactionsQuery&);
|
|
GetFeatureIdTransactionsQuery& operator=(const GetFeatureIdTransactionsQuery&);
|
|
};
|
|
}
|
|
|
|
using namespace TaskClaimRewardsNamespace;
|
|
|
|
// ======================================================================
|
|
|
|
TaskClaimRewards::TaskClaimRewards(uint32 clusterId, uint32 gameServerId, StationId stationId, NetworkId const & playerId, std::string const & rewardEvent, bool consumeEvent, std::string const & rewardItem, bool consumeItem, uint32 accountFeatureId, bool consumeAccountFeatureId, int previousAccountFeatureIdCount, int currentAccountFeatureIdCount) :
|
|
DB::TaskRequest(),
|
|
m_clusterId(clusterId),
|
|
m_gameServerId(gameServerId),
|
|
m_stationId(stationId),
|
|
m_playerId(playerId),
|
|
m_rewardEvent(rewardEvent),
|
|
m_consumeEvent(consumeEvent),
|
|
m_rewardItem(rewardItem),
|
|
m_consumeItem(consumeItem),
|
|
m_accountFeatureId(accountFeatureId),
|
|
m_consumeAccountFeatureId(consumeAccountFeatureId),
|
|
m_previousAccountFeatureIdCount(previousAccountFeatureIdCount),
|
|
m_currentAccountFeatureIdCount(currentAccountFeatureIdCount),
|
|
m_result(false)
|
|
{
|
|
}
|
|
|
|
// ----------------------------------------------------------------------
|
|
|
|
bool TaskClaimRewards::process(DB::Session *session)
|
|
{
|
|
if (!session->setAutoCommitMode(false))
|
|
return false;
|
|
|
|
// record the account feature id transaction
|
|
if ((m_accountFeatureId > 0) && m_consumeAccountFeatureId)
|
|
{
|
|
UpdateFeatureIdTransactionQuery featureIdQry(m_stationId, m_playerId, m_clusterId, m_rewardItem, 1);
|
|
if (!session->exec(&featureIdQry))
|
|
return false;
|
|
if (!featureIdQry.getResult())
|
|
{
|
|
if (!session->rollbackTransaction())
|
|
return false;
|
|
m_result = false;
|
|
return true;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// consume the event
|
|
if (m_consumeEvent)
|
|
{
|
|
ConsumeEventQuery eventQry(m_stationId, m_playerId, m_clusterId, m_rewardEvent);
|
|
if (!session->exec(&eventQry))
|
|
return false;
|
|
if (!eventQry.getResult())
|
|
{
|
|
if (!session->rollbackTransaction())
|
|
return false;
|
|
m_result = false;
|
|
return true;
|
|
}
|
|
}
|
|
|
|
// consume the item
|
|
if (m_consumeItem)
|
|
{
|
|
ClaimItemQuery itemQuery(m_stationId, m_playerId, m_clusterId, m_rewardItem);
|
|
if (!session->exec(&itemQuery))
|
|
return false;
|
|
if (!itemQuery.getResult())
|
|
{
|
|
if (!session->rollbackTransaction())
|
|
return false;
|
|
m_result = false;
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!session->commitTransaction())
|
|
return false;
|
|
m_result = true;
|
|
return true;
|
|
}
|
|
|
|
// ----------------------------------------------------------------------
|
|
|
|
void TaskClaimRewards::onComplete()
|
|
{
|
|
// if the reward used an account feature id, we have already updated the account feature id
|
|
// on session/Platform, so regardless if whether we were able to record the transaction
|
|
// in the LoginServer DB or not, always send SUCCESS back to the game server for the item
|
|
// to be granted
|
|
ClaimRewardsReplyMessage msg(m_gameServerId, m_stationId, m_playerId, m_rewardEvent, m_rewardItem, m_accountFeatureId, m_consumeAccountFeatureId, m_previousAccountFeatureIdCount, m_currentAccountFeatureIdCount, (((m_accountFeatureId > 0) && m_consumeAccountFeatureId) ? true : m_result));
|
|
LoginServer::getInstance().sendToCluster(m_clusterId, msg);
|
|
}
|
|
|
|
// ======================================================================
|
|
|
|
TaskFeatureIdTransactionRequest::TaskFeatureIdTransactionRequest(uint32 clusterId, StationId stationId, NetworkId const & playerId, uint32 gameServerId) :
|
|
DB::TaskRequest(),
|
|
m_clusterId(clusterId),
|
|
m_stationId(stationId),
|
|
m_playerId(playerId),
|
|
m_gameServerId(gameServerId),
|
|
m_transactions()
|
|
{
|
|
}
|
|
|
|
// ----------------------------------------------------------------------
|
|
|
|
bool TaskFeatureIdTransactionRequest::process(DB::Session *session)
|
|
{
|
|
GetFeatureIdTransactionsQuery qry(m_stationId, m_playerId, m_clusterId);
|
|
if (!(session->exec(&qry)))
|
|
return false;
|
|
|
|
int rowsFetched;
|
|
while ((rowsFetched = qry.fetch()) > 0)
|
|
m_transactions[qry.item_id.getValueASCII()] = static_cast<int>(qry.count.getValue());
|
|
|
|
return (rowsFetched >= 0);
|
|
}
|
|
|
|
// ----------------------------------------------------------------------
|
|
|
|
void TaskFeatureIdTransactionRequest::onComplete()
|
|
{
|
|
FeatureIdTransactionResponse const fitr(m_gameServerId, m_playerId, m_transactions);
|
|
LoginServer::getInstance().sendToCluster(m_clusterId, fitr);
|
|
}
|
|
|
|
// ======================================================================
|
|
|
|
TaskFeatureIdTransactionSyncUpdate::TaskFeatureIdTransactionSyncUpdate(uint32 clusterId, StationId stationId, NetworkId const & playerId, std::string const & itemId, int adjustment) :
|
|
DB::TaskRequest(),
|
|
m_clusterId(clusterId),
|
|
m_stationId(stationId),
|
|
m_playerId(playerId),
|
|
m_itemId(itemId),
|
|
m_adjustment(adjustment)
|
|
{
|
|
}
|
|
|
|
// ----------------------------------------------------------------------
|
|
|
|
bool TaskFeatureIdTransactionSyncUpdate::process(DB::Session *session)
|
|
{
|
|
UpdateFeatureIdTransactionQuery featureIdQry(m_stationId, m_playerId, m_clusterId, m_itemId, m_adjustment);
|
|
if (!session->exec(&featureIdQry))
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
// ----------------------------------------------------------------------
|
|
|
|
void TaskFeatureIdTransactionSyncUpdate::onComplete()
|
|
{
|
|
}
|
|
|
|
// ======================================================================
|
|
|
|
TaskClaimRewardsNamespace::ConsumeEventQuery::ConsumeEventQuery(StationId stationId, NetworkId const & characterId, uint32 clusterId, std::string const & eventId) :
|
|
DB::Query(),
|
|
station_id(static_cast<long>(stationId)),
|
|
character_id(characterId),
|
|
cluster_id(static_cast<long>(clusterId)),
|
|
event_id(eventId),
|
|
result(0)
|
|
{
|
|
}
|
|
|
|
// ----------------------------------------------------------------------
|
|
|
|
void TaskClaimRewardsNamespace::ConsumeEventQuery::getSQL(std::string &sql)
|
|
{
|
|
sql = std::string("begin :result := ")+DatabaseConnection::getInstance().getSchemaQualifier()+"login.consume_reward_event(:station_id, :character_id, :cluster_id, :event_id); end;";
|
|
}
|
|
|
|
// ----------------------------------------------------------------------
|
|
|
|
bool TaskClaimRewardsNamespace::ConsumeEventQuery::bindParameters()
|
|
{
|
|
if (!bindParameter(result)) return false;
|
|
if (!bindParameter(station_id)) return false;
|
|
if (!bindParameter(character_id)) return false;
|
|
if (!bindParameter(cluster_id)) return false;
|
|
if (!bindParameter(event_id)) return false;
|
|
return true;
|
|
}
|
|
|
|
// ----------------------------------------------------------------------
|
|
|
|
bool TaskClaimRewardsNamespace::ConsumeEventQuery::bindColumns()
|
|
{
|
|
return true;
|
|
}
|
|
|
|
// ----------------------------------------------------------------------
|
|
|
|
TaskClaimRewardsNamespace::ConsumeEventQuery::QueryMode TaskClaimRewardsNamespace::ConsumeEventQuery::getExecutionMode() const
|
|
{
|
|
return MODE_PROCEXEC;
|
|
}
|
|
|
|
// ----------------------------------------------------------------------
|
|
|
|
bool TaskClaimRewardsNamespace::ConsumeEventQuery::getResult() const
|
|
{
|
|
return (result.getValue() != 0);
|
|
}
|
|
|
|
// ======================================================================
|
|
|
|
TaskClaimRewardsNamespace::ClaimItemQuery::ClaimItemQuery(StationId stationId, NetworkId const & characterId, uint32 clusterId, std::string const & itemId) :
|
|
DB::Query(),
|
|
station_id(static_cast<long>(stationId)),
|
|
character_id(characterId),
|
|
cluster_id(static_cast<long>(clusterId)),
|
|
item_id(itemId),
|
|
result(0)
|
|
{
|
|
}
|
|
|
|
// ----------------------------------------------------------------------
|
|
|
|
void TaskClaimRewardsNamespace::ClaimItemQuery::getSQL(std::string &sql)
|
|
{
|
|
sql = std::string("begin :result := ")+DatabaseConnection::getInstance().getSchemaQualifier()+"login.claim_reward_item(:station_id, :character_id, :cluster_id, :item_id); end;";
|
|
}
|
|
|
|
// ----------------------------------------------------------------------
|
|
|
|
bool TaskClaimRewardsNamespace::ClaimItemQuery::bindParameters()
|
|
{
|
|
if (!bindParameter(result)) return false;
|
|
if (!bindParameter(station_id)) return false;
|
|
if (!bindParameter(character_id)) return false;
|
|
if (!bindParameter(cluster_id)) return false;
|
|
if (!bindParameter(item_id)) return false;
|
|
return true;
|
|
}
|
|
|
|
// ----------------------------------------------------------------------
|
|
|
|
bool TaskClaimRewardsNamespace::ClaimItemQuery::bindColumns()
|
|
{
|
|
return true;
|
|
}
|
|
|
|
// ----------------------------------------------------------------------
|
|
|
|
TaskClaimRewardsNamespace::ClaimItemQuery::QueryMode TaskClaimRewardsNamespace::ClaimItemQuery::getExecutionMode() const
|
|
{
|
|
return MODE_PROCEXEC;
|
|
}
|
|
|
|
// ----------------------------------------------------------------------
|
|
|
|
bool TaskClaimRewardsNamespace::ClaimItemQuery::getResult() const
|
|
{
|
|
return (result.getValue() != 0);
|
|
}
|
|
|
|
// ======================================================================
|
|
|
|
TaskClaimRewardsNamespace::UpdateFeatureIdTransactionQuery::UpdateFeatureIdTransactionQuery(StationId stationId, NetworkId const & characterId, uint32 clusterId, std::string const & itemId, int countAdjustment) :
|
|
DB::Query(),
|
|
station_id(static_cast<long>(stationId)),
|
|
character_id(characterId),
|
|
cluster_id(static_cast<long>(clusterId)),
|
|
item_id(itemId),
|
|
count_adjustment(static_cast<long>(countAdjustment)),
|
|
result(0)
|
|
{
|
|
}
|
|
|
|
// ----------------------------------------------------------------------
|
|
|
|
void TaskClaimRewardsNamespace::UpdateFeatureIdTransactionQuery::getSQL(std::string &sql)
|
|
{
|
|
sql = std::string("begin :result := ")+DatabaseConnection::getInstance().getSchemaQualifier()+"login.update_feature_id_transaction(:station_id, :cluster_id, :character_id, :item_id, :count_adjustment); end;";
|
|
}
|
|
|
|
// ----------------------------------------------------------------------
|
|
|
|
bool TaskClaimRewardsNamespace::UpdateFeatureIdTransactionQuery::bindParameters()
|
|
{
|
|
if (!bindParameter(result)) return false;
|
|
if (!bindParameter(station_id)) return false;
|
|
if (!bindParameter(cluster_id)) return false;
|
|
if (!bindParameter(character_id)) return false;
|
|
if (!bindParameter(item_id)) return false;
|
|
if (!bindParameter(count_adjustment)) return false;
|
|
return true;
|
|
}
|
|
|
|
// ----------------------------------------------------------------------
|
|
|
|
bool TaskClaimRewardsNamespace::UpdateFeatureIdTransactionQuery::bindColumns()
|
|
{
|
|
return true;
|
|
}
|
|
|
|
// ----------------------------------------------------------------------
|
|
|
|
TaskClaimRewardsNamespace::UpdateFeatureIdTransactionQuery::QueryMode TaskClaimRewardsNamespace::UpdateFeatureIdTransactionQuery::getExecutionMode() const
|
|
{
|
|
return MODE_PROCEXEC;
|
|
}
|
|
|
|
// ----------------------------------------------------------------------
|
|
|
|
bool TaskClaimRewardsNamespace::UpdateFeatureIdTransactionQuery::getResult() const
|
|
{
|
|
return (result.getValue() != 0);
|
|
}
|
|
|
|
// ======================================================================
|
|
|
|
TaskClaimRewardsNamespace::GetFeatureIdTransactionsQuery::GetFeatureIdTransactionsQuery(StationId stationId, NetworkId const & characterId, uint32 clusterId) :
|
|
DB::Query(),
|
|
item_id(),
|
|
count(0),
|
|
station_id(static_cast<long>(stationId)),
|
|
character_id(characterId),
|
|
cluster_id(static_cast<long>(clusterId))
|
|
{
|
|
}
|
|
|
|
// ----------------------------------------------------------------------
|
|
|
|
void TaskClaimRewardsNamespace::GetFeatureIdTransactionsQuery::getSQL(std::string &sql)
|
|
{
|
|
sql = std::string("begin :result := ")+DatabaseConnection::getInstance().getSchemaQualifier()+"login.get_feature_id_transactions(:station_id, :cluster_id, :character_id); end;";
|
|
}
|
|
|
|
// ----------------------------------------------------------------------
|
|
|
|
bool TaskClaimRewardsNamespace::GetFeatureIdTransactionsQuery::bindParameters()
|
|
{
|
|
if (!bindParameter(station_id)) return false;
|
|
if (!bindParameter(cluster_id)) return false;
|
|
if (!bindParameter(character_id)) return false;
|
|
return true;
|
|
}
|
|
|
|
// ----------------------------------------------------------------------
|
|
|
|
bool TaskClaimRewardsNamespace::GetFeatureIdTransactionsQuery::bindColumns()
|
|
{
|
|
if (!bindCol(item_id)) return false;
|
|
if (!bindCol(count)) return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
// ----------------------------------------------------------------------
|
|
|
|
TaskClaimRewardsNamespace::GetFeatureIdTransactionsQuery::QueryMode TaskClaimRewardsNamespace::GetFeatureIdTransactionsQuery::getExecutionMode() const
|
|
{
|
|
return MODE_PLSQL_REFCURSOR;
|
|
}
|
|
|
|
// ======================================================================
|