CWE-ou-minkata/MOULOpenSourceClientPlugin/Plasma20/Sources/Plasma/PythonLib/pyVault/pyVNodeMgr.cpp

/*==LICENSE==*

CyanWorlds.com Engine - MMOG client, server and tools
Copyright (C) 2011  Cyan Worlds, Inc.

This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.

You can contact Cyan Worlds, Inc. by email legal@cyan.com
 or by snail mail at:
      Cyan Worlds, Inc.
      14617 N Newport Hwy
      Mead, WA   99021

*==LICENSE==*/
#include "pyVNodeMgr.h"
#include "../plVault/plVaultCallback.h"
#include "../plVault/plVaultInitTasks.h"
#include "../pfPython/pyVaultNode.h"
#include "../pfPython/pyVaultFolderNode.h"
#include "../pyNetClientComm/pyNetClientComm.h"
#include "../plNetMessage/plNetMessage.h"
#include "../plStatusLog/plStatusLog.h"

////////////////////////////////////////////////////////////////////

class pyVaultOperationCallback : public plVaultOperationCallback
{
public:
	PyObject * fPyObject;
	pyVaultOperationCallback( PyObject * pyObject )
		: fPyObject( pyObject )
	{
		Py_XINCREF( fPyObject );
	}
	~pyVaultOperationCallback()
	{
		Py_XDECREF( fPyObject );
	}
	void VaultOperationStarted( UInt32 context )
	{
		if ( fPyObject )
		{
			// Do callback
			PyObject* func = PyObject_GetAttrString( fPyObject, "operationStarted" );
			if ( func )
			{
				if ( PyCallable_Check(func)>0 )
				{
					PyObject* retVal = PyObject_CallMethod(fPyObject, "operationStarted", "l", context);
					Py_XDECREF(retVal);
				}
			}
		}
	}
	void VaultOperationComplete( UInt32 context, int resultCode )
	{
		if ( fPyObject )
		{
			// Pass args.
//			PyObject* pyArgs = PyObject_GetAttrString( fPyObject, "fCbArgs" );
//			if ( pyArgs )
//			{
//				dict pyDict = dict();
//				std::map<UInt16,plCreatable*>	args;
//				fCbArgs.GetItems( args );
//				for ( std::map<UInt16,plCreatable*>::iterator ii=args.begin(); ii!=args.end(); ++ii )
//				{
//					UInt16 key = ii->first;
//					plCreatable* arg = ii->second;
//					plCreatableGenericValue * genValue = plCreatableGenericValue::ConvertNoRef( arg );
//					if ( genValue )
//					{
//						plGenericType & value = genValue->Value();
//						switch ( value.GetType() )
//						{
//						case plGenericType::kInt:
//							pyDict[key] = (int)value;
//							break;
//						case plGenericType::kUInt:
//							pyDict[key] = (unsigned int)value;
//							break;
//						case plGenericType::kFloat:
//							pyDict[key] = (float)value;
//							break;
//						case plGenericType::kDouble:
//							pyDict[key] = (double)value;
//							break;
//						case plGenericType::kBool:
//							pyDict[key] = (bool)value;
//							break;
//						case plGenericType::kChar:
//							pyDict[key] = (char)value;
//							break;
//						case plGenericType::kString:
//							pyDict[key] = (const char *)value;
//							break;
//						case plGenericType::kAny:
//							break;
//						case plGenericType::kNone:
//							break;
//						}
//					}
//				}
//				PyObject_SetAttrString( fPyObject, "fCbArgs", pyDict.ptr() );
//			}
			// Do callback
			PyObject* func = PyObject_GetAttrString( fPyObject, "operationComplete" );
			if ( func )
			{
				if ( PyCallable_Check(func)>0 )
				{
					PyObject* retVal = PyObject_CallMethod(fPyObject, "operationComplete", "li", context, resultCode);
					Py_XDECREF(retVal);
				}
			}
		}
		delete this;
	}
};


class pyVaultCallback : public plVaultStubbedCallback
{
public:
	PyObject * fPyObject;
	pyVaultCallback( PyObject * pyObject )
		: fPyObject( pyObject )
	{
		Py_XINCREF( fPyObject );
	}
	~pyVaultCallback()
	{
		Py_XDECREF( fPyObject );
	}
};


////////////////////////////////////////////////////////////////////

int pyVNodeMgr::VaultMsgHandler::HandleMessage( plNetMessage* msg )
{
	plNetMsgVault * vaultMsg = plNetMsgVault::ConvertNoRef( msg );

	if ( vaultMsg )
	{
		plNetCoreMessage * ncmsg = (plNetCoreMessage*)msg->GetNetCoreMsg();
		msg->PeekBuffer( ncmsg->GetData(), ncmsg->GetLen() );
		fMyVNodeMgr->GetStatusLog()->AddLineF( "\t%s", msg->AsStdString().c_str() );
		plVault::ProcessMsg( vaultMsg );
		return plNetClientComm::kOK_MsgConsumed;
	}

	return hsFail;
}


// pyVNodeMgr ----------------------------------------------
pyVNodeMgr::pyVNodeMgr( PyObject* thaComm )
{
	if (!pyNetClientComm::Check(thaComm))
	{
		fMyCommObj = NULL;
		return; // screwed!
	}

	fMsgHandler.setMgr(this);

	fMyCommObj = thaComm;
	Py_INCREF(fMyCommObj);
	fMyComm = pyNetClientComm::ConvertFrom(fMyCommObj);
	fMyComm->GetNetClientComm()->AddMsgHandlerForType( plNetMsgVault::Index(), &fMsgHandler );
	plVNodeMgr::SetStatusLog( fMyComm->GetNetClientComm()->GetLog(), false );
}

// ~pyVNodeMgr ----------------------------------------------
pyVNodeMgr::~pyVNodeMgr()
{
	fMyComm->GetNetClientComm()->RemoveMsgHandler( &fMsgHandler );
	Py_DECREF(fMyCommObj);
}

void pyVNodeMgr::setMyComm(PyObject* thaComm)
{
	if (fMyComm)
	{
		fMyComm->GetNetClientComm()->RemoveMsgHandler(&fMsgHandler);
		Py_DECREF(fMyCommObj);
		fMyCommObj = NULL;
		fMyComm = NULL;
	}
	if (!pyNetClientComm::Check(thaComm))
		return; // screwed!

	fMyCommObj = thaComm;
	Py_INCREF(fMyCommObj);
	fMyComm = pyNetClientComm::ConvertFrom(fMyCommObj);
	fMyComm->GetNetClientComm()->AddMsgHandlerForType(plNetMsgVault::Index(), &fMsgHandler);
	plVNodeMgr::SetStatusLog(fMyComm->GetNetClientComm()->GetLog(), false);
}

// IAmOnline ----------------------------------------------
bool pyVNodeMgr::IAmOnline() const
{
	return true;
}

// IIsThisMe ----------------------------------------------
bool pyVNodeMgr::IIsThisMe( plVaultPlayerInfoNode* node ) const
{
	return ( fMyComm->GetNetClientComm()->GetPlayerID()==node->GetPlayerID() );
}

// IIsThisMe ----------------------------------------------
bool pyVNodeMgr::IIsThisMe( plVaultPlayerNode * node ) const
{
	return ( fMyComm->GetNetClientComm()->GetPlayerID()==node->GetID() );
}

// ISendNetMsg ----------------------------------------------
int pyVNodeMgr::ISendNetMsg( plNetMsgVault* msg, UInt32 sendFlags/*=0 */)
{
	return fMyComm->GetNetClientComm()->SendMsg( msg, sendFlags );
}

// IGetPlayerID ----------------------------------------------
UInt32 pyVNodeMgr::IGetPlayerID() const
{
	return fMyComm->GetNetClientComm()->GetPlayerID();
}

// Update ----------------------------------------------
int pyVNodeMgr::Update( double secs )
{
	return plVNodeMgr::Update( secs );
}

// Startup ----------------------------------------------
void pyVNodeMgr::Startup()
{
	plVNodeMgr::Startup();
}

// Shutdown ----------------------------------------------
void pyVNodeMgr::Shutdown()
{
	plVNodeMgr::Shutdown();
}


// IsConnected ----------------------------------------------
bool pyVNodeMgr::IsConnected()
{
	return plVNodeMgr::IsConnected();
}

// Disconnect ----------------------------------------------
void pyVNodeMgr::Disconnect( PyObject* cb/*=nil*/, UInt32 cbContext/*=0 */)
{
	// disconnect from allplayers and globalsdl folders
	plVaultNodeRef * out;
	plVaultNode * root = plVNodeMgr::GetRootNode();
	if ( root )
	{
		plVaultFolderNode tmpGlobalSDL;
		tmpGlobalSDL.SetFolderType( plVault::kAllAgeGlobalSDLNodesFolder );
		if ( root->FindNode( &tmpGlobalSDL, out ) )
			root->RemoveNode( out->GetChildID() );
		plVaultFolderNode tmpAllPlayers;
		tmpAllPlayers.SetFolderType( plVault::kAllPlayersFolder );
		if ( root->FindNode( &tmpAllPlayers, out ) )
			root->RemoveNode( out->GetChildID() );
	}
	plVNodeMgr::Disconnect( new pyVaultOperationCallback( cb ), cbContext );
}

// Connect ----------------------------------------------
void pyVNodeMgr::Connect( int childFetchLevel/*=plVault::kFetchAllChildren*/, PyObject* cb/*=nil*/, UInt32 cbContext/*=0 */)
{
	plVNodeMgr::Connect( childFetchLevel, new pyVaultOperationCallback( cb ), cbContext );
}

// FetchNode ----------------------------------------------
bool pyVNodeMgr::FetchNode( UInt32 nodeID,
	int childFetchLevel/*=plVault::kFetchAllChildren*/,
	PyObject* cb/*=nil*/,
	UInt32 cbContext/*=0 */)
{
	return plVNodeMgr::FetchNode( nodeID, childFetchLevel, new pyVaultOperationCallback( cb ), cbContext );
}

// GetRootNode ----------------------------------------------
PyObject* pyVNodeMgr::GetRootNode() const
{
	return pyVaultNode::New( plVNodeMgr::GetRootNode() );
}

// GetClientID ----------------------------------------------
UInt32 pyVNodeMgr::GetClientID() const
{
	return plVNodeMgr::GetClientID();
}

// GetNode ----------------------------------------------
PyObject* pyVNodeMgr::GetNode( UInt32 id ) const
{
	plVaultNode * tmp;
	if ( plVNodeMgr::GetNode( id, tmp ) )
		return pyVaultNode::New( tmp );
	PYTHON_RETURN_NONE;
}

// FindNode ----------------------------------------------
PyObject* pyVNodeMgr::FindNode( pyVaultNode* templateNode ) const
{
	plVaultNode * node;
	if ( plVNodeMgr::FindNode( templateNode->GetNode(), node ) )
		return pyVaultNode::New( node );
	PYTHON_RETURN_NONE;
}

// EnableCallbacks ----------------------------------------------
bool pyVNodeMgr::EnableCallbacks( bool b )
{
	return plVNodeMgr::EnableCallbacks( b );
}

// AddCallback ----------------------------------------------
void pyVNodeMgr::AddCallback( PyObject* cb )
{
	pyVaultCallback * pycb = new pyVaultCallback( cb );
	fPyCallbacks.push_back( pycb );
	plVNodeMgr::AddCallback( pycb );
}

// RemoveCallback ----------------------------------------------
void pyVNodeMgr::RemoveCallback( PyObject* cb )
{
	PyCallbackVec	tmp;
	for ( int i=0; i<fPyCallbacks.size(); i++ )
	{
		if ( fPyCallbacks[i]->fPyObject==cb )
			tmp.push_back( fPyCallbacks[i] );
	}
	for ( int i=0; i<tmp.size(); i++ )
	{
		PyCallbackVec::iterator it = std::find( fPyCallbacks.begin(), fPyCallbacks.end(), tmp[i] );
		if ( it!=fPyCallbacks.end() )
			fPyCallbacks.erase( it );
		plVNodeMgr::RemoveCallback( tmp[i] );
		delete tmp[i];
	}
}

// CreateNode ----------------------------------------------
PyObject* pyVNodeMgr::CreateNode( int nodeType, bool persistent )
{
	plVaultNode * node = plVNodeMgr::CreateNode( nodeType, persistent?kNewPersistentNodeOptions( this ):kNilNodeOptions() );
	if ( node )
		return pyVaultNode::New( node );
	PYTHON_RETURN_NONE;
}

// Dump ----------------------------------------------
void pyVNodeMgr::Dump() const
{
	plVNodeMgr::Dump();
}

////////////////////////////////////////////////////////////////////////

pyPlayerVNodeMgr::pyPlayerVNodeMgr( PyObject* thaComm )
: pyVNodeMgr( thaComm )
{}

// IAmSuperUser ----------------------------------------------
bool pyPlayerVNodeMgr::IAmSuperUser( void ) const
{
	return false;
}

// IFillOutConnectFields ----------------------------------------------
void pyPlayerVNodeMgr::IFillOutConnectFields( plNetMsgVault* msg ) const
{
	msg->GetArgs()->AddInt( plVault::kArg_NodeMgrType, plVault::kNodeType_VNodeMgrPlayer );
	msg->GetArgs()->AddInt( plVault::kArg_NodeMgrID, fMyComm->GetNetClientComm()->GetPlayerID() );
}

// IGetNodeInitializationTask ----------------------------------------------
plVNodeInitTask * pyPlayerVNodeMgr::IGetNodeInitializationTask( plVaultNode * node )
{
	if ( plVaultPlayerNode::ConvertNoRef( node ) )
		return new plVaultPlayerInitializationTask( this, node, true );
	return nil;
}

////////////////////////////////////////////////////////////////////////

pyAgeVNodeMgr::pyAgeVNodeMgr( PyObject* thaComm )
: pyVNodeMgr( thaComm )
{}

// IAmSuperUser ----------------------------------------------
bool pyAgeVNodeMgr::IAmSuperUser( void ) const
{
	return false;
}

// IFillOutConnectFields ----------------------------------------------
void pyAgeVNodeMgr::IFillOutConnectFields( plNetMsgVault* msg ) const
{
	msg->GetArgs()->AddInt( plVault::kArg_NodeMgrType, plVault::kNodeType_VNodeMgrAge );
	msg->GetArgs()->AddString( plVault::kArg_NodeMgrAgeInstanceName, fAgeFilename.c_str() );
	msg->GetArgs()->AddItem( plVault::kArg_NodeMgrAgeGuid, &fAgeInstanceGuid );
}

// IGetNodeInitializationTask ----------------------------------------------
plVNodeInitTask * pyAgeVNodeMgr::IGetNodeInitializationTask( plVaultNode * node )
{
	if ( plVaultAgeNode::ConvertNoRef( node ) )
		return new plVaultAgeInitializationTask( this, node, nil, true );
	if ( plVaultAgeInfoNode::ConvertNoRef( node ) )
		return new plVaultAgeInfoInitializationTask( this, node );
	return nil;
}

// SetAgeInfo ----------------------------------------------
void pyAgeVNodeMgr::SetAgeInfo( const char * ageFilename, const char * ageInstanceGuid )
{
	fAgeFilename = ageFilename;
	fAgeInstanceGuid.FromString( ageInstanceGuid );
}

////////////////////////////////////////////////////////////////////////

pyAdminVNodeMgr::pyAdminVNodeMgr( PyObject* thaComm )
: pyVNodeMgr( thaComm )
, fWantGlobalSDL( true )
, fWantAllPlayers( false )
{}

// IAmSuperUser ----------------------------------------------
bool pyAdminVNodeMgr::IAmSuperUser( void ) const
{
	return true;
}

// IFillOutConnectFields ----------------------------------------------
void pyAdminVNodeMgr::IFillOutConnectFields( plNetMsgVault* msg ) const
{
	msg->GetArgs()->AddInt( plVault::kArg_NodeMgrType, plVault::kNodeType_VNodeMgrAdmin );
	msg->GetArgs()->AddInt( plVault::kArg_NodeMgrID, fMyComm->GetNetClientComm()->GetPlayerID() );
}

// IGetNodeInitializationTask ----------------------------------------------
plVNodeInitTask * pyAdminVNodeMgr::IGetNodeInitializationTask( plVaultNode * node )
{
	if ( plVaultAdminNode::ConvertNoRef( node ) )
		return new plVaultAdminInitializationTask( this, node, fWantGlobalSDL, fWantAllPlayers );
	return nil;
}

// GetGlobalInbox ----------------------------------------------
PyObject * pyAdminVNodeMgr::GetGlobalInbox() const
{
	plVaultFolderNode tmp;
	tmp.SetFolderType( plVault::kGlobalInboxFolder );
	plVaultNode * node;
	if ( plVNodeMgr::FindNode( &tmp, node ) )
	{
		return pyVaultFolderNode::New( plVaultFolderNode::ConvertNoRef( node ) );
	}
	PYTHON_RETURN_NONE;
}

////////////////////////////////////////////////////////////////////
// End.