Redone correctly , structure, its pretty

eveonline/admin.py

@@ -0,0 +1,3 @@
+from django.contrib import admin
+
+# Register your models here.

eveonline/forms.py

@@ -0,0 +1,6 @@
+from django import forms
+
+
+class UpdateKeyForm(forms.Form):
+    api_id = forms.CharField(max_length=254, required=True)
+    api_key = forms.CharField(max_length=254, required=True)

eveonline/managers.py

@@ -0,0 +1,105 @@
+from models import EveCharacter
+from models import EveApiKeyPair
+from services.managers.eve_api_manager import EveApiManager
+
+
+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):
+
+        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()
+
+    @staticmethod
+    def create_characters_from_list(chars, user, api_id):
+
+        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)
+
+    @staticmethod
+    def create_api_keypair(api_id, api_key, 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()
+
+    @staticmethod
+    def get_api_key_pairs(user_id):
+        if EveApiKeyPair.objects.filter(user=user_id).exists():
+            return EveApiKeyPair.objects.filter(user=user_id)
+
+    @staticmethod
+    def delete_api_key_pair(api_id, user_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:
+                apikeypair.delete()
+
+    @staticmethod
+    def delete_characters_by_api_id(api_id, user_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)
+
+            for char in characters:
+                if char.user.id == user_id:
+                    char.delete()
+
+    @staticmethod
+    def check_if_character_exist(char_name):
+        return EveCharacter.objects.filter(character_name=char_name).exists()
+
+    @staticmethod
+    def get_characters_by_owner_id(user):
+        if EveCharacter.objects.filter(user=user).exists():
+            return EveCharacter.objects.all().filter(user=user)
+
+        return None
+
+    @staticmethod
+    def get_character_by_id(char_id):
+        if EveCharacter.objects.filter(character_id=char_id).exists():
+            return EveCharacter.objects.get(character_id=char_id)
+        
+        return None
+
+    @staticmethod
+    def get_charater_alliance_id_by_id(char_id):
+        if EveCharacter.objects.filter(character_id=char_id).exists():
+            return EveCharacter.objects.get(character_id=char_id).alliance_id
+
+    @staticmethod
+    def check_if_character_owned_by_user(char_id, user):
+        character = EveCharacter.objects.get(character_id=char_id)
+
+        if character.user.id == user.id:
+            return True
+        
+        return False

eveonline/models.py

@@ -0,0 +1,24 @@
+from django.db import models
+from django.contrib import admin
+from django.contrib.auth.models import User
+
+
+class EveCharacter(models.Model):
+    character_id = models.CharField(max_length=254)
+    character_name = models.CharField(max_length=254)
+    corporation_id = models.CharField(max_length=254)
+    corporation_name = models.CharField(max_length=254)
+    corporation_ticker = models.CharField(max_length=254)
+    alliance_id = models.CharField(max_length=254)
+    alliance_name = models.CharField(max_length=254)
+    api_id = models.CharField(max_length=254)
+    user = models.ForeignKey(User)
+
+
+class EveApiKeyPair(models.Model):
+    api_id = models.CharField(max_length=254)
+    api_key = models.CharField(max_length=254)
+    user = models.ForeignKey(User)
+
+admin.site.register(EveCharacter)
+admin.site.register(EveApiKeyPair)

eveonline/tests.py

@@ -0,0 +1,3 @@
+from django.test import TestCase
+
+# Create your tests here.

eveonline/views.py

@@ -0,0 +1,76 @@
+from util import add_member_permission
+from util import remove_member_permission
+from django.conf import settings
+from django.http import HttpResponseRedirect
+from django.shortcuts import render_to_response
+from django.template import RequestContext
+from django.contrib.auth.decorators import login_required
+
+from forms import UpdateKeyForm
+from managers import EveManager
+
+from authentication.managers import AuthServicesInfoManager
+from services.managers.eve_api_manager import EveApiManager
+
+
+@login_required
+def api_key_management_view(request):
+
+    if request.method == 'POST':
+        form = UpdateKeyForm(request.POST)
+
+        if form.is_valid():
+            EveManager.create_api_keypair(form.cleaned_data['api_id'],
+                                          form.cleaned_data['api_key'],
+                                          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, request.user, form.cleaned_data['api_id'])
+            return HttpResponseRedirect("/api_key_management/")
+    else:
+        form = UpdateKeyForm()
+    context = {'form': form, 'apikeypairs': EveManager.get_api_key_pairs(request.user.id)}
+    return render_to_response('registered/apikeymanagment.html', context,
+                              context_instance=RequestContext(request))
+
+
+@login_required
+def api_key_removal(request, api_id):
+    # Check if our users main id is in the to be deleted characters
+    characters = EveManager.get_characters_by_owner_id(request.user.id)
+    if characters is not None:
+        for character in characters:
+            if character.character_id == request.user.main_char_id:
+                # TODO: Remove servies also
+                AuthServicesInfoManager.update_main_char_Id("", request.user.id)
+
+    EveManager.delete_api_key_pair(api_id, request.user.id)
+    EveManager.delete_characters_by_api_id(api_id, request.user.id)
+
+    return HttpResponseRedirect("/api_key_management/")
+
+
+@login_required
+def characters_view(request):
+
+    render_items = {'characters': EveManager.get_characters_by_owner_id(request.user.id),
+                    'authinfo': AuthServicesInfoManager.get_auth_service_info(request.user)}
+    return render_to_response('registered/characters.html', render_items, context_instance=RequestContext(request))
+
+
+@login_required
+def main_character_change(request, char_id):
+
+    if EveManager.check_if_character_owned_by_user(char_id, request.user):
+        AuthServicesInfoManager.update_main_char_Id(char_id, request.user)
+        # Check if character is in the alliance
+        if EveManager.get_charater_alliance_id_by_id(char_id) == settings.ALLIANCE_ID:
+            add_member_permission(request.user, 'alliance_member')
+        else:
+            #TODO: disable serivces
+            remove_member_permission(request.user, 'alliance_member')
+
+        return HttpResponseRedirect("/characters")
+    return HttpResponseRedirect("/characters")