Mathis/allianceauth
1
0
Fork 0
mirror of https://gitlab.com/allianceauth/allianceauth.git synced 2025-07-12 05:50:16 +02:00
Code Issues Packages Projects Releases Wiki Activity

Move error handling to api calls

Browse Source 
- allows interpretation of diffferent evelink codes
This commit is contained in:
Adarnof 2016-03-17 22:18:02 +00:00
parent 3b62c5eaaf
commit d461e6af79
3 changed files with 272 additions and 324 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

396
celerytask/tasks.py
View File

@ -31,6 +31,7 @@ from eveonline.models import EveAllianceInfo
from authentication.managers import AuthServicesInfoManager from authentication.managers import AuthServicesInfoManager
from services.models import DiscordAuthToken from services.models import DiscordAuthToken
import evelink
import time import time
import logging import logging
@ -460,76 +461,43 @@ def refresh_api(api_key_pair):
state = determine_membership_by_user(user) state = determine_membership_by_user(user)
if state == "BLUE": if state == "BLUE":
if settings.BLUE_API_ACCOUNT: if settings.BLUE_API_ACCOUNT:
type = EveApiManager.check_api_is_type_account(api_key_pair.api_id, api_key_pair.api_key) if not EveApiManager.check_api_is_type_account(api_key_pair.api_id, api_key_pair.api_key):
if type == None:
api_key_pair.error_count += 1
api_key_pair.save()
logger.info("API key %s incurred an error checking if type account. Error count is now %s" % (api_key_pair.api_id, api_key_pair.error_count))
still_valid = None
elif type == False:
logger.info("Determined api key %s for blue user %s is no longer type account as requred." % (api_key_pair.api_id, user)) logger.info("Determined api key %s for blue user %s is no longer type account as requred." % (api_key_pair.api_id, user))
still_valid = False still_valid = False
notify(user, "API Failed Validation", message="Your API key ID %s is not account-wide as required." % api_key_pair.api_id, level="danger") notify(user, "API Failed Validation", message="Your API key ID %s is not account-wide as required." % api_key_pair.api_id, level="danger")
full = EveApiManager.check_blue_api_is_full(api_key_pair.api_id, api_key_pair.api_key) if not EveApiManager.check_blue_api_is_full(api_key_pair.api_id, api_key_pair.api_key):
if full == None:
api_key_pair.error_count += 1
api_key_pair.save()
logger.info("API key %s incurred an error checking if meets mask requirements. Error count is now %s" % (api_key_pair.api_id, api_key_pair.error_count))
still_valid = None
elif full == False:
logger.info("Determined api key %s for blue user %s no longer meets minimum access mask as required." % (api_key_pair.api_id, user)) logger.info("Determined api key %s for blue user %s no longer meets minimum access mask as required." % (api_key_pair.api_id, user))
still_valid = False still_valid = False
notify(user, "API Failed Validation", message="Your API key ID %s does not meet access mask requirements." % api_key_pair.api_id, level="danger") notify(user, "API Failed Validation", message="Your API key ID %s does not meet access mask requirements." % api_key_pair.api_id, level="danger")
elif state == "MEMBER": elif state == "MEMBER":
if settings.MEMBER_API_ACCOUNT: if settings.MEMBER_API_ACCOUNT:
type = EveApiManager.check_api_is_type_account(api_key_pair.api_id, api_key_pair.api_key) if not EveApiManager.check_api_is_type_account(api_key_pair.api_id, api_key_pair.api_key):
if type == None:
api_key_pair.error_count += 1
api_key_pair.save()
logger.info("API key %s incurred an error checking if type account. Error count is now %s" % (api_key_pair.api_id, api_key_pair.error_count))
still_valid = None
elif type == False:
logger.info("Determined api key %s for user %s is no longer type account as required." % (api_key_pair.api_id, user)) logger.info("Determined api key %s for user %s is no longer type account as required." % (api_key_pair.api_id, user))
still_valid = False still_valid = False
notify(user, "API Failed Validation", message="Your API key ID %s is not account-wide as required." % api_key_pair.api_id, level="danger") notify(user, "API Failed Validation", message="Your API key ID %s is not account-wide as required." % api_key_pair.api_id, level="danger")
full = EveApiManager.check_api_is_full(api_key_pair.api_id, api_key_pair.api_key) if not EveApiManager.check_api_is_full(api_key_pair.api_id, api_key_pair.api_key):
if full == None:
api_key_pair.error_count += 1
api_key_pair.save()
logger.info("API key %s incurred an error checking if meets mask requirements. Error count is now %s" % (api_key_pair.api_id, api_key_pair.error_count))
still_valid = None
elif full == False:
logger.info("Determined api key %s for user %s no longer meets minimum access mask as required." % (api_key_pair.api_id, user)) logger.info("Determined api key %s for user %s no longer meets minimum access mask as required." % (api_key_pair.api_id, user))
still_valid = False still_valid = False
notify(user, "API Failed Validation", message="Your API key ID %s does not meet access mask requirements." % api_key_pair.api_id, level="danger") notify(user, "API Failed Validation", message="Your API key ID %s does not meet access mask requirements." % api_key_pair.api_id, level="danger")
if still_valid == None: if not still_valid:
if api_key_pair.error_count >= 3: logger.debug("API key %s has failed validation; it and its characters will be deleted." % api_key_pair.api_id)
logger.info("API key %s has incurred 3 or more errors. Assuming invalid." % api_key_pair.api_id) EveManager.delete_characters_by_api_id(api_key_pair.api_id, user.id)
still_valid = False EveManager.delete_api_key_pair(api_key_pair.api_id, user.id)
notify(user, "API Failed Validation", message="Your API key ID %s has accumulated too many errors during refresh and is assumed to be invalid." % api_key_pair.api_id, level="danger") notify(user, "API Key Deleted", message="Your API key ID %s has failed validation. It and its associated characters have been deleted." % api_key_pair.api_id, level="danger")
if still_valid == False: else:
logger.debug("API key %s has failed validation; it and its characters will be deleted." % api_key_pair.api_id) logger.info("Determined api key %s still meets requirements." % api_key_pair.api_id)
EveManager.delete_characters_by_api_id(api_key_pair.api_id, user.id) # Update characters
EveManager.delete_api_key_pair(api_key_pair.api_id, user.id) characters = EveApiManager.get_characters_from_api(api_key_pair.api_id, api_key_pair.api_key)
notify(user, "API Key Deleted", message="Your API key ID %s has failed validation. It and its associated characters have been deleted." % api_key_pair.api_id, level="danger") EveManager.update_characters_from_list(characters)
elif still_valid == True: new_character = False
if api_key_pair.error_count != 0: for char in characters.result:
logger.info("Clearing error count for api %s as it passed validation" % api_key_pair.api_id) # Ensure we have a model for all characters on key
api_key_pair.error_count = 0 if not EveManager.check_if_character_exist(characters.result[char]['name']):
api_key_pair.save() new_character = True
logger.info("Determined api key %s still meets requirements." % api_key_pair.api_id) logger.debug("API key %s has a new character on the account: %s" % (api_key_pair.api_id, characters.result[char]['name']))
# Update characters if new_character:
characters = EveApiManager.get_characters_from_api(api_key_pair.api_id, api_key_pair.api_key) logger.debug("Creating new character %s from api key %s" % (characters.result[char]['name'], api_key_pair.api_id))
EveManager.update_characters_from_list(characters) EveManager.create_characters_from_list(characters, user, api_key_pair.api_id)
new_character = False
for char in characters.result:
# Ensure we have a model for all characters on key
if not EveManager.check_if_character_exist(characters.result[char]['name']):
new_character = True
logger.debug("API key %s has a new character on the account: %s" % (api_key_pair.api_id, characters.result[char]['name']))
if new_character:
logger.debug("Creating new character %s from api key %s" % (characters.result[char]['name'], api_key_pair.api_id))
EveManager.create_characters_from_list(characters, user, api_key_pair.api_id)
else: else:
logger.debug("API key %s is no longer valid; it and its characters will be deleted." % api_key_pair.api_id) logger.debug("API key %s is no longer valid; it and its characters will be deleted." % api_key_pair.api_id)
EveManager.delete_characters_by_api_id(api_key_pair.api_id, user.id) EveManager.delete_characters_by_api_id(api_key_pair.api_id, user.id)
@ -551,7 +519,19 @@ def run_api_refresh():
authserviceinfo, c = AuthServicesInfo.objects.get_or_create(user=user) authserviceinfo, c = AuthServicesInfo.objects.get_or_create(user=user)
logger.debug("User %s has api keys. Proceeding to refresh." % user) logger.debug("User %s has api keys. Proceeding to refresh." % user)
for api_key_pair in api_key_pairs: for api_key_pair in api_key_pairs:
refresh_api(api_key_pair) try:
refresh_api(api_key_pair)
except evelink.api.APIError as e:
if int(e.code) >= 500:
logger.error("EVE API servers encountered an error. Aborting API updates")
return
elif int(e.code) == 221:
logger.warn("API server hiccup while updating %s" % api_key_pair)
else:
logger.debug("API key %s failed update with error code %s" % (api_key_pair.api_id, e.code))
EveManager.delete_characters_by_api_id(api_key_pair.api_id, user.id)
EveManager.delete_api_key_pair(api_key_pair.api_id, user.id)
notify(user, "API Key Deleted", message="Your API key ID %s failed validation with code %s. It and its associated characters have been deleted." % (api_key_pair.api_id, e.code), level="danger")
# Check our main character # Check our main character
if EveCharacter.objects.filter(character_id=authserviceinfo.main_char_id).exists() is False: if EveCharacter.objects.filter(character_id=authserviceinfo.main_char_id).exists() is False:
logger.info("User %s main character id %s missing model. Clearning main character." % (user, authserviceinfo.main_char_id)) logger.info("User %s main character id %s missing model. Clearning main character." % (user, authserviceinfo.main_char_id))
@ -625,178 +605,180 @@ def run_corp_update():
logger.warn("Aborted updating corp and alliance models: API server unreachable") logger.warn("Aborted updating corp and alliance models: API server unreachable")
return return
standing_level = 'alliance' standing_level = 'alliance'
try:
# get corp info for owning corp if required # get corp info for owning corp if required
ownercorpinfo = {} ownercorpinfo = {}
if settings.IS_CORP: if settings.IS_CORP:
standing_level = 'corp' standing_level = 'corp'
logger.debug("Getting information for owning corp with id %s" % settings.CORP_ID) logger.debug("Getting information for owning corp with id %s" % settings.CORP_ID)
ownercorpinfo = EveApiManager.get_corporation_information(settings.CORP_ID) ownercorpinfo = EveApiManager.get_corporation_information(settings.CORP_ID)
if not ownercorpinfo: if not ownercorpinfo:
logger.error("Failed to retrieve corp info for owning corp id %s - bad corp id?" % settings.CORP_ID) logger.error("Failed to retrieve corp info for owning corp id %s - bad corp id?" % settings.CORP_ID)
return return
# check if we need to update an alliance model # check if we need to update an alliance model
alliance_id = '' alliance_id = ''
if ownercorpinfo and ownercorpinfo['alliance']['id']: if ownercorpinfo and ownercorpinfo['alliance']['id']:
alliance_id = ownercorpinfo['alliance']['id'] alliance_id = ownercorpinfo['alliance']['id']
elif settings.IS_CORP is False: elif settings.IS_CORP is False:
alliance_id = settings.ALLIANCE_ID alliance_id = settings.ALLIANCE_ID
# get and create alliance info for owning alliance if required # get and create alliance info for owning alliance if required
alliance = None alliance = None
if alliance_id: if alliance_id:
logger.debug("Getting information for owning alliance with id %s" % alliance_id) logger.debug("Getting information for owning alliance with id %s" % alliance_id)
ownerallianceinfo = EveApiManager.get_alliance_information(alliance_id) ownerallianceinfo = EveApiManager.get_alliance_information(alliance_id)
if not ownerallianceinfo: if not ownerallianceinfo:
logger.error("Failed to retrieve corp info for owning alliance id %s - bad alliance id?" % alliance_id) logger.error("Failed to retrieve corp info for owning alliance id %s - bad alliance id?" % alliance_id)
return return
if EveAllianceInfo.objects.filter(alliance_id=ownerallianceinfo['id']).exists(): if EveAllianceInfo.objects.filter(alliance_id=ownerallianceinfo['id']).exists():
logger.debug("Updating existing owner alliance model with id %s" % alliance_id) logger.debug("Updating existing owner alliance model with id %s" % alliance_id)
EveManager.update_alliance_info(ownerallianceinfo['id'], ownerallianceinfo['executor_id'], ownerallianceinfo['member_count'], False) EveManager.update_alliance_info(ownerallianceinfo['id'], ownerallianceinfo['executor_id'], ownerallianceinfo['member_count'], False)
else: else:
populate_alliance(alliance_id) populate_alliance(alliance_id)
alliance = EveAllianceInfo.objects.get(alliance_id=alliance_id) alliance = EveAllianceInfo.objects.get(alliance_id=alliance_id)
# create corp info for owning corp if required # create corp info for owning corp if required
if ownercorpinfo: if ownercorpinfo:
if EveCorporationInfo.objects.filter(corporation_id=ownercorpinfo['id']).exists(): if EveCorporationInfo.objects.filter(corporation_id=ownercorpinfo['id']).exists():
logger.debug("Updating existing owner corp model with id %s" % ownercorpinfo['id']) logger.debug("Updating existing owner corp model with id %s" % ownercorpinfo['id'])
EveManager.update_corporation_info(ownercorpinfo['id'], ownercorpinfo['members']['current'], alliance, False) EveManager.update_corporation_info(ownercorpinfo['id'], ownercorpinfo['members']['current'], alliance, False)
else: else:
logger.info("Creating model for owning corp with id %s" % ownercorpinfo['id']) logger.info("Creating model for owning corp with id %s" % ownercorpinfo['id'])
EveManager.create_corporation_info(ownercorpinfo['id'], ownercorpinfo['name'], ownercorpinfo['ticker'], EveManager.create_corporation_info(ownercorpinfo['id'], ownercorpinfo['name'], ownercorpinfo['ticker'],
ownercorpinfo['members']['current'], False, alliance) ownercorpinfo['members']['current'], False, alliance)
# validate and create corp models for member corps of owning alliance # validate and create corp models for member corps of owning alliance
if alliance: if alliance:
current_corps = EveCorporationInfo.objects.filter(alliance=alliance) current_corps = EveCorporationInfo.objects.filter(alliance=alliance)
for corp in current_corps: for corp in current_corps:
if corp.corporation_id in ownerallianceinfo['member_corps'] is False: if corp.corporation_id in ownerallianceinfo['member_corps'] is False:
logger.info("Corp %s is no longer in owning alliance %s - updating model." % (corp, alliance)) logger.info("Corp %s is no longer in owning alliance %s - updating model." % (corp, alliance))
corp.alliance = None corp.alliance = None
corp.save()
for member_corp in ownerallianceinfo['member_corps']:
if EveCorporationInfo.objects.filter(corporation_id=member_corp).exists():
corp = EveCorporationInfo.objects.get(corporation_id=member_corp)
if corp.alliance == alliance is not True:
logger.info("Associating corp %s with owning alliance %s" % (corp, alliance))
corp.alliance = alliance
corp.save() corp.save()
else: for member_corp in ownerallianceinfo['member_corps']:
corpinfo = EveApiManager.get_corporation_information(member_corp) if EveCorporationInfo.objects.filter(corporation_id=member_corp).exists():
logger.info("Creating model for owning alliance member corp with id %s" % corpinfo['id']) corp = EveCorporationInfo.objects.get(corporation_id=member_corp)
EveManager.create_corporation_info(corpinfo['id'], corpinfo['name'], corpinfo['ticker'], if corp.alliance == alliance is not True:
logger.info("Associating corp %s with owning alliance %s" % (corp, alliance))
corp.alliance = alliance
corp.save()
else:
corpinfo = EveApiManager.get_corporation_information(member_corp)
logger.info("Creating model for owning alliance member corp with id %s" % corpinfo['id'])
EveManager.create_corporation_info(corpinfo['id'], corpinfo['name'], corpinfo['ticker'],
corpinfo['members']['current'], False, alliance) corpinfo['members']['current'], False, alliance)
# update existing corp models # update existing corp models
for corp in EveCorporationInfo.objects.all(): for corp in EveCorporationInfo.objects.all():
update_corp.delay(corp.corporation_id) update_corp.delay(corp.corporation_id)
# update existing alliance models # update existing alliance models
for alliance in EveAllianceInfo.objects.all(): for alliance in EveAllianceInfo.objects.all():
update_alliance.delay(alliance.alliance_id) update_alliance.delay(alliance.alliance_id)
# create standings # create standings
standings = EveApiManager.get_corp_standings() standings = EveApiManager.get_corp_standings()
if standings: if standings:
standings = standings[standing_level] standings = standings[standing_level]
for standing in standings: for standing in standings:
if int(standings[standing]['standing']) >= settings.BLUE_STANDING: if int(standings[standing]['standing']) >= settings.BLUE_STANDING:
logger.debug("Standing %s meets threshold" % standing) logger.debug("Standing %s meets threshold" % standing)
if EveApiManager.check_if_id_is_alliance(standing): if EveApiManager.check_if_id_is_alliance(standing):
logger.debug("Standing %s is an alliance" % standing) logger.debug("Standing %s is an alliance" % standing)
if EveAllianceInfo.objects.filter(alliance_id=standing).exists(): if EveAllianceInfo.objects.filter(alliance_id=standing).exists():
alliance = EveAllianceInfo.objects.get(alliance_id=standing) alliance = EveAllianceInfo.objects.get(alliance_id=standing)
if alliance.is_blue is not True: if alliance.is_blue is not True:
logger.info("Updating alliance %s as blue" % alliance) logger.info("Updating alliance %s as blue" % alliance)
alliance.is_blue = True alliance.is_blue = True
alliance.save() alliance.save()
else: else:
populate_alliance(standing, blue=True) populate_alliance(standing, blue=True)
elif EveApiManager.check_if_id_is_corp(standing): elif EveApiManager.check_if_id_is_corp(standing):
logger.debug("Standing %s is a corp" % standing) logger.debug("Standing %s is a corp" % standing)
if EveCorporationInfo.objects.filter(corporation_id=standing).exists(): if EveCorporationInfo.objects.filter(corporation_id=standing).exists():
corp = EveCorporationInfo.objects.get(corporation_id=standing) corp = EveCorporationInfo.objects.get(corporation_id=standing)
if corp.is_blue is not True: if corp.is_blue is not True:
logger.info("Updating corp %s as blue" % corp) logger.info("Updating corp %s as blue" % corp)
corp.is_blue = True corp.is_blue = True
corp.save() corp.save()
else: else:
logger.info("Creating model for blue corp with id %s" % standing) logger.info("Creating model for blue corp with id %s" % standing)
corpinfo = EveApiManager.get_corporation_information(standing) corpinfo = EveApiManager.get_corporation_information(standing)
corp_alliance = None corp_alliance = None
if EveAllianceInfo.objects.filter(alliance_id=corpinfo['alliance']['id']).exists(): if EveAllianceInfo.objects.filter(alliance_id=corpinfo['alliance']['id']).exists():
logger.debug("New corp model for standing %s has existing alliance model" % standing) logger.debug("New corp model for standing %s has existing alliance model" % standing)
corp_alliance = EveAllianceInfo.objects.get(alliance_id=corpinfo['alliance']['id']) corp_alliance = EveAllianceInfo.objects.get(alliance_id=corpinfo['alliance']['id'])
EveManager.create_corporation_info(corpinfo['id'], corpinfo['name'], corpinfo['ticker'], EveManager.create_corporation_info(corpinfo['id'], corpinfo['name'], corpinfo['ticker'],
corpinfo['members']['current'], True, corp_alliance) corpinfo['members']['current'], True, corp_alliance)
# update alliance standings # update alliance standings
for alliance in EveAllianceInfo.objects.filter(is_blue=True): for alliance in EveAllianceInfo.objects.filter(is_blue=True):
if int(alliance.alliance_id) in standings: if int(alliance.alliance_id) in standings:
if float(standings[int(alliance.alliance_id)]['standing']) < float(settings.BLUE_STANDING): if float(standings[int(alliance.alliance_id)]['standing']) < float(settings.BLUE_STANDING):
logger.info("Alliance %s no longer meets minimum blue standing threshold" % alliance) logger.info("Alliance %s no longer meets minimum blue standing threshold" % alliance)
alliance.is_blue = False
alliance.save()
else:
logger.info("Alliance %s no longer in standings" % alliance)
alliance.is_blue = False alliance.is_blue = False
alliance.save() alliance.save()
else:
logger.info("Alliance %s no longer in standings" % alliance) # update corp standings
alliance.is_blue = False for corp in EveCorporationInfo.objects.filter(is_blue=True):
alliance.save() if int(corp.corporation_id) in standings:
if float(standings[int(corp.corporation_id)]['standing']) < float(settings.BLUE_STANDING):
# update corp standings logger.info("Corp %s no longer meets minimum blue standing threshold" % corp)
for corp in EveCorporationInfo.objects.filter(is_blue=True):
if int(corp.corporation_id) in standings:
if float(standings[int(corp.corporation_id)]['standing']) < float(settings.BLUE_STANDING):
logger.info("Corp %s no longer meets minimum blue standing threshold" % corp)
corp.is_blue = False
corp.save()
else:
if corp.alliance:
if corp.alliance.is_blue is False:
logger.info("Corp %s and its alliance %s are no longer blue" % (corp, corp.alliance))
corp.is_blue = False corp.is_blue = False
corp.save() corp.save()
else: else:
logger.info("Corp %s is no longer blue" % corp) if corp.alliance:
corp.is_blue = False if corp.alliance.is_blue is False:
corp.save() logger.info("Corp %s and its alliance %s are no longer blue" % (corp, corp.alliance))
corp.is_blue = False
corp.save()
else:
logger.info("Corp %s is no longer blue" % corp)
corp.is_blue = False
corp.save()
# delete unnecessary alliance models # delete unnecessary alliance models
for alliance in EveAllianceInfo.objects.filter(is_blue=False): for alliance in EveAllianceInfo.objects.filter(is_blue=False):
logger.debug("Checking to delete alliance %s" % alliance) logger.debug("Checking to delete alliance %s" % alliance)
if settings.IS_CORP is False: if settings.IS_CORP is False:
if alliance.alliance_id == settings.ALLIANCE_ID is False: if alliance.alliance_id == settings.ALLIANCE_ID is False:
logger.info("Deleting unnecessary alliance model %s" % alliance) logger.info("Deleting unnecessary alliance model %s" % alliance)
alliance.delete() alliance.delete()
else:
if alliance.evecorporationinfo_set.filter(corporation_id=settings.CORP_ID).exists() is False:
logger.info("Deleting unnecessary alliance model %s" % alliance)
alliance.delete()
# delete unnecessary corp models
for corp in EveCorporationInfo.objects.filter(is_blue=False):
logger.debug("Checking to delete corp %s" % corp)
if settings.IS_CORP is False:
if corp.alliance:
logger.debug("Corp %s has alliance %s" % (corp, corp.alliance))
if corp.alliance.alliance_id == settings.ALLIANCE_ID is False:
logger.info("Deleting unnecessary corp model %s" % corp)
corp.delete()
else: else:
logger.info("Deleting unnecessary corp model %s" % corp) if alliance.evecorporationinfo_set.filter(corporation_id=settings.CORP_ID).exists() is False:
corp.delete() logger.info("Deleting unnecessary alliance model %s" % alliance)
else: alliance.delete()
if corp.corporation_id != settings.CORP_ID:
logger.debug("Corp %s is not owning corp" % corp) # delete unnecessary corp models
for corp in EveCorporationInfo.objects.filter(is_blue=False):
logger.debug("Checking to delete corp %s" % corp)
if settings.IS_CORP is False:
if corp.alliance: if corp.alliance:
logger.debug("Corp %s has alliance %s" % (corp, corp.alliance)) logger.debug("Corp %s has alliance %s" % (corp, corp.alliance))
if corp.alliance.evecorporationinfo_set.filter(corporation_id=settings.CORP_ID).exists() is False: if corp.alliance.alliance_id == settings.ALLIANCE_ID is False:
logger.info("Deleting unnecessary corp model %s" % corp) logger.info("Deleting unnecessary corp model %s" % corp)
corp.delete() corp.delete()
else: else:
logger.info("Deleting unnecessary corp model %s" % corp) logger.info("Deleting unnecessary corp model %s" % corp)
corp.delete() corp.delete()
else: else:
logger.debug("Corp %s is owning corp" % corp) if corp.corporation_id != settings.CORP_ID:
logger.debug("Corp %s is not owning corp" % corp)
if corp.alliance:
logger.debug("Corp %s has alliance %s" % (corp, corp.alliance))
if corp.alliance.evecorporationinfo_set.filter(corporation_id=settings.CORP_ID).exists() is False:
logger.info("Deleting unnecessary corp model %s" % corp)
corp.delete()
else:
logger.info("Deleting unnecessary corp model %s" % corp)
corp.delete()
else:
logger.debug("Corp %s is owning corp" % corp)
except evelink.api.APIError as e:
logger.error("Model update failed with error code %s" % e.code)

54
eveonline/forms.py
View File

@ -4,6 +4,7 @@ from django.conf import settings
from services.managers.eve_api_manager import EveApiManager from services.managers.eve_api_manager import EveApiManager
from eveonline.managers import EveManager from eveonline.managers import EveManager
from eveonline.models import EveCharacter from eveonline.models import EveCharacter
import evelink
from celerytask.tasks import determine_membership_by_character from celerytask.tasks import determine_membership_by_character
@ -28,27 +29,34 @@ class UpdateKeyForm(forms.Form):
super(UpdateKeyForm, self).clean() super(UpdateKeyForm, self).clean()
if 'api_id' in self.cleaned_data and 'api_key' in self.cleaned_data: if 'api_id' in self.cleaned_data and 'api_key' in self.cleaned_data:
if EveManager.check_if_api_key_pair_exist(self.cleaned_data['api_id']): try:
logger.debug("UpdateKeyForm failed cleaning as API id %s already exists." % self.cleaned_data['api_id']) if EveManager.check_if_api_key_pair_exist(self.cleaned_data['api_id']):
raise forms.ValidationError(u'API key already exist') logger.debug("UpdateKeyForm failed cleaning as API id %s already exists." % self.cleaned_data['api_id'])
if EveApiManager.api_key_is_valid(self.cleaned_data['api_id'], self.cleaned_data['api_key']) is False: raise forms.ValidationError(u'API key already exist')
raise forms.ValidationError(u'API key is invalid') if EveApiManager.api_key_is_valid(self.cleaned_data['api_id'], self.cleaned_data['api_key']) is False:
chars = EveApiManager.get_characters_from_api(self.cleaned_data['api_id'], self.cleaned_data['api_key']).result raise forms.ValidationError(u'API key is invalid')
states = [] chars = EveApiManager.get_characters_from_api(self.cleaned_data['api_id'], self.cleaned_data['api_key']).result
states.append(self.user_state) states = []
for char in chars: states.append(self.user_state)
evechar = EveCharacter() for char in chars:
evechar.character_name = chars[char]['name'] evechar = EveCharacter()
evechar.corporation_id = chars[char]['corp']['id'] evechar.character_name = chars[char]['name']
evechar.alliance_id = chars[char]['alliance']['id'] evechar.corporation_id = chars[char]['corp']['id']
state = determine_membership_by_character(evechar) evechar.alliance_id = chars[char]['alliance']['id']
logger.debug("API ID %s character %s has state %s" % (self.cleaned_data['api_id'], evechar, state)) state = determine_membership_by_character(evechar)
states.append(state) logger.debug("API ID %s character %s has state %s" % (self.cleaned_data['api_id'], evechar, state))
states.append(state)
if 'MEMBER' in states: if 'MEMBER' in states:
if EveApiManager.validate_member_api(self.cleaned_data['api_id'], self.cleaned_data['api_key']) is False: if EveApiManager.validate_member_api(self.cleaned_data['api_id'], self.cleaned_data['api_key']) is False:
raise forms.ValidationError(u'API must meet member requirements') raise forms.ValidationError(u'API must meet member requirements')
if 'BLUE' in states: if 'BLUE' in states:
if EveApiManager.validate_blue_api(self.cleaned_data['api_id'], self.cleaned_data['api_key']) is False: if EveApiManager.validate_blue_api(self.cleaned_data['api_id'], self.cleaned_data['api_key']) is False:
raise forms.ValidationError(u'API must meet blue requirements') raise forms.ValidationError(u'API must meet blue requirements')
return self.cleaned_data return self.cleaned_data
except evelink.api.APIError as e:
logger.debug("Got error code %s while validating API %s" % (e.code, self.cleaned_data['api_id']))
if int(e.code) in [221, 222]:
raise forms.ValidationError("API key failed validation")
else:
raise forms.ValidationError("Failed to reach API servers")

146
services/managers/eve_api_manager.py
View File

@ -16,14 +16,10 @@ class EveApiManager():
def get_characters_from_api(api_id, api_key): def get_characters_from_api(api_id, api_key):
chars = [] chars = []
logger.debug("Getting characters from api id %s" % api_id) logger.debug("Getting characters from api id %s" % api_id)
try: api = evelink.api.API(api_key=(api_id, api_key))
api = evelink.api.API(api_key=(api_id, api_key)) # Should get characters
# Should get characters account = evelink.account.Account(api=api)
account = evelink.account.Account(api=api) chars = account.characters()
chars = account.characters()
except evelink.api.APIError as error:
logger.exception("Unhandled APIError occured.")
logger.debug("Retrieved characters %s from api id %s" % (chars, api_id)) logger.debug("Retrieved characters %s from api id %s" % (chars, api_id))
return chars return chars
@ -31,15 +27,11 @@ class EveApiManager():
def get_corporation_ticker_from_id(corp_id): def get_corporation_ticker_from_id(corp_id):
logger.debug("Getting ticker for corp id %s" % corp_id) logger.debug("Getting ticker for corp id %s" % corp_id)
ticker = "" ticker = ""
try: api = evelink.api.API()
api = evelink.api.API() corp = evelink.corp.Corp(api)
corp = evelink.corp.Corp(api) response = corp.corporation_sheet(corp_id)
response = corp.corporation_sheet(corp_id) logger.debug("Retrieved corp sheet for id %s: %s" % (corp_id, response))
logger.debug("Retrieved corp sheet for id %s: %s" % (corp_id, response)) ticker = response[0]['ticker']
ticker = response[0]['ticker']
except evelink.api.APIError as error:
logger.exception("Unhandled APIError occured.")
logger.debug("Determined corp id %s ticker: %s" % (corp_id, ticker)) logger.debug("Determined corp id %s ticker: %s" % (corp_id, ticker))
return ticker return ticker
@ -47,13 +39,10 @@ class EveApiManager():
def get_alliance_information(alliance_id): def get_alliance_information(alliance_id):
results = {} results = {}
logger.debug("Getting info for alliance with id %s" % alliance_id) logger.debug("Getting info for alliance with id %s" % alliance_id)
try: api = evelink.api.API()
api = evelink.api.API() eve = evelink.eve.EVE(api=api)
eve = evelink.eve.EVE(api=api) alliance = eve.alliances()
alliance = eve.alliances() results = alliance[0][int(alliance_id)]
results = alliance[0][int(alliance_id)]
except evelink.api.APIError as error:
logger.exception("Unhandled APIError occured.")
logger.debug("Got alliance info %s" % results) logger.debug("Got alliance info %s" % results)
return results return results
@ -61,88 +50,57 @@ class EveApiManager():
def get_corporation_information(corp_id): def get_corporation_information(corp_id):
logger.debug("Getting info for corp with id %s" % corp_id) logger.debug("Getting info for corp with id %s" % corp_id)
results = {} results = {}
try: api = evelink.api.API()
api = evelink.api.API() corp = evelink.corp.Corp(api=api)
corp = evelink.corp.Corp(api=api) corpinfo = corp.corporation_sheet(corp_id=int(corp_id))
corpinfo = corp.corporation_sheet(corp_id=int(corp_id)) results = corpinfo[0]
results = corpinfo[0]
except evelink.api.APIError as error:
logger.exception("Unhandled APIError occured.")
logger.debug("Got corp info %s" % results) logger.debug("Got corp info %s" % results)
return results return results
@staticmethod @staticmethod
def check_api_is_type_account(api_id, api_key): def check_api_is_type_account(api_id, api_key):
logger.debug("Checking if api id %s is account." % api_id) logger.debug("Checking if api id %s is account." % api_id)
try: api = evelink.api.API(api_key=(api_id, api_key))
api = evelink.api.API(api_key=(api_id, api_key)) account = evelink.account.Account(api=api)
account = evelink.account.Account(api=api) info = account.key_info()
info = account.key_info() logger.debug("API id %s is type %s" % (api_id, info[0]['type']))
logger.debug("API id %s is type %s" % (api_id, info[0]['type'])) return info[0]['type'] == "account"
return info[0]['type'] == "account"
except evelink.api.APIError as error:
logger.exception("Unhandled APIError occured.")
return None
@staticmethod @staticmethod
def check_api_is_full(api_id, api_key): def check_api_is_full(api_id, api_key):
logger.debug("Checking if api id %s meets member requirements." % api_id) logger.debug("Checking if api id %s meets member requirements." % api_id)
try: api = evelink.api.API(api_key=(api_id, api_key))
api = evelink.api.API(api_key=(api_id, api_key)) account = evelink.account.Account(api=api)
account = evelink.account.Account(api=api) info = account.key_info()
info = account.key_info() logger.debug("API has mask %s, required is %s" % (info[0]['access_mask'], settings.MEMBER_API_MASK))
logger.debug("API has mask %s, required is %s" % (info[0]['access_mask'], settings.MEMBER_API_MASK)) return info[0]['access_mask'] & int(settings.MEMBER_API_MASK) == int(settings.MEMBER_API_MASK)
return info[0]['access_mask'] & int(settings.MEMBER_API_MASK) == int(settings.MEMBER_API_MASK)
except evelink.api.APIError as error:
logger.exception("Unhandled APIError occured.")
return None
@staticmethod @staticmethod
def check_blue_api_is_full(api_id, api_key): def check_blue_api_is_full(api_id, api_key):
logger.debug("Checking if api id %s meets blue requirements." % api_id) logger.debug("Checking if api id %s meets blue requirements." % api_id)
try: api = evelink.api.API(api_key=(api_id, api_key))
api = evelink.api.API(api_key=(api_id, api_key)) account = evelink.account.Account(api=api)
account = evelink.account.Account(api=api) info = account.key_info()
info = account.key_info() logger.debug("API has mask %s, required is %s" % (info[0]['access_mask'], settings.BLUE_API_MASK))
logger.debug("API has mask %s, required is %s" % (info[0]['access_mask'], settings.BLUE_API_MASK)) return info[0]['access_mask'] & int(settings.BLUE_API_MASK) == int(settings.BLUE_API_MASK)
return info[0]['access_mask'] & int(settings.BLUE_API_MASK) == int(settings.BLUE_API_MASK)
except evelink.api.APIError as error:
logger.exception("Unhandled APIError occured.")
return None
@staticmethod @staticmethod
def get_api_info(api_id, api_key): def get_api_info(api_id, api_key):
logger.debug("Getting api info for key id %s" % api_id) logger.debug("Getting api info for key id %s" % api_id)
try: api = evelink.api.API(api_key=(api_id, api_key))
api = evelink.api.API(api_key=(api_id, api_key)) account = evelink.account.Account(api=api)
account = evelink.account.Account(api=api) info = account.key_info()
info = account.key_info() logger.debug("Got info for api id %s: %s" % (api_id, info))
logger.debug("Got info for api id %s: %s" % (api_id, info)) return info
return info
except evelink.api.APIError as error:
logger.exception("Unhandled APIError occured.")
return None
@staticmethod @staticmethod
def api_key_is_valid(api_id, api_key): def api_key_is_valid(api_id, api_key):
logger.debug("Checking if api id %s is valid." % api_id) logger.debug("Checking if api id %s is valid." % api_id)
try: api = evelink.api.API(api_key=(api_id, api_key))
api = evelink.api.API(api_key=(api_id, api_key)) account = evelink.account.Account(api=api)
account = evelink.account.Account(api=api) info = account.key_info()
info = account.key_info() logger.info("Verified api id %s is still valid." % api_id)
logger.info("Verified api id %s is still valid." % api_id) return True
return True
except evelink.api.APIError as error:
logger.exception("APIError occured while validating api id %s" % api_id)
logger.info("API id %s is invalid." % api_id)
return False
@staticmethod @staticmethod
def check_if_api_server_online(): def check_if_api_server_online():
@ -170,6 +128,9 @@ class EveApiManager():
logger.debug("Confirmed id %s is a corp." % corp_id) logger.debug("Confirmed id %s is a corp." % corp_id)
return True return True
except evelink.api.APIError as error: except evelink.api.APIError as error:
if int(error.code) == '523':
logger.debug("Confirmed id %s is not a corp" % corp_id)
return False
logger.debug("APIError occured while checking if id %s is corp. Possibly not corp?" % corp_id) logger.debug("APIError occured while checking if id %s is corp. Possibly not corp?" % corp_id)
logger.debug("Unable to verify id %s is corp." % corp_id) logger.debug("Unable to verify id %s is corp." % corp_id)
@ -178,16 +139,13 @@ class EveApiManager():
@staticmethod @staticmethod
def get_corp_standings(): def get_corp_standings():
if settings.CORP_API_ID and settings.CORP_API_VCODE: if settings.CORP_API_ID and settings.CORP_API_VCODE:
try: logger.debug("Getting corp standings with api id %s" % settings.CORP_API_ID)
logger.debug("Getting corp standings with api id %s" % settings.CORP_API_ID) api = evelink.api.API(api_key=(settings.CORP_API_ID, settings.CORP_API_VCODE))
api = evelink.api.API(api_key=(settings.CORP_API_ID, settings.CORP_API_VCODE)) corp = evelink.corp.Corp(api=api)
corp = evelink.corp.Corp(api=api) corpinfo = corp.contacts()
corpinfo = corp.contacts() results = corpinfo.result
results = corpinfo.result logger.debug("Got corp standings from settings: %s" % results)
logger.debug("Got corp standings from settings: %s" % results) return results
return results
except evelink.api.APIError as error:
logger.exception("Unhandled APIError occured.", exc_info=True)
else: else:
logger.error("No corp API key supplied in settings. Unable to get standings.") logger.error("No corp API key supplied in settings. Unable to get standings.")
return {} return {}