def fetch_starbaselist(apiupdate_pk): try: target, corporation = _get_corporation_auth(apiupdate_pk) except CorporationSheet.DoesNotExist: log.debug("CorporationSheet 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(corporation.owner_key) try: api_data = auth.corp.StarbaseList(characterID=corporation.owner_key.characterID) except AuthenticationError: log.error('AuthenticationError for key "{0}" owned by "{1}"'.format(target.apikey.keyID, target.apikey.owner)) target.delete() return posIDs = handler.autoparse_list( api_data.starbases, Starbase, unique_together=("itemID",), extra_selectors={"owner": corporation}, owner=corporation, pre_save=True, ) Starbase.objects.filter(owner=corporation).exclude(pk__in=posIDs).delete() target.updated(api_data)
def fetch_outpostservicedetails(apiupdate_pk, stationID): try: target, corporation = _get_corporation_auth(apiupdate_pk) except CorporationSheet.DoesNotExist: log.debug("CorporationSheet 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.corp.OutpostServiceDetail(itemID=stationID) except AuthenticationError: log.error('AuthenticationError for key "{0}" owned by "{1}"'.format(target.apikey.keyID, target.apikey.owner)) target.delete() return outpost_services_ids = handler.autoparse_list( api_data.outpostServiceDetails, OutpostService, unique_together=("stationID", "serviceName"), extra_selectors={"owner": corporation}, owner=corporation, ) OutpostService.objects.filter(owner=corporation).exclude(pk__in=outpost_services_ids).delete() target.updated(api_data) corporation_outpost_services_updated.send(OutpostService, corporationID=corporation.pk, stationID=stationID)
def fetch_blueprints(apiupdate_pk): try: target, corporation = _get_corporation_auth(apiupdate_pk) except CorporationSheet.DoesNotExist: log.debug('CorporationSheet 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(corporation.owner_key) try: api_data = auth.corp.Blueprints(characterID=corporation.owner_key.characterID) 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': corporation}, owner=corporation, pre_save=True) Blueprint.objects.filter(owner=corporation) \ .exclude(pk__in=blueprintsIDs).delete() target.updated(api_data)
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_skillqueue(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.SkillQueue(characterID=target.owner) except AuthenticationError: log.error('AuthenticationError for key "{0}" owned by "{1}"'.format( target.apikey.keyID, target.apikey.owner )) target.delete() return skills = handler.autoparse_list(api_data.skillqueue, SkillQueue, unique_together=('typeID', 'level'), extra_selectors={'owner': character}, owner=character, pre_save=True) SkillQueue.objects.filter(owner=character).exclude(pk__in=skills).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_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_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_contracts(apiupdate_pk): try: target, corporation = _get_corporation_auth(apiupdate_pk) except CorporationSheet.DoesNotExist: log.debug("CorporationSheet 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.corp.Contracts() except AuthenticationError: log.error('AuthenticationError for key "{0}" owned by "{1}"'.format(target.apikey.keyID, target.apikey.owner)) target.delete() return contract_ids = handler.autoparse_list( api_data.contractList, Contract, unique_together=("contractID",), extra_selectors={"owner": corporation}, owner=corporation, ) target.updated(api_data) corporation_contracts_updated.send(Contract, corporationID=corporation.pk) for id in contract_ids: contract = Contract.objects.get(pk=id) if contract.get_items().count() == 0: app.send_task("corporation.fetch_contractitems", [target.pk, contract.pk])
def fetch_contractbids(apiupdate_pk): try: target, corporation = _get_corporation_auth(apiupdate_pk) except CorporationSheet.DoesNotExist: log.debug("CorporationSheet 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.corp.ContractBids() except AuthenticationError: log.error('AuthenticationError for key "{0}" owned by "{1}"'.format(target.apikey.keyID, target.apikey.owner)) target.delete() return bid_ids, overlap = handler.autoparse_list( api_data.bidList, ContractBid, unique_together=("contractID", "bidID"), extra_selectors={"owner": corporation}, owner=corporation, immutable=True, ) target.updated(api_data) # Only trigger if there are new bids for bid in ContractBid.objects.filter(pk__in=bid_ids): corporation_contract_bids_new_bid.send( ContractBid, corporationID=corporation.pk, contractID=bid.contractID, bid_pk=bid.pk ) corporation_contract_bids_updated.send(ContractBid, corporationID=corporation.pk)
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_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_facilities(apiupdate_pk): try: target, corporation = _get_corporation_auth(apiupdate_pk) except CorporationSheet.DoesNotExist: log.debug("CorporationSheet 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.corp.Facilities() except AuthenticationError: log.error('AuthenticationError for key "{0}" owned by "{1}"'.format(target.apikey.keyID, target.apikey.owner)) target.delete() return facility_ids = handler.autoparse_list( api_data.facilities, Facility, unique_together=("facilityID",), extra_selectors={"owner": corporation}, owner=corporation, ) Facility.objects.filter(owner=corporation).exclude(pk__in=facility_ids).delete() target.updated(api_data) corporation_facilities_updated.send(Facility, corporationID=corporation.pk)
def fetch_accountbalance(apiupdate_pk): try: target, corporation = _get_corporation_auth(apiupdate_pk) except CorporationSheet.DoesNotExist: log.debug('CorporationSheet 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(corporation.owner_key) try: api_data = auth.corp.AccountBalance(characterID=corporation.owner_key.characterID) 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.accounts, AccountBalance, unique_together=('accountKey',), extra_selectors={'owner': corporation}, owner=corporation, pre_save=True) target.updated(api_data)
def fetch_membermedals(apiupdate_pk): try: target, corporation = _get_corporation_auth(apiupdate_pk) except CorporationSheet.DoesNotExist: log.debug("CorporationSheet 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.corp.MemberMedals() except AuthenticationError: log.error('AuthenticationError for key "{0}" owned by "{1}"'.format(target.apikey.keyID, target.apikey.owner)) target.delete() return medal_ids = handler.autoparse_list( api_data.issuedMedals, MemberMedal, unique_together=("medalID", "characterID"), extra_selectors={"owner": corporation}, owner=corporation, ) MemberMedal.objects.filter(owner=corporation).exclude(pk__in=medal_ids).delete() target.updated(api_data) corporation_member_medals_updated.send(MemberMedal, corporationID=corporation.pk)
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) 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_marketorders(apiupdate_pk): try: target, corporation = _get_corporation_auth(apiupdate_pk) except CorporationSheet.DoesNotExist: log.debug("CorporationSheet 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.corp.MarketOrders() 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": corporation}, owner=corporation, ) target.updated(api_data) corporation_market_orders_updated.send(MarketOrder, corporationID=corporation.pk)
def fetch_membersecuritylog(apiupdate_pk): try: target, corporation = _get_corporation_auth(apiupdate_pk) except CorporationSheet.DoesNotExist: log.debug("CorporationSheet 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.corp.MemberSecurityLog() 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.roleHistory, MemberSecurityLog, unique_together=("changeTime", "characterID", "roleLocationType"), extra_selectors={"owner": corporation}, owner=corporation, immutable=True, ) target.updated(api_data) corporation_member_security_log_updated.send(MemberSecurityLog, corporationID=corporation.pk)
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_membertracking(apiupdate_pk): try: target, corporation = _get_corporation_auth(apiupdate_pk) except CorporationSheet.DoesNotExist: log.debug("CorporationSheet 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.corp.MemberTracking(characterID=target.apikey.characterID, extended=1) except AuthenticationError: log.error('AuthenticationError for key "{0}" owned by "{1}"'.format(target.apikey.keyID, target.apikey.owner)) target.delete() return memberIDs = handler.autoparse_list( api_data.members, MemberTracking, unique_together=("characterID",), extra_selectors={"owner": corporation}, owner=corporation, pre_save=True, ) MemberTracking.objects.filter(owner=corporation).exclude(pk__in=memberIDs).delete() target.updated(api_data) corporation_member_tracking_updated.send(Starbase, corporationID=corporation.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_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_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_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 = handler.autoparse_list(api_data.notifications, Notification, unique_together=('notificationID',), extra_selectors={'owner': character}, owner=character, pre_save=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_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() 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)
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 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_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 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 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_starbasedetails(apiupdate_pk, starbase_pk): try: target, corporation = _get_corporation_auth(apiupdate_pk) except CorporationSheet.DoesNotExist: log.debug("CorporationSheet 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 try: starbase = Starbase.objects.get(owner=corporation, pk=starbase_pk) except Starbase.DoesNotExist: log.warning( "Received request for starbase details on non-existant starbase {0} owned by {1}.".format( starbase_pk, corporation ) ) return # Unanchored starbases dont have details, just wait for somebody to anchor it first. if starbase.state == 0: return handler = EveAPIHandler() auth = handler.get_authed_eveapi(target.apikey) try: api_data = auth.corp.StarbaseDetail(itemID=starbase.itemID) except AuthenticationError: log.error('AuthenticationError for key "{0}" owned by "{1}"'.format(target.apikey.keyID, target.apikey.owner)) target.delete() return except ServerError: log.error( "ServerError while getting starbase details for {0} with apikey {1}.".format( starbase.itemID, target.apikey.keyID ) ) return fuel_ids = handler.autoparse_list( api_data.fuel, StarbaseFuel, unique_together=("starbase", "typeID"), extra_selectors={"owner": corporation}, owner=corporation, static_defaults={"starbase": starbase}, ) StarbaseFuel.objects.filter(owner=corporation, starbase=starbase).exclude(pk__in=fuel_ids).delete() target.updated(api_data) corporation_starbase_details_updated.send(Starbase, corporationID=corporation.pk, starbase_pk=starbase.pk)
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 fetch_assetlist(apiupdate_pk): try: target, corporation = _get_corporation_auth(apiupdate_pk) except CorporationSheet.DoesNotExist: log.debug("CorporationSheet 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.corp.AssetList(characterID=target.apikey.characterID) except AuthenticationError: log.error('AuthenticationError for key "{0}" owned by "{1}"'.format(target.apikey.keyID, target.apikey.owner)) target.delete() return assetlist = AssetList(owner=corporation, retrieved=api_data._meta.currentTime) assetlist.items, itemIDs_with_names = handler.asset_parser(api_data.assets, Asset, corporation, target) assetlist.save() if target.apikey.can_call(APICall.objects.get(type="Corporation", name="Locations")): names_registered = 0 log.info('Fetching the item name of {0} items for "{1}".'.format(len(itemIDs_with_names), corporation)) for block in _blocker(itemIDs_with_names, 1000): try: api_data = auth.corp.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": corporation}, owner=corporation, pre_save=True, ) names_registered += len(IDs) old_names = ItemLocationName.objects.filter(owner=corporation).exclude(pk__in=itemIDs_with_names) log.debug( 'Fetched {0} names and deleted {1} for "{2}"'.format(names_registered, old_names.count(), corporation) ) old_names.delete()
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 fetch_npcstandings(apiupdate_pk): try: target, corporation = _get_corporation_auth(apiupdate_pk) except CorporationSheet.DoesNotExist: log.debug("CorporationSheet 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.corp.Standings() except AuthenticationError: log.error('AuthenticationError for key "{0}" owned by "{1}"'.format(target.apikey.keyID, target.apikey.owner)) target.delete() return agent_ids = handler.autoparse_list( api_data.corporationNPCStandings.agents, NPCStanding, unique_together=("fromID",), extra_selectors={"owner": corporation}, owner=corporation, static_defaults={"type": "Agent"}, ) corp_ids = handler.autoparse_list( api_data.corporationNPCStandings.NPCCorporations, NPCStanding, unique_together=("fromID",), extra_selectors={"owner": corporation}, owner=corporation, static_defaults={"type": "Corporation"}, ) faction_ids = handler.autoparse_list( api_data.corporationNPCStandings.factions, NPCStanding, unique_together=("fromID",), extra_selectors={"owner": corporation}, owner=corporation, static_defaults={"type": "Faction"}, ) all_ids = agent_ids + corp_ids + faction_ids NPCStanding.objects.filter(owner=corporation).exclude(pk__in=all_ids).delete() target.updated(api_data) corporation_npc_standings_updated.send(NPCStanding, corporationID=corporation.pk)
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_shareholders(apiupdate_pk): try: target, corporation = _get_corporation_auth(apiupdate_pk) except CorporationSheet.DoesNotExist: log.debug("CorporationSheet 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.corp.ShareHolders() except AuthenticationError: log.error('AuthenticationError for key "{0}" owned by "{1}"'.format(target.apikey.keyID, target.apikey.owner)) target.delete() return char_ids = handler.autoparse_list( api_data.characters, Shareholder, unique_together=("shareholderID", "holder_type"), extra_selectors={"owner": corporation}, owner=corporation, static_defaults={"holder_type": "Character"}, ) corp_ids = handler.autoparse_list( api_data.corporations, Shareholder, unique_together=("shareholderID", "holder_type"), extra_selectors={"owner": corporation}, owner=corporation, static_defaults={"holder_type": "Corporation"}, ) old_entries = Shareholder.objects.filter(owner=corporation).exclude(pk__in=char_ids + corp_ids) deleted = old_entries.count() old_entries.delete() log.info( 'Updated shareholders for corporation "{0}". {1} entries, {2} old entries removed.'.format( corporation, len(corp_ids) + len(char_ids), deleted ) ) target.updated(api_data) corporation_shareholders_updated.send(Shareholder, corporationID=corporation.pk)
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_outposts(apiupdate_pk): try: target, corporation = _get_corporation_auth(apiupdate_pk) except CorporationSheet.DoesNotExist: log.debug("CorporationSheet 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.corp.OutpostList() except AuthenticationError: log.error('AuthenticationError for key "{0}" owned by "{1}"'.format(target.apikey.keyID, target.apikey.owner)) target.delete() return outpost_ids = handler.autoparse_list( api_data.corporationStarbases, Outpost, unique_together=("stationID",), extra_selectors={"owner": corporation}, owner=corporation, ) old_entries = Outpost.objects.filter(owner=corporation).exclude(pk__in=outpost_ids) deleted = old_entries.count() old_entries.delete() log.info( 'Updated outposts for corporation "{0}". {1} entries, {2} old entries removed.'.format( corporation, len(outpost_ids), deleted ) ) target.updated(api_data) corporation_outposts_updated.send(Outpost, corporationID=corporation.pk) try: details_call = APICall.objects.get(type="Corporation", name="OutpostServiceDetail") details_target = APIUpdate.objects.get(apicall=details_call, apikey=target.apikey, owner=target.owner) for outpost_pk in outpost_ids: app.send_task("corporation.fetch_outpostservicedetails", (details_target.pk, outpost_pk)) except APICall.DoesNotExist: log.error("Could not find APICall for OutpostServiceDetail.") except APIUpdate.DoesNotExist: log.debug("Key {0} cant call outpost details, so its services remain undetailed.".format(target.apikey.keyID))
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_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 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_corporation_names(): handler = EveAPIHandler() api = handler.get_eveapi()
Validates an apikey and register all characters or corporations that should be updated using this key. The process is roughly: 1. Check the key against the eveapi. Disable if expired or not existing etc 2. Create an APIUpdate "target" for the services the access mask grants you access to, for every character or corporation the key is valid for. :param apikey_pk: :return: """ try: apikey = APIKey.objects.get(pk=apikey_pk) except APIKey.DoesNotExist, dne: raise dne handler = EveAPIHandler() api = handler.get_eveapi() auth = api.auth(keyID=apikey.keyID, vCode=apikey.vCode) try: keyinfo = auth.account.APIKeyInfo() except AuthenticationError: apikey.brokeness += 1 if apikey.brokeness == 3: apikey.expired = True apikey.save() APIUpdate.objects.filter(apikey=apikey).delete() log.info( 'APIKey "{0}" owned by "{1}" is disabled according to the eveapi.'. format(apikey.name, apikey.owner)) return
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: