PyResult TradeService::Handle_InitiateTrade(PyCallArgs &call){
Call_SingleIntegerArg args;
if(!args.Decode(&call.tuple)) {
codelog(CLIENT__ERROR, "%s: failed to decode arguments", call.client->GetName());
return NULL;
}
Client *target = EntityList::FindCharacter( args.arg );
InitiateTradeRsp rsp;
rsp.nodeID = PyServiceMgr::GetNodeID();
rsp.stationID = target->GetStationID();
rsp.ownerID = call.client->GetCharacterID();
rsp.targetID = target->GetCharacterID();
rsp.moneyToGive = 0;
rsp.moneyToReceive = 0;
rsp.when = Win32TimeNow();
rsp.unknown7 = 0;
SysLog::Debug("Trade Service", "Called InitiateTrade with character: %u", args.arg);
return rsp.Encode();
}
PyResult ContractMgrService::Handle_GetContract( PyCallArgs& call )
{
Call_SingleIntegerArg arg;
PyDict* _contract = new PyDict;
if( !arg.Decode( &call.tuple ) )
{
codelog(SERVICE__ERROR, "%s: Bad arguments to GetContract in contractMgr", call.client->GetCharacterName() );
return NULL;
}
ContractRef contract = m_contractManager->GetContract( arg.arg );
if( contract == NULL )
{
codelog(SERVICE__ERROR, "%s: Can't get contract %d, got NULL pointer!", call.client->GetCharacterName(), arg.arg );
return NULL;
}
_contract->SetItemString( "items", contract->GetItemsList() );
_contract->SetItemString( "bids", contract->GetBids() );
_contract->SetItemString( "contract", contract->GetContractRow() );
PyObject* res = new PyObject( new PyString( "util.KeyVal" ), _contract );
return res;
}
PyResult CorpMgrService::Handle_GetPublicInfo(PyCallArgs &call) {
Call_SingleIntegerArg corpID;
if (!corpID.Decode(&call.tuple)) {
codelog(SERVICE__ERROR, "Bad param");
return NULL;
}
return m_db.GetCorporation(corpID.arg);
}
PyResult RamProxyService::Handle_AssemblyLinesGet(PyCallArgs &call) {
Call_SingleIntegerArg arg; // containerID
if(!arg.Decode(&call.tuple)) {
_log(SERVICE__ERROR, "Unable to decode args.");
return NULL;
}
return(m_db.AssemblyLinesGet(arg.arg));
}
PyResult FactoryService::Handle_GetBlueprintAttributes(PyCallArgs &call) {
Call_SingleIntegerArg arg;
if(!arg.Decode(&call.tuple)) {
_log(SERVICE__ERROR, "Failed to decode args.");
return NULL;
}
BlueprintRef b = ItemFactory::GetBlueprint(arg.arg);
if( !b )
return NULL;
return b->GetBlueprintAttributes();
}
PyResult MailMgrService::Handle_MoveToTrashByList(PyCallArgs &call)
{
Call_SingleIntegerArg args;
if (!args.Decode(&call.tuple))
{
codelog(CLIENT__ERROR, "Failed to decode MoveToTrashByList args");
return NULL;
}
int listId = args.arg;
return NULL;
}
PyResult MailMgrService::Handle_MarkAsUnreadByLabel(PyCallArgs &call)
{
Call_SingleIntegerArg args;
if (!args.Decode(&call.tuple))
{
codelog(CLIENT__ERROR, "Failed to decode MarkAsUnreadByLabel args");
return NULL;
}
int labelId = args.arg;
return NULL;
}
PyResult MailMgrService::Handle_DeleteLabel(PyCallArgs &call)
{
Call_SingleIntegerArg args;
if (!args.Decode(&call.tuple))
{
codelog(CLIENT__ERROR, "Failed to decode DeleteLabel args");
return NULL;
}
m_db->DeleteLabel(call.client->GetCharacterID(), args.arg /*labelID*/);
return NULL;
}
PyResult ContractMgrService::Handle_GetContract( PyCallArgs& call )
{
Call_SingleIntegerArg arg;
PyDict* _contract = new PyDict;
if( !arg.Decode( &call.tuple ) )
{
codelog(SERVICE__ERROR, "%s: Bad arguments to GetContract in contractMgr", call.client->GetCharacterName() );
return NULL;
}
// Manual creation of PyPackedRow
DBRowDescriptor *header = new DBRowDescriptor();
header->AddColumn( "contractID", DBTYPE_I4 );
header->AddColumn( "issuerID", DBTYPE_I4 );
header->AddColumn( "issuerCorpID", DBTYPE_I4 );
header->AddColumn( "type", DBTYPE_UI1 );
header->AddColumn( "availability", DBTYPE_I4 );
header->AddColumn( "assigneeID", DBTYPE_I4 );
header->AddColumn( "numDays", DBTYPE_I4 );
header->AddColumn( "startStationID", DBTYPE_I4 );
header->AddColumn( "endStationID", DBTYPE_I4 );
header->AddColumn( "startSolarSystemID", DBTYPE_I4 );
header->AddColumn( "endSolarSystemID", DBTYPE_I4 );
header->AddColumn( "startRegionID", DBTYPE_I4 );
header->AddColumn( "endRegionID", DBTYPE_I4 );
header->AddColumn( "price", DBTYPE_CY );
header->AddColumn( "reward", DBTYPE_CY );
header->AddColumn( "collateral", DBTYPE_CY );
header->AddColumn( "title", DBTYPE_WSTR );
header->AddColumn( "description", DBTYPE_WSTR );
header->AddColumn( "forCorp", DBTYPE_BOOL );
header->AddColumn( "status", DBTYPE_UI1 );
header->AddColumn( "acceptorID", DBTYPE_I4 );
header->AddColumn( "dateIssued", DBTYPE_FILETIME );
header->AddColumn( "dateExpired", DBTYPE_FILETIME );
header->AddColumn( "dateAccepted", DBTYPE_FILETIME );
header->AddColumn( "dateCompleted", DBTYPE_FILETIME );
header->AddColumn( "volume", DBTYPE_R8 );
header->AddColumn( "issuerAllianceID", DBTYPE_I4 );
header->AddColumn( "issuerWalletKey", DBTYPE_I4 );
header->AddColumn( "acceptorWalletKey", DBTYPE_I4 );
header->AddColumn( "crateID", DBTYPE_I4 );
ContractRef contract = m_contractManager->GetContract( arg.arg );
uint32 n = 0;
PyPackedRow* into = new PyPackedRow( header );
into->SetField( "contractID", new PyInt( contract->contractID() ) );
into->SetField( "issuerID", new PyInt( contract->issuerID() ) );
into->SetField( "issuerCorpID", new PyInt( contract->issuerCorpID() ) );
into->SetField( "type", new PyInt( contract->type() ) );
into->SetField( "availability", new PyInt( contract->avail() ) );
into->SetField( "assigneeID", new PyInt( contract->assigneeID() ) );
into->SetField( "numDays", new PyInt( 0 ) );
into->SetField( "startStationID", new PyInt( contract->startStationID() ) );
into->SetField( "endStationID", new PyInt( contract->endStationID() ) );
into->SetField( "startSolarSystemID", new PyInt( contract->startSolarSystemID() ) );
into->SetField( "endSolarSystemID", new PyInt( contract->endSolarSystemID() ) );
into->SetField( "startRegionID", new PyInt( contract->startRegionID() ) );
into->SetField( "endRegionID", new PyInt( contract->endRegionID() ) );
into->SetField( "price", new PyFloat( contract->price() ) );
into->SetField( "reward", new PyFloat( contract->reward() ) );
into->SetField( "collateral", new PyFloat( contract->collateral() ) );
into->SetField( "title", new PyString( "title" ) );
into->SetField( "description", new PyString( "description" ) );
into->SetField( "forCorp", new PyBool( contract->forCorp() ) );
into->SetField( "status", new PyInt( contract->status() ) );
into->SetField( "acceptorID", new PyInt( contract->acceptorID() ) );
into->SetField( "dateIssued", new PyLong( contract->dateIssued() ) );
into->SetField( "dateExpired", new PyLong( contract->dateExpired() ) );
into->SetField( "dateAccepted", new PyLong( contract->dateAccepted() ) );
into->SetField( "dateCompleted", new PyLong( contract->dateCompleted() ) );
into->SetField( "volume", new PyFloat( contract->volume() ) );
into->SetField( "issuerAllianceID", new PyInt( contract->issuerAllianceID() ) );
into->SetField( "issuerWalletKey", new PyInt( contract->issuerWalletKey() ) );
into->SetField( "acceptorWalletKey", new PyInt( 0 ) );
into->SetField( "crateID", new PyInt( 0 ) );
PyList* itemList = new PyList;
DBRowDescriptor *itemHeader = new DBRowDescriptor();
itemHeader->AddColumn( "contractID", DBTYPE_I4 );
itemHeader->AddColumn( "itemID", DBTYPE_I4 );
itemHeader->AddColumn( "quantity", DBTYPE_I4 );
itemHeader->AddColumn( "itemTypeID", DBTYPE_I4 );
itemHeader->AddColumn( "inCrate", DBTYPE_BOOL );
itemHeader->AddColumn( "parentID", DBTYPE_I4 );
itemHeader->AddColumn( "productivityLevel", DBTYPE_I4 );
itemHeader->AddColumn( "materialLevel", DBTYPE_I4 );
itemHeader->AddColumn( "copy", DBTYPE_I4 );
itemHeader->AddColumn( "licensedProductionRunsRemaining", DBTYPE_I4 );
itemHeader->AddColumn( "damage", DBTYPE_R8 );
itemHeader->AddColumn( "flagID", DBTYPE_I2 );
std::map<uint32, ContractGetItemsRef>::const_iterator cur, end;
std::map<uint32, ContractGetItemsRef> items = contract->items();
cur = items.begin();
end = items.end();
for(; cur != end; cur++ )
{
PyPackedRow* data = new PyPackedRow( itemHeader );
InventoryItemRef item = m_manager->item_factory.GetItem( cur->second->m_itemID );
data->SetField( "contractID", new PyInt( contract->contractID() ) );
data->SetField( "itemID", new PyInt( item->itemID() ) );
data->SetField( "quantity", new PyInt( cur->second->m_quantity ) );
data->SetField( "itemTypeID", new PyInt( item->typeID() ) );
data->SetField( "inCrate", new PyBool( true ) );
if( item->categoryID() == EVEDB::invCategories::Blueprint )
{
BlueprintRef bp = m_manager->item_factory.GetBlueprint( item->itemID() );
data->SetField( "parentID", new PyInt( bp->parentBlueprintTypeID() ) );
data->SetField( "productivityLevel", new PyInt( bp->productivityLevel() ) );
data->SetField( "materialLevel", new PyInt( bp->materialLevel() ) );
data->SetField( "copy", new PyInt( bp->copy() ) );
data->SetField( "licensedProductionRunsRemaining", new PyInt( bp->licensedProductionRunsRemaining() ) );
if( bp->HasAttribute( 3 ) )
data->SetField( "damage", new PyFloat( bp->GetAttribute( 3 ).get_float() ) );
else
data->SetField( "damage", new PyFloat( 0.0 ) );
data->SetField( "flagID", new PyInt( bp->flag() ) );
}
else
{
data->SetField( "parentID", new PyInt( 0 ) );
data->SetField( "productivityLevel", new PyInt( 0 ) );
data->SetField( "materialLevel", new PyInt( 0 ) );
data->SetField( "copy", new PyInt( 0 ) );
data->SetField( "licensedProductionRunsRemaining", new PyInt( 0 ) );
if( item->HasAttribute( 3 ) )
data->SetField( "damage", new PyFloat( item->GetAttribute( 3 ).get_float() ) );
else
data->SetField( "damage", new PyFloat( 0.0 ) );
data->SetField( "flagID", new PyInt( item->flag() ) );
}
itemList->AddItem( data );
}
std::map<uint32, ContractRequestItemRef>::const_iterator c, e;
std::map<uint32, ContractRequestItemRef> requestItems = contract->requestItems();
c = requestItems.begin();
e = requestItems.end();
for(; c != e; c++ )
{
PyPackedRow* data = new PyPackedRow( itemHeader );
data->SetField( "contractID", new PyInt( arg.arg ) );
data->SetField( "itemID", new PyInt( 0 ) );
data->SetField( "quantity", new PyInt( c->second->m_quantity ) );
data->SetField( "itemTypeID", new PyInt( c->second->m_typeID ) );
data->SetField( "inCrate", new PyBool( false ) );
data->SetField( "parentID", new PyInt( 0 ) );
data->SetField( "productivityLevel", new PyInt( 0 ) );
data->SetField( "materialLevel", new PyInt( 0 ) );
data->SetField( "copy", new PyInt( 0 ) );
data->SetField( "licensedProductionRunsRemaining", new PyInt( 0 ) );
data->SetField( "damage", new PyFloat( 0.0 ) );
data->SetField( "flagID", new PyInt( 0 ) );
itemList->AddItem( data );
}
DBRowDescriptor *bidsHeader = new DBRowDescriptor();
bidsHeader->AddColumn( "bidID", DBTYPE_I4 );
bidsHeader->AddColumn( "contractID", DBTYPE_I4 );
bidsHeader->AddColumn( "issuerID", DBTYPE_I4 );
bidsHeader->AddColumn( "quantity", DBTYPE_I4 );
bidsHeader->AddColumn( "issuerCorpID", DBTYPE_I4 );
bidsHeader->AddColumn( "issuerStationID", DBTYPE_I4 );
bidsHeader->AddColumn( "issuerSolarSystemID", DBTYPE_I4 );
bidsHeader->AddColumn( "issuerRegionID", DBTYPE_I4 );
CRowSet *bids_rowset = new CRowSet( &bidsHeader );
_contract->SetItemString( "items", itemList );
_contract->SetItemString( "bids", bids_rowset );
_contract->SetItemString( "contract", into);
PyObject* res = new PyObject( new PyString( "util.KeyVal" ), _contract );
return res;
}
