Mathis/allianceauth
1
0
Fork 0
mirror of https://gitlab.com/allianceauth/allianceauth.git synced 2026-02-08 08:06:20 +01:00
Code Issues Packages Projects Releases Wiki Activity

Bulk of the profile work is done.

Browse Source
This commit is contained in:
Adarnof
2017-03-23 22:54:25 -04:00
parent bb87fdd958
commit e15d79b834
155 changed files with 1693 additions and 3080 deletions
Download Patch File Download Diff File Expand all files Collapse all files

41
eveonline/admin.py
View File

@@ -1,46 +1,31 @@
from __future__ import unicode_literals
from django.contrib import admin
from django.core.exceptions import ObjectDoesNotExist
from eveonline.models import EveCharacter
from eveonline.models import EveApiKeyPair
from eveonline.models import EveAllianceInfo
from eveonline.models import EveCorporationInfo
from authentication.models import AuthServicesInfo
admin.site.register(EveAllianceInfo)
admin.site.register(EveCorporationInfo)
class EveApiKeyPairAdmin(admin.ModelAdmin):
search_fields = ['api_id', 'user__username']
list_display = ['api_id', 'user', 'characters']
@staticmethod
def characters(obj):
return ', '.join(sorted([c.character_name for c in EveCharacter.objects.filter(api_id=obj.api_id)]))
def get_search_results(self, request, queryset, search_term):
queryset, use_distinct = super(EveApiKeyPairAdmin, self).get_search_results(request, queryset, search_term)
chars = EveCharacter.objects.filter(character_name__icontains=search_term)
queryset |= EveApiKeyPair.objects.filter(api_id__in=[char.api_id for char in chars if bool(char.api_id)])
return queryset, use_distinct
class EveCharacterAdmin(admin.ModelAdmin):
search_fields = ['character_name', 'corporation_name', 'alliance_name', 'user__username', 'api_id']
search_fields = ['character_name', 'corporation_name', 'alliance_name', 'character_ownership__user__username']
list_display = ('character_name', 'corporation_name', 'alliance_name', 'user', 'main_character')
@staticmethod
def user(obj):
try:
return obj.character_ownership.user
except (AttributeError, ObjectDoesNotExist):
return None
@staticmethod
def main_character(obj):
if obj.user:
auth = AuthServicesInfo.objects.get(user=obj.user)
if auth and auth.main_char_id:
try:
return EveCharacter.objects.get(character_id=auth.main_char_id)
except EveCharacter.DoesNotExist:
pass
return None
try:
return obj.character_ownership.user.profile.main_character
except (AttributeError, ObjectDoesNotExist):
return None
admin.site.register(EveCharacter, EveCharacterAdmin)
admin.site.register(EveApiKeyPair, EveApiKeyPairAdmin)

52
eveonline/forms.py
View File

@@ -1,52 +0,0 @@
from __future__ import unicode_literals
from django import forms
from django.conf import settings
from services.managers.eve_api_manager import EveApiManager
from eveonline.managers import EveManager
from eveonline.models import EveApiKeyPair
import evelink
import logging
logger = logging.getLogger(__name__)
class UpdateKeyForm(forms.Form):
api_id = forms.CharField(max_length=254, required=True, label="Key ID")
api_key = forms.CharField(max_length=254, required=True, label="Verification Code")
def __init__(self, user, *args, **kwargs):
super(UpdateKeyForm, self).__init__(*args, **kwargs)
self.user = user
def clean_api_id(self):
try:
api_id = int(self.cleaned_data['api_id'])
return api_id
except:
raise forms.ValidationError("API ID must be a number")
def clean(self):
if 'api_id' not in self.cleaned_data or 'api_key' not in self.cleaned_data:
# need to check if api_id and vcode in cleaned_data because
# if they fail, they get removed from the dict but this method still happens
return self.cleaned_data
if EveManager.check_if_api_key_pair_exist(self.cleaned_data['api_id']):
logger.debug("UpdateKeyForm failed cleaning as API id %s already exists." % self.cleaned_data['api_id'])
if EveApiKeyPair.objects.get(api_id=self.cleaned_data['api_id']).user:
# allow orphaned APIs to proceed to SSO validation upon re-entry
raise forms.ValidationError('API key already exist')
if settings.REJECT_OLD_APIS and not EveManager.check_if_api_key_pair_is_new(
self.cleaned_data['api_id'],
settings.REJECT_OLD_APIS_MARGIN):
raise forms.ValidationError('API key is too old. Please create a new key')
try:
EveApiManager.validate_api(self.cleaned_data['api_id'], self.cleaned_data['api_key'], self.user)
return self.cleaned_data
except EveApiManager.ApiValidationError as e:
raise forms.ValidationError(str(e))
except evelink.api.APIError as e:
logger.debug("Got error code %s while validating API %s" % (e.code, self.cleaned_data['api_id']))
raise forms.ValidationError('Error while checking API key (%s)' % e.code)

112
eveonline/managers.py
View File

@@ -1,11 +1,8 @@
from __future__ import unicode_literals
from eveonline.models import EveCharacter
from eveonline.models import EveApiKeyPair
from eveonline.models import EveAllianceInfo
from eveonline.models import EveCorporationInfo
from authentication.models import AuthServicesInfo
from eveonline.providers import eve_adapter_factory, EveXmlProvider
from services.managers.eve_api_manager import EveApiManager
from eveonline.providers import eve_adapter_factory
import logging
logger = logging.getLogger(__name__)
@@ -25,11 +22,11 @@ class EveManager(object):
return cls.get_adapter().get_character(character_id)
@staticmethod
def create_character(id, user, api_id):
return EveManager.create_character_obj(EveManager.get_character(id), user, api_id)
def create_character(id):
return EveManager.create_character_obj(EveManager.get_character(id))
@staticmethod
def create_character_obj(character, user, api_id):
def create_character_obj(character,):
return EveCharacter.objects.create(
character_id=character.id,
character_name=character.name,
@@ -38,8 +35,6 @@ class EveManager(object):
corporation_ticker=character.corp.ticker,
alliance_id=character.alliance.id,
alliance_name=character.alliance.name,
user=user,
api_id=api_id,
)
@staticmethod
@@ -58,19 +53,6 @@ class EveManager(object):
model.save()
return model
@staticmethod
def create_api_keypair(api_id, api_key, user_id):
logger.debug("Creating api keypair id %s for user_id %s" % (api_id, user_id))
if not EveApiKeyPair.objects.filter(api_id=api_id).exists():
api_pair = EveApiKeyPair()
api_pair.api_id = api_id
api_pair.api_key = api_key
api_pair.user = user_id
api_pair.save()
logger.info("Created api keypair id %s for user %s" % (api_id, user_id))
else:
logger.warn("Attempting to create existing api keypair with id %s" % api_id)
@classmethod
def get_alliance(cls, alliance_id):
return cls.get_adapter().get_alliance(alliance_id)
@@ -157,82 +139,6 @@ class EveManager(object):
def get_itemtype(cls, type_id):
return cls.get_adapter().get_itemtype(type_id)
@staticmethod
def get_characters_from_api(api):
char_result = EveApiManager.get_characters_from_api(api.api_id, api.api_key).result
provider = EveXmlProvider(adapter=EveManager.get_adapter())
return [provider._build_character(result) for id, result in char_result.items()]
@staticmethod
def get_api_key_pairs(user):
if EveApiKeyPair.objects.filter(user=user).exists():
logger.debug("Returning api keypairs for user %s" % user)
return EveApiKeyPair.objects.filter(user=user)
else:
logger.debug("No api keypairs found for user %s" % user)
@staticmethod
def get_all_api_key_pairs():
if EveApiKeyPair.objects.exists():
logger.debug("Returning all api keypairs.")
return EveApiKeyPair.objects.all()
else:
logger.debug("No api keypairs found.")
@staticmethod
def check_if_api_key_pair_exist(api_id):
if EveApiKeyPair.objects.filter(api_id=api_id).exists():
logger.debug("Determined api id %s exists." % api_id)
return True
else:
logger.debug("Determined api id %s does not exist." % api_id)
return False
@staticmethod
def check_if_api_key_pair_is_new(api_id, fudge_factor):
if EveApiKeyPair.objects.count() == 0:
return True
latest_api_id = int(EveApiKeyPair.objects.order_by('-api_id')[0].api_id) - fudge_factor
if latest_api_id >= api_id:
logger.debug("api key (%d) is older than latest API key (%d). Rejecting" % (api_id, latest_api_id))
return False
else:
logger.debug("api key (%d) is new. Accepting" % api_id)
return True
@staticmethod
def delete_api_key_pair(api_id, user_id):
logger.debug("Deleting api id %s" % api_id)
if EveApiKeyPair.objects.filter(api_id=api_id).exists():
# Check that its owned by our user_id
apikeypair = EveApiKeyPair.objects.get(api_id=api_id)
if apikeypair.user.id == user_id:
logger.info("Deleted user %s api key id %s" % (user_id, api_id))
apikeypair.delete()
else:
logger.error(
"Unable to delete api: user mismatch: key id %s owned by user id %s, not deleting user id %s" % (
api_id, apikeypair.user.id, user_id))
else:
logger.warn("Unable to locate api id %s - cannot delete." % api_id)
@staticmethod
def delete_characters_by_api_id(api_id, user_id):
logger.debug("Deleting all characters associated with api id %s" % api_id)
if EveCharacter.objects.filter(api_id=api_id).exists():
# Check that its owned by our user_id
characters = EveCharacter.objects.filter(api_id=api_id)
logger.debug("Got user %s characters %s from api %s" % (user_id, characters, api_id))
for char in characters:
if char.user.id == user_id:
logger.info("Deleting user %s character %s from api %s" % (user_id, char, api_id))
char.delete()
else:
logger.error(
"Unable to delete character %s by api %s: user mismatch: character owned by user id %s, "
"not deleting user id %s" % (
char, api_id, char.user.id, user_id))
@staticmethod
def check_if_character_exist(char_name):
return EveCharacter.objects.filter(character_name=char_name).exists()
@@ -256,16 +162,6 @@ class EveManager(object):
return None
@staticmethod
def get_main_character(user):
"""
Get a characters main
:param user: django.contrib.auth.models.User
:return: EveCharacter
"""
authserviceinfo = AuthServicesInfo.objects.get(user=user)
return EveManager.get_character_by_id(authserviceinfo.main_char_id)
@staticmethod
def get_characters_by_api_id(api_id):
return EveCharacter.objects.filter(api_id=api_id)

38
eveonline/migrations/0008_remove_apikeys.py Normal file
View File

@@ -0,0 +1,38 @@
# -*- coding: utf-8 -*-
# Generated by Django 1.10.5 on 2017-03-22 23:09
from __future__ import unicode_literals
from django.db import migrations
class Migration(migrations.Migration):
dependencies = [
('eveonline', '0007_unique_id_name'),
]
operations = [
migrations.RemoveField(
model_name='eveapikeypair',
name='user',
),
migrations.RemoveField(
model_name='eveallianceinfo',
name='is_blue',
),
migrations.RemoveField(
model_name='evecharacter',
name='api_id',
),
migrations.RemoveField(
model_name='evecharacter',
name='user',
),
migrations.RemoveField(
model_name='evecorporationinfo',
name='is_blue',
),
migrations.DeleteModel(
name='EveApiKeyPair',
),
]

16
eveonline/models.py
View File

@@ -1,7 +1,6 @@
from __future__ import unicode_literals
from django.utils.encoding import python_2_unicode_compatible
from django.db import models
from django.contrib.auth.models import User
@python_2_unicode_compatible
@@ -13,31 +12,17 @@ class EveCharacter(models.Model):
corporation_ticker = models.CharField(max_length=254)
alliance_id = models.CharField(max_length=254, blank=True, null=True, default='')
alliance_name = models.CharField(max_length=254, blank=True, null=True, default='')
api_id = models.CharField(max_length=254)
user = models.ForeignKey(User, blank=True, null=True)
def __str__(self):
return self.character_name
@python_2_unicode_compatible
class EveApiKeyPair(models.Model):
api_id = models.CharField(max_length=254, unique=True)
api_key = models.CharField(max_length=254)
user = models.ForeignKey(User, blank=True, null=True)
sso_verified = models.BooleanField(default=False)
def __str__(self):
return self.api_id
@python_2_unicode_compatible
class EveAllianceInfo(models.Model):
alliance_id = models.CharField(max_length=254, unique=True)
alliance_name = models.CharField(max_length=254, unique=True)
alliance_ticker = models.CharField(max_length=254)
executor_corp_id = models.CharField(max_length=254)
is_blue = models.BooleanField(default=False)
def __str__(self):
return self.alliance_name
@@ -49,7 +34,6 @@ class EveCorporationInfo(models.Model):
corporation_name = models.CharField(max_length=254, unique=True)
corporation_ticker = models.CharField(max_length=254)
member_count = models.IntegerField()
is_blue = models.BooleanField(default=False)
alliance = models.ForeignKey(EveAllianceInfo, blank=True, null=True)
def __str__(self):

2
eveonline/providers.py
View File

@@ -330,9 +330,9 @@ class EveXmlProvider(EveProvider):
self.adapter,
id,
corpinfo['name'],
corpinfo['ticker'],
corpinfo['ceo']['id'],
corpinfo['members']['current'],
corpinfo['ticker'],
corpinfo['alliance']['id'] if corpinfo['alliance'] else None,
)
return model

175
eveonline/tasks.py
View File

@@ -1,123 +1,29 @@
from __future__ import unicode_literals
from django.conf import settings
from celery.task import periodic_task
from django.contrib.auth.models import User
from notifications import notify
from celery import task
from celery.task.schedules import crontab
from authentication.models import AuthServicesInfo
from eveonline.managers import EveManager
from eveonline.models import EveApiKeyPair
from services.managers.eve_api_manager import EveApiManager
from eveonline.models import EveCharacter
from eveonline.models import EveCorporationInfo
from eveonline.models import EveAllianceInfo
from eveonline.providers import eve_adapter_factory, ObjectNotFound
from authentication.tasks import set_state
from eveonline.providers import ObjectNotFound
import logging
import evelink
logger = logging.getLogger(__name__)
@task
def refresh_api(api):
logger.debug('Running update on api key %s' % api.api_id)
still_valid = True
try:
EveApiManager.validate_api(api.api_id, api.api_key, api.user)
# Update characters
characters = EveManager.get_characters_from_api(api)
for c in characters:
try:
EveManager.update_character_obj(c)
except EveCharacter.DoesNotExist:
logger.debug("API key %s has a new character on the account: %s" % (api.api_id, c))
EveManager.create_character_obj(c, api.user, api.api_id)
current_chars = EveCharacter.objects.filter(api_id=api.api_id)
for c in current_chars:
if not int(c.character_id) in [c.id for c in characters]:
logger.info("Character %s no longer found on API ID %s" % (c, api.api_id))
c.delete()
except evelink.api.APIError as e:
logger.warning('Received unexpected APIError (%s) while updating API %s' % (e.code, api.api_id))
except EveApiManager.ApiInvalidError:
logger.debug("API key %s is no longer valid; it and its characters will be deleted." % api.api_id)
notify(api.user, "API Failed Validation", message="Your API key ID %s is no longer valid." % api.api_id,
level="danger")
still_valid = False
except EveApiManager.ApiAccountValidationError:
logger.info(
"Determined api key %s for user %s no longer meets account access requirements." % (api.api_id, api.user))
notify(api.user, "API Failed Validation",
message="Your API key ID %s is no longer account-wide as required." % api.api_id, level="danger")
still_valid = False
except EveApiManager.ApiMaskValidationError as e:
logger.info("Determined api key %s for user %s no longer meets minimum access mask as required." % (
api.api_id, api.user))
notify(api.user, "API Failed Validation",
message="Your API key ID %s no longer meets access mask requirements. Required: %s Got: %s" % (
api.api_id, e.required_mask, e.api_mask), level="danger")
still_valid = False
except EveApiManager.ApiServerUnreachableError as e:
logger.warn("Error updating API %s\n%s" % (api.api_id, str(e)))
finally:
if not still_valid:
EveManager.delete_characters_by_api_id(api.api_id, api.user.id)
EveManager.delete_api_key_pair(api.api_id, api.user.id)
notify(api.user, "API Key Deleted",
message="Your API key ID %s is invalid. It and its associated characters have been deleted." % api.api_id,
level="danger")
def update_corp(corp_id, is_blue=None):
EveManager.update_corporation(corp_id, is_blue=is_blue)
@task
def refresh_user_apis(user):
logger.debug('Refreshing all APIs belonging to user %s' % user)
apis = EveApiKeyPair.objects.filter(user=user)
for x in apis:
refresh_api(x)
# Check our main character
auth = AuthServicesInfo.objects.get(user=user)
if auth.main_char_id:
if EveCharacter.objects.filter(character_id=auth.main_char_id).exists() is False:
logger.info(
"User %s main character id %s missing model. Clearning main character." % (user, auth.main_char_id))
auth.main_char_id = ''
auth.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)
@periodic_task(run_every=crontab(minute=0, hour="*/3"))
def run_api_refresh():
if not EveApiManager.check_if_api_server_online():
logger.warn("Aborted scheduled API key refresh: API server unreachable")
return
for u in User.objects.all():
refresh_user_apis.delay(u)
@task
def update_corp(id, is_blue=None):
EveManager.update_corporation(id, is_blue=is_blue)
@task
def update_alliance(id, is_blue=None):
EveManager.update_alliance(id, is_blue=is_blue)
EveManager.populate_alliance(id)
def update_alliance(alliance_id, is_blue=None):
EveManager.update_alliance(alliance_id, is_blue=is_blue)
EveManager.populate_alliance(alliance_id)
@periodic_task(run_every=crontab(minute=0, hour="*/2"))
def run_corp_update():
if not EveApiManager.check_if_api_server_online():
logger.warn("Aborted updating corp and alliance models: API server unreachable")
return
# generate member corps
for corp_id in settings.STR_CORP_IDS + settings.STR_BLUE_CORP_IDS:
is_blue = True if corp_id in settings.STR_BLUE_CORP_IDS else False
@@ -151,72 +57,3 @@ def run_corp_update():
for alliance in EveAllianceInfo.objects.exclude(
alliance_id__in=settings.STR_ALLIANCE_IDS + settings.STR_BLUE_ALLIANCE_IDS):
update_alliance.delay(alliance.alliance_id)
try:
# create standings
standings = EveApiManager.get_corp_standings()
if standings:
standings = standings[settings.STANDING_LEVEL]
for standing in standings:
if float(standings[standing]['standing']) >= settings.BLUE_STANDING:
logger.debug("Standing %s meets threshold" % standing)
if EveApiManager.check_if_id_is_alliance(standing):
logger.debug("Standing %s is an alliance" % standing)
if EveAllianceInfo.objects.filter(alliance_id=standing).exists():
alliance = EveAllianceInfo.objects.get(alliance_id=standing)
if alliance.is_blue is not True:
logger.info("Updating alliance %s as blue" % alliance)
alliance.is_blue = True
alliance.save()
else:
EveManager.create_alliance(standing, is_blue=True)
elif EveApiManager.check_if_id_is_corp(standing):
logger.debug("Standing %s is a corp" % standing)
if EveCorporationInfo.objects.filter(corporation_id=standing).exists():
corp = EveCorporationInfo.objects.get(corporation_id=standing)
if corp.is_blue is not True:
logger.info("Updating corp %s as blue" % corp)
corp.is_blue = True
corp.save()
else:
logger.info("Creating model for blue corp with id %s" % standing)
EveManager.create_corporation(standing, is_blue=True)
# update alliance standings
for alliance in EveAllianceInfo.objects.filter(is_blue=True):
if int(alliance.alliance_id) in standings:
if float(standings[int(alliance.alliance_id)]['standing']) < float(settings.BLUE_STANDING):
logger.info("Alliance %s no longer meets minimum blue standing threshold" % alliance)
alliance.is_blue = False
alliance.save()
elif alliance.alliance_id not in settings.STR_BLUE_ALLIANCE_IDS:
logger.info("Alliance %s no longer in standings" % alliance)
alliance.is_blue = False
alliance.save()
# update corp standings
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()
elif corp.corporation_id not in settings.STR_BLUE_CORP_IDS:
if corp.alliance:
if not corp.alliance.is_blue:
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()
except evelink.api.APIError as e:
logger.error("Model update failed with error code %s" % e.code)
# delete unnecessary alliance models
EveAllianceInfo.objects.filter(is_blue=False).exclude(alliance_id__in=settings.STR_ALLIANCE_IDS).delete()
# delete unnecessary corp models
EveCorporationInfo.objects.filter(is_blue=False).exclude(corporation_id__in=settings.STR_CORP_IDS).exclude(
alliance__alliance_id__in=settings.STR_ALLIANCE_IDS).delete()

0
eveonline/templatetags/__init__.py
View File

17
eveonline/templatetags/eveonline_extras.py
View File

@@ -1,17 +0,0 @@
from django import template
from django.conf import settings
from django.utils.safestring import mark_safe
register = template.Library()
@register.filter(name='api_link')
def api_link(api, style_class):
if settings.API_KEY_AUDIT_URL:
url = settings.API_KEY_AUDIT_URL.format(api_id=api.api_id, vcode=api.api_key, pk=api.pk)
element = "<a href='{url}' class='{style}' target='_new'>{api_id}</a>".format(url=url, style=style_class,
api_id=api.api_id)
else:
element = "<a href='#' class='{style}' onclick='return prompt({prompt}, {vcode})'>{api_id}</a>".format(
style=style_class, prompt='"Verification Code"', vcode='"%s"' % api.api_key, api_id=api.api_id)
return mark_safe(element)

173
eveonline/views.py
View File

@@ -1,176 +1,3 @@
from __future__ import unicode_literals
from django.shortcuts import render, redirect, get_object_or_404
from django.contrib.auth.decorators import login_required
from django.contrib import messages
from django.utils.translation import ugettext_lazy as _
from eveonline.forms import UpdateKeyForm
from eveonline.managers import EveManager
from authentication.managers import AuthServicesInfoManager
from services.managers.eve_api_manager import EveApiManager
from eveonline.models import EveApiKeyPair, EveCharacter
from authentication.models import AuthServicesInfo
from authentication.tasks import set_state
from eveonline.tasks import refresh_api
from esi.decorators import token_required
from django.conf import settings
import logging
logger = logging.getLogger(__name__)
@login_required
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 %(apiid)s to your account.') % {"apiid": 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)
@login_required
@token_required(new=True)
def api_sso_validate(request, token, api_id):
logger.debug('api_sso_validate called by user %s for api %s' % (request.user, api_id))
api = get_object_or_404(EveApiKeyPair, api_id=api_id)
if api.user and api.user != request.user:
logger.warning('User %s attempting to take ownership of api %s from %s' % (request.user, api_id, api.user))
messages.warning(request, _('API %(apiid)s already claimed by user %(user)s') % {"apiid": api_id, "user": api.user})
return redirect('auth_dashboard')
elif api.sso_verified:
logger.debug('API %s has already been verified.' % api_id)
messages.info(request, _('API %(apiid)s has already been verified') % {"apiid": api_id})
return redirect('auth_dashboard')
logger.debug('API %s has not been verified. Checking if token for %s matches.' % (api_id, token.character_name))
characters = EveApiManager.get_characters_from_api(api.api_id, api.api_key).result
if token.character_id in characters:
api.user = request.user
api.sso_verified = True
api.save()
EveCharacter.objects.filter(character_id__in=characters).update(user=request.user, api_id=api_id)
messages.success(request, _('Confirmed ownership of API %(apiid)s') % {"apiid": api.api_id})
auth = AuthServicesInfo.objects.get(user=request.user)
if not auth.main_char_id:
return redirect('auth_characters')
return redirect('auth_dashboard')
else:
messages.warning(request, _('%(character)s not found on API %(apiid)s. Please SSO as a character on the API.') % {
"character": token.character_name, "apiid": api.api_id})
return render(request, 'registered/apisso.html', context={'api': api})
@login_required
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)
@login_required
def api_key_removal(request, api_id):
logger.debug("api_key_removal called by user %s for api id %s" % (request.user, api_id))
authinfo = AuthServicesInfo.objects.get(user=request.user)
EveManager.delete_api_key_pair(api_id, request.user.id)
EveManager.delete_characters_by_api_id(api_id, request.user.id)
messages.success(request, _('Deleted API key %(apiid)s') % {"apiid": api_id})
logger.info("Succesfully processed api delete request by user %s for api %s" % (request.user, api_id))
if not EveCharacter.objects.filter(character_id=authinfo.main_char_id).exists():
authinfo.main_char_id = None
authinfo.save()
set_state(request.user)
return redirect("auth_dashboard")
@login_required
def characters_view(request):
logger.debug("characters_view called by user %s" % request.user)
render_items = {'characters': EveCharacter.objects.filter(user=request.user),
'authinfo': AuthServicesInfo.objects.get(user=request.user)}
return render(request, 'registered/characters.html', context=render_items)
@login_required
def main_character_change(request, char_id):
logger.debug("main_character_change called by user %s for character id %s" % (request.user, char_id))
if EveCharacter.objects.filter(character_id=char_id).exists() and EveCharacter.objects.get(
character_id=char_id).user == request.user:
AuthServicesInfoManager.update_main_char_id(char_id, request.user)
messages.success(request, _('Changed main character ID to %(charid)s') % {"charid": char_id})
set_state(request.user)
return redirect("auth_dashboard")
messages.error(request, _('Failed to change main character - selected character is not owned by your account.'))
return redirect("auth_characters")
@login_required
def user_refresh_api(request, api_id):
logger.debug("user_refresh_api called by user %s for api id %s" % (request.user, api_id))
if EveApiKeyPair.objects.filter(api_id=api_id).exists():
api_key_pair = EveApiKeyPair.objects.get(api_id=api_id)
if api_key_pair.user == request.user:
refresh_api(api_key_pair)
messages.success(request, _('Refreshed API key %(apiid)s') % {"apiid": api_id})
set_state(request.user)
else:
messages.warning(request, _('You are not authorized to refresh that API key.'))
logger.warn("User %s not authorized to refresh api id %s" % (request.user, api_id))
else:
messages.warning(request, _('Unable to locate API key %(apiid)s') % {"apiid": api_id})
logger.warn("User %s unable to refresh api id %s - api key not found" % (request.user, api_id))
return redirect("auth_dashboard")