CWE-ou-minkata/MOULOpenSourceClientPlugin/Plasma20/Sources/Plasma/FeatureLib/pfPython/pyAgeVault.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==*/
//////////////////////////////////////////////////////////////////////
//
// pyAgeVault   - a wrapper class to provide interface to the plVaultAgeNode
//
//////////////////////////////////////////////////////////////////////

#include "pyAgeVault.h"
#include "pyVault.h"
#include "pyVaultNodeRef.h"
#include "pyVaultFolderNode.h"
#include "pyVaultPlayerInfoListNode.h"
#include "pyVaultPlayerInfoNode.h"
#include "pyVaultAgeInfoNode.h"
#include "pyVaultAgeLinkNode.h"
#include "pyVaultChronicleNode.h"
#include "pyVaultTextNoteNode.h"
#include "pyNetLinkingMgr.h"
#include "pyAgeInfoStruct.h"
#include "pySDL.h"


#include "plVault/plVault.h"
#include "plNetClient/plNetClientMgr.h"
#include "plNetClient/plNetLinkingMgr.h"
#include "plNetTransport/plNetTransport.h"
#include "plNetTransport/plNetTransportMember.h"
#include "plSDL/plSDL.h"
#include "pnNetCommon/plNetApp.h"

pyAgeVault::pyAgeVault() {
}

pyAgeVault::~pyAgeVault() {
}

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

PyObject* pyAgeVault::GetAgeInfo()
{
	RelVaultNode * rvn = VaultGetAgeInfoNodeIncRef();
	if (rvn) {
		PyObject * result = pyVaultAgeInfoNode::New(rvn);
		rvn->DecRef();
		return result;
	}

	// just return a None object
	PYTHON_RETURN_NONE;
}

PyObject* pyAgeVault::GetAgeDevicesFolder( void )
{
	RelVaultNode * rvn = VaultGetAgeDevicesFolderIncRef();
	if (rvn) {
		PyObject * result = pyVaultFolderNode::New(rvn);
		rvn->DecRef();
		return result;
	}

	// just return a None object
	PYTHON_RETURN_NONE;
}

PyObject* pyAgeVault::GetSubAgesFolder( void )
{
	RelVaultNode * rvn = VaultGetAgeSubAgesFolderIncRef();
	if (rvn) {
		PyObject * result = pyVaultFolderNode::New(rvn);
		rvn->DecRef();
		return result;
	}

	// just return a None object
	PYTHON_RETURN_NONE;
}

PyObject* pyAgeVault::GetChronicleFolder( void )
{
	RelVaultNode * rvn = VaultGetAgeChronicleFolderIncRef();
	if (rvn) {
		PyObject * result = pyVaultFolderNode::New(rvn);
		rvn->DecRef();
		return result;
	}

	// just return a None object
	PYTHON_RETURN_NONE;
}

PyObject* pyAgeVault::GetBookshelfFolder ( void )
{
	RelVaultNode * rvn = VaultAgeGetBookshelfFolderIncRef();
	if (rvn) {
		PyObject * result = pyVaultFolderNode::New(rvn);
		rvn->DecRef();
		return result;
	}

	// just return a None object
	PYTHON_RETURN_NONE;
}

PyObject* pyAgeVault::GetPeopleIKnowAboutFolder( void )
{
	RelVaultNode * rvn = VaultGetAgePeopleIKnowAboutFolderIncRef();
	if (rvn) {
		PyObject * result = pyVaultFolderNode::New(rvn);
		rvn->DecRef();
		return result;
	}

	// just return a None object
	PYTHON_RETURN_NONE;
}


PyObject* pyAgeVault::GetPublicAgesFolder(void)
{
	RelVaultNode * rvn = VaultGetAgePublicAgesFolderIncRef();
	if (rvn) {
		PyObject * result = pyVaultFolderNode::New(rvn);
		rvn->DecRef();
		return result;
	}

	// just return a None object
	PYTHON_RETURN_NONE;
}

PyObject* pyAgeVault::GetSubAgeLink( const pyAgeInfoStruct & info )
{
	RelVaultNode * rvn = VaultFindAgeSubAgeLinkIncRef(info.GetAgeInfo());
	if (rvn) {
		PyObject * result = pyVaultAgeLinkNode::New(rvn);
		rvn->DecRef();
		return result;
	}

	// just return a None object
	PYTHON_RETURN_NONE;
}

const char* pyAgeVault::GetAgeGuid( void )
{
	RelVaultNode * rvn = VaultGetAgeInfoNodeIncRef();
	if (rvn) {
		VaultAgeInfoNode ageInfo(rvn);
		GuidToString(ageInfo.ageInstUuid, fAgeGuid, arrsize(fAgeGuid));
		rvn->DecRef();
	}
	else {
		fAgeGuid[0] = 0;
	}
	return fAgeGuid;
}


///////////////
// Chronicle
PyObject* pyAgeVault::FindChronicleEntry( const char * entryName )
{
	wchar wEntryName[kMaxVaultNodeStringLength];
	StrToUnicode(wEntryName, entryName, arrsize(wEntryName));
	
	if (RelVaultNode * rvn = VaultFindAgeChronicleEntryIncRef(wEntryName)) {
		PyObject * result = pyVaultChronicleNode::New(rvn);
		rvn->DecRef();
		return result;
	}
	
	// just return a None object
	PYTHON_RETURN_NONE;
}

void pyAgeVault::AddChronicleEntry( const char * name, UInt32 type, const char * value )
{
	wchar * wEntryName = StrDupToUnicode(name);
	wchar * wEntryValue = StrDupToUnicode(value);
	
	VaultAddAgeChronicleEntry(wEntryName, type, wEntryValue);
	
	FREE(wEntryName);
	FREE(wEntryValue);
}

// AGE DEVICES. AKA IMAGERS, WHATEVER.
// Add a new device.
void pyAgeVault::AddDevice( const char * deviceName, PyObject * cbObject, UInt32 cbContext )
{
	pyVaultNode::pyVaultNodeOperationCallback * cb = NEWZERO(pyVaultNode::pyVaultNodeOperationCallback)( cbObject );
	cb->VaultOperationStarted( cbContext );

	wchar wStr[MAX_PATH];
	StrToUnicode(wStr, deviceName, arrsize(wStr));

	if (RelVaultNode * rvn = VaultAgeAddDeviceAndWaitIncRef(wStr)) {
		cb->SetNode(rvn);
		rvn->DecRef();
	}

	cb->VaultOperationComplete( cbContext, cb->GetNode() ? hsOK : hsFail);	// cbHolder deletes itself here.
}

// Remove a device.
void pyAgeVault::RemoveDevice( const char * deviceName )
{
	wchar wStr[MAX_PATH];
	StrToUnicode(wStr, deviceName, arrsize(wStr));

	VaultAgeRemoveDevice(wStr);
}

// True if device exists in age.
bool pyAgeVault::HasDevice( const char * deviceName )
{
	wchar wStr[MAX_PATH];
	StrToUnicode(wStr, deviceName, arrsize(wStr));

	return VaultAgeHasDevice(wStr);
}

PyObject * pyAgeVault::GetDevice( const char * deviceName )
{
	wchar wStr[MAX_PATH];
	StrToUnicode(wStr, deviceName, arrsize(wStr));

	if (RelVaultNode * rvn = VaultAgeGetDeviceIncRef(wStr)) {
		PyObject * result = pyVaultTextNoteNode::New(rvn);
		rvn->DecRef();
		return result;
	}

	PYTHON_RETURN_NONE;
}

// Sets the inbox associated with a device.
void pyAgeVault::SetDeviceInbox( const char * deviceName, const char * inboxName, PyObject * cbObject, UInt32 cbContext )
{
	pyVaultNode::pyVaultNodeOperationCallback * cb = NEWZERO(pyVaultNode::pyVaultNodeOperationCallback)( cbObject );
	cb->VaultOperationStarted( cbContext );

	wchar wDev[MAX_PATH];
	StrToUnicode(wDev, deviceName, arrsize(wDev));
	wchar wInb[MAX_PATH];
	StrToUnicode(wInb, inboxName, arrsize(wInb));
	
	if (RelVaultNode * rvn = VaultAgeSetDeviceInboxAndWaitIncRef(wDev, wInb)) {
		cb->SetNode(rvn);
		rvn->DecRef();
	}

	cb->VaultOperationComplete( cbContext, cb->GetNode() ? hsOK : hsFail );	// cbHolder deletes itself here.
}

PyObject * pyAgeVault::GetDeviceInbox( const char * deviceName )
{
	wchar wStr[MAX_PATH];
	StrToUnicode(wStr, deviceName, arrsize(wStr));

	if (RelVaultNode * rvn = VaultAgeGetDeviceInboxIncRef(wStr)) {
		PyObject * result = pyVaultTextNoteNode::New(rvn);
		rvn->DecRef();
		return result;
	}

	PYTHON_RETURN_NONE;
}

PyObject * pyAgeVault::GetAgeSDL() const
{
	plStateDataRecord * rec = NEWZERO(plStateDataRecord);
	if (!VaultAgeGetAgeSDL(rec)) {
		DEL(rec);
		PYTHON_RETURN_NONE;
	}
	else {
		return pySDLStateDataRecord::New( rec );
	}	
}

void pyAgeVault::UpdateAgeSDL( pySDLStateDataRecord & pyrec )
{
	plStateDataRecord * rec = pyrec.GetRec();
	if ( !rec )
		return;
		
	VaultAgeUpdateAgeSDL(rec);
}

PyObject* pyAgeVault::FindNode( pyVaultNode* templateNode ) const
{
	if (RelVaultNode * rvn = VaultGetAgeNodeIncRef()) {
		RelVaultNode * find = rvn->GetChildNodeIncRef(templateNode->fNode, 1);
		rvn->DecRef();
		if (find) {
			PyObject * result = pyVaultNode::New(find);
			find->DecRef();
			return result;
		}
	}

	PYTHON_RETURN_NONE;
}