def fetch_marketorders(apiupdate_pk):
try:
target, character = _get_character_auth(apiupdate_pk)
except CharacterSheet.DoesNotExist:
log.debug('CharacterSheet for APIUpdate {0} not indexed yet.'.format(
apiupdate_pk))
return
except APIUpdate.DoesNotExist:
log.warning('Target APIUpdate {0} was deleted mid-flight.'.format(
apiupdate_pk))
return
handler = EveAPIHandler()
auth = handler.get_authed_eveapi(target.apikey)
try:
api_data = auth.char.MarketOrders(characterID=target.owner)
except AuthenticationError:
log.error('AuthenticationError for key "{0}" owned by "{1}"'.format(
target.apikey.keyID, target.apikey.owner))
target.delete()
return
handler.autoparse_list(api_data.orders,
MarketOrder,
unique_together=('orderID', ),
extra_selectors={'owner': character},
owner=character,
pre_save=True)
target.updated(api_data)
def fetch_blueprints(apiupdate_pk):
try:
target, character = _get_character_auth(apiupdate_pk)
except CharacterSheet.DoesNotExist:
log.debug('CharacterSheet for APIUpdate {0} not indexed yet.'.format(
apiupdate_pk))
return
except APIUpdate.DoesNotExist:
log.warning('Target APIUpdate {0} was deleted mid-flight.'.format(
apiupdate_pk))
return
handler = EveAPIHandler()
auth = handler.get_authed_eveapi(target.apikey)
try:
api_data = auth.char.Blueprints(characterID=target.owner)
except AuthenticationError:
log.error('AuthenticationError for key "{0}" owned by "{1}"'.format(
target.apikey.keyID, target.apikey.owner))
target.delete()
return
blueprintsIDs = handler.autoparse_list(
api_data.blueprints,
Blueprint,
unique_together=('itemID', ),
extra_selectors={'owner': character},
owner=character,
pre_save=True)
Blueprint.objects.filter(owner=character) \
.exclude(pk__in=blueprintsIDs).delete()
target.updated(api_data)
def fetch_mailinglists(apiupdate_pk):
try:
target, character = _get_character_auth(apiupdate_pk)
except CharacterSheet.DoesNotExist:
log.debug('CharacterSheet for APIUpdate {0} not indexed yet.'.format(
apiupdate_pk))
return
except APIUpdate.DoesNotExist:
log.warning('Target APIUpdate {0} was deleted mid-flight.'.format(
apiupdate_pk))
return
handler = EveAPIHandler()
auth = handler.get_authed_eveapi(target.apikey)
try:
api_data = auth.char.MailingLists(characterID=target.owner)
except AuthenticationError:
log.error('AuthenticationError for key "{0}" owned by "{1}"'.format(
target.apikey.keyID, target.apikey.owner))
target.delete()
return
listIDs = handler.autoparse_shared_list(api_data.mailingLists,
MailingList, ('listID', ),
character,
pre_save=True)
unsubscribed = character.mailinglist_set.exclude(listID__in=listIDs)
for desub in unsubscribed:
desub.owners.remove(character)
target.updated(api_data)
def fetch_wallettransactions(apiupdate_pk):
try:
target, character = _get_character_auth(apiupdate_pk)
except CharacterSheet.DoesNotExist:
log.debug('CharacterSheet for APIUpdate {0} not indexed yet.'.format(
apiupdate_pk))
return
except APIUpdate.DoesNotExist:
log.warning('Target APIUpdate {0} was deleted mid-flight.'.format(
apiupdate_pk))
return
handler = EveAPIHandler()
auth = handler.get_authed_eveapi(target.apikey)
try:
api_data = auth.char.WalletTransactions(characterID=target.owner,
rowCount=2560)
except AuthenticationError:
log.error('AuthenticationError for key "{0}" owned by "{1}"'.format(
target.apikey.keyID, target.apikey.owner))
target.delete()
return
handler.autoparse_list(api_data.transactions,
WalletTransaction,
unique_together=('transactionID', ),
extra_selectors={'owner': character},
owner=character,
exclude=['transactionType', 'transactionFor'],
pre_save=True,
immutable=True)
target.updated(api_data)
def fetch_industryjobshistory(apiupdate_pk):
try:
target, character = _get_character_auth(apiupdate_pk)
except CharacterSheet.DoesNotExist:
log.debug('CharacterSheet for APIUpdate {0} not indexed yet.'.format(
apiupdate_pk))
return
except APIUpdate.DoesNotExist:
log.warning('Target APIUpdate {0} was deleted mid-flight.'.format(
apiupdate_pk))
return
handler = EveAPIHandler()
auth = handler.get_authed_eveapi(target.apikey)
try:
api_data = auth.char.IndustryJobsHistory(characterID=target.owner)
except AuthenticationError:
log.error('AuthenticationError for key "{0}" owned by "{1}"'.format(
target.apikey.keyID, target.apikey.owner))
target.delete()
return
handler.autoparse_list(api_data.jobs,
IndustryJobHistory,
unique_together=('jobID', ),
extra_selectors={'owner': character},
owner=character)
target.updated(api_data)
character_industry_jobs_history_updated.send(IndustryJobHistory,
characterID=character.pk)
def fetch_skill_in_training(apiupdate_pk):
try:
target, character = _get_character_auth(apiupdate_pk)
except CharacterSheet.DoesNotExist:
log.debug('CharacterSheet for APIUpdate {0} not indexed yet.'.format(
apiupdate_pk))
return
except APIUpdate.DoesNotExist:
log.warning('Target APIUpdate {0} was deleted mid-flight.'.format(
apiupdate_pk))
return
handler = EveAPIHandler()
auth = handler.get_authed_eveapi(target.apikey)
try:
api_data = auth.char.SkillInTraining(characterID=target.owner)
except AuthenticationError:
log.error('AuthenticationError for key "{0}" owned by "{1}"'.format(
target.apikey.keyID, target.apikey.owner))
target.delete()
return
obj = handler.autoparseObj(api_data,
SkillInTraining,
extra_selectors={'owner': character},
owner=character,
exclude=('currentTQTime', ))
obj.currentTQTime = api_data.currentTQTime.data
obj.save()
target.updated(api_data)
def fetch_assetlist(apiupdate_pk):
try:
target, character = _get_character_auth(apiupdate_pk)
except CharacterSheet.DoesNotExist:
log.debug('CharacterSheet for APIUpdate {0} not indexed yet.'.format(
apiupdate_pk))
return
except APIUpdate.DoesNotExist:
log.warning('Target APIUpdate {0} was deleted mid-flight.'.format(
apiupdate_pk))
return
handler = EveAPIHandler()
auth = handler.get_authed_eveapi(target.apikey)
try:
api_data = auth.char.AssetList(characterID=target.owner)
except AuthenticationError:
log.error('AuthenticationError for key "{0}" owned by "{1}"'.format(
target.apikey.keyID, target.apikey.owner))
target.delete()
return
assetlist = AssetList(owner=character,
retrieved=api_data._meta.currentTime)
assetlist.items, itemIDs_with_names = handler.asset_parser(
api_data.assets, Asset, character, target)
assetlist.save()
if target.apikey.can_call(
APICall.objects.get(type='Character', name='Locations')):
names_registered = 0
log.debug('Fetching the item name of {0} items.'.format(
len(itemIDs_with_names)))
for block in _blocker(itemIDs_with_names, 1000):
try:
if target.apikey.type == 'Account':
api_data = auth.char.Locations(characterID=character.pk,
IDs=','.join(block))
else:
api_data = auth.char.Locations(IDs=','.join(block))
except Exception, ex:
log.warning(
'Could not fetch names for itemIDs "{0}", with APIKey {1}.\n{2}'
.format(block, target.apikey.pk, format_exc(ex)))
continue
IDs = handler.autoparse_list(api_data.locations,
ItemLocationName,
unique_together=('itemID', ),
extra_selectors={'owner': character},
owner=character,
pre_save=True)
names_registered += len(IDs)
old_names = ItemLocationName.objects.filter(owner=character).exclude(
pk__in=itemIDs_with_names)
log.debug('Fetched {0} names and deleted {1} for "{2}"'.format(
names_registered, old_names.count(), character))
old_names.delete()
def fetch_notifications(apiupdate_pk):
try:
target, character = _get_character_auth(apiupdate_pk)
except CharacterSheet.DoesNotExist:
log.debug('CharacterSheet for APIUpdate {0} not indexed yet.'.format(
apiupdate_pk))
return
except APIUpdate.DoesNotExist:
log.warning('Target APIUpdate {0} was deleted mid-flight.'.format(
apiupdate_pk))
return
handler = EveAPIHandler()
auth = handler.get_authed_eveapi(target.apikey)
try:
api_data = auth.char.Notifications(characterID=target.owner)
except AuthenticationError:
log.error('AuthenticationError for key "{0}" owned by "{1}"'.format(
target.apikey.keyID, target.apikey.owner))
target.delete()
return
notifications, overlaped = handler.autoparse_list(
api_data.notifications,
Notification,
unique_together=('notificationID', ),
extra_selectors={'owner': character},
owner=character,
pre_save=True,
immutable=True)
unfetched_notifications = Notification.objects.filter(owner=character,
pk__in=notifications,
broken=False,
raw_message=None)
if unfetched_notifications.count() > 0:
note_texts = auth.char.NotificationTexts(
characterID=target.owner,
IDs=[note.notificationID for note in unfetched_notifications])
for note_data in note_texts.notifications:
try:
note = Notification.objects.get(
notificationID=note_data.notificationID,
owner=target.owner)
note.raw_message = note_data.data
note.save()
except Notification.DoesNotExist:
log.error(
'Could not fetch notification text for notificationID {0} belonging to character "{1}".'
.format(note_data.notificationID, character))
# except:
# note.broken = True
# note.save()
target.updated(api_data)
def fetch_contacts(apiupdate_pk):
try:
target, character = _get_character_auth(apiupdate_pk)
except CharacterSheet.DoesNotExist:
log.debug('CharacterSheet for APIUpdate {0} not indexed yet.'.format(
apiupdate_pk))
return
except APIUpdate.DoesNotExist:
log.warning('Target APIUpdate {0} was deleted mid-flight.'.format(
apiupdate_pk))
return
handler = EveAPIHandler()
auth = handler.get_authed_eveapi(target.apikey)
try:
api_data = auth.char.ContactList(characterID=target.owner)
except AuthenticationError:
log.error('AuthenticationError for key "{0}" owned by "{1}"'.format(
target.apikey.keyID, target.apikey.owner))
target.delete()
return
cIDs = handler.autoparse_list(api_data.contactList,
Contact,
unique_together=('contactID', ),
extra_selectors={
'owner': character,
'listType': 'Private'
},
owner=character,
pre_save=True)
cIDs.extend(
handler.autoparse_list(api_data.corporateContactList,
Contact,
unique_together=('contactID', ),
extra_selectors={
'owner': character,
'listType': 'Corporate'
},
owner=character,
pre_save=True))
cIDs.extend(
handler.autoparse_list(api_data.allianceContactList,
Contact,
unique_together=('contactID', ),
extra_selectors={
'owner': character,
'listType': 'Alliance'
},
owner=character,
pre_save=True))
Contact.objects.filter(owner=character).exclude(pk__in=cIDs).delete()
target.updated(api_data)
def fetch_reftypes():
handler = EveAPIHandler()
api = handler.get_eveapi()
apiData = api.eve.RefTypes()
rIDs = handler.autoparse_list(apiData.refTypes,
RefType,
unique_together=('refTypeID', ),
pre_save=True)
log.info('Updated {0} ref types.'.format(len(rIDs)))
update, created = UniverseUpdate.objects.get_or_create(apicall='RefTypes')
update.updated(apiData)
def fetch_mails(apiupdate_pk):
try:
target, character = _get_character_auth(apiupdate_pk)
except CharacterSheet.DoesNotExist:
log.debug('CharacterSheet for APIUpdate {0} not indexed yet.'.format(
apiupdate_pk))
return
except APIUpdate.DoesNotExist:
log.warning('Target APIUpdate {0} was deleted mid-flight.'.format(
apiupdate_pk))
return
handler = EveAPIHandler()
auth = handler.get_authed_eveapi(target.apikey)
try:
api_data = auth.char.MailMessages(characterID=target.owner)
except AuthenticationError:
log.error('AuthenticationError for key "{0}" owned by "{1}"'.format(
target.apikey.keyID, target.apikey.owner))
target.delete()
return
mails = handler.autoparse_shared_list(api_data.messages,
MailMessage, ('messageID', ),
character,
pre_save=True)
unfetched_mails = MailMessage.objects.filter(owners__in=[character.pk],
pk__in=mails,
broken=False,
raw_message=None)
EveName.objects.populate()
if unfetched_mails.count() > 0:
mail_bodies = auth.char.MailBodies(
characterID=target.owner,
IDs=[mail.messageID for mail in unfetched_mails])
for mail_body in mail_bodies.messages:
try:
mail = MailMessage.objects.get(messageID=mail_body.messageID)
mail.raw_message = mail_body.data
mail.populate_receivers()
mail.save()
except MailMessage.DoesNotExist:
log.error(
'Could not fetch message body for messageID {0} belonging to character "{1}".'
.format(mail_body.messageID, character))
# except:
# note.broken = True
# note.save()
target.updated(api_data)
def fetch_sovereignty():
handler = EveAPIHandler()
api = handler.get_eveapi()
apiData = api.map.Sovereignty()
sovIDs = handler.autoparse_list(apiData.solarSystems,
Sovereignty,
unique_together=('solarSystemID', ),
pre_save=True)
log.info('Updated sovereignty for {0} systems.'.format(len(sovIDs)))
update, created = UniverseUpdate.objects.get_or_create(
apicall='Sovereignty')
update.updated(apiData)
def fetch_conquerable_stations():
handler = EveAPIHandler()
api = handler.get_eveapi()
apiData = api.eve.ConquerableStationList()
stationIDs = handler.autoparse_list(apiData.outposts,
ConquerableStation,
unique_together=('stationID', ),
pre_save=True)
log.info('Updated {0} conquerable stations.'.format(len(stationIDs)))
update, created = UniverseUpdate.objects.get_or_create(
apicall='ConquerableStationList')
update.updated(apiData)
def get(self, request):
handler = EveAPIHandler()
api = handler.get_eveapi()
try:
status = api.server.ServerStatus()
response = json.dumps({
"serverOpen": status.serverOpen,
"onlinePlayers": status.onlinePlayers
})
except:
response = '{"serverOpen": "False", "onlinePlayers": 0}'
return HttpResponse(response)
def walk_walletjournal(apiupdate_pk, fromID):
try:
target, character = _get_character_auth(apiupdate_pk)
except CharacterSheet.DoesNotExist:
log.debug('CharacterSheet for APIUpdate {0} not indexed yet.'.format(
apiupdate_pk))
return
except APIUpdate.DoesNotExist:
log.warning('Target APIUpdate {0} was deleted mid-flight.'.format(
apiupdate_pk))
return
handler = EveAPIHandler()
auth = handler.get_authed_eveapi(target.apikey)
try:
api_data = auth.char.WalletJournal(characterID=character.pk,
rowCount=2560,
fromID=fromID)
except AuthenticationError:
log.error('AuthenticationError for key "{0}" owned by "{1}"'.format(
target.apikey.keyID, target.apikey.owner))
return
new_ids, overlap_ids = handler.autoparse_list(
api_data.transactions,
WalletJournal,
unique_together=['refID'],
extra_selectors={'owner': character},
owner=character,
pre_save=True,
immutable=True)
log.info(
'Walked {0} wallet journal entries for character "{1}". {2} new entries, {3} already known'
.format(
len(new_ids) + len(overlap_ids), character, len(new_ids),
len(overlap_ids)))
entry_ids = new_ids + overlap_ids
if len(api_data.transactions) >= 2560 and len(overlap_ids) < 2560:
last_journal_entry = WalletJournal.objects.filter(
owner=character, pk__in=entry_ids).aggregate(Min('refID'))
log.debug(
'Continuing wallet journal walk for "{0}" from redID {1}.'.format(
character, last_journal_entry))
app.send_task('character.walk_walletjournal',
[apiupdate_pk, last_journal_entry['refID__min']])
target.updated(api_data)
def fetch_apicalls():
handler = EveAPIHandler()
api = handler.get_eveapi()
apiData = api.api.CallList()
cgIDs = handler.autoparse_list(apiData.callGroups,
APICallGroup,
unique_together=('groupID', ),
pre_save=True)
cIDs = handler.autoparse_list(apiData.calls,
APICall,
unique_together=('accessMask', 'type'),
pre_save=True)
log.info('Added {0} call groups and {1} calls.'.format(cgIDs, cIDs))
update, created = UniverseUpdate.objects.get_or_create(apicall='CallList')
update.updated(apiData)
def fetch_alliances():
handler = EveAPIHandler()
api = handler.get_eveapi()
apiData = api.eve.AllianceList()
allianceIDs = handler.autoparse_list(apiData.alliances,
Alliance,
unique_together=('allianceID', ))
log.info('Updated {0} alliances.'.format(len(allianceIDs)))
closed = Alliance.objects.exclude(pk__in=allianceIDs)
for alliance in closed:
alliance.closed = True
alliance.endDate = datetime.now(tz=UTC)
alliance.save()
log.info('Closed {0} alliances.'.format(closed.count()))
update, created = UniverseUpdate.objects.get_or_create(
apicall='AllianceList')
update.updated(apiData)
def _blocker(itr, size):
for i in xrange(0, len(itr), size):
yield itr[i:i + size]
@app.task(name='character.fetch_charactersheet', max_retries=0)
def fetch_charactersheet(apiupdate_pk):
try:
target = APIUpdate.objects.get(pk=apiupdate_pk)
except APIUpdate.DoesNotExist, dne:
log.error('Target APIUpdate {0} was deleted mid-flight.'.format(
apiupdate_pk))
raise dne
apikey = target.apikey
handler = EveAPIHandler()
auth = handler.get_authed_eveapi(apikey)
try:
sheet = auth.char.CharacterSheet(characterID=target.owner)
except AuthenticationError:
log.error('AuthenticationError for key "{0}" owned by "{1}"'.format(
target.apikey.keyID, target.apikey.owner))
target.delete()
return
try:
character = CharacterSheet.objects.get(characterID=sheet.characterID)
# As long as the apikey can get a valid character sheet back from the
# eveapi, we'll allow the CS model to change owner and/or key
if character.owner_key != apikey:
def fetch_corporation_names():
handler = EveAPIHandler()
api = handler.get_eveapi()
