468 lines
12 KiB
C++
468 lines
12 KiB
C++
|
|
#include "Stdafx.h"
|
|
#include "MasterSystemCacheRepository.h"
|
|
#include "DNDBConnection.h"
|
|
#include "DNUserSession.h"
|
|
#include "DNMasterConnection.h"
|
|
#include "DNWorldUserState.h"
|
|
|
|
using namespace MasterSystem;
|
|
|
|
void CCacheRepository::ClearCache()
|
|
{
|
|
DWORD dwCurTime = timeGetTime();
|
|
if( dwCurTime-m_dwCacheTick < CACHECLEARTICK )
|
|
return;
|
|
|
|
ScopeLock<CSyncLock> Lock( m_Sync );
|
|
|
|
m_dwCacheTick = dwCurTime;
|
|
|
|
switch( m_uiCacheClearCount%5 )
|
|
{
|
|
case 0: // [0]MasterList
|
|
{
|
|
for( MMasterListItor itor=m_mMasterList.begin() ; itor!=m_mMasterList.end() ; )
|
|
{
|
|
if( dwCurTime-(*itor).second.first > CACHECLEARTICK )
|
|
m_mMasterList.erase( itor++ );
|
|
else
|
|
++itor;
|
|
}
|
|
break;
|
|
}
|
|
case 1: // [1]PupilList
|
|
{
|
|
for( MPupilListItor itor=m_mPupilList.begin() ; itor!=m_mPupilList.end() ; )
|
|
{
|
|
if( dwCurTime-(*itor).second.first > CACHECLEARTICK )
|
|
m_mPupilList.erase( itor++ );
|
|
else
|
|
++itor;
|
|
}
|
|
break;
|
|
}
|
|
case 2: // [2]Master&Classmate List
|
|
{
|
|
for( MMasterClassmateListItor itor=m_mMasterClassmateList.begin() ; itor!=m_mMasterClassmateList.end() ; )
|
|
{
|
|
if( dwCurTime-(*itor).second.first > CACHECLEARTICK )
|
|
m_mMasterClassmateList.erase( itor++ );
|
|
else
|
|
++itor;
|
|
}
|
|
break;
|
|
}
|
|
case 3: // [3]ClassmateInfo
|
|
{
|
|
for( MClassmateInfoListItor itor=m_mClassmateList.begin() ; itor!=m_mClassmateList.end() ; )
|
|
{
|
|
if( dwCurTime-(*itor).second.first > CACHECLEARTICK )
|
|
m_mClassmateList.erase( itor++ );
|
|
else
|
|
++itor;
|
|
}
|
|
break;
|
|
}
|
|
case 4: // [4]MyMasterInfo
|
|
{
|
|
for( MMyMasterInfoListItor itor=m_mMyMasterList.begin() ; itor!=m_mMyMasterList.end() ; )
|
|
{
|
|
if( dwCurTime-(*itor).second.first > CACHECLEARTICK )
|
|
m_mMyMasterList.erase( itor++ );
|
|
else
|
|
++itor;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
++m_uiCacheClearCount;
|
|
}
|
|
|
|
void CCacheRepository::GetMasterList( CDNUserSession* pSession, UINT uiPage, BYTE cJob, BYTE cGender )
|
|
{
|
|
{
|
|
ScopeLock<CSyncLock> Lock( m_Sync );
|
|
|
|
MMasterListItor itor = m_mMasterList.find( std::tr1::make_tuple(uiPage,cJob,cGender) );
|
|
if( itor != m_mMasterList.end() )
|
|
{
|
|
if( timeGetTime()-(*itor).second.first < CACHETICK )
|
|
{
|
|
if( pSession )
|
|
pSession->SendMasterSystemMasterList( ERROR_NONE, (*itor).second.second );
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
// QUERY
|
|
CDNDBConnection* pDBCon = pSession->GetDBConnection();
|
|
if( !pDBCon || !pDBCon->GetActive() )
|
|
{
|
|
pSession->SendMasterSystemMasterList( ERROR_GENERIC_DBCON_NOT_FOUND, std::vector<TMasterInfo>() );
|
|
return;
|
|
}
|
|
|
|
pDBCon->QueryGetPageMasterCharacter( pSession, uiPage, cJob, cGender );
|
|
}
|
|
|
|
void CCacheRepository::SetMasterList( CDNUserSession* pSession, TAGetPageMasterCharacter* pData )
|
|
{
|
|
ClearCache();
|
|
|
|
if( pData->nRetCode == ERROR_NONE )
|
|
{
|
|
ScopeLock<CSyncLock> Lock( m_Sync );
|
|
|
|
MMasterListItor itor = m_mMasterList.find( std::tr1::make_tuple(pData->uiPage,pData->cJobCode,pData->cGenderCode) );
|
|
if( itor != m_mMasterList.end() )
|
|
{
|
|
(*itor).second.first = timeGetTime();
|
|
(*itor).second.second.clear();
|
|
for( UINT i=0 ; i<pData->cCount ; ++i )
|
|
(*itor).second.second.push_back( pData->MasterInfoList[i] );
|
|
}
|
|
else
|
|
{
|
|
std::vector<TMasterInfo> vMasterList;
|
|
if( pData->cCount > 0 )
|
|
{
|
|
vMasterList.reserve( pData->cCount );
|
|
for( UINT i=0 ; i<pData->cCount ; ++i )
|
|
vMasterList.push_back( pData->MasterInfoList[i] );
|
|
}
|
|
|
|
m_mMasterList.insert( std::make_pair( std::tr1::make_tuple(pData->uiPage,pData->cJobCode,pData->cGenderCode),std::make_pair(timeGetTime(),vMasterList) ) );
|
|
}
|
|
|
|
GetMasterList( pSession, pData->uiPage, pData->cJobCode, pData->cGenderCode );
|
|
}
|
|
else
|
|
{
|
|
if( pSession )
|
|
pSession->SendMasterSystemMasterList( pData->nRetCode, std::vector<TMasterInfo>() );
|
|
}
|
|
}
|
|
|
|
void CCacheRepository::GetMasterCharacter( CDNUserSession* pSession, INT64 biCharacterDBID )
|
|
{
|
|
// QUERY
|
|
if( pSession == NULL )
|
|
return;
|
|
|
|
CDNDBConnection* pDBCon = pSession->GetDBConnection();
|
|
if( !pDBCon || !pDBCon->GetActive() )
|
|
{
|
|
pSession->SendMasterSystemMasterCharacterInfo( ERROR_GENERIC_DBCON_NOT_FOUND );
|
|
return;
|
|
}
|
|
|
|
pDBCon->QueryGetMasterCharacterType1( pSession, pSession->GetCharacterDBID() );
|
|
}
|
|
|
|
void CCacheRepository::SetMasterCharacter( CDNUserSession* pSession, TAGetMasterCharacterType1* pData )
|
|
{
|
|
if( pSession )
|
|
pSession->SendMasterSystemMasterCharacterInfo( pData->nRetCode, &pData->MasterCharacterInfo );
|
|
|
|
if( pData->nRetCode == ERROR_NONE )
|
|
GetPupilList( pSession, pData->biMasterCharacterDBID, true );
|
|
}
|
|
|
|
void CCacheRepository::GetMyMasterInfo( CDNUserSession* pSession, INT64 biPupilCharacterDBID, INT64 biMasterCharacterDBID, bool bRefresh )
|
|
{
|
|
if( bRefresh == false )
|
|
{
|
|
ScopeLock<CSyncLock> Lock( m_Sync );
|
|
|
|
MMyMasterInfoListItor itor = m_mMyMasterList.find( std::make_pair(biPupilCharacterDBID,biMasterCharacterDBID) );
|
|
if( itor != m_mMyMasterList.end() )
|
|
{
|
|
if( timeGetTime()-(*itor).second.first < CACHETICK )
|
|
{
|
|
if( pSession )
|
|
pSession->SendMasterSystemMyMasterInfo( ERROR_NONE, &(*itor).second.second );
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
// QUERY
|
|
if( pSession == NULL )
|
|
return;
|
|
|
|
CDNDBConnection* pDBCon = pSession->GetDBConnection();
|
|
if( !pDBCon || !pDBCon->GetActive() )
|
|
{
|
|
pSession->SendMasterSystemMyMasterInfo( ERROR_GENERIC_DBCON_NOT_FOUND );
|
|
return;
|
|
}
|
|
|
|
pDBCon->QueryGetMasterCharacterType2( pSession, biMasterCharacterDBID, biPupilCharacterDBID );
|
|
}
|
|
|
|
void CCacheRepository::SetMyMasterInto( CDNUserSession* pSession, TAGetMasterCharacterType2* pData )
|
|
{
|
|
ClearCache();
|
|
|
|
if( pData->nRetCode == ERROR_NONE )
|
|
{
|
|
ScopeLock<CSyncLock> Lock( m_Sync );
|
|
|
|
MMyMasterInfoListItor itor = m_mMyMasterList.find( std::make_pair(pData->biPupilCharacterDBID,pData->biMasterCharacterDBID) );
|
|
if( itor != m_mMyMasterList.end() )
|
|
{
|
|
(*itor).second.first = timeGetTime();
|
|
(*itor).second.second = pData->MasterInfo;
|
|
}
|
|
else
|
|
{
|
|
m_mMyMasterList.insert( std::make_pair( std::make_pair(pData->biPupilCharacterDBID,pData->biMasterCharacterDBID),std::make_pair(timeGetTime(),pData->MasterInfo) ) );
|
|
}
|
|
|
|
GetMyMasterInfo( pSession, pData->biPupilCharacterDBID, pData->biMasterCharacterDBID, false );
|
|
}
|
|
else
|
|
{
|
|
if( pSession )
|
|
pSession->SendMasterSystemMyMasterInfo( pData->nRetCode );
|
|
}
|
|
}
|
|
|
|
const TPupilInfo* CCacheRepository::GetPupilInfo( INT64 biMasterCharacterDBID, INT64 biPupilCharacterDBID )
|
|
{
|
|
ScopeLock<CSyncLock> Lock( m_Sync );
|
|
|
|
MPupilListItor itor = m_mPupilList.find( biMasterCharacterDBID );
|
|
if( itor == m_mPupilList.end() )
|
|
return NULL;
|
|
|
|
for( UINT i=0 ; i<(*itor).second.second.size() ; ++i )
|
|
{
|
|
if( (*itor).second.second[i].biCharacterDBID == biPupilCharacterDBID )
|
|
return &(*itor).second.second[i];
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
void CCacheRepository::GetPupilList( CDNUserSession* pSession, INT64 biCharacterDBID, bool bRefresh )
|
|
{
|
|
if( bRefresh == false )
|
|
{
|
|
ScopeLock<CSyncLock> Lock( m_Sync );
|
|
|
|
MPupilListItor itor = m_mPupilList.find( biCharacterDBID );
|
|
if( itor != m_mPupilList.end() )
|
|
{
|
|
if( timeGetTime()-(*itor).second.first < CACHETICK )
|
|
{
|
|
if( pSession )
|
|
pSession->SendMasterSystemPupilList( ERROR_NONE, biCharacterDBID, (*itor).second.second );
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
// QUERY
|
|
if( pSession == NULL )
|
|
return;
|
|
|
|
CDNDBConnection* pDBCon = pSession->GetDBConnection();
|
|
if( !pDBCon || !pDBCon->GetActive() )
|
|
{
|
|
pSession->SendMasterSystemMasterCharacterInfo( ERROR_GENERIC_DBCON_NOT_FOUND );
|
|
return;
|
|
}
|
|
|
|
pDBCon->QueryGetPupilList( pSession, biCharacterDBID );
|
|
}
|
|
|
|
void CCacheRepository::SetPupilList( CDNUserSession* pSession, TAGetListPupil* pData )
|
|
{
|
|
ClearCache();
|
|
|
|
if( pData->nRetCode == ERROR_NONE )
|
|
{
|
|
ScopeLock<CSyncLock> Lock( m_Sync );
|
|
|
|
MPupilListItor itor = m_mPupilList.find( pData->biCharacterDBID );
|
|
if( itor != m_mPupilList.end() )
|
|
{
|
|
(*itor).second.first = timeGetTime();
|
|
(*itor).second.second.clear();
|
|
for( UINT i=0 ; i<pData->cCount ; ++i )
|
|
(*itor).second.second.push_back( pData->PupilInfoList[i] );
|
|
}
|
|
else
|
|
{
|
|
std::vector<TPupilInfo> vPupilList;
|
|
if( pData->cCount > 0 )
|
|
{
|
|
vPupilList.reserve( pData->cCount );
|
|
for( UINT i=0 ; i<pData->cCount ; ++i )
|
|
vPupilList.push_back( pData->PupilInfoList[i] );
|
|
}
|
|
|
|
m_mPupilList.insert( std::make_pair( pData->biCharacterDBID,std::make_pair(timeGetTime(),vPupilList) ) );
|
|
}
|
|
|
|
GetPupilList( pSession, pData->biCharacterDBID, false );
|
|
}
|
|
else
|
|
{
|
|
if( pSession )
|
|
pSession->SendMasterSystemPupilList( pData->nRetCode, pData->biCharacterDBID, std::vector<TPupilInfo>() );
|
|
}
|
|
}
|
|
|
|
void CCacheRepository::GetMasterClassmateList( CDNUserSession* pSession, INT64 biCharacterDBID, bool bRefresh )
|
|
{
|
|
if( bRefresh == false )
|
|
{
|
|
ScopeLock<CSyncLock> Lock( m_Sync );
|
|
|
|
MMasterClassmateListItor itor = m_mMasterClassmateList.find( biCharacterDBID );
|
|
if( itor != m_mMasterClassmateList.end() )
|
|
{
|
|
if( timeGetTime()-(*itor).second.first < CACHETICK )
|
|
{
|
|
if( pSession )
|
|
pSession->SendMasterSystemMasterAndClassmateInfo( ERROR_NONE, (*itor).second.second );
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
// QUERY
|
|
if( pSession == NULL )
|
|
return;
|
|
|
|
if( pSession->CheckDBConnection() == false )
|
|
{
|
|
pSession->SendMasterSystemMasterAndClassmateInfo( ERROR_GENERIC_DBCON_NOT_FOUND, std::vector<TMasterAndClassmateInfo>() );
|
|
return;
|
|
}
|
|
|
|
pSession->GetDBConnection()->QueryGetMasterAndClassmate( pSession, biCharacterDBID );
|
|
}
|
|
|
|
void CCacheRepository::SetMasterClassmateList( CDNUserSession* pSession, TAGetListMyMasterAndClassmate* pData )
|
|
{
|
|
ClearCache();
|
|
|
|
if( pData->nRetCode == ERROR_NONE )
|
|
{
|
|
ScopeLock<CSyncLock> Lock( m_Sync );
|
|
|
|
MMasterClassmateListItor itor = m_mMasterClassmateList.find( pData->biCharacterDBID );
|
|
if( itor != m_mMasterClassmateList.end() )
|
|
{
|
|
(*itor).second.first = timeGetTime();
|
|
(*itor).second.second.clear();
|
|
for( UINT i=0 ; i<pData->cCount ; ++i )
|
|
(*itor).second.second.push_back( pData->MasterAndClassmateInfoList[i] );
|
|
}
|
|
else
|
|
{
|
|
std::vector<TMasterAndClassmateInfo> vList;
|
|
if( pData->cCount > 0 )
|
|
{
|
|
vList.reserve( pData->cCount );
|
|
for( UINT i=0 ; i<pData->cCount ; ++i )
|
|
vList.push_back( pData->MasterAndClassmateInfoList[i] );
|
|
}
|
|
|
|
m_mMasterClassmateList.insert( std::make_pair( pData->biCharacterDBID,std::make_pair(timeGetTime(),vList) ) );
|
|
}
|
|
|
|
GetMasterClassmateList( pSession, pData->biCharacterDBID, false );
|
|
}
|
|
else
|
|
{
|
|
if( pSession )
|
|
pSession->SendMasterSystemMasterAndClassmateInfo( pData->nRetCode, std::vector<TMasterAndClassmateInfo>() );
|
|
}
|
|
}
|
|
|
|
void CCacheRepository::GetClassmateInfo( CDNUserSession* pSession, INT64 biClassmateCharacterDBID, bool bRefresh )
|
|
{
|
|
if( bRefresh == false )
|
|
{
|
|
ScopeLock<CSyncLock> Lock( m_Sync );
|
|
|
|
MClassmateInfoListItor itor = m_mClassmateList.find( biClassmateCharacterDBID );
|
|
if( itor != m_mClassmateList.end() )
|
|
{
|
|
if( timeGetTime()-(*itor).second.first < CACHETICK )
|
|
{
|
|
if( pSession )
|
|
pSession->SendMasterSystemClassmateInfo( ERROR_NONE, &(*itor).second.second );
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
// QUERY
|
|
if( pSession == NULL )
|
|
return;
|
|
|
|
if( pSession->CheckDBConnection() == false )
|
|
{
|
|
pSession->SendMasterSystemClassmateInfo( ERROR_GENERIC_DBCON_NOT_FOUND );
|
|
return;
|
|
}
|
|
|
|
pSession->GetDBConnection()->QueryGetClassmateInfo( pSession, biClassmateCharacterDBID );
|
|
}
|
|
|
|
void CCacheRepository::SetClassmateInfo( CDNUserSession* pSession, TAGetMyClassmate* pData )
|
|
{
|
|
ClearCache();
|
|
|
|
if( pData->nRetCode == ERROR_NONE )
|
|
{
|
|
ScopeLock<CSyncLock> Lock( m_Sync );
|
|
|
|
MClassmateInfoListItor itor = m_mClassmateList.find( pData->ClassmateInfo.biCharacterDBID );
|
|
if( itor != m_mClassmateList.end() )
|
|
{
|
|
(*itor).second.first = timeGetTime();
|
|
(*itor).second.second = pData->ClassmateInfo;
|
|
}
|
|
else
|
|
{
|
|
m_mClassmateList.insert( std::make_pair( pData->ClassmateInfo.biCharacterDBID,std::make_pair(timeGetTime(),pData->ClassmateInfo) ) );
|
|
}
|
|
|
|
GetClassmateInfo( pSession, pData->ClassmateInfo.biCharacterDBID, false );
|
|
}
|
|
else
|
|
{
|
|
if( pSession )
|
|
pSession->SendMasterSystemClassmateInfo( pData->nRetCode );
|
|
}
|
|
}
|
|
|
|
TCommunityLocation CCacheRepository::GetLocationInfo( INT64 biCharacterDBID )
|
|
{
|
|
TCommunityLocation Location;
|
|
g_pWorldUserState->GetUserState( biCharacterDBID, Location );
|
|
|
|
return Location;
|
|
}
|
|
|
|
void CCacheRepository::SetRegisterMaster( CDNUserSession* pSession, TAAddMasterCharacter* pData )
|
|
{
|
|
if( pSession )
|
|
pSession->SendMasterSystemIntroductionOnOff( pData->nRetCode, true, pData->wszSelfIntroduction );
|
|
}
|
|
|
|
void CCacheRepository::SetRegisterMaster( CDNUserSession* pSession, TADelMasterCharacter* pData )
|
|
{
|
|
if( pSession )
|
|
pSession->SendMasterSystemIntroductionOnOff( pData->nRetCode, false, NULL );
|
|
}
|
|
|