def run_api_refresh():
users = User.objects.all()
logger.debug("Running api refresh on %s users." % len(users))
for user in users:
# Check if the api server is online
logger.debug("Running api refresh for user %s" % user)
if EveApiManager.check_if_api_server_online():
api_key_pairs = EveManager.get_api_key_pairs(user.id)
logger.debug("User %s has api key pairs %s" % (user, api_key_pairs))
if api_key_pairs:
authserviceinfo, c = AuthServicesInfo.objects.get_or_create(user=user)
logger.debug("User %s has api keys. Proceeding to refresh." % user)
for api_key_pair in api_key_pairs:
try:
refresh_api(api_key_pair)
except evelink.api.APIError as e:
if int(e.code) >= 500:
logger.error("EVE API servers encountered error %s updating %s" % (e.code, api_key_pair))
elif int(e.code) == 221:
logger.warn("API server hiccup %s while updating %s" % (e.code, api_key_pair))
else:
logger.info("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
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))
authserviceinfo.main_char_id = ''
authserviceinfo.save()
notify(user, "Main Character Reset", message="Your specified main character no longer has a model.\nThis could be the result of an invalid API\nYour main character ID has been reset.", level="warn")
set_state(user)
def run_api_refresh():
users = User.objects.all()
logger.debug("Running api refresh on %s users." % len(users))
for user in users:
# Check if the api server is online
logger.debug("Running api refresh for user %s" % user)
if EveApiManager.check_if_api_server_online():
api_key_pairs = EveManager.get_api_key_pairs(user.id)
logger.debug("User %s has api key pairs %s" % (user, api_key_pairs))
if api_key_pairs:
authserviceinfo, c = AuthServicesInfo.objects.get_or_create(user=user)
logger.debug("User %s has api keys. Proceeding to refresh." % user)
for api_key_pair in api_key_pairs:
try:
refresh_api(api_key_pair)
except evelink.api.APIError as e:
if int(e.code) >= 500:
logger.error("EVE API servers encountered error %s updating %s" % (e.code, api_key_pair))
elif int(e.code) == 221:
logger.warn("API server hiccup %s while updating %s" % (e.code, api_key_pair))
else:
logger.info("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
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))
authserviceinfo.main_char_id = ''
authserviceinfo.save()
notify(user, "Main Character Reset", message="Your specified main character no longer has a model.\nThis could be the result of an invalid API\nYour main character ID has been reset.", level="warn")
set_state(user)
def api_key_management_view(request):
logger.debug("api_key_management_view called by user %s" % request.user)
context = {
'apikeypairs': EveManager.get_api_key_pairs(request.user.id),
'api_sso_validation': settings.API_SSO_VALIDATION or False
}
return render(request, 'registered/apikeymanagment.html', context=context)
def api_key_management_view(request):
logger.debug("api_key_management_view called by user %s" % request.user)
context = {
'apikeypairs': EveManager.get_api_key_pairs(request.user.id),
'api_sso_validation': settings.API_SSO_VALIDATION or False
}
return render(request, 'registered/apikeymanagment.html', context=context)
def synchronize_eveapis(user=None):
seat_all_keys = SeatManager.get_all_seat_eveapis()
userinfo = None
# retrieve only user-specific api keys if user is specified
if user:
keypars = EveManager.get_api_key_pairs(user)
try:
userinfo = SeatManager.check_user_status(user.seat.username)
except ObjectDoesNotExist:
pass
else:
# retrieve all api keys instead
keypars = EveManager.get_all_api_key_pairs()
if keypars:
for keypar in keypars:
if keypar.api_id not in seat_all_keys.keys():
#Add new keys
logger.debug("Adding Api Key with ID %s" % keypar.api_id)
ret = SeatManager.exec_request('key', 'post', key_id=keypar.api_id, v_code=keypar.api_key)
logger.debug(ret)
else:
# remove it from the list so it doesn't get deleted in the last step
seat_all_keys.pop(keypar.api_id)
if not userinfo: # TODO: should the following be done only for new keys?
# Check the key's user status
logger.debug("Retrieving user name from Auth's SeAT users database")
try:
if keypar.user.seat.username:
logger.debug("Retrieving user %s info from SeAT users database" % keypar.user.seat.username)
userinfo = SeatManager.check_user_status(keypar.user.seat.username)
except ObjectDoesNotExist:
pass
if userinfo:
try:
# If the user has activated seat, assign the key to him.
logger.debug("Transferring Api Key with ID %s to user %s with ID %s " % (
keypar.api_id,
keypar.user.seat.username,
userinfo['id']))
ret = SeatManager.exec_request('key/transfer/{}/{}'.format(keypar.api_id, userinfo['id']),
'get')
logger.debug(ret)
except ObjectDoesNotExist:
logger.debug("User does not have SeAT activated, could not assign key to user")
if bool(seat_all_keys) and not user and hasattr(settings, 'SEAT_PURGE_DELETED') and settings.SEAT_PURGE_DELETED:
# remove from SeAT keys that were removed from Auth
for key, key_user in iteritems(seat_all_keys):
# Remove the key only if it is an account or character key
ret = SeatManager.exec_request('key/{}'.format(key), 'get')
logger.debug(ret)
try:
if (ret['info']['type'] == "Account") or (ret['info']['type'] == "Character"):
logger.debug("Removing api key %s from SeAT database" % key)
ret = SeatManager.exec_request('key/{}'.format(key), 'delete')
logger.debug(ret)
except KeyError:
pass
def run_api_refresh():
users = User.objects.all()
for user in users:
# Check if the api server is online
if EveApiManager.check_if_api_server_online():
api_key_pairs = EveManager.get_api_key_pairs(user.id)
if api_key_pairs:
authserviceinfo = AuthServicesInfo.objects.get(user=user)
if settings.DEBUG:
print 'Running update on user: '******'Running on ' + api_key_pair.api_id + ':' + api_key_pair.api_key
if EveApiManager.api_key_is_valid(api_key_pair.api_id, api_key_pair.api_key):
# Update characters
characters = EveApiManager.get_characters_from_api(api_key_pair.api_id,
api_key_pair.api_key)
EveManager.update_characters_from_list(characters)
# Check our main character
character = EveManager.get_character_by_id(authserviceinfo.main_char_id)
main_alliance_id = EveManager.get_charater_corporation_id_by_id(
authserviceinfo.main_char_id)
# NPC corps return as None
if main_alliance_id is None or int(main_alliance_id) != int(settings.ALLIANCE_ID):
if settings.DEBUG:
print 'Not in Corp'
SlackManager.send_director('API ERROR: ' + user.username +
' Not in corp.\n\tServices disabled.\n\tAPI removed.')
remove_user_all_groups(user)
deactivate_services(user)
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)
else:
if settings.DEBUG:
print 'Bad API Deleting character and api for ' + user.username
SlackManager.send_director('API ERROR: Bad API for user ' + user.username +
'\n\tServices disabled.\n\tAPI removed.')
remove_user_all_groups(user)
deactivate_services(user)
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)
else:
if settings.DEBUG:
print 'No main_char_id set'
def run_api_refresh():
users = User.objects.all()
for user in users:
# Check if the api server is online
if EveApiManager.check_if_api_server_online():
api_key_pairs = EveManager.get_api_key_pairs(user.id)
if api_key_pairs:
valid_key = False
authserviceinfo = AuthServicesInfo.objects.get(user=user)
print 'Running update on user: '******'Running on ' + api_key_pair.api_id + ':' + api_key_pair.api_key
if EveApiManager.api_key_is_valid(
api_key_pair.api_id, api_key_pair.api_key):
# Update characters
characters = EveApiManager.get_characters_from_api(
api_key_pair.api_id, api_key_pair.api_key)
EveManager.update_characters_from_list(
characters)
valid_key = True
else:
EveManager.delete_characters_by_api_id(
api_key_pair.api_id, user)
EveManager.delete_api_key_pair(
api_key_pair.api_id, api_key_pair.api_key)
if valid_key:
# Check our main character
character = EveManager.get_character_by_id(
authserviceinfo.main_char_id)
corp = EveManager.get_corporation_info_by_id(
character.corporation_id)
main_alliance_id = EveManager.get_charater_alliance_id_by_id(
authserviceinfo.main_char_id)
if main_alliance_id == settings.ALLIANCE_ID:
pass
elif corp is not None:
if corp.is_blue is not True:
deactivate_services(user)
else:
deactivate_services(user)
else:
# nuke it
deactivate_services(user)
else:
print 'No main_char_id set'
def synchronize_eveapis(user=None):
seat_all_keys = SeatManager.get_all_seat_eveapis()
userinfo = None
# retrieve only user-specific api keys if user is specified
if user:
auth, c = AuthServicesInfo.objects.get_or_create(user=user.id)
keypars = EveManager.get_api_key_pairs(user)
if auth.seat_username:
userinfo = SeatManager.check_user_status(auth.seat_username)
else:
# retrieve all api keys instead
keypars = EveManager.get_all_api_key_pairs()
if keypars:
for keypar in keypars:
if keypar.api_id not in seat_all_keys.keys():
#Add new keys
logger.debug("Adding Api Key with ID %s" % keypar.api_id)
ret = SeatManager.exec_request('key', 'post', key_id=keypar.api_id, v_code=keypar.api_key)
logger.debug(ret)
else:
# remove it from the list so it doesn't get deleted in the last step
seat_all_keys.pop(keypar.api_id)
if not userinfo: # TODO: should the following be done only for new keys?
# Check the key's user status
logger.debug("Retrieving user name from Auth's SeAT users database")
auth, c = AuthServicesInfo.objects.get_or_create(user=keypar.user)
if auth.seat_username:
logger.debug("Retrieving user %s info from SeAT users database" % auth.seat_username)
userinfo = SeatManager.check_user_status(auth.seat_username)
if userinfo:
# If the user has activated seat, assign the key to him.
logger.debug("Transferring Api Key with ID %s to user %s with ID %s " % (keypar.api_id, auth.seat_username,
userinfo['id']))
ret = SeatManager.exec_request('key/transfer/' + keypar.api_id + '/' + userinfo['id'], 'get')
logger.debug(ret)
if bool(seat_all_keys) & (not user):
# remove from SeAT keys that were removed from Auth
for key, key_user in seat_all_keys.iteritems():
# Remove the key only if it is an account or character key
ret = SeatManager.exec_request('key/'+key, 'get')
logger.debug(ret)
try:
if (ret['info']['type'] == "Account") or (ret['info']['type'] == "Character"):
logger.debug("Removing api key %s from SeAT database" % key)
ret = SeatManager.exec_request('key' + "/" + key, 'delete')
logger.debug(ret)
except KeyError:
pass
def add_api_key(request):
logger.debug("add_api_key called by user %s" % request.user)
if request.method == 'POST':
form = UpdateKeyForm(request.user, request.POST)
logger.debug("Request type POST with form valid: %s" % form.is_valid())
if form.is_valid():
if EveApiKeyPair.objects.filter(api_id=form.cleaned_data['api_id'],
api_key=form.cleaned_data['api_key']).exists():
# allow orphaned keys to proceed to SSO validation upon re-entry
api_key = EveApiKeyPair.objects.get(api_id=form.cleaned_data['api_id'],
api_key=form.cleaned_data['api_key'])
elif EveApiKeyPair.objects.filter(api_id=form.cleaned_data['api_id']).exists():
logger.warn('API %s re-added with different vcode.' % form.cleaned_data['api_id'])
EveApiKeyPair.objects.filter(api_id=form.cleaned_data['api_id']).delete()
api_key = EveApiKeyPair.objects.create(api_id=form.cleaned_data['api_id'],
api_key=form.cleaned_data['api_key'])
else:
api_key = EveApiKeyPair.objects.create(api_id=form.cleaned_data['api_id'],
api_key=form.cleaned_data['api_key'])
owner = None
if not settings.API_SSO_VALIDATION:
# set API and character owners if SSO validation not requested
api_key.user = request.user
api_key.save()
owner = request.user
# Grab characters associated with the key pair
characters = EveApiManager.get_characters_from_api(form.cleaned_data['api_id'],
form.cleaned_data['api_key'])
EveManager.create_characters_from_list(characters, owner, form.cleaned_data['api_id'])
logger.info("Successfully processed api add form for user %s" % request.user)
if not settings.API_SSO_VALIDATION:
messages.success(request, 'Added API key %s to your account.' % form.cleaned_data['api_id'])
auth = AuthServicesInfo.objects.get_or_create(user=request.user)[0]
if not auth.main_char_id:
return redirect('auth_characters')
return redirect("/api_key_management/")
else:
logger.debug('Requesting SSO validation of API %s by user %s' % (api_key.api_id, request.user))
return render(request, 'registered/apisso.html', context={'api':api_key})
else:
logger.debug("Form invalid: returning to form.")
else:
logger.debug("Providing empty update key form for user %s" % request.user)
form = UpdateKeyForm(request.user)
context = {'form': form, 'apikeypairs': EveManager.get_api_key_pairs(request.user.id)}
return render(request, 'registered/addapikey.html', context=context)
def add_api_key(request):
logger.debug("add_api_key called by user %s" % request.user)
if request.method == 'POST':
form = UpdateKeyForm(request.user, request.POST)
logger.debug("Request type POST with form valid: %s" % form.is_valid())
if form.is_valid():
if EveApiKeyPair.objects.filter(api_id=form.cleaned_data['api_id'],
api_key=form.cleaned_data['api_key']).exists():
# allow orphaned keys to proceed to SSO validation upon re-entry
api_key = EveApiKeyPair.objects.get(api_id=form.cleaned_data['api_id'],
api_key=form.cleaned_data['api_key'])
elif EveApiKeyPair.objects.filter(api_id=form.cleaned_data['api_id']).exists():
logger.warn('API %s re-added with different vcode.' % form.cleaned_data['api_id'])
EveApiKeyPair.objects.filter(api_id=form.cleaned_data['api_id']).delete()
api_key = EveApiKeyPair.objects.create(api_id=form.cleaned_data['api_id'],
api_key=form.cleaned_data['api_key'])
else:
api_key = EveApiKeyPair.objects.create(api_id=form.cleaned_data['api_id'],
api_key=form.cleaned_data['api_key'])
owner = None
if not settings.API_SSO_VALIDATION:
# set API and character owners if SSO validation not requested
api_key.user = request.user
api_key.save()
owner = request.user
# Grab characters associated with the key pair
characters = EveManager.get_characters_from_api(api_key)
[EveManager.create_character_obj(c, owner, api_key.api_id) for c in characters if
not EveCharacter.objects.filter(character_id=c.id).exists()]
logger.info("Successfully processed api add form for user %s" % request.user)
if not settings.API_SSO_VALIDATION:
messages.success(request, 'Added API key %s to your account.' % form.cleaned_data['api_id'])
auth = AuthServicesInfo.objects.get(user=request.user)
if not auth.main_char_id:
return redirect('auth_characters')
return redirect("auth_dashboard")
else:
logger.debug('Requesting SSO validation of API %s by user %s' % (api_key.api_id, request.user))
return render(request, 'registered/apisso.html', context={'api': api_key})
else:
logger.debug("Form invalid: returning to form.")
else:
logger.debug("Providing empty update key form for user %s" % request.user)
form = UpdateKeyForm(request.user)
context = {'form': form, 'apikeypairs': EveManager.get_api_key_pairs(request.user.id)}
return render(request, 'registered/addapikey.html', context=context)
def run_api_refresh():
users = User.objects.all()
for user in users:
# Check if the api server is online
if EveApiManager.check_if_api_server_online():
api_key_pairs = EveManager.get_api_key_pairs(user.id)
if api_key_pairs:
valid_key = False
authserviceinfo = AuthServicesInfo.objects.get(user=user)
print 'Running update on user: '******'Running on ' + api_key_pair.api_id + ':' + api_key_pair.api_key
if EveApiManager.api_key_is_valid(api_key_pair.api_id, api_key_pair.api_key):
# Update characters
characters = EveApiManager.get_characters_from_api(api_key_pair.api_id,
api_key_pair.api_key)
EveManager.update_characters_from_list(characters)
valid_key = True
else:
EveManager.delete_characters_by_api_id(api_key_pair.api_id, user)
EveManager.delete_api_key_pair(api_key_pair.api_id, api_key_pair.api_key)
if valid_key:
# Check our main character
character = EveManager.get_character_by_id(authserviceinfo.main_char_id)
corp = EveManager.get_corporation_info_by_id(character.corporation_id)
main_alliance_id = EveManager.get_charater_alliance_id_by_id(authserviceinfo.main_char_id)
if main_alliance_id == settings.ALLIANCE_ID:
pass
elif corp is not None:
if corp.is_blue is not True:
deactivate_services(user)
else:
deactivate_services(user)
else:
# nuke it
deactivate_services(user)
else:
print 'No main_char_id set'
def run_api_refresh():
users = User.objects.all()
logger.debug("Running api refresh on %s users." % len(users))
for user in users:
# Check if the api server is online
logger.debug("Running api refresh for user %s" % user)
if EveApiManager.check_if_api_server_online():
api_key_pairs = EveManager.get_api_key_pairs(user.id)
logger.debug("User %s has api key pairs %s" % (user, api_key_pairs))
if api_key_pairs:
authserviceinfo, c = AuthServicesInfo.objects.get_or_create(user=user)
logger.debug("User %s has api keys. Proceeding to refresh." % user)
for api_key_pair in api_key_pairs:
refresh_api(api_key_pair)
# Check our main character
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))
authserviceinfo.main_char_id = ''
authserviceinfo.save()
set_state(user)
def run_api_refresh():
users = User.objects.all()
logger.debug("Running api refresh on %s users." % len(users))
for user in users:
# Check if the api server is online
logger.debug("Running api refresh for user %s" % user)
if EveApiManager.check_if_api_server_online():
api_key_pairs = EveManager.get_api_key_pairs(user.id)
logger.debug("User %s has api key pairs %s" % (user, api_key_pairs))
if api_key_pairs:
authserviceinfo, c = AuthServicesInfo.objects.get_or_create(user=user)
logger.debug("User %s has api keys. Proceeding to refresh." % user)
for api_key_pair in api_key_pairs:
refresh_api(api_key_pair)
# Check our main character
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))
authserviceinfo.main_char_id = ''
authserviceinfo.save()
notify(user, "Main Character Reset", message="Your specified main character no longer has a model.\nThis could be the result of an invalid API\nYour main character ID has been reset." % api_key_pair.api_id, level="warn")
set_state(user)
def dashboard_view(request):
logger.debug("dashboard_view called by user %s" % request.user)
auth_info = AuthServicesInfo.objects.get(user=request.user)
apikeypairs = EveManager.get_api_key_pairs(request.user.id)
sso_validation = settings.API_SSO_VALIDATION or False
api_chars = []
if apikeypairs:
for api in apikeypairs:
api_chars.append({
'id': api.api_id,
'sso_verified': api.sso_verified if sso_validation else True,
'characters': EveCharacter.objects.filter(api_id=api.api_id),
})
context = {
'main': EveManager.get_character_by_id(auth_info.main_char_id),
'apis': api_chars,
'api_sso_validation': settings.API_SSO_VALIDATION or False,
}
return render(request, 'registered/dashboard.html', context=context)
def dashboard_view(request):
logger.debug("dashboard_view called by user %s" % request.user)
auth_info = AuthServicesInfo.objects.get(user=request.user)
apikeypairs = EveManager.get_api_key_pairs(request.user.id)
sso_validation = settings.API_SSO_VALIDATION or False
api_chars = []
if apikeypairs:
for api in apikeypairs:
api_chars.append({
'id': api.api_id,
'sso_verified': api.sso_verified if sso_validation else True,
'characters': EveCharacter.objects.filter(api_id=api.api_id),
})
context = {
'main': EveManager.get_character_by_id(auth_info.main_char_id),
'apis': api_chars,
'api_sso_validation': settings.API_SSO_VALIDATION or False,
}
return render(request, 'registered/dashboard.html', context=context)
def run_api_refresh():
users = User.objects.all()
for user in users:
# Check if the api server is online
if EveApiManager.check_if_api_server_online():
api_key_pairs = EveManager.get_api_key_pairs(user.id)
if api_key_pairs:
valid_key = False
authserviceinfo = AuthServicesInfo.objects.get(user=user)
print 'Running update on user: '******'Running on ' + api_key_pair.api_id + ':' + api_key_pair.api_key
if EveApiManager.api_key_is_valid(api_key_pair.api_id, api_key_pair.api_key):
#check to ensure API key meets min spec
still_valid = True
if authserviceinfo.is_blue:
if settings.BLUE_API_ACCOUNT:
if not EveApiManager.check_api_is_type_account(api_key_pair.api_id, api_key_pair.api_key):
still_valid = False
if not EveApiManager.check_blue_api_is_full(api_key_pair.api_id, api_key_pair.api_key):
still_valid = False
else:
if settings.MEMBER_API_ACCOUNT:
if not EveApiManager.check_api_is_type_account(api_key_pair.api_id, api_key_pair.api_key):
still_valid = False
if not EveApiManager.check_api_is_full(api_key_pair.api_id, api_key_pair.api_key):
still_valid = False
if still_valid is not True:
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)
else:
# Update characters
characters = EveApiManager.get_characters_from_api(api_key_pair.api_id,
api_key_pair.api_key)
EveManager.update_characters_from_list(characters)
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
if new_character:
EveManager.create_characters_from_list(characters, user, api_key_pair.api_key)
valid_key = True
else:
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)
if valid_key:
# Check our main character
character = EveManager.get_character_by_id(authserviceinfo.main_char_id)
if character is not None and EveManager.check_if_corporation_exists_by_id(character.corporation_id):
corp = EveManager.get_corporation_info_by_id(character.corporation_id)
main_corp_id = EveManager.get_charater_corporation_id_by_id(authserviceinfo.main_char_id)
main_alliance_id = EveManager.get_charater_alliance_id_by_id(authserviceinfo.main_char_id)
if (settings.IS_CORP and main_corp_id == settings.CORP_ID) or (not settings.IS_CORP and main_alliance_id == settings.ALLIANCE_ID):
if not check_if_user_has_permission(user, "member"):
#transition from none or blue to member
if check_if_user_has_permission(user, "blue_member"):
#strip blue status
remove_member_permission(user, "blue_member")
remove_user_from_group(user, settings.DEFAULT_BLUE_GROUP)
AuthServicesInfoManager.update_is_blue(False, user)
#add to auth group
add_member_permission(user, "member")
add_user_to_group(user, settings.DEFAULT_AUTH_GROUP)
#add to required corp group
add_user_to_group(user, generate_corp_group_name(character.corporation_name))
elif corp.corporation_id != oldcorp_id:
#changed corps, both corps auth'd, need to change group assignment
oldcorp = EveCorporationInfo.objects.get(corporation_id=oldcorp_id)
remove_user_from_group(user, generate_corp_group_name(oldcorp.corporation_name))
add_user_to_group(user, generate_corp_group_name(character.corporation_name))
#reset services to force new mumble names and group assignments
deactivate_services(user)
elif corp is not None:
if corp.is_blue is not True:
if check_if_user_has_permission(user, "member"):
#transition from member to nobody
disable_alliance_member(user, authserviceinfo.main_char_id)
elif check_if_user_has_permission(user, "blue_member"):
#transition from blue to nobody
disable_blue_member(user)
else:
#stay nobody, make sure no services
deactivate_services(user)
else:
if check_if_user_has_permission(user, "member"):
#remove auth member to prepare for member to blue transition
disable_alliance_member(user, authserviceinfo.main_char_id)
if not check_if_user_has_permission(user, "blue_member"):
#perform nobody to blue transition
add_member_permission(user, "blue_member")
add_user_to_group(user, settings.DEFAULT_BLUE_GROUP)
AuthServicesInfoManager.update_is_blue(True, user)
else:
# disable accounts with missing corp model (not blue or member)
if check_if_user_has_permission(user, "member"):
disable_alliance_member(user, authserviceinfo.main_char_id)
elif check_if_user_has_permission(user, "blue_member"):
disable_blue_member(user)
else:
deactivate_services(user)
else:
# nuke it, the hard way
disable_expired_member(user)
else:
# disable accounts with invalid keys
disable_expired_member(user)
else:
print 'No main_char_id set'
def run_api_refresh():
users = User.objects.all()
logger.debug("Running api refresh on %s users." % len(users))
for user in users:
# Check if the api server is online
logger.debug("Running api refresh for user %s" % user)
if EveApiManager.check_if_api_server_online():
api_key_pairs = EveManager.get_api_key_pairs(user.id)
logger.debug("User %s has api key pairs %s" % (user, api_key_pairs))
if api_key_pairs:
valid_key = False
authserviceinfo = AuthServicesInfo.objects.get(user=user)
logger.debug("User %s has api keys. Proceeding to refresh." % user)
if authserviceinfo.main_char_id:
if authserviceinfo.main_char_id != "":
#preserve old corp ID for corp change test on members
oldcorp_id = 0
if EveManager.get_character_by_id(authserviceinfo.main_char_id):
oldcorp_id = EveCharacter.objects.get(character_id=authserviceinfo.main_char_id).corporation_id
logger.debug("Determined user %s current main corp id %s" % (user, oldcorp_id))
for api_key_pair in api_key_pairs:
logger.debug("Running update on api key %s" % api_key_pair.api_id)
if EveApiManager.api_key_is_valid(api_key_pair.api_id, api_key_pair.api_key):
#check to ensure API key meets min spec
logger.info("Determined api key %s is still active." % api_key_pair.api_id)
still_valid = True
if authserviceinfo.is_blue:
if settings.BLUE_API_ACCOUNT:
if not EveApiManager.check_api_is_type_account(api_key_pair.api_id, api_key_pair.api_key):
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
if not EveApiManager.check_blue_api_is_full(api_key_pair.api_id, api_key_pair.api_key):
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
else:
if settings.MEMBER_API_ACCOUNT:
if not EveApiManager.check_api_is_type_account(api_key_pair.api_id, api_key_pair.api_key):
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
if not EveApiManager.check_api_is_full(api_key_pair.api_id, api_key_pair.api_key):
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
if still_valid is not True:
logger.debug("API key %s has failed validation; 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_api_key_pair(api_key_pair.api_id, user.id)
else:
logger.info("Determined api key %s still meets requirements." % api_key_pair.api_id)
# Update characters
characters = EveApiManager.get_characters_from_api(api_key_pair.api_id,
api_key_pair.api_key)
EveManager.update_characters_from_list(characters)
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_key)
valid_key = True
else:
logger.debug("API key %s is no longer active; 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_api_key_pair(api_key_pair.api_id, user.id)
if valid_key:
# Check our main character
character = EveManager.get_character_by_id(authserviceinfo.main_char_id)
logger.debug("User %s has valid api key, checking main character %s" % (user, character))
if character is not None and EveManager.check_if_corporation_exists_by_id(character.corporation_id):
corp = EveManager.get_corporation_info_by_id(character.corporation_id)
main_corp_id = EveManager.get_charater_corporation_id_by_id(authserviceinfo.main_char_id)
main_alliance_id = EveManager.get_charater_alliance_id_by_id(authserviceinfo.main_char_id)
logger.debug("User %s main character %s has corp %s with alliance id %s" % (user, character, corp, main_alliance_id))
if (settings.IS_CORP and main_corp_id == settings.CORP_ID) or (not settings.IS_CORP and main_alliance_id == settings.ALLIANCE_ID):
logger.debug("User %s corp or alliance meets membership requirements. Ensuring has required permissions and groups." % user)
if not check_if_user_has_permission(user, "member"):
#transition from none or blue to member
if check_if_user_has_permission(user, "blue_member"):
#strip blue status
logger.debug("Removing user %s blue permission and group to prepare for member transition." % user)
remove_member_permission(user, "blue_member")
remove_user_from_group(user, settings.DEFAULT_BLUE_GROUP)
AuthServicesInfoManager.update_is_blue(False, user)
#add to auth group
add_member_permission(user, "member")
add_user_to_group(user, settings.DEFAULT_AUTH_GROUP)
#add to required corp group
add_user_to_group(user, generate_corp_group_name(character.corporation_name))
logger.info("User %s transitioned to full member during api refresh." % user)
elif corp.corporation_id != oldcorp_id:
#changed corps, both corps auth'd, need to change group assignment
logger.debug("User %s main character changed corp from id %s to %s, both meet membership requirements. Updating corp group." % (user, oldcorp_id, corp.corporation_id))
oldcorp = EveCorporationInfo.objects.get(corporation_id=oldcorp_id)
remove_user_from_group(user, generate_corp_group_name(oldcorp.corporation_name))
add_user_to_group(user, generate_corp_group_name(character.corporation_name))
#reset services to force new mumble names and group assignments
deactivate_services(user)
logger.info("User %s transferred corps from member to member. Reassigned groups." % user)
elif corp is not None:
logger.debug("User %s main corp %s does not meet membership requirements." % (user, corp))
if corp.is_blue is not True:
if check_if_user_has_permission(user, "member"):
#transition from member to nobody
disable_alliance_member(user, authserviceinfo.main_char_id)
logger.info("User %s no longer member: main has left member corp/alliance." % user)
elif check_if_user_has_permission(user, "blue_member"):
#transition from blue to nobody
disable_blue_member(user)
logger.info("User %s no longer blue: main has left blue entities." % user)
else:
#stay nobody, make sure no services
deactivate_services(user)
logger.debug("Ensured non-member %s has no services." % user)
else:
if check_if_user_has_permission(user, "member"):
#remove auth member to prepare for member to blue transition
disable_alliance_member(user, authserviceinfo.main_char_id)
logger.debug("Removed user %s member group/permissions to transition to blue." % user)
if not check_if_user_has_permission(user, "blue_member"):
#perform nobody to blue transition
add_member_permission(user, "blue_member")
add_user_to_group(user, settings.DEFAULT_BLUE_GROUP)
AuthServicesInfoManager.update_is_blue(True, user)
logger.info("User %s transitioned to blue member during api refresh." % user)
else:
# disable accounts with missing corp model (not blue or member)
if check_if_user_has_permission(user, "member"):
disable_alliance_member(user, authserviceinfo.main_char_id)
logger.info("User %s disabled (previously member) as unable to check missing corp model." % user)
elif check_if_user_has_permission(user, "blue_member"):
disable_blue_member(user)
logger.info("User %s disabled (previously blue) as unable to check missing corp model." % user)
else:
deactivate_services(user)
logger.debug("Ensured non-member %s has no services." % user)
else:
# nuke it, the hard way
disable_expired_member(user)
logger.info("User %s disabled due to missing main character or corp model." % user)
else:
# disable accounts with invalid keys
disable_expired_member(user)
logger.info("User %s has no valid api keys and has been disabled." % user)
else:
logger.warn("User %s has no main character id, unable to validate membership.")
def synchronize_eveapis(user=None):
seat_all_keys = SeatManager.get_all_seat_eveapis()
userinfo = None
# retrieve only user-specific api keys if user is specified
if user:
keypars = EveManager.get_api_key_pairs(user)
try:
userinfo = SeatManager.check_user_status(user.seat.username)
except ObjectDoesNotExist:
pass
else:
# retrieve all api keys instead
keypars = EveManager.get_all_api_key_pairs()
if keypars:
for keypar in keypars:
if keypar.api_id not in seat_all_keys.keys():
#Add new keys
logger.debug("Adding Api Key with ID %s" % keypar.api_id)
ret = SeatManager.exec_request('key',
'post',
key_id=keypar.api_id,
v_code=keypar.api_key)
logger.debug(ret)
else:
# remove it from the list so it doesn't get deleted in the last step
seat_all_keys.pop(keypar.api_id)
if not userinfo: # TODO: should the following be done only for new keys?
# Check the key's user status
logger.debug(
"Retrieving user name from Auth's SeAT users database")
try:
if keypar.user.seat.username:
logger.debug(
"Retrieving user %s info from SeAT users database"
% keypar.user.seat.username)
userinfo = SeatManager.check_user_status(
keypar.user.seat.username)
except ObjectDoesNotExist:
pass
if userinfo:
try:
# If the user has activated seat, assign the key to him.
logger.debug(
"Transferring Api Key with ID %s to user %s with ID %s "
% (keypar.api_id, keypar.user.seat.username,
userinfo['id']))
ret = SeatManager.exec_request(
'key/transfer/{}/{}'.format(
keypar.api_id, userinfo['id']), 'get')
logger.debug(ret)
except ObjectDoesNotExist:
logger.debug(
"User does not have SeAT activated, could not assign key to user"
)
if bool(seat_all_keys) and not user and hasattr(
settings,
'SEAT_PURGE_DELETED') and settings.SEAT_PURGE_DELETED:
# remove from SeAT keys that were removed from Auth
for key, key_user in iteritems(seat_all_keys):
# Remove the key only if it is an account or character key
ret = SeatManager.exec_request('key/{}'.format(key), 'get')
logger.debug(ret)
try:
if (ret['info']['type']
== "Account") or (ret['info']['type']
== "Character"):
logger.debug("Removing api key %s from SeAT database" %
key)
ret = SeatManager.exec_request('key/{}'.format(key),
'delete')
logger.debug(ret)
except KeyError:
pass
def synchronize_eveapis(cls, user=None):
# Fetch all of the API keys stored in SeAT already
seat_all_keys = cls.get_all_seat_eveapis()
# retrieve only user-specific api keys if user is specified
if user:
keypairs = EveManager.get_api_key_pairs(user)
else:
# retrieve all api keys instead
keypairs = EveManager.get_all_api_key_pairs()
for keypair in keypairs:
# Transfer the key if it isn't already in SeAT
if keypair.api_id not in seat_all_keys.keys():
# Add new keys
logger.debug("Adding Api Key with ID %s" % keypair.api_id)
try:
ret = cls.exec_request('key', 'post',
key_id=keypair.api_id,
v_code=keypair.api_key,
raise_for_status=True)
logger.debug(ret)
except requests.HTTPError as e:
if e.response.status_code == 400:
logger.debug("API key already exists")
else:
logger.exception("API key sync failed")
continue # Skip the rest of the key processing
else:
# remove it from the list so it doesn't get deleted in the last step
seat_all_keys.pop(keypair.api_id)
# Attach API key to the users SeAT account, if possible
try:
userinfo = cache.get_or_set('seat_user_status_' + cls.username_hash(keypair.user.seat.username),
lambda: cls.check_user_status(keypair.user.seat.username),
300) # Cache for 5 minutes
if not bool(userinfo):
# No SeAT account, skip
logger.debug("Could not find users SeAT id, cannot assign key to them")
continue
# If the user has activated seat, assign the key to them
logger.debug("Transferring Api Key with ID %s to user %s with ID %s " % (
keypair.api_id,
keypair.user.seat.username,
userinfo['id']))
ret = cls.exec_request('key/transfer/{}/{}'.format(keypair.api_id, userinfo['id']),
'get')
logger.debug(ret)
except ObjectDoesNotExist:
logger.debug("User does not have SeAT activated, could not assign key to user")
if bool(seat_all_keys) and not user and getattr(settings, 'SEAT_PURGE_DELETED', False):
# remove from SeAT keys that were removed from Auth
for key, key_user in iteritems(seat_all_keys):
# Remove the key only if it is an account or character key
ret = cls.exec_request('key/{}'.format(key), 'get')
logger.debug(ret)
try:
if (ret['info']['type'] == "Account") or (ret['info']['type'] == "Character"):
logger.debug("Removing api key %s from SeAT database" % key)
ret = cls.exec_request('key/{}'.format(key), 'delete')
logger.debug(ret)
except KeyError:
pass
def synchronize_eveapis(cls, user=None):
# Fetch all of the API keys stored in SeAT already
seat_all_keys = cls.get_all_seat_eveapis()
# retrieve only user-specific api keys if user is specified
if user:
keypairs = EveManager.get_api_key_pairs(user)
else:
# retrieve all api keys instead
keypairs = EveManager.get_all_api_key_pairs()
for keypair in keypairs:
# Transfer the key if it isn't already in SeAT
if keypair.api_id not in seat_all_keys.keys():
# Add new keys
logger.debug("Adding Api Key with ID %s" % keypair.api_id)
try:
ret = cls.exec_request('key',
'post',
key_id=keypair.api_id,
v_code=keypair.api_key,
raise_for_status=True)
logger.debug(ret)
except requests.HTTPError as e:
if e.response.status_code == 400:
logger.debug("API key already exists")
else:
logger.exception("API key sync failed")
continue # Skip the rest of the key processing
else:
# remove it from the list so it doesn't get deleted in the last step
seat_all_keys.pop(keypair.api_id)
# Attach API key to the users SeAT account, if possible
try:
userinfo = cache.get_or_set(
'seat_user_status_' +
cls.username_hash(keypair.user.seat.username),
lambda: cls.check_user_status(keypair.user.seat.username),
300) # Cache for 5 minutes
if not bool(userinfo):
# No SeAT account, skip
logger.debug(
"Could not find users SeAT id, cannot assign key to them"
)
continue
# If the user has activated seat, assign the key to them
logger.debug(
"Transferring Api Key with ID %s to user %s with ID %s " %
(keypair.api_id, keypair.user.seat.username,
userinfo['id']))
ret = cls.exec_request(
'key/transfer/{}/{}'.format(keypair.api_id,
userinfo['id']), 'get')
logger.debug(ret)
except ObjectDoesNotExist:
logger.debug(
"User does not have SeAT activated, could not assign key to user"
)
if bool(seat_all_keys) and not user and getattr(
settings, 'SEAT_PURGE_DELETED', False):
# remove from SeAT keys that were removed from Auth
for key, key_user in iteritems(seat_all_keys):
# Remove the key only if it is an account or character key
ret = cls.exec_request('key/{}'.format(key), 'get')
logger.debug(ret)
try:
if (ret['info']['type']
== "Account") or (ret['info']['type']
== "Character"):
logger.debug("Removing api key %s from SeAT database" %
key)
ret = cls.exec_request('key/{}'.format(key), 'delete')
logger.debug(ret)
except KeyError:
pass
def run_api_refresh():
users = User.objects.all()
logger.debug("Running api refresh on %s users." % len(users))
for user in users:
# Check if the api server is online
logger.debug("Running api refresh for user %s" % user)
if EveApiManager.check_if_api_server_online():
api_key_pairs = EveManager.get_api_key_pairs(user.id)
logger.debug("User %s has api key pairs %s" % (user, api_key_pairs))
if api_key_pairs:
authserviceinfo, c = AuthServicesInfo.objects.get_or_create(user=user)
logger.debug("User %s has api keys. Proceeding to refresh." % user)
for api_key_pair in api_key_pairs:
logger.debug("Running update on api key %s" % api_key_pair.api_id)
if EveApiManager.api_key_is_valid(api_key_pair.api_id, api_key_pair.api_key):
# check to ensure API key meets min spec
logger.info("Determined api key %s is still active." % api_key_pair.api_id)
still_valid = True
state = determine_membership_by_user(user)
if state == "BLUE":
if settings.BLUE_API_ACCOUNT:
type = 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)
)
still_valid = False
full = 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)
)
still_valid = False
elif state == "MEMBER":
if settings.MEMBER_API_ACCOUNT:
type = 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)
)
still_valid = False
full = 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)
)
still_valid = False
if still_valid == None:
if api_key_pair.error_count >= 3:
logger.info(
"API key %s has incurred 3 or more errors. Assuming invalid." % api_key_pair.api_id
)
still_valid = False
if still_valid == False:
logger.debug(
"API key %s has failed validation; 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_api_key_pair(api_key_pair.api_id, user.id)
elif still_valid == True:
if api_key_pair.error_count != 0:
logger.info(
"Clearing error count for api %s as it passed validation" % api_key_pair.api_id
)
api_key_pair.error_count = 0
api_key_pair.save()
logger.info("Determined api key %s still meets requirements." % api_key_pair.api_id)
# Update characters
characters = EveApiManager.get_characters_from_api(
api_key_pair.api_id, api_key_pair.api_key
)
EveManager.update_characters_from_list(characters)
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_key)
else:
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_api_key_pair(api_key_pair.api_id, user.id)
# Check our main character
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)
)
authserviceinfo.main_char_id = ""
authserviceinfo.save()
else:
logger.warn("User %s has no main character id, unable to validate membership.")
set_state(user)
def api_key_management_view(request):
logger.debug("api_key_management_view called by user %s" % request.user)
context = {'apikeypairs': EveManager.get_api_key_pairs(request.user.id)}
return render(request, 'registered/apikeymanagment.html', context=context)
