EvEmu  0.8.4
11 September 2021
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Modules Pages
APICharacterManager.cpp
Go to the documentation of this file.
1 /*
2  ------------------------------------------------------------------------------------
3  LICENSE:
4  ------------------------------------------------------------------------------------
5  This file is part of EVEmu: EVE Online Server Emulator
6  Copyright 2006 - 2021 The EVEmu Team
7  For the latest information visit https://evemu.dev
8  ------------------------------------------------------------------------------------
9  This program is free software; you can redistribute it and/or modify it under
10  the terms of the GNU Lesser General Public License as published by the Free Software
11  Foundation; either version 2 of the License, or (at your option) any later
12  version.
13 
14  This program is distributed in the hope that it will be useful, but WITHOUT
15  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
16  FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
17 
18  You should have received a copy of the GNU Lesser General Public License along with
19  this program; if not, write to the Free Software Foundation, Inc., 59 Temple
20  Place - Suite 330, Boston, MA 02111-1307, USA, or go to
21  http://www.gnu.org/copyleft/lesser.txt.
22  ------------------------------------------------------------------------------------
23  Author: Aknor Jaden
24 */
25 
26 #include "eve-server.h"
27 
28 #include "apiserver/APICharacterManager.h"
29 #include "inventory/AttributeEnum.h"
30 
31 APICharacterManager::APICharacterManager(const PyServiceMgr &services)
32 : APIServiceManager(services)
33 {
34 }
35 
36 std::tr1::shared_ptr<std::string> APICharacterManager::ProcessCall(const APICommandCall * pAPICommandCall)
37 {
38  sLog.Debug("APIAdminManager::ProcessCall()", "EVEmu API - Character Service Manager");
39 
40  if( pAPICommandCall->find( "servicehandler" ) == pAPICommandCall->end() )
41  {
42  sLog.Error( "APICharacterManager::ProcessCall()", "Cannot find 'servicehandler' specifier in pAPICommandCall packet" );
43  return std::tr1::shared_ptr<std::string>(new std::string(""));
44  }
45 
46  if( pAPICommandCall->find( "servicehandler" )->second == "CharacterSheet.xml.aspx" )
47  return _CharacterSheet(pAPICommandCall);
48  if( pAPICommandCall->find( "servicehandler" )->second == "SkillQueue.xml.aspx" )
49  return _SkillQueue(pAPICommandCall);
50  if( pAPICommandCall->find( "servicehandler" )->second == "SkillInTraining.xml.aspx" )
51  return _SkillInTraining(pAPICommandCall);
52  //else if( pAPICommandCall->find( "servicehandler" )->second == "TODO.xml.aspx" )
53  // return _TODO(pAPICommandCall);
54  else
55  {
56  sLog.Error("APIAdminManager::ProcessCall()", "EVEmu API - Admin Service Manager - ERROR: Cannot resolve '%s' as a valid service query for Admin Service Manager",
57  pAPICommandCall->find("servicehandler")->second.c_str() );
58  return std::tr1::shared_ptr<std::string>(new std::string(""));
59  }
60  sLog.Debug("APICharacterManager::ProcessCall()", "EVEmu API - Character Service Manager");
61 
62  return BuildErrorXMLResponse( "9999", "EVEmu API Server: Character Manager - Unknown call." );
63 }
64 
65 std::tr1::shared_ptr<std::string> APICharacterManager::_CharacterSheet(const APICommandCall * pAPICommandCall)
66 {
67  size_t i;
68 
69  sLog.Error( "APICharacterManager::_CharacterSheet()", "TODO: Insert code to validate userID and apiKey" );
70 
71  sLog.Debug("APICharacterManager::_CharacterSheet()", "EVEmu API - Character Service Manager - CALL: CharacterSheet.xml.aspx");
72 
73  if( pAPICommandCall->find( "userid" ) == pAPICommandCall->end() )
74  {
75  sLog.Error( "APICharacterManager::_CharacterSheet()", "ERROR: No 'userID' parameter found in call argument list - exiting with error and sending back NOTHING" );
76  return BuildErrorXMLResponse( "106", "Must provide userID parameter for authentication." );
77  }
78 
79  if( pAPICommandCall->find( "apikey" ) == pAPICommandCall->end() )
80  {
81  sLog.Error( "APICharacterManager::_CharacterSheet()", "ERROR: No 'apiKey' parameter found in call argument list - exiting with error and sending back NOTHING" );
82  return BuildErrorXMLResponse( "203", "Authentication failure." );
83  }
84 
85  if( pAPICommandCall->find( "characterid" ) == pAPICommandCall->end() )
86  {
87  sLog.Error( "APICharacterManager::_CharacterSheet()", "ERROR: No 'characterID' parameter found in call argument list - exiting with error and sending back NOTHING" );
88  return BuildErrorXMLResponse( "105", "Invalid characterID." );
89  }
90 
91  // Make calls to the APICharacterDB class to grab all data for this call and populate the xml structure with that data
92  uint32 characterID = atoi( pAPICommandCall->find( "characterid" )->second.c_str() );
93  std::vector<std::string> skillTypeIDList;
94  std::vector<std::string> skillPointsList;
95  std::vector<std::string> skillLevelList;
96  std::vector<std::string> skillPublishedList;
97  m_charDB.GetCharacterSkillsTrained( characterID, skillTypeIDList, skillPointsList, skillLevelList, skillPublishedList );
98 
99  std::vector<std::string> charInfoList;
100  m_charDB.GetCharacterInfo( characterID, charInfoList );
101 
102  std::map<std::string, std::string> charAttributes;
103  m_charDB.GetCharacterAttributes( characterID, charAttributes );
104 
105  sLog.Error( "APICharacterManager::_CharacterSheet()", "INFO: Sections Currently hard-coded: attributeEnhancers, certificates, corporation roles" );
106 
107  std::vector<std::string> rowset;
108  _BuildXMLHeader();
109  {
110  _BuildXMLTag( "result" );
111  {
112  _BuildSingleXMLTag( "characterID", std::string(itoa(characterID)) );
113  _BuildSingleXMLTag( "name", charInfoList.at(12) );
114  _BuildSingleXMLTag( "DoB", Win32TimeToString(strtoull(charInfoList.at(8).c_str(), NULL, 0) ));
115  _BuildSingleXMLTag( "race", charInfoList.at(11) );
116  _BuildSingleXMLTag( "bloodLine", charInfoList.at(10) );
117  _BuildSingleXMLTag( "ancestry", charInfoList.at(9) );
118  _BuildSingleXMLTag( "gender", ( (atoi(charInfoList.at(14).c_str()) > 0) ? "Male" : "Female") );
119  _BuildSingleXMLTag( "corporationName", charInfoList.at(13) );
120  _BuildSingleXMLTag( "corporationID", charInfoList.at(2) );
121  _BuildSingleXMLTag( "allianceName", "none" );
122  _BuildSingleXMLTag( "allianceID", "0" );
123  _BuildSingleXMLTag( "cloneName", "Clone Grade Pi" );
124  _BuildSingleXMLTag( "cloneSkillPoints", "54600000" );
125  _BuildSingleXMLTag( "balance", charInfoList.at(0) );
126 
127  // TODO: code these for real, as what follows are hard coded examples to fill out the whole xml document:
128  // Attribute Enhancers (implants)
129  _BuildXMLTag( "attributeEnhancers" );
130  {
131  /*
132  _BuildXMLTag( "memoryBonus" );
133  {
134  _BuildSingleXMLTag( "augmentatorName", "Memory Augmentation - Basic" );
135  _BuildSingleXMLTag( "augmentatorValue", "3" );
136  }
137  _CloseXMLTag(); // close tag "memoryBonus"
138  _BuildXMLTag( "perceptionBonus" );
139  {
140  _BuildSingleXMLTag( "augmentatorName", "Ocular Filter - Basic" );
141  _BuildSingleXMLTag( "augmentatorValue", "3" );
142  }
143  _CloseXMLTag(); // close tag "perceptionBonus"
144  _BuildXMLTag( "willpowerBonus" );
145  {
146  _BuildSingleXMLTag( "augmentatorName", "Neural Boost - Basic" );
147  _BuildSingleXMLTag( "augmentatorValue", "3" );
148  }
149  _CloseXMLTag(); // close tag "willpowerBonus"
150  _BuildXMLTag( "intelligenceBonus" );
151  {
152  _BuildSingleXMLTag( "augmentatorName", "Snake Delta" );
153  _BuildSingleXMLTag( "augmentatorValue", "3" );
154  }
155  _CloseXMLTag(); // close tag "intelligenceBonus"
156  _BuildXMLTag( "charismaBonus" );
157  {
158  _BuildSingleXMLTag( "augmentatorName", "Limited Social Adaptation Chip" );
159  _BuildSingleXMLTag( "augmentatorValue", "3" );
160  }
161  _CloseXMLTag(); // close tag "charismaBonus"
162  */
163  }
164  _CloseXMLTag(); // close tag "attributeEnhancers"
165 
166  // TODO: code these for real, as what follows are hard coded examples to fill out the whole xml document:
167  // Attributes
168  _BuildXMLTag( "attributes" );
169  {
170  _BuildSingleXMLTag( "intelligence", charAttributes.find( std::string(itoa(AttrIntelligence)))->second );
171  _BuildSingleXMLTag( "memory", charAttributes.find( std::string(itoa(AttrMemory)))->second );
172  _BuildSingleXMLTag( "charisma", charAttributes.find( std::string(itoa(AttrCharisma)))->second );
173  _BuildSingleXMLTag( "perception", charAttributes.find( std::string(itoa(AttrPerception)))->second );
174  _BuildSingleXMLTag( "willpower", charAttributes.find( std::string(itoa(AttrWillpower)))->second );
175  }
176  _CloseXMLTag(); // close tag "attributes"
177 
178  // Skills
179  rowset.clear();
180  rowset.push_back("typeID");
181  rowset.push_back("skillpoints");
182  rowset.push_back("level");
183  rowset.push_back("published");
184  _BuildXMLRowSet( "skills", "typeID", &rowset );
185  {
186  for(i=0; i<skillTypeIDList.size(); i++)
187  {
188  rowset.clear();
189  rowset.push_back(skillTypeIDList.at(i));
190  rowset.push_back(skillPointsList.at(i));
191  rowset.push_back(skillLevelList.at(i));
192  rowset.push_back(skillPublishedList.at(i));
193  _BuildXMLRow( &rowset );
194  }
195  }
196  _CloseXMLRowSet(); // close rowset "skills"
197 
198  // TODO: code these for real, as what follows are hard coded examples to fill out the whole xml document:
199  // Certificates:
200  rowset.clear();
201  rowset.push_back("certificateID");
202  _BuildXMLRowSet( "certificates", "certificateID", &rowset );
203  {
204  // for(i=0; i<skillTypeIDList.size(); i++)
205  // {
206  rowset.clear();
207  //rowset.push_back(certificatesList.at(i));
208  rowset.push_back("1");
209  _BuildXMLRow( &rowset );
210  // }
211  }
212  _CloseXMLRowSet(); // close rowset "certificates"
213 
214  // TODO: code these for real, as what follows are hard coded examples to fill out the whole xml document:
215  // Corporation Roles:
216  //rowset.clear();
217  //rowset.push_back("");
218  //_BuildXMLRowSet( "", "", &rowset );
219  //{
220  //}
221  _CloseXMLRowSet(); // close rowset ""
222  }
223  _CloseXMLTag(); // close tag "result"
224  }
225  _CloseXMLHeader( EVEAPI::CacheStyles::Long );
226 
227  return _GetXMLDocumentString();
228 }
229 
230 std::tr1::shared_ptr<std::string> APICharacterManager::_SkillQueue(const APICommandCall * pAPICommandCall)
231 {
232  size_t i;
233 
234  sLog.Error( "APICharacterManager::_SkillQueue()", "TODO: Insert code to validate userID and apiKey" );
235 
236  sLog.Debug("APICharacterManager::_SkillQueue()", "EVEmu API - Character Service Manager - CALL: SkillQueue.xml.aspx");
237 
238  if( pAPICommandCall->find( "userid" ) == pAPICommandCall->end() )
239  {
240  sLog.Error( "APICharacterManager::_SkillQueue()", "ERROR: No 'userID' parameter found in call argument list - exiting with error and sending back NOTHING" );
241  return BuildErrorXMLResponse( "106", "Must provide userID parameter for authentication." );
242  }
243 
244  if( pAPICommandCall->find( "apikey" ) == pAPICommandCall->end() )
245  {
246  sLog.Error( "APICharacterManager::_SkillQueue()", "ERROR: No 'apiKey' parameter found in call argument list - exiting with error and sending back NOTHING" );
247  return BuildErrorXMLResponse( "203", "Authentication failure." );
248  }
249 
250  if( pAPICommandCall->find( "characterid" ) == pAPICommandCall->end() )
251  {
252  sLog.Error( "APICharacterManager::_SkillQueue()", "ERROR: No 'characterID' parameter found in call argument list - exiting with error and sending back NOTHING" );
253  return BuildErrorXMLResponse( "105", "Invalid characterID." );
254  }
255 
256  // Make calls to the APICharacterDB class to grab all data for this call and populate the xml structure with that data
257  uint32 characterID = atoi( pAPICommandCall->find( "characterid" )->second.c_str() );
258 
259  std::map<std::string, std::string> charLearningAttributesString;
260  std::map<uint32, uint32> charLearningAttributes;
261  m_charDB.GetCharacterAttributes( characterID, charLearningAttributesString );
262  charLearningAttributes.insert( std::pair<uint32, uint32>( AttrMemory, ((uint32)(atoi(charLearningAttributesString.find(std::string(itoa(AttrMemory)))->second.c_str()))) ));
263  charLearningAttributes.insert( std::pair<uint32, uint32>( AttrIntelligence, ((uint32)(atoi(charLearningAttributesString.find(std::string(itoa(AttrIntelligence)))->second.c_str()))) ));
264  charLearningAttributes.insert( std::pair<uint32, uint32>( AttrCharisma, ((uint32)(atoi(charLearningAttributesString.find(std::string(itoa(AttrCharisma)))->second.c_str()))) ));
265  charLearningAttributes.insert( std::pair<uint32, uint32>( AttrWillpower, ((uint32)(atoi(charLearningAttributesString.find(std::string(itoa(AttrWillpower)))->second.c_str()))) ));
266  charLearningAttributes.insert( std::pair<uint32, uint32>( AttrPerception, ((uint32)(atoi(charLearningAttributesString.find(std::string(itoa(AttrPerception)))->second.c_str()))) ));
267 
268  std::vector<std::string> queueOrderList;
269  std::vector<std::string> queueSkillTypeIdList;
270  std::vector<std::string> queueSkillLevelList;
271  std::vector<std::string> queueSkillRankList;
272  std::vector<std::string> queueSkillIdList;
273  std::vector<std::string> queueSkillPrimaryAttrList;
274  std::vector<std::string> queueSkillSecondaryAttrList;
275  std::vector<std::string> queueSkillPointsTrainedList;
276 
277  uint32 queueSkillPrimaryAttribute;
278  uint32 queueSkillSecondaryAttribute;
279  std::vector<uint32> queueSkillStartSP;
280  std::vector<uint32> queueSkillEndSP;
281  std::vector<uint64> queueSkillStartTime;
282  std::vector<uint64> queueSkillEndTime;
283  EvilNumber spPerMinute(0.0);
284  EvilNumber skillStartSP(0.0);
285  EvilNumber skillEndSP(0.0);
286  EvilNumber timeNow(0.0);
287  uint64 skillStartTime;
288  uint64 skillEndTime;
289 
290  bool status = m_charDB.GetCharacterSkillQueue( characterID, queueOrderList, queueSkillTypeIdList, queueSkillLevelList, queueSkillRankList,
291  queueSkillIdList, queueSkillPrimaryAttrList, queueSkillSecondaryAttrList, queueSkillPointsTrainedList );
292 
293  sLog.Error( "APICharacterManager::_SkillQueue()", "INFO: Calculation of Skill End Time based on Effective SP/min does NOT include implants/boosters at this time" );
294 
295  if( status )
296  {
297  timeNow = EvilTimeNow();
298  for( i=0; i<queueOrderList.size(); i++ )
299  {
300  queueSkillPrimaryAttribute = charLearningAttributes.find( atoi(queueSkillPrimaryAttrList.at(i).c_str()) )->second;
301  queueSkillSecondaryAttribute = charLearningAttributes.find( atoi(queueSkillSecondaryAttrList.at(i).c_str()) )->second;
302  skillStartSP = EvilNumber(atoi( queueSkillPointsTrainedList.at(i).c_str() ));
303  queueSkillStartSP.push_back( static_cast<uint32>( skillStartSP.get_int() ));
304  skillEndSP = SkillPointsAtLevel( atoi(queueSkillLevelList.at(i).c_str()), atoi(queueSkillRankList.at(i).c_str()) );
305  queueSkillEndSP.push_back( static_cast<uint32>( skillEndSP.get_int() ) );
306  spPerMinute = SkillPointsPerMinute( queueSkillPrimaryAttribute, queueSkillSecondaryAttribute );
307  skillStartTime = static_cast<uint64>(SkillStartingTime( skillStartSP, skillEndSP, spPerMinute, timeNow ).get_int());
308  skillEndTime = static_cast<uint64>(SkillEndingTime( skillStartSP, skillEndSP, spPerMinute, timeNow ).get_int());
309  queueSkillStartTime.push_back( skillStartTime );
310  queueSkillEndTime.push_back( skillEndTime );
311  timeNow = skillEndTime;
312  }
313  }
314 
315  // EXAMPLE:
316  std::vector<std::string> rowset;
317  _BuildXMLHeader();
318  {
319  _BuildXMLTag( "result" );
320  {
321  // Skill Queue
322  rowset.push_back("queuePosition");
323  rowset.push_back("typeID");
324  rowset.push_back("level");
325  rowset.push_back("startSP");
326  rowset.push_back("endSP");
327  rowset.push_back("startTime");
328  rowset.push_back("endTime");
329  _BuildXMLRowSet( "skillqueue", "queuePosition", &rowset );
330  {
331  if( status )
332  {
333  for(i=0; i<queueOrderList.size(); i++)
334  {
335  rowset.clear();
336  rowset.push_back( queueOrderList.at(i) );
337  rowset.push_back( queueSkillTypeIdList.at(i) );
338  rowset.push_back( queueSkillLevelList.at(i) );
339  rowset.push_back( std::string(itoa(queueSkillStartSP.at(i))) );
340  rowset.push_back( std::string(itoa(queueSkillEndSP.at(i))) );
341  rowset.push_back( Win32TimeToString(queueSkillStartTime.at(i)) );
342  rowset.push_back( Win32TimeToString(queueSkillEndTime.at(i)) );
343  _BuildXMLRow( &rowset );
344  }
345  }
346  }
347  _CloseXMLRowSet(); // close rowset "skillqueue"
348  }
349  _CloseXMLTag(); // close tag "result"
350  }
351  _CloseXMLHeader( EVEAPI::CacheStyles::Modified );
352 
353  return _GetXMLDocumentString();
354 }
355 
356 std::tr1::shared_ptr<std::string> APICharacterManager::_SkillInTraining(const APICommandCall * pAPICommandCall)
357 {
358  sLog.Error( "APICharacterManager::_SkillInTraining()", "TODO: Insert code to validate userID and apiKey" );
359 
360  sLog.Debug("APICharacterManager::_SkillInTraining()", "EVEmu API - Character Service Manager - CALL: SkillInTraining.xml.aspx");
361 
362  if( pAPICommandCall->find( "userid" ) == pAPICommandCall->end() )
363  {
364  sLog.Error( "APICharacterManager::_SkillInTraining()", "ERROR: No 'userID' parameter found in call argument list - exiting with error and sending back NOTHING" );
365  return BuildErrorXMLResponse( "106", "Must provide userID parameter for authentication." );
366  }
367 
368  if( pAPICommandCall->find( "apikey" ) == pAPICommandCall->end() )
369  {
370  sLog.Error( "APICharacterManager::_SkillInTraining()", "ERROR: No 'apiKey' parameter found in call argument list - exiting with error and sending back NOTHING" );
371  return BuildErrorXMLResponse( "203", "Authentication failure." );
372  }
373 
374  if( pAPICommandCall->find( "characterid" ) == pAPICommandCall->end() )
375  {
376  sLog.Error( "APICharacterManager::_SkillInTraining()", "ERROR: No 'characterID' parameter found in call argument list - exiting with error and sending back NOTHING" );
377  return BuildErrorXMLResponse( "105", "Invalid characterID." );
378  }
379 
380  // Make calls to the APICharacterDB class to grab all data for this call and populate the xml structure with that data
381  uint32 characterID = atoi( pAPICommandCall->find( "characterid" )->second.c_str() );
382 
383  std::map<std::string, std::string> charLearningAttributesString;
384  std::map<uint32, uint32> charLearningAttributes;
385  m_charDB.GetCharacterAttributes( characterID, charLearningAttributesString );
386  charLearningAttributes.insert( std::pair<uint32, uint32>( AttrMemory, ((uint32)(atoi(charLearningAttributesString.find(std::string(itoa(AttrMemory)))->second.c_str()))) ));
387  charLearningAttributes.insert( std::pair<uint32, uint32>( AttrIntelligence, ((uint32)(atoi(charLearningAttributesString.find(std::string(itoa(AttrIntelligence)))->second.c_str()))) ));
388  charLearningAttributes.insert( std::pair<uint32, uint32>( AttrCharisma, ((uint32)(atoi(charLearningAttributesString.find(std::string(itoa(AttrCharisma)))->second.c_str()))) ));
389  charLearningAttributes.insert( std::pair<uint32, uint32>( AttrWillpower, ((uint32)(atoi(charLearningAttributesString.find(std::string(itoa(AttrWillpower)))->second.c_str()))) ));
390  charLearningAttributes.insert( std::pair<uint32, uint32>( AttrPerception, ((uint32)(atoi(charLearningAttributesString.find(std::string(itoa(AttrPerception)))->second.c_str()))) ));
391 
392  std::vector<std::string> queueOrderList;
393  std::vector<std::string> queueSkillTypeIdList;
394  std::vector<std::string> queueSkillLevelList;
395  std::vector<std::string> queueSkillRankList;
396  std::vector<std::string> queueSkillIdList;
397  std::vector<std::string> queueSkillPrimaryAttrList;
398  std::vector<std::string> queueSkillSecondaryAttrList;
399  std::vector<std::string> queueSkillPointsTrainedList;
400 
401  uint32 queueSkillPrimaryAttribute;
402  uint32 queueSkillSecondaryAttribute;
403  std::vector<uint32> queueSkillStartSP;
404  std::vector<uint32> queueSkillEndSP;
405  std::vector<uint64> queueSkillStartTime;
406  std::vector<uint64> queueSkillEndTime;
407  EvilNumber spPerMinute(0.0);
408  EvilNumber skillStartSP(0.0);
409  EvilNumber skillEndSP(0.0);
410  EvilNumber timeNow(0.0);
411  uint64 skillStartTime;
412  uint64 skillEndTime;
413 
414  bool status = m_charDB.GetCharacterSkillQueue( characterID, queueOrderList, queueSkillTypeIdList, queueSkillLevelList, queueSkillRankList,
415  queueSkillIdList, queueSkillPrimaryAttrList, queueSkillSecondaryAttrList, queueSkillPointsTrainedList );
416 
417  if( status )
418  {
419  sLog.Error( "APICharacterManager::_SkillInTraining()", "INFO: Calculation of Skill End Time based on Effective SP/min does NOT include implants/boosters at this time" );
420  timeNow = EvilTimeNow();
421 
422  queueSkillPrimaryAttribute = charLearningAttributes.find( atoi(queueSkillPrimaryAttrList.at(0).c_str()) )->second;
423  queueSkillSecondaryAttribute = charLearningAttributes.find( atoi(queueSkillSecondaryAttrList.at(0).c_str()) )->second;
424  skillStartSP = EvilNumber(atoi( queueSkillPointsTrainedList.at(0).c_str() ));
425  queueSkillStartSP.push_back( static_cast<uint32>( skillStartSP.get_int() ));
426  skillEndSP = SkillPointsAtLevel( atoi(queueSkillLevelList.at(0).c_str()), atoi(queueSkillRankList.at(0).c_str()) );
427  queueSkillEndSP.push_back( static_cast<uint32>( skillEndSP.get_int() ) );
428  spPerMinute = SkillPointsPerMinute( queueSkillPrimaryAttribute, queueSkillSecondaryAttribute );
429  skillStartTime = static_cast<uint64>(SkillStartingTime( skillStartSP, skillEndSP, spPerMinute, timeNow ).get_int());
430  skillEndTime = static_cast<uint64>(SkillEndingTime( skillStartSP, skillEndSP, spPerMinute, timeNow ).get_int());
431  queueSkillStartTime.push_back( skillStartTime );
432  queueSkillEndTime.push_back( skillEndTime );
433  }
434 
435  // EXAMPLE:
436  std::vector<std::string> rowset;
437  _BuildXMLHeader();
438  {
439  _BuildXMLTag( "result" );
440  {
441  if( status )
442  {
443  _BuildSingleXMLTag( "currentTQTime", Win32TimeToString(static_cast<uint64>(timeNow.get_int())) );
444  _BuildSingleXMLTag( "trainingEndTime", Win32TimeToString(skillEndTime) );
445  _BuildSingleXMLTag( "trainingStartTime", Win32TimeToString(skillStartTime) );
446  _BuildSingleXMLTag( "trainingTypeID", queueSkillTypeIdList.at(0) );
447  _BuildSingleXMLTag( "trainingStartSP", std::string(itoa(skillStartSP.get_int())) );
448  _BuildSingleXMLTag( "trainingDestinationSP", std::string(itoa(skillEndSP.get_int())) );
449  _BuildSingleXMLTag( "trainingToLevel", queueSkillLevelList.at(0) );
450  _BuildSingleXMLTag( "skillInTraining", "1" );
451  }
452  else
453  {
454  _BuildSingleXMLTag( "skillInTraining", "0" );
455  }
456  }
457  _CloseXMLTag(); // close tag "result"
458  }
459  _CloseXMLHeader( EVEAPI::CacheStyles::Modified );
460 
461  return _GetXMLDocumentString();
462 }
APIServiceManager::BuildErrorXMLResponse
std::tr1::shared_ptr< std::string > BuildErrorXMLResponse(std::string errorCode, std::string errorMessage)
Definition: APIServiceManager.cpp:131
APIServiceManager::_GetXMLDocumentString
std::tr1::shared_ptr< std::string > _GetXMLDocumentString()
Definition: APIServiceManager.cpp:345
APICharacterManager::ProcessCall
std::tr1::shared_ptr< std::string > ProcessCall(const APICommandCall *pAPICommandCall)
Definition: APICharacterManager.cpp:36
APICharacterManager::_CharacterSheet
std::tr1::shared_ptr< std::string > _CharacterSheet(const APICommandCall *pAPICommandCall)
Definition: APICharacterManager.cpp:65
APICharacterManager::_SkillQueue
std::tr1::shared_ptr< std::string > _SkillQueue(const APICommandCall *pAPICommandCall)
Definition: APICharacterManager.cpp:230
APIServiceManager::_BuildSingleXMLTag
void _BuildSingleXMLTag(std::string name, std::string param)
Definition: APIServiceManager.cpp:305
EvilNumber
this is a class that kinda mimics how python polymorph's numbers.
Definition: EvilNumber.h:59
APICharacterDB::GetCharacterInfo
bool GetCharacterInfo(uint32 characterID, std::vector< std::string > &charInfoList)
?
Definition: APICharacterDB.cpp:110
APICharacterManager::_SkillInTraining
std::tr1::shared_ptr< std::string > _SkillInTraining(const APICommandCall *pAPICommandCall)
Definition: APICharacterManager.cpp:356
APICommandCall
std::map< std::string, std::string > APICommandCall
Definition: APIServiceManager.h:59
sLog
#define sLog
Evaluates to a NewLog instance.
Definition: LogNew.h:250
APICharacterDB::GetCharacterSkillQueue
bool GetCharacterSkillQueue(uint32 characterID, std::vector< std::string > &orderList, std::vector< std::string > &typeIdList, std::vector< std::string > &levelList, std::vector< std::string > &rankList, std::vector< std::string > &skillIdList, std::vector< std::string > &primaryAttrList, std::vector< std::string > &secondaryAttrList, std::vector< std::string > &skillPointsTrainedList)
?
Definition: APICharacterDB.cpp:259
EvilNumber::get_int
int64 get_int()
Definition: EvilNumber.cpp:166
APIServiceManager
Generic Base Class used to derive classes for specific service handlers (character, corporation, etc)
Definition: APIServiceManager.h:73
APICharacterDB::GetCharacterAttributes
bool GetCharacterAttributes(uint32 characterID, std::map< std::string, std::string > &attribList)
?
Definition: APICharacterDB.cpp:170
uint32
unsigned __int32 uint32
Definition: eve-compat.h:50
APIServiceManager::_BuildXMLTag
void _BuildXMLTag(std::string name)
Definition: APIServiceManager.cpp:280
APICharacterManager::APICharacterManager
APICharacterManager(const PyServiceMgr &services)
Definition: APICharacterManager.cpp:31
strtoull
#define strtoull
Definition: eve-compat.h:247
Win32TimeToString
std::string Win32TimeToString(int64 win32t)
Definition: utils_time.cpp:59
APICharacterDB::GetCharacterSkillsTrained
bool GetCharacterSkillsTrained(uint32 characterID, std::vector< std::string > &skillTypeIDList, std::vector< std::string > &skillPointsList, std::vector< std::string > &skillLevelList, std::vector< std::string > &skillPublishedList)
?
Definition: APICharacterDB.cpp:35
APIServiceManager::_BuildXMLRow
void _BuildXMLRow(const std::vector< std::string > *columns)
Definition: APIServiceManager.cpp:259
APIServiceManager::_CloseXMLHeader
void _CloseXMLHeader(uint32 cacheStyle)
Definition: APIServiceManager.cpp:214
APIServiceManager::_BuildXMLRowSet
void _BuildXMLRowSet(std::string name, std::string key, const std::vector< std::string > *columns)
Definition: APIServiceManager.cpp:233
itoa
const char * itoa(int64 num)
Convers num to string.
Definition: utils_string.cpp:159