EVE Swagger Interface

Closes #591

Conflicts:
	authentication/views.py
	eveonline/views.py
	stock/templates/public/characternotexisting.html

eveonline/managers.py

@@ -3,71 +3,48 @@ from eveonline.models import EveCharacter
 from eveonline.models import EveApiKeyPair
 from eveonline.models import EveAllianceInfo
 from eveonline.models import EveCorporationInfo
-
+from eveonline.providers import eve_adapter_factory, EveXmlProvider
 from services.managers.eve_api_manager import EveApiManager
 import logging
 
 logger = logging.getLogger(__name__)
 
+adapter = eve_adapter_factory()
 
 class EveManager:
     def __init__(self):
         pass
 
     @staticmethod
-    def create_character(character_id, character_name, corporation_id,
-                         corporation_name, corporation_ticker, alliance_id,
-                         alliance_name, user, api_id):
-        logger.debug("Creating model for character %s id %s" % (character_name, character_id))
-        if not EveCharacter.objects.filter(character_id=character_id).exists():
-            eve_char = EveCharacter()
-            eve_char.character_id = character_id
-            eve_char.character_name = character_name
-            eve_char.corporation_id = corporation_id
-            eve_char.corporation_name = corporation_name
-            eve_char.corporation_ticker = corporation_ticker
-            eve_char.alliance_id = alliance_id
-            eve_char.alliance_name = alliance_name
-            eve_char.user = user
-            eve_char.api_id = api_id
-            eve_char.save()
-            logger.info("Created new character model %s for user %s" % (eve_char, user))
-        else:
-            logger.warn("Attempting to create existing character model with id %s" % character_id)
+    def create_character(id, user, api_id):
+        return EveManager.create_character_obj(adapter.get_character(id), user, api_id)
 
     @staticmethod
-    def create_characters_from_list(chars, user, api_id):
-        logger.debug("Creating characters from batch: %s" % chars.result)
-        for char in chars.result:
-            if not EveManager.check_if_character_exist(chars.result[char]['name']):
-                EveManager.create_character(chars.result[char]['id'],
-                                            chars.result[char]['name'],
-                                            chars.result[char]['corp']['id'],
-                                            chars.result[char]['corp']['name'],
-                                            EveApiManager.get_corporation_ticker_from_id(
-                                                chars.result[char]['corp']['id']),
-                                            chars.result[char]['alliance']['id'],
-                                            chars.result[char]['alliance']['name'],
-                                            user, api_id)
+    def create_character_obj(character, user, api_id):
+        EveCharacter.objects.create(
+            character_id = character.id,
+            character_name = character.name,
+            corporation_id = character.corp.id,
+            corporation_name = character.corp.name,
+            alliance_id = character.alliance.id,
+            alliance_name = character.alliance.name,
+            user = user,
+            api_id = api_id,
+        )
 
     @staticmethod
-    def update_characters_from_list(chars):
-        logger.debug("Updating characters from list: %s" % chars.result)
-        for char in chars.result:
-            if EveManager.check_if_character_exist(chars.result[char]['name']):
-                eve_char = EveManager.get_character_by_character_name(chars.result[char]['name'])
-                logger.debug("Got existing character model %s" % eve_char)
-                eve_char.corporation_id = chars.result[char]['corp']['id']
-                eve_char.corporation_name = chars.result[char]['corp']['name']
-                eve_char.corporation_ticker = EveApiManager.get_corporation_ticker_from_id(
-                    chars.result[char]['corp']['id'])
-                eve_char.alliance_id = chars.result[char]['alliance']['id']
-                eve_char.alliance_name = chars.result[char]['alliance']['name']
-                eve_char.save()
-                logger.info("Updated character model %s" % eve_char)
-            else:
-                logger.warn(
-                    "Attempting to update non-existing character model with name %s" % chars.result[char]['name'])
+    def update_character(id):
+        return EveManager.update_character_obj(adapter.get_character(id))
+
+    @staticmethod
+    def update_character_obj(char):
+        model = EveCharacter.objects.get(character_id=char.id)
+        model.character_name = char.name
+        model.corporation_id = char.corp.id
+        model.corporation_name = char.corp.name
+        model.alliance_id = char.alliance.id
+        model.alliance_name = char.alliance.name
+        model.save()
 
     @staticmethod
     def create_api_keypair(api_id, api_key, user_id):
@@ -83,64 +60,80 @@ class EveManager:
             logger.warn("Attempting to create existing api keypair with id %s" % api_id)
 
     @staticmethod
-    def create_alliance_info(alliance_id, alliance_name, alliance_ticker, alliance_executor_corp_id,
-                             alliance_member_count, is_blue):
-        logger.debug("Creating alliance info for alliance %s id %s" % (alliance_name, alliance_id))
-        if not EveManager.check_if_alliance_exists_by_id(alliance_id):
-            alliance_info = EveAllianceInfo()
-            alliance_info.alliance_id = alliance_id
-            alliance_info.alliance_name = alliance_name
-            alliance_info.alliance_ticker = alliance_ticker
-            alliance_info.executor_corp_id = alliance_executor_corp_id
-            alliance_info.member_count = alliance_member_count
-            alliance_info.is_blue = is_blue
-            alliance_info.save()
-            logger.info("Created alliance model for %s" % alliance_info)
-        else:
-            logger.warn("Attempting to create existing alliance model with id %s" % alliance_id)
+    def create_alliance(id, is_blue=False):
+        return EveManager.create_alliance_obj(adapter.get_alliance(id), is_blue=is_blue)
 
     @staticmethod
-    def update_alliance_info(alliance_id, alliance_executor_corp_id, alliance_member_count, is_blue):
-        logger.debug("Updating alliance model with id %s" % alliance_id)
-        if EveManager.check_if_alliance_exists_by_id(alliance_id):
-            alliance_info = EveAllianceInfo.objects.get(alliance_id=alliance_id)
-            alliance_info.executor_corp_id = alliance_executor_corp_id
-            alliance_info.member_count = alliance_member_count
-            alliance_info.is_blue = is_blue
-            alliance_info.save()
-            logger.debug("Updated alliance model %s" % alliance_info)
-        else:
-            logger.warn("Attempting to update non-existing alliance model with id %s" % alliance_id)
+    def create_alliance_obj(alliance, is_blue=False):
+        EveAllianceInfo.objects.create(
+            alliance_id = alliance.id,
+            alliance_name = alliance.name,
+            alliance_ticker = alliance.ticker,
+            executor_corp_id = alliance.executor_corp_id,
+            is_blue = is_blue,
+        )
 
     @staticmethod
-    def create_corporation_info(corp_id, corp_name, corp_ticker, corp_member_count, is_blue, alliance):
-        logger.debug("Creating corp info for corp %s id %s" % (corp_name, corp_id))
-        if not EveManager.check_if_corporation_exists_by_id(corp_id):
-            corp_info = EveCorporationInfo()
-            corp_info.corporation_id = corp_id
-            corp_info.corporation_name = corp_name
-            corp_info.corporation_ticker = corp_ticker
-            corp_info.member_count = corp_member_count
-            corp_info.is_blue = is_blue
-            if alliance:
-                corp_info.alliance = alliance
-            corp_info.save()
-            logger.info("Created corp model for %s" % corp_info)
-        else:
-            logger.warn("Attempting to create existing corp model with id %s" % corp_id)
+    def update_alliance(id, is_blue=None):
+        return EveManager.update_alliance_obj(adapter.get_alliance(id), is_blue=is_blue)
 
     @staticmethod
-    def update_corporation_info(corp_id, corp_member_count, alliance, is_blue):
-        logger.debug("Updating corp model with id %s" % corp_id)
-        if EveManager.check_if_corporation_exists_by_id(corp_id):
-            corp_info = EveCorporationInfo.objects.get(corporation_id=corp_id)
-            corp_info.member_count = corp_member_count
-            corp_info.alliance = alliance
-            corp_info.is_blue = is_blue
-            corp_info.save()
-            logger.debug("Updated corp model %s" % corp_info)
-        else:
-            logger.warn("Attempting to update non-existant corp model with id %s" % corp_id)
+    def update_alliance_obj(alliance, is_blue=None):
+        model = EveAllianceInfo.objects.get(alliance_id=alliance.id)
+        model.executor_corp_id = alliance.executor_corp_id
+        model.is_blue = model.is_blue if is_blue == None else is_blue
+        model.save()
+
+    @staticmethod
+    def populate_alliance(id):
+        alliance_model = EveAllianceInfo.objects.get(alliance_id=id)
+        alliance = adapter.get_alliance(id)
+        for corp_id in alliance.corp_ids:
+            if not EveCorporationInfo.objects.filter(corporation_id=corp_id).exists():
+               EveManager.create_corporation(corp_id, is_blue=alliance_model.is_blue)
+        EveCorporationInfo.objects.filter(corporation_id__in=alliance.corp_ids).update(alliance=alliance_model)
+        EveCorporationInfo.objects.filter(alliance=alliance_model).exclude(corporation_id__in=alliance.corp_ids).update(alliance=None)
+            
+
+    @staticmethod
+    def create_corporation(id, is_blue=False):
+        return EveManager.create_corporation_obj(adapter.get_corp(id), is_blue=is_blue)
+
+    @staticmethod
+    def create_corporation_obj(corp, is_blue=False):
+        try:
+            alliance = EveAllianceInfo.objects.get(alliance_id=corp.alliance_id)
+        except EveAllianceInfo.DoesNotExist:
+            alliance = None
+        EveCorporationInfo.objects.create(
+            corporation_id = corp.id,
+            corporation_name = corp.name,
+            corporation_ticker = corp.ticker,
+            member_count = corp.members,
+            alliance = alliance,
+            is_blue = is_blue,
+        )
+
+    @staticmethod
+    def update_corporation(id, is_blue=None):
+        return EveManager.update_corporation_obj(adapter.get_corp(id), is_blue=is_blue)
+
+    @staticmethod
+    def update_corporation_obj(corp, is_blue=None):
+        model = EveCorporationInfo.objects.get(corporation_id=corp.id)
+        model.member_count = corp.members
+        try:
+            model.alliance = EveAllianceInfo.objects.get(alliance_id=corp.alliance_id)
+        except EveAllianceInfo.DoesNotExist:
+            model.alliance = None
+        model.is_blue = model.is_blue if is_blue == None else is_blue
+        model.save()
+
+    @staticmethod
+    def get_characters_from_api(api):
+        char_result = EveApiManager.get_characters_from_api(api.api_id, api.api_key).result
+        provider = EveXmlProvider(adapter=adapter)
+        return [provider._build_character(result) for id, result in char_result.items()]
 
     @staticmethod
     def get_api_key_pairs(user):

eveonline/migrations/0005_remove_eveallianceinfo_member_count.py

@@ -0,0 +1,19 @@
+# -*- coding: utf-8 -*-
+# Generated by Django 1.10.1 on 2016-12-16 23:22
+from __future__ import unicode_literals
+
+from django.db import migrations
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('eveonline', '0004_eveapikeypair_sso_verified'),
+    ]
+
+    operations = [
+        migrations.RemoveField(
+            model_name='eveallianceinfo',
+            name='member_count',
+        ),
+    ]

eveonline/models.py

@@ -38,7 +38,6 @@ class EveAllianceInfo(models.Model):
     alliance_ticker = models.CharField(max_length=254)
     executor_corp_id = models.CharField(max_length=254)
     is_blue = models.BooleanField(default=False)
-    member_count = models.IntegerField()
 
     def __str__(self):
         return self.alliance_name

eveonline/providers.py

@@ -0,0 +1,279 @@
+from django.utils.encoding import python_2_unicode_compatible
+from esi.clients import esi_client_factory
+from django.conf import settings
+from bravado.exception import HTTPNotFound, HTTPUnprocessableEntity
+import evelink
+
+@python_2_unicode_compatible
+class ObjectNotFound(Exception):
+    def __init__(self, id, type):
+        self.id = id
+        self.type = type
+
+    def __str__(self):
+        return '%s with ID %s not found.' % (self.type, self.id)
+
+
+@python_2_unicode_compatible
+class Entity(object):
+    def __init__(self, id, name):
+        self.id = id
+        self.name = name
+
+    def __str__(self):
+        return self.name
+
+    def __repr__(self):
+        return "<{} ({}): {}>".format(self.__class__.__name__, self.id, self.name)
+
+    def __bool__(self):
+        return bool(self.id)
+
+    def __eq__(self, other):
+        return self.id == other.id
+
+
+class Corporation(Entity):
+    def __init__(self, provider, id, name, ticker, ceo_id, members, alliance_id):
+        super(Corporation, self).__init__(id, name)
+        self.provider = provider
+        self.ticker = ticker
+        self.ceo_id = ceo_id
+        self.members = members
+        self.alliance_id = alliance_id
+
+    @property
+    def alliance(self):
+        if self.alliance_id:
+            return self.provider.get_alliance(self.alliance_id)
+        return Entity(None, None)
+
+    @property
+    def ceo(self):
+        return self.provider.get_character(self.ceo_id)
+
+
+class Alliance(Entity):
+    def __init__(self, provider, id, name, ticker, corp_ids, executor_corp_id):
+        super(Alliance, self).__init__(id, name)
+        self.provider = provider
+        self.ticker = ticker
+        self.corp_ids = corp_ids
+        self.executor_corp_id = executor_corp_id
+
+    def corp(self, id):
+        assert id in self.corp_ids
+        return self.provider.get_corp(id)
+
+    @property
+    def corps(self):
+        return sorted([self.corp(id) for id in self.corp_ids], key=lambda x: x.name)
+
+    @property
+    def executor_corp(self):
+        return self.provider.get_corp(self.executor_corp_id)
+
+
+class Character(Entity):
+    def __init__(self, provider, id, name, corp_id, alliance_id):
+        super(Character, self).__init__(id, name)
+        self.provider = provider
+        self.corp_id = corp_id
+        self.alliance_id = alliance_id
+
+    @property
+    def corp(self):
+        return self.provider.get_corp(self.corp_id)
+
+    @property
+    def alliance(self):
+        if self.alliance_id:
+            return self.provider.get_alliance(self.alliance_id)
+        return Entity(None, None)
+
+
+class EveProvider:
+    def get_alliance(self, alliance_id):
+        """
+        :return: an Alliance object for the given ID
+        """
+        raise NotImplementedError()
+
+    def get_corp(self, corp_id):
+        """
+        :return: a Corporation object for the given ID
+        """
+        raise NotImplementedError()
+
+    def get_character(self, corp_id):
+        """
+        :return: a Character object for the given ID
+        """
+        raise NotImplementedError()
+
+
+@python_2_unicode_compatible
+class EveSwaggerProvider(EveProvider):
+    def __init__(self, token=None, adapter=None):
+        self.client = esi_client_factory(token=token)
+        self.adapter = adapter or self
+
+    def __str__(self):
+        return 'esi'
+
+    def get_alliance(self, id):
+        try:
+            data = self.client.Alliance.get_alliances_alliance_id(alliance_id=id).result()
+            corps = self.client.Alliance.get_alliances_alliance_id_corporations(alliance_id=id).result()
+            model = Alliance(
+                self.adapter,
+                id,
+                data['alliance_name'],
+                data['ticker'],
+                corps,
+                data['executor_corp'],
+            )
+            return model
+        except HTTPNotFound:
+            raise ObjectNotFound(id, 'alliance')
+
+    def get_corp(self, id):
+        try:
+            data = self.client.Corporation.get_corporations_corporation_id(corporation_id=id).result()
+            model = Corporation(
+                self.adapter,
+                id,
+                data['corporation_name'],
+                data['ticker'],
+                data['ceo_id'],
+                data['member_count'],
+                data['alliance_id'] if 'alliance_id' in data else None,
+            )
+            return model
+        except HTTPNotFound:
+            raise ObjectNotFound(id, 'corporation')
+
+    def get_character(self, id):
+        try:
+            data = self.client.Character.get_characters_character_id(character_id=id).result()
+            alliance_id = self.adapter.get_corp(data['corporation_id']).alliance_id
+            model = Character(
+                self.adapter,
+                id,
+                data['name'],
+                data['corporation_id'],
+                alliance_id,
+            )
+            return model
+        except (HTTPNotFound, HTTPUnprocessableEntity):
+            raise ObjectNotFound(id, 'character')
+
+
+@python_2_unicode_compatible
+class EveXmlProvider(EveProvider):
+    def __init__(self, api_key=None, adapter=None):
+        """
+        :param api_key: eveonline.EveApiKeyPair
+        """
+        self.api = evelink.api.API(api_key=(api_key.api_id, api_key.api_key)) if api_key else evelink.api.API()
+        self.adapter = adapter or self
+
+    def __str__(self):
+        return 'xml'
+
+    def get_alliance(self, id):
+        api = evelink.eve.EVE(api=self.api)
+        alliances = api.alliances().result
+        try:
+            results = alliances[int(id)]
+        except KeyError:
+            raise ObjectNotFound(id, 'alliance')
+        model = Alliance(
+            self.adapter,
+            id,
+            results['name'],
+            results['ticker'],
+            results['member_corps'],
+            results['executor_id'],
+        )
+        return model
+
+    def get_corp(self, id):
+        api = evelink.corp.Corp(api=self.api)
+        try:
+            corpinfo = api.corporation_sheet(corp_id=int(id)).result
+        except evelink.api.APIError as e:
+            if int(e.code) == 523:
+                raise ObjectNotFound(id, 'corporation')
+            raise e
+        model = Corporation(
+            self.adapter,
+            id,
+            corpinfo['name'],
+            corpinfo['ceo']['id'],
+            corpinfo['members']['current'],
+            corpinfo['ticker'],
+            corpinfo['alliance']['id'] if corpinfo['alliance'] else None,
+        )
+        return model
+
+    def _build_character(self, result):
+        return Character(
+            self.adapter,
+            result['id'],
+            result['name'],
+            result['corp']['id'],
+            result['alliance']['id'],
+        )
+
+    def get_character(self, id):
+        api = evelink.eve.EVE(api=self.api)
+        try:
+            charinfo = api.character_info_from_id(id).result
+        except evelink.api.APIError as e:
+            if int(e.code) == 105:
+                raise ObjectNotFound(id, 'character')
+            raise e
+        return self._build_character(charinfo)
+
+
+class EveAdapter(EveProvider):
+    """
+    Redirects queries to appropriate data source.
+    """
+    def __init__(self, char_provider, corp_provider, alliance_provider):
+        self.char_provider = char_provider
+        self.corp_provider = corp_provider
+        self.alliance_provider = alliance_provider
+        self.char_provider.adapter = self
+        self.corp_provider.adapter = self
+        self.alliance_provider.adapter = self
+
+    def __repr__(self):
+        return "<{} (char:{}, corp:{}, alliance:{})>".format(self.__class__.__name__, str(self.char_provider), str(self.corp_provider), str(self.alliance_provider))
+
+    def get_character(self, id):
+        return self.char_provider.get_character(id)
+
+    def get_corp(self, id):
+        return self.corp_provider.get_corp(id)
+
+    def get_alliance(self, id):
+        return self.alliance_provider.get_alliance(id)
+
+
+def eve_adapter_factory(character_source=settings.EVEONLINE_CHARACTER_PROVIDER, corp_source=settings.EVEONLINE_CORP_PROVIDER, alliance_source=settings.EVEONLINE_ALLIANCE_PROVIDER, api_key=None, token=None):
+    sources = [character_source, corp_source, alliance_source]
+    providers = []
+
+    xml = EveXmlProvider(api_key=api_key)
+    esi = EveSwaggerProvider(token=token)
+
+    for source in sources:
+        if source == 'xml':
+            providers.append(xml)
+        elif source == 'esi':
+            providers.append(esi)
+        else:
+            raise ValueError('Unrecognized data source "%s"' % source)
+    return EveAdapter(providers[0], providers[1], providers[2])

eveonline/tasks.py

@@ -12,6 +12,7 @@ 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
 from authentication.tasks import set_state
 import logging
 import evelink
@@ -26,21 +27,16 @@ def refresh_api(api):
     try:
         EveApiManager.validate_api(api.api_id, api.api_key, api.user)
         # Update characters
-        characters = EveApiManager.get_characters_from_api(api.api_id, api.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']):
-                logger.debug(
-                    "API key %s has a new character on the account: %s" % (api.api_id, characters.result[char]['name']))
-                new_character = True
-        if new_character:
-            logger.debug("Creating new character %s from api key %s" % (characters.result[char]['name'], api.api_id))
-            EveManager.create_characters_from_list(characters, api.user, api.api_id)
+        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 characters.result:
+            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:
@@ -105,65 +101,14 @@ def run_api_refresh():
         refresh_user_apis.delay(u)
 
 
-def populate_alliance(id, blue=False):
-    logger.debug("Populating alliance model with id %s blue %s" % (id, blue))
-    alliance_info = EveApiManager.get_alliance_information(id)
-
-    if not alliance_info:
-        raise ValueError("Supplied alliance id %s is invalid" % id)
-
-    if not EveAllianceInfo.objects.filter(alliance_id=id).exists():
-        EveManager.create_alliance_info(alliance_info['id'], alliance_info['name'], alliance_info['ticker'],
-                                        alliance_info['executor_id'], alliance_info['member_count'], blue)
-    alliance = EveAllianceInfo.objects.get(alliance_id=id)
-    for member_corp in alliance_info['member_corps']:
-        if EveCorporationInfo.objects.filter(corporation_id=member_corp).exists():
-            corp = EveCorporationInfo.objects.get(corporation_id=member_corp)
-            if corp.alliance != alliance:
-                corp.alliance = alliance
-                corp.save()
-        else:
-            logger.info("Creating new alliance member corp id %s" % member_corp)
-            corpinfo = EveApiManager.get_corporation_information(member_corp)
-            EveManager.create_corporation_info(corpinfo['id'], corpinfo['name'], corpinfo['ticker'],
-                                               corpinfo['members']['current'], blue, alliance)
-
+@task
+def update_corp(id):
+    EveManager.update_corporation(id)
 
 @task
 def update_alliance(id):
-    alliance = EveAllianceInfo.objects.get(alliance_id=id)
-    corps = EveCorporationInfo.objects.filter(alliance=alliance)
-    logger.debug("Updating alliance %s with %s member corps" % (alliance, len(corps)))
-    allianceinfo = EveApiManager.get_alliance_information(alliance.alliance_id)
-    if allianceinfo:
-        EveManager.update_alliance_info(allianceinfo['id'], allianceinfo['executor_id'],
-                                        allianceinfo['member_count'], alliance.is_blue)
-        for corp in corps:
-            if corp.corporation_id in allianceinfo['member_corps'] is False:
-                logger.info("Corp %s no longer in alliance %s" % (corp, alliance))
-                corp.alliance = None
-                corp.save()
-        populate_alliance(alliance.alliance_id, blue=alliance.is_blue)
-    elif EveApiManager.check_if_alliance_exists(alliance.alliance_id) is False:
-        logger.info("Alliance %s has closed. Deleting model" % alliance)
-        alliance.delete()
-
-
-@task
-def update_corp(id):
-    corp = EveCorporationInfo.objects.get(corporation_id=id)
-    logger.debug("Updating corp %s" % corp)
-    corpinfo = EveApiManager.get_corporation_information(corp.corporation_id)
-    if corpinfo:
-        alliance = None
-        if EveAllianceInfo.objects.filter(alliance_id=corpinfo['alliance']['id']).exists():
-            alliance = EveAllianceInfo.objects.get(alliance_id=corpinfo['alliance']['id'])
-        EveManager.update_corporation_info(corpinfo['id'], corpinfo['members']['current'], alliance, corp.is_blue)
-    elif EveApiManager.check_if_corp_exists(corp.corporation_id) is False:
-        logger.info("Corp %s has closed. Deleting model" % corp)
-        corp.delete()
-
-        # Run Every 2 hours
+    EveManager.update_alliance(id)
+    EveManager.populate_alliance(id)
 
 
 @periodic_task(run_every=crontab(minute=0, hour="*/2"))
@@ -172,80 +117,36 @@ def run_corp_update():
         logger.warn("Aborted updating corp and alliance models: API server unreachable")
         return
     standing_level = 'alliance'
+    alliance_id = settings.ALLIANCE_ID
+
+    # get corp info for owning corp if required
+    if settings.IS_CORP:
+        standing_level = 'corp'
+        if EveCorporationInfo.objects.filter(corporation_id=settings.CORP_ID).exists():
+            update_corp(settings.CORP_ID)
+        else:
+            EveManager.create_corporation(settings.CORP_ID)
+        
+        alliance_id = eve_adapter_factory().get_corp(settings.CORP_ID).alliance_id
+
+    # get and create alliance info for owning alliance if required
+    if alliance_id:
+        if EveAllianceInfo.objects.filter(alliance_id=alliance_id).exists():
+            logger.debug("Updating existing owner alliance model with id %s" % alliance_id)
+            update_alliance(alliance_id)
+        else:
+            EveManager.create_alliance(id)
+            EveManager.populate_alliance(id)
+
+    # update existing corp models
+    for corp in EveCorporationInfo.objects.all():
+        update_corp.delay(corp.corporation_id)
+
+    # update existing alliance models
+    for alliance in EveAllianceInfo.objects.all():
+        update_alliance.delay(alliance.alliance_id)
+
     try:
-        # get corp info for owning corp if required
-        ownercorpinfo = {}
-        if settings.IS_CORP:
-            standing_level = 'corp'
-            logger.debug("Getting information for owning corp with id %s" % settings.CORP_ID)
-            ownercorpinfo = EveApiManager.get_corporation_information(settings.CORP_ID)
-            if not ownercorpinfo:
-                logger.error("Failed to retrieve corp info for owning corp id %s - bad corp id?" % settings.CORP_ID)
-                return
-
-        # check if we need to update an alliance model
-        alliance_id = ''
-        if ownercorpinfo and ownercorpinfo['alliance']['id']:
-            alliance_id = ownercorpinfo['alliance']['id']
-        elif settings.IS_CORP is False:
-            alliance_id = settings.ALLIANCE_ID
-
-        # get and create alliance info for owning alliance if required
-        alliance = None
-        if alliance_id:
-            logger.debug("Getting information for owning alliance with id %s" % alliance_id)
-            ownerallianceinfo = EveApiManager.get_alliance_information(alliance_id)
-            if not ownerallianceinfo:
-                logger.error("Failed to retrieve corp info for owning alliance id %s - bad alliance id?" % alliance_id)
-                return
-            if EveAllianceInfo.objects.filter(alliance_id=ownerallianceinfo['id']).exists():
-                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)
-            else:
-                populate_alliance(alliance_id)
-                alliance = EveAllianceInfo.objects.get(alliance_id=alliance_id)
-
-        # create corp info for owning corp if required
-        if ownercorpinfo:
-            if EveCorporationInfo.objects.filter(corporation_id=ownercorpinfo['id']).exists():
-                logger.debug("Updating existing owner corp model with id %s" % ownercorpinfo['id'])
-                EveManager.update_corporation_info(ownercorpinfo['id'], ownercorpinfo['members']['current'], alliance,
-                                                   False)
-            else:
-                logger.info("Creating model for owning corp with id %s" % ownercorpinfo['id'])
-                EveManager.create_corporation_info(ownercorpinfo['id'], ownercorpinfo['name'], ownercorpinfo['ticker'],
-                                                   ownercorpinfo['members']['current'], False, alliance)
-
-        # validate and create corp models for member corps of owning alliance
-        if alliance:
-            current_corps = EveCorporationInfo.objects.filter(alliance=alliance)
-            for corp in current_corps:
-                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))
-                    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()
-                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)
-
-        # update existing corp models
-        for corp in EveCorporationInfo.objects.all():
-            update_corp.delay(corp.corporation_id)
-
-        # update existing alliance models
-        for alliance in EveAllianceInfo.objects.all():
-            update_alliance.delay(alliance.alliance_id)
-
         # create standings
         standings = EveApiManager.get_corp_standings()
         if standings:
@@ -262,7 +163,7 @@ def run_corp_update():
                                 alliance.is_blue = True
                                 alliance.save()
                         else:
-                            populate_alliance(standing, blue=True)
+                            EveManager.create_alliance(standing, 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():
@@ -273,13 +174,7 @@ def run_corp_update():
                                 corp.save()
                         else:
                             logger.info("Creating model for blue corp with id %s" % standing)
-                            corpinfo = EveApiManager.get_corporation_information(standing)
-                            corp_alliance = None
-                            if EveAllianceInfo.objects.filter(alliance_id=corpinfo['alliance']['id']).exists():
-                                logger.debug("New corp model for standing %s has existing alliance model" % standing)
-                                corp_alliance = EveAllianceInfo.objects.get(alliance_id=corpinfo['alliance']['id'])
-                            EveManager.create_corporation_info(corpinfo['id'], corpinfo['name'], corpinfo['ticker'],
-                                                               corpinfo['members']['current'], True, corp_alliance)
+                            EveManager.create_corporation(standing, blue=True)
 
         # update alliance standings
         for alliance in EveAllianceInfo.objects.filter(is_blue=True):
@@ -310,43 +205,43 @@ def run_corp_update():
                     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
-        for alliance in EveAllianceInfo.objects.filter(is_blue=False):
-            logger.debug("Checking to delete alliance %s" % alliance)
-            if not settings.IS_CORP:
-                if not alliance.alliance_id == settings.ALLIANCE_ID:
-                    logger.info("Deleting unnecessary alliance model %s" % alliance)
-                    alliance.delete()
+    # delete unnecessary alliance models
+    for alliance in EveAllianceInfo.objects.filter(is_blue=False):
+        logger.debug("Checking to delete alliance %s" % alliance)
+        if not settings.IS_CORP:
+            if not alliance.alliance_id == settings.ALLIANCE_ID:
+                logger.info("Deleting unnecessary alliance model %s" % alliance)
+                alliance.delete()
+        else:
+            if not alliance.evecorporationinfo_set.filter(corporation_id=settings.CORP_ID).exists():
+                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 not settings.IS_CORP:
+            if corp.alliance:
+                logger.debug("Corp %s has alliance %s" % (corp, corp.alliance))
+                if not corp.alliance.alliance_id == settings.ALLIANCE_ID:
+                    logger.info("Deleting unnecessary corp model %s" % corp)
+                    corp.delete()
             else:
-                if not alliance.evecorporationinfo_set.filter(corporation_id=settings.CORP_ID).exists():
-                    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 not settings.IS_CORP:
+                logger.info("Deleting unnecessary corp model %s" % corp)
+                corp.delete()
+        else:
+            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 not corp.alliance.alliance_id == settings.ALLIANCE_ID:
+                    if not corp.alliance.evecorporationinfo_set.filter(corporation_id=settings.CORP_ID).exists():
                         logger.info("Deleting unnecessary corp model %s" % corp)
                         corp.delete()
                 else:
                     logger.info("Deleting unnecessary corp model %s" % corp)
                     corp.delete()
             else:
-                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 not corp.alliance.evecorporationinfo_set.filter(corporation_id=settings.CORP_ID).exists():
-                            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)
+                logger.debug("Corp %s is owning corp" % corp)

eveonline/views.py

@@ -12,7 +12,7 @@ from authentication.models import AuthServicesInfo
 from authentication.tasks import set_state
 from eveonline.tasks import refresh_api
 
-from eve_sso.decorators import token_required
+from esi.decorators import token_required
 from django.conf import settings
 import logging
 
@@ -46,9 +46,8 @@ def add_api_key(request):
                 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'])
+            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'])
@@ -70,7 +69,7 @@ def add_api_key(request):
 
 @login_required
 @token_required(new=True)
-def api_sso_validate(request, tokens, api_id):
+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:
@@ -81,7 +80,6 @@ def api_sso_validate(request, tokens, api_id):
         logger.debug('API %s has already been verified.' % api_id)
         messages.info(request, 'API %s has already been verified' % api_id)
         return redirect('auth_dashboard')
-    token = tokens[0]
     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: